AI Documentation Generator

Enterprise-grade documentation automation powered by DeepSeek's 671B-parameter AI model.

Overview

The AI Documentation Generator is a VS Code/Cursor extension that automatically analyzes code repositories and generates comprehensive technical documentation using DeepSeek R1T2 Chimera (671B parameter model). Designed for teams requiring always-accurate documentation synchronized with their codebase.

Key Value Proposition

• Zero Manual Effort: Full documentation generation from code analysis
• Continuous Sync: Real-time updates through Git integration
• Multi-Language Intelligence: Sophisticated understanding of 15+ programming languages
• Enterprise Scalability: Handles monorepos and large codebases (>100k LOC)

Target Use Cases

1. API Development: Automatic OpenAPI-compatible documentation
2. Legacy Modernization: Documenting undocumented systems
3. Compliance Requirements: Audit-ready technical documentation
4. Developer Onboarding: Instant project understanding for new team members

Architecture

System Design

graph TD
    A[Code Changes] --> B[File System Watcher]
    B --> C[Language Parser]
    C --> D[AST Analyzer]
    D --> E[Semantic Model Builder]
    E --> F[AI Documentation Engine]
    F --> G[Template Processor]
    G --> H[Markdown Output]
    H --> I[Git Integration]
    
    F <--> J[DeepSeek API]
    style J fill:#4b0082,color:white
    
    classDef component fill:#2d4263,color:white;
    class A,B,C,D,E,F,G,H,I,J component;

Core Components

1. Code Analyzer Engine

• Language Parsers: Abstract Syntax Tree (AST) generators for TypeScript, Python, Java
• Dependency Mapper: Creates import/require dependency graphs
• Pattern Recognizer: Identifies architectural patterns (MVC, Microservices)

2. AI Processing Layer

• Context Builder: Creates optimized prompts from code structure (50-75 tokens/file)
• Model Orchestrator: Manages API calls to DeepSeek R1T2 Chimera with exponential backoff
• Response Validator: Ensures technical accuracy through AST cross-validation

3. Output Generation System

• Template Engine: Mustache-based template processing with partial support
• Version Controller: Git integration with atomic commits
• Format Adapters: Markdown, HTML, and PDF output via Pandoc integration

Data Flow Process

1. File system watcher detects code changes (polling interval: 500ms)
2. Language-specific parser creates enriched AST (supports JSX/TSX)
3. Semantic model extracts architectural relationships (component coupling metrics)
4. AI engine processes code context through 163k token window (chunking strategy: hierarchical)
5. Generated documentation validated against source code (AST node matching)
6. Final output committed via Git with semantic commit messages

Features

Core Capabilities

AI Model Specifications

Advanced Capabilities

• Incremental Updates: Regenerates only changed sections (delta updates)
• Cross-Reference Links: Automatic linking between related components (uses AST identifiers)
• Code Examples: Generates usage examples from function signatures (supports 90%+ use cases)
• Deprecation Warnings: Flags outdated documentation elements through git history analysis

Installation & Setup

System Requirements

• Editor: VS Code v1.85+ or Cursor v0.8+
• Memory: 4GB RAM minimum (8GB recommended for >50k LOC)
• Platform: Windows/Linux/macOS (x64/arm64)
• Dependencies: Git 2.30+, Node.js 18+

Installation Procedure

1. Install Extension

# VS Code
code --install-extension voznyye.auto-documentation-generator

# Cursor
cursor --install-extension voznyye.auto-documentation-generator

2. Configure API Access

# Obtain free API key from OpenRouter
curl -X POST https://openrouter.ai/api/v1/auth/keys \
  -H "Content-Type: application/json" \
  -d '{"email":"your@email.com","application":"DocGenerator"}'

3. Extension Configuration (.vscode/settings.json)

{
  "docGenerator.ai.apiKey": "sk_your_openrouter_key",
  "docGenerator.filePatterns": ["src/**/*.{ts,js,py,java}"],
  "docGenerator.excludePatterns": ["**/node_modules/**", "**/test/**"],
  "docGenerator.output.formats": ["README.md", "ARCHITECTURE.md"],
  "docGenerator.git.autoCommit": true,
  "docGenerator.ai.maxTokens": 12288
}

