openairev 0.2.0

package/src/cli/status.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { listSessions } from '../session/session-manager.js';
+import { getActiveChain } from '../session/chain-manager.js';
+import { loadConfig } from '../config/config-loader.js';
+import { requireConfig, statusColor, stageLabel, timeAgo } from './format-helpers.js';
+
+export async function statusCommand() {
+  const cwd = process.cwd();
+  requireConfig(cwd);
+
+  const config = loadConfig(cwd);
+
+  console.log(chalk.bold('\nOpenAIRev Status\n'));
+
+  const agents = Object.entries(config.agents || {})
+    .filter(([, v]) => v.available)
+    .map(([k]) => k);
+  console.log(`  Agents:   ${agents.map(a => chalk.cyan(a)).join(', ') || chalk.dim('none')}`);
+  console.log(`  Trigger:  ${chalk.cyan(config.review_trigger)}`);
+
+  const toolNames = config.tools ? Object.keys(config.tools) : [];
+  console.log(`  Tools:    ${toolNames.map(t => chalk.dim(t)).join(', ') || chalk.dim('none')}`);
+
+  for (const [executor, policy] of Object.entries(config.review_policy || {})) {
+    const reviewer = typeof policy === 'string' ? policy : policy.reviewer;
+    const iterations = typeof policy === 'object' ? policy.max_iterations : null;
+    const iterStr = iterations ? ` (max ${iterations} iterations)` : '';
+    console.log(`  Policy:   ${chalk.cyan(executor)} → reviewed by ${chalk.cyan(reviewer)}${chalk.dim(iterStr)}`);
+  }
+
+  const activeChain = getActiveChain(cwd);
+  if (activeChain) {
+    const stColor = activeChain.status === 'blocked' ? chalk.yellow : chalk.blue;
+
+    console.log(chalk.bold('\n  Active Workflow'));
+    console.log(`    Chain:    ${chalk.dim(activeChain.chain_id)}`);
+    console.log(`    Stage:    ${stColor(stageLabel(activeChain.stage))}`);
+    console.log(`    Status:   ${statusColor(activeChain.status)(activeChain.status)}`);
+    console.log(`    Agents:   ${chalk.cyan(activeChain.participants.executor)} ↔ ${chalk.cyan(activeChain.participants.reviewer)}`);
+    console.log(`    Rounds:   ${activeChain.rounds.length}/${activeChain.max_rounds}`);
+
+    if (activeChain.task?.user_request) console.log(`    Task:     ${chalk.dim(activeChain.task.user_request)}`);
+    if (activeChain.task?.spec_ref) console.log(`    Spec:     ${chalk.dim(activeChain.task.spec_ref)}`);
+
+    const phase = activeChain.phases?.[activeChain.phase_index];
+    if (phase) console.log(`    Phase:    ${phase.name} (${phase.status})`);
+
+    const pending = activeChain.questions?.filter(q => q.status === 'pending') || [];
+    if (pending.length > 0) {
+      console.log(chalk.yellow.bold('\n    Pending Questions:'));
+      pending.forEach(q => console.log(`      ${chalk.yellow('?')} [${q.id}] ${q.question}`));
+    }
+
+    const lastRound = activeChain.rounds?.[activeChain.rounds.length - 1];
+    if (lastRound?.review?.verdict) {
+      const v = lastRound.review.verdict;
+      console.log(`\n    Last ${lastRound.kind}: ${statusColor(v.status)(v.status)} (${((v.confidence || 0) * 100).toFixed(0)}%)`);
+    }
+
+    console.log(chalk.dim(`\n    Resume with: openairev resume`));
+  } else {
+    console.log(chalk.dim('\n  No active workflows.'));
+  }
+
+  const sessions = listSessions(cwd, 1);
+  if (sessions.length > 0) {
+    const last = sessions[0];
+    const ago = timeAgo(new Date(last.created));
+    console.log(`\n  Last review: ${statusColor(last.status)(last.status)} — ${ago}`);
+  }
+
+  console.log('');
+}

package/src/config/config-loader.js

