Repowise

English | 简体中文

Set it up in one line

Open Claude Code, Codex, Cursor or any MCP-capable agent in your repository and paste:

Read https://docs.repowise.dev/setup.md and set up Repowise in this repository.

The agent installs Repowise, indexes the repo with no API key, connects itself to the index, and asks you before anything costs money. To do it by hand:

uv tool install repowise          # or: pipx install repowise / pip install repowisecd /path/to/your/reporepowise init --yes --no-prose    # graph, git, health, dead code, docs. No key, no spend.                                  # answers and docs: run repowise generate (one command, no re-index)repowise serve                    # dashboard + MCP server (needs Node 20+; first run downloads the UI)

serve opens the dashboard in your browser. After a first index it starts with a short guided tour, and Setup is where you connect agents, turn on sync and add coverage or a model.

Restart Claude Code or run /mcp, then ask "What breaks if I change src/auth.py?" or "Use Repowise get_overview to summarize this repository." init wires Claude Code for this repo and adds the global repowise MCP entry when there is none; it never moves one that serves another repo. Full setup for every agent →

Your agent stops guessing

Without an index, an agent rediscovers your codebase on every task: grep, open a file, open three more, grep again. Repowise answers those questions ahead of time, so the agent asks once and gets on with the work.

In a measured run on django/django, an agent with Repowise made 3.8 tool calls instead of 7.2, opened 3.0 files instead of 7.2 and wrote 31.6% less, with answers just as good. That is the largest saving of the five context tools we tested. On a small local model the output cut reaches 47.9%. How it was measured →

• Your agent gets ten task-shaped MCP tools. Ask about several files at once and get callers, risk, tests, owners and the reasons behind the code in one answer. The tool list ↓
• Up to 99% less command noise. repowise distill trims test, install and git output before the agent reads it and keeps every error line. Distill →
• Context before the agent asks. Optional hooks warn it off fragile files and stale paths, and Repowise keeps your CLAUDE.md and AGENTS.md current from the index.
• See your own savings. repowise saved and the dashboard's Usage and savings page count the tokens your agent no longer has to read.

What it does

One index of your code, its history and its decisions, used three ways: to understand the code, to change it safely, and to keep improving it.

Hosted, and Foresight

Everything above runs free on your own machine. repowise.dev runs it for you, private repos included, and is where Foresight arrives first: models trained on years of real commits and fixes that rank the files a fix will touch, name what a change forgot, and explain every answer, with no LLM. What Foresight does →

[Hosted at repowise.dev: everything in this README with nothing to run, private repos included, one MCP endpoint for Claude, ChatGPT and Cursor, the PR bot with free deterministic review and AI review for cents a pull request, Jira and Confluence, and team workspaces. Coming to repowise.dev: Foresight, models trained on how real codebases change that rank the files a fix will touch, flag what a change forgot, and explain every answer.]

[Start free on hosted repowise.dev] [Join the Foresight waitlist]

Already indexed locally? repowise publish puts the repo on repowise.dev in one command. It indexes your GitHub remote, so nothing is uploaded from your machine. Public repos are free.

Know what breaks before you merge

All of this comes from the graph and git history, with no LLM, so the same diff always gets the same answer.

• Change risk. Score any commit or branch 0 to 10 against your repository's own recent commits, with what it may break, the companion files it forgot, the tests it is missing and the tests to run. repowise risk main..HEAD (reference)
• Tests without a coverage run. Which tests reach a file and which ones a diff exercises, from a coverage report when you have one and from the call graph when you do not: 97.5% correct on which tests to run. repowise impacted-tests main..HEAD (reference)
• Bug magnets. Which files keep getting bug fixes, with a warning when your agent edits one. (reference)
• Branch overlap. Other open branches editing the same files. repowise overlap (reference)
• In CI. Patch coverage, doc drift, security and change risk as gates through the GitHub Action, a GitLab template or plain CLI, with SARIF output. No API key. Repowise in CI →

On every pull request. The free Repowise PR Bot posts one comment, edited in place on every push, with the callers outside the PR, the tests and companion files it is missing, and its change risk. A green PR gets no comment at all.

