openairev 0.2.0

package/src/cli/format-helpers.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { configExists } from '../config/config-loader.js';
+
+export const STAGE_LABELS = {
+  analyze: 'Analyzing',
+  awaiting_user: 'Waiting for User',
+  planning: 'Planning',
+  plan_review: 'Plan Review',
+  plan_fix: 'Fixing Plan',
+  implementation: 'Implementing',
+  code_review: 'Code Review',
+  code_fix: 'Fixing Code',
+  done: 'Done',
+};
+
+export function stageLabel(stage) {
+  return STAGE_LABELS[stage] || stage;
+}
+
+const STATUS_COLORS = {
+  approved: chalk.green,
+  completed: chalk.green,
+  active: chalk.blue,
+  blocked: chalk.yellow,
+  needs_changes: chalk.yellow,
+  in_progress: chalk.yellow,
+  max_rounds_reached: chalk.yellow,
+  reject: chalk.red,
+  rejected: chalk.red,
+  error: chalk.red,
+};
+
+export function statusColor(status) {
+  return STATUS_COLORS[status] || chalk.white;
+}
+
+export function timeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+  if (seconds < 60) return 'just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+export function requireConfig(cwd) {
+  if (!configExists(cwd)) {
+    console.log(chalk.red('No .openairev/config.yaml found. Run `openairev init` first.'));
+    process.exit(1);
+  }
+}

package/src/cli/history.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import { listSessions } from '../session/session-manager.js';
+import { listChains } from '../session/chain-manager.js';
+import { statusColor, stageLabel } from './format-helpers.js';
+
+export async function historyCommand(options) {
+  const cwd = process.cwd();
+  const limit = options.limit || 10;
+
+  if (options.chains) {
+    showChainHistory(cwd, limit);
+  } else {
+    showSessionHistory(cwd, limit);
+  }
+}
+
+function showChainHistory(cwd, limit) {
+  const chains = listChains(cwd, { limit });
+
+  if (chains.length === 0) {
+    console.log(chalk.dim('\nNo workflow chains found.\n'));
+    return;
+  }
+
+  console.log(chalk.bold(`\nWorkflow Chains (last ${chains.length})\n`));
+
+  for (const c of chains) {
+    const date = new Date(c.updated).toLocaleString();
+    const executorName = c.participants?.executor || '?';
+    const reviewerName = c.participants?.reviewer || '?';
+    const roundCount = c.rounds?.length || 0;
+    const topic = c.task?.user_request;
+    const stage = c.stage ? ` [${stageLabel(c.stage)}]` : '';
+
+    console.log(`  ${chalk.dim(c.chain_id)}`);
+    console.log(`    ${date}  ${statusColor(c.status)(c.status)}${chalk.dim(stage)}  ${executorName} ↔ ${reviewerName}`);
+    console.log(`    Rounds: ${roundCount}/${c.max_rounds}`);
+    if (topic) console.log(`    Topic: ${chalk.dim(topic)}`);
+
+    const lastRound = c.rounds?.[c.rounds.length - 1];
+    if (lastRound?.review?.verdict) {
+      const v = lastRound.review.verdict;
+      console.log(`    Last verdict: ${statusColor(v.status)(v.status)} (${((v.confidence || 0) * 100).toFixed(0)}%)`);
+      if (v.critical_issues?.length) {
+        console.log(`    ${chalk.red(v.critical_issues.length + ' critical issue(s)')}`);
+      }
+    }
+    console.log('');
+  }
+}
+
+function showSessionHistory(cwd, limit) {
+  const sessions = listSessions(cwd, limit);
+
+  if (sessions.length === 0) {
+    console.log(chalk.dim('\nNo review sessions found.\n'));
+    return;
+  }
+
+  console.log(chalk.bold(`\nReview History (last ${sessions.length})\n`));
+
+  for (const s of sessions) {
+    const date = new Date(s.created).toLocaleString();
+    const verdict = s.final_verdict;
+    const verdictStr = verdict
+      ? `${verdict.status} (${((verdict.confidence || 0) * 100).toFixed(0)}%)`
+      : 'no verdict';
+
+    console.log(`  ${chalk.dim(s.id)}`);
+    console.log(`    ${date}  ${statusColor(s.status)(s.status)}  ${s.executor} → ${s.reviewer}  ${chalk.dim(verdictStr)}`);
+    if (verdict?.critical_issues?.length) {
+      console.log(`    ${chalk.red(verdict.critical_issues.length + ' critical issue(s)')}`);
+    }
+    console.log('');
+  }
+}

