doc-analyzer

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Purpose

用途

The doc-analyzer skill provides comprehensive capabilities for analyzing fetched library and framework documentation to extract actionable implementation guidance. This skill helps the Documentation Researcher agent identify relevant code patterns, best practices, common pitfalls, and integration strategies that enable high-quality feature implementations.

This skill emphasizes:

Pattern Recognition: Identify reusable code patterns and architectural approaches
Best Practice Extraction: Discover recommended practices from authoritative sources
Example Compilation: Collect and categorize working code examples
Pitfall Identification: Recognize common mistakes and antipatterns
Integration Guidance: Extract patterns for combining libraries and frameworks

The doc-analyzer skill ensures that documentation research provides practical, actionable guidance rather than raw documentation dumps.

doc-analyzer技能提供全面的能力，可分析获取的库和框架文档，提取可落地的实现指导。该技能帮助Documentation Researcher Agent识别相关的代码模式、最佳实践、常见陷阱和集成策略，助力高质量的功能实现。

本技能重点关注：

模式识别：识别可复用的代码模式和架构方法
最佳实践提取：从权威来源发现推荐实践
示例整理：收集并分类可运行的代码示例
陷阱识别：识别常见错误和反模式
集成指导：提取库与框架的组合模式

doc-analyzer技能确保文档研究提供实用、可落地的指导，而非原始文档的堆砌。

When to Use

使用场景

This skill auto-activates when the agent describes:

"Analyze documentation for..."
"Extract patterns from..."
"Identify best practices..."
"Find examples of..."
"Discover common pitfalls..."
"Extract API usage patterns..."
"Analyze integration approaches..."
"Identify security considerations..."

当Agent描述以下内容时，本技能会自动激活：

"分析文档以..."
"从...提取模式"
"识别最佳实践..."
"查找...的示例"
"发现常见陷阱..."
"提取API使用模式..."
"分析集成方法..."
"识别安全注意事项..."

Provided Capabilities

提供的能力

1. Code Pattern Extraction

1. 代码模式提取

What it provides:

Initialization and setup patterns
Common usage patterns
Integration patterns between libraries
Configuration patterns
Testing patterns

Pattern Categories:

Initialization Patterns:

python

def extract_initialization_patterns(docs: dict) -> list:
    """
    Extract initialization and setup patterns from documentation.
    """
    keywords = [
        "setup", "initialize", "config", "configuration",
        "getting started", "first steps", "__init__", "setup.py"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "initialization",
                "title": section["title"],
                "code": extract_code_blocks(section),
                "description": section["description"],
                "prerequisites": extract_prerequisites(section)
            })

    return patterns

提供内容：

初始化与设置模式
常见使用模式
库之间的集成模式
配置模式
测试模式

模式分类：

初始化模式：

python

def extract_initialization_patterns(docs: dict) -> list:
    """
    Extract initialization and setup patterns from documentation.
    """
    keywords = [
        "setup", "initialize", "config", "configuration",
        "getting started", "first steps", "__init__", "setup.py"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "initialization",
                "title": section["title"],
                "code": extract_code_blocks(section),
                "description": section["description"],
                "prerequisites": extract_prerequisites(section)
            })

    return patterns

Example extracted pattern

{ "type": "initialization", "title": "FastAPI Application Setup", "code": """ from fastapi import FastAPI

app = FastAPI( title="My API", description="API description", version="1.0.0" ) """, "description": "Basic FastAPI application initialization with metadata", "prerequisites": ["fastapi installed", "Python 3.7+"] }


