Skip to content
sdsvnPublic

Repository files navigation

Co-Review logo

Co-Review

You built it with your coding agent. Review the whole repository together, and make it yours again.

Made for Claude Code. Native packages for Pi and Oh My Pi. Works with any MCP agent.

Built on Eclipse Theia Made for Claude Code Pi and Oh My Pi Platforms

Co-Review - Read the whole repository with the agent that built it | Product Hunt

Website · Install · Connect your agent · Usage · Docs · Contributing

Building with an agent is fast. Change by change, each diff looks fine, and months later the codebase works but no longer feels like yours: you don't know where things live or why they're built the way they are. Co-Review is for getting it back. Once in a while, open the entire repository as a review and read it with the agent that built it, the way you'd read a pull request. Comment on a line, a function, a file or a folder, and ask why; the agent answers in the thread, from the code. An overview shows where to start, the agent can take a first pass with findings grouped by area, and coverage tracks what you've read.

Reading the whole repository, to learn it and find its weak spots, is one of the jobs below, each one command away. In every one the agent sets up the review and takes a first pass before you see it, so it opens on what to look at (how each workflow goes):

Review Claude Code Pi / Oh My Pi
Understand the whole repository: the agent writes a guide to what it does, its map, vocabulary, flows, patterns and naming, with C4 diagrams. No findings, no verdict /co-review:understand /co-review-understand
Audit the whole repository, once you know it: a short overview and the agent's findings by area /co-review:audit /co-review-audit
Your change: the agent's diff as a pull-request page, with line comments, suggested edits and one verdict /co-review:review /co-review-change
Someone else's pull request: the agent takes the first pass, you decide what goes back to the author, and post it to GitHub as a review with line comments /co-review:pr <n> /co-review-pr <n>
A design, before the code: an L1 · L2 · L3 plan with Mermaid diagrams, revised from your comments before anything is built /co-review:design <task> /co-review-design <task>

Co-Review is a review tool with IDE features, not an IDE. It's built on Eclipse Theia, so navigation, search, Git and language servers are the real thing; everything unrelated to reviewing is removed.

 you ── inline threads, Ask Agent, Submit review ──┐
                                                   ▼
                     Co-Review  (desktop app or browser)
                      │  reviews live in ~/.co-review, outside the repo
       ┌──────────────┼─────────────────────┐
  Claude Code     Pi / Oh My Pi        any MCP client
  plugin          packages             (Codex, Cursor, VS Code, …)
       │              │                     │
  the agent that did the work opens the review and answers your comments —
  or Co-Review launches an agent for a question (ACP: Claude Code, Codex,
  Gemini, OpenCode, Goose, Pi, Oh My Pi, with the model you pick)

Features

  • Whole-repository reviews with an overview page, per-area coverage (Cmd+Alt+V marks a file viewed) and an agent first pass whose findings arrive proposed for you to accept or dismiss, collected on an overview page you read like a report and comment on like any document.
  • Inline threads on a line, range, symbol, file, folder or the whole repository. Comments are anchored to their symbol and Tree-sitter tokens, so they follow the code through edits and are marked outdated instead of drifting.
  • Agents as reviewers. Select code and Ask Agent: the answer streams into the thread with the agent's steps, and permission requests become buttons.
  • A repository map (Tree-sitter, built on demand, stored outside the repo) that takes agents straight to the right code. With Graphify installed (uv tool install graphifyy), Co-Review also builds a code graph of the repository (Tree-sitter, no LLM, seconds), so the overview shows the most connected code, the clusters and how they connect.
  • Design review: rendered Markdown, Mermaid diagrams with per-node comments, and an L1 · L2 · L3 design tree whose structure is declared and checked.
  • Patches and knowledge bundles: .patch / .diff files open as pull-request pages; OKF bundles open as commentable pages linked to the code.
  • One verdict — Approve, Request changes or Comment — and the agent gets every open comment in one batch. For a GitHub pull request, the same verdict posts to it as a review with line comments and suggestions (gh).
  • Phone view to read, reply and submit away from your desk.

Install

macOS and Linux:

curl -fsSL https://sdsvn.github.io/co-review/install.sh | bash

This installs the desktop app (macOS on Apple silicon, Linux x64 and arm64) and the co-review command, which runs on the app's own runtime (no Node.js needed). Run it again to update; CO_REVIEW_VERSION=v0.2.0 pins a release. Windows: use the installer from the latest release.

co-review ~/src/my-service     # open a repository

To build from source instead, see Contributing.

The builds are not code-signed yet. install.sh takes care of that on macOS. If you download a release file by hand, macOS may say the app "is damaged": run xattr -dr com.apple.quarantine /Applications/Co-Review.app once. On Windows, SmartScreen asks first: choose More info → Run anyway. Intel Macs have no prebuilt app; build from source.

Co-Review collects no telemetry and needs no account. Reviews are stored on your machine in ~/.co-review; your code goes to the agent you choose, and to GitHub only when you post a review there.

Connect your agent

Every integration launches Co-Review through the co-review command, so install it first. Inside Co-Review, Connect an Agent in the Review panel sets up any of the harnesses below for you.

Claude Code

/plugin marketplace add sdsvn/co-review
/plugin install co-review@co-review
Command What Claude does
/co-review:understand [focus] Helps you understand the whole repository: a guide to what it does, its map, vocabulary, flows, patterns and naming and how to change it, with C4 diagrams and a check question per chapter, then answers your questions. No findings, no verdict. Takes the agent a few minutes
/co-review:audit [focus] Reviews the whole repository for problems: a short overview, where it hurts, and proposed findings by area, then acts on your verdict. Takes the agent a few minutes
/co-review:review [base] Opens its change (the diff) as a pull-request page, points out what deserves attention, answers your comments and acts on your verdict
/co-review:pr <n> Reviews someone else's pull request with you: its first pass, your verdict, then posted to the pull request (line comments, suggestions, your decision) when you choose to
/co-review:design <task> Writes a design doc, has you review it, implements what you approved

