# repowise

> repowise is an open-source (AGPL-3.0) codebase intelligence platform that indexes any repository once and serves both AI coding agents and the humans accountable for the code. For agents, it provides queryable architecture documentation, a dependency graph, git intelligence, architectural decisions, and ten MCP tools for Claude Code, Cursor, Cline, and Codex. For teams, it provides a defect-validated code-health score (cross-project ROC AUC 0.74 across 21 repos and 9 languages), change-risk analysis, dead code detection, and agent provenance tracking. The core engine is free, self-hosted, and requires no cloud account.

Setting up Repowise for a user? Follow https://docs.repowise.dev/setup.md, a step-by-step runbook written for coding agents.

Setting up Repowise Hosted (repowise.dev) for a user? Follow https://docs.repowise.dev/hosted/setup.md: sign-in, indexing, MCP over OAuth, the PR bot and coverage, with no key in chat.

Evaluating Repowise for a company? Start with the Evaluating Repowise section below.

Docs pages and the pricing page are also served as Markdown: append `.md` to the URL, or request it with `Accept: text/markdown`.

## Evaluating Repowise

- [Pricing](https://repowise.dev/pricing.md): Every plan's monthly and yearly price, what each includes, the full comparison, and how code is handled
- [Security & data handling](https://docs.repowise.dev/security.md): What Repowise processes, what it persists, what leaves your machine under each deployment mode, and how to reduce that to zero.
- [Hosted security and data handling](https://docs.repowise.dev/hosted/data-handling.md): A security reviewer's guide to Hosted at repowise.dev, covering what happens to your source code, what is kept, when a model sees it, and how data is deleted.
- [Hosted vs self-hosted](https://docs.repowise.dev/hosted/vs-self-hosted.md): Hosted and self-hosted repowise ship the same intelligence layers, MCP tools and dashboard. They differ in ops, billing and team features, not agent power.
- [Licensing](https://docs.repowise.dev/licensing.md): repowise is AGPL-3.0. What that allows, why internal use creates no obligation to publish your code, and when a company needs a commercial licence.
- [Enterprise](https://docs.repowise.dev/enterprise.md): repowise for platform, AppSec and architecture leads: change and component evidence computed inside your network, and what the commercial licence adds.
- [Benchmarks](https://docs.repowise.dev/reference/benchmarks.md): The headline measurements with their samples, the scale table with lines of code, the rows we lose, and where the full methodology and raw runs live.
- [Security policy](https://repowise.dev/legal/security): Encryption, access control, incident response and compliance status
- [Privacy policy](https://repowise.dev/legal/privacy): What personal data Repowise Hosted collects and how it is used
- [Terms of service](https://repowise.dev/legal/terms): The terms that govern use of Repowise Hosted
- [Enterprise security review](https://docs.repowise.dev/enterprise.md#security-review-for-enterprise): Residency, subprocessors, model training, SLA, certifications, SSO, DPA and indemnity, answered for Enterprise
- [Benchmark results](https://repowise.dev/benchmarks): Retrieval, token, call-graph and code-health results, with method and raw runs
- Enterprise runs entirely inside your perimeter: Repowise never handles your code or data, so your own controls and certifications cover the deployment.
- Security reviews, DPAs and questionnaires: security@repowise.dev or hello@repowise.dev

## Product

- [Homepage](https://repowise.dev/): What repowise is, who it serves, and the one-command install
- [Pricing](https://repowise.dev/pricing): Free (public repos), Pro, Teams, Enterprise
- [Architecture](https://repowise.dev/architecture): How the indexing pipeline, graph, and intelligence layers fit together
- [Explore](https://repowise.dev/explore): Live indexed repositories to browse repowise output on real codebases
- [Health leaderboard](https://repowise.dev/leaderboard): Curated public repositories ranked by deterministic code-health score
- [Bot](https://repowise.dev/bot): The GitHub PR bot: free deterministic risk, coverage and health checks, optional AI review on every pull request that changes code, and a Repowise review check on every push
- [AI code review cost calculator](https://repowise.dev/tools/ai-code-review-cost-calculator): Yearly cost of repowise, CodeRabbit, Greptile, Qodo, Copilot, Cursor Bugbot and Claude Code Review for a team, from dated list prices
- [Claude Code](https://repowise.dev/claude-code): Lens, the part of the Claude Code plugin that shows what Claude reads and edits, from a local index
- [Codex MCP server for codebase context](https://repowise.dev/integrations/codex): Give Codex full context of a large codebase: 10 MCP tools over your code graph, git history and decisions, session hooks and a managed AGENTS.md. Open source.
- [Cursor MCP server for codebase context](https://repowise.dev/integrations/cursor): Give Cursor full context of a large codebase: 10 MCP tools over your code graph, git history and decisions, an always-on rule and a distill hook. Open source.
- [GitHub Copilot MCP server for codebase context](https://repowise.dev/integrations/github-copilot): Give GitHub Copilot in VS Code and Copilot CLI full context of a large codebase: 10 MCP tools over your code graph, git history and decisions. Open source.
- [MCP server for Cline, Windsurf, Gemini CLI, Zed](https://repowise.dev/integrations/mcp-clients): One MCP server gives OpenCode, Kiro, Cline, Windsurf, Gemini CLI and Zed full codebase context: 10 tools over your code graph, git history and decisions.

## Documentation

- [Docs index](https://docs.repowise.dev/llms.txt): Every docs page, titled, described and linked as Markdown
- [Agent setup runbook](https://docs.repowise.dev/getting-started/setup.md): The step-by-step runbook a coding agent follows to install repowise, index the current repository, connect the MCP tools and report back, readable by anyone.
- [Quickstart](https://docs.repowise.dev/getting-started/quickstart.md): Install repowise, index your repo with no API key, open the dashboard and connect your agent. Self-hosted, hosted (repowise.dev), or a multi-repo workspace.
- [Set up with your agent](https://docs.repowise.dev/getting-started/for-agents.md): Paste one line into Claude Code, Codex, Cursor or any coding agent and it installs repowise, indexes the repo, connects the MCP tools and asks one question.
- [Install repowise](https://docs.repowise.dev/installation/install.md): Install the repowise CLI on macOS, Linux, or Windows via pip or uv. Verify, upgrade, switch versions, or uninstall. Every step.
- [MCP tools: overview](https://docs.repowise.dev/mcp/overview.md): The curated set of task-shaped MCP tools repowise exposes to Claude Code and any MCP agent, batched to collapse long tool-call chains into one round-trip.
- [CLI overview](https://docs.repowise.dev/cli/overview.md): Every repowise CLI command at a glance, from init, update and serve to search, health, risk, distill and decision, with a link to each command's full guide.
- [Workspace setup](https://docs.repowise.dev/multi-repo/workspace-setup.md): Index related git repos as one repowise workspace for cross-repo co-changes, API contract matching and federated MCP queries on top of per-repo intelligence.
- [Gates in CI](https://docs.repowise.dev/ci.md): Gate pull requests in CI on patch coverage, new doc drift, new security findings, new code-health findings and change risk, enforce a change policy, and run only the tests needed.
- [Hosted platform](https://docs.repowise.dev/hosted/overview.md): What the managed platform adds to the OSS engine: zero-ops indexing, push-sync, AI docs and chat, a security suite, team portfolio intelligence and alerting.

## Research

- [State of open-source code health 2026](https://repowise.dev/research/code-health-2026): 195 GitHub repositories with 1,000+ stars: hotspots, bug-fix concentration, dead code, circular import chains, hub files, bus factor and tests, with method and tables
- [Who Wrote This?](https://repowise.dev/resources/ai-governance): The engineering leader's guide to governing AI-written code, and the technical debt that comes with it. The AI code governance guide, with an AI coding policy template

Who Wrote This? is a free field guide from Repowise for engineering leaders whose teams use coding agents. It measures how AI-era code differs in 200+ popular open-source repositories, compared at the same age, and turns the findings into actions and a maturity model.

- Popular open-source projects built with coding agents carry about 4.5 times the share of too-big functions that projects started in 2021-22 had at the same age, and about 3 times after accounting for codebase size. (Our study of 200+ open-source repositories, 2026, observational, projects compared at the same age; chapter 2)
- Commit trailers miss much of the agent use: 34 of 79 young projects that barely credited agents still added an agent config file within two months. (Our study of 200+ open-source repositories, 2026, observational, young projects with few agent credits; chapter 3)
- In agent-era projects, each contributor adds over three times as much new code a week as in older projects of the same age, and all of it lands on the same reviewers. (Our study of 200+ open-source repositories, 2026, observational, lines added per contributor-week at six months; chapter 4)
- Splitting a big function moves the work: its new helpers take 41% to 57% of the later edits in that area. (Our study of 200+ open-source repositories, 2026, observational, later edits after a split; chapter 6)
- In a controlled trial, experienced developers were 19% slower with AI while believing they were faster. (METR randomised trial, 16 developers, 246 issues, early 2025; chapter 1)

- [Chapter 1: Your codebase has a new author](https://repowise.dev/resources/ai-governance/your-codebase-has-a-new-author): how widely teams use AI coding tools, how little they trust the output, and why few can say which code an agent wrote.
- [Chapter 2: Debt at agent speed](https://repowise.dev/resources/ai-governance/debt-at-agent-speed): agent-era open-source projects carry about 4.5 times the share of too-big functions at the same age. What we measured and what to do on Monday.
- [Chapter 3: Who wrote this?](https://repowise.dev/resources/ai-governance/who-wrote-this): read commit trailers, agent config files and edit capture to record which agent wrote each change, report label coverage, and keep Change Records.
- [Chapter 4: Reviewing at agent speed](https://repowise.dev/resources/ai-governance/reviewing-at-agent-speed): contributors to agent-era projects add over three times as much code a week. Point review at code with a fix history and run the tests it reaches.
- [Chapter 5: When nobody remembers why](https://repowise.dev/resources/ai-governance/when-nobody-remembers-why): ownership looks the same in both eras, but reasons get lost. Keep the why behind each decision next to the code, where agents and new hires read it.
- [Chapter 6: Paying it down without breaking things](https://repowise.dev/resources/ai-governance/paying-it-down-without-breaking-things): after a big function is split, its new helpers take 41% to 57% of later edits. Plan each refactor around how the code changes and judge the area.
- [Chapter 7: Policy engineers will actually follow](https://repowise.dev/resources/ai-governance/policy-engineers-will-follow): map SOC 2, ISO 27001, SOX and PCI DSS change controls to AI-written code, and five policies a team can enforce in CI with tools it already has.
- [Chapter 8: The AI Code Governance Maturity Model](https://repowise.dev/resources/ai-governance/ai-code-governance-maturity-model): the AI Code Governance Maturity Model. Six dimensions, five levels scored against evidence you can open today, and a 90-day plan to move up.

## Features

- [Code health](https://repowise.dev/features/code-health): Find the files most likely to break
- [AI provenance](https://repowise.dev/features/agent-provenance): Know which commits an agent wrote, with coverage
- [Agent context](https://repowise.dev/features/ai-context): Give Claude Code and Cursor the whole repo
- [Change risk](https://repowise.dev/features/change-risk): See what a change reaches before it merges
- [Security](https://repowise.dev/features/security): CVE triage that knows what you actually call
- [Generated docs](https://repowise.dev/features/wiki): Documentation that rebuilds itself on every commit
- [Git intelligence](https://repowise.dev/features/git-intelligence): Hotspots, owners, and hidden coupling
- [Architecture](https://repowise.dev/features/architecture): See your system as it actually is
- [Decisions](https://repowise.dev/features/decisions): Keep the why attached to the code
- [Dead code](https://repowise.dev/features/dead-code): Unused files, exports and packages, tiered by confidence
- [Test coverage](https://repowise.dev/features/test-coverage): Which tests reach a file, with or without a coverage run
- [Performance](https://repowise.dev/features/performance): N+1 queries and blocking calls, traced across files
- [Refactoring](https://repowise.dev/features/refactoring): A ranked fix-first queue with named refactoring plans

## Solutions

- [For AI agents](https://repowise.dev/for/agents): Give Claude Code, Cursor, Codex and VS Code the repository in one call
- [For developers](https://repowise.dev/for/developers): Understand any repository fast: answers with sources, docs, health and owners
- [For teams and enterprise](https://repowise.dev/for/teams): Review, risk and governance across every repository, hosted or in your network

## Languages

- [Code analysis by language](https://repowise.dev/languages): 42 languages on a five-rung ladder, and how to find dead code across a polyglot repository
- [Python static analysis: dead code, complexity and call graphs](https://repowise.dev/languages/python): Django, FastAPI, Flask and pytest aware dead code, call graph, complexity and performance markers.
- [TypeScript static analysis: unused exports, complexity and call graphs](https://repowise.dev/languages/typescript): tsconfig paths, workspaces and package exports resolved; Next.js, NestJS, tRPC and Angular entry points known.
- [JavaScript static analysis: dead code, complexity and call graphs](https://repowise.dev/languages/javascript): CommonJS and ES modules, Express, Koa, Fastify and Hono routes, with dynamic require handled.
- [Svelte, Vue and Astro code analysis: components, routes and dead code](https://repowise.dev/languages/svelte-vue-astro): Component files projected to TypeScript at the same line numbers; SvelteKit, Nuxt and Astro routes known.
- [Java static analysis: dead code, call graphs and complexity](https://repowise.dev/languages/java): Spring, Jakarta EE, Quarkus, Micronaut and Android manifest aware, with JaCoCo coverage and Gradle source sets.
- [Kotlin code analysis: dead code, architecture and Android](https://repowise.dev/languages/kotlin): Kotlin Multiplatform expect/actual rules, Android manifest components, Spring and Ktor, sharing one index with Java.
- [Go code analysis: dead code, call graphs and complexity](https://repowise.dev/languages/go): Package-level reachability, gin, echo, chi, fiber, gorilla/mux and gRPC handlers, coverprofile coverage.
- [Rust code analysis: unused code, call graphs and complexity](https://repowise.dev/languages/rust): Cargo workspaces and module trees resolved, Axum and Actix routes, unused public items across crates.
- [C++ code analysis: call graphs, dead code and complexity](https://repowise.dev/languages/cpp): compile_commands.json include paths, preprocessor-aware dead code, GoogleTest, Catch2 and libFuzzer entry points.
- [C# and .NET code analysis: unused code, call graphs and complexity](https://repowise.dev/languages/csharp): .csproj and .sln resolution, ASP.NET controllers and minimal APIs, EF Core, MediatR and MassTransit handlers.
- [Scala code analysis: call graphs, complexity and dead code](https://repowise.dev/languages/scala): Shared JVM index with Java, sbt and Mill fallback, Future and regex performance markers.
- [Ruby and Rails code analysis: dead code, complexity and call graphs](https://repowise.dev/languages/ruby): routes.rb to controllers, ActiveRecord associations, Zeitwerk autoload roots, ActiveRecord N+1 markers.
- [Salesforce Apex code analysis: dead code, call graphs and org metadata](https://repowise.dev/languages/apex): sfdx namespace resolution, LWC, Aura, Visualforce, Flows and object metadata linked to Apex, Apex coverage JSON.
- [PHP and Laravel static analysis: dead code, complexity and call graphs](https://repowise.dev/languages/php): PSR-4 and classmap autoload, Laravel routes, events, policies, providers and commands, TYPO3 conventions.
- [Dart and Flutter code analysis: unused code, widget trees and complexity](https://repowise.dev/languages/dart): pubspec package resolution across a monorepo, Flutter routes, GoRoute and widget-tree edges.
- [COBOL code analysis: map, document and modernize a mainframe codebase](https://repowise.dev/languages/cobol): CALL, PERFORM, CICS LINK and XCTL, copybooks, JCL, BMS and CSD linked; runs self-hosted and offline.

## Comparisons

- [All comparisons](https://repowise.dev/compare): How repowise compares to the field
- [repowise vs CodeScene](https://repowise.dev/compare/codescene-alternative): CodeScene is the more focused choice for behavioral code analysis and conservative prioritization. Repowise is designed to connect health evidence with architecture, history, decisions, documentation, and agent retrieval.
- [repowise vs DeepWiki](https://repowise.dev/compare/deepwiki-alternative): DeepWiki is attractive when the immediate job is to read and ask questions about a repository. Repowise adds code health, git risk, decisions, dependency evidence, and agent-facing retrieval to the documentation layer.
- [repowise vs Sourcegraph](https://repowise.dev/compare/sourcegraph-alternative): Sourcegraph is the stronger fit for global search across a very large code estate. Repowise is the more focused fit when repository understanding, history, health, decisions, and self-hosted agent context belong in one system.
- [repowise vs Cursor](https://repowise.dev/compare/cursor-alternative): Cursor is the better choice when AI-assisted editing is the center of the workflow. Repowise complements or replaces only the context layer, keeping repository evidence available outside a particular editor session.
- [repowise vs GitClear](https://repowise.dev/compare/gitclear-alternative): GitClear is the more direct fit for delivery trends and AI-code adoption analytics. Repowise focuses on explaining the repository itself, including ownership, change risk, health, decisions, and architecture.
- [repowise vs SonarQube](https://repowise.dev/compare/sonarqube-alternative): SonarQube is the stronger fit when CI enforcement, rules, and quality gates are the contract. Repowise is built to explain a repository and rank its files for attention, and it does not replace every Sonar rule or gate.
- [repowise vs Snyk Code](https://repowise.dev/compare/snyk-code-alternative): Snyk Code is the appropriate choice when source-code security scanning and remediation are the buying requirement. Repowise covers code health, git history and architecture, and it does not replace a dedicated SAST program.
- [repowise vs Codacy](https://repowise.dev/compare/codacy-alternative): Codacy is a direct fit for automated quality checks and coverage reporting across many languages. Repowise is a different kind of system: a persistent repository model for technical understanding, prioritization, and agent context.
- [repowise vs Code Climate / Qlty](https://repowise.dev/compare/codeclimate-qlty-alternative): Qlty is the direct successor for teams that used Code Climate for maintainability and coverage. Repowise adds architecture, git history, recorded decisions and agent access around its code-health findings.
- [repowise vs Qodo](https://repowise.dev/compare/qodo-alternative): Qodo is the stronger fit when you want enforced review standards learned from your own PR history, on GitHub, GitLab, Bitbucket or Azure DevOps. The Repowise PR bot starts from the dependency graph and git history, comments without a model by default, and adds AI review as an option.
- [repowise vs Greptile](https://repowise.dev/compare/greptile-alternative): Greptile is the focused pick for LLM review backed by a repository graph, billed per review at $1 a credit with no seats, and it self-hosts on Enterprise. The Repowise PR bot posts free graph and git-history checks first, with AI review optional.
- [repowise vs Swimm](https://repowise.dev/compare/swimm-alternative): Swimm is the more direct fit when guided modernization or authored knowledge workflows are central. Repowise automatically builds an evidence-backed repository model for ongoing browsing and agent retrieval.
- [repowise vs CodeRabbit](https://repowise.dev/compare/coderabbit-alternative): CodeRabbit is the direct fit when you want an AI reviewer on GitHub, GitLab, Azure DevOps or Bitbucket that comments line by line, runs 50+ linters and follows your feedback. The Repowise PR bot scores change risk from the diff, the dependency graph and git history without a model, and the same index serves documentation, health and agent context outside the review.
- [repowise vs CodeGraph](https://repowise.dev/compare/codegraph-alternative): CodeGraph is a genuine measured competitor and the better fit when graph indexing speed and a narrow agent interface matter most. Repowise builds substantially more context and led the measured retrieval and agent-loop results.
- [repowise vs Graphify](https://repowise.dev/compare/graphify-alternative): Graphify is the stronger fit when your material is a mixture of code, documents and images, or when you want graph exports and graph-analysis commands such as communities, paths and reverse impact. In the Repowise benchmark it indexed substantial repository structure, while its broad result sets traded precision for reach.
- [repowise vs Serena](https://repowise.dev/compare/serena-alternative): Serena is the better fit when language-server symbols and agent editing tools are the core need, with no up-front index build. Repowise is intended for durable, browsable evidence and more concise question-oriented retrieval.
- [repowise vs code-review-graph](https://repowise.dev/compare/code-review-graph-alternative): code-review-graph produced the most precise retrieval set in the Repowise benchmark, with lower coverage. It is a credible focused option when compact review context matters more than the wider evidence surface.

## Guides

- [Code Health: The Complete Guide to Defect-Validated Code Quality](https://repowise.dev/guides/code-health): How repowise scores every file from 1 to 10 with 23 deterministic markers, why the score predicts real bugs, and how to turn it into a ranked worklist you act on the same day.
- [AI Context & MCP: How repowise Cuts Agent Context Tokens by 96%](https://repowise.dev/guides/ai-context-mcp): How repowise indexes your repo once and serves it to AI coding agents through ten task-shaped MCP tools that collapse search, read, and reason into a single curated call.
- [Git Intelligence: Hotspots, Bus Factor & Hidden Coupling, Explained](https://repowise.dev/guides/git-intelligence): How repowise reads your git history to surface hotspots, bus factor, and hidden co-change coupling: four behavioral signals static analysis can't see, computed deterministically with zero LLM.
- [Change Risk & PR Review: Catch the PRs That Break Things Before You Merge](https://repowise.dev/guides/change-risk): How repowise scores change risk and blast radius deterministically from the real dependency graph and git history, then turns it into may_break, missing_cochanges, and missing_tests directives you act on before merge.
- [Architecture & Dependency Graph: The Complete Guide to Diagrams Derived From Code](https://repowise.dev/guides/architecture): How repowise parses your repo into one directed dependency graph across 27 languages, ranks it with centrality, and derives browsable C4 and knowledge-graph views with no LLM in the layout path.
- [Auto-Wiki & CLAUDE.md: Documentation That Stays in Sync With Every Commit](https://repowise.dev/guides/auto-wiki): How repowise writes a documentation page for every module and file, regenerates only the pages a commit touches, and generates CLAUDE.md and AGENTS.md from the same index, so your docs and your agents stay current with HEAD.
- [Decisions & ADRs: Capture the Why Your Code Was Shaped This Way](https://repowise.dev/guides/decisions-adr): How repowise mines architecture decisions from ten sources, backs each with evidence spans, links them to the dependency graph, ages them as the code changes, and serves the rationale over MCP via get_why.
- [Agent Provenance: Which Commits an Agent Wrote, with Coverage](https://repowise.dev/guides/agent-provenance): How repowise labels commits agent, human-attested or unknown from the evidence a repository carries, and why every AI share is shown with its coverage and withheld below 30 percent.
- [Security: Reachability-Aware CVE Triage, Not a Vulnerability Scanner](https://repowise.dev/guides/security): How repowise adds reachability-aware CVE triage, full-history secret detection, and in-review security signals on top of its dependency graph, and where Snyk and SAST stay the right tool.

## Glossary

- [Codebase glossary](https://repowise.dev/glossary): Definitions of code health, git history, change risk and architecture terms
- [What is code health?](https://repowise.dev/glossary/code-health): Code health measures how costly the next change to a file will be, as a score from 1 to 10. What goes into it, how to read it and how to check it against bugs.
- [What is a code smell?](https://repowise.dev/glossary/code-smell): A code smell is a surface sign of a deeper design problem. Fowler and Beck's classic smells, with examples, free detection tools and how repowise flags them.
- [What is cognitive complexity?](https://repowise.dev/glossary/cognitive-complexity): Cognitive complexity scores how hard code is to read: +1 per break in linear flow plus a nesting penalty. Rules, a worked example and the cyclomatic difference.
- [What is cyclomatic complexity?](https://repowise.dev/glossary/cyclomatic-complexity): Cyclomatic complexity counts the independent paths through code: M = E - N + 2P, or decision points plus 1. Formula, a worked example and common thresholds.
- [What is technical debt?](https://repowise.dev/glossary/technical-debt): What is technical debt? The meaning, Ward Cunningham's origin, Fowler's four-quadrant model, how to measure it and which debt to pay down first.
- [What is bus factor?](https://repowise.dev/glossary/bus-factor): Bus factor is the number of people who would have to leave before a project or file stalls. How it is computed from git history, with a worked example.
- [What is code churn?](https://repowise.dev/glossary/code-churn): Code churn in software development is how much code is added, changed or deleted in a file over a period. How to measure it with git, with a worked example.
- [What is a code hotspot?](https://repowise.dev/glossary/code-hotspot): A code hotspot is a file that changes often and is hard to change safely. How churn and complexity find hotspots with git, plus a free command to start.
- [What is code ownership?](https://repowise.dev/glossary/code-ownership): Code ownership is who is responsible for, and knows, a piece of code. How owners are measured from git blame and commits, and how it differs from CODEOWNERS.
- [What is temporal coupling?](https://repowise.dev/glossary/temporal-coupling): Temporal coupling (co-change, logical coupling) is when files keep changing in the same commits. How support and confidence measure it, with a worked example.
- [What is blast radius?](https://repowise.dev/glossary/blast-radius): Blast radius meaning in software: everything a code change or failure can affect. How to measure it from the call graph, with a worked example.
- [What is change risk?](https://repowise.dev/glossary/change-risk): Change risk analysis scores a commit or pull request for defect risk from its size, spread and history. How it works, with free ways to measure it.
- [What is the CRAP score?](https://repowise.dev/glossary/crap-score): The CRAP score combines cyclomatic complexity and test coverage to flag risky, untested code. See the formula, a worked table and the usual threshold of 30.
- [What is a test coverage gap?](https://repowise.dev/glossary/test-coverage-gap): A test coverage gap is code that matters or keeps changing but no test runs. Patch vs total coverage, how to find gaps, and the report formats repowise reads.
- [What is a call graph?](https://repowise.dev/glossary/call-graph): A call graph maps which functions call which. Static vs dynamic call graphs, why dynamic dispatch makes them hard, free tools, and how repowise scores edges.
- [What is dead code?](https://repowise.dev/glossary/dead-code): Dead code is code that never runs or that nothing uses. Unreachable vs unused code, how to find it with free tools per language, and how to delete it safely.
- [What is a dependency graph?](https://repowise.dev/glossary/dependency-graph): A dependency graph shows what depends on what. Package graph vs code import graph, how cycles and fan-in are measured, and free tools such as madge and pydeps.
- [What is a zombie dependency?](https://repowise.dev/glossary/zombie-dependency): A zombie dependency is a declared package that nothing imports. How it differs from an unused import, and free tools to find one in JS, Python, Rust and Go.
- [What is an architecture decision record (ADR)?](https://repowise.dev/glossary/architecture-decision-record): An architecture decision record (ADR) is a short file that records one design decision, its context and consequences. Template, tools, and how to mine them.
- [What is the C4 model?](https://repowise.dev/glossary/c4-model): The C4 model describes software architecture at four zoom levels: context, containers, components and code. What each level shows and how to generate them.
- [What is codebase intelligence?](https://repowise.dev/glossary/codebase-intelligence): Codebase intelligence is a kept-current model of a repository: code graph, git history, docs, decisions and health, queried by people and agents.
- [What is an MCP server for codebases?](https://repowise.dev/glossary/mcp-server): An MCP server exposes tools to AI agents over the Model Context Protocol. What a codebase MCP server does, how it connects, and what to expect from one.

## Blog

- [All posts](https://repowise.dev/blog)
- [Comparisons](https://repowise.dev/blog/comparisons): 71 posts
- [Guides](https://repowise.dev/blog/guides): 29 posts
- [MCP & AI Agents](https://repowise.dev/blog/mcp): 14 posts
- [Engineering](https://repowise.dev/blog/engineering): 38 posts
- [Use Cases](https://repowise.dev/blog/use-cases): 13 posts

### Key guides

- [Code Health: The Complete Guide to Metrics and Scores (2026)](https://repowise.dev/blog/guides/code-health-complete-guide): Code health explained: its metrics (complexity, coupling, coverage, churn, ownership), how each is computed, and how they roll up into a 1-to-10 score.
- [Code Hotspots: Find High-Churn, Complex Files with git](https://repowise.dev/blog/guides/git-hotspot-analysis-risky-files): Find git hotspots with one git log command, then rank them by churn, bug fixes and complexity. Includes a repowise workflow and what to do with the list.
- [Code Churn: What It Is, How to Measure It and What It Predicts](https://repowise.dev/blog/guides/code-churn): Code churn is the amount of code added, changed or deleted over time. Measure it with git log --numstat, combine it with complexity, and avoid the common traps.
- [What Is Bus Factor? How to Measure It from Git History](https://repowise.dev/blog/guides/code-ownership-bus-factor-git): Find who owns each file and which files have a bus factor of one, using git shortlog, git-fame and repowise, plus what to do about the risky ones.
- [Which Code to Test First: Combine Coverage, Complexity and Churn](https://repowise.dev/blog/guides/untested-hotspots-coverage-priority): Find untested hotspots: files with high churn, many dependents and low coverage. Rank them with git, lcov and repowise, then write the tests that matter first.
- [How to Find Dead Code in Your Repository](https://repowise.dev/blog/guides/find-dead-code-repository): Find dead code with Knip, vulture, Go deadcode and cargo-machete, or one repowise pass across every language, then delete the strongest findings first.
- [Architecture Diagram Generator for Code: 3 Tools Compared](https://repowise.dev/blog/guides/generate-architecture-diagram-from-github-repo): Generate an architecture diagram from a GitHub repo with GitDiagram, Eraser or repowise, checked edge by edge against Flask's real import graph.
- [What Is an MCP Server? Model Context Protocol for Codebases](https://repowise.dev/blog/mcp/what-is-mcp-model-context-protocol): MCP is the open standard that lets AI agents call tools and read data. Here is how it works, what a codebase MCP server exposes, and how to set one up.
- [Architectural Decision Records: Capture Why Your Code Is the Way It Is](https://repowise.dev/blog/engineering/architectural-decision-records-capture-why): Write architectural decision records that stay true: a template, when to write one, how to recover the why from git history, and how to hand it to AI agents.

### Comparisons and roundups

- [Best Claude Code Skills in 2026: Seven Skill Repos Worth Installing](https://repowise.dev/blog/comparisons/best-claude-code-skills): The best Claude Code skills in 2026, from engineering workflows to security audits and UI cleanup, with install commands for Claude, Codex and agent skills.
- [Best AI Code Governance and Audit Tools (2026)](https://repowise.dev/blog/comparisons/best-ai-code-governance-audit-tools): Track and audit AI-generated code across repos: GitHub Copilot metrics, Sonar AI Code Assurance, commit trailers, Git AI and repowise provenance compared.
- [Best Air-Gapped Code Analysis Tools (2026)](https://repowise.dev/blog/comparisons/best-air-gapped-self-hosted-code-analysis-tools): Self-hosted and air-gapped code analysis tools compared: SonarQube, CodeScene, Semgrep, Sourcegraph, Greptile and repowise, and what each runs offline.
- [Best Tools to Predict Bug-Prone Files (2026)](https://repowise.dev/blog/comparisons/best-bug-prone-file-prediction-tools): Defect prediction tools that work from git history: CodeScene, PyDriller for SZZ research, the Google bug prediction heuristic, Sonar and repowise.
- [Best Co-Change and Temporal Coupling Tools](https://repowise.dev/blog/comparisons/best-co-change-temporal-coupling-tools): Tools that show which files change together: code-maat, CodeScene, git log scripts and repowise, plus what Sourcegraph does and does not do.
- [Best COBOL Analysis and Mainframe Modernization Tools](https://repowise.dev/blog/comparisons/best-cobol-analysis-mainframe-modernization-tools): COBOL code analysis tools for mainframe modernization compared: IBM watsonx and ADDI, OpenText Enterprise Analyzer, AWS, Raincode, CAST and repowise.
- [Best Code Hotspot Analysis Tools in 2026](https://repowise.dev/blog/comparisons/best-code-hotspot-analysis-tools): Code hotspot tools that combine git churn and complexity: CodeScene, code-maat, repowise, and why SonarQube and Understand are a different job.
- [Best Code Ownership and Bus Factor Tools (2026)](https://repowise.dev/blog/comparisons/best-code-ownership-bus-factor-tools): Bus factor and code ownership analysis tools compared: git-fame, git-truck, GitHub CODEOWNERS, CodeScene and repowise, with when each one is the right pick.
- [Best Tools to Keep Docs in Sync With Code (2026)](https://repowise.dev/blog/comparisons/best-documentation-drift-detection-tools): Docs drift detection tools compared: Swimm, Mintlify, DeepWiki, lychee link checks and repowise doc-drift, and what each catches when code changes.
- [Best Multi-Repo Context Tools for Coding Agents](https://repowise.dev/blog/comparisons/best-multi-repo-context-tools-coding-agents): How to give coding agents context across multiple repositories: Sourcegraph MCP, Augment Context Engine, Claude Code add-dir, Cursor and repowise compared.
- [Best PR Risk Score and Blast Radius Tools (2026)](https://repowise.dev/blog/comparisons/best-pr-risk-score-blast-radius-tools): Pull request risk assessment tools compared: CodeScene, Sonar quality gates, Codecov, CodeRabbit, Greptile and repowise, and what each does for blast radius.
- [Best Technical Due Diligence Tools for M&A (2026)](https://repowise.dev/blog/comparisons/best-technical-due-diligence-tools): Technical due diligence tools compared: Black Duck audits, SIG, CAST Highlight, CodeScene, SonarQube, Snyk and repowise. Which to use for an M&A code review.
- [Best Tools to Reduce Claude Code Token Usage](https://repowise.dev/blog/comparisons/best-tools-reduce-claude-code-token-usage): Cut Claude Code token usage on large repos: built-in /compact and subagents, RTK, Serena, Context7, ccusage and repowise distill with MCP, compared.
- [Augment Code Pricing in 2026: $20 or $100 a Month for a Pooled Team of 50](https://repowise.dev/blog/comparisons/augment-code-pricing): Augment Code costs $20 a month (Standard) or $100 (Business) flat for up to 50 seats, with usage billed in dollars plus a 40% fee on LLM use. What a team pays.
- [Best AI Coding Agents in 2026: How They Handle a Large Codebase](https://repowise.dev/blog/comparisons/best-ai-coding-agents): The best AI coding agents in 2026: Claude Code, Codex, Cursor and Copilot compared on pricing, where they run, MCP support and large-codebase context.
- [Best Code Graph MCP Servers for Coding Agents (2026)](https://repowise.dev/blog/comparisons/best-code-graph-mcp-servers): We compared nine code graph MCP servers, including repowise, CodeGraph, Graphify, Serena and GitNexus, on tool count, license, price and, for five, call-graph accuracy.
- [Best Cross-Repo Code Intelligence Tools in 2026](https://repowise.dev/blog/comparisons/best-cross-repo-code-intelligence-tools): We compared cross-repo code intelligence tools by the job each does best, from multi-repo search and navigation to service graphs, co-change and refactors.
- [Codacy Alternatives in 2026 for Quality and Tech Debt](https://repowise.dev/blog/comparisons/codacy-alternatives): The best Codacy alternative depends on the job: SonarQube or DeepSource for quality gates, Semgrep for security, and CodeScene or repowise for technical debt.
- [Git Alternatives in 2026: What Works for AI Agent Workflows](https://repowise.dev/blog/comparisons/git-alternatives-for-ai-agents): Jujutsu, Sapling, GitButler, worktrees, stacked PRs and merge queues tested against the problems AI coding agents create, with real commands and output.
- [Graphify Review and Alternatives: Tested on FastAPI](https://repowise.dev/blog/comparisons/graphify-review-and-alternatives): Graphify turns a codebase into a queryable graph for Claude Code. We ran it on FastAPI next to repowise and compare it with Serena, GitNexus and CodeGraph.
- [Greptile vs CodeRabbit: How Each Reviews a Pull Request (2026)](https://repowise.dev/blog/comparisons/greptile-vs-coderabbit): Greptile vs CodeRabbit compared on price, git hosts, self-hosting and how each reviews a pull request, with real review comments from public PRs.
- [Knip vs ts-prune vs unimported: Tested on One Repo](https://repowise.dev/blog/comparisons/knip-vs-ts-prune-vs-unimported): Knip vs ts-prune vs unimported on the Excalidraw monorepo: Knip is the only one still released, ts-prune misread a modern tsconfig, unimported took 112 seconds.
- [Madge vs dependency-cruiser: Cycles, Rules and CI on Excalidraw](https://repowise.dev/blog/comparisons/madge-vs-dependency-cruiser): Madge vs dependency-cruiser on the Excalidraw monorepo: madge lists cycles with no setup, dependency-cruiser enforces import rules in CI and can baseline old violations.
- [OpenWiki Alternatives in 2026: 5 Codebase Wikis Compared](https://repowise.dev/blog/comparisons/openwiki-alternatives): The best OpenWiki alternatives are DeepWiki and Google Code Wiki for hosted reading, OpenDeepWiki for self-hosting, and repowise for a wiki with no model.
- [Qodo Pricing in 2026: $0.015 a Credit, About $2.14 a Review, and What a Team Pays](https://repowise.dev/blog/comparisons/qodo-pricing): Qodo Pro Team costs $0.015 a credit, about $2.14 a review on its own pack estimates, so a 20-developer team pays about $5,140 a year for pull request review.
- [SonarQube Pricing in 2026: Free Tiers, $34 Cloud, and Server by Quote](https://repowise.dev/blog/comparisons/sonarqube-pricing): SonarQube Cloud Team starts at $34 a month for 100K lines of code, Community Build is free, and SonarQube Server editions are priced by quote. Real costs by size.
- [Best AI Code Review Tools for GitLab and Azure DevOps](https://repowise.dev/blog/comparisons/ai-code-review-gitlab-merge-requests): AI code review for GitLab merge requests and Azure DevOps pull requests: GitLab Duo, CodeRabbit, Copilot, Greptile, PR-Agent and repowise CI gates.
- [Claude Code Review Pricing 2026: Anthropic's $15 to $25 per PR Estimate, and a 200-PR Budget](https://repowise.dev/blog/comparisons/claude-code-review-pricing): Anthropic's March 2026 launch estimate for Claude Code Review was $15 to $25 a PR. Its current docs give no flat price, so measure your own average.
- [CodeRabbit Pricing in 2026: $24 to $72 a Developer, and What a 20-Dev Team Pays](https://repowise.dev/blog/comparisons/coderabbit-pricing): CodeRabbit costs $24, $48 or $72 per developer a month billed annually ($30, $60, $90 monthly). Public repos are free; 20 devs pay $5,760 a year.
- [Cursor Bugbot Pricing in 2026: Cursor Lists $1.00 to $1.50 a Run, and Cheaper Alternatives](https://repowise.dev/blog/comparisons/cursor-bugbot-pricing-alternatives): Cursor Bugbot is usage-based since May 2026. Cursor's published figure is $1.00 to $1.50 per run, and a June update made runs about 22% cheaper.
- [Free AI Code Review for Open Source: Every Free Option for Maintainers in 2026](https://repowise.dev/blog/comparisons/free-ai-code-review-open-source): Every free AI code review option for open-source repos in 2026: CodeRabbit, Qodo, Greptile, Bito, Copilot, PR-Agent, reviewdog and repowise, with limits.
- [GitHub Copilot Code Review Cost in 2026: $1.50 a Review, Actions Minutes and a Team Estimate](https://repowise.dev/blog/comparisons/github-copilot-code-review-cost): A GitHub Copilot code review costs about $1.50 of AI Credits at the default Balanced level plus Actions minutes, and a Business seat is $19 a month.
- [Greptile Pricing in 2026: $1 a Credit, No Seat Fee, and What a Year Costs](https://repowise.dev/blog/comparisons/greptile-pricing): Greptile Pro costs $1 a credit with no seat fee. A Base review is 1 credit, Plus 3 and Apex 10, so 20 devs at 10 PRs a month pay about $2,400 a year.
- [AI Code Review Pricing Compared (2026): What 7 Tools Cost a Year for 5 to 200 Developers](https://repowise.dev/blog/comparisons/ai-code-review-pricing-compared): Most AI code review costs $1 to $25 a review or $19 to $48 a seat as of November 2026, about $120 to $576 per developer a year. Worked for 5 to 200 devs.
- [Augment Context Engine Alternatives for Claude Code, Cursor and Codex](https://repowise.dev/blog/comparisons/augment-context-engine-alternatives): Augment's Context Engine bills per MCP query. Compare CodeGraph, Graphify, Serena, GitNexus, Sourcegraph, Greptile and repowise on price, license and reach.
- [CodeScene Pricing 2026: What a 10, 50 or 200-Dev Team Pays (and Cheaper Options)](https://repowise.dev/blog/comparisons/codescene-pricing): CodeScene charges €18 or €27 per active author a month. Worked yearly costs for 10, 50 and 200 developers, what counts as an author, and cheaper options.
- [CodeSee Alternatives: Codebase Map and Visualizer Tools for 2026](https://repowise.dev/blog/comparisons/codesee-alternatives-codebase-maps): CodeSee's public site no longer loads after GitKraken bought it. Compare six tools that replace its codebase maps, PR review maps and dependency graphs.
- [DeepWiki Alternatives 2026: OpenWiki, Google Code Wiki, DeepWiki-Open, repowise](https://repowise.dev/blog/comparisons/deepwiki-alternatives): Five DeepWiki alternatives compared on the same three repos: how far behind HEAD each wiki was, self-hosting, private repo support and agent access.
- [DeepWiki for Private Repos: Your Options in 2026](https://repowise.dev/blog/comparisons/deepwiki-private-repos): DeepWiki for private repos runs through a Devin account. We compare it with self-hosted and hosted routes on cost, data handling and freshness.
- [IcePanel Alternatives (Including Open Source) for C4 in 2026](https://repowise.dev/blog/comparisons/icepanel-alternatives): Compare seven IcePanel alternatives for C4 diagrams, from open source Structurizr and LikeC4 to Ilograph and C4 generated from code, with prices.
- [Serena vs Graphify vs CodeGraph vs repowise: Benchmarked on the Same Repos](https://repowise.dev/blog/comparisons/serena-vs-graphify-vs-codegraph-vs-repowise): Serena, Graphify, CodeGraph and repowise compared on the same repos: agent tokens, file retrieval, call-graph accuracy, index time and which to pick.
- [SonarQube Alternatives in 2026: Open Source and Small-Team Options](https://repowise.dev/blog/comparisons/sonarqube-alternatives): Eight SonarQube alternatives compared on licence, free tier, price and what each one checks, from Semgrep and Opengrep to Codacy, CodeScene and repowise.
- [Sourcegraph Alternatives 2026: Open Source, Self-Hosted and AI Context](https://repowise.dev/blog/comparisons/sourcegraph-alternatives-2026): Sourcegraph now lists only an Enterprise plan from $16K a year. Eight alternatives, split by the job: exact code search, agent context, and understanding code.
- [Sourcegraph vs GitHub Code Search vs Rolling Your Own: A Build-vs-Buy Cost Table](https://repowise.dev/blog/comparisons/sourcegraph-vs-github-code-search-vs-build-your-own): GitHub code search is free, Sourcegraph starts at $16K a year, and a zoekt or embeddings stack costs 70 to 500 engineer-hours. Pick by repos, hosts, branches.
- [Structurizr vs Mermaid vs PlantUML for C4 (and When to Generate Instead)](https://repowise.dev/blog/comparisons/structurizr-vs-mermaid-vs-plantuml-c4): The same C4 container diagram written in Structurizr DSL, Mermaid and C4-PlantUML, with a feature table and a look at how each one keeps up with the code.
- [Technical Debt Measurement Tools Compared: What Each Score Measures](https://repowise.dev/blog/comparisons/technical-debt-measurement-tools-compared): SonarQube, CodeScene, Qlty, Codacy, NDepend and repowise compared on what their technical debt score counts, and which have evidence it points at bugs.
- [Best AI Code Review Tools in 2026: 14 Compared on Price and Fit](https://repowise.dev/blog/comparisons/best-ai-code-review-tools): The best AI code review tools in 2026 are CodeRabbit, Greptile and GitHub Copilot code review. 14 tools compared on price, context, git hosts and BYOK.
- [Best Architecture Documentation Tools in 2026: C4, ADRs and Diagrams](https://repowise.dev/blog/comparisons/best-architecture-documentation-tools): Nine architecture documentation tools compared on C4 views, ADRs, price and staying current, with data from 195 repos on how fast code outruns diagrams.
- [Best Code Health Tools in 2026: Five Compared](https://repowise.dev/blog/comparisons/best-code-health-tools-2026): CodeScene, SonarQube, Codacy, Qlty and repowise compared on scoring, hotspots, MCP and price, with code health scores from 195 popular open-source repos.
- [Best Code Search Tools for Engineering Teams in 2026](https://repowise.dev/blog/comparisons/best-code-search-tools-teams): Sourcegraph, GitHub code search, Zoekt, OpenGrok, Greptile and repowise compared on exact, symbol and semantic search, self-hosting, price and agent access.
- [Best Codebase Documentation Tools for AI Coding Agents (2026)](https://repowise.dev/blog/comparisons/best-codebase-documentation-tools-ai-agents): Eight tools that document a codebase for AI coding agents, compared on MCP access, freshness and private repos, with data on why hubs and owners matter.
- [Best Code Visualization Tools in 2026: Graphs, Maps and Diagrams](https://repowise.dev/blog/comparisons/best-codebase-visualization-tools): Seven code visualization tools compared on what each draws from source code and what it costs, plus what a map must show, from 195 real repos.
- [Best Dead Code Detection Tools by Language (2026)](https://repowise.dev/blog/comparisons/best-dead-code-detection-tools): Knip for TypeScript, Vulture for Python, deadcode for Go, PHPStan for PHP and repowise for mixed repos. We found dead code in 96% of 190 popular repos.
- [Best Dependency Graph Tools for Monorepos in 2026](https://repowise.dev/blog/comparisons/best-dependency-graph-tools-monorepos): Nx, Turborepo, Madge, dependency-cruiser, Knip and repowise compared, with data from 195 repos: 89% have circular import chains between files.
- [Git Analytics Tools: Code-Level and Team-Level, Compared](https://repowise.dev/blog/comparisons/best-git-analytics-tools): Ten git analytics tools compared with November 2026 prices, plus data from 195 repos: 10% of files take 68% of churn and 60% have one main author.
- [Best GitHub PR Review Bots in 2026: 8 Compared With Pricing](https://repowise.dev/blog/comparisons/best-github-pr-review-bots-2026): The best PR review bots for GitHub in 2026 are CodeRabbit, Greptile and Copilot code review for AI review, and repowise or Reviewdog for repeatable checks.
- [Best MCP Servers in 2026: Coding Agents and Awesome Lists](https://repowise.dev/blog/comparisons/best-mcp-servers-coding-agents): The best MCP servers in 2026 for coding agents, from Context7 and GitHub to Playwright and repowise, plus the awesome MCP servers lists to find more.
- [Best Open Source Alternatives to CodeScene in 2026](https://repowise.dev/blog/comparisons/best-open-source-codescene-alternatives): repowise, code-maat, PyDriller and SonarQube Community Build compared as open source CodeScene alternatives for hotspots, ownership and code health.
- [Best Refactoring Tools in 2026: What to Fix First and How](https://repowise.dev/blog/comparisons/best-refactoring-tools): IDE refactorings, AI agents, Moderne, CodeScene and repowise compared. In 173 popular repos, the least-healthy 20% of files held 60% of bug-fixed files.
- [Best Self-Hosted Codebase Documentation Tools in 2026](https://repowise.dev/blog/comparisons/best-self-hosted-codebase-documentation): Compare repowise, Backstage TechDocs, BookStack, Outline, Docusaurus and GitBook for self-hosted codebase documentation, with licenses, auth and pricing.
- [Best Static Analysis Tools in 2026, Compared for Large Codebases](https://repowise.dev/blog/comparisons/best-static-analysis-tools-large-codebases): SonarQube, Semgrep, CodeQL, Snyk Code, Veracode, Coverity and free linters compared on price and depth, plus data from 195 large repos on where risk sits.
- [Best Code Coverage Tools in 2026: Language Tools and Platforms](https://repowise.dev/blog/comparisons/best-test-coverage-tools): Code coverage tools compared: JaCoCo, coverage.py, Istanbul, Go cover, Codecov, Coveralls, SonarQube, Qlty and repowise, with pricing and a decision guide.
- [Best Tools for Engineering Managers to See Codebase Risk (2026)](https://repowise.dev/blog/comparisons/best-tools-engineering-managers-codebase-risk): CodeScene and repowise show codebase risk at file level; LinearB, Swarmia, Jellyfish and DX show delivery and capacity. Compared on price and fit, October 2026.
- [Best Tools for Onboarding Engineers in 2026](https://repowise.dev/blog/comparisons/best-tools-for-onboarding-engineers): The best tools for onboarding engineers in 2026: repowise, Swimm, CodeTour, Backstage, Stack Internal and Confluence or Notion, with a stack by team size.
- [Best Tools to Generate CLAUDE.md and AGENTS.md Files](https://repowise.dev/blog/comparisons/best-tools-generate-claude-md-agents-md): Claude Code /init, Codex, GitHub Copilot, Cursor rules, Aider and repowise compared on what each writes, how it stays fresh, and which fits your repo.
- [Best Tools to Understand a Legacy Codebase Fast](https://repowise.dev/blog/comparisons/best-tools-understand-legacy-codebase): Compare repowise, Sourcegraph, DeepWiki, CodeScene and Aider for understanding a legacy codebase, with pricing, private repo support and a day-one audit plan.
- [Best Codebase Documentation Tools in 2026: Six Compared](https://repowise.dev/blog/comparisons/best-codebase-documentation-tools-2026): repowise, DeepWiki, Google Code Wiki, CodeScene, Sourcegraph and Swimm compared on generated docs, self-hosting, git history, price and MCP for agents.
- [repowise vs CodeScene: Code Health, Hotspots and Agent Access](https://repowise.dev/blog/comparisons/repowise-vs-codescene): CodeScene is the established behavioural analysis product; repowise is open source, self-hostable and serves code health and git history to agents over MCP.
- [repowise vs DeepWiki: Self-Hosted Codebase Docs That Stay Fresh](https://repowise.dev/blog/comparisons/repowise-vs-deepwiki): DeepWiki by Cognition writes a hosted wiki for a public GitHub repo. repowise runs on your machine and adds git history, code health and ten MCP tools.
- [repowise vs Google Code Wiki: Public Repos, Private Code and What Each Does](https://repowise.dev/blog/comparisons/repowise-vs-google-codewiki): Google Code Wiki documents public GitHub repos for free. repowise runs on private repos today and adds git history, code health and ten MCP tools.
- [repowise vs Sourcegraph: Code Search or Codebase Intelligence?](https://repowise.dev/blog/comparisons/repowise-vs-sourcegraph): Sourcegraph is the leader in cross-repo code search. repowise is an open-source index with docs, git risk, code health and ten MCP tools. See which fits.

## Indexed repositories

4,037 public repositories are indexed and browsable. Each repository serves the same seven pages: /overview (health, hotspots, structure), /architecture (dependency graph and layered C4 view), /code-health (code health, hotspots, coverage, dead code), /docs (generated documentation), /commits (per-commit change risk), /owners (ownership and bus factor), and /decisions (architectural decision records mined from history). Append the path to any repository URL.

Repo pages for agents: https://repowise.dev/repo/{owner}/{name}.md (or the page URL with `Accept: text/markdown`) gives what the repo is, how to install it, how it works, code health and maintenance, as of an indexed commit.

- [Explore](https://repowise.dev/explore): Every indexed repository, searchable by owner, name, language, and stars
- [Health leaderboard](https://repowise.dev/leaderboard): The curated repositories ranked by deterministic code-health score

## Optional

- [Full content dump](https://repowise.dev/llms-full.txt): Expanded page content for LLM ingestion
- [Docs full content dump](https://docs.repowise.dev/llms-full.txt): Full documentation text
- Support: hello@repowise.dev
- GitHub: https://github.com/repowise-dev/repowise
- Discord: https://discord.gg/cQVpuDB6rh
- Docs: https://docs.repowise.dev (docs index for LLMs: https://docs.repowise.dev/llms.txt)