# 05.5 个人知识体系

## 核心问题

> 如何建立可持续的个人AI工具箱？
> 什么样的文档策略能有效支持长期学习？
> 如何通过社区参与加速成长？

---

## 概念讲解

### 个人知识体系的结构

一个有效的个人知识体系应该是有机的、可演进的：

```
个人知识体系结构

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  第一层：知识获取层 (Acquisition)                           │
│  ──────────────────────────────────────────────────────    │
│     • 信息源管理（RSS、通讯、期刊）                          │
│     • 学习计划（短期、中期、长期）                           │
│     • 时间分配（阅读、实践、反思）                           │
│                                                             │
│  第二层：知识处理层 (Processing)                            │
│  ──────────────────────────────────────────────────────    │
│     • 笔记系统（捕获、整理、归档）                            │
│     • 知识连接（建立概念间的关系）                           │
│     • 代码片段库（可复用的代码片段）                         │
│                                                             │
│  第三层：知识应用层 (Application)                           │
│  ──────────────────────────────────────────────────────    │
│     • 项目实践（真实问题应用）                               │
│     • 工具箱（积累的AI工具和工作流）                         │
│     • 模板库（常用分析模板）                                 │
│                                                             │
│  第四层：知识分享层 (Sharing)                               │
│  ──────────────────────────────────────────────────────    │
│     • 写作（博客、论文、文档）                               │
│     • 演讲（会议、工作坊）                                   │
│     • 开源（贡献代码和工具）                                 │
│                                                             │
│  第五层：知识反思层 (Reflection)                            │
│  ──────────────────────────────────────────────────────    │
│     • 定期回顾（月度、年度）                                 │
│     • 知识审计（识别盲区和过时知识）                         │
│     • 体系优化（持续改进知识系统）                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

关键特征：
• 开放性：可以不断添加和更新
• 连接性：知识之间相互关联
• 可检索性：快速找到所需信息
• 可维护性：低成本的维护和更新
```

### AI工具箱的构成

```
个人AI工具箱

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  1. 基础工具集                                             │
│     ───────────────────────────────────────────────────    │
│     • 通用AI助手（Claude, ChatGPT）                         │
│     • 代码助手（GitHub Copilot）                            │
│     • 图像生成（Midjourney, DALL-E）                        │
│                                                             │
│  2. 专业工具集                                             │
│     ───────────────────────────────────────────────────    │
│     • 空间分析AI（遥感解译、地理NLP）                        │
│     • 数据处理AI（数据清洗、转换）                           │
│     • 可视化AI（自动图表、地图生成）                         │
│                                                             │
│  3. 自定义工具集                                           │
│     ───────────────────────────────────────────────────    │
│     • 自定义Skills（Prompt集合）                             │
│     • 专用工作流（针对特定任务）                             │
│     • 集成系统（API整合）                                    │
│                                                             │
│  4. 辅助资源集                                             │
│     ───────────────────────────────────────────────────    │
│     • Prompt模板库                                          │
│     • 示例案例集                                            │
│     • 最佳实践文档                                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 文档化策略

```
有效的文档化

金字塔模型：

           ┌──────────────┐
           │   即时笔记   │  ← 捕获想法，最小开销
           └──────┬───────┘
                  │
           ┌──────┴───────┐
           │   项目笔记   │  ← 项目上下文，详细记录
           └──────┬───────┘
                  │
           ┌──────┴───────┐
           │   知识笔记   │  ← 提炼知识，建立连接
           └──────┬───────┘
                  │
           ┌──────┴───────┐
           │   指南文档   │  ← 结构化输出，可分享
           └──────────────┘

不同文档的特点：

即时笔记:
• 快速捕获
• 原始想法
• 待整理

项目笔记:
• 项目特定
• 决策记录
• 问题解决

知识笔记:
• 跨项目
• 概念理解
• 最佳实践

指南文档:
• 面向读者
• 结构完整
• 可独立使用
```

---

## 设计原理

### 知识管理系统实现

```python
"""
个人知识管理系统
"""
from typing import Dict, List, Set, Optional, Any
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
import json
from enum import Enum

class NoteType(Enum):
    """笔记类型"""
    QUICK = "quick"           # 即时笔记
    PROJECT = "project"       # 项目笔记
    KNOWLEDGE = "knowledge"   # 知识笔记
    GUIDE = "guide"          # 指南文档