**Usage Patterns:**
```python
def extract_usage_patterns(docs: dict) -> list:
    """
    Extract common usage patterns from documentation.
    """
    keywords = [
        "example", "usage", "how to", "tutorial",
        "guide", "quickstart", "getting started"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "usage",
                "title": section["title"],
                "code": extract_code_blocks(section),
                "use_case": identify_use_case(section),
                "complexity": assess_complexity(section)
            })

    return patterns

Integration Patterns:

python

def extract_integration_patterns(docs: dict) -> list:
    """
    Extract patterns for integrating with other libraries.
    """
    keywords = [
        "integrate", "combination", "together", "with",
        "plugin", "middleware", "extension"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "integration",
                "libraries": identify_libraries(section),
                "pattern": section["title"],
                "code": extract_code_blocks(section),
                "compatibility": extract_compatibility(section)
            })

    return patterns

{ "type": "initialization", "title": "FastAPI Application Setup", "code": """ from fastapi import FastAPI


**使用模式：**
```python
def extract_usage_patterns(docs: dict) -> list:
    """
    Extract common usage patterns from documentation.
    """
    keywords = [
        "example", "usage", "how to", "tutorial",
        "guide", "quickstart", "getting started"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "usage",
                "title": section["title"],
                "code": extract_code_blocks(section),
                "use_case": identify_use_case(section),
                "complexity": assess_complexity(section)
            })

    return patterns

集成模式：

python

def extract_integration_patterns(docs: dict) -> list:
    """
    Extract patterns for integrating with other libraries.
    """
    keywords = [
        "integrate", "combination", "together", "with",
        "plugin", "middleware", "extension"
    ]

    patterns = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            patterns.append({
                "type": "integration",
                "libraries": identify_libraries(section),
                "pattern": section["title"],
                "code": extract_code_blocks(section),
                "compatibility": extract_compatibility(section)
            })

    return patterns

2. Best Practice Identification

2. 最佳实践识别

What it provides:

Recommended practices from official documentation
Performance optimization techniques
Security best practices
Code organization recommendations
Testing strategies

Best Practice Categories:

Recommended Practices:

python

def extract_best_practices(docs: dict, category: str = "recommended") -> list:
    """
    Extract best practices from documentation.
    """
    # Keywords for different categories
    keywords = {
        "recommended": ["best practice", "recommended", "should", "prefer", "tip"],
        "avoid": ["avoid", "don't", "antipattern", "pitfall", "common mistake"],
        "performance": ["performance", "optimize", "efficient", "fast", "slow", "bottleneck"],
        "security": ["security", "secure", "vulnerability", "safety", "protect", "authentication"]
    }

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords[category]):
            practices.append({
                "category": category,
                "practice": extract_practice_statement(section),
                "rationale": extract_rationale(section),
                "example": extract_code_example(section),
                "source": section["source_url"]
            })

    return practices

提供内容：

官方文档推荐的实践
性能优化技巧
安全最佳实践
代码组织建议
测试策略

最佳实践分类：

推荐实践：

python

def extract_best_practices(docs: dict, category: str = "recommended") -> list:
    """
    Extract best practices from documentation.
    """
    # Keywords for different categories
    keywords = {
        "recommended": ["best practice", "recommended", "should", "prefer", "tip"],
        "avoid": ["avoid", "don't", "antipattern", "pitfall", "common mistake"],
        "performance": ["performance", "optimize", "efficient", "fast", "slow", "bottleneck"],
        "security": ["security", "secure", "vulnerability", "safety", "protect", "authentication"]
    }

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords[category]):
            practices.append({
                "category": category,
                "practice": extract_practice_statement(section),
                "rationale": extract_rationale(section),
                "example": extract_code_example(section),
                "source": section["source_url"]
            })

    return practices

Example extracted best practice

{ "category": "recommended", "practice": "Use dependency injection for database connections", "rationale": "Enables testability and reduces coupling", "example": """ from fastapi import Depends

async def get_db(): db = Database() try: yield db finally: await db.close()

@app.get("/items/") async def read_items(db = Depends(get_db)): return db.query("SELECT * FROM items") """, "source": "https://fastapi.tiangolo.com/tutorial/dependencies/" }


