Your AI is flying blind

Every new chat, every new prompt — your AI tool forgets your entire codebase. The result? Hallucinated imports, broken refactors, and thousands of tokens wasted re-scanning files it already saw.

Depwire fixes this.

The context layer that turns vibe coding into software engineering. Deterministic dependency graph. Not probabilistic guessing.

8 CLI commands. 16 MCP tools. 13 auto-generated documents. What If simulation. Architecture health scoring.

40%

fewer tool calls

56%

fewer file reads

100%

deterministic accuracy

2.3s

to parse 350 files

Install in 10 seconds View on GitHub

Depwire visualizing the Hono framework — 305 files, 5,636 symbols, 1,565 edges

The Real Cost

Lost Context = Wasted Tokens

AI tools scan your entire codebase every session. Hundreds of files, thousands of tokens, just to understand what they already knew 5 minutes ago.

Blind Refactoring = Broken Code

Rename a function without knowing every downstream consumer? That's how you ship bugs at 2am. AI tools guess at dependencies — Depwire knows them.

New Chat = Starting Over

Every new conversation with Claude or Cursor starts from zero. No memory of your architecture, no knowledge of what connects to what. You re-explain your codebase every single time.

Give your AI tools a map of your entire codebase

Depwire parses your code, builds a dependency graph, and serves it to AI tools via MCP. No more guessing.

🔍

Parse

tree-sitter extracts every symbol and reference

🕸️

Graph

graphology builds an in-memory dependency graph

🤖

Query

AI tools query the graph via MCP for context-aware answers

🎨

Visualize

D3.js renders interactive arc diagrams in your browser

Built for Modern Development

🎨

Beautiful Visualization

See your entire architecture at a glance. Interactive arc diagrams that make dependencies visible, not hidden in import statements.

🤖

AI Context Engine

16 MCP tools that give Claude, Cursor, and any AI assistant full dependency context. Your AI never flies blind again.

💥

Impact Analysis

Renaming a function? Moving a file? Upgrading a dependency? Know the full blast radius — 2-3 levels deep — before you change a single line.

🌍

Multi-Language

TypeScript, JavaScript, Python, Go, Rust, and C. Mixed-language monorepos supported. Tree-sitter parsing for deterministic accuracy.

⚡

Zero Config

One command: npm install -g depwire-cli. No databases, no cloud accounts, no Docker. Everything runs locally, everything stays private.

🔄

Live Updates

Edit a file and the graph updates automatically. No re-indexing, no cache invalidation. Always see the current state of your architecture.

📄

Auto-Generated Documentation

One command generates architecture docs, coding conventions, dependency maps, and onboarding guides — all from your dependency graph. Zero manual writing.

⏳

Temporal Graph

Visualize how your codebase architecture evolved over git history. Scrub through time with an interactive timeline slider.

🧹

Dead Code Detection

Find unused symbols before they become technical debt. Confidence-based scoring with smart exclusion rules for entry points, test files, and barrel exports.

High / medium / low confidence classification
CI-ready JSON output
Integrated health score impact
MCP tool: find_dead_code

🔮

What If Simulation

Simulate moving, deleting, or renaming files before touching code. See the full blast radius, broken imports, and health score delta — before your AI makes a single change.

Health score delta (before/after)
Broken import detection
Circular dependency analysis
CLI: depwire whatif

Track Your Codebase Evolution Over Time

See how your architecture grew, morphed, and evolved across git history.

Depwire temporal graph showing Hono framework evolution

Depwire temporal visualization — Scrub through time, watch arcs morph, see files added and removed

Documentation from Your Dependency Graph

One command. Thirteen comprehensive documents. Generated from your actual code structure, not guesses.

🏗️

ARCHITECTURE.md

Module structure, entry points, hub files, layer analysis, and circular dependency detection with suggested fixes.

📐

CONVENTIONS.md

Naming patterns, import/export style, and design patterns detected automatically from your actual code.

🔗

DEPENDENCIES.md

Module dependency matrix, high-impact symbols, longest dependency chains, and tightly coupled file pairs.

🗺️

ONBOARDING.md

Recommended reading order (Foundation → Core → Entry Points), module map, key concepts, and high-impact file warnings.

📁

FILES.md

Complete file catalog with stats, orphan files detection, and hub files that break the most things when changed.

🔌

API_SURFACE.md

All exported symbols (public API), most-used exports, unused exports, and barrel file analysis.

⚠️

ERRORS.md

Error handling patterns, error-prone files, custom error classes, and recommendations for improvement.

🧪

TESTS.md

Test file inventory, test-to-source mapping, untested files prioritized by risk, and coverage stats.

📜

HISTORY.md

Git history + graph analysis: file churn, feature timeline, contributors, and development hotspots.

📸

CURRENT.md

Complete codebase snapshot — every file, every symbol, every connection. The exhaustive reference.