package/src/cli/init.js

@@ -0,0 +1,211 @@
+import { writeFileSync, mkdirSync, copyFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import YAML from 'yaml';
+import chalk from 'chalk';
+import { getConfigDir, getConfigPath, configExists } from '../config/config-loader.js';
+import { detectAgent } from '../agents/detect.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROMPTS_SRC = join(__dirname, '../../prompts');
+
+export async function initCommand() {
+  const cwd = process.cwd();
+
+  if (configExists(cwd)) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: '.openairev/config.yaml already exists. Overwrite?',
+      default: false,
+    }]);
+    if (!overwrite) {
+      console.log(chalk.yellow('Init cancelled.'));
+      return;
+    }
+  }
+
+  console.log(chalk.bold('\nOpenAIRev Setup\n'));
+
+  // Detect available CLIs
+  const [claudeAvailable, codexAvailable] = await Promise.all([
+    detectAgent('claude'),
+    detectAgent('codex'),
+  ]);
+
+  console.log(`  Claude Code CLI: ${claudeAvailable ? chalk.green('found') : chalk.red('not found')}`);
+  console.log(`  Codex CLI:       ${codexAvailable ? chalk.green('found') : chalk.red('not found')}\n`);
+
+  if (!claudeAvailable && !codexAvailable) {
+    console.log(chalk.red('No agent CLIs found. Install claude or codex CLI first.'));
+    process.exit(1);
+  }
+
+  const agents = [];
+  if (claudeAvailable) agents.push({ name: 'Claude Code', value: 'claude_code' });
+  if (codexAvailable) agents.push({ name: 'Codex CLI', value: 'codex' });
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'agents',
+      message: 'Which agent CLIs do you want to use?',
+      choices: agents,
+      default: agents.map(a => a.value),
+      validate: v => v.length > 0 || 'Select at least one agent',
+    },
+    {
+      type: 'list',
+      name: 'claude_reviewer',
+      message: 'When Claude Code executes, who reviews?',
+      choices: [
+        { name: 'Codex (recommended)', value: 'codex' },
+        { name: 'Claude Code (self-review)', value: 'claude_code' },
+        { name: 'Skip review', value: null },
+      ],
+      when: a => a.agents.includes('claude_code'),
+    },
+    {
+      type: 'list',
+      name: 'codex_reviewer',
+      message: 'When Codex executes, who reviews?',
+      choices: [
+        { name: 'Claude Code (recommended)', value: 'claude_code' },
+        { name: 'Codex (self-review)', value: 'codex' },
+        { name: 'Skip review', value: null },
+      ],
+      when: a => a.agents.includes('codex'),
+    },
+    {
+      type: 'list',
+      name: 'trigger',
+      message: 'Review trigger mode?',
+      choices: [
+        { name: 'explicit (openairev review)', value: 'explicit' },
+        { name: 'auto (every output triggers review)', value: 'auto' },
+      ],
+    },
+    {
+      type: 'checkbox',
+      name: 'tool_selection',
+      message: 'Enable tool gates?',
+      choices: [
+        { name: 'Tests', value: 'run_tests', checked: true },
+        { name: 'Linter', value: 'run_lint', checked: true },
+        { name: 'Type checker', value: 'run_typecheck', checked: true },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'test_cmd',
+      message: 'Test command?',
+      default: 'npm test',
+      when: a => a.tool_selection.includes('run_tests'),
+    },
+    {
+      type: 'input',
+      name: 'lint_cmd',
+      message: 'Lint command?',
+      default: 'npm run lint',
+      when: a => a.tool_selection.includes('run_lint'),
+    },
+    {
+      type: 'input',
+      name: 'typecheck_cmd',
+      message: 'Type check command?',
+      default: 'npx tsc --noEmit',
+      when: a => a.tool_selection.includes('run_typecheck'),
+    },
+    {
+      type: 'number',
+      name: 'claude_iterations',
+      message: 'Max iterations when Claude Code executes (Claude→Codex→Claude→... cycles)?',
+      default: 5,
+      when: a => a.agents.includes('claude_code') && a.claude_reviewer,
+    },
+    {
+      type: 'number',
+      name: 'codex_iterations',
+      message: 'Max iterations when Codex executes (Codex→Claude→Codex→... cycles)?',
+      default: 1,
+      when: a => a.agents.includes('codex') && a.codex_reviewer,
+    },
+  ]);
+
+  // Build config
+  const config = {
+    agents: {},
+    review_policy: {},
+    review_trigger: answers.trigger,
+    tools: buildToolsConfig(answers),
+    session: {
+      store_history: true,
+      archive_after: '7d',
+    },
+  };
+
+  if (answers.agents.includes('claude_code')) {
+    config.agents.claude_code = {
+      cmd: 'claude',
+      available: true,
+    };
+    if (answers.claude_reviewer) {
+      config.review_policy.claude_code = {
+        reviewer: answers.claude_reviewer,
+        max_iterations: answers.claude_iterations ?? 5,
+      };
+    }
+  }
+
+  if (answers.agents.includes('codex')) {
+    config.agents.codex = {
+      cmd: 'codex',
+      available: true,
+    };
+    if (answers.codex_reviewer) {
+      config.review_policy.codex = {
+        reviewer: answers.codex_reviewer,
+        max_iterations: answers.codex_iterations ?? 1,
+      };
+    }
+  }
+
+  // Write config
+  const configDir = getConfigDir(cwd);
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(join(configDir, 'sessions'), { recursive: true });
+  mkdirSync(join(configDir, 'prompts'), { recursive: true });
+
+  writeFileSync(getConfigPath(cwd), YAML.stringify(config));
+
+  // Copy prompt templates
+  const promptsDir = join(configDir, 'prompts');
+  copyIfMissing(join(PROMPTS_SRC, 'reviewer.md'), join(promptsDir, 'reviewer.md'));
+  copyIfMissing(join(PROMPTS_SRC, 'plan-reviewer.md'), join(promptsDir, 'plan-reviewer.md'));
+  copyIfMissing(join(PROMPTS_SRC, 'executor-feedback.md'), join(promptsDir, 'executor-feedback.md'));
+
+  console.log(`\n${chalk.green('✓')} Config written to .openairev/config.yaml`);
+  console.log(`${chalk.green('✓')} Prompt templates written to .openairev/prompts/`);
+  console.log(`\nRun ${chalk.cyan('openairev review')} to trigger a review.\n`);
+}
+
+function buildToolsConfig(answers) {
+  const tools = {};
+  if (answers.tool_selection?.includes('run_tests')) {
+    tools.run_tests = answers.test_cmd || 'npm test';
+  }
+  if (answers.tool_selection?.includes('run_lint')) {
+    tools.run_lint = answers.lint_cmd || 'npm run lint';
+  }
+  if (answers.tool_selection?.includes('run_typecheck')) {
+    tools.run_typecheck = answers.typecheck_cmd || 'npx tsc --noEmit';
+  }
+  return tools;
+}
+
+function copyIfMissing(src, dest) {
+  if (!existsSync(dest) && existsSync(src)) {
+    copyFileSync(src, dest);
+  }
+}