class Tag(Enum):
    """常用标签分类"""
    SKILL = "skill"
    CONCEPT = "concept"
    TOOL = "tool"
    WORKFLOW = "workflow"
    PROBLEM = "problem"
    SOLUTION = "solution"
    REFERENCE = "reference"

@dataclass
class Note:
    """知识条目"""
    id: str
    title: str
    content: str
    note_type: NoteType
    tags: Set[str] = field(default_factory=set)
    created: str = ""
    modified: str = ""
    related_notes: Set[str] = field(default_factory=set)
    metadata: Dict = field(default_factory=dict)

    def __post_init__(self):
        if not self.created:
            self.created = datetime.now().isoformat()
        self.modified = self.created

@dataclass
class CodeSnippet:
    """代码片段"""
    id: str
    name: str
    description: str
    code: str
    language: str
    tags: Set[str] = field(default_factory=set)
    dependencies: List[str] = field(default_factory=list)
    created: str = ""

    def __post_init__(self):
        if not self.created:
            self.created = datetime.now().isoformat()

@dataclass
class ToolEntry:
    """工具条目"""
    name: str
    category: str
    url: str
    description: str
    use_cases: List[str]
    pros: List[str]
    cons: List[str]
    last_used: str = ""
    proficiency: str = "beginner"  # beginner, intermediate, advanced