**Performance Best Practices:**
```python
def extract_performance_practices(docs: dict) -> list:
    """
    Extract performance optimization practices.
    """
    keywords = ["performance", "optimize", "cache", "async", "efficient", "scalability"]

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            practices.append({
                "category": "performance",
                "optimization": section["title"],
                "technique": extract_technique(section),
                "impact": assess_performance_impact(section),
                "implementation": extract_code_blocks(section)
            })

    return practices

Security Best Practices:

python

def extract_security_practices(docs: dict) -> list:
    """
    Extract security best practices.
    """
    keywords = ["security", "secure", "authentication", "authorization", "vulnerability", "OWASP"]

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            practices.append({
                "category": "security",
                "security_concern": identify_concern(section),
                "mitigation": extract_mitigation(section),
                "implementation": extract_code_blocks(section),
                "owasp_category": map_to_owasp(section) if applicable else None
            })

    return practices

{ "category": "recommended", "practice": "Use dependency injection for database connections", "rationale": "Enables testability and reduces coupling", "example": """ from fastapi import Depends

async def get_db(): db = Database() try: yield db finally: await db.close()

@app.get("/items/") async def read_items(db = Depends(get_db)): return db.query("SELECT * FROM items") """, "source": "https://fastapi.tiangolo.com/tutorial/dependencies/" }


**性能最佳实践：**
```python
def extract_performance_practices(docs: dict) -> list:
    """
    Extract performance optimization practices.
    """
    keywords = ["performance", "optimize", "cache", "async", "efficient", "scalability"]

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            practices.append({
                "category": "performance",
                "optimization": section["title"],
                "technique": extract_technique(section),
                "impact": assess_performance_impact(section),
                "implementation": extract_code_blocks(section)
            })

    return practices

安全最佳实践：

python

def extract_security_practices(docs: dict) -> list:
    """
    Extract security best practices.
    """
    keywords = ["security", "secure", "authentication", "authorization", "vulnerability", "OWASP"]

    practices = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            practices.append({
                "category": "security",
                "security_concern": identify_concern(section),
                "mitigation": extract_mitigation(section),
                "implementation": extract_code_blocks(section),
                "owasp_category": map_to_owasp(section) if applicable else None
            })

    return practices

3. API Usage Example Compilation

3. API使用示例整理

What it provides:

Categorized code examples
Working, runnable code
Example annotations and explanations
Complexity ratings
Use case mapping

Example Extraction:

python

def extract_api_examples(docs: dict) -> list:
    """
    Extract and categorize API usage examples.
    """
    examples = []

    for section in docs["sections"]:
        code_blocks = extract_code_blocks(section)

        for code_block in code_blocks:
            examples.append({
                "api_element": identify_api_element(code_block),
                "use_case": infer_use_case(section["title"], code_block),
                "code": code_block["code"],
                "language": code_block["language"],
                "complexity": assess_complexity(code_block),
                "runnable": validate_runnability(code_block),
                "dependencies": extract_dependencies(code_block),
                "explanation": section["description"]
            })

    return examples

提供内容：

分类后的代码示例
可运行的代码
示例注释与说明
复杂度评级
用例映射

示例提取：

python

def extract_api_examples(docs: dict) -> list:
    """
    Extract and categorize API usage examples.
    """
    examples = []

    for section in docs["sections"]:
        code_blocks = extract_code_blocks(section)

        for code_block in code_blocks:
            examples.append({
                "api_element": identify_api_element(code_block),
                "use_case": infer_use_case(section["title"], code_block),
                "code": code_block["code"],
                "language": code_block["language"],
                "complexity": assess_complexity(code_block),
                "runnable": validate_runnability(code_block),
                "dependencies": extract_dependencies(code_block),
                "explanation": section["description"]
            })

    return examples

Example output

{ "api_element": "FastAPI.get decorator", "use_case": "Simple GET endpoint with path parameter", "code": """ @app.get("/items/{item_id}") async def read_item(item_id: int, q: str = None): return {"item_id": item_id, "q": q} """, "language": "python", "complexity": "simple", "runnable": True, "dependencies": ["fastapi"], "explanation": "Defines a GET endpoint with a path parameter and optional query parameter" }