package/src/cli/resume.js

@@ -0,0 +1,135 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { loadConfig, getMaxIterations } from '../config/config-loader.js';
+import { listChains, loadChain, answerQuestion, hasPendingQuestions, transitionTo } from '../session/chain-manager.js';
+import { runWorkflow } from '../orchestrator/orchestrator.js';
+import { getDiff } from '../tools/git-tools.js';
+import { requireConfig, statusColor, stageLabel, timeAgo } from './format-helpers.js';
+
+export async function resumeCommand(options) {
+  const cwd = process.cwd();
+  requireConfig(cwd);
+
+  const config = loadConfig(cwd);
+  let chain;
+
+  if (options.chain) {
+    chain = loadChain(options.chain, cwd);
+    if (!chain) {
+      console.log(chalk.red(`Chain not found: ${options.chain}`));
+      process.exit(1);
+    }
+  } else {
+    const allChains = listChains(cwd);
+    const resumable = allChains.filter(c => c.status === 'active' || c.status === 'blocked');
+
+    if (resumable.length === 0) {
+      if (allChains.length === 0) {
+        console.log(chalk.dim('\nNo chains found. Run `openairev review` to start one.\n'));
+        return;
+      }
+      console.log(chalk.dim('\nNo active/blocked chains. Recent chains:\n'));
+      for (const c of allChains.slice(0, 5)) {
+        const ago = timeAgo(new Date(c.updated));
+        console.log(`  ${chalk.dim(c.chain_id)}  ${statusColor(c.status)(c.status)}  ${stageLabel(c.stage)}  ${ago}`);
+      }
+      console.log('');
+      return;
+    }
+
+    if (resumable.length === 1) {
+      chain = resumable[0];
+    } else {
+      const { selected } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selected',
+        message: 'Which workflow to resume?',
+        choices: resumable.map(c => {
+          const ago = timeAgo(new Date(c.updated));
+          const label = `${c.task?.user_request || 'untitled'} — ${stageLabel(c.stage)} — ${ago}`;
+          return { name: label, value: c.chain_id };
+        }),
+      }]);
+      chain = loadChain(selected, cwd);
+    }
+  }
+
+  if (!chain) {
+    console.log(chalk.red('Failed to load chain.'));
+    process.exit(1);
+  }
+
+  const executor = chain.participants.executor;
+  const reviewerName = chain.participants.reviewer;
+
+  console.log(chalk.bold('\nResuming Workflow\n'));
+  console.log(`  Chain:   ${chalk.dim(chain.chain_id)}`);
+  console.log(`  Stage:   ${chalk.cyan(stageLabel(chain.stage))}`);
+  console.log(`  Status:  ${statusColor(chain.status)(chain.status)}`);
+  console.log(`  Agents:  ${chalk.cyan(executor)} ↔ ${chalk.cyan(reviewerName)}`);
+  console.log(`  Rounds:  ${chain.rounds.length}/${chain.max_rounds}`);
+  if (chain.task?.user_request) console.log(`  Task:    ${chalk.dim(chain.task.user_request)}`);
+
+  // Handle blocked chain — answer pending questions
+  if (chain.status === 'blocked' && hasPendingQuestions(chain)) {
+    const pending = chain.questions.filter(q => q.status === 'pending');
+    console.log(chalk.yellow.bold('\n  Pending questions:\n'));
+
+    for (const q of pending) {
+      const { answer } = await inquirer.prompt([{
+        type: 'input',
+        name: 'answer',
+        message: q.question,
+      }]);
+      answerQuestion(chain, q.id, answer, cwd);
+    }
+
+    if (chain.stage === 'awaiting_user') {
+      transitionTo(chain, 'planning', cwd);
+    }
+    console.log(chalk.green('\n  Questions answered. Resuming workflow...\n'));
+  }
+
+  let diff = '';
+  try { diff = getDiff(); } catch { /* ok */ }
+
+  const codeRoundsDone = chain.rounds.filter(r => r.kind === 'code_review').length;
+  if (codeRoundsDone >= chain.max_rounds) {
+    console.log(chalk.yellow('\nMax rounds reached. Start a new workflow with `openairev review`.'));
+    return;
+  }
+
+  try {
+    const result = await runWorkflow({
+      config, executor, reviewerName, maxRounds: chain.max_rounds,
+      diff, taskDescription: chain.task?.user_request,
+      specRef: chain.task?.spec_ref, tools: config.tools,
+      cwd, existingChain: chain,
+      onStageChange: (stage) => console.log(chalk.bold(`\n[${stageLabel(stage)}]\n`)),
+      onRoundEnd: (stage, review, toolResults) => {
+        if (toolResults) {
+          for (const [name, tr] of Object.entries(toolResults)) {
+            const icon = tr.passed ? chalk.green('✓') : chalk.red('✗');
+            console.log(`  ${icon} ${name}: ${tr.output}`);
+          }
+        }
+        if (review.verdict) {
+          const v = review.verdict;
+          const color = statusColor(v.status);
+          console.log(`  ${color(v.status.toUpperCase())} (${((v.confidence || 0) * 100).toFixed(0)}%)`);
+          if (v.critical_issues?.length) {
+            v.critical_issues.forEach(i => console.log(`    ${chalk.red('•')} ${i}`));
+          }
+        }
+      },
+    });
+
+    console.log(chalk.bold(`\n${'='.repeat(40)}`));
+    console.log(`  Status: ${statusColor(result.status)(result.status)}`);
+    if (result.message) console.log(`  ${chalk.yellow(result.message)}`);
+    console.log('');
+  } catch (e) {
+    console.log(chalk.red(`\nResume failed: ${e.message}`));
+    process.exit(1);
+  }
+}