class PersonalKnowledgeSystem:
    """个人知识系统"""

    def __init__(self, base_path: str):
        self.base_path = Path(base_path)
        self.notes: Dict[str, Note] = {}
        self.snippets: Dict[str, CodeSnippet] = {}
        self.tools: Dict[str, ToolEntry] = {}
        self.connections: Dict[str, Set[str]] = {}  # 知识关联图

        self._load()

    def add_note(self, title: str, content: str,
                 note_type: NoteType, tags: List[str] = None) -> Note:
        """添加笔记"""
        note_id = self._generate_id()
        note = Note(
            id=note_id,
            title=title,
            content=content,
            note_type=note_type,
            tags=set(tags or [])
        )
        self.notes[note_id] = note
        self._save_note(note)
        return note

    def add_code_snippet(self, name: str, code: str, language: str,
                        description: str = "") -> CodeSnippet:
        """添加代码片段"""
        snippet_id = self._generate_id()
        snippet = CodeSnippet(
            id=snippet_id,
            name=name,
            description=description,
            code=code,
            language=language
        )
        self.snippets[snippet_id] = snippet
        self._save_snippet(snippet)
        return snippet

    def add_tool(self, name: str, category: str, url: str,
                description: str, use_cases: List[str]) -> ToolEntry:
        """添加工具"""
        tool = ToolEntry(
            name=name,
            category=category,
            url=url,
            description=description,
            use_cases=use_cases,
            pros=[],
            cons=[]
        )
        self.tools[name] = tool
        self._save_tools()
        return tool

    def connect_notes(self, note_id1: str, note_id2: str, relation: str = ""):
        """连接两个笔记"""
        if note_id1 in self.notes and note_id2 in self.notes:
            self.notes[note_id1].related_notes.add(note_id2)
            self.notes[note_id2].related_notes.add(note_id1)

            # 更新关联图
            if note_id1 not in self.connections:
                self.connections[note_id1] = set()
            if note_id2 not in self.connections:
                self.connections[note_id2] = set()
            self.connections[note_id1].add(note_id2)
            self.connections[note_id2].add(note_id1)

            self._save_note(self.notes[note_id1])
            self._save_note(self.notes[note_id2])

    def search(self, query: str) -> List[Note]:
        """搜索笔记"""
        results = []
        query_lower = query.lower()

        for note in self.notes.values():
            if (query_lower in note.title.lower() or
                query_lower in note.content.lower() or
                any(query_lower in tag.lower() for tag in note.tags)):
                results.append(note)

        return sorted(results, key=lambda n: n.modified, reverse=True)

    def get_related_notes(self, note_id: str) -> List[Note]:
        """获取相关笔记"""
        if note_id not in self.notes:
            return []

        related_ids = self.notes[note_id].related_notes
        return [self.notes[nid] for nid in related_ids if nid in self.notes]

    def get_knowledge_graph(self) -> Dict[str, List[str]]:
        """获取知识图谱"""
        graph = {}
        for note_id, note in self.notes.items():
            graph[note.title] = [
                self.notes[rid].title
                for rid in note.related_notes
                if rid in self.notes
            ]
        return graph

    def review_periodic(self, days: int = 30) -> Dict[str, List[Note]]:
        """定期回顾：获取需要复习的笔记"""
        from datetime import timedelta

        cutoff = datetime.now() - timedelta(days=days)
        to_review = {
            'stale': [],      # 长时间未更新的笔记
            'orphan': [],     # 没有关联的笔记
            'valuable': []    # 高价值笔记
        }

        for note in self.notes.values():
            modified = datetime.fromisoformat(note.modified)

            # 识别陈旧笔记
            if modified < cutoff:
                to_review['stale'].append(note)

            # 识别孤立笔记
            if not note.related_notes:
                to_review['orphan'].append(note)

            # 识别高价值笔记（知识型和指南型）
            if note.note_type in [NoteType.KNOWLEDGE, NoteType.GUIDE]:
                to_review['valuable'].append(note)

        return to_review

    def export_markdown(self, note_id: str, output_path: str):
        """导出为Markdown"""
        if note_id not in self.notes:
            return

        note = self.notes[note_id]

        md_content = f"""# {note.title}

**类型**: {note.note_type.value}
**标签**: {', '.join(note.tags)}
**创建**: {note.created}
**修改**: {note.modified}

---

{note.content}
"""

        if note.related_notes:
            md_content += "\n\n## 相关笔记\n\n"
            for rid in note.related_notes:
                if rid in self.notes:
                    related = self.notes[rid]
                    md_content += f"- [{related.title}](notes/{rid}.md)\n"

        Path(output_path).write_text(md_content, encoding='utf-8')

    def _generate_id(self) -> str:
        """生成唯一ID"""
        import uuid
        return str(uuid.uuid4())[:8]

    def _save_note(self, note: Note):
        """保存笔记"""
        note_dir = self.base_path / "notes"
        note_dir.mkdir(parents=True, exist_ok=True)
        note_file = note_dir / f"{note.id}.json"
        note_file.write_text(json.dumps(note.__dict__, default=str), encoding='utf-8')

    def _save_snippet(self, snippet: CodeSnippet):
        """保存代码片段"""
        snippet_dir = self.base_path / "snippets"
        snippet_dir.mkdir(parents=True, exist_ok=True)
        snippet_file = snippet_dir / f"{snippet.id}.json"
        snippet_file.write_text(json.dumps(snippet.__dict__, default=str), encoding='utf-8')

    def _save_tools(self):
        """保存工具列表"""
        tools_file = self.base_path / "tools.json"
        tools_data = {name: tool.__dict__ for name, tool in self.tools.items()}
        tools_file.write_text(json.dumps(tools_data, default=str, ensure_ascii=False), encoding='utf-8')

    def _load(self):
        """加载数据"""
        # 加载笔记
        note_dir = self.base_path / "notes"
        if note_dir.exists():
            for note_file in note_dir.glob("*.json"):
                data = json.loads(note_file.read_text(encoding='utf-8'))
                data['note_type'] = NoteType(data['note_type'])
                data['tags'] = set(data.get('tags', []))
                data['related_notes'] = set(data.get('related_notes', []))
                note = Note(**data)
                self.notes[note.id] = note

        # 加载代码片段
        snippet_dir = self.base_path / "snippets"
        if snippet_dir.exists():
            for snippet_file in snippet_dir.glob("*.json"):
                data = json.loads(snippet_file.read_text(encoding='utf-8'))
                data['tags'] = set(data.get('tags', []))
                snippet = CodeSnippet(**data)
                self.snippets[snippet.id] = snippet

        # 加载工具
        tools_file = self.base_path / "tools.json"
        if tools_file.exists():
            data = json.loads(tools_file.read_text(encoding='utf-8'))
            for name, tool_data in data.items():
                self.tools[name] = ToolEntry(**tool_data)

# === 空间AI工具箱 ===

