deep-wiki

Files (1)

• SKILL.md

SKILL.md (first lines)

# Deep Wiki - Codebase Documentation Generator

## Overview

This skill guides you in creating comprehensive, navigable documentation for any codebase, similar to what [DeepWiki.com](https://deepwiki.com) provides. The documentation is saved to a `.docs/` directory in HTML or Markdown format, analyzing code structure, extracting relationships, and creating an interactive wiki.

**Note:** This is a methodology skill that guides you through the documentation generation process. It does not provide a command-line tool. Instead, you will analyze the codebase and create documentation manually or with the help of existing documentation tools.

## When to Use

Use this skill when:

- Documenting a new or existing codebase
- Creating architecture documentation
- Generating wiki pages for a project
- The user mentions "deep wiki", "codebase documentation", or "generate docs"
- Onboarding new team members who need codebase understanding
- Preparing project handoff documentation

## Output Structure

```
.docs/
├── index.html (or index.md)
├── architecture/
│   ├── overview.html
│   ├── components.html
│   ├── data-flow.html
│   └── dependencies.html
├── modules/
│   ├── module-name/
│   │   ├── overview.html
│   │   ├── api.html
│   │   └── examples.html
├── api/
│   ├── endpoints.html (for APIs)
│   └── reference.html
├── guides/
│   ├── getting-started.html
│   ├── development.html
│   └── deployment.html
└── assets/
    ├── diagrams/
    └── images/
```

**Important:** Generated documentation should use [Mermaid](https://mermaid.js.org/) diagrams for all visualizations. Mermaid renders flowcharts, sequence diagrams, class diagrams, entity relationship diagrams, Gantt charts, and more directly in Markdown/HTML.

## Documentation Generation Process

### Phase 1: Codebase Analysis

1. **Scan Project Structure**
   - Identify main directories and their purposes
   - Detect project type (library, application, API, etc.)
   - Find configuration files (package.json, requirements.txt, Cargo.toml, etc.)
   - Identify entry points and main modules

2. **Extract Code Structure**
   - Parse source files for classes, functions, modules
   - Extract type definitions and interfaces
   - Identify dependencies between modules
   - Map import/export relationships

3. **Analyze Relationships**
   - Build dependency graph
   - Identify core components vs utilities
   - Detect architectural patterns (MVC, microservices, monorepo, etc.)
   - Find circular dependencies

### Phase 2: Documentation Generation

1. **Architecture Documentation**

   ````markdown
   # Architecture Overview

   ## System Design

   [High-level description of the system]

   ## Components

   - **Component A**: [Description]
   - **Component B**: [Description]

   ## Data Flow

   ```mermaid
   flowchart LR
       Client[Client] --> API[API Server]
       API --> Services[Services]
       Services --> Database[(Database)]
       API --> Cache[(Cache)]
   ```
   ````

   ## Dependencies

   ```mermaid
   graph TD
       A[Main App] --> B[Auth Module]
       A --> C[API Module]
       A --> D[Database Module]
       B --> C
       C --> D
   ```

   ```

   ```

2. **Module Documentation**

   ````markdown
   # Module: [module-name]

   ## Overview

From ntk148v/skills, MIT.

More from ntk148v/skills