ArchiLens

AI-powered layered architecture & process flow visualization for Git repositories.

ArchiLens analyses your codebase and generates interactive, hierarchical architecture diagrams — from system-level context down to runtime process flows. Think of it as Google Maps for codebases: zoom from continents (system architecture) to cities (class-level components).

🌐 Website: https://saurabh-oss.github.io/archilens/
📦 Repository: https://github.com/saurabh-oss/archilens

How ArchiLens Compares

_{Based on each project's README and docs as checked in October 2026. ✗ means we found no mention of the capability. Corrections welcome — please open an issue.}

Language support: imports are resolved to files in the repository for Python (flat and src/ layouts, relative imports), JavaScript/TypeScript (relative paths, tsconfig path aliases, npm/yarn/pnpm workspace packages), Java (packages, wildcard and static imports) and Go (module paths). Other languages are discovered and counted, but get no dependency edges yet.

Diagram Levels

L0: System Context         ← Your system as a black box + external actors
L1: Module Architecture    ← Major modules/services + dependencies
L2: Component Detail       ← Classes, interfaces inside a module
L3: Process Flows          ← Runtime request lifecycles (AI-inferred)

Quick Start

Prerequisites

• Python 3.10+
• Git
• (Optional) Anthropic API key for AI features

Installation

# From PyPI
pip install archilens

# With the interactive web viewer and/or the MCP server
pip install "archilens[viewer,mcp]"

# From source (development)
git clone https://github.com/saurabh-oss/archilens.git
cd archilens
python -m pip install -e ".[dev,viewer,mcp]"

Windows note: If pip is blocked by policy, use python -m pip install instead.

Initialize in Your Repository

cd /path/to/your/repo
python -m archilens init

This writes an annotated example .archilens.yml (its capabilities, external systems and rules describe a fictional order-management system, so replace them). Edit it to:

• Map modules to business capabilities
• Define entry points for process flow tracing
• Configure external systems for the L0 context diagram
• Set architecture rules for CI enforcement

Generate Diagrams

# Full analysis, with AI summaries if Anthropic credentials are available
# (ANTHROPIC_API_KEY or `ant auth login`). Without them, ArchiLens prints one
# warning and runs the static analysis only.
python -m archilens analyze --repo .

# Static analysis only, never calls an LLM
python -m archilens analyze --repo . --no-ai

# Generate only a specific level
python -m archilens analyze --repo . --level 1

# Choose output format: mermaid (default), d2, or plantuml
python -m archilens analyze --repo . --format d2

# Output as JSON (for programmatic use)
python -m archilens analyze --repo . --json-output > snapshot.json

Interactive Web Viewer

python -m archilens serve --repo . --port 8765

Requires the viewer extra (pip install "archilens[viewer]"). Opens a dark-themed single-page app at http://127.0.0.1:8765. It binds to loopback by default; --host 0.0.0.0 exposes it to your network, and the viewer has no authentication, so only do that on a trusted network. It includes:

• Sidebar navigation across all four diagram levels
• Click any module in the L1 diagram to drill into its L2 component view
• Zoom controls (−/+/Fit/1:1), mouse-wheel zoom, and click-drag pan
• Search/filter sidebar for large repos
• Live re-analysis without restarting the server

Architecture Drift Detection

# Compare current branch against main
python -m archilens diff --base main --head HEAD

# Write the diff report to a file
python -m archilens diff --base v1.0 --head v2.0 --output drift.md

Evolution Timeline

# Analyse architecture across all semver tags
python -m archilens history --repo . --tags

# Analyse specific refs
python -m archilens history --repo . --refs "v1.0,v1.5,v2.0,HEAD"

Produces a Mermaid timeline diagram and a full markdown evolution report showing module additions, removals, and LOC trends across your git history.

MCP Server for AI Coding Agents

ArchiLens can serve its architecture model to coding agents (Claude Code, Cursor and other MCP clients), so an agent can check where code belongs and whether a new import is allowed before it edits.

pip install "archilens[mcp]"

# Register with Claude Code (stdio transport)
claude mcp add archilens -- archilens serve-mcp --repo /path/to/repo

# Or run as an HTTP/SSE endpoint (binds to 127.0.0.1 by default)
archilens serve-mcp --repo /path/to/repo --transport sse --port 8766

The server re-analyses automatically when the repository changes: a new commit, uncommitted edits, a change to .archilens.yml, or an ArchiLens upgrade. Snapshots of clean work trees are cached in ~/.archilens/snapshots.db; --refresh clears the cache for the repository.

Configuration Reference

The .archilens.yml file controls all analysis behaviour.

Project

project:
  name: "My Application"
  description: "What this system does"
  type: "microservices"  # monolith | microservices | modular-monolith | library

Analysis

analysis:
  languages: ["python", "typescript"]  # Auto-detected if omitted

  entry_points:
    - pattern: "**/*controller*.py"
      type: "http_handler"
    - pattern: "**/routes/**/*.ts"
      type: "http_handler"

  exclude:
    - "**/node_modules/**"
    - "**/__pycache__/**"
    - "**/venv/**"

  module_depth: 2   # directory levels below a source root that name a module

How files are grouped into modules

A module is a directory. ArchiLens first finds the source roots: the repository root, Python source roots such as src/, JVM roots such as src/main/java, directories with a go.mod, and JS/TS workspace packages (directories with their own package.json). Below a root it skips directories that contain no files and only one subdirectory, such as Java's com/acme/shop or a lone src/<package>, and the next module_depth levels name the module. Each workspace package is a single module.

Files ignored by .gitignore, and files under test/, tests/, __tests__/, spec/, e2e/ or testdata/, are not part of any module.

Business Capability Mapping

capabilities:
  - name: "Order Management"
    description: "Order lifecycle from creation to fulfillment"
    modules:
      - "src/orders/**"
      - "services/order-service/**"

  - name: "Payment Processing"
    modules:
      - "src/payments/**"

External Systems

external_systems:
  - name: "PostgreSQL"
    type: "database"
    description: "Primary data store"

  - name: "Stripe API"
    type: "external_api"
    description: "Payment processing"

Diagram Output

diagrams:
  output_dir: ".archilens/diagrams"
  format: "mermaid"   # mermaid | d2 | plantuml
  levels:
    - { level: 0, enabled: true }
    - { level: 1, enabled: true }
    - { level: 2, enabled: true }
    - { level: 3, enabled: true }

AI Configuration

ai:
  provider: "anthropic"        # anthropic | openai | ollama | litellm
  model: "claude-opus-5-5"     # cheaper option for one-line summaries: "claude-haiku-5-5"
  effort: "low"                # Claude 5 models: low | medium | high | xhigh | max (null = model default)
  cache: true                  # reuse answers for unchanged input (~/.archilens/ai_cache.db)
  features:
    process_flow_inference: true
    node_annotations: true         # reserved, not used yet
    capability_suggestions: true   # reserved, not used yet
    pattern_detection: true
    module_summaries: true

What is sent to the model.

• Module summaries: each module's name, class names and dependencies, plus a signature outline of its largest files (class, function and type declarations only, no bodies, capped at about 6,000 characters).
• Process flows: the source of each configured entry-point file, truncated to 15,000 characters.
• Pattern detection: the module dependency list and a directory tree.

Answers are cached by a hash of the model, effort, schema and prompt, so unchanged modules cost nothing on the next run and their summaries don't change wording. For modules with no configured capability, the AI's capability suggestion is shown in analyze output and the MCP get_module_context tool as a suggestion; it is never assigned, because capabilities drive CI rules.

CI Rules

ci:
  fail_on: "new"            # new (default): only violations a PR introduces fail | all
  rules:
    - name: "ui-skips-domain"
      type: "forbidden-dependency"
      from: "src/presentation/**"
      to: "src/infrastructure/**"
      action: "fail"        # warn | fail

    - name: "payments-independent-of-identity"
      type: "forbidden-dependency"
      from_capability: "Payment Processing"   # capabilities come from the `capabilities` section
      to_capability: "User Management"
      action: "fail"

    - name: "acyclic-modules"
      type: "no-cycles"
      action: "warn"

    - name: "small-surface"
      type: "max-fan-out"
      threshold: 10
      action: "warn"

Patterns are matched against module paths, and dir/** also matches dir itself. A rule with an unknown or missing type, or without the fields its type needs, is a configuration error. (Rules named no-layer-skip or max-fan-out without a type keep working, as in earlier versions.)

Existing violations don't fail pull requests. archilens diff evaluates the rules on both refs: violations already present on the base ref are listed as existing (folded in the PR comment), and only new ones count. So a rule can be adopted on a codebase that breaks it today, and PRs that make things worse still fail. Set fail_on: "all" to fail on every violation of a fail rule.

To check the working tree without a diff (locally, or in a pre-commit hook):

archilens check --repo .            # exit 1 if any rule with action: "fail" is violated
archilens check --repo . --json-output

GitHub Actions Integration

Using the ArchiLens action

The composite action runs the analysis, posts (and on later pushes, updates) one architecture-diff comment per pull request, and uploads the diagrams as a workflow artifact. The comment opens with a Mermaid diagram of just the modules and dependencies the PR changes (new, removed, resized, and any new dependency that breaks a rule), followed by the full change table and rule results:

# .github/workflows/architecture.yml
name: Architecture
on:
  pull_request:

permissions:
  contents: read
  pull-requests: write   # to post the PR comment

jobs:
  archilens:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0   # the diff needs the base commit
      - uses: saurabh-oss/archilens/github_action@v0.6.2
        with:
          enable-ai: "false"           # deterministic, no API key needed
          fail-on-violations: "true"   # fail the job on rules with action: "fail"

Outputs: diagrams-path, has-changes, violations-count. The report is also written to the job summary. On pull requests from forks, GitHub gives the workflow a read-only token, so the comment can't be posted; the action logs a warning and carries on.

Writing the workflow yourself

Or add this workflow to your repository:

# .github/workflows/archilens.yml
name: Architecture Analysis
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

permissions:
  contents: write
  pull-requests: write

jobs:
  architecture:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - uses: actions/setup-python@v7
        with:
          python-version: "3.12"

      - run: pip install archilens

      - name: Generate Diagrams
        if: github.event_name == 'push'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: python -m archilens analyze --repo . --output .archilens/diagrams

      - name: Commit Diagrams
        if: github.event_name == 'push'
        run: |
          git config user.name "ArchiLens Bot"
          git config user.email "archilens[bot]@users.noreply.github.com"
          git add .archilens/diagrams/
          git diff --cached --quiet || git commit -m "docs: update architecture diagrams [skip ci]"
          git push

      - name: PR Drift Detection
        if: github.event_name == 'pull_request'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: python -m archilens diff --base origin/${{ github.base_ref }} --head HEAD

Architecture of ArchiLens Itself

archilens/
├── archilens/                    # Core Python package
│   ├── __init__.py
│   ├── __main__.py               # Enables python -m archilens
│   ├── cli.py                    # Click CLI with Rich output (the only top-level module)
│   ├── config/                   # YAML config loader, defaults and validation
│   ├── engine/                   # Main orchestrator pipeline
│   ├── rules/                    # Architecture rule engine (forbidden deps, cycles, fan-out)
│   ├── models/
│   │   └── __init__.py           # Pydantic models (ArchSnapshot, nodes, edges, flows)
│   ├── analyzers/
│   │   ├── discovery.py          # File discovery + language detection
│   │   ├── dependencies.py       # Static analysis (imports, classes, call graph)
│   │   ├── treesitter.py         # Tree-sitter AST extraction (Python/JS/TS/Java/Go)
│   │   ├── diff.py               # Architecture diff engine
│   │   ├── evolution.py          # Git history evolution & timeline
│   │   └── git_utils.py          # Git ref checkout via blob reading
│   ├── generators/
│   │   ├── base.py               # DiagramGenerator ABC + factory
│   │   ├── mermaid.py            # Mermaid.js output (L0-L3)
│   │   ├── d2.py                 # D2 output (L0-L3)
│   │   └── plantuml.py           # PlantUML output (L0-L3)
│   ├── viewer/
│   │   ├── __init__.py
│   │   └── app.py                # Flask SPA with zoom/pan, drill-down
│   ├── mcp/
│   │   ├── server.py             # MCP server: architecture tools for coding agents
│   │   └── cache.py              # SQLite snapshot cache
│   ├── ai/
│   │   └── __init__.py           # LLM integration (Anthropic/OpenAI/Ollama)
│   ├── utils/
│   │   └── __init__.py           # Module glob matching
│   └── templates/
│       └── archilens.example.yml # Annotated config written by `archilens init`
├── docs/
│   └── index.html                # GitHub Pages landing site
├── scripts/
│   └── render_check.py           # Renders every diagram format with the official tools (CI)
├── github_action/
│   └── action.yml                # Composite GitHub Action
├── tests/                        # pytest suite (CLI, analysis, generators, MCP, viewer)
├── .archilens.yml                # ArchiLens's own architecture rules, checked on every PR
├── .github/workflows/
│   ├── ci.yml                    # Tests, Ruff, mypy
│   ├── publish.yml               # PyPI release on v*.*.* tags
│   └── archilens.yml             # Runs the ArchiLens action on ArchiLens's own PRs
├── pyproject.toml                # Project metadata + dependencies
└── README.md

Pipeline Flow

  .archilens.yml          Source Code           Git History
       │                      │                      │
       ▼                      ▼                      ▼
  ┌──────────┐      ┌──────────────────┐     ┌────────────┐
  │  Config   │      │    Discovery     │     │  Git Utils │
  │  Loader   │      │  (Tree-sitter)   │     │ (evolution │
  └────┬─────┘      └───────┬──────────┘     │  + diff)   │
       │                    │                └─────┬──────┘
       ▼                    ▼                      │
  ┌─────────────────────────────────────────────────────────┐
  │                    Analysis Engine                       │
  │  ┌─────────────┐  ┌──────────────┐  ┌───────────────┐  │
  │  │   Static    │  │     AI       │  │   Metrics &   │  │
  │  │  Analysis   │  │  Augmentation│  │   Patterns    │  │
  │  └──────┬──────┘  └──────┬───────┘  └───────┬───────┘  │
  │         └────────┬────────┘──────────────────┘          │
  └──────────────────┼──────────────────────────────────────┘
                     ▼
              ┌──────────────┐
              │ ArchSnapshot │  (Pydantic: nodes + edges + flows)
              └──────┬───────┘
                     │
       ┌─────────────┼──────────────┐
       ▼             ▼              ▼
  ┌─────────┐  ┌──────────┐  ┌──────────┐
  │Mermaid  │  │    D2    │  │ PlantUML │
  │  (L0-3) │  │  (L0-3)  │  │  (L0-3)  │
  └────┬────┘  └──────────┘  └──────────┘
       │
       ▼
  ┌──────────┐   ┌──────────┐   ┌──────────┐
  │ Web      │   │   Diff   │   │   JSON   │
  │ Viewer   │   │  Report  │   │  Export  │
  └──────────┘   └──────────┘   └──────────┘

Development Setup

# Clone the repository
git clone https://github.com/saurabh-oss/archilens.git
cd archilens

# Create virtual environment
python -m venv .venv
source .venv/bin/activate   # Linux/Mac
# .venv\Scripts\activate    # Windows

# Install with dev dependencies (viewer and mcp extras are needed by the tests and mypy)
python -m pip install -e ".[dev,viewer,mcp]"

# Run tests
pytest tests/ -v --cov=archilens

# Lint
ruff check archilens/
ruff format --check archilens/
mypy archilens/

Roadmap

• Core static analysis engine (multi-language via Tree-sitter + regex fallback)
• L0-L3 Mermaid diagram generation
• D2 and PlantUML output formats
• AI-powered process flow inference and module summaries
• Architecture drift detection (diff engine with CI rules)
• Git history evolution timeline (archilens history)
• GitHub Action for CI/CD
• Business capability mapping
• CLI with Rich output (analyze, diff, check, history, serve, serve-mcp, init)
• MCP server for AI coding agents (archilens serve-mcp)
• Interactive web viewer with zoom/pan and click-to-drill-down
• GitHub Pages landing site
• PyPI release (pip install archilens)
• Per-language import resolution: JS/TS relative and path-alias imports, workspace packages, Java packages, Go module paths, Python src/ layouts
• Rule types decoupled from rule names, capability-level rules, and a violation baseline so only new violations fail CI
• VS Code extension
• GitHub App (persistent bot with richer PR integration)
• Monorepo support (multi-service cross-repo analysis)
• OpenTelemetry integration (runtime architecture from traces)

Contributing

Contributions are welcome! Key areas:

1. Language parsers — Add Tree-sitter grammars for more languages (Ruby, Rust, C#, etc.)
2. Pattern detection — Expand the set of recognized architectural patterns (CQRS, Saga, etc.)
3. VS Code extension — TypeScript extension surfacing L2/L3 diagrams inline
4. GitHub App — Probot/Node.js app for persistent PR bot integration

License

MIT — see LICENSE.