@@ -0,0 +1,74 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import YAML from 'yaml';
+import { DEFAULTS } from './defaults.js';
+
+const CONFIG_DIR = '.openairev';
+const CONFIG_FILE = 'config.yaml';
+
+export function getConfigDir(cwd = process.cwd()) {
+  return join(cwd, CONFIG_DIR);
+}
+
+export function getConfigPath(cwd = process.cwd()) {
+  return join(getConfigDir(cwd), CONFIG_FILE);
+}
+
+export function configExists(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
+
+export function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    return deepMerge({}, DEFAULTS);
+  }
+  const raw = readFileSync(configPath, 'utf-8');
+  const parsed = YAML.parse(raw);
+  return deepMerge(DEFAULTS, parsed);
+}
+
+/**
+ * Get the reviewer agent name for a given executor.
+ * Supports both formats:
+ *   review_policy.claude_code: "codex"              (simple)
+ *   review_policy.claude_code: { reviewer: "codex" } (full)
+ */
+export function getReviewer(config, executor) {
+  const policy = config.review_policy?.[executor];
+  if (!policy) return null;
+  if (typeof policy === 'string') return policy;
+  return policy.reviewer || null;
+}
+
+/**
+ * Get max iterations for a given executor↔reviewer direction.
+ */
+export function getMaxIterations(config, executor) {
+  const policy = config.review_policy?.[executor];
+  if (typeof policy === 'object' && policy.max_iterations != null) {
+    return policy.max_iterations;
+  }
+  return 3; // default
+}
+
+/**
+ * Deep merge two objects. User values override defaults.
+ * Arrays are replaced, not merged.
+ */
+function deepMerge(defaults, overrides) {
+  if (!overrides) return { ...defaults };
+  if (!defaults) return { ...overrides };
+
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const val = overrides[key];
+    if (val && typeof val === 'object' && !Array.isArray(val) &&
+        result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}

package/src/config/config-loader.test.js

@@ -0,0 +1,113 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, configExists, getReviewer, getMaxIterations } from './config-loader.js';
+
+const TMP = join(process.cwd(), '.test-tmp-config');
+
+describe('config-loader', () => {
+  beforeEach(() => {
+    mkdirSync(join(TMP, '.openairev'), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TMP, { recursive: true, force: true });
+  });
+
+  it('returns defaults when no config file exists', () => {
+    const config = loadConfig(TMP);
+    assert.equal(config.review_trigger, 'explicit');
+    assert.ok(config.agents.claude_code);
+    assert.ok(config.agents.codex);
+  });
+
+  it('detects config existence', () => {
+    assert.equal(configExists(TMP), false);
+    writeFileSync(join(TMP, '.openairev', 'config.yaml'), 'review_trigger: auto\n');
+    assert.equal(configExists(TMP), true);
+  });
+
+  it('loads and merges config with defaults', () => {
+    writeFileSync(join(TMP, '.openairev', 'config.yaml'), [
+      'review_trigger: auto',
+      'review_policy:',
+      '  claude_code:',
+      '    reviewer: codex',
+      '    max_iterations: 5',
+    ].join('\n'));
+
+    const config = loadConfig(TMP);
+    assert.equal(config.review_trigger, 'auto');
+    assert.equal(getReviewer(config, 'claude_code'), 'codex');
+    assert.ok(config.agents);
+  });
+
+  it('getReviewer works with simple string format', () => {
+    const config = { review_policy: { claude_code: 'codex', codex: 'claude_code' } };
+    assert.equal(getReviewer(config, 'claude_code'), 'codex');
+    assert.equal(getReviewer(config, 'codex'), 'claude_code');
+    assert.equal(getReviewer(config, 'unknown'), null);
+  });
+
+  it('getReviewer works with object format', () => {
+    const config = {
+      review_policy: {
+        claude_code: { reviewer: 'codex', max_iterations: 5 },
+        codex: { reviewer: 'claude_code', max_iterations: 1 },
+      },
+    };
+    assert.equal(getReviewer(config, 'claude_code'), 'codex');
+    assert.equal(getReviewer(config, 'codex'), 'claude_code');
+  });
+
+  it('getMaxIterations returns per-direction iterations', () => {
+    const config = {
+      review_policy: {
+        claude_code: { reviewer: 'codex', max_iterations: 5 },
+        codex: { reviewer: 'claude_code', max_iterations: 1 },
+      },
+    };
+    assert.equal(getMaxIterations(config, 'claude_code'), 5);
+    assert.equal(getMaxIterations(config, 'codex'), 1);
+  });
+
+  it('getMaxIterations returns default for simple string policy', () => {
+    const config = { review_policy: { claude_code: 'codex' } };
+    assert.equal(getMaxIterations(config, 'claude_code'), 3);
+  });
+
+  it('getMaxIterations returns default for unknown executor', () => {
+    assert.equal(getMaxIterations({}, 'unknown'), 3);
+  });
+
+  it('deep merges partial config without dropping nested defaults', () => {
+    // Only override claude_code agent, codex should still be present from defaults
+    writeFileSync(join(TMP, '.openairev', 'config.yaml'), [
+      'agents:',
+      '  claude_code:',
+      '    available: true',
+    ].join('\n'));
+
+    const config = loadConfig(TMP);
+    assert.equal(config.agents.claude_code.available, true);
+    assert.equal(config.agents.claude_code.cmd, 'claude'); // from defaults
+    assert.ok(config.agents.codex); // not dropped
+    assert.equal(config.agents.codex.cmd, 'codex'); // from defaults
+  });
+
+  it('deep merges review_policy without dropping other directions', () => {
+    writeFileSync(join(TMP, '.openairev', 'config.yaml'), [
+      'review_policy:',
+      '  claude_code:',
+      '    reviewer: codex',
+      '    max_iterations: 10',
+    ].join('\n'));
+
+    const config = loadConfig(TMP);
+    // Overridden value
+    assert.equal(getMaxIterations(config, 'claude_code'), 10);
+    // Default for codex direction still present
+    assert.equal(getReviewer(config, 'codex'), 'claude_code');
+  });
+});