4. Initialize Documentation

# Via Command Palette (Ctrl+Shift+P)
> AI Doc Generator: Initialize Project Documentation

# Expected output:
# ✔ Analyzed 42 files (15,328 LOC)
# ✔ Generated README.md (2.1 KB)
# ✔ Generated ARCHITECTURE.md (5.7 KB)
# ✔ Committed docs to Git (commit a1b2c3d)

API Reference

Extension Command API

generateProjectDocumentation

/**
 * Generates complete project documentation suite
 * @param {DocumentationConfig} config - Generation parameters
 * @returns {Promise<DocumentationReport>} Generation report
 */
interface DocumentationConfig {
  outputDir?: string;      // Default: './docs'
  template?: 'default' | 'technical' | 'minimal' | string; // Custom template path
  detailLevel?: 'overview' | 'full'; // Detail depth
  forceRefresh?: boolean;  // Bypass cache
}

interface DocumentationReport {
  generatedFiles: string[];
  analysisTime: number;
  tokenUsage: number;
}

// Usage Example:
const report = await vscode.commands.executeCommand(
  'docGenerator.generate', 
  {
    template: 'technical',
    detailLevel: 'full',
    outputDir: './documentation'
  }
);
console.log(report.generatedFiles); // ['README.md', 'ARCHITECTURE.md']

updateDocumentation

/**
 * Performs incremental documentation update
 * @param {UpdateParams} params - Update configuration
 * @returns {Promise<DocumentationDiff>} Change report
 */
interface UpdateParams {
  changedFiles: string[];   // Array of modified file paths
  incremental?: boolean;    // Default: true
}

interface DocumentationDiff {
  updatedFiles: string[];
  deletedFiles: string[];
}

// Usage Example:
const diff = await vscode.commands.executeCommand(
  'docGenerator.update',
  {
    changedFiles: ['src/core/parser.ts'],
    incremental: true 
  }
);
console.log(diff.updatedFiles); // ['README.md', 'API.md']

Configuration API

Configuration

Full Configuration Schema (.docgenrc.json)

{
  "$schema": "./docgen.schema.json",
  "analysis": {
    "depth": "full", // 'module' or 'function'
    "languageOverrides": {
      "typescript": {
        "parserOptions": {
          "jsx": true,
          "experimentalDecorators": true
        }
      }
    }
  },
  "output": {
    "formats": [
      {
        "template": "./templates/README.md.mustache",
        "outputPath": "./README.md"
      },
      {
        "template": "api-reference",
        "outputPath": "./docs/API.md"
      }
    ],
    "diagram": {
      "format": "mermaid",
      "depth": 2 // Relationship depth for diagrams
    }
  },
  "ai": {
    "maxRetries": 3,
    "timeout": 30000,
    "fallbackModel": "claude-3-sonnet"
  }
}

Environment Variables

# Priority order: env vars > config file > defaults
export DOCGEN_API_KEY=sk_your_key_here       # Overrides ai.apiKey 
export DOCGEN_LOG_LEVEL=debug                # error|warn|info|debug 
export DOCGEN_CACHE_DIR=.docgen_cache        # Cache location 
export DOCGEN_MAX_CONCURRENT=5               # Parallel processing threads 

Usage Examples

Basic Generation Workflow

# Generate full documentation suite 
> AI Doc Generator: Generate Project Documentation

# Monitor generation progress in Output panel:
# [info] Analyzing src/ (24 files)
# [info] Generating API documentation...
# [success] Documentation generated in 4.2s 

Custom Template Implementation

<!-- templates/module-overview.mustache -->
## {{moduleName}} 