**Example Categorization:**
```python
def categorize_examples(examples: list) -> dict:
    """
    Categorize examples by complexity and use case.
    """
    categorized = {
        "basic": [],      # Simple, introductory examples
        "intermediate": [],  # Common patterns
        "advanced": [],   # Complex integrations
        "by_feature": {}  # Organized by feature
    }

    for example in examples:
        # By complexity
        categorized[example["complexity"]].append(example)

        # By feature
        feature = example["api_element"]
        if feature not in categorized["by_feature"]:
            categorized["by_feature"][feature] = []
        categorized["by_feature"][feature].append(example)

    return categorized


**示例分类：**
```python
def categorize_examples(examples: list) -> dict:
    """
    Categorize examples by complexity and use case.
    """
    categorized = {
        "basic": [],      # Simple, introductory examples
        "intermediate": [],  # Common patterns
        "advanced": [],   # Complex integrations
        "by_feature": {}  # Organized by feature
    }

    for example in examples:
        # By complexity
        categorized[example["complexity"]].append(example)

        # By feature
        feature = example["api_element"]
        if feature not in categorized["by_feature"]:
            categorized["by_feature"][feature] = []
        categorized["by_feature"][feature].append(example)

    return categorized

4. Common Pitfall Identification

4. 常见陷阱识别

What it provides:

Common mistakes and antipatterns
Error-prone patterns
Deprecated features
Version-specific gotchas
Migration pitfalls

Pitfall Detection:

python

def identify_pitfalls(docs: dict) -> list:
    """
    Identify common pitfalls from documentation.
    """
    keywords = [
        "avoid", "don't", "pitfall", "common mistake", "gotcha",
        "warning", "caution", "deprecated", "not recommended"
    ]

    pitfalls = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            pitfalls.append({
                "pitfall": extract_pitfall_description(section),
                "why_problematic": extract_reasoning(section),
                "incorrect_example": extract_incorrect_example(section),
                "correct_alternative": extract_correct_example(section),
                "severity": assess_severity(section)
            })

    return pitfalls

提供内容：

常见错误与反模式
易出错的模式
已废弃的功能
特定版本的注意事项
迁移陷阱

陷阱检测：

python

def identify_pitfalls(docs: dict) -> list:
    """
    Identify common pitfalls from documentation.
    """
    keywords = [
        "avoid", "don't", "pitfall", "common mistake", "gotcha",
        "warning", "caution", "deprecated", "not recommended"
    ]

    pitfalls = []
    for section in docs["sections"]:
        if contains_keywords(section, keywords):
            pitfalls.append({
                "pitfall": extract_pitfall_description(section),
                "why_problematic": extract_reasoning(section),
                "incorrect_example": extract_incorrect_example(section),
                "correct_alternative": extract_correct_example(section),
                "severity": assess_severity(section)
            })

    return pitfalls

Example identified pitfall

{ "pitfall": "Blocking I/O in async functions", "why_problematic": "Blocks the event loop, preventing concurrent request handling", "incorrect_example": """ @app.get("/items/") async def read_items(): # ❌ Blocking database call in async function items = blocking_db_query("SELECT * FROM items") return items """, "correct_alternative": """ @app.get("/items/") async def read_items(): # ✅ Non-blocking async database call items = await async_db_query("SELECT * FROM items") return items """, "severity": "high" }

undefined

undefined

5. Integration Strategy Extraction

5. 集成策略提取

What it provides:

Multi-library integration patterns
Middleware and plugin patterns
Configuration strategies
Dependency management

Integration Analysis:

python

def extract_integration_strategies(docs: dict, libraries: list) -> dict:
    """
    Extract strategies for integrating multiple libraries.
    """
    strategies = {}

    for lib in libraries:
        # Find integration mentions
        integration_sections = find_integration_sections(docs, lib)

        strategies[lib] = {
            "compatibility": extract_compatibility_info(integration_sections),
            "integration_pattern": extract_integration_pattern(integration_sections),
            "configuration": extract_configuration(integration_sections),
            "examples": extract_integration_examples(integration_sections),
            "known_issues": extract_known_issues(integration_sections)
        }

    return strategies