package/src/config/defaults.js

@@ -0,0 +1,38 @@
+export const DEFAULTS = {
+  agents: {
+    claude_code: {
+      cmd: 'claude',
+      available: false,
+    },
+    codex: {
+      cmd: 'codex',
+      available: false,
+    },
+  },
+  // max_iterations is per direction — it controls how many rounds the
+  // EXECUTOR gets to fix its code after receiving review feedback.
+  // Claude Code is less stable at aligning to reviewer feedback across
+  // rounds, so it gets more iterations to converge. Codex applies
+  // feedback more consistently, so fewer iterations are needed.
+  // These are defaults — users override during `openairev init`.
+  review_policy: {
+    claude_code: {
+      reviewer: 'codex',
+      max_iterations: 5,
+    },
+    codex: {
+      reviewer: 'claude_code',
+      max_iterations: 1,
+    },
+  },
+  review_trigger: 'explicit',
+  tools: {
+    run_tests: 'npm test',
+    run_lint: 'npm run lint',
+    run_typecheck: 'npx tsc --noEmit',
+  },
+  session: {
+    store_history: true,
+    archive_after: '7d',
+  },
+};

package/src/config/plan-verdict-schema.json

@@ -0,0 +1,44 @@
+{
+  "type": "object",
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["approved", "needs_changes", "reject"]
+    },
+    "critical_issues": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "missing_requirements": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "sequencing_issues": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "risks": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "risk_level": {
+      "type": "string",
+      "enum": ["low", "medium", "high"]
+    },
+    "confidence": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "repair_instructions": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "false_positives_reconsidered": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  },
+  "required": ["status", "critical_issues", "risk_level", "confidence"],
+  "additionalProperties": false
+}

package/src/config/verdict-schema.json

