@open-code-review/cli 1.0.0

package/README.md

@@ -0,0 +1,65 @@
+# @open-code-review/cli
+
+CLI for Open Code Review - Multi-environment setup and progress tracking.
+
+## Installation
+
+```bash
+# Via npx (no install)
+npx @open-code-review/cli init
+
+# Via pnpm dlx
+pnpm dlx @open-code-review/cli init
+
+# Global install
+npm install -g @open-code-review/cli
+ocr init
+```
+
+## Commands
+
+### `ocr init`
+
+Set up OCR for your AI coding environments.
+
+```bash
+# Interactive mode - select tools via checkbox
+ocr init
+
+# Non-interactive - specify tools
+ocr init --tools claude,windsurf,cursor
+
+# Install for all supported tools
+ocr init --tools all
+
+# Skip AGENTS.md/CLAUDE.md injection
+ocr init --no-inject
+```
+
+### `ocr progress`
+
+Watch real-time progress of an active code review session.
+
+```bash
+# Auto-detect current session
+ocr progress
+
+# Specify session
+ocr progress --session 2025-01-26-feature-auth
+```
+
+## Supported AI Tools
+
+| Tool | Config Directory |
+|------|------------------|
+| Claude Code | `.claude/` |
+| Windsurf | `.windsurf/` |
+| Cursor | `.cursor/` |
+| GitHub Copilot | `.github/` |
+| Cline | `.cline/` |
+| Continue | `.continue/` |
+| And more... | See `ocr init --help` |
+
+## License
+
+Apache-2.0

package/dist/index.js

