CODEBASE INTELLIGENCE FOR AI AGENTS · OPEN SOURCE · HOSTED

Your AI agent doesn't
understand your codebase.

repowise indexes any repo into a documented dependency graph in under 30 seconds — feeding Claude Code, Cursor, and your own agents real architecture, ownership, and decisions instead of guesses.

Paste any public GitHub repo URL to instantly explore its architecture, dependencies, and more.

1.4k
GitHub stars
260
Repos indexed
8
MCP tools
<30s
Incremental update

Live on Repowise

Try it on real codebases

We index and keep these repos fresh ourselves — open one to see exactly what Repowise does on a real, large codebase. No mock data, no signup.

See all public repos
01HOW YOU USE IT

One engine, three interfaces

Install once. Choose the interface that fits your workflow — or use all three. They share the same data, the same intelligence, the same stores.

CLI

For the solo developer

pip install repowise. Run init, update, search, dead-code, and 10 more commands. Works fully offline with Ollama. Your code never leaves your machine.

$ repowise init .
$ repowise update
$ repowise search "auth flow"
$ repowise dead-code --safe-only

MCP Server

For AI-native workflows

8 tools that plug into Claude Code, Cursor, or Cline. Your AI agent calls get_context() instead of reading 40 files. Config auto-generated after repowise init.

$ repowise mcp
$ get_overview()
$ get_context(["src/auth"])
$ get_risk(["payments.py"])

Web UI

For the whole team

Browse the wiki, explore the dependency graph in D3, view hotspot tables, track doc freshness, and chat with your codebase. All served from repowise serve.

$ repowise serve
$ localhost:7337/repos/1/wiki
$ localhost:7337/repos/1/graph
$ localhost:7337/repos/1/hotspots
02GETTING STARTED

From install to codebase intelligence
in four commands

One pip install. Works offline with Ollama. No account required to get started — run everything on your machine.

01

Install

Works on Python 3.10+. Supports Anthropic, OpenAI, Gemini, and Ollama (fully offline).

$ pip install repowise
02

Index your repo

Parses your codebase, builds a dependency graph, mines git history, and generates wiki pages with an LLM.

$ repowise init .
Traversing 847 files...
Building dependency graph (3,241 nodes)...
Indexing git history (1,204 commits)...
Generating 85 wiki pages · claude-sonnet-4-5...
✓ Done in 4m 12s · $1.34 LLM cost
03

Stay current

Run after commits. Detects changed files, cascades updates through the dependency graph.

$ repowise update
3 changed files → cascading to 12 pages...
✓ Updated in 28s · $0.11 LLM cost
04

Open the web UI

Full dashboard: wiki explorer, interactive dependency graph, hotspot tables, ownership maps, and codebase chat.

$ repowise serve
Web UI running at http://localhost:7337
03INTELLIGENCE LAYERS

Most tools answer one question.
repowise answers four.

Graph structure, git history, generated documentation, and architectural decisions — four layers that compound into genuine codebase understanding.

01
Graph Intelligence

Every dependency, ranked and traced

repowise parses your codebase into a directed dependency graph using tree-sitter ASTs across 10 languages. PageRank identifies your most critical symbols. Community detection discovers logical modules even when directory structure doesn't reflect them.

  • 6,284+ nodes with PageRank, betweenness centrality, SCC detection
  • Edge types: imports, calls, inherits, implements, co-changes
  • Topological sort drives generation order — bottom-up, always
  • Scales to 30K+ nodes with automatic SQLite-backed graph
Dependency graph visualization showing interconnected code modules ranked by PageRank
02
Git Intelligence

History that writes the documentation

GitIndexer mines your commit history to classify files as hotspots or stable, compute ownership, extract significant commit messages, and discover co-change partners. These signals flow into generation prompts, so your wiki explains why code was written — not just what it does.

  • Hotspot detection: top 25% churn + complexity files flagged
  • Co-change partners: files that change together without imports
  • Ownership from git blame — primary owner + top 3 contributors
  • Significant commits filtered and included in generation prompts
Hotspot analysis table showing file churn, complexity, risk scores, and code owners
03
Documentation Intelligence

Wiki pages that stay fresh