class SpatialAIToolkit:
    """空间AI工具箱"""

    def __init__(self, knowledge_system: PersonalKnowledgeSystem):
        self.knowledge = knowledge_system
        self.categories = {
            'llm': '大语言模型',
            'vision': '计算机视觉',
            'gis_ai': 'GIS AI工具',
            'remote_sensing': '遥感AI',
            'data': '数据处理',
            'visualization': '可视化'
        }

    def register_tool(self, name: str, category: str, url: str,
                     description: str, use_cases: List[str],
                     pros: List[str] = None, cons: List[str] = None):
        """注册工具"""
        tool = self.knowledge.add_tool(
            name=name,
            category=category,
            url=url,
            description=description,
            use_cases=use_cases
        )
        if pros:
            tool.pros = pros
        if cons:
            tool.cons = cons

        # 添加对应的笔记
        self.knowledge.add_note(
            title=f"工具: {name}",
            content=f"""
## {name}

**类别**: {self.categories.get(category, category)}
**链接**: {url}

### 描述
{description}

### 适用场景
{chr(10).join(f'- {uc}' for uc in use_cases)}

### 优点
{chr(10).join(f'- {p}' for p in (pros or ['']))}

### 缺点
{chr(10).join(f'- {c}' for c in (cons or ['']))}
""",
            note_type=NoteType.QUICK,
            tags=[Tag.TOOL.value, category]
        )

        return tool

    def add_workflow(self, name: str, description: str,
                    steps: List[str], tools: List[str],
                    code_example: str = None):
        """添加工作流"""
        # 添加工作流笔记
        content = f"""## {name}

### 描述
{description}

### 步骤
{chr(10).join(f'{i+1}. {step}' for i, step in enumerate(steps))}

### 所需工具
{chr(10).join(f'- {t}' for t in tools)}
"""

        if code_example:
            content += f"\n### 代码示例\n\n```python\n{code_example}\n```\n"

        note = self.knowledge.add_note(
            title=f"工作流: {name}",
            content=content,
            note_type=NoteType.GUIDE,
            tags=[Tag.WORKFLOW.value]
        )

        # 如果有代码，添加代码片段
        if code_example:
            self.knowledge.add_code_snippet(
                name=name,
                description=description,
                code=code_example,
                language="python"
            )

        return note

# === 使用示例 ===

def initialize_knowledge_system(base_path: str) -> PersonalKnowledgeSystem:
    """初始化知识系统"""
    print("=== 初始化个人知识系统 ===\n")

    pks = PersonalKnowledgeSystem(base_path)
    toolkit = SpatialAIToolkit(pks)

    # 注册常用工具
    print("注册AI工具...")

    toolkit.register_tool(
        name="Claude",
        category="llm",
        url="https://claude.ai",
        description="Anthropic的大语言模型，擅长分析和写作",
        use_cases=["代码生成", "文档写作", "问题分析", "代码审查"],
        pros=["上下文窗口大", "安全性好", "输出质量高"],
        cons=["无法实时联网", "不能运行代码"]
    )

    toolkit.register_tool(
        name="ChatGPT",
        category="llm",
        url="https://chat.openai.com",
        description="OpenAI的对话式AI",
        use_cases=["对话交流", "知识问答", "创意生成"],
        pros=["响应快速", "知识广博", "有插件生态"],
        cons=["上下文限制", "可能有幻觉"]
    )

    toolkit.register_tool(
        name="GitHub Copilot",
        category="llm",
        url="https://github.com/features/copilot",
        description="AI代码助手",
        use_cases=["代码补全", "函数生成", "代码解释"],
        pros=["集成在编辑器中", "学习代码模式", "提高效率"],
        cons=["需要订阅", "可能生成不安全代码"]
    )

    toolkit.register_tool(
        name="QGIS",
        category="gis_ai",
        url="https://qgis.org",
        description="开源GIS软件，支持Python插件",
        use_cases=["空间分析", "地图制作", "数据处理"],
        pros=["免费开源", "功能强大", "社区活跃"],
        cons=["学习曲线陡峭", "大数据处理慢"]
    )

    # 添加工作流
    print("添加工作流...")

    toolkit.add_workflow(
        name="遥感影像分类工作流",
        description="使用深度学习进行遥感影像分类",
        steps=[
            "准备训练数据和标签",
            "数据预处理和增强",
            "训练深度学习模型",
            "模型评估和调优",
            "对全图进行预测",
            "后处理和结果导出"
        ],
        tools=["Python", "TensorFlow/PyTorch", "GDAL"],
        code_example="""
# 简化的遥感分类示例
import rasterio
from sklearn.ensemble import RandomForestClassifier

# 读取影像
with rasterio.open('image.tif') as src:
    image = src.read()
    profile = src.profile

# 训练分类器
# clf = RandomForestClassifier()
# clf.fit(train_samples, train_labels)

# 预测
# prediction = clf.predict(image_pixels)
"""
    )

    # 添加核心概念笔记
    print("添加核心概念...")

    pks.add_note(
        title="空间自相关",
        content="""
## 空间自相关 (Spatial Autocorrelation)

### 定义
空间上相近的事物往往比随机分布的事物更相似。

### 度量指标
- **Moran's I**: 全局空间自相关
- **Geary's C**: 另一种全局指标
- **LISA**: 局部空间关联指标

### 应用
- 生态格局分析
- 疾病传播研究
- 房地产价格分析

### Python实现
```python
from libpysal.weights import Queen
from esda.moran import Moran

# 创建空间权重
w = Queen.from_dataframe(gdf)

# 计算Moran's I
moran = Moran(values, w)
```
""",
        note_type=NoteType.KNOWLEDGE,
        tags=[Tag.CONCEPT.value, "statistics", "spatial"]
    )

    print(f"\n知识系统初始化完成！")
    print(f"- 笔记: {len(pks.notes)}")
    print(f"- 代码片段: {len(pks.snippets)}")
    print(f"- 工具: {len(pks.tools)}")

    return pks