@@ -0,0 +1,1052 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// packages/cli/src/index.ts
+import { Command as Command4 } from "commander";
+
+// packages/cli/src/commands/init.ts
+import { Command } from "commander";
+import { checkbox } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+
+// packages/cli/src/lib/config.ts
+var AI_TOOLS = [
+  {
+    id: "amazon-q",
+    name: "Amazon Q Developer",
+    configDir: ".aws/amazonq",
+    commandsDir: ".aws/amazonq/commands",
+    skillsDir: ".aws/amazonq/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "augment",
+    name: "Augment (Auggie)",
+    configDir: ".augment",
+    commandsDir: ".augment/commands",
+    skillsDir: ".augment/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "claude",
+    name: "Claude Code",
+    configDir: ".claude",
+    commandsDir: ".claude/commands",
+    skillsDir: ".claude/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    configDir: ".cline",
+    commandsDir: ".cline/commands",
+    skillsDir: ".cline/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    configDir: ".codex",
+    commandsDir: ".codex/commands",
+    skillsDir: ".codex/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "continue",
+    name: "Continue",
+    configDir: ".continue",
+    commandsDir: ".continue/commands",
+    skillsDir: ".continue/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    configDir: ".cursor",
+    commandsDir: ".cursor/commands",
+    skillsDir: ".cursor/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    configDir: ".gemini",
+    commandsDir: ".gemini/commands",
+    skillsDir: ".gemini/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    configDir: ".github",
+    commandsDir: ".github/commands",
+    skillsDir: ".github/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "kilo-code",
+    name: "Kilo Code",
+    configDir: ".kilocode",
+    commandsDir: ".kilocode/commands",
+    skillsDir: ".kilocode/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    configDir: ".opencode",
+    commandsDir: ".opencode/commands",
+    skillsDir: ".opencode/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "qoder",
+    name: "Qoder",
+    configDir: ".qoder",
+    commandsDir: ".qoder/commands",
+    skillsDir: ".qoder/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "roo-code",
+    name: "RooCode",
+    configDir: ".roo",
+    commandsDir: ".roo/commands",
+    skillsDir: ".roo/skills",
+    commandStrategy: "subdirectory"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    configDir: ".windsurf",
+    commandsDir: ".windsurf/workflows",
+    skillsDir: ".windsurf/skills",
+    commandStrategy: "flat-prefixed"
+  }
+];
+function getToolIds() {
+  return AI_TOOLS.map((tool) => tool.id);
+}
+function parseToolsArg(toolsArg) {
+  if (toolsArg === "all") {
+    return getToolIds();
+  }
+  const requestedIds = toolsArg.split(",").map((s) => s.trim().toLowerCase());
+  const validIds = getToolIds();
+  const result = [];
+  for (const id of requestedIds) {
+    if (validIds.includes(id)) {
+      result.push(id);
+    } else {
+      throw new Error(
+        `Invalid tool ID: "${id}". Valid options: ${validIds.join(", ")}`
+      );
+    }
+  }
+  return result;
+}
+
+// packages/cli/src/lib/installer.ts
+import {
+  existsSync,
+  mkdirSync,
+  cpSync,
+  writeFileSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getAgentsPackagePath() {
+  try {
+    const agentsPath = require2.resolve("@open-code-review/agents/package.json");
+    return dirname(agentsPath);
+  } catch {
+    const localPath = join(process.cwd(), "packages", "agents");
+    if (existsSync(localPath)) {
+      return localPath;
+    }
+    throw new Error(
+      "Could not find @open-code-review/agents package. Run from OCR repo or install the package."
+    );
+  }
+}
+function copyDirSafe(src, dest) {
+  try {
+    ensureDir(dirname(dest));
+    cpSync(src, dest, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function copyFileSafe(src, dest) {
+  try {
+    ensureDir(dirname(dest));
+    const content = readFileSync(src);
+    writeFileSync(dest, content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateCommandReference(commandName, description) {
+  const baseName = commandName.replace(/\.md$/, "").replace(/^ocr-/, "");
+  return `---
+description: ${description}
+---
+
+# OCR: ${baseName.charAt(0).toUpperCase() + baseName.slice(1)}
+
+This command is managed by Open Code Review.
+
+**Execute this command by reading and following:** \`.ocr/commands/${baseName}.md\`
+`;
+}
+function extractDescription(content) {
+  const match = content.match(/^---[\s\S]*?description:\s*(.+?)\n/m);
+  return match?.[1]?.trim() ?? "OCR command";
+}
+function installCommandsForTool(tool, commandsSource, targetDir) {
+  const toolCommandsDir = join(targetDir, tool.commandsDir);
+  const centralCommandsDir = join(targetDir, ".ocr", "commands");
+  ensureDir(toolCommandsDir);
+  ensureDir(centralCommandsDir);
+  try {
+    const commandFiles = readdirSync(commandsSource).filter(
+      (f) => f.endsWith(".md")
+    );
+    for (const file of commandFiles) {
+      const srcPath = join(commandsSource, file);
+      const normalizedName = file.replace(/^ocr-/, "");
+      const centralPath = join(centralCommandsDir, normalizedName);
+      if (!copyFileSafe(srcPath, centralPath)) {
+        return false;
+      }
+    }
+    if (tool.commandStrategy === "subdirectory") {
+      const ocrSubdir = join(toolCommandsDir, "ocr");
+      ensureDir(ocrSubdir);
+      for (const file of commandFiles) {
+        const srcPath = join(commandsSource, file);
+        const content = readFileSync(srcPath, "utf-8");
+        const description = extractDescription(content);
+        const normalizedName = file.replace(/^ocr-/, "");
+        const refContent = generateCommandReference(
+          normalizedName,
+          description
+        );
+        const destPath = join(ocrSubdir, normalizedName);
+        writeFileSync(destPath, refContent);
+      }
+    } else {
+      for (const file of commandFiles) {
+        const srcPath = join(commandsSource, file);
+        const content = readFileSync(srcPath, "utf-8");
+        const description = extractDescription(content);
+        const normalizedName = file.replace(/^ocr-/, "");
+        const destName = `ocr-${normalizedName}`;
+        const refContent = generateCommandReference(
+          normalizedName,
+          description
+        );
+        const destPath = join(toolCommandsDir, destName);
+        writeFileSync(destPath, refContent);
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installForTool(tool, targetDir) {
+  const agentsPath = getAgentsPackagePath();
+  const ocrSkillsSource = join(agentsPath, "skills", "ocr");
+  const commandsSource = join(agentsPath, "commands");
+  const ocrDir = join(targetDir, ".ocr");
+  const ocrSkillsDest = join(ocrDir, "skills");
+  ensureDir(ocrDir);
+  ensureDir(join(ocrDir, "sessions"));
+  const gitignoreContent = `# OCR session files
+sessions/
+`;
+  const gitignorePath = join(ocrDir, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, gitignoreContent);
+  }
+  const configPath = join(ocrDir, "config.yaml");
+  let existingConfig = null;
+  if (existsSync(configPath)) {
+    try {
+      existingConfig = readFileSync(configPath);
+    } catch {
+    }
+  }
+  const skillsOk = copyDirSafe(ocrSkillsSource, ocrSkillsDest);
+  if (!skillsOk) {
+    return {
+      tool,
+      success: false,
+      error: "Failed to install OCR skills to .ocr/"
+    };
+  }
+  const configSource = join(ocrSkillsSource, "assets", "config.yaml");
+  if (existingConfig) {
+    try {
+      writeFileSync(configPath, existingConfig);
+    } catch {
+    }
+  } else if (existsSync(configSource)) {
+    copyFileSafe(configSource, configPath);
+  }
+  const duplicateConfig = join(ocrSkillsDest, "assets", "config.yaml");
+  if (existsSync(duplicateConfig)) {
+    try {
+      unlinkSync(duplicateConfig);
+    } catch {
+    }
+  }
+  const commandsOk = installCommandsForTool(tool, commandsSource, targetDir);
+  if (!commandsOk) {
+    return {
+      tool,
+      success: false,
+      error: `Failed to install OCR commands to ${tool.commandsDir}`
+    };
+  }
+  return {
+    tool,
+    success: true
+  };
+}
+function detectInstalledTools(targetDir, tools) {
+  return tools.filter((tool) => {
+    const configPath = join(targetDir, tool.configDir);
+    return existsSync(configPath);
+  });
+}
+
+// packages/cli/src/lib/injector.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var START_MARKER = "<!-- OCR:START -->";
+var END_MARKER = "<!-- OCR:END -->";
+var OCR_INSTRUCTION_BLOCK = `${START_MARKER}
+# Open Code Review Instructions
+
+These instructions are for AI assistants handling code review in this project.
+
+Always open \`.ocr/skills/SKILL.md\` when the request:
+- Asks for code review, PR review, or feedback on changes
+- Mentions "review my code" or similar phrases
+- Wants multi-perspective analysis of code quality
+
+Use \`.ocr/skills/SKILL.md\` to learn:
+- How to run the 8-phase review workflow
+- Available reviewer personas and their focus areas
+- Session management and output format
+
+Keep this managed block so 'ocr init' can refresh the instructions.
+
+${END_MARKER}`;
+function injectOcrInstructions(filePath) {
+  try {
+    let content = existsSync2(filePath) ? readFileSync2(filePath, "utf-8") : "";
+    const regex = new RegExp(
+      `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
+      "g"
+    );
+    content = content.replace(regex, "");
+    content = content.trim();
+    if (content.length > 0) {
+      content += "\n\n";
+    }
+    content += OCR_INSTRUCTION_BLOCK + "\n";
+    writeFileSync2(filePath, content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function injectIntoProjectFiles(targetDir) {
+  const agentsMdPath = join2(targetDir, "AGENTS.md");
+  const claudeMdPath = join2(targetDir, "CLAUDE.md");
+  const agentsMd = injectOcrInstructions(agentsMdPath);
+  const claudeMd = injectOcrInstructions(claudeMdPath);
+  return { agentsMd, claudeMd };
+}
+
+// packages/cli/src/commands/init.ts
+var initCommand = new Command("init").description("Set up OCR for AI coding environments").option("-t, --tools <tools>", 'Comma-separated tool IDs or "all"').option("--no-inject", "Skip injecting instructions into AGENTS.md/CLAUDE.md").action(async (options) => {
+  console.log();
+  console.log(chalk.bold.cyan("  Open Code Review"));
+  console.log(chalk.dim("  AI-powered multi-agent code review"));
+  console.log();
+  const targetDir = process.cwd();
+  let selectedTools;
+  if (options.tools) {
+    try {
+      const toolIds = parseToolsArg(options.tools);
+      selectedTools = toolIds.map((id) => AI_TOOLS.find((t) => t.id === id)).filter((t) => t !== void 0);
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `Error: ${error instanceof Error ? error.message : "Invalid tools argument"}`
+        )
+      );
+      console.log();
+      console.log(
+        chalk.dim(`Valid tool IDs: ${AI_TOOLS.map((t) => t.id).join(", ")}`)
+      );
+      process.exit(1);
+    }
+  } else {
+    const installedTools = detectInstalledTools(targetDir, AI_TOOLS);
+    const choices = AI_TOOLS.map((tool) => {
+      const isInstalled = installedTools.some((t) => t.id === tool.id);
+      return {
+        name: isInstalled ? `${tool.name} ${chalk.dim("(detected)")}` : tool.name,
+        value: tool.id,
+        checked: isInstalled
+      };
+    });
+    try {
+      const selectedIds = await checkbox({
+        message: "Select AI tools to configure",
+        choices,
+        pageSize: 15
+      });
+      if (selectedIds.length === 0) {
+        console.log(chalk.yellow("No tools selected. Exiting."));
+        process.exit(0);
+      }
+      selectedTools = selectedIds.map((id) => AI_TOOLS.find((t) => t.id === id)).filter((t) => t !== void 0);
+    } catch {
+      console.log(chalk.yellow("\nOperation cancelled."));
+      process.exit(0);
+    }
+  }
+  console.log();
+  const spinner = ora("Installing OCR...").start();
+  const results = [];
+  for (const tool of selectedTools) {
+    spinner.text = `Installing for ${tool.name}...`;
+    const result = installForTool(tool, targetDir);
+    results.push(result);
+  }
+  spinner.stop();
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  if (successful.length > 0) {
+    console.log(chalk.green("\u2713 OCR installed successfully"));
+    console.log();
+    for (const result of successful) {
+      console.log(`  ${chalk.green("\u2713")} ${result.tool.name}`);
+    }
+  }
+  if (failed.length > 0) {
+    console.log();
+    console.log(chalk.red("\u2717 Some installations failed:"));
+    for (const result of failed) {
+      console.log(`  ${chalk.red("\u2717")} ${result.tool.name}: ${result.error}`);
+    }
+  }
+  if (options.inject && successful.length > 0) {
+    console.log();
+    const injectSpinner = ora(
+      "Injecting OCR instructions into project files..."
+    ).start();
+    const injectResults = injectIntoProjectFiles(targetDir);
+    injectSpinner.stop();
+    if (injectResults.agentsMd || injectResults.claudeMd) {
+      console.log(chalk.green("\u2713 OCR instructions injected"));
+      if (injectResults.agentsMd) {
+        console.log(`  ${chalk.green("\u2713")} AGENTS.md`);
+      }
+      if (injectResults.claudeMd) {
+        console.log(`  ${chalk.green("\u2713")} CLAUDE.md`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk.bold("Next steps:"));
+  console.log();
+  console.log(
+    `  ${chalk.cyan("1.")} Review ${chalk.yellow(".ocr/config.yaml")}`
+  );
+  console.log(
+    chalk.dim(
+      "     Add project context, review rules, and customize discovery settings."
+    )
+  );
+  console.log();
+  console.log(
+    `  ${chalk.cyan("2.")} Run ${chalk.yellow("/ocr-review")} to start a code review session.`
+  );
+  console.log();
+});
+
+// packages/cli/src/commands/progress.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+import { watch } from "chokidar";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
+import { join as join4, basename } from "node:path";
+import logUpdate from "log-update";
+
+// packages/cli/src/lib/guards.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import chalk2 from "chalk";
+function checkOcrSetup(targetDir) {
+  const ocrDir = join3(targetDir, ".ocr");
+  const skillsDir = join3(ocrDir, "skills");
+  const sessionsDir = join3(ocrDir, "sessions");
+  const hasOcrDir = existsSync3(ocrDir);
+  const hasSkills = existsSync3(skillsDir);
+  const hasSessions = existsSync3(sessionsDir);
+  return {
+    valid: hasOcrDir && hasSkills,
+    ocrDir,
+    skillsDir,
+    sessionsDir,
+    hasSkills,
+    hasSessions
+  };
+}
+function requireOcrSetup(targetDir) {
+  const status = checkOcrSetup(targetDir);
+  if (!status.valid) {
+    console.log();
+    console.log(chalk2.red.bold("  \u2717 OCR is not set up in this directory"));
+    console.log();
+    if (!existsSync3(status.ocrDir)) {
+      console.log(chalk2.dim("  The .ocr directory was not found."));
+    } else if (!status.hasSkills) {
+      console.log(chalk2.dim("  The .ocr/skills directory is missing."));
+      console.log(chalk2.dim("  OCR may have been partially installed."));
+    }
+    console.log();
+    console.log(chalk2.dim("  To set up OCR, run:"));
+    console.log();
+    console.log(chalk2.white("    ocr init"));
+    console.log();
+    console.log(chalk2.dim("  Or with npx:"));
+    console.log();
+    console.log(chalk2.white("    npx @open-code-review/cli init"));
+    console.log();
+    process.exit(1);
+  }
+  return status;
+}
+function ensureSessionsDir(targetDir) {
+  const sessionsDir = join3(targetDir, ".ocr", "sessions");
+  if (!existsSync3(sessionsDir)) {
+    mkdirSync2(sessionsDir, { recursive: true });
+  }
+  return sessionsDir;
+}
+
+// packages/cli/src/commands/progress.ts
+var TOTAL_PHASES = 8;
+function findLatestSession(sessionsDir) {
+  if (!existsSync4(sessionsDir)) {
+    return null;
+  }
+  const sessions = readdirSync2(sessionsDir).filter((name) => {
+    const sessionPath = join4(sessionsDir, name);
+    return statSync(sessionPath).isDirectory();
+  }).sort().reverse();
+  return sessions[0] ?? null;
+}
+function countFindings(filePath) {
+  if (!existsSync4(filePath)) {
+    return 0;
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  const findingMatches = content.match(/^##\s+(Finding|Issue|Suggestion)/gm);
+  return findingMatches?.length ?? 0;
+}
+function formatReviewerName(filename) {
+  const base = filename.replace(".md", "");
+  const match = base.match(/^(.+)-(\d+)$/);
+  if (match && match[1] && match[2]) {
+    const name = match[1].charAt(0).toUpperCase() + match[1].slice(1);
+    return `${name} #${match[2]}`;
+  }
+  return base.charAt(0).toUpperCase() + base.slice(1);
+}
+function parseSessionState(sessionPath, preservedStartTime) {
+  const session = basename(sessionPath);
+  const statePath = join4(sessionPath, "state.json");
+  if (!existsSync4(statePath)) {
+    return null;
+  }
+  try {
+    const stateContent = readFileSync3(statePath, "utf-8");
+    const state = JSON.parse(stateContent);
+    return parseFromStateJson(session, state, sessionPath, preservedStartTime);
+  } catch {
+    return null;
+  }
+}
+function parseFromStateJson(session, state, sessionPath, preservedStartTime) {
+  const startTime = preservedStartTime ?? (state.started_at ? new Date(state.started_at).getTime() : Date.now());
+  const completed = new Set(state.completed_phases);
+  const reviewsDir = join4(sessionPath, "reviews");
+  const reviewers = [];
+  if (existsSync4(reviewsDir)) {
+    const reviewFiles = readdirSync2(reviewsDir).filter(
+      (f) => f.endsWith(".md")
+    );
+    for (const file of reviewFiles) {
+      const reviewPath = join4(reviewsDir, file);
+      const findings = countFindings(reviewPath);
+      reviewers.push({
+        name: file.replace(".md", ""),
+        displayName: formatReviewerName(file),
+        status: "complete",
+        findings
+      });
+    }
+  }
+  return {
+    session,
+    phase: state.current_phase,
+    phaseNumber: state.phase_number,
+    totalPhases: TOTAL_PHASES,
+    contextComplete: completed.has("context"),
+    requirementsComplete: completed.has("requirements"),
+    analysisComplete: completed.has("analysis"),
+    reviewsComplete: completed.has("reviews"),
+    aggregationComplete: completed.has("aggregation"),
+    discourseComplete: completed.has("discourse"),
+    synthesisComplete: completed.has("synthesis"),
+    reviewers,
+    startTime,
+    complete: state.current_phase === "complete"
+  };
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
+}
+var PHASE_INFO = [
+  { key: "context", label: "Context Discovery", icon: "\u{1F4CB}" },
+  { key: "requirements", label: "Requirements Gathering", icon: "\u{1F4DD}" },
+  { key: "analysis", label: "Tech Lead Analysis", icon: "\u{1F50D}" },
+  { key: "reviews", label: "Parallel Reviews", icon: "\u{1F465}" },
+  { key: "aggregation", label: "Aggregate Findings", icon: "\u{1F4CA}" },
+  { key: "discourse", label: "Reviewer Discourse", icon: "\u{1F4AC}" },
+  { key: "synthesis", label: "Final Synthesis", icon: "\u2728" },
+  { key: "complete", label: "Review Complete", icon: "\u{1F389}" }
+];
+function getPhaseIcon(phaseKey, isComplete, isCurrent) {
+  if (isComplete) return chalk3.green("\u2713");
+  if (isCurrent) return chalk3.yellow("\u25CF");
+  return chalk3.dim("\u25CB");
+}
+function renderProgressBar(current, total) {
+  const width = 20;
+  const filled = Math.round(current / total * width);
+  const empty = width - filled;
+  const bar = chalk3.green("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(empty));
+  const percent = Math.round(current / total * 100);
+  return `${bar} ${percent}%`;
+}
+function renderProgress(state) {
+  const lines = [];
+  const log = (line = "") => lines.push(line);
+  const title = "Open Code Review - Live Progress";
+  const boxWidth = title.length + 4;
+  const border = "\u2500".repeat(boxWidth);
+  log(chalk3.bold.cyan(`  \u250C${border}\u2510`));
+  log(
+    chalk3.bold.cyan("  \u2502") + chalk3.bold(`  ${title}  `) + chalk3.bold.cyan("\u2502")
+  );
+  log(chalk3.bold.cyan(`  \u2514${border}\u2518`));
+  log();
+  const elapsed = Date.now() - state.startTime;
+  log(chalk3.dim(`  Session:  `) + chalk3.white(state.session));
+  log(chalk3.dim(`  Elapsed:  `) + chalk3.white(formatDuration(elapsed)));
+  log();
+  const progressPhases = state.complete ? 8 : state.phaseNumber;
+  log(`  ${renderProgressBar(progressPhases, 8)}`);
+  log();
+  const currentPhase = PHASE_INFO.find((p) => p.key === state.phase);
+  if (currentPhase && !state.complete) {
+    log(
+      chalk3.bold(`  ${currentPhase.icon} `) + chalk3.bold.yellow(currentPhase.label) + chalk3.yellow(" in progress...")
+    );
+    log();
+  }
+  log(chalk3.dim("  \u2500\u2500\u2500 Workflow Phases \u2500\u2500\u2500"));
+  log();
+  const phaseCompletion = {
+    waiting: false,
+    context: state.contextComplete,
+    requirements: state.requirementsComplete,
+    analysis: state.analysisComplete,
+    reviews: state.reviewsComplete,
+    aggregation: state.aggregationComplete,
+    discourse: state.discourseComplete,
+    synthesis: state.synthesisComplete,
+    complete: state.complete
+  };
+  for (const phase of PHASE_INFO) {
+    const isComplete = phaseCompletion[phase.key];
+    const isCurrent = state.phase === phase.key && !state.complete;
+    const icon = getPhaseIcon(phase.key, isComplete, isCurrent);
+    let label = phase.label;
+    if (isCurrent) {
+      label = chalk3.yellow(label);
+    } else if (isComplete) {
+      label = chalk3.white(label);
+    } else {
+      label = chalk3.dim(label);
+    }
+    log(`  ${icon} ${label}`);
+    if (phase.key === "reviews" && state.reviewers.length > 0) {
+      for (const reviewer of state.reviewers) {
+        const reviewerIcon = reviewer.status === "complete" ? chalk3.green("\u2713") : chalk3.dim("\u25CB");
+        const findings = reviewer.findings > 0 ? chalk3.cyan(
+          ` \u2192 ${reviewer.findings} finding${reviewer.findings > 1 ? "s" : ""}`
+        ) : "";
+        log(
+          chalk3.dim(`     \u2514\u2500 `) + `${reviewerIcon} ${chalk3.dim(reviewer.displayName)}${findings}`
+        );
+      }
+    }
+  }
+  log();
+  if (state.complete) {
+    const totalFindings = state.reviewers.reduce(
+      (sum, r) => sum + r.findings,
+      0
+    );
+    log(chalk3.green.bold("  \u2705 Review Complete!"));
+    if (totalFindings > 0) {
+      log(
+        chalk3.dim(
+          `     ${totalFindings} total finding${totalFindings > 1 ? "s" : ""} identified`
+        )
+      );
+    }
+    log();
+    log(
+      chalk3.dim("  Results saved to: ") + chalk3.white(`.ocr/sessions/${state.session}/final.md`)
+    );
+  } else {
+    log(chalk3.dim("  Press Ctrl+C to exit"));
+  }
+  log();
+  logUpdate(lines.join("\n"));
+}
+function renderWaiting() {
+  const lines = [];
+  const log = (line = "") => lines.push(line);
+  const title = "Open Code Review - Live Progress";
+  const boxWidth = title.length + 4;
+  const border = "\u2500".repeat(boxWidth);
+  log(chalk3.bold.cyan(`  \u250C${border}\u2510`));
+  log(
+    chalk3.bold.cyan("  \u2502") + chalk3.bold(`  ${title}  `) + chalk3.bold.cyan("\u2502")
+  );
+  log(chalk3.bold.cyan(`  \u2514${border}\u2518`));
+  log();
+  log(chalk3.dim("  Session:  ") + chalk3.yellow("Waiting for session..."));
+  log();
+  const bar = chalk3.dim("\u2591".repeat(20));
+  log(`  ${bar} 0%`);
+  log();
+  log(chalk3.yellow("  \u23F3 Waiting for a code review to begin..."));
+  log();
+  log(chalk3.dim("  \u2500\u2500\u2500 How to Start \u2500\u2500\u2500"));
+  log();
+  log(
+    chalk3.dim("  Run ") + chalk3.white("/ocr-review") + chalk3.dim(" in your AI assistant to begin")
+  );
+  log(chalk3.dim("  This display will update automatically"));
+  log();
+  log(chalk3.dim("  Press Ctrl+C to exit"));
+  log();
+  logUpdate(lines.join("\n"));
+}
+var progressCommand = new Command2("progress").description("Watch real-time progress of a code review session").option("-s, --session <name>", "Specify session name").action(async (options) => {
+  const targetDir = process.cwd();
+  requireOcrSetup(targetDir);
+  const sessionsDir = ensureSessionsDir(targetDir);
+  const ocrDir = join4(targetDir, ".ocr");
+  if (options.session) {
+    const sessionPath = join4(sessionsDir, options.session);
+    if (!existsSync4(sessionPath)) {
+      console.log(chalk3.red(`Session not found: ${options.session}`));
+      process.exit(1);
+    }
+    let state = parseSessionState(sessionPath);
+    if (!state) {
+      console.log(
+        chalk3.red(
+          `Session ${options.session} has no state.json - cannot track progress`
+        )
+      );
+      console.log(
+        chalk3.dim(
+          `The orchestrating agent must create state.json for progress tracking.`
+        )
+      );
+      process.exit(1);
+    }
+    let preservedStartTime2 = state.startTime;
+    renderProgress(state);
+    const timerInterval2 = setInterval(() => {
+      const newState = parseSessionState(sessionPath, preservedStartTime2);
+      if (newState) {
+        state = newState;
+        renderProgress(state);
+      }
+    }, 1e3);
+    const watcher = watch(sessionPath, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 2
+    });
+    watcher.on("all", () => {
+      const newState = parseSessionState(sessionPath, preservedStartTime2);
+      if (newState) {
+        state = newState;
+        renderProgress(state);
+      }
+    });
+    process.on("SIGINT", () => {
+      clearInterval(timerInterval2);
+      watcher.close();
+      logUpdate.done();
+      process.exit(0);
+    });
+    return;
+  }
+  let currentSession = findLatestSession(sessionsDir);
+  let currentSessionPath = currentSession ? join4(sessionsDir, currentSession) : null;
+  let sessionWatcher = null;
+  let preservedStartTime;
+  const updateDisplay = () => {
+    if (currentSessionPath && existsSync4(currentSessionPath)) {
+      const state = parseSessionState(currentSessionPath, preservedStartTime);
+      if (state) {
+        if (!preservedStartTime) {
+          preservedStartTime = state.startTime;
+        }
+        renderProgress(state);
+      } else {
+        renderWaiting();
+      }
+    } else {
+      preservedStartTime = void 0;
+      renderWaiting();
+    }
+  };
+  const watchSession = (sessionPath) => {
+    if (sessionWatcher) {
+      sessionWatcher.close();
+    }
+    sessionWatcher = watch(sessionPath, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 2
+    });
+    sessionWatcher.on("all", updateDisplay);
+  };
+  updateDisplay();
+  if (currentSessionPath) {
+    watchSession(currentSessionPath);
+  }
+  const timerInterval = setInterval(updateDisplay, 1e3);
+  const watchDir = existsSync4(ocrDir) ? ocrDir : targetDir;
+  const dirWatcher = watch(watchDir, {
+    persistent: true,
+    ignoreInitial: true,
+    depth: 3
+  });
+  dirWatcher.on("addDir", (dirPath) => {
+    const parentDir = join4(dirPath, "..");
+    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join4(".ocr", "sessions"));
+    if (isDirectChild && !dirPath.endsWith("sessions")) {
+      const newSession = basename(dirPath);
+      currentSession = newSession;
+      currentSessionPath = dirPath;
+      preservedStartTime = void 0;
+      watchSession(dirPath);
+      updateDisplay();
+    }
+  });
+  dirWatcher.on("add", updateDisplay);
+  dirWatcher.on("change", updateDisplay);
+  process.on("SIGINT", () => {
+    clearInterval(timerInterval);
+    dirWatcher.close();
+    if (sessionWatcher) sessionWatcher.close();
+    logUpdate.done();
+    process.exit(0);
+  });
+});
+
+// packages/cli/src/commands/update.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+import ora2 from "ora";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+function detectConfiguredTools(targetDir) {
+  return AI_TOOLS.filter((tool) => {
+    if (tool.commandStrategy === "subdirectory") {
+      const ocrDir = join5(targetDir, tool.commandsDir, "ocr");
+      return existsSync5(ocrDir);
+    } else {
+      const reviewCmd = join5(targetDir, tool.commandsDir, "ocr-review.md");
+      return existsSync5(reviewCmd);
+    }
+  });
+}
+var updateCommand = new Command3("update").description("Update OCR assets after package upgrade").option("--commands", "Update only commands/workflows").option(
+  "--skills",
+  "Update only skills (includes templates, references, assets)"
+).option("--inject", "Update only AGENTS.md/CLAUDE.md injection").option("--dry-run", "Preview changes without modifying files").action(async (options) => {
+  const targetDir = process.cwd();
+  requireOcrSetup(targetDir);
+  console.log();
+  console.log(chalk4.bold.cyan("  Open Code Review - Update"));
+  console.log();
+  const configuredTools = detectConfiguredTools(targetDir);
+  const installedTools = detectInstalledTools(targetDir, AI_TOOLS);
+  const toolsToUpdate = AI_TOOLS.filter(
+    (tool) => configuredTools.some((t) => t.id === tool.id) || installedTools.some((t) => t.id === tool.id)
+  );
+  if (toolsToUpdate.length === 0) {
+    console.log(chalk4.yellow("  No configured AI tools found."));
+    console.log(chalk4.dim("  Run `ocr init` to set up OCR first."));
+    console.log();
+    process.exit(1);
+  }
+  const hasSpecificFlag = options.commands || options.skills || options.inject;
+  const updateCommands = options.commands || !hasSpecificFlag;
+  const updateSkills = options.skills || !hasSpecificFlag;
+  const updateInject = options.inject || !hasSpecificFlag;
+  if (options.dryRun) {
+    console.log(chalk4.yellow("  Dry run mode - no files will be modified"));
+    console.log();
+  }
+  console.log(chalk4.dim("  Detected tools:"));
+  for (const tool of toolsToUpdate) {
+    console.log(`    \u2022 ${tool.name}`);
+  }
+  console.log();
+  if (updateCommands || updateSkills) {
+    if (options.dryRun) {
+      console.log(chalk4.dim("  Would update:"));
+      console.log(chalk4.dim("    \u2022 .ocr/skills/SKILL.md (main skill)"));
+      console.log(
+        chalk4.dim("    \u2022 .ocr/skills/references/ (workflow, reviewers)")
+      );
+      console.log(chalk4.dim("    \u2022 .ocr/skills/assets/reviewer-template.md"));
+      console.log(
+        chalk4.dim("    \u2022 .ocr/config.yaml (preserved if customized)")
+      );
+      for (const tool of toolsToUpdate) {
+        if (tool.commandStrategy === "subdirectory") {
+          console.log(chalk4.dim(`    \u2022 ${tool.commandsDir}/ocr/ (commands)`));
+        } else {
+          console.log(
+            chalk4.dim(`    \u2022 ${tool.commandsDir}/ocr-*.md (commands)`)
+          );
+        }
+      }
+      console.log();
+    } else {
+      const spinner = ora2("Updating OCR commands and skills...").start();
+      const results = [];
+      for (const tool of toolsToUpdate) {
+        spinner.text = `Updating ${tool.name}...`;
+        const result = installForTool(tool, targetDir);
+        results.push(result);
+      }
+      spinner.stop();
+      const successful = results.filter((r) => r.success);
+      const failed = results.filter((r) => !r.success);
+      if (successful.length > 0) {
+        console.log(chalk4.green("  \u2713 Commands and skills updated"));
+        console.log(
+          chalk4.dim("    Including: SKILL.md, references/, assets/")
+        );
+        for (const result of successful) {
+          console.log(`    ${chalk4.green("\u2713")} ${result.tool.name}`);
+        }
+      }
+      if (failed.length > 0) {
+        console.log();
+        console.log(chalk4.red("  \u2717 Some updates failed:"));
+        for (const result of failed) {
+          console.log(
+            `    ${chalk4.red("\u2717")} ${result.tool.name}: ${result.error}`
+          );
+        }
+      }
+      console.log();
+    }
+  }
+  if (updateInject) {
+    if (options.dryRun) {
+      console.log(chalk4.dim("  Would update:"));
+      if (existsSync5(join5(targetDir, "AGENTS.md"))) {
+        console.log(chalk4.dim("    \u2022 AGENTS.md (OCR managed block)"));
+      }
+      if (existsSync5(join5(targetDir, "CLAUDE.md"))) {
+        console.log(chalk4.dim("    \u2022 CLAUDE.md (OCR managed block)"));
+      }
+      console.log();
+    } else {
+      const spinner = ora2("Updating AGENTS.md/CLAUDE.md...").start();
+      const injectResults = injectIntoProjectFiles(targetDir);
+      spinner.stop();
+      if (injectResults.agentsMd || injectResults.claudeMd) {
+        console.log(chalk4.green("  \u2713 Instructions updated"));
+        if (injectResults.agentsMd) {
+          console.log(`    ${chalk4.green("\u2713")} AGENTS.md`);
+        }
+        if (injectResults.claudeMd) {
+          console.log(`    ${chalk4.green("\u2713")} CLAUDE.md`);
+        }
+      } else {
+        console.log(chalk4.dim("  No instruction files to update"));
+      }
+      console.log();
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk4.dim("  Run without --dry-run to apply changes."));
+  } else {
+    console.log(chalk4.green("  \u2713 Update complete"));
+  }
+  console.log();
+});
+
+// packages/cli/src/index.ts
+var program = new Command4();
+program.name("ocr").description("Open Code Review - AI-powered multi-agent code review").version("1.0.0");
+program.addCommand(initCommand);
+program.addCommand(progressCommand);
+program.addCommand(updateCommand);
+program.parse();

package/dist/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@open-code-review/cli",
+  "version": "1.0.0",
+  "description": "CLI for Open Code Review - Multi-environment setup and progress tracking",
+  "type": "module",
+  "bin": {
+    "ocr": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "code-review",
+    "ai",
+    "cli",
+    "claude",
+    "cursor",
+    "windsurf"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/spencermarx/open-code-review",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Spencer Marx",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.2.0",
+    "@open-code-review/agents": "workspace:*",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.0.0",
+    "log-update": "^7.0.2",
+    "ora": "^8.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@open-code-review/cli",
+  "version": "1.0.0",
+  "description": "CLI for Open Code Review - Multi-environment setup and progress tracking",
+  "type": "module",
+  "bin": {
+    "ocr": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "code-review",
+    "ai",
+    "cli",
+    "claude",
+    "cursor",
+    "windsurf"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/spencermarx/open-code-review",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Spencer Marx",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.2.0",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.0.0",
+    "log-update": "^7.0.2",
+    "ora": "^8.1.1",
+    "@open-code-review/agents": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}