openairev 0.2.4 → 0.3.1

package/bin/openairev.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
+import { VERSION } from '../src/version.js';
 import { initCommand } from '../src/cli/init.js';
 import { reviewCommand } from '../src/cli/review.js';
 import { resumeCommand } from '../src/cli/resume.js';
@@ -12,7 +13,7 @@ const program = new Command();
 program
   .name('openairev')
   .description('OpenAIRev — cross-model AI code reviewer')
-  .version('0.2.4');
+  .version(VERSION);
 
 program
   .command('init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openairev",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Cross-model AI code reviewer — independent review for AI-assisted coding workflows",
   "type": "module",
   "bin": {

package/src/agents/claude-code.js

@@ -38,9 +38,9 @@ export class ClaudeCodeAdapter {
       if (!this.sessionName && parsed.session_id) {
         this.sessionName = parsed.session_id;
       }
-      return parsed;
+      return { ...parsed, raw_output: result.stdout };
     } catch {
-      return { raw: result.stdout, error: 'Failed to parse JSON output' };
+      return { raw: result.stdout, raw_output: result.stdout, error: 'Failed to parse JSON output' };
     }
   }
 }

package/src/agents/codex.js

@@ -1,6 +1,7 @@
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { exec } from './exec-helper.js';
+import { createCodexSummarizer } from './stream-summarizer.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -15,7 +16,7 @@ export class CodexAdapter {
     this.sessionId = id;
   }
 