package/src/cli/review.js

@@ -0,0 +1,151 @@
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { loadConfig, getReviewer, getMaxIterations } from '../config/config-loader.js';
+import { getDiff } from '../tools/git-tools.js';
+import { runReview } from '../review/review-runner.js';
+import { runWorkflow } from '../orchestrator/orchestrator.js';
+import { createSession, saveSession } from '../session/session-manager.js';
+import { requireConfig, statusColor, stageLabel } from './format-helpers.js';
+
+export async function reviewCommand(options) {
+  const cwd = process.cwd();
+  requireConfig(cwd);
+
+  const config = loadConfig(cwd);
+  const executor = options.executor || guessExecutor(config);
+  const reviewerName = options.reviewer || getReviewer(config, executor);
+
+  if (!reviewerName) {
+    console.log(chalk.red(`No reviewer configured for executor "${executor}". Run \`openairev init\` or use --reviewer.`));
+    process.exit(1);
+  }
+
+  const maxRounds = options.rounds || getMaxIterations(config, executor);
+  const skipAnalyze = options.once || options.quick;
+  const skipPlan = options.once || options.quick || !options.plan;
+
+  console.log(chalk.bold(`\nOpenAIRev\n`));
+  console.log(`  Executor:    ${chalk.cyan(executor)}`);
+  console.log(`  Reviewer:    ${chalk.cyan(reviewerName)}`);
+  console.log(`  Max rounds:  ${chalk.cyan(maxRounds)}`);
+
+  if (options.once) {
+    console.log(`  Mode:        ${chalk.cyan('single review')}`);
+  } else if (options.plan) {
+    console.log(`  Mode:        ${chalk.cyan('full workflow (analyze → plan → review → implement)')}`);
+  } else {
+    console.log(`  Mode:        ${chalk.cyan('implement → review loop')}`);
+  }
+
+  let diff = '';
+  if (options.file) {
+    console.log(`  Source:      ${chalk.cyan(options.file)}`);
+    diff = readFileSync(options.file, 'utf-8');
+  } else {
+    try { diff = getDiff(options.diff); } catch { /* no diff yet is ok for workflow mode */ }
+    if (diff?.trim()) console.log(`  Diff lines:  ${chalk.cyan(diff.split('\n').length)}`);
+  }
+
+  if (options.specRef) console.log(`  Spec:        ${chalk.cyan(options.specRef)}`);
+
+  if (options.dryRun) {
+    console.log(chalk.yellow('\n[Dry run] Would start workflow. Exiting.'));
+    return;
+  }
+
+  console.log('');
+
+  if (options.once) {
+    if (!diff?.trim()) {
+      console.log(chalk.yellow('No changes found. Stage some changes or specify --diff <ref>.'));
+      process.exit(0);
+    }
+    try {
+      console.log(chalk.dim('Starting review...\n'));
+      const review = await runReview(diff, { config, reviewerName, cwd });
+
+      const session = createSession({ executor, reviewer: reviewerName, diff_ref: options.diff || 'auto' });
+      session.iterations.push({ round: 1, review, timestamp: new Date().toISOString() });
+      session.final_verdict = review.verdict;
+      session.status = review.verdict ? 'completed' : 'error';
+      saveSession(session, cwd);
+
+      if (review.verdict) {
+        printVerdict(review.verdict);
+        console.log(chalk.dim(`\nSession: ${session.id}`));
+      } else {
+        console.log(chalk.yellow('\nReviewer did not return a structured verdict.'));
+      }
+    } catch (e) {
+      console.log(chalk.red(`\nReview failed: ${e.message}`));
+      process.exit(1);
+    }
+  } else {
+    try {
+      const result = await runWorkflow({
+        config, executor, reviewerName, maxRounds, diff, diffRef: options.diff,
+        taskDescription: options.task, specRef: options.specRef, tools: config.tools,
+        cwd, skipAnalyze, skipPlan,
+        onStageChange: (stage) => console.log(chalk.bold(`\n[${stageLabel(stage)}]\n`)),
+        onRoundEnd: (stage, review, toolResults) => {
+          if (toolResults) {
+            for (const [name, tr] of Object.entries(toolResults)) {
+              const icon = tr.passed ? chalk.green('✓') : chalk.red('✗');
+              console.log(`  ${icon} ${name}: ${tr.output}`);
+            }
+            console.log('');
+          }
+          if (review.verdict) printVerdict(review.verdict);
+        },
+      });
+
+      console.log(chalk.bold(`\n${'='.repeat(40)}`));
+      console.log(chalk.bold('Workflow Complete\n'));
+      console.log(`  Status:  ${statusColor(result.status)(result.status)}`);
+      if (result.rounds) console.log(`  Rounds:  ${result.rounds}`);
+      if (result.stage) console.log(`  Stage:   ${stageLabel(result.stage)}`);
+      console.log(`  Chain:   ${chalk.dim(result.chain.chain_id)}`);
+      if (result.message) console.log(`  Note:    ${chalk.yellow(result.message)}`);
+      if (result.status === 'blocked') {
+        console.log(chalk.yellow(`\nWorkflow waiting for user input. Run \`openairev resume\`.`));
+      }
+      console.log('');
+    } catch (e) {
+      console.log(chalk.red(`\nWorkflow failed: ${e.message}`));
+      process.exit(1);
+    }
+  }
+}
+
+function printVerdict(verdict) {
+  console.log(chalk.bold('Verdict: ') + statusColor(verdict.status)(verdict.status.toUpperCase()));
+  console.log(`Risk:       ${verdict.risk_level || 'unknown'}`);
+  console.log(`Confidence: ${((verdict.confidence || 0) * 100).toFixed(0)}%\n`);
+
+  const sections = [
+    ['critical_issues', chalk.red, 'Critical Issues'],
+    ['missing_requirements', chalk.red, 'Missing Requirements'],
+    ['test_gaps', chalk.yellow, 'Test Gaps'],
+    ['requirement_mismatches', chalk.yellow, 'Requirement Mismatches'],
+    ['sequencing_issues', chalk.yellow, 'Sequencing Issues'],
+    ['risks', chalk.yellow, 'Risks'],
+    ['repair_instructions', chalk.cyan, 'Repair Instructions'],
+  ];
+
+  for (const [key, color, label] of sections) {
+    if (verdict[key]?.length) {
+      console.log(color.bold(`${label}:`));
+      verdict[key].forEach(i => console.log(`  ${color('•')} ${i}`));
+    }
+  }
+
+  if (verdict.false_positives_reconsidered?.length) {
+    console.log(chalk.dim('\nFalse Positives Dropped:'));
+    verdict.false_positives_reconsidered.forEach(i => console.log(`  ${chalk.dim('~')} ${i}`));
+  }
+}
+
+function guessExecutor(config) {
+  const agents = Object.keys(config.agents || {}).filter(a => config.agents[a].available);
+  return agents[0] || 'claude_code';
+}