@@ -0,0 +1,44 @@
+{
+  "type": "object",
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["approved", "needs_changes", "reject"]
+    },
+    "critical_issues": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "test_gaps": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "requirement_mismatches": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "rule_violations": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "risk_level": {
+      "type": "string",
+      "enum": ["low", "medium", "high"]
+    },
+    "confidence": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "repair_instructions": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "false_positives_reconsidered": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  },
+  "required": ["status", "critical_issues", "risk_level", "confidence"],
+  "additionalProperties": false
+}

package/src/mcp/mcp-server.js

@@ -0,0 +1,261 @@
+import { loadConfig, getReviewer } from '../config/config-loader.js';
+import { getDiff } from '../tools/git-tools.js';
+import { runToolGates } from '../tools/tool-runner.js';
+import { runReview } from '../review/review-runner.js';
+import { createSession, saveSession } from '../session/session-manager.js';
+
+/**
+ * MCP Server using stdio with Content-Length framing per MCP spec.
+ * Both Claude Code and Codex can call this as an MCP server.
+ */
+export function startMcpServer() {
+  const cwd = process.cwd();
+  const config = loadConfig(cwd);
+
+  let buffer = Buffer.alloc(0);
+
+  process.stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    buffer = processBuffer(buffer, config, cwd);
+  });
+
+  process.stdin.on('end', () => process.exit(0));
+}
+
+/**
+ * Parse Content-Length framed messages from buffer.
+ * Format: "Content-Length: <N>\r\n\r\n<JSON body of N bytes>"
+ */
+function processBuffer(buf, config, cwd) {
+  while (true) {
+    const headerEnd = buf.indexOf('\r\n\r\n');
+    if (headerEnd === -1) break;
+
+    const header = buf.slice(0, headerEnd).toString('utf-8');
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) {
+      // Fallback: try newline-delimited JSON for compatibility
+      const nlIndex = buf.indexOf('\n');
+      if (nlIndex === -1) break;
+      const line = buf.slice(0, nlIndex).toString('utf-8').trim();
+      buf = buf.slice(nlIndex + 1);
+      if (line) {
+        try {
+          const request = JSON.parse(line);
+          handleRequest(request, config, cwd).then(response => {
+            if (response !== null) sendResponse(response);
+          }).catch(() => {});
+        } catch {
+          // skip malformed
+        }
+      }
+      continue;
+    }
+
+    const contentLength = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    if (buf.length < bodyStart + contentLength) break; // incomplete body
+
+    const body = buf.slice(bodyStart, bodyStart + contentLength).toString('utf-8');
+    buf = buf.slice(bodyStart + contentLength);
+
+    try {
+      const request = JSON.parse(body);
+      handleRequest(request, config, cwd).then(response => {
+        if (response !== null) sendResponse(response);
+      });
+    } catch {
+      sendResponse({
+        jsonrpc: '2.0',
+        error: { code: -32700, message: 'Parse error' },
+        id: null,
+      });
+    }
+  }
+  return buf; // Return unconsumed remainder
+}
+
+/**
+ * Send a JSON-RPC response with Content-Length framing.
+ */
+function sendResponse(response) {
+  const body = JSON.stringify(response);
+  const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+  process.stdout.write(header + body);
+}
+
+async function handleRequest(request, config, cwd) {
+  const { method, params, id } = request;
+
+  switch (method) {
+    case 'initialize':
+      return {
+        jsonrpc: '2.0',
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'openairev', version: '0.2.0' },
+        },
+        id,
+      };
+
+    case 'notifications/initialized':
+      return null; // Notifications get no response
+
+    case 'tools/list':
+      return {
+        jsonrpc: '2.0',
+        result: {
+          tools: getToolDefinitions(),
+        },
+        id,
+      };
+
+    case 'tools/call':
+      return {
+        jsonrpc: '2.0',
+        result: await callTool(params.name, params.arguments || {}, config, cwd),
+        id,
+      };
+
+    default:
+      return {
+        jsonrpc: '2.0',
+        error: { code: -32601, message: `Method not found: ${method}` },
+        id,
+      };
+  }
+}
+
+function getToolDefinitions() {
+  return [
+    {
+      name: 'openairev_review',
+      description: 'TRIGGER: Use this tool when the user says "review", "review my code", "get a review", "check my changes", "openairev", or asks for independent/cross-model code review. Sends current code changes to a DIFFERENT AI model for independent review. Returns a structured verdict with critical issues, test gaps, risk level, confidence score, and repair instructions. The reviewer is never the same model as the executor — this ensures unbiased, independent judgment.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          executor: {
+            type: 'string',
+            description: 'Which agent wrote the code (claude_code or codex). If you are Claude Code, set this to "claude_code". If you are Codex, set this to "codex". This determines which other model will review.',
+          },
+          diff: {
+            type: 'string',
+            description: 'The diff or code to review. If omitted, auto-detects from git (staged → unstaged → last commit).',
+          },
+          task_description: {
+            type: 'string',
+            description: 'What the code is supposed to do. Used for requirement checking. Include acceptance criteria if available.',
+          },
+        },
+      },
+    },
+    {
+      name: 'openairev_status',
+      description: 'Get the status and verdict of the most recent OpenAIRev review session. Use when the user asks "what did the review say", "review status", or "last review results".',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'openairev_run_tests',
+      description: 'Run the project test suite and return pass/fail results. Use when user asks to "run tests" or you need to verify code before review.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'openairev_run_lint',
+      description: 'Run the project linter and return results.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'openairev_get_diff',
+      description: 'Get the current git diff (staged, unstaged, or last commit).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          ref: { type: 'string', description: 'Git ref to diff against' },
+        },
+      },
+    },
+  ];
+}
+
+async function callTool(name, args, config, cwd) {
+  try {
+    switch (name) {
+      case 'openairev_review': {
+        const executor = args.executor || Object.keys(config.agents).find(a => config.agents[a].available);
+        const reviewerName = getReviewer(config, executor);
+        if (!reviewerName) {
+          return formatResult(`No reviewer configured for executor "${executor}"`);
+        }
+        const diff = args.diff || getDiff();
+
+        if (!diff.trim()) {
+          return formatResult('No changes found to review.');
+        }
+
+        const review = await runReview(diff, {
+          config,
+          reviewerName,
+          taskDescription: args.task_description,
+          cwd,
+        });
+
+        // Save session
+        const session = createSession({ executor, reviewer: reviewerName });
+        session.iterations.push({ round: 1, review, timestamp: new Date().toISOString() });
+        session.final_verdict = review.verdict;
+        session.status = 'completed';
+        saveSession(session, cwd);
+
+        // Return executor-facing feedback (framed as peer review, not user command)
+        return formatResult(review.executor_feedback || JSON.stringify(review.verdict || review, null, 2));
+      }
+
+      case 'openairev_status': {
+        const { listSessions } = await import('../session/session-manager.js');
+        const sessions = listSessions(cwd, 1);
+        if (sessions.length === 0) {
+          return formatResult('No review sessions found.');
+        }
+        const last = sessions[0];
+        return formatResult(JSON.stringify({
+          id: last.id,
+          status: last.status,
+          verdict: last.final_verdict,
+          created: last.created,
+        }, null, 2));
+      }
+
+      case 'openairev_run_tests': {
+        const testCmd = config.tools?.run_tests || 'npm test';
+        const results = runToolGates(['run_tests'], cwd, { run_tests: testCmd });
+        return formatResult(JSON.stringify(results.tests, null, 2));
+      }
+
+      case 'openairev_run_lint': {
+        const lintCmd = config.tools?.run_lint || 'npm run lint';
+        const results = runToolGates(['run_lint'], cwd, { run_lint: lintCmd });
+        return formatResult(JSON.stringify(results.lint, null, 2));
+      }
+
+      case 'openairev_get_diff': {
+        const diff = getDiff(args.ref);
+        return formatResult(diff || 'No changes found.');
+      }
+
+      default:
+        return formatResult(`Unknown tool: ${name}`);
+    }
+  } catch (e) {
+    return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+  }
+}
+
+function formatResult(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+// If run directly, start the server
+if (process.argv[1] && process.argv[1].includes('mcp-server')) {
+  startMcpServer();
+}