✅

STATUS.md

TODO/FIXME/HACK inventory with priority matrix. Shows what's implemented vs pending, prioritized by impact.

🏥

HEALTH.md

Architecture health score report — coupling, cohesion, circular dependencies, god files, orphans, and depth analysis with improvement recommendations.

🪦

DEAD_CODE.md

Unused symbol inventory with confidence classification. High, medium, and low confidence dead code with smart exclusion rules for entry points and test files.

Generate Documentation
depwire docs --verbose --stats

Tested on Hono (352 files, 6,072 symbols) — generates all 13 documents in under 0.3 seconds.

Tested on real-world projects

Project	Language	Files	Symbols	Time
Hono	TypeScript	305	5,636	2.3s
Excalidraw	TypeScript/React	320	—	< 3s
FastAPI	Python	47	—	< 1s
Express	JavaScript	6	—	< 1s
Cobra	Go	19	—	< 1s

Zero parse errors. Zero configuration. Every project, first try.

Install in 10 seconds

NPM Install
npm install -g depwire-cli
CLI Usage
# Auto-detects project root from current directory
depwire viz
depwire parse
depwire docs
depwire health
depwire whatif

# Or specify a directory explicitly
npx depwire-cli viz ./my-project
npx depwire-cli parse ./my-project

# Exclude test files and node_modules
npx depwire-cli parse --exclude "**/*.test.*" "**/node_modules/**"
Claude Desktop Config
// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "depwire": {
      "command": "npx",
      "args": ["-y", "depwire-cli", "mcp"]
    }
  }
}

// Depwire auto-detects your project root. No path configuration needed.
Then in chat
Show me the architecture.

16 MCP Tools for AI Assistants

Depwire isn't just a visualizer. It's a full context engine with 16 tools that AI assistants call autonomously based on your questions.

Tool	What It Does
`connect_repo`	Connect to any local project or GitHub repo
`impact_analysis`	What breaks if you change a symbol?
`get_file_context`	Full context — imports, exports, dependents
`get_dependencies`	What does a symbol depend on?
`get_dependents`	What depends on this symbol?
`search_symbols`	Find symbols by name
`get_architecture_summary`	High-level project overview
`list_files`	List all files with stats
`get_symbol_info`	Look up any symbol's details
`visualize_graph`	Generate interactive arc diagram visualization
`get_project_docs`	Retrieve auto-generated codebase documentation
`update_project_docs`	Regenerate documentation on demand
`get_health_score`	Architecture health score across 6 dimensions
`get_temporal_graph`	Visualize how your codebase evolved over git history
`find_dead_code`	Find unused symbols with confidence-based scoring
`simulate_change`	Simulate architectural changes before touching code

PR Impact Analysis

See the impact of every PR before you merge

🔀

Automatic Dependency Impact Reports

The Depwire GitHub Action runs on every pull request and posts an automatic dependency impact report. Know exactly which symbols break, which files are affected, and what the architectural blast radius is — before the code lands.

✓ Automatic PR comments with impact analysis
✓ Dependency diff (added, removed, changed)
✓ Zero configuration for public repos
✓ Free on GitHub Marketplace

View on GitHub Marketplace →

Setup — .github/workflows/depwire.yml

name: Depwire PR Impact
on:
  pull_request:
    branches: [main]

jobs:
  impact:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: depwire/depwire-action@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}

Deterministic Graph vs Probabilistic RAG

Most AI coding tools use semantic search — they guess what's relevant based on text similarity. Depwire builds a precise, verifiable map of every function call and import using Tree-sitter. The AI doesn't guess. It knows.

Feature	Depwire	Standard RAG	LLM Native Scanning
Logic	✓ Deterministic Graph	Probabilistic Match	Brute Force Reading
Precision	✓ 100% (Tree-sitter AST)	~70% (Embedding match)	Varies — hallucination prone
Refactor Safety	✓ Traces full call chains	Misses indirect refs	Zero — blind edits
Token Cost	✓ Ultra-low — surgical reads	High — context stuffing	Extreme — scans everything
Circular Detection	✓ Built-in	✗ Not possible	Occasional
What If Simulation	✓ Before touching code	✗	✗
Architecture Health Score	✓ 0-100 with dimensions	✗	✗

Depwire is the GPS. Your AI is the driver.

Depwire doesn't replace Claude Code, Cursor, or Aider. It gives them the map they've been missing.

🧠

Depwire + Claude Code

Surgical refactoring with full blast radius awareness before touching anything.

🖥️

Depwire + Cursor

IDE coding with architecture health monitoring and dead code detection.

⚡

Depwire + Context7

The Power Couple Stack. Internal codebase structure + external library docs = nothing left to guess.

💻

Depwire + Aider

Terminal-based refactoring with deterministic impact analysis instead of repo map guessing.