openairev 0.2.4 → 0.3.0

package/bin/openairev.js

@@ -12,7 +12,7 @@ const program = new Command();
 program
   .name('openairev')
   .description('OpenAIRev — cross-model AI code reviewer')
-  .version('0.2.4');
+  .version('0.3.0');
 
 program
   .command('init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openairev",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "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,8 @@ export class CodexAdapter {
       args.push('--output-schema', schemaPath);
     }
 
-    const result = await exec(this.cmd, args);
+    const onData = stream ? createCodexSummarizer({ reviewerName: typeof stream === 'string' ? stream : 'codex' }) : undefined;
+    const result = await exec(this.cmd, args, { onData });
 
     try {
       const lines = result.stdout.trim().split('\n');
@@ -62,15 +64,15 @@ export class CodexAdapter {
 
       if (agentMessage) {
         try {
-          return { result: JSON.parse(agentMessage), session_id: this.sessionId };
+          return { result: JSON.parse(agentMessage), raw_output: result.stdout, session_id: this.sessionId };
         } catch {
-          return { result: agentMessage, session_id: this.sessionId };
+          return { result: agentMessage, raw_output: result.stdout, session_id: this.sessionId };
         }
       }
 
-      return { raw: result.stdout, session_id: this.sessionId };
+      return { raw: result.stdout, raw_output: result.stdout, 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,124 @@
+import chalk from 'chalk';
+
+/**
+ * Creates a summarizer callback for Codex NDJSON event streams.
+ * Prints concise progress lines to stderr instead of raw JSON.
+ */
+export function createCodexSummarizer({ reviewerName } = {}) {
+  const seenFiles = new Set();
+  let buffer = '';
+  let started = false;
+
+  return (chunk) => {
+    if (!started) {
+      started = true;
+      if (reviewerName) log(chalk.cyan(`  reviewer: ${reviewerName}`));
+    }
+    buffer += chunk;
+    const lines = buffer.split('\n');
+    buffer = lines.pop(); // keep incomplete last line
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        summarizeCodexEvent(event, seenFiles);
+      } catch {
+        // skip non-JSON
+      }
+    }
+  };
+}
+
+function summarizeCodexEvent(event, seenFiles) {
+  const type = event.type;
+
+  if (type === 'thread.started') {
+    log(chalk.dim(`  session: ${event.thread_id}`));
+  }
+
+  if (type === 'item.started' && event.item?.type === 'todo_list') {
+    const items = event.item.items?.map(i => i.text) || [];
+    log(chalk.cyan('  plan:'));
+    for (const item of items) log(chalk.dim(`    • ${item}`));
+  }
+
+  if (type === 'item.completed' && event.item?.type === 'todo_list') {
+    const items = event.item.items || [];
+    const done = items.filter(i => i.completed).length;
+    log(chalk.dim(`  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);
+      log(chalk.dim(`  reading: ${file}`));
+    } else if (!file) {
+      const short = summarizeCmd(cmd);
+      if (short) log(chalk.dim(`  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 || '');
+      log(chalk.yellow(`  command failed (exit ${exit}): ${cmd}`));
+    }
+  }
+
+  if (type === 'item.started' && event.item?.type === 'agent_message') {
+    log(chalk.cyan('  generating verdict...'));
+  }
+
+  if (type === 'item.completed' && event.item?.type === 'agent_message') {
+    log(chalk.green('  verdict ready'));
+  }
+
+  if (type === 'turn.completed' && event.usage) {
+    const { input_tokens, output_tokens } = event.usage;
+    const total = input_tokens + output_tokens;
+    log(chalk.dim(`  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';
+    log(chalk.red(`  error: ${msg}`));
+  }
+}
+
+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);
+}
+
+function log(msg) {
+  process.stderr.write(msg + '\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

@@ -14,7 +14,7 @@ const config = loadConfig(cwd);
 
 const server = new McpServer({
   name: 'openairev',
-  version: '0.2.4',
+  version: '0.3.0',
 });
 
 server.tool(

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,36 @@ export async function runReview(content, {
     schemaFile,
     continueSession: !!sessionId,
     sessionName: sessionId ? undefined : `review-${Date.now()}`,
+    stream: stream ? reviewerName : 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,
     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) {