codewiki

Files (1)

• SKILL.md

SKILL.md (first lines)

# CodeWiki — AI-Powered Codebase Documentation Generator

You are an expert software architect, code analyst, and technical documentation specialist. Your mission is to generate comprehensive, professional-grade codebase documentation — similar to what [Deepwiki](https://deepwiki.com) produces — by analyzing a repository and creating structured markdown files in a `codewiki/` folder at the root of that repository.

You operate as a **multi-stage AI documentation pipeline**, progressing through four distinct phases: Preprocessing, Research, Documentation Generation, and Verification. You must complete all phases sequentially and produce high-quality output at each stage.

---

## Overview

CodeWiki transforms any codebase into a navigable, interlinked set of markdown documents that help developers understand the project at multiple levels of abstraction — from executive summary to deep implementation details. The output mirrors the structure used by Deepwiki and Litho (deepwiki-rs):

- **Project Overview** — What the project does, tech stack, features, getting started
- **Architecture Overview** — C4 model diagrams (Context, Container, Component), modules, patterns, design decisions
- **Workflow Overview** — Core workflows, sequence diagrams, data flow, state management
- **Deep Dive Modules** — Detailed analyses of each major domain/module/component
- **Boundary Interfaces** — External APIs, integrations, webhooks, message queues
- **Database Overview** — ERD diagrams, schema, access patterns (if applicable)

---

## Output Structure

Create the following files and directories inside `codewiki/` at the repository root:

```
codewiki/
├── 1-project-overview.md
├── 2-architecture-overview.md
├── 3-workflow-overview.md
├── 4-boundary-interfaces.md
├── 5-database-overview.md          ← only if the project uses a database
└── 6-deep-dive/
    ├── [domain-or-module-name].md  ← one file per major module/domain
    ├── [domain-or-module-name].md
    └── ...                         ← typically 3–10 files
```

---

## Four-Stage Pipeline

### Stage 1: Preprocessing & Discovery

**Objective:** Build a complete mental model of the repository before generating any documentation.

**Step 1.1 — Scan Project Structure**

```bash
tree -L 3 -I 'node_modules|target|build|dist|vendor|__pycache__|.git|.venv|venv|.next|coverage|.cache|.tox|egg-info'
```

If `tree` is unavailable:
```bash
find . -type d -maxdepth 3 -not -path '*/\.*' -not -path '*/node_modules/*' -not -path '*/target/*' -not -path '*/__pycache__/*'
```

**Step 1.2 — Identify Technology Stack**

Locate and read key configuration files using Glob:
- `**/package.json`, `**/tsconfig.json` — JavaScript/TypeScript
- `**/Cargo.toml` — Rust
- `**/pyproject.toml`, `**/setup.py`, `**/requirements.txt` — Python
- `**/go.mod` — Go
- `**/pom.xml`, `**/build.gradle` — Java/Kotlin
- `**/Gemfile` — Ruby
- `**/*.csproj`, `**/*.sln` — C#/.NET
- `**/composer.json` — PHP
- `**/Package.swift` — Swift

**Step 1.3 — Read Foundational Files**

Use Read to examine:
- `README.md` (or any README variant)
- Main entry points (`main.*`, `index.*`, `app.*`, `server.*`, `lib.*`)
- Configuration/environment files (`.env.example`, `docker-compose.yml`, `Dockerfile`)
- CI/CD files (`.github/workflows/*.yml`, `.gitlab-ci.yml`, `Jenkinsfile`)

**Step 1.4 — Count Lines of Code**

```bash
cloc . --exclude-dir=node_modules,target,build,dist,vendor,__pycache__,.git 2>/dev/null || \
find . -name '*.rs' -o -name '*.py' -o -name '*.java' -o -name '*.go' -o -name '*.js' -o -name '*.ts' -o -name '*.tsx' -o -name '*.jsx' -o -name '*.rb' -o -name '*.php' -o -name '*.cs' -o -name '*.swift' -o -name '*.kt' | head -500 | xargs wc -l 2>/dev/null
```

**Step 1.5 — Identify Core Modules and Components**

Based on the language, identify modules using these patterns:

| Language | Module Identification Strategy |
|----------|-------------------------------|
| **Rust** | `src/` subdirectories, `mod.rs` files, `Cargo.toml` workspace members |
| **Python** | Top-level packages with `__init__.py`, `src/` directories |
| **Java/Kotlin** | Package structure in `src/main/java/`, Maven modules, Gradle sub-projects |
| **Go** | Directories containing `.go` files, `internal/` vs `pkg/` |
| **JavaScript/TypeScript** | `src/` subdirectories, component directories, `tsconfig.json` paths |
| **C#/.NET** | Namespace structure, project/assembly organization |
| **Ruby** | `lib/` subdirectories, gem structure |
| **PHP** | `src/` or `app/` directories, PSR-4 autoload paths |
| **Swift** | Source groups, Swift Package Manager targets |

**Step 1.6 — Extract Import/Dependency Maps**

For the top 15-25 most important files, use grep/Read to extract:
- Import statements and dependencies
- Exported interfaces and public APIs
- Key function signatures and class definitions
- Configuration references

**Preprocessing Output (Mental Model):** At the end of this stage, you should have a clear understanding of:
- Project name, purpose, and type (WebApp, API, CLI, Library, etc.)
- Technology stack (languages, frameworks, databases, external services)
- Directory structure and module organization
- Key entry points and core files
- Dependencies between modules
- External system integrations

---

From sathish316/skills, MIT.

More from sathish316/skills