With Claude Code's channels on, your questions reach the running session the moment you ask. A background co-reviewer subagent can keep answering while the main conversation fixes things, and a session hook tells Claude which reviews are waiting. Plain requests ("review this with me") work too.

Pi and Oh My Pi

Both ship inside Co-Review, so there is nothing to clone:

co-review setup pi     # or: co-review setup omp

You get the same co_review_* tools and /co-review-understand, /co-review-audit, /co-review-change, /co-review-pr and /co-review-design commands in both (plus /co-review to join the review of the working directory), plus a co-reviewer agent and the skills. In Oh My Pi, only the main session listens for your questions, not every task subagent. Details: Pi and Oh My Pi.

Other agents

Codex, Cursor, VS Code, Gemini CLI, Zed, OpenCode, Goose and any other MCP client: add the MCP server (co-review mcp, config for each) and, optionally, the skills with npx skills add sdsvn/co-review. The full contract is in llms.txt.

Or let Co-Review launch the agent

For quick questions while you review, ⋯ → Connect agent… in the Review panel starts an ACP agent (Claude Code, Codex, Gemini, OpenCode, Goose, Pi or Oh My Pi) with the model you pick. Then select code → Ask Agent (Cmd+Alt+A). See Agents for when to use which.

Important

Agents and language servers use Co-Review's environment. The desktop app loads your login shell's PATH, and co-review passes on the terminal's.

Usage

Open the Review panel (status bar, or Cmd+Shift+Alt+R) and pick what to review: the entire repository, the current file, a branch against its base, or a commit. Or right-click files or folders → Start Review of Selection.

To comment on Do this
A line or range Click + in the gutter (drag for a range), or select and press Cmd+Alt+M
A symbol Right-click inside it → Add Review Comment on Symbol
A file or folder Right-click it in the explorer → Add Review Comment
The repository ⋯ in the Review panel → Comment on the repository

Once an agent is connected, asking it is the default (Ask Agent); Comment is the deliberate choice for feedback that goes with your verdict. Reply, resolve and collapse threads inline; the panel lists them by file (Open / Proposed / Resolved / All), and ⋯ has the rest.

  • Whole repository: the panel's Coverage shows what you've viewed, overall and per area. Overview says where to start, and Findings opens every finding and comment as one page. /co-review:understand (or /co-review-understand in Pi and Oh My Pi) has the agent write you a guide first; /co-review:audit has it find the problems first.
  • Designs and pages: Markdown files open rendered (the toolbar opens the source; opening at a line goes to the editor). Comment on text, diagram nodes and edges, or design steps. HTML files open as source; Open in Browser (editor or explorer context menu) shows the page in your browser. See Design documents.
  • Phone: ⋯ → Open mobile view, or http://<host>:<port>/m/ (local connections only; over Tailscale).

Keyboard shortcuts

Cmd on macOS, Ctrl elsewhere. Every command is also in the command palette under Review:.

Shortcut Action
Cmd+Alt+M / Cmd+Alt+A Comment on / ask the agent about the line or selection
Cmd+Alt+↓ / Cmd+Alt+↑ Next / previous comment
Cmd+Alt+O Go to comment…
Cmd+Alt+V Mark the file as viewed (or not)
Cmd+Enter / Esc Submit / discard an empty draft
Cmd+Shift+Alt+R Show or hide the Review panel

Language support (TypeScript, JavaScript, JSON, Markdown, PHP, Go with gopls, and how to add more), configuration variables and themes are covered in Running and packaging.

Documentation

Published at https://sdsvn.github.io/co-review/.

Contributing

Requires Node.js 20+, Git and a C/C++ toolchain (Xcode command-line tools on macOS, build-essential on Linux).

make install                       # npm install + bundled extensions into plugins/
make start REPO=/path/to/repo      # browser app on http://127.0.0.1:3000
make desktop REPO=/path/to/repo    # desktop app
make dev                           # rebuild on change
make install-cli                   # `co-review` command running from this checkout
make package                       # installers in applications/electron/dist
make help                          # all targets

The browser and desktop apps compile native modules for different runtimes; make browser and make desktop-build switch between them, so build the one you run. Agent instructions (skills, commands, subagents, tool text) are written once in prompts/: edit them there and run make prompts. There are no automated tests yet: changes are verified in the running app and with scripted MCP and ACP clients against a local server. Releases are built by .github/workflows/release.yml when a v* tag is pushed.

applications/            Theia browser and desktop apps (composition, electron-builder config)
extensions/review        the review extension (common · node · electron-node · browser)
bin/                     co-review CLI, install-cli.sh, review server mode, gen-prompts.mjs
prompts/                 the agent prompts, written once; `make prompts` copies them everywhere
plugin/, .claude-plugin/ Claude Code plugin and its marketplace manifest
integrations/shared      the Pi / Oh My Pi extension and slash commands
integrations/pi, omp     Pi and Oh My Pi packages (harness adapter, co-reviewer agent)
docs/                    guides (the source of the website's docs)
site/                    website: Astro + Starlight (`cd site && npm run dev`), deployed from main
llms.txt                 integration contract for agents

See Architecture and Running and packaging for details.

Star History

Star History Chart

License

MIT. Co-Review is built on Eclipse Theia and other open-source components under their own licenses; see third-party notices.

Releases

Packages

Contributors

Languages