What is repowise

Repowise is a codebase intelligence engine. Point it at a git repository and it produces a single artifact — a SQLite + vector store under .repowise/ — that AI agents and humans can both query.

The artifact captures four layers of context that no static analyzer or LLM-only tool gives you on its own.

The four intelligence layers

1. Static structure

Every file, symbol, and import edge, parsed by language-aware resolvers across 14 languages — TypeScript, Python, Java, Go, Rust, C++, C#, JavaScript at the Full tier; C, Kotlin, Ruby, Swift, Scala, PHP at Good; plus config and data formats (OpenAPI, Protobuf, GraphQL, Dockerfile, Terraform, etc.).

The dependency graph has two tiers (file nodes + symbol nodes) and uses a three-tier call resolver with confidence scoring to handle import aliases, barrel re-exports, namespace imports, and framework conventions (Django, FastAPI, Spring, Express, NestJS, Rails, Laravel, Axum, Actix). Plus heritage extraction (extends, implements, trait impls, derive macros, mixins, extension conformance) and Leiden community detection that finds logical modules even when your directory structure doesn't reflect them.

2. Git history

500 commits of history (configurable up to 5,000) turned into behavioural signals static analysis can't produce:

• Hotspot files — high churn × high complexity, where bugs live.
• Ownership — git blame aggregated into per-engineer percentages.
• Bus factor — how many people could leave before a file becomes unowned.
• Co-change pairs — files that change together without an import edge between them. Hidden coupling that AST analysis cannot detect.
• Significant commits — meaningful messages (filtered of merges, dependency bumps, lint runs) that explain why code evolved.

3. Auto-generated wiki

An LLM-authored Markdown page for every module and every notable file. The pages cite source ranges, get a confidence score, are incrementally regenerated on every commit (typical update: 3–10 pages in under 30 seconds), and feed semantic search through a LanceDB vector store.

The prompt the LLM sees isn't just source — it includes parsed structure, top callers/callees, the most significant commit messages, ownership, and trend signals. That's the recipe for docs that explain why, not just what.

4. Architectural decisions

The layer nobody else has. Repowise treats decisions as first-class data — captured by hand (repowise decision add), mined from git history (auto-proposed), or extracted from inline markers in source:

# WHY: JWT chosen over sessions — API must be stateless for k8s scaling
# DECISION: All external API calls wrapped in CircuitBreaker after Q3 outages
# TRADEOFF: Accepted eventual consistency in preferences for write throughput

Decisions are linked to the graph nodes they govern, tracked for staleness as code evolves, and surfaced via get_why the moment your agent touches a governed file.

The agent surface

Your editor's AI agent talks to all of this through seven MCP tools. They're task-shaped, not entity-shaped — pass multiple targets in one call, get complete context back in one round-trip.

Five calls usually replace what would otherwise take 30 reads and greps. Same answer, 27× fewer tokens, 36% cheaper, 49% fewer tool calls on the repowise-bench SWE-QA suite.

Why your agent needs this

LLMs are good at reading the file in front of them and bad at reasoning across the rest of the codebase. They:

• Guess at module boundaries.
• Miss callers and dependents.
• Hallucinate function signatures from neighbouring repos.
• Have no idea why the previous engineer chose the design they did.

Without context, the agent does what a junior engineer does on day one: reads files, asks lots of questions, and ships changes that break unrelated parts of the system.

Repowise gives the agent the institutional knowledge a senior engineer would have. Hotspot warnings before edits. Co-change partners surfaced automatically. Architectural decisions linked to governed files. Ownership and bus-factor visible in every response.

The agent stops guessing.

Who it's for

• AI-first engineering teams who use Claude Code, Cursor, or Windsurf as their primary IDE.
• Teams onboarding into unfamiliar codebases — a new hire's first two weeks become two days when their agent already knows the hotspots, owners, and decisions.
• Open-source maintainers who want their contributors' agents to have full context without writing it all into CONTRIBUTING.md.
• Anyone tired of watching their agent cat the same file four times.

Self-hosted or hosted

Both modes ship the same intelligence — same parsers, same git analysis, same wiki generation, same MCP tools. Pick whichever fits.

See Hosted vs self-hosted for the full side-by-side. Or just jump to Quickstart and try one — switching later is painless because both speak the same MCP protocol.

What's next

• Quickstart — install + index
  • connect Claude Code in under a minute.
• How it works — the end-to-end flow from repowise init to a connected agent.
• MCP tools overview — what your agent can actually ask for.