if __name__ == "__main__":
    # 初始化知识系统
    pks = initialize_knowledge_system("./knowledge_base")

    # 示例：搜索
    print("\n=== 搜索示例 ===")
    results = pks.search("空间")
    for note in results[:3]:
        print(f"- {note.title} ({note.note_type.value})")

    # 示例：知识图谱
    print("\n=== 知识图谱 ===")
    graph = pks.get_knowledge_graph()
    for title, related in list(graph.items())[:3]:
        if related:
            print(f"{title} → {', '.join(related)}")

    # 示例：定期回顾
    print("\n=== 需要回顾的内容 ===")
    review = pks.review_periodic(days=30)
    print(f"陈旧笔记: {len(review['stale'])}")
    print(f"孤立笔记: {len(review['orphan'])}")
    print(f"高价值笔记: {len(review['valuable'])}")
```

### 社区参与策略

```
社区参与的层次

        ┌─────────────────┐
        │   贡献者        │  ← 创建新价值
        │   - 开源项目    │
        │   - 发表论文    │
        │   - 开发工具    │
        └────────┬────────┘
                 │
        ┌────────┴────────┐
        │   分享者        │  ← 分享知识
        │   - 写博客      │
        │   - 做演讲      │
        │   - 回答问题    │
        └────────┬────────┘
                 │
        ┌────────┴────────┐
        │   参与者        │  ← 参与讨论
        │   - 参加会议    │
        │   - 社区讨论    │
        │   - 提问互动    │
        └────────┬────────┘
                 │
        ┌────────┴────────┐
        │   观察者        │  ← 获取信息
        │   - 阅读文档    │
        │   - 关注动态    │
        │   - 收集资源    │
        └─────────────────┘

各层次的行动建议：

观察者:
• 订阅精选博客和通讯
• 关注领域专家
• 收集优质资源

参与者:
• 加入相关社区（Discord, Slack, 邮件列表）
• 参加线上/线下活动
• 积极提问和讨论

分享者:
• 写学习笔记和博客
• 在会议上分享经验
• 回答社区问题

贡献者:
• 提交PR到开源项目
• 发布自己的工具
• 参与学术研究
```

---

## 案例分析

### 案例1：建立个人Prompt库

```python
"""
个人Prompt管理系统
"""
from typing import Dict, List
from dataclasses import dataclass

@dataclass
class PromptTemplate:
    """Prompt模板"""
    name: str
    description: str
    category: str
    template: str
    variables: List[str]  # 模板中的变量
    examples: List[Dict]  # 使用示例
    tags: List[str]

class PromptLibrary:
    """Prompt库"""

    def __init__(self):
        self.prompts: Dict[str, PromptTemplate] = {}

    def add_prompt(self, prompt: PromptTemplate):
        """添加Prompt模板"""
        self.prompts[prompt.name] = prompt

    def get_prompt(self, name: str, **kwargs) -> str:
        """获取填充后的Prompt"""
        if name not in self.prompts:
            raise ValueError(f"Prompt '{name}' not found")

        template = self.prompts[name]
        result = template.template

        # 替换变量
        for var, value in kwargs.items():
            result = result.replace(f"{{{var}}}", str(value))

        return result

    def list_by_category(self, category: str) -> List[PromptTemplate]:
        """按类别列出"""
        return [p for p in self.prompts.values() if p.category == category]