-  async run(prompt, { useSchema = false, schemaFile = 'verdict-schema.json', continueSession = false, sessionName = null } = {}) {
+  async run(prompt, { useSchema = false, schemaFile = 'verdict-schema.json', continueSession = false, sessionName = null, stream = false } = {}) {
     const args = ['exec'];
 
     if (continueSession && this.sessionId) {
@@ -30,7 +31,11 @@ export class CodexAdapter {
       args.push('--output-schema', schemaPath);
     }
 
-    const result = await exec(this.cmd, args);
+    const summarizer = stream ? createCodexSummarizer({
+      reviewerName: stream.reviewerName || 'codex',
+      tty: stream.tty !== false,
+    }) : undefined;
+    const result = await exec(this.cmd, args, { onData: summarizer });
 
     try {
       const lines = result.stdout.trim().split('\n');
@@ -60,17 +65,19 @@ export class CodexAdapter {
         this.sessionId = sessionId;
       }
 
+      const progress = summarizer?.getProgress() || [];
+
       if (agentMessage) {
         try {
-          return { result: JSON.parse(agentMessage), session_id: this.sessionId };
+          return { result: JSON.parse(agentMessage), raw_output: result.stdout, progress, session_id: this.sessionId };
         } catch {
-          return { result: agentMessage, session_id: this.sessionId };
+          return { result: agentMessage, raw_output: result.stdout, progress, session_id: this.sessionId };
         }
       }
 
-      return { raw: result.stdout, session_id: this.sessionId };
+      return { raw: result.stdout, raw_output: result.stdout, progress, session_id: this.sessionId };
     } catch {
-      return { raw: result.stdout, error: 'Failed to parse output' };
+      return { raw: result.stdout, raw_output: result.stdout, error: 'Failed to parse output' };
     }
   }
 }

package/src/agents/exec-helper.js

@@ -1,13 +1,51 @@
-import { execFile } from 'child_process';
+import { spawn } from 'child_process';
 
-export function exec(cmd, args) {
+const MAX_BUFFER = 10 * 1024 * 1024;
+
+export function exec(cmd, args, { onData } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(cmd, args, {
-      maxBuffer: 10 * 1024 * 1024,
+    const child = spawn(cmd, args, {
       timeout: 300_000,
-    }, (error, stdout, stderr) => {
-      if (error && !stdout) {
-        reject(new Error(`${cmd} failed: ${stderr || error.message}`));
+    });
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutLen = 0;
+    let stderrLen = 0;
+    let killed = false;
+
+    child.stdout.on('data', (chunk) => {
+      if (onData) onData(chunk.toString());
+      stdoutLen += chunk.length;
+      if (stdoutLen <= MAX_BUFFER) {
+        stdoutChunks.push(chunk);
+      } else if (!killed) {
+        killed = true;
+        child.kill();
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderrLen += chunk.length;
+      if (stderrLen <= MAX_BUFFER) {
+        stderrChunks.push(chunk);
+      } else if (!killed) {
+        killed = true;
+        child.kill();
+      }
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`${cmd} failed: ${err.message}`));
+    });
+
+    child.on('close', (code) => {
+      const stdout = Buffer.concat(stdoutChunks).toString();
+      const stderr = Buffer.concat(stderrChunks).toString();
+      if (killed) {
+        reject(new Error(`${cmd} output exceeded ${MAX_BUFFER} bytes`));
+      } else if (code !== 0 && !stdout) {
+        reject(new Error(`${cmd} failed (exit ${code}): ${stderr}`));
       } else {
         resolve({ stdout, stderr });
       }

package/src/agents/stream-summarizer.js

@@ -0,0 +1,139 @@
+import chalk from 'chalk';
+
+/**
+ * Creates a summarizer callback for Codex NDJSON event streams.
+ * tty=true: prints colored progress to stderr.
+ * tty=false: collects plain-text progress lines silently.
+ * Both modes always collect lines for the final summary.
+ */
+export function createCodexSummarizer({ reviewerName, tty = true } = {}) {
+  const seenFiles = new Set();
+  const progressLines = [];
+  let buffer = '';
+  let started = false;
+
+  const summarizer = (chunk) => {
+    if (!started) {
+      started = true;
+      if (reviewerName) emit(`reviewer: ${reviewerName}`, 'cyan');
+    }
+    buffer += chunk;
+    const lines = buffer.split('\n');
+    buffer = lines.pop();
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        summarizeCodexEvent(event, seenFiles, { emit });
+      } catch {
+        // skip non-JSON
+      }
+    }
+  };
+
+  summarizer.getProgress = () => progressLines;
+
+  function emit(msg, color) {
+    if (progressLines.length < 200) progressLines.push(msg);
+    if (tty) {
+      const colorFn = color === 'cyan' ? chalk.cyan
+        : color === 'green' ? chalk.green
+        : color === 'yellow' ? chalk.yellow
+        : color === 'red' ? chalk.red
+        : chalk.dim;
+      process.stderr.write(`  ${colorFn(msg)}\n`);
+    }
+  }
+
+  return summarizer;
+}
+
+function summarizeCodexEvent(event, seenFiles, { emit }) {
+  const type = event.type;
+
+  if (type === 'thread.started') {
+    emit(`session: ${event.thread_id}`);
+  }
+
+  if (type === 'item.started' && event.item?.type === 'todo_list') {
+    const items = event.item.items?.map(i => i.text) || [];
+    emit('plan:', 'cyan');
+    for (const item of items) emit(`  • ${item}`);
+  }
+
+  if (type === 'item.completed' && event.item?.type === 'todo_list') {
+    const items = event.item.items || [];
+    const done = items.filter(i => i.completed).length;
+    emit(`progress: ${done}/${items.length} tasks done`);
+  }
+
+  if (type === 'item.started' && event.item?.type === 'command_execution') {
+    const cmd = event.item.command || '';
+    if (isInternalCmd(cmd)) return;
+    const file = extractFileFromCmd(cmd);
+    if (file && !seenFiles.has(file)) {
+      seenFiles.add(file);
+      emit(`reading: ${file}`);
+    } else if (!file) {
+      const short = summarizeCmd(cmd);
+      if (short) emit(`running: ${short}`);
+    }
+  }
+
+  if (type === 'item.completed' && event.item?.type === 'command_execution') {
+    const exit = event.item.exit_code;
+    if (exit !== null && exit !== 0) {
+      const cmd = summarizeCmd(event.item.command || '');
+      emit(`command failed (exit ${exit}): ${cmd}`, 'yellow');
+    }
+  }
+
+  if (type === 'item.started' && event.item?.type === 'agent_message') {
+    emit('generating verdict...', 'cyan');
+  }
+
+  if (type === 'item.completed' && event.item?.type === 'agent_message') {
+    emit('verdict ready', 'green');
+  }
+
+  if (type === 'turn.completed' && event.usage) {
+    const { input_tokens, output_tokens } = event.usage;
+    const total = input_tokens + output_tokens;
+    emit(`tokens: ${fmt(total)} total (${fmt(input_tokens)} in / ${fmt(output_tokens)} out)`);
+  }
+
+  if (type === 'error' || type === 'turn.failed') {
+    const msg = event.message || event.error?.message || 'unknown error';
+    emit(`error: ${msg}`, 'red');
+  }
+}
+
+function isInternalCmd(cmd) {
+  return /node\s+-e\s/.test(cmd) ||
+    /require\(['"]child_process['"]\)/.test(cmd) ||
+    /spawn\(/.test(cmd) ||
+    /execFile\(/.test(cmd) ||
+    /process\.exec/.test(cmd) ||
+    /<<'NODE'/.test(cmd) ||
+    /echo\s/.test(cmd);
+}
+
+function extractFileFromCmd(cmd) {
+  const match = cmd.match(/(?:cat|sed|nl|head|tail|less)\s+(?:-[^\s]*\s+)*([^\s|>"']+\.\w+)/);
+  if (match) return match[1];
+  const match2 = cmd.match(/\s([a-zA-Z][\w/.-]+\.\w{1,5})(?:\s|$|\|)/);
+  return match2 ? match2[1] : null;
+}
+
+function summarizeCmd(cmd) {
+  const inner = cmd.replace(/^\/bin\/\w+\s+-\w+\s+["'](.+)["']$/, '$1');
+  const clean = inner.replace(/\\"/g, '"').trim();
+  return clean.length > 80 ? clean.slice(0, 77) + '...' : clean;
+}
+
+function fmt(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + 'k';
+  return String(n);
+}

package/src/cli/review.js

@@ -25,8 +25,8 @@ export async function reviewCommand(options) {
   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(`  Executor:    ${chalk.dim(executor)}`);
   console.log(`  Max rounds:  ${chalk.cyan(maxRounds)}`);
 
   if (options.once) {
@@ -62,7 +62,7 @@ export async function reviewCommand(options) {
     }
     try {
       console.log(chalk.dim('Starting review...\n'));
-      const review = await runReview(diff, { config, reviewerName, cwd });
+      const review = await runReview(diff, { config, reviewerName, cwd, stream: true });
 
       const session = createSession({ executor, reviewer: reviewerName, diff_ref: options.diff || 'auto' });
       session.iterations.push({ round: 1, review, timestamp: new Date().toISOString() });

package/src/mcp/mcp-server.js

@@ -8,13 +8,14 @@ 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';
+import { VERSION } from '../version.js';
 
 const cwd = process.cwd();
 const config = loadConfig(cwd);
 
 const server = new McpServer({
   name: 'openairev',
-  version: '0.2.4',
+  version: VERSION,
 });
 
 server.tool(
@@ -52,6 +53,7 @@ server.tool(
       reviewerName,
       taskDescription: task_description,
       cwd,
+      stream: 'silent',
     });
 
     const session = createSession({ executor: execAgent, reviewer: reviewerName });
@@ -60,8 +62,16 @@ server.tool(
     session.status = 'completed';
     saveSession(session, cwd);
 
-    const text = review.executor_feedback || JSON.stringify(review.verdict || review, null, 2);
-    return { content: [{ type: 'text', text }] };
+    const parts = [];
+
+    if (review.progress?.length > 0) {
+      parts.push({ type: 'text', text: `Review progress:\n${review.progress.map(l => `  ${l}`).join('\n')}` });
+    }
+
+    const feedback = review.executor_feedback || JSON.stringify(review.verdict || review, null, 2);
+    parts.push({ type: 'text', text: feedback });
+
+    return { content: parts };
   }
 );
 

package/src/orchestrator/orchestrator.js

@@ -263,7 +263,7 @@ async function runReviewRound(reviewerName, config, content, { kind, chain, spec
     config, reviewerName, promptFile,
     taskDescription: chain.task?.user_request,
     specRef: specRef || chain.task?.spec_ref,
-    cwd, sessionId,
+    cwd, sessionId, stream: true,
   });
 }
 

package/src/review/review-runner.js

@@ -1,3 +1,5 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
 import { createAdapter } from '../agents/registry.js';
 import { stageInput, buildInputReference } from './input-stager.js';
 import { loadPromptFile } from './prompt-loader.js';
@@ -10,6 +12,7 @@ export async function runReview(content, {
   specRef,
   cwd = process.cwd(),
   sessionId = null,
+  stream = false,
 }) {
   const adapter = createAdapter(reviewerName, config, { cwd });
 
@@ -37,19 +40,37 @@ export async function runReview(content, {
     schemaFile,
     continueSession: !!sessionId,
     sessionName: sessionId ? undefined : `review-${Date.now()}`,
+    stream: stream ? { reviewerName, tty: stream === true } : false,
   });
 
   const verdict = extractVerdict(result);
   const executorFeedback = buildExecutorFeedback(verdict, cwd);
+  const rawOutput = result?.raw_output || result?.raw || '';
+
+  logReviewerOutput(rawOutput, reviewerName, cwd);
 
   return {
     reviewer: reviewerName,
     verdict,
     executor_feedback: executorFeedback,
+    reviewer_output: rawOutput,
+    progress: result?.progress || [],
     session_id: adapter.sessionName || adapter.sessionId,
   };
 }
 
+function logReviewerOutput(rawOutput, reviewerName, cwd) {
+  if (!rawOutput) return;
+  try {
+    const logDir = join(cwd, '.openairev', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    writeFileSync(join(logDir, `review-${reviewerName}-${ts}.log`), rawOutput);
+  } catch {
+    // non-critical, don't fail the review
+  }
+}
+
 function buildExecutorFeedback(verdict, cwd) {
   const feedbackPrompt = loadPromptFile('executor-feedback.md', cwd);
   if (!verdict) return null;

package/src/review/review-runner.test.js

@@ -1,5 +1,8 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { existsSync, readdirSync, readFileSync, mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
 
 // Test verdict extraction logic (mirrors the function in review-runner.js)
 
@@ -77,3 +80,42 @@ describe('verdict extraction', () => {
     assert.equal(verdict, null);
   });
 });
+
+describe('reviewer output logging', () => {
+  function logReviewerOutput(rawOutput, reviewerName, cwd) {
+    if (!rawOutput) return;
+    try {
+      const logDir = join(cwd, '.openairev', 'logs');
+      mkdirSync(logDir, { recursive: true });
+      const ts = new Date().toISOString().replace(/[:.]/g, '-');
+      writeFileSync(join(logDir, `review-${reviewerName}-${ts}.log`), rawOutput);
+    } catch {
+      // non-critical
+    }
+  }
+
+  it('writes reviewer output to log file', () => {
+    const tmp = mkdtempSync(join(tmpdir(), 'orev-log-'));
+    try {
+      logReviewerOutput('raw reviewer thinking here', 'codex', tmp);
+      const logDir = join(tmp, '.openairev', 'logs');
+      assert.ok(existsSync(logDir));
+      const files = readdirSync(logDir);
+      assert.equal(files.length, 1);
+      assert.ok(files[0].startsWith('review-codex-'));
+      assert.equal(readFileSync(join(logDir, files[0]), 'utf-8'), 'raw reviewer thinking here');
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it('skips logging when output is empty', () => {
+    const tmp = mkdtempSync(join(tmpdir(), 'orev-log-'));
+    try {
+      logReviewerOutput('', 'codex', tmp);
+      assert.ok(!existsSync(join(tmp, '.openairev', 'logs')));
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/src/tools/git-tools.js

@@ -18,7 +18,7 @@ const EXCLUDE_PATTERNS = [
  * Uses minimal context (1 line) and excludes irrelevant files.
  */
 export function getDiff(ref, { context = 1, excludes = EXCLUDE_PATTERNS } = {}) {
-  const excludeArgs = excludes.flatMap(p => ['--', `:!${p}`]);
+  const excludeArgs = ['--', ...excludes.map(p => `:!${p}`)];
   const contextArgs = [`-U${context}`];
 
   if (ref) {

package/src/version.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+export const VERSION = pkg.version;