提供内容：

多库集成模式
中间件与插件模式
配置策略
依赖管理

集成分析：

python

def extract_integration_strategies(docs: dict, libraries: list) -> dict:
    """
    Extract strategies for integrating multiple libraries.
    """
    strategies = {}

    for lib in libraries:
        # Find integration mentions
        integration_sections = find_integration_sections(docs, lib)

        strategies[lib] = {
            "compatibility": extract_compatibility_info(integration_sections),
            "integration_pattern": extract_integration_pattern(integration_sections),
            "configuration": extract_configuration(integration_sections),
            "examples": extract_integration_examples(integration_sections),
            "known_issues": extract_known_issues(integration_sections)
        }

    return strategies

Example integration strategy

{ "library": "sqlalchemy", "compatibility": "Compatible with FastAPI via async support", "integration_pattern": "Dependency injection for database sessions", "configuration": { "database_url": "Configuration via environment variables", "engine_options": "async_engine with asyncpg driver" }, "examples": [...], "known_issues": ["Connection pool management in async context"] }

undefined

undefined

6. Version Compatibility Analysis

6. 版本兼容性分析

What it provides:

Breaking changes between versions
Deprecated features
Migration requirements
Version-specific considerations

Compatibility Detection:

python

def analyze_version_compatibility(docs: dict, current_version: str, target_version: str) -> dict:
    """
    Analyze compatibility between versions.
    """
    changelog = extract_changelog(docs)

    return {
        "current_version": current_version,
        "target_version": target_version,
        "breaking_changes": extract_breaking_changes(changelog, current_version, target_version),
        "deprecations": extract_deprecations(changelog, current_version, target_version),
        "new_features": extract_new_features(changelog, target_version),
        "migration_required": requires_migration(changelog, current_version, target_version),
        "migration_guide": extract_migration_guide(docs, current_version, target_version),
        "compatibility_notes": extract_compatibility_notes(docs)
    }

提供内容：

版本间的破坏性变更
已废弃的功能
迁移要求
特定版本的注意事项

兼容性检测：

python

def analyze_version_compatibility(docs: dict, current_version: str, target_version: str) -> dict:
    """
    Analyze compatibility between versions.
    """
    changelog = extract_changelog(docs)

    return {
        "current_version": current_version,
        "target_version": target_version,
        "breaking_changes": extract_breaking_changes(changelog, current_version, target_version),
        "deprecations": extract_deprecations(changelog, current_version, target_version),
        "new_features": extract_new_features(changelog, target_version),
        "migration_required": requires_migration(changelog, current_version, target_version),
        "migration_guide": extract_migration_guide(docs, current_version, target_version),
        "compatibility_notes": extract_compatibility_notes(docs)
    }

Usage Guide

使用指南

Step 1: Receive Fetched Documentation

步骤1：接收获取的文档

doc-fetcher completes → Fetched documentation → doc-analyzer input

doc-fetcher完成 → 获取的文档 → doc-analyzer输入

Step 2: Extract Code Patterns

步骤2：提取代码模式

Documentation → Pattern recognition → Categorized patterns

文档 → 模式识别 → 分类后的模式

Step 3: Identify Best Practices

步骤3：识别最佳实践

Documentation → Best practice detection → Recommended/avoid lists

文档 → 最佳实践检测 → 推荐/避免列表

Step 4: Compile Examples

步骤4：整理示例

Code blocks → Extraction → Categorization → Example library

代码块 → 提取 → 分类 → 示例库

Step 5: Identify Pitfalls

步骤5：识别陷阱

Documentation → Pitfall detection → Antipattern catalog

文档 → 陷阱检测 → 反模式目录

Step 6: Analyze Integration

步骤6：分析集成

Multiple libraries → Integration patterns → Compatibility matrix

多个库 → 集成模式 → 兼容性矩阵

Step 7: Generate Analysis Summary

步骤7：生成分析摘要