# === 空间AI专用Prompt ===

spatial_prompts = [
    PromptTemplate(
        name="spatial_analysis_explain",
        description="解释空间分析方法的原理和实现",
        category="analysis",
        template="""
你是一个空间分析专家。请解释以下空间分析方法：

**方法名称**: {method}

请包括：
1. 方法的核心原理
2. 数学基础（如果有）
3. 适用场景
4. 局限性
5. Python实现示例
6. 与其他方法的比较
""",
        variables=["method"],
        examples=[
            {"method": "Moran's I"},
            {"method": "最小累积阻力模型"}
        ],
        tags=["解释", "分析"]
    ),

    PromptTemplate(
        name="code_review_spatial",
        description="审查空间分析代码",
        category="code",
        template="""
请审查以下空间分析代码：

```python
{code}
```

请检查：
1. 空间数据处理是否正确（坐标系、投影等）
2. 算法选择是否合适
3. 效率问题
4. 潜在的错误
5. 改进建议
""",
        variables=["code"],
        examples=[{"code": "# 空间分析代码"}],
        tags=["代码审查", "质量"]
    ),

    PromptTemplate(
        name="gis_choice_advice",
        description="获取工具选择建议",
        category="advice",
        template="""
我需要为以下项目选择合适的GIS工具：

**项目描述**: {project_description}
**主要任务**: {tasks}
**数据量**: {data_size}
**团队情况**: {team_info}
**预算**: {budget}

请比较：
1. QGIS
2. ArcGIS
3. 其他相关工具

给出推荐和理由。
""",
        variables=["project_description", "tasks", "data_size", "team_info", "budget"],
        examples=[],
        tags=["工具选择", "建议"]
    ),

    PromptTemplate(
        name="spatial_data_cleaning",
        description="空间数据清洗指导",
        category="data",
        template="""
我需要清洗以下空间数据：

**数据描述**: {data_description}
**当前问题**: {problems}

请提供：
1. 诊断步骤
2. 清洗方法
3. Python代码示例
4. 质量检查方法
""",
        variables=["data_description", "problems"],
        examples=[],
        tags=["数据清洗", "质量"]
    ),

    PromptTemplate(
        name="landscape_pattern_analysis",
        description="景观格局分析",
        category="ecology",
        template="""
请帮我进行景观格局分析：

**研究区域**: {study_area}
**数据**: {data_description}
**研究问题**: {research_question}

请提供：
1. 合适的景观指数
2. 分析流程
3. 代码实现
4. 结果解释框架
""",
        variables=["study_area", "data_description", "research_question"],
        examples=[],
        tags=["景观", "生态"]
    ),
]

# 初始化Prompt库
prompt_lib = PromptLibrary()
for prompt in spatial_prompts:
    prompt_lib.add_prompt(prompt)

# 使用示例
if __name__ == "__main__":
    print("=== 空间AI Prompt库 ===\n")

    # 使用Prompt
    prompt = prompt_lib.get_prompt(
        "spatial_analysis_explain",
        method="最小累积阻力模型"
    )
    print("生成的Prompt:")
    print(prompt[:200] + "...\n")

    # 列出某类别
    analysis_prompts = prompt_lib.list_by_category("analysis")
    print(f"分析类Prompt: {[p.name for p in analysis_prompts]}")
```

### 案例2：项目文档化策略

```python
"""
项目文档化模板系统
"""

class ProjectDocumentation:
    """项目文档化"""

    @staticmethod
    def create_readme_template() -> str:
        """README模板"""
        return """# {project_name}

## 简介
{description}

## 背景
{background}

## 目标
{goals}

## 数据
- 数据来源: {data_sources}
- 数据格式: {data_formats}
- 数据质量: {data_quality}

## 方法
{methods}

## 结果
{results}

## 运行
```bash
{run_commands}
```

## 依赖
{dependencies}

## 作者
{authors}

## 许可
{license}
"""

    @staticmethod
    def create_methodology_section(method: str, data: Dict) -> str:
        """方法学文档"""
        return f"""
## {method}

### 原理
{data.get('principle', '')}

### 实现
```python
{data.get('code', '')}
```

### 参数
{chr(10).join(f"- **{k}**: {v}" for k, v in data.get('parameters', {}).items())}

### 参考文献
{chr(10).join(f"- [{ref}]({ref})" for ref in data.get('references', []))}
"""

    @staticmethod
    def create_decision_log_template() -> str:
        """决策日志模板"""
        return """# 项目决策日志

## 决策记录

| 日期 | 决策 | 理由 | 替代方案 | 状态 |
|------|------|------|----------|------|
| {date} | {decision} | {rationale} | {alternatives} | {status} |

## 重要决策详情

### {decision_title}
**日期**: {date}
**决策者**: {decision_maker}

**问题**:
{problem}

**选项**:
1. {option1}
2. {option2}
3. {option3}

**选择**: {chosen_option}

**理由**:
{rationale}

**预期影响**:
{expected_impact}
"""

