A CLI tool that reads codebases and generates Mermaid diagrams. Supports Rust, Go, and TypeScript.

• Three diagram types: class diagrams, ER diagrams, ZenUML sequence diagrams
• Three languages: Rust, Go, TypeScript — parsed via tree-sitter for fast, accurate AST extraction
• Automatic language detection from file extensions
• Single binary — no runtime dependencies on language toolchains

Field types are analyzed to infer relationships with cardinality:

Requires a Rust toolchain (1.70+) and a C compiler (for tree-sitter grammar compilation).

cargo install --path .

Or build from source:

cargo build --release
./target/release/code-documenter --help

code-documenter [OPTIONS] <PATH>

Arguments:
  <PATH>  Path to source file or directory to analyze

Options:
  -d, --diagram <DIAGRAM>    Diagram type: class, er, zenuml  [default: class]
  -l, --language <LANGUAGE>  Force language: rust, go, type-script  [default: auto]
  -e, --entry <ENTRY>        Entry function for ZenUML sequence diagrams
  -o, --output <OUTPUT>      Output file (defaults to stdout)

Generate a class diagram from a Rust project:

code-documenter ./src -d class

Generate an ER diagram from a single file:

code-documenter ./src/model.rs -d er

Generate a ZenUML sequence diagram:

code-documenter ./src -d zenuml

Write output to a file:

code-documenter ./src -d class -o diagram.mmd

Force a specific language:

code-documenter ./lib -d class -l type-script

Running code-documenter on a Rust file with a few structs produces:

classDiagram
    class User {
        <<Struct>>
        +String name
        -i32 age
        +List~Order~ orders
        +get_name() String
    }
    class Order {
        <<Struct>>
        +i32 id
        +String status
    }
    User *-- Order : orders

ER diagram output:

erDiagram
    User {
        String name
        i32 age
        List~Order~ orders
    }
    Order {
        i32 id PK
        String status
    }
    User ||--|{ Order : "orders"

src/
  main.rs              CLI entry point (clap)
  lib.rs               Orchestration: walk files -> parse -> merge -> emit
  model.rs             Internal IR (CodeModel, Entity, Function, Relationship)
  parse/
    mod.rs             Language detection and parser dispatch
    rust.rs            tree-sitter-rust parser
    go.rs              tree-sitter-go parser
    typescript.rs      tree-sitter-typescript parser
  emit/
    mod.rs             Diagram type dispatch
    class_diagram.rs   Mermaid classDiagram renderer
    er_diagram.rs      Mermaid erDiagram renderer
    zenuml.rs          Mermaid zenuml renderer

The pipeline is: source files -> tree-sitter AST -> CodeModel IR -> Mermaid string.

Each language parser produces a CodeModel containing entities (structs, classes, interfaces), functions, and relationships. Multiple files are parsed independently and merged. The emitter then renders the merged model into the requested Mermaid diagram format.

• Call graph resolution (ZenUML) is syntactic, not semantic — function calls are matched by name, not by full qualification. Cross-module calls may not resolve correctly.
• Generics are captured structurally but complex generic bounds or where clauses are simplified.
• Go interfaces — implicit interface satisfaction is not detected; only explicit embedding is tracked.
• TypeScript — decorators, namespaces, and complex mapped/conditional types are not parsed.

MIT