All analyses → Synthesis → Structured output

所有分析 → 合成 → 结构化输出

Best Practices

最佳实践

Focus on Relevance
- Extract only patterns relevant to feature requirements
- Prioritize commonly used patterns over edge cases
- Filter examples by complexity appropriate to feature
Validate Code Examples
- Verify examples are runnable
- Check for required dependencies
- Test examples if possible
- Document prerequisites
Prioritize Official Sources
- Official documentation takes precedence
- Cross-reference multiple sources
- Note source URL for all extracted content
- Verify currency of information
Categorize Systematically
- Use consistent categorization scheme
- Tag with complexity level
- Associate with use cases
- Link related patterns
Document Context
- Include version information
- Note applicable scenarios
- Document limitations
- Provide rationale for recommendations
Security-First Analysis
- Identify security considerations in all patterns
- Extract security best practices explicitly
- Flag potential vulnerabilities
- Cross-reference with OWASP Top 10

聚焦相关性
- 仅提取与功能需求相关的模式
- 优先关注常用模式而非边缘案例
- 根据功能的复杂度筛选示例
验证代码示例
- 验证示例是否可运行
- 检查所需依赖
- 尽可能测试示例
- 记录前置条件
优先官方来源
- 官方文档具有最高优先级
- 交叉参考多个来源
- 为所有提取内容标注来源URL
- 验证信息的时效性
系统分类
- 使用一致的分类方案
- 标记复杂度等级
- 关联对应用例
- 链接相关模式
记录上下文
- 包含版本信息
- 标注适用场景
- 记录限制条件
- 提供推荐理由
安全优先分析
- 识别所有模式中的安全注意事项
- 明确提取安全最佳实践
- 标记潜在漏洞
- 与OWASP Top 10交叉参考

Resources

资源

pattern-extraction-guide.md

Comprehensive guide for pattern extraction:

Pattern recognition techniques
Code block parsing methods
Pattern categorization schemes
Example validation approaches
Integration pattern identification
Testing pattern extraction

模式提取综合指南：

模式识别技术
代码块解析方法
模式分类方案
示例验证方法
集成模式识别
测试模式提取

best-practices-catalog.md

Catalog of best practices by framework:

Common best practices across frameworks
Framework-specific recommendations
Security patterns and practices
Performance optimization techniques
Testing best practices
Error handling patterns

按框架分类的最佳实践目录：

跨框架通用最佳实践
框架特定推荐
安全模式与实践
性能优化技巧
测试最佳实践
错误处理模式

Example Usage

示例用法

Input (from Documentation Researcher agent):

输入（来自Documentation Researcher Agent）：

"Analyze FastAPI documentation to extract API routing patterns, dependency injection examples, and Pydantic integration best practices."

"Analyze FastAPI documentation to extract API routing patterns, dependency injection examples, and Pydantic integration best practices."

Output (doc-analyzer skill provides):

输出（doc-analyzer技能提供）：

python

undefined

python

undefined

Comprehensive documentation analysis

analysis = { "library": "fastapi", "version": "0.100.0",

"patterns": {
    "api_routing": [
        {
            "pattern": "Path parameter with type hint",
            "code": "@app.get('/items/{item_id}')\nasync def read_item(item_id: int): ...",
            "use_case": "REST API with typed path parameters",
            "complexity": "simple"
        },
        {
            "pattern": "Query parameters with defaults",
            "code": "@app.get('/items/')\nasync def read_items(skip: int = 0, limit: int = 10): ...",
            "use_case": "Pagination with query parameters",
            "complexity": "simple"
        }
    ],
    "dependency_injection": [
        {
            "pattern": "Database session dependency",
            "code": "def get_db():\n    db = Database()\n    try:\n        yield db\n    finally:\n        db.close()",
            "use_case": "Resource management with cleanup",
            "complexity": "intermediate"
        }
    ]
},

"best_practices": {
    "recommended": [
        {
            "practice": "Use async def for I/O-bound operations",
            "rationale": "Enables concurrent request handling",
            "example": "@app.get('/items/')\nasync def read_items(): ..."
        },
        {
            "practice": "Use Pydantic models for request/response validation",
            "rationale": "Automatic validation and documentation generation",
            "example": "class Item(BaseModel):\n    name: str\n    price: float"
        }
    ],
    "avoid": [
        {
            "antipattern": "Blocking I/O in async functions",
            "why_problematic": "Blocks event loop, kills performance",
            "alternative": "Use async database drivers and await calls"
        }
    ]
},

"examples": {
    "basic": [...],
    "intermediate": [...],
    "advanced": [...]
},

"integration": {
    "pydantic": {
        "compatibility": "Native integration, Pydantic v2 supported",
        "pattern": "Use BaseModel for all request/response schemas",
        "examples": [...]
    }
},

"version_notes": "FastAPI 0.100.0 requires Pydantic v2.x"

}