_{A real comment on a real PR: repowise-dev/repowise#1204 · its analysis page → · install the PR bot →}

Every change, with its evidence

Each merged PR or commit becomes a Change Record: what it touched, who owns it, the tests that reach it, the contracts and decisions it crosses, and what happened after it landed. No forge API is called.

Know exactly what to fix

Every file gets a 1 to 10 score from 53 deterministic detectors, read three ways: defect risk, maintainability and performance. Performance findings such as N+1 queries and I/O in loops are traced across functions and files.

The score is checked against real bugs. On 21 open-source projects, ranking by Repowise found 2.3x as many later-buggy files as CodeScene in the same review budget. It also checks itself on your repository after every index: "16 of the 20 lowest-health files had a bug fix in the last 6 months, 3.3x the 24% baseline."

Then it names the fix: Extract Method, Extract Class, Move Method, Split File or Break Cycle, with the exact symbols that move, ranked so a fix on a central file comes before the same fix on a leaf. Each plan has a copy-to-agent button.

repowise next                          # what to fix first, ranked by impact and effortrepowise health --refactoring-targets  # concrete plansrepowise dead-code                     # what can go, by confidence tier

Code health · Refactoring · Dead code · How it was validated →

Across your repositories

Real systems are more than one repository, and the expensive failures live between them. Change a backend contract and Repowise names the frontend calls that consume it, the services downstream, and the architecture rule the new dependency breaks, before it ships.

Workspace guide and support matrix → · Keeping the index fresh →

Measured against the field

The same repositories, commits and questions for every tool, each given its full advertised surface, against answer keys we did not write.

Every result, in plain English, with the method → · The research it is built on →

Supported languages

28 languages parsed to an AST, 42 on a five-rung ladder, framework-aware where an ecosystem handler exists. Every language ships in the open-source distribution.

Full   [Python] [TypeScript] [JavaScript] [Svelte] [Vue] [Astro] [Java] [Kotlin] [Go] [Rust] [C++] [C#] [Scala] [Ruby] [Apex (Salesforce)]

Good   [C] [Swift] [PHP] [Dart] [Object Pascal / Delphi] [COBOL] [GDScript / Godot] [VB.NET] [Elixir] [F#] [Objective-C]  · Partial   [Luau] [Razor / Blazor]

Supported agents and editors

Eight agents wired end to end · two at the Full tier · every other MCP host one paste away.

Full tier   [Claude Code] [Codex CLI]

Good tier   [VS Code] [Cursor] [OpenCode] [Hermes] [GitHub Copilot CLI] [Kiro]

Full is every surface Repowise has: MCP tools, skills, slash commands, a managed instructions file, hook-level interception of tool calls, and transcript mining after the session. Good is MCP tools plus an instructions file or skills, without transcript mining (hooks only where the matrix says). Basic is the MCP config alone. Anything else that speaks MCP is one snippet away: repowise agents print-config claude-code prints a server entry for Cline, Windsurf, Zed, Gemini CLI or any host that reads mcpServers. Integration matrix →

In VS Code, the Repowise extension shows what your change breaks before you push (riskiest files, what is downstream, forgotten companion files, missing tests, suggested reviewers), health in the gutter and status bar, callers and ownership on hover, and refactoring plans as CodeLens. One install also registers the MCP server, so the same index serves you and your agent. Install from the Marketplace or Open VSX and run Repowise: Set Up This Repository. VS Code guide →

In Claude Code, Lens ships inside the Repowise plugin and shows you what the index knows while Claude works: the file it is on and how many files depend on it, a change review after a turn that edits files (code health, tests to run, other branches on the same files), and /lens, a pane with Flow (what to check before accepting each turn), a map of the repo lit by what Claude searched, opened and edited and what its edits reach, Ask, and a session recap. Nothing reaches Claude unless you press a button, and Lens makes no model calls of its own. It needs Claude Code 2.1.287 or later, and the map needs repowise serve --no-ui running. Lens guide →

The ten MCP tools

Every response carries a _meta envelope with the indexed commit, the index age and a stale warning when the index has fallen behind your checkout, so your agent always knows how much to trust what it just read.

For teams and enterprises

AI makes producing a change cheaper. It does not make understanding its consequences cheaper. Repowise gives developers, agents, reviewers and platform teams the same evidence about what exists, what depends on it, what is risky and what will break, from one index, in place of a separate health tool, dead-code tool, code-search layer for agents, docs generator and test-impact service.

Graph, git, health, change risk, tests, dead code and PR review make zero LLM calls, and raw source is never stored. Prose is optional and runs on your own provider or fully offline through Ollama.

Evidence you can hand to someone else.

Any git host works, because indexing reads a local checkout: GitHub (PR bot, Action, webhooks), GitLab (CI template, webhooks), Bitbucket and others through the CLI, and plain directories or Perforce and SVN exports for every layer except history.

Commercial licences come per seat, per indexed repository or enterprise-wide, with a named contact, an SLA and a quarterly architecture review. Using Repowise inside your company under the AGPL creates no obligation to publish your own code.

Commercial detail and capability status · Security review pack · Evaluating it for your company · [email protected]

Privacy

• Deterministic or offline mode: with --no-prose, code-derived content stays on your infrastructure. The CLI reports anonymous, opt-out usage telemetry (command names and coarse environment only); turn it off with repowise telemetry disable, DO_NOT_TRACK=1, or by running fully offline. What's collected →
• Optional LLM features: generated prose, decision extraction and refactoring code generation send code-derived prompts directly to the provider configured with your own key. Repowise does not proxy those calls.
• What's stored: the graph, embeddings, generated wiki pages and git metadata. Raw source is processed transiently and never persisted.
• Fully offline: Ollama plus a local embedding model means zero external calls.

Doing a security review? docs/business/SECURITY_COMPLIANCE.md →

CLI

repowise init [PATH]      # index a codebase (plan screen; --yes --no-prose needs no key)repowise generate [PATH]  # answers and docs with a model, on an existing index (no re-index)repowise serve [PATH]     # MCP server + local dashboardrepowise update [PATH]    # incremental update (--workspace for every repo)repowise watch            # re-index on file changerepowise search "<q>"     # hybrid search (fulltext / semantic / symbol / path)repowise ask "<q>"        # a synthesized answer with citationsrepowise context <files>  # triage card: layer, hotspot, fix history, freshnessrepowise symbol <id>      # one symbol's body, with verified line boundsrepowise why <q|path>     # decisions, rationale, git archaeologyrepowise next             # what to fix firstrepowise health           # code-health KPIs and lowest-scoring filesrepowise risk main..HEAD  # score a branch or PR rangerepowise overlap          # other branches editing the same filesrepowise impacted-tests   # only the tests a diff exercisesrepowise changes show ID  # one merged change and its evidence checklistrepowise check            # evaluate .repowise/policies.yaml against a changerepowise suspects         # recent changes ranked against a symptomrepowise components       # declared and derived components, owners vs activityrepowise packages where   # where a third-party package is importedrepowise report           # assessment, change evidence and inventory packsrepowise dead-code        # unreachable code by confidence tierrepowise doc-drift        # documentation the code no longer supportsrepowise security         # secrets and risky patterns, tree or full historyrepowise decision list    # architectural decisionsrepowise export --format structurizr  # the architecture as Structurizr DSLrepowise distill pytest   # compact, errors-first, reversible command outputrepowise saved            # tokens and dollars saved by distillationrepowise workspace add    # multi-repo workspace managementrepowise doctor           # check setup, API keys, index driftrepowise publish          # put this repo on repowise.dev (indexed from GitHub; public repos free)repowise uninstall        # remove what repowise wrote, and say what it left

Contributing

git clone https://github.com/repowise-dev/repowisecd repowiseuv sync --all-packagesuv run repowise --versionuv run pytest tests/unit/

New here? You do not have to read 3,000 files to start. We keep a public index of this repository built by Repowise itself, re-indexed on every push: explore repowise with repowise → (architecture, hotspots, ownership, decisions, and a ranked refactoring backlog you are welcome to pick from).

Full guide, including how to add languages and LLM providers: CONTRIBUTING.md · architecture: docs/architecture/

License

AGPL-3.0. Free for individuals, teams and companies using Repowise internally.

For commercial licensing (the enterprise security and compliance layer, SSO/SCIM, RBAC, workflow integrations, priority support and SLA, or embedding Repowise in a product without AGPL obligations), see docs/business/COMMERCIAL.md or contact [email protected].