Skip to content
Back to search

aclarify

MarketplaceWorks with Claude CodeGitHub

AI-powered multi-agent code review. Simulates a customizable team of Engineers performing code review with built-in discourse.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/spencermarx/open-code-review with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/spencermarx/open-code-review'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/spencermarx-open-code-review/badge.svg)](/listings/spencermarx-open-code-review)

HTML

<a href="/listings/spencermarx-open-code-review"><img src="/api/listings/spencermarx-open-code-review/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Prerequisites:** Node.js >= 22.5, Git, and an [AI coding assistant](#supported-ai-tools).

# 1. Install the CLI globally
npm install -g @open-code-review/cli

# 2. Initialize OCR in your project
cd your-project
ocr init

# 3. Launch the dashboard and run your first review
ocr dashboard

Your browser will open the OCR dashboard — you're ready to run your first review.

> **Any package manager works.** From **v2.1** OCR uses Node's built-in SQLite (`node:sqlite`) — there's > no native module to compile, so `npm i -g`, `pnpm add -g`, and `yarn global add` all install cleanly > (including under pnpm 10+, which blocks dependency build scripts). It just needs **Node >= 22.5**.

`ocr init` detects your installed AI tools (Claude Code, Cursor, Windsurf, and [11 more](#supported-ai-tools)) and configures each one automatically. Then open the dashboard to run a review, browse results, and manage your workflow from the browser.

Or run reviews directly from your AI coding assistant:

/ocr:review                                    # Claude Code / Cursor
/ocr-review                                    # Windsurf / other tools
/ocr-review Review against openspec/spec.md    # With requirements

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "aclarify",
  3. "owner": {
  4. "name": "Spencer Marx",
  5. "url": "https://github.com/spencermarx"
  6. },
  7. "metadata": {
  8. "description": "Multi-agent code review tools for AI-assisted development"
  9. },
  10. "plugins": [
  11. {
  12. "name": "ocr",
  13. "source": "./packages/agents",
  14. "category": "development"
  15. }
  16. ]
  17. }
README.md · README · 686 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <!--
  2. The cover banner IS the H1: a real, indexable <h1> element whose accessible /
  3. scraped name comes from the image alt ("Open Code Review"). This keeps the
  4. semantic heading for SEO + screen readers + the document outline while removing
  5. the visually-redundant text line that duplicated the wordmark already in the
  6. cover. (GitHub strips inline `style`, so a CSS-hidden <h1> is not an option —
  7. wrapping the banner in the heading is the GitHub-valid equivalent.)
  8. -->
  9. <h1 align="center">
  10. <img src="assets/OCR-Github-Cover.png" alt="Open Code Review" width="100%" />
  11. </h1>
  12. <p align="center">
  13. <strong>Customizable multi-agent code review for AI-assisted development</strong>
  14. </p>
  15. <p align="center">
  16. <a href="https://www.npmjs.com/package/@open-code-review/cli"><img src="https://img.shields.io/npm/v/@open-code-review/cli.svg" alt="npm version"></a>
  17. <a href="https://github.com/spencermarx/open-code-review/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="License"></a>
  18. </p>
  19. ---
  20. ## Quick Start
  21. **Prerequisites:** Node.js >= 22.5, Git, and an [AI coding assistant](#supported-ai-tools).
  22. ```bash
  23. # 1. Install the CLI globally
  24. npm install -g @open-code-review/cli
  25. # 2. Initialize OCR in your project
  26. cd your-project
  27. ocr init
  28. # 3. Launch the dashboard and run your first review
  29. ocr dashboard
  30. ```
  31. Your browser will open the OCR dashboard — you're ready to run your first review.
  32. > **Any package manager works.** From **v2.1** OCR uses Node's built-in SQLite (`node:sqlite`) — there's
  33. > no native module to compile, so `npm i -g`, `pnpm add -g`, and `yarn global add` all install cleanly
  34. > (including under pnpm 10+, which blocks dependency build scripts). It just needs **Node >= 22.5**.
  35. `ocr init` detects your installed AI tools (Claude Code, Cursor, Windsurf, and [11 more](#supported-ai-tools)) and configures each one automatically. Then open the dashboard to run a review, browse results, and manage your workflow from the browser.
  36. Or run reviews directly from your AI coding assistant:
  37. ```
  38. /ocr:review # Claude Code / Cursor
  39. /ocr-review # Windsurf / other tools
  40. /ocr-review Review against openspec/spec.md # With requirements
  41. ```
  42. ---
  43. ## Why Open Code Review?
  44. When you ask an AI to "review my code," you get a single perspective — one pass, one set of priorities. OCR changes that fundamentally:
  45. - **Multi-agent redundancy** — Multiple reviewer instances examine your code independently. Different attention patterns catch different issues. What one reviewer misses, another finds.
  46. - **Discourse before synthesis** — Reviewers don't just produce findings — they debate them. They challenge assumptions, validate concerns, and surface questions no single reviewer would ask.
  47. - **Fully customizable teams** — Pick from 28 reviewer personas (including famous engineers like Martin Fowler, Kent Beck, and Sandi Metz), create your own persistent reviewers, or describe ephemeral one-off reviewers inline.
  48. - **Requirements-aware** — Pass in a spec, proposal, or acceptance criteria. Every reviewer evaluates the code against your stated requirements, not just general best practices.
  49. - **Project context** — OCR discovers your standards from `CLAUDE.md`, `.cursorrules`, OpenSpec configs, and other common patterns. Reviewers apply *your* conventions.
  50. ```
  51. ┌─────────────┐
  52. │ Tech Lead │ ← Orchestrates the review
  53. └──────┬──────┘
  54. │
  55. ┌─────────────────┼─────────────────┐
  56. │ │ │
  57. ▼ ▼ ▼
  58. ┌─────────────────┐ ┌─────────────┐ ┌─────────────────┐
  59. │ Your Team │ │ Your Team │ │ Your Team │
  60. │ Composition │ │ Composition│ │ Composition │
  61. └─────────────────┘ └─────────────┘ └─────────────────┘
  62. │ │ │
  63. └─────────────────┼─────────────────┘
  64. │
  65. ┌──────▼──────┐
  66. │ Discourse │ ← Reviewers debate findings
  67. └──────┬──────┘
  68. │
  69. ┌──────▼──────┐
  70. │ Synthesis │ ← Unified, prioritized feedback
  71. └─────────────┘
  72. ```
  73. > **Note**: OCR does not replace human code review. The goal is to reduce the burden on human reviewers by catching issues earlier — so human review is faster and more focused on things machines can't catch.
  74. ---
  75. ## Table of Contents
  76. - [The Dashboard](#the-dashboard)
  77. - [IDE & CLI Workflows](#ide--cli-workflows)
  78. - [Features](#features)
  79. - [Multi-Agent Review](#multi-agent-review)
  80. - [Multi-Model Teams](#multi-model-teams)
  81. - [Code Review Maps](#code-review-maps)
  82. - [Requirements-Aware Review](#requirements-aware-review)
  83. - [Reviewer Discourse](#reviewer-discourse)
  84. - [GitHub PR Posting](#github-pr-posting)
  85. - [Multi-Round Reviews](#multi-round-reviews)
  86. - [Custom Reviewers](#custom-reviewers)
  87. - [Famous Engineer Personas](#famous-engineer-personas)
  88. - [Ephemeral Reviewers](#ephemeral-reviewers)
  89. - [Real-Time Progress](#real-time-progress)
  90. - [Address Feedback](#address-feedback)
  91. - [Session Notes & Chat](#session-notes--chat)
  92. - [Configuration](#configuration)
  93. - [Commands Reference](#commands-reference)
  94. - [Updating OCR](#updating-ocr)
  95. - [Supported AI Tools](#supported-ai-tools)
  96. - [Requirements](#requirements)
  97. - [Contributing](#contributing)
  98. ---
  99. ## The Dashboard
  100. The dashboard is the recommended way to run reviews, browse results, and manage your workflow. Launch it with `ocr dashboard`.
  101. ### Run reviews and maps
  102. The **Command Center** lets you launch multi-agent code reviews and Code Review Maps directly from the dashboard. Specify targets, add requirements, toggle fresh starts — then watch live terminal output as agents work.
  103. <p align="center">
  104. <img src="assets/ocr-tool-command-center.png" alt="OCR Dashboard Command Center" width="700" />
  105. </p>
  106. ### Browse and triage reviews
  107. View verdict banners, individual reviewer cards, findings tables, and cross-reviewer discourse for every review round. Set triage status on findings (needs review, in progress, changes made, acknowledged, dismissed) with filtering and sorting.
  108. <p align="center">
  109. <img src="assets/ocr-tool-focused-review.png" alt="OCR review output with findings" width="700" />
  110. </p>
  111. ### Explore Code Review Maps
  112. Navigate large changesets with section-based breakdowns, rendered Mermaid dependency graphs, and file-level progress tracking.
  113. <p align="center">
  114. <img src="assets/ocr-tool-focused-code-review-map.png" alt="OCR Code Review Map" width="700" />
  115. </p>
  116. ### Post to GitHub
  117. Two posting modes from the review round page:
  118. - **Post Team Review** — Posts the multi-reviewer synthesis as-is
  119. - **Generate Human Review** — AI-rewrites all findings into a single, natural human voice following [Google's code review guidelines](https://google.github.io/eng-practices/review/reviewer/). Preview, edit, and save drafts before posting.
  120. <p align="center">
  121. <img src="assets/ocr-tool-translate-to-human-review-button.png" alt="Post Review to GitHub dialog" width="700" />
  122. </p>
  123. <p align="center">
  124. <img src="assets/ocr-tool-example-translated-human-review.png" alt="Human-voice review posted to GitHub PR" width="700" />
  125. </p>
  126. ### Manage your review team
  127. The **Team** page lets you browse all 28 reviewer personas grouped by tier (Generalists, Specialists, Famous Engineers, Custom). View full prompts, focus areas, and persona details. Create new reviewers or sync metadata — all from the dashboard.
  128. <p align="center">
  129. <img src="assets/ocr-tool-manage-reviewers-team.png" alt="OCR Team page for managing reviewer personas" width="700" />
  130. </p>
  131. ### Set your default team composition
  132. Pick which personas show up on every review and how many instances of each — your default lineup, persisted to `.ocr/config.yaml`.
  133. <p align="center">
  134. <img src="assets/ocr-default-team-composition.png" alt="OCR default team composition editor" width="700" />
  135. </p>
  136. ### Assign models per reviewer
  137. Different reviewers, different models. Pair a fast model on a generalist with a deeper model on a specialist, mix vendors across a single team, or set a workspace-wide default. The dashboard discovers your installed vendor (Claude Code or OpenCode) and lists every model it offers.
  138. <p align="center">
  139. <img src="assets/ocr-default-reviewer-model-configuration.png" alt="Per-reviewer model configuration on the Team page" width="700" />
  140. </p>
  141. ### Override the team for a single review
  142. Need a heavier-hitting model for one risky changeset? The Command Center lets you swap personas and models per-review without touching your saved defaults.
  143. <p align="center">
  144. <img src="assets/ocr-per-review-model-configuration.png" alt="Per-review model configuration in the Command Center" width="700" />
  145. </p>
  146. ### Address Feedback
  147. After reviewing findings, address them directly. Copy a portable AI prompt into any coding tool, or — with Claude Code or OpenCode detected — run an agent directly from the dashboard to corroborate, validate, and implement changes.
  148. ### Ask the Team
  149. AI-powered chat on every review round and map run page. Ask follow-up questions about specific findings, request clarification on reviewer reasoning, or explore alternative approaches.
  150. The chat is read-only: the AI can only read and search files in your repository. It requires Claude Code 2.1.295 or later, or OpenCode 1.3.4 or later (1.x).
  151. The dashboard reads from the same `.ocr/` directory and SQLite database used by the review workflow. No separate configuration is needed.
  152. ---
  153. ## IDE & CLI Workflows
  154. Run all OCR commands directly from your AI coding assistant using slash commands.
  155. ### Start a review
  156. ```bash
  157. git add .
  158. ```
  159. Then in your AI assistant:
  160. ```
  161. /ocr-review # Windsurf / flat-prefix tools
  162. /ocr:review # Claude Code / Cursor
  163. /ocr-review Review against openspec/spec.md # With requirements context
  164. ```
  165. ### Watch progress in real-time
  166. In a separate terminal:
  167. ```bash
  168. ocr progress
  169. ```
  170. ```
  171. Open Code Review
  172. 2026-01-26-main · Round 2 · 1m 23s
  173. ━━━━━━━━━━━━━━━━──────── 60% · Parallel Reviews
  174. ✓ Context Discovery
  175. ✓ Change Context
  176. ✓ Tech Lead Analysis
  177. ▸ Parallel Reviews
  178. Round 2
  179. ✓ Principal #1 2 │ ✓ Principal #2 1 │ ○ Quality #1 0 │ ○ Quality #2 0
  180. Round 1 ✓ 4 reviewers
  181. · Aggregate Findings
  182. · Reviewer Discourse
  183. · Final Synthesis
  184. Ctrl+C to exit
  185. ```
  186. ### More AI assistant commands
  187. ```
  188. /ocr-map # Generate a Code Review Map for large changesets
  189. /ocr-post # Post review to GitHub PR
  190. /ocr-doctor # Verify installation
  191. /ocr-reviewers # List available reviewer personas
  192. /ocr-history # List past review sessions
  193. /ocr-show [session] # Display a specific past review
  194. ```
  195. For Claude Code / Cursor, use `/ocr:review`, `/ocr:map`, `/ocr:post`, etc.
  196. ---
  197. ## Features
  198. ### Multi-Agent Review
  199. OCR follows an 8-phase workflow orchestrated by a Tech Lead agent:
  200. | Phase | What happens |
  201. |-------|--------------|
  202. | 1. Context Discovery | Load config, discover project standards, read OpenSpec context |
  203. | 2. Change Analysis | Analyze `git diff`, understand what changed and why |
  204. | 3. Tech Lead Assessment | Summarize changes, identify risks, select reviewer team |
  205. | 4. Parallel Reviews | Each reviewer examines code independently based on your team config |
  206. | 5. Aggregation | Merge findings from redundant reviewers |
  207. | 6. Discourse | Reviewers challenge, validate, and connect findings |
  208. | 7. Synthesis | Produce prioritized, deduplicated final review |
  209. | 8. Presentation | Display results; optionally post to GitHub |
  210. ### Multi-Model Teams
  211. Different reviewers can run on different models. Pair a fast generalist on Sonnet with a deep specialist on Opus, share a single model across a redundancy pair, or define personal aliases like `workhorse`/`big-brain` so config reads naturally.
  212. ```yaml
  213. # .ocr/config.yaml
  214. models:
  215. aliases:
  216. workhorse: claude-sonnet-4-6
  217. big-brain: claude-opus-4-7
  218. default: claude-sonnet-4-6 # used when an instance has no explicit model
  219. default_team:
  220. # Form 1 — shorthand: N instances, default model
  221. quality: 2
  222. # Form 2 — object: N instances, all sharing one model
  223. security: { count: 1, model: big-brain }
  224. # Form 3 — list: per-instance model and optional name
  225. principal:
  226. - { model: big-brain }
  227. - { model: workhorse, name: principal-balanced }
  228. ```
  229. Override per-review from the Command Center, or via `--team` on the command line. The dashboard auto-discovers every model your installed vendor (Claude Code or OpenCode) offers — no need to memorize identifiers.
  230. ### Code Review Maps
  231. For large changesets (20+ files), Code Review Maps provide a structured navigation document — grouping related changes into sections, identifying key files, and surfacing dependencies with Mermaid diagrams.
  232. ```
  233. /ocr-map # Map staged changes
  234. /ocr-map HEAD~10 # Map last 10 commits
  235. /ocr-map feature/big-refactor # Map branch vs main
  236. /ocr-map --requirements spec.md # Map with requirements context
  237. ```
  238. Three specialized agents (Map Architect, Flow Analyst, Requirements Mapper) run with configurable redundancy. Browse maps in the dashboard with dependency graphs and file-level progress tracking.
  239. **When to use a map**: Large changesets where you'd spend time figuring out where to start, or to orient a teammate before they dive into the code. For most changesets, `/ocr-review` alone is sufficient.
  240. ### Requirements-Aware Review
  241. OCR is most powerful when reviewing code against explicit requirements:
  242. ```
  243. /ocr-review Review against openspec/specs/cli/spec.md # Spec file
  244. /ocr-review Check against openspec/changes/add-auth/proposal.md # Proposal
  245. /ocr-review Requirements: # Inline
  246. - Max 100 requests per minute per user
  247. - Return 429 with Retry-After header
  248. /ocr-review This fixes BUG-1234 where users bypassed rate limiting # Ticket
  249. ```
  250. Requirements propagate to all reviewers. The final synthesis includes a **Requirements Verification** table showing which requirements are met, which have gaps, and any ambiguities.
  251. ### Reviewer Discourse
  252. Before producing the final review, reviewers examine each other's findings in a structured debate:
  253. - **AGREE** — Validate findings with supporting evidence
  254. - **CHALLENGE** — Question assumptions or reasoning
  255. - **CONNECT** — Relate findings across reviewers
  256. - **SURFACE** — Raise new concerns from the debate
  257. This catches false positives, strengthens valid findings, and surfaces issues that no single reviewer would find alone.
  258. ### GitHub PR Posting
  259. Post reviews directly to your PR from the dashboard or your AI assistant:
  260. ```
  261. /ocr-post
  262. ```
  263. Two modes:
  264. - **Team Review** — Posts the multi-reviewer synthesis as-is
  265. - **Human Review Translation** — AI-rewrites findings into a natural, first-person voice following Google's code review guidelines. Preview, edit, and save drafts before posting.
  266. <p align="center">
  267. <img src="assets/github-code-review-example.png" alt="OCR review posted to GitHub PR" width="700" />
  268. </p>
  269. **Prerequisites**: GitHub CLI (`gh`) installed and authenticated, open PR on current branch.
  270. ### Multi-Round Reviews
  271. OCR supports iterative review cycles:
  272. | Round | Trigger | Use case |
  273. |-------|---------|----------|
  274. | `round-1/` | First `/ocr-review` | Initial code review |
  275. | `round-2/` | Second `/ocr-review` after round-1 completes | Re-review after addressing feedback |
  276. | `round-3+` | Subsequent runs | Further iteration |
  277. Running `/ocr-review` on an existing session checks if the current round is complete. If complete, it starts a new round. Previous rounds are preserved — shared context (`discovered-standards.md`, `context.md`) is reused across rounds.
  278. ### Custom Reviewers
  279. OCR ships with 28 reviewer personas across four tiers — generalists, specialists, famous engineers, and custom. Browse and manage them from the dashboard's **Team** page, or create your own.
  280. Three ways to build your review team:
  281. | Mode | How | Persists? |
  282. |------|-----|-----------|
  283. | **Library reviewers** | Select from the Team page or `--team` flag | Yes |
  284. | **Custom persistent** | Create via `/ocr:create-reviewer` | Yes |
  285. | **Ephemeral** | Describe inline via `--reviewer` at review time | No |
  286. **Create a custom reviewer** from your AI assistant:
  287. ```
  288. /ocr:create-reviewer api-design --focus "REST API design, backwards compatibility, versioning, error response consistency"
  289. ```
  290. This generates a reviewer file following the standard template, syncs metadata, and makes it available in the dashboard immediately.
  291. **Override your team per-review** with the `--team` flag:
  292. ```
  293. /ocr:review --team principal:2,security:1,martin-fowler:1
  294. ```
  295. ### Famous Engineer Personas
  296. Review your code through the lens of industry legends. OCR includes personas for **Martin Fowler**, **Kent Beck**, **Sandi Metz**, **Rich Hickey**, **Kent Dodds**, **Anders Hejlsberg**, **John Ousterhout**, **Kamil Mysliwiec**, **Tanner Linsley**, and **Vladimir Khorikov** — each with review styles, philosophies, and focus areas reflecting their published work.
  297. <p align="center">
  298. <img src="assets/ocr-tool-famous-engineer-reviewers.png" alt="Famous Engineer reviewer personas on the Team page" width="700" />
  299. </p>
  300. Add them to your team like any other reviewer:
  301. ```yaml
  302. # .ocr/config.yaml
  303. default_team:
  304. principal: 2
  305. martin-fowler: 1
  306. sandi-metz: 1
  307. ```
  308. ### Ephemeral Reviewers
  309. Need a one-off review perspective without creating a persistent reviewer? Describe it inline with `--reviewer`:
  310. ```
  311. /ocr:review --reviewer "Focus on error handling in the auth flow"
  312. /ocr:review --team principal:2 --reviewer "Review as a junior developer would" --reviewer "Check accessibility compliance"
  313. ```
  314. Ephemeral reviewers participate in all review phases (parallel reviews, discourse, synthesis) just like library reviewers. They don't persist to the reviewer library — they exist only for that review session.
  315. ### Real-Time Progress
  316. The `ocr progress` command shows a live terminal UI with phase tracking, elapsed time, reviewer status, finding counts, and completion percentage. It auto-detects the latest active session or accepts a `--session` flag.
  317. ### Address Feedback
  318. After a review, use the `/ocr-address` command or the dashboard's "Address Feedback" button to spawn an AI agent that corroborates each finding against actual code, validates the suggestions, and implements the changes — with human approval at each step.
  319. ### Session Notes & Chat
  320. The dashboard supports session-level notes for tracking follow-up items and AI-powered chat on review rounds and map runs for asking follow-up questions about findings.
  321. ---
  322. ## Configuration
  323. After running `ocr init`, edit `.ocr/config.yaml`:
  324. ```yaml
  325. # Project context injected into all reviews
  326. context: |
  327. Tech stack: TypeScript, React, Node.js
  328. Critical: All public APIs must be backwards compatible
  329. # Customize your reviewer team composition
  330. # Three forms — see "Multi-Model Teams" above for the full variants.
  331. default_team:
  332. principal: 2 # Architecture, design patterns
  333. quality: 2 # Code style, best practices
  334. # security: 1 # Auto-added for auth/data changes
  335. # testing: 1 # Auto-added for logic changes
  336. # martin-fowler: 1 # Famous engineer persona
  337. # Optional: model aliases + workspace default
  338. # models:
  339. # aliases:
  340. # workhorse: claude-sonnet-4-6
  341. # big-brain: claude-opus-4-7
  342. # default: claude-sonnet-4-6
  343. # Context discovery
  344. context_discovery:
  345. openspec:
  346. enabled: true
  347. references:
  348. - "CLAUDE.md"
  349. - ".cursorrules"
  350. - "CONTRIBUTING.md"
  351. # Code Review Map tuning
  352. code-review-map:
  353. agents:
  354. flow_analysts: 2
  355. requirements_mappers: 2
  356. # Discourse
  357. discourse:
  358. enabled: true
  359. # GitHub posting
  360. github:
  361. auto_prompt_post: false
  362. comment_format: "single"
  363. # Dashboard integration
  364. dashboard:
  365. ai_cli: auto # auto | claude | opencode | off
  366. ide: auto # vscode | cursor | windsurf | jetbrains | sublime
  367. ```
  368. Team composition can also be changed per-review via `--team` (explicit roster) or `--reviewer` (ephemeral reviewers), or via natural language: "use 3 principal reviewers and add security."
  369. ### Dashboard child-process environment
  370. Reviews launched from the dashboard see the same environment as the shell
  371. where you ran `ocr dashboard` — if it works in your shell, it works in the
  372. dashboard. OCR removes only its own `OCR_*` internals, npm's script-lifecycle
  373. plumbing your shell never had (`npm_*` and `INIT_CWD`), and `NODE_OPTIONS`
  374. (the one intentional difference from your shell — an inherited `--inspect` or
  375. `--require` breaks concurrent review children), and every run's log records
  376. exactly what was removed. The snapshot is taken at launch: variables exported afterwards are
  377. invisible to children until you run `ocr dashboard` again. To withhold a
  378. variable from dashboard children: `env -u VAR ocr dashboard`.
  379. ---
  380. ## Commands Reference
  381. ### AI Assistant Commands
  382. | Command | Description |
  383. |---------|-------------|
  384. | `/ocr-review [target]` | Review staged changes, commits, or branches |
  385. | `/ocr-review --team id:n,...` | Review with a custom team composition |
  386. | `/ocr-review --reviewer "..."` | Add an ephemeral reviewer by description |
  387. | `/ocr-review --fresh` | Clear session and start fresh |
  388. | `/ocr-map [target]` | Generate a Code Review Map for large changesets |
  389. | `/ocr-post` | Post review as a GitHub PR comment |
  390. | `/ocr-create-reviewer name --focus "..."` | Create a custom persistent reviewer |
  391. | `/ocr-sync-reviewers` | Sync reviewer metadata for the dashboard |
  392. | `/ocr-doctor` | Verify installation and dependencies |
  393. | `/ocr-reviewers` | List available reviewer personas |
  394. | `/ocr-history` | List past review sessions |
  395. | `/ocr-show [session]` | Display a specific past review |
  396. | `/ocr-address [final.md]` | Address review feedback with AI agent |
  397. *For Claude Code / Cursor, use `/ocr:review`, `/ocr:map`, etc.*
  398. ### CLI Commands
  399. | Command | Description |
  400. |---------|-------------|
  401. | `ocr init` | Initialize OCR for your AI tools |
  402. | `ocr dashboard` | Start the web dashboard interface |
  403. | `ocr progress` | Watch review progress live |
  404. | `ocr doctor` | Check installation and verify dependencies |
  405. | `ocr update` | Update skills and commands after package upgrade |
  406. | `ocr state` | Manage session state (internal, used by review workflow) |
  407. ---
  408. ## Updating OCR
  409. After upgrading the package, run `ocr update` to sync your project:
  410. ```bash
  411. npm i -g @open-code-review/cli@latest
  412. ocr update
  413. ```
  414. | Asset | Updated? | Notes |
  415. |-------|----------|-------|
  416. | `.ocr/skills/SKILL.md` | Yes | Tech Lead orchestration |
  417. | `.ocr/skills/references/` | Yes | Workflow, discourse rules |
  418. | Tool commands (`.windsurf/`, `.claude/`, etc.) | Yes | Slash command definitions |
  419. | `AGENTS.md` / `CLAUDE.md` | Yes | OCR managed blocks only |
  420. | `.ocr/config.yaml` | **No** | Your customizations preserved |
  421. | `.ocr/skills/references/reviewers/` | **No** | All reviewer personas preserved |
  422. | `.ocr/sessions/` | **No** | Review history untouched |
  423. ```bash
  424. ocr update --dry-run # Preview changes
  425. ocr update --commands # Commands only
  426. ocr update --skills # Skills and references only
  427. ocr update --inject # AGENTS.md/CLAUDE.md only
  428. ```
  429. ---
  430. ## Supported AI Tools
  431. `ocr init` detects and configures all of these automatically:
  432. | Tool | Config Directory |
  433. |------|------------------|
  434. | Amazon Q Developer | `.aws/amazonq/` |
  435. | Augment (Auggie) | `.augment/` |
  436. | Claude Code | `.claude/` |
  437. | Cline | `.cline/` |
  438. | Codex | `.codex/` |
  439. | Continue | `.continue/` |
  440. | Cursor | `.cursor/` |
  441. | Gemini CLI | `.gemini/` |
  442. | GitHub Copilot | `.github/` |
  443. | Kilo Code | `.kilocode/` |
  444. | OpenCode | `.opencode/` |
  445. | Qoder | `.qoder/` |
  446. | RooCode | `.roo/` |
  447. | Windsurf | `.windsurf/` |
  448. ---
  449. ## Requirements
  450. - **Node.js** >= 22.5.0
  451. - **Git** — For diff analysis
  452. - **An AI coding assistant** — Claude Code, Cursor, Windsurf, or [any supported tool](#supported-ai-tools)
  453. - **GitHub CLI** (`gh`) — Optional, for posting reviews to PRs
  454. > **v2.1 — built-in SQLite engine**: OCR stores state with Node's built-in
  455. > SQLite (`node:sqlite`, on-disk + WAL) for durable, concurrent-safe writes —
  456. > **no native module, no prebuilt binary, no install script.** It installs
  457. > cleanly under any package manager (npm, **pnpm 10+**, yarn) on every platform.
  458. > This requires **Node >= 22.5** (when `node:sqlite` landed); on an older Node
  459. > the CLI prints a clear upgrade message. Run `ocr doctor` to verify the engine.
  460. >
  461. > **Upgrading from v1.x or v2.0?** Make sure you're on **Node >= 22.5**, quit any
  462. > running `ocr dashboard`, then `npm i -g @open-code-review/cli@latest` (or
  463. > `pnpm add -g …`). Your existing database upgrades **automatically** on the next
  464. > `ocr` command: a backup is written to `ocr.db.bak.v<n>`, legacy sessions are
  465. > reconciled, and a one-time notice summarizes what happened. No manual steps.
  466. Run `ocr doctor` to verify your setup.
  467. > **Important**: The CLI (`npm install -g @open-code-review/cli`) is required for all OCR workflows. Both review and map commands use `ocr state` for progress tracking at every phase transition.
  468. ---
  469. ## Session Storage
  470. Reviews are persisted to `.ocr/sessions/{date}-{branch}/`:
  471. ```
  472. .ocr/sessions/2026-01-26-feature-auth/
  473. ├── discovered-standards.md # Merged project context (shared)
  474. ├── context.md # Change summary + Tech Lead guidance (shared)
  475. ├── requirements.md # User-provided requirements (shared, if any)
  476. ├── rounds/
  477. │ ├── round-1/
  478. │ │ ├── reviews/ # Individual reviewer outputs
  479. │ │ │ ├── principal-1.md
  480. │ │ │ ├── quality-1.md
  481. │ │ │ └── ephemeral-1.md # From --reviewer (if used)
  482. │ │ ├── discourse.md # Cross-reviewer discussion
  483. │ │ └── final.md # Synthesized final review
  484. │ └── round-2/ # Created on re-review
  485. └── maps/
  486. └── run-1/
  487. ├── map.md # Code Review Map
  488. └── flow-analysis.md # Dependency graph (Mermaid)
  489. ```
  490. Sessions are gitignored by default.
  491. ---
  492. ## Contributing
  493. Contributions are welcome! We use OCR on OCR: before a maintainer reviews a PR, contributors run the repo's OCR review loop (`/ocr-review-loop` in Claude Code, or `/ocr:review` + `/ocr:address` round by round in other tools, `/ocr-review` + `/ocr-address` where commands are flat) until it comes back **APPROVE**, with each round posted to the PR. Non-trivial changes start with an issue, so we can agree on the approach before you build. See [CONTRIBUTING.md](CONTRIBUTING.md) for the why, the how, and what to do if you don't have AI tooling.
  494. ---
  495. ## License
  496. Apache-2.0
  497. ---
  498. ## Links
  499. - **GitHub**: [github.com/spencermarx/open-code-review](https://github.com/spencermarx/open-code-review)
  500. - **npm (CLI)**: [@open-code-review/cli](https://www.npmjs.com/package/@open-code-review/cli)
  501. - **npm (Agents)**: [@open-code-review/agents](https://www.npmjs.com/package/@open-code-review/agents)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.