Each wiki page is generated with 9 layers of context: source code, symbol signatures, graph metrics, git history, import summaries, RAG context, co-change docs, dead code findings, and reverse imports. Confidence scores decay when source changes — stale pages auto-regenerate.

  • Confidence scoring: 0.0–1.0 with git-informed decay modifiers
  • RAG context via LanceDB or pgvector — each page knows its imports
  • 9-level hierarchical generation: symbols → files → modules → repo
  • Resumable jobs — crash-safe, idempotent, checkpoint after every page
Auto-generated wiki page for auth/service.py showing API signatures, ownership, and freshness score
04
Decision Intelligence

The why behind your architecture

Decisions are extracted from four sources: inline markers (# WHY:, # DECISION:, # TRADEOFF:), git archaeology, README/docs mining, and manual CLI capture. Each decision tracks staleness — when affected files change, the decision is flagged for review.

  • 4 capture sources with confidence: inline (0.95), git (0.70–0.85), docs (0.60), CLI (1.00)
  • Staleness tracking — decisions age when governed files get commits
  • Health dashboard: stale decisions, ungoverned hotspots, proposed reviews
  • MCP tool get_why() searches decisions before you change anything
Architectural decision records showing ADRs with source, confidence, and staleness tracking
05MCP INTEGRATION

8 tools your AI agent already knows how to call

The MCP server exposes the entire wiki as structured, queryable tools. Instead of reading 40 source files, your agent calls get_overview() and gets a current architecture summary. Config auto-generated for Claude Code, Cursor, and Cline.

get_overview()

Architecture summary, module map, entry points, tech stack.

First call when exploring an unfamiliar codebase.

get_context()

Docs, ownership, history, decisions, freshness for files, modules, or symbols. Pass multiple targets in one call.

Before reading or modifying specific code.

get_risk()

Hotspot score, dependents, co-change partners, risk summary. Also returns top 5 global hotspots.

Before modifying files — assess blast radius.

get_why()

Three modes: natural language search over decisions, path-based lookup, or health dashboard.

Before architectural changes — understand existing intent.

search_codebase()

Semantic search over the full wiki using LanceDB or pgvector. Natural language queries.

When you don't know where something lives.

get_dependency_path()

Connection path between two files or modules in the dependency graph.

Understand how two things are connected.

get_dead_code()

Unreachable files, unused exports, zombie packages — sorted by confidence and cleanup impact.

Before cleanup or refactoring tasks.

get_architecture_diagram()

Mermaid diagram for the full repo or a specific module scope.

For documentation, presentations, or onboarding.

MCP tool registry showing 8 tools: get_overview, get_context, get_risk, get_why, search_codebase, get_dependency_path, get_dead_code, get_architecture_diagram
SUPPORTED EDITORS
Claude Code|Cursor|Cline|Any MCP client
07CODEBASE CHAT

Ask questions.
Get grounded answers.

The chat agent has access to all 8 MCP tools. It searches the wiki, reads the graph, checks git history, and cites architectural decisions — all automatically. Answers are grounded in your actual codebase, not hallucinated from training data.

  • Provider-agnostic — uses whichever LLM you configured
  • SSE streaming with real-time tool call visibility
  • Conversation persistence across page refreshes
  • Artifact panel for rich results: wiki pages, diagrams, risk reports
Codebase chat showing AI agent querying authentication code with MCP tools and returning grounded answers
04EDITOR INTELLIGENCE

CLAUDE.md that writes itself

After every repowise update, the CLAUDE.md is regenerated from real data — graph metrics, git history, dead code findings. No LLM needed. No templates. Just your codebase, distilled into the context your AI agent needs.

  • Architecture overview extracted from the real dependency graph
  • Hotspot warnings with file paths, churn metrics, and owners
  • Architectural constraints and key design decisions
  • Dead code summary with confidence scores
  • Entry points, build commands, and tech stack detection

Also generates cursor.md for Cursor users. Same data, different format.

Auto-generated CLAUDE.md showing architecture, hotspots, constraints, and entry points
06GIT INTELLIGENCE

What your git history has been trying to tell you

repowise mines commit history into actionable signals: which files break most often, who owns what, and which files are secretly coupled. These signals drive generation depth, confidence decay, and risk assessment.

↑↓

Hotspot Detection

Top 25% churn + complexity files flagged automatically. Hotspot pages get deeper generation and faster confidence decay.

⌘

Ownership Maps

git blame + commit history reveals who owns what. Bus factor calculated per module. Single-owner modules highlighted.

↔

Co-change Partners

Files that change together without import relationships. These hidden couplings are invisible to static analysis.

⏱

Significant Commits

Large diffs, refactors, and migration commits are identified and included in generation prompts for richer context.

↻

Confidence Decay

When source files get new commits, associated wiki pages decay in confidence. Stale pages auto-regenerate on next run.

⚓

90-Day Windows

All git metrics use rolling 90-day windows by default. Reflects current activity, not ancient history.

Git intelligence dashboard showing ownership maps with bus factor and co-change partner analysis
09HOW WE COMPARE

The full picture, side by side

Most tools solve one slice of the problem. repowise is the only open-source platform that combines auto-generated documentation, git intelligence, decision records, and MCP tools in a single self-hostable package.

FeaturerepowiseGoogle CodeWikiDeepWikiCodeSceneSourcegraph
Self-hostable OSS✓————
Works with private repos✓—✓✓✓
Auto-generated wiki (LLM)✓✓✓——
Git intelligence (hotspots / ownership / co-changes)✓——✓—
Dead code detection✓————
Architectural decision records✓————
MCP server for AI agents✓————
Semantic search✓✓✓—✓
Doc freshness / confidence scoring✓————
CLAUDE.md auto-generation✓————
Codebase chat (agentic)✓✓✓——
Dependency graph visualization✓✓✓✓✓
Provider choice (4 LLM providers)✓————
Privacy (code never leaves your infra)✓——✓✓
repowise: 14/14 · CodeScene: 3/14 · Sourcegraph: 3/14 · DeepWiki: 4/14 · Google CodeWiki: 3/14

Self-assessed against publicly documented features as of May 2026. Vendor capabilities change — please verify before committing to any tool.

See it in action →
08HOSTED PRODUCT

Team intelligence, managed for you

Everything in the open-source product, plus team features. No infrastructure to manage. We handle ingestion, storage, and updates.

Shared Team Context

Everyone on the team queries the same wiki, same graph, same decisions. New hires get onboarded with get_overview() instead of a stale Notion doc.

Plugin Store

COMING SOON

Extend repowise with community plugins: custom parsers, integration hooks, specialized MCP tools, and export formats.

Role-Based Access

COMING SOON

Control who can trigger regeneration, view sensitive repos, or modify architectural decisions. SSO integration included.

Analytics Dashboard

COMING SOON

Track doc freshness trends, generation costs, token usage, hotspot evolution over time, and team adoption metrics.

10FROM THE BLOG

Guides, comparisons, and deep dives

Learn about codebase intelligence, MCP tools for AI agents, and how repowise compares to other tools.

5 Best Codebase Documentation Tools in 2026 (Compared)
comparisons11 min read

5 Best Codebase Documentation Tools in 2026 (Compared)

For decades, 'good documentation' was the white whale of software engineering. We all knew it was necessary, but the friction of maintaining it—manually upda...

repowise vs CodeScene: Full Codebase Intelligence Without the Enterprise Price Tag
comparisons9 min read

repowise vs CodeScene: Full Codebase Intelligence Without the Enterprise Price Tag

Technical debt is rarely a single catastrophic event. Instead, it’s a slow accumulation of 'paper cuts'—a complex module here, a high-churn file there, and a...

repowise vs DeepWiki: Self-Hosted Codebase Docs That Stay Fresh
comparisons9 min read

repowise vs DeepWiki: Self-Hosted Codebase Docs That Stay Fresh

Every engineering team eventually hits the 'Documentation Wall.' It’s the moment when the codebase grows faster than the human capacity to describe it. You’v...

View all posts →
10GET ACCESS

Three paths to codebase intelligence

  • Self-host (free, forever)

    pip install repowise. Run on your machine, your server, your CI. AGPL-3.0. Full feature set. Your code never leaves your infrastructure.

  • Hosted SaaS — live now

    Managed indexing, team workspaces, and semantic chat. Free tier for public repos up to 250 MB; auto-sync and bigger repos on Pro. Pro at $15/mo with LLM credits included. Sign up free →

  • Enterprise

    On-prem deployment, SSO, role-based access, dedicated support, SLAs. Reach out below and we'll scope it together.

I'm interested in