undefined

analysis = { "library": "fastapi", "version": "0.100.0",

"patterns": {
    "api_routing": [
        {
            "pattern": "Path parameter with type hint",
            "code": "@app.get('/items/{item_id}')\nasync def read_item(item_id: int): ...",
            "use_case": "REST API with typed path parameters",
            "complexity": "simple"
        },
        {
            "pattern": "Query parameters with defaults",
            "code": "@app.get('/items/')\nasync def read_items(skip: int = 0, limit: int = 10): ...",
            "use_case": "Pagination with query parameters",
            "complexity": "simple"
        }
    ],
    "dependency_injection": [
        {
            "pattern": "Database session dependency",
            "code": "def get_db():\n    db = Database()\n    try:\n        yield db\n    finally:\n        db.close()",
            "use_case": "Resource management with cleanup",
            "complexity": "intermediate"
        }
    ]
},

"best_practices": {
    "recommended": [
        {
            "practice": "Use async def for I/O-bound operations",
            "rationale": "Enables concurrent request handling",
            "example": "@app.get('/items/')\nasync def read_items(): ..."
        },
        {
            "practice": "Use Pydantic models for request/response validation",
            "rationale": "Automatic validation and documentation generation",
            "example": "class Item(BaseModel):\n    name: str\n    price: float"
        }
    ],
    "avoid": [
        {
            "antipattern": "Blocking I/O in async functions",
            "why_problematic": "Blocks event loop, kills performance",
            "alternative": "Use async database drivers and await calls"
        }
    ]
},

"examples": {
    "basic": [...],
    "intermediate": [...],
    "advanced": [...]
},

"integration": {
    "pydantic": {
        "compatibility": "Native integration, Pydantic v2 supported",
        "pattern": "Use BaseModel for all request/response schemas",
        "examples": [...]
    }
},

"version_notes": "FastAPI 0.100.0 requires Pydantic v2.x"

}

undefined

Integration

集成

Used By:

被以下组件使用：

@documentation-researcher (Primary) - Phase 2 sub-agent for documentation research

@documentation-researcher（主要）- 文档研究的第二阶段子Agent

Integrates With:

与以下组件集成：

doc-fetcher skill - Analyzes documentation fetched by doc-fetcher
prp-generator skill (Design Orchestrator) - Analysis feeds into PRP generation

doc-fetcher技能 - 分析由doc-fetcher获取的文档
prp-generator技能（设计编排器）- 分析结果用于PRP生成

Workflow Position:

工作流位置：

doc-fetcher skill fetches documentation (Step 3-4)
doc-analyzer skill analyzes documentation (Step 5-6)
Documentation summary compiled (Step 7)
Design Orchestrator synthesizes into PRP

Version: 2.0.0 Auto-Activation: Yes Phase: 2 - Design & Planning Created: 2025-10-29

doc-fetcher技能获取文档（步骤3-4）
doc-analyzer技能分析文档（步骤5-6）
整理文档摘要（步骤7）
设计编排器合成为PRP

版本： 2.0.0 自动激活： 是 阶段： 2 - 设计与规划 创建时间： 2025-10-29