# === 自动文档生成 ===

class AutoDocumentation:
    """自动文档生成器"""

    @staticmethod
    def generate_code_documentation(code: str, ai_assistant) -> Dict:
        """使用AI生成代码文档"""
        prompt = f"""
请为以下代码生成文档：

```python
{code}
```

返回JSON格式：
{{
    "description": "代码描述",
    "parameters": "参数说明",
    "returns": "返回值说明",
    "example": "使用示例",
    "notes": "注意事项"
}}
"""
        response = ai_assistant.query(prompt)
        return response

    @staticmethod
    def generate_workflow_diagram(steps: List[str]) -> str:
        """生成工作流图（Mermaid格式）"""
        mermaid = ["graph TD"]
        for i, step in enumerate(steps):
            node_id = f"S{i}"
            mermaid.append(f"    {node_id}[{step}]")
            if i > 0:
                mermaid.append(f"    S{i-1} --> {node_id}")
        return "\n".join(mermaid)
```

### 案例3：学习路径规划

```python
"""
个人学习路径规划器
"""
from typing import List, Dict, Optional
from dataclasses import dataclass
from datetime import datetime, timedelta

@dataclass
class LearningGoal:
    """学习目标"""
    name: str
    description: str
    priority: str  # high, medium, low
    estimated_hours: float
    dependencies: List[str]  # 前置要求
    resources: List[str]  # 学习资源
    status: str = "planned"  # planned, in_progress, completed
    start_date: Optional[str] = None
    completed_date: Optional[str] = None

class LearningPathPlanner:
    """学习路径规划器"""

    def __init__(self):
        self.goals: Dict[str, LearningGoal] = {}
        self.completed: List[str] = []

    def add_goal(self, goal: LearningGoal):
        """添加学习目标"""
        self.goals[goal.name] = goal

    def get_recommended_order(self) -> List[str]:
        """获取推荐的学习顺序（拓扑排序）"""
        # 简化的拓扑排序
        ordered = []
        remaining = set(self.goals.keys())

        while remaining:
            # 找到没有未满足依赖的目标
            ready = [
                name for name in remaining
                if all(dep in self.completed for dep in self.goals[name].dependencies)
            ]

            if not ready:
                # 循环依赖，按优先级选一个
                ready = [min(remaining, key=lambda n: self.goals[n].priority)]

            # 按优先级排序
            ready.sort(key=lambda n: {'high': 0, 'medium': 1, 'low': 2}[self.goals[n].priority])

            next_goal = ready[0]
            ordered.append(next_goal)
            remaining.remove(next_goal)

        return ordered

    def create_schedule(self, weekly_hours: float, start_date: str = None) -> Dict:
        """创建学习计划"""
        if start_date is None:
            start_date = datetime.now()
        else:
            start_date = datetime.fromisoformat(start_date)

        schedule = {}
        current = start_date
        ordered = self.get_recommended_order()

        for goal_name in ordered:
            goal = self.goals[goal_name]

            # 计算需要周数
            weeks_needed = goal.estimated_hours / weekly_hours

            schedule[goal_name] = {
                'start': current.isoformat(),
                'end': (current + timedelta(weeks=weeks_needed)).isoformat(),
                'weeks': weeks_needed,
                'hours_per_week': weekly_hours
            }

            current += timedelta(weeks=weeks_needed)

        return schedule

    def mark_completed(self, goal_name: str):
        """标记目标完成"""
        if goal_name in self.goals:
            self.goals[goal_name].status = "completed"
            self.goals[goal_name].completed_date = datetime.now().isoformat()
            self.completed.append(goal_name)

# === 空间AI学习路径 ===

