Labsco
PARS-DOE logo

Autodocument

★ 5

from PARS-DOE

Automatically generates documentation for code repositories by analyzing directory structures and code files using the OpenRouter API.

🔥🔥🔥✓ VerifiedAccount requiredAdvanced setup
#automation#scraping#git#security

Autodocument MCP Server

An MCP (Model Context Protocol) server that automatically generates documentation for code repositories by analyzing directory structures and code files using OpenRouter API.

Features

  • Smart Directory Analysis: Recursively analyzes directories and files in a code repository
  • Git Integration: Respects .gitignore patterns to skip ignored files
  • AI-Powered Documentation: Uses OpenRouter API (with Claude 3.7 by default) to generate comprehensive documentation
  • Test Plan Generation: Automatically creates test plans with suitable test types, edge cases, and mock requirements
  • Code Review: Performs senior developer-level code reviews focused on security, best practices, and improvements
  • Bottom-Up Approach: Starts with leaf directories and works upward, creating a coherent documentation hierarchy
  • Intelligent File Handling:
    • Creates documentation.md, testplan.md, and review.md files at each directory level
    • Skips single-file directories but includes their content in parent outputs
    • Supports updating existing files
    • Creates fallback files for directories that exceed limits
  • Progress Reporting: Provides detailed progress updates to prevent timeouts in long-running operations
  • Highly Configurable: Customize file extensions, size limits, models, prompts, and more
  • Extensible Architecture: Modular design makes it easy to add more auto-* tools in the future

Using with Roo or Cline

Roo Code and Cline are AI assistants that support the Model Context Protocol (MCP), which allows them to use external tools like autodocument.

Setup for Roo/Cline

  1. Clone and build the repository (follow the Installation Steps above)

  2. Configure the MCP server:

    For Roo:

    In the MCP Servers menu, Edit the MCP Settings and add the autodocument configuration using the full path to where you cloned the repository:

    Add the autodocument configuration using the full path to where you cloned the repository:

    {
  "mcpServers": {
    "autodocument": {
      "command": "node",
      "args": ["/path/to/autodocument/build/index.js"],
      "env": {
        "OPENROUTER_API_KEY": "your-api-key-here"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

    For Claude Desktop App:

    Edit the Claude desktop app configuration file at:

    • Windows: %APPDATA%\Claude\claude_desktop_config.json
    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Linux: ~/.config/Claude/claude_desktop_config.json

    Add the autodocument configuration using the full path to where you cloned the repository:

    {
  "mcpServers": {
    "autodocument": {
      "command": "node",
      "args": ["/path/to/autodocument/build/index.js"],
      "env": {
        "OPENROUTER_API_KEY": "your-api-key-here"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

  3. Important: Make sure to use absolute paths to the build/index.js file in your cloned repository

  4. Restart Roo/Cline or the Claude desktop app

  5. Use the tool: In a conversation with Roo or Claude, you can now ask it to generate documentation or test plans for your code repository:

    Please generate documentation for my project at /path/to/my/project

    Or for test plans:

    Please create a test plan for my project at /path/to/my/project

    Or for code reviews:

    Please review the code in my project at /path/to/my/project

How It Works

The autodocument server works using a bottom-up approach:

  1. Discovery: Scans the target directory recursively, respecting .gitignore rules
  2. Smart Directory Processing:
    • Identifies directories with multiple code files or subdirectories
    • Skips single-file directories but includes their content in parent documentation
  3. File Analysis: Analyzes code files, filtering by extension and size
  4. Documentation Generation: For each qualifying directory:
    • Reads code files
    • Sends code to OpenRouter API with optimized prompts
    • Creates a documentation.md file (or updates existing one)
  5. Aggregation: As it moves up the directory tree:
    • Processes each parent directory
    • Includes documentation from child directories
    • Creates a comprehensive overview at each level

Architecture

The project follows a modular architecture:

  • Core Components: Configuration management and server implementation
  • Crawler Module: Directory traversal and file discovery
  • Analyzer Module: Code file analysis and filtering
  • OpenRouter Module: AI integration for LLM-based content generation
  • Documentation Module: Orchestration of the documentation process
  • Tools Module: Extensible system for different auto-* tools (documentation, test plans, etc.)
  • Prompts Configuration: Centralized prompt management for easy customization

Customizing Prompts

You can easily customize the prompts used by the tools by editing the src/prompt-config.ts file. This allows you to:

  • Adjust the tone and style of generated content
  • Add specific instructions for your project's needs
  • Modify how existing content is updated

The prompt configuration is separated from the tool implementation, making it easy to experiment with different prompts without changing the code.

Available Tools

generate_documentation

Generates comprehensive documentation for a code repository:

{
  "path": "/path/to/your/project",
  "openRouterApiKey": "your-api-key-here", // Optional
  "model": "anthropic/claude-3-7-sonnet", // Optional
  "updateExisting": true // Optional, defaults to true
}

autotestplan

Generates test plans for functions and components in a code repository:

{
  "path": "/path/to/your/project",
  "openRouterApiKey": "your-api-key-here", // Optional
  "model": "anthropic/claude-3-7-sonnet", // Optional
  "updateExisting": true // Optional, defaults to true
}

autoreview

Generates a senior developer-level code review for a repository:

{
  "path": "/path/to/your/project",
  "openRouterApiKey": "your-api-key-here", // Optional
  "model": "anthropic/claude-3-7-sonnet", // Optional
  "updateExisting": true // Optional, defaults to true
}

Output Files

The server creates several types of output files:

documentation.md

Contains comprehensive documentation of the code in a directory, including:

  • Purpose of the code
  • Key functions and classes
  • Relationships between files
  • Integration with child components

testplan.md

Contains detailed test plans for code in a directory, including:

  • Appropriate test types (unit, integration, e2e) for each function
  • Common edge cases to test
  • Dependency mocking requirements
  • Integration testing strategies

review.md

Contains senior developer-level code review feedback, including:

  • Security issues and vulnerabilities
  • Best practice violations
  • Potential bugs or architectural concerns
  • Opportunities for refactoring
  • Practical, constructive feedback (not nitpicking style issues)

Fallback Files

Created when a directory exceeds size or file count limits:

  • undocumented.md - For documentation generation
  • untested.md - For test plan generation
  • review-skipped.md - For code review generation

These files contain:

  • Reason for skipping processing
  • List of files that were analyzed and excluded
  • Instructions on how to fix (increase limits or manually create content)