{{#hasDescription}}
> {{description}} 
{{/hasDescription}}

### Responsibilities 
{{#responsibilities}}
- {{.}}
{{/responsibilities}}

{{#dependencies}}
### Dependencies 
| Module | Interface |
|--------|-----------|
{{#modules}}
| {{name}} | {{interface}} |
{{/modules}}
{{/dependencies}}

CI/CD Integration (GitHub Actions)

name: Documentation Sync

on:
  push:
    branches: [ main ]
    paths: 
      - 'src/**'
      - '.github/workflows/docs.yml'

jobs:
  update-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        
      - name: Generate Documentation 
        uses: voznyye/doc-generator-action@v1
        with:
          api-key: ${{ secrets.DOCGEN_KEY }}
          args: --strict --template=enterprise --output-dir=docs/
          
      - name: Create Pull Request 
        uses: peter-evans/create-pull-request@v5
        with:
          commit-message: "docs: auto-update from ${{ github.sha }}"
          branch: "docs/auto-update"

Advanced Usage - Monorepo Support

// .docgenrc.json 
{
  "monorepo": {
    "packages": ["packages/*", "services/*"],
    "sharedDocsPath": "./common-docs",
    "rootTemplate": "./templates/monorepo-root.md.mustache",
    "dependencyResolution": "hoisted" // 'nested' or 'workspace'
  }
}

Development

Local Setup

1. Clone repository:

   git clone https://github.com/voznyye/AutoDoc.git 
   cd AutoDoc/doc-generator-extension 
   

2. Install dependencies:

   npm install --include=dev 
   

3. Build extension:

   npm run build   # Compile TypeScript 
   npm run package # Create .vsix bundle 
   

Testing Strategy

Unit Tests (Jest):

npm test # Tests core functionality 

Integration Tests:

npm run test:integration # Requires VS Code test instance 

Test Coverage Areas:

1. AST parsing accuracy across languages (>95% coverage per parser)
2. AI prompt generation correctness (golden file comparisons)
3. Git integration workflows (mock git repository tests)

Debugging Workflow

1. Launch VS Code Extension Host:

   npm run debug 
   

2. Set breakpoints in src/analyzer/core.ts or src/ai/engine.ts
3. Use test workspace (test-fixtures/) for live debugging

Troubleshooting

Common Issues & Solutions

Documentation Out of Sync

[warning] Documentation mismatch detected in src/api/module.ts

Solutions:

1. Force revalidation:

   > AI Doc Generator: Validate Documentation --strict 
   

2. Reset documentation cache:

   { "cache": { "enabled": false } } // Add to config 
   

AI Generation Failures

[error] AI Engine Error: Context length exceeded (16384 tokens)

Solutions:

1. Reduce context size through configuration:

   { 
     "ai.maxTokens": 8192,
     "analysis.depth": "module" 
   } 
   

2. Exclude large files via glob patterns:

   { "excludePatterns": ["**/vendor/**", "**/generated/**"] } 
   

Performance Optimization
For repositories >50k LOC:

{
  "cache.enabled": true,
  "analysis.concurrency": 8, // CPU core count
  "ai.chunkStrategy": "hierarchical",
  "fileBatchSize": 50 // Files per AI request
}

FAQ

Q: How does the generator handle private codebases?
A: All processing occurs locally except AI inference calls which use encrypted connections to DeepSeek API

Q: Can I use my own AI models?
A: Yes through OpenRouter configuration - supports any compatible OpenAI API endpoint

Q: What's the maximum repository size supported?
A: Tested up to 250k LOC - performance scales linearly with proper hardware configuration

Contributing

Development Workflow

1. Create feature branch from develop:

   git checkout -b feat/new-parser-engine 
   

2. Implement changes with tests (>80% coverage required):

   npm run test:watch # TDD workflow recommended 
   

3. Submit PR with required artifacts:

   • Technical design document (DESIGN.md)
   • Performance benchmarks (benchmarks/results.md)
   • Updated documentation (docs/**)

Contribution Areas

High Priority Features:

1. WebAssembly-based AST parser (performance critical)
2. OpenAPI/Swagger integration (documentation interoperability)
3. Real-time collaboration features (multi-user editing)

Testing Needs:

• Large-scale performance testing (>1M LOC repositories)
• Edge case language syntax handling (obscure language features)
• Documentation validation test suite (output quality assurance)

License & Credits

License: MIT License
Full Text: LICENSE

Acknowledgments

• DeepSeek Team for R1T2 Chimera model architecture and training
• OpenRouter for enterprise-grade inference infrastructure
• VS Code team for extensibility APIs and testing framework

"Documentation is love made visible."
Generated by DeepSeek-R1-T2-Chimera at {timestamp}

This documentation was automatically generated on August 20, 2025
To update documentation content: AI Doc Generator > Update Documentation