def create_spatial_ai_learning_path() -> LearningPathPlanner:
    """创建空间AI学习路径"""
    planner = LearningPathPlanner()

    # 基础
    planner.add_goal(LearningGoal(
        name="Python基础",
        description="掌握Python编程基础",
        priority="high",
        estimated_hours=40,
        dependencies=[],
        resources=["Python官方教程", "Automate the Boring Stuff"]
    ))

    planner.add_goal(LearningGoal(
        name="GIS基础",
        description="理解地理信息系统基本概念",
        priority="high",
        estimated_hours=30,
        dependencies=[],
        resources=["QGIS官方教程", "Geocomputation with R"]
    ))

    # 核心
    planner.add_goal(LearningGoal(
        name="空间数据处理",
        description="使用Python处理空间数据",
        priority="high",
        estimated_hours=50,
        dependencies=["Python基础", "GIS基础"],
        resources=["GeoPandas文档", "PyTutoria"]
    ))

    planner.add_goal(LearningGoal(
        name="空间统计分析",
        description="空间统计方法和实践",
        priority="high",
        estimated_hours=60,
        dependencies=["空间数据处理"],
        resources=["PySAL文档", "Spatial Statistics"]
    ))

    planner.add_goal(LearningGoal(
        name="机器学习基础",
        description="机器学习算法和原理",
        priority="medium",
        estimated_hours=80,
        dependencies=["Python基础"],
        resources=["Hands-On ML", "Scikit-learn文档"]
    ))

    # 进阶
    planner.add_goal(LearningGoal(
        name="深度学习",
        description="深度学习和神经网络",
        priority="medium",
        estimated_hours=100,
        dependencies=["机器学习基础"],
        resources=["Deep Learning", "Fast.ai"]
    ))

    planner.add_goal(LearningGoal(
        name="遥感AI",
        description="遥感影像的深度学习应用",
        priority="medium",
        estimated_hours=60,
        dependencies=["深度学习", "空间数据处理"],
        resources=["深度学习与遥感", "torchgeo"]
    ))

    planner.add_goal(LearningGoal(
        name="LLM应用",
        description="大语言模型在空间分析中的应用",
        priority="low",
        estimated_hours=40,
        dependencies=["机器学习基础", "空间数据处理"],
        resources=["Claude文档", "LangChain文档"]
    ))

    return planner

if __name__ == "__main__":
    print("=== 空间AI学习路径 ===\n")

    planner = create_spatial_ai_learning_path()

    print("推荐学习顺序:")
    order = planner.get_recommended_order()
    for i, goal_name in enumerate(order, 1):
        goal = planner.goals[goal_name]
        print(f"{i}. {goal_name} ({goal.estimated_hours}h) - {goal.priority}")

    print("\n学习计划 (每周10小时):")
    schedule = planner.create_schedule(weekly_hours=10)
    for goal_name, info in schedule.items():
        start = info['start'][:10]
        end = info['end'][:10]
        print(f"{goal_name}: {start} → {end} ({info['weeks']:.1f}周)")

    total_hours = sum(g.estimated_hours for g in planner.goals.values())
    total_weeks = total_hours / 10
    print(f"\n总计: {total_hours}小时, 约{total_weeks:.1f}周")
```

---

## 反思与延伸

### 思考问题

1. **知识审计**：你当前的知识体系有哪些空白？

2. **工具评估**：你的AI工具箱中有多少工具是真正常用的？

3. **文档习惯**：你目前的文档化习惯有什么问题？

4. **社区参与**：你在哪个层次的社区参与？如何提升？

### 实践练习

1. **建立知识库**：使用文中代码创建你的个人知识系统

2. **整理Prompt**：收集并整理你常用的Prompt模板

3. **规划学习**：为未来6个月创建详细的学习计划

### 延伸阅读

- **"Building a Second Brain"** (Tiago Forte) - 个人知识管理
- **"How to Take Smart Notes"** (Sönke Ahrens) - 卡片笔记法
- **"Digital Minimalism"** (Cal Newport) - 数字工具的选择

---

## 关键要点

1. **个人知识体系应该是分层的**，从捕获到分享
2. **AI工具箱需要分类管理**，包括基础、专业、自定义工具
3. **文档化应该遵循金字塔模型**，不同类型文档有不同目的
4. **社区参与是多层次的**，从观察到贡献逐步深入
5. **持续优化是关键**，定期回顾和调整你的知识系统
