openairev 0.2.0

package/src/orchestrator/orchestrator.js

@@ -0,0 +1,344 @@
+import { createAdapter } from '../agents/registry.js';
+import { runReview } from '../review/review-runner.js';
+import { loadPromptFile } from '../review/prompt-loader.js';
+import { getDiff } from '../tools/git-tools.js';
+import { runToolGates } from '../tools/tool-runner.js';
+import {
+  createChain, transitionTo, addRound, setArtifact,
+  setExecutorSession, getExecutorSession, getReviewerSession,
+  setPhases, closeChain, advancePhase, getCurrentPhase,
+  addQuestion,
+} from '../session/chain-manager.js';
+
+export async function runWorkflow({
+  config,
+  executor,
+  reviewerName,
+  maxRounds,
+  diff: initialDiff,
+  diffRef,
+  taskDescription,
+  specRef,
+  tools,
+  cwd = process.cwd(),
+  existingChain = null,
+  skipAnalyze = false,
+  skipPlan = false,
+  onStageChange,
+  onRoundEnd,
+}) {
+  const chain = existingChain || createChain({
+    executor,
+    reviewer: reviewerName,
+    topic: taskDescription,
+    maxRounds,
+    specRef,
+    cwd,
+  });
+
+  if (!existingChain) {
+    if (skipAnalyze && skipPlan) {
+      transitionTo(chain, 'implementation', cwd);
+    } else if (skipAnalyze) {
+      transitionTo(chain, 'planning', cwd);
+    }
+  }
+
+  let currentDiff = initialDiff;
+  let codeReviewCount = 0;
+  let planReviewCount = 0;
+
+  while (chain.status === 'active' || chain.stage === 'done') {
+    if (onStageChange) onStageChange(chain.stage, chain);
+
+    switch (chain.stage) {
+      case 'analyze': {
+        const prompt = buildAnalysisPrompt(chain, specRef);
+        const result = await runExecutor(executor, config, prompt, chain, cwd);
+        const output = result.output || '';
+
+        setArtifact(chain, 'analysis', output || 'Analysis complete', cwd);
+
+        const questions = extractQuestions(output);
+        if (questions.length > 0) {
+          for (const q of questions) addQuestion(chain, q, cwd);
+          transitionTo(chain, 'awaiting_user', cwd);
+        } else if (skipPlan) {
+          transitionTo(chain, 'implementation', cwd);
+        } else {
+          transitionTo(chain, 'planning', cwd);
+        }
+        break;
+      }
+
+      case 'awaiting_user':
+        return { chain, status: 'blocked', stage: 'awaiting_user' };
+
+      case 'planning': {
+        const prompt = buildPlanPrompt(chain, specRef);
+        const result = await runExecutor(executor, config, prompt, chain, cwd);
+        const output = result.output || '';
+
+        setArtifact(chain, 'plan', output || 'Plan created', cwd);
+
+        const phases = extractPhases(output);
+        if (phases.length > 0) setPhases(chain, phases, cwd);
+
+        transitionTo(chain, 'plan_review', cwd);
+        break;
+      }
+
+      case 'plan_review': {
+        planReviewCount++;
+        if (planReviewCount > maxRounds) {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: 'Plan review exceeded max rounds' };
+        }
+
+        const review = await runReviewRound(reviewerName, config, chain.artifacts.plan || '', {
+          kind: 'plan_review', chain, cwd,
+        });
+
+        addRound(chain, { kind: 'plan_review', review, cwd });
+
+        if (!review.verdict) {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: 'Plan reviewer did not return a verdict' };
+        }
+
+        if (onRoundEnd) onRoundEnd(chain.stage, review);
+
+        if (review.verdict.status === 'approved') {
+          transitionTo(chain, 'implementation', cwd);
+        } else if (review.verdict.status === 'needs_changes') {
+          transitionTo(chain, 'plan_fix', cwd);
+        } else {
+          closeChain(chain, 'rejected', cwd);
+          return { chain, status: 'rejected', message: 'Plan rejected', verdict: review.verdict };
+        }
+        break;
+      }
+
+      case 'plan_fix': {
+        const lastVerdict = chain.rounds[chain.rounds.length - 1]?.review?.verdict;
+        const feedback = buildFeedback(lastVerdict, cwd);
+        const result = await runExecutor(executor, config, feedback, chain, cwd);
+
+        setArtifact(chain, 'plan', result.output || chain.artifacts.plan, cwd);
+
+        const phases = extractPhases(result.output || '');
+        if (phases.length > 0) setPhases(chain, phases, cwd);
+
+        transitionTo(chain, 'plan_review', cwd);
+        break;
+      }
+
+      case 'implementation': {
+        const phase = getCurrentPhase(chain);
+        if (phase) phase.status = 'in_progress';
+
+        const prompt = buildImplementationPrompt(chain, specRef);
+        await runExecutor(executor, config, prompt, chain, cwd);
+
+        try {
+          currentDiff = getDiff(diffRef);
+        } catch {
+          currentDiff = '';
+        }
+
+        if (currentDiff?.trim()) {
+          setArtifact(chain, 'current_diff_ref', diffRef || 'auto', cwd);
+          transitionTo(chain, 'code_review', cwd);
+        } else {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: 'No changes after implementation' };
+        }
+        break;
+      }
+
+      case 'code_review': {
+        codeReviewCount++;
+        if (codeReviewCount > maxRounds) {
+          closeChain(chain, 'max_rounds_reached', cwd);
+          return { chain, status: 'max_rounds_reached', rounds: codeReviewCount, verdict: getLastVerdict(chain) };
+        }
+
+        let toolResults = null;
+        if (tools && typeof tools === 'object' && Object.keys(tools).length > 0) {
+          toolResults = runToolGates(Object.keys(tools), cwd, tools);
+        }
+
+        const review = await runReviewRound(reviewerName, config, currentDiff, {
+          kind: 'code_review', chain, specRef, cwd,
+        });
+
+        const phaseId = getCurrentPhase(chain)?.id;
+        addRound(chain, { kind: 'code_review', review, toolResults, phaseId, cwd });
+
+        if (!review.verdict) {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: 'Code reviewer did not return a verdict' };
+        }
+
+        if (onRoundEnd) onRoundEnd(chain.stage, review, toolResults);
+
+        if (review.verdict.status === 'approved') {
+          const hasMore = advancePhase(chain, cwd);
+          if (hasMore) {
+            transitionTo(chain, 'implementation', cwd);
+          } else {
+            // Set stage directly so the done case can execute before status flips
+            chain.stage = 'done';
+            chain.updated = new Date().toISOString();
+          }
+        } else if (review.verdict.status === 'needs_changes') {
+          transitionTo(chain, 'code_fix', cwd);
+        } else {
+          closeChain(chain, 'rejected', cwd);
+          return { chain, status: 'rejected', rounds: codeReviewCount, verdict: review.verdict };
+        }
+        break;
+      }
+
+      case 'code_fix': {
+        const lastVerdict = chain.rounds[chain.rounds.length - 1]?.review?.verdict;
+        const feedback = buildFeedback(lastVerdict, cwd);
+        await runExecutor(executor, config, feedback, chain, cwd);
+
+        try {
+          currentDiff = getDiff(diffRef);
+        } catch (e) {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: `Failed to get diff: ${e.message}` };
+        }
+
+        if (!currentDiff?.trim()) {
+          closeChain(chain, 'error', cwd);
+          return { chain, status: 'error', message: 'No changes after fix attempt' };
+        }
+
+        transitionTo(chain, 'code_review', cwd);
+        break;
+      }
+
+      case 'done': {
+        closeChain(chain, 'completed', cwd);
+        return { chain, status: 'completed', rounds: codeReviewCount, verdict: getLastVerdict(chain) };
+      }
+
+      default: {
+        closeChain(chain, 'error', cwd);
+        return { chain, status: 'error', message: `Unknown stage: ${chain.stage}` };
+      }
+    }
+  }
+
+  return { chain, status: chain.status, stage: chain.stage };
+}
+
+// --- Helpers ---
+
+async function runExecutor(executor, config, prompt, chain, cwd) {
+  const adapter = createAdapter(executor, config, { cwd });
+
+  const existingSession = getExecutorSession(chain, chain.stage);
+  if (existingSession) adapter.restoreSession(existingSession);
+
+  const result = await adapter.run(prompt, {
+    continueSession: !!existingSession,
+    sessionName: existingSession ? undefined : `${chain.chain_id}-${chain.stage}`,
+  });
+
+  const sessionId = adapter.sessionName || adapter.sessionId || result?.session_id;
+  if (sessionId) setExecutorSession(chain, sessionId, chain.stage, cwd);
+
+  return { output: result?.result || result?.raw || null, session_id: sessionId };
+}
+
+async function runReviewRound(reviewerName, config, content, { kind, chain, specRef, cwd }) {
+  const promptFile = kind === 'plan_review' ? 'plan-reviewer.md' : 'reviewer.md';
+  const sessionId = getReviewerSession(chain, kind);
+
+  return runReview(content, {
+    config, reviewerName, promptFile,
+    taskDescription: chain.task?.user_request,
+    specRef: specRef || chain.task?.spec_ref,
+    cwd, sessionId,
+  });
+}
+
+function buildFeedback(verdict, cwd) {
+  const feedbackPrompt = loadPromptFile('executor-feedback.md', cwd) ||
+    'The following is feedback from an independent AI reviewer. Use your judgment.';
+
+  if (!verdict) return feedbackPrompt;
+  return `${feedbackPrompt}\n\n\`\`\`json\n${JSON.stringify(verdict, null, 2)}\n\`\`\`\n\nPlease fix the issues identified above. Edit the files directly.`;
+}
+
+function buildAnalysisPrompt(chain, specRef) {
+  let prompt = `Analyze the codebase for the following task: ${chain.task?.user_request || 'unknown task'}\n\n`;
+  prompt += 'Identify relevant files, dependencies, and potential challenges.\n';
+  prompt += 'If you need clarification from the user, list your questions as lines starting with "QUESTION: ".\n';
+  prompt += 'Be concise.';
+  if (specRef) prompt += `\n\nThe spec for this task is at: ${specRef}\nRead it for requirements and acceptance criteria.`;
+  return prompt;
+}
+
+function buildPlanPrompt(chain, specRef) {
+  let prompt = `Create an implementation plan for: ${chain.task?.user_request || 'unknown task'}\n\n`;
+  if (chain.artifacts.analysis) prompt += `Analysis:\n${chain.artifacts.analysis}\n\n`;
+
+  const answered = chain.questions?.filter(q => q.status === 'answered') || [];
+  if (answered.length > 0) {
+    prompt += 'Clarifications from user:\n';
+    for (const q of answered) prompt += `Q: ${q.question}\nA: ${q.answer}\n`;
+    prompt += '\n';
+  }
+
+  prompt += 'Break the work into phases. For each phase, use this format:\nPHASE: <name>\nGOAL: <goal>\n\n';
+  prompt += 'If the task is simple enough for one phase, that is fine.';
+  if (specRef) prompt += `\n\nThe spec for this task is at: ${specRef}\nEnsure the plan covers all requirements and scenarios.`;
+  return prompt;
+}
+
+function buildImplementationPrompt(chain, specRef) {
+  const phase = getCurrentPhase(chain);
+  let prompt = phase
+    ? `Implement phase: ${phase.name}\nGoal: ${phase.goal || phase.name}\n\n`
+    : `Implement: ${chain.task?.user_request || 'the task'}\n\n`;
+
+  if (chain.artifacts.plan) prompt += `Plan:\n${chain.artifacts.plan}\n\n`;
+  prompt += 'Write the code. Edit files directly.';
+  if (specRef) prompt += `\n\nThe spec is at: ${specRef}\nEnsure the implementation satisfies the spec scenarios.`;
+  return prompt;
+}
+
+function extractQuestions(output) {
+  if (!output || typeof output !== 'string') return [];
+  return output.split('\n')
+    .filter(line => line.trim().startsWith('QUESTION:'))
+    .map(line => line.trim().replace(/^QUESTION:\s*/, ''));
+}
+
+function extractPhases(output) {
+  if (!output || typeof output !== 'string') return [];
+  const phases = [];
+  const lines = output.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith('PHASE:')) {
+      const name = line.replace(/^PHASE:\s*/, '').trim();
+      let goal = name;
+      if (i + 1 < lines.length && lines[i + 1].trim().startsWith('GOAL:')) {
+        goal = lines[i + 1].trim().replace(/^GOAL:\s*/, '').trim();
+      }
+      phases.push({ name, goal });
+    }
+  }
+  return phases;
+}
+
+function getLastVerdict(chain) {
+  if (chain.rounds.length === 0) return null;
+  return chain.rounds[chain.rounds.length - 1].review?.verdict || null;
+}

package/src/review/input-stager.js

@@ -0,0 +1,35 @@
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const INLINE_THRESHOLD = 8_000; // characters — inline if under this
+
+/**
+ * Stage review input. For small content, returns it inline.
+ * For large content, writes to .openairev/tmp/ and returns a file reference.
+ */
+export function stageInput(content, { cwd = process.cwd(), label = 'review-input' } = {}) {
+  if (content.length <= INLINE_THRESHOLD) {
+    return { mode: 'inline', content };
+  }
+
+  const tmpDir = join(cwd, '.openairev', 'tmp');
+  mkdirSync(tmpDir, { recursive: true });
+
+  const filename = `${label}-${Date.now()}.diff`;
+  const filePath = join(tmpDir, filename);
+  const relativePath = `.openairev/tmp/${filename}`;
+
+  writeFileSync(filePath, content);
+
+  return { mode: 'file', filePath, relativePath };
+}
+
+/**
+ * Build the prompt prefix for the first pass based on staging result.
+ */
+export function buildInputReference(staged) {
+  if (staged.mode === 'inline') {
+    return `\n\n--- DIFF ---\n${staged.content}`;
+  }
+  return `\n\nThe diff to review is stored at: ${staged.relativePath}\nRead that file to see the full changes. It is too large to include inline.`;
+}

package/src/review/input-stager.test.js

@@ -0,0 +1,53 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { stageInput, buildInputReference } from './input-stager.js';
+
+const TMP = join(process.cwd(), '.test-tmp-stager');
+
+describe('input-stager', () => {
+  beforeEach(() => {
+    mkdirSync(TMP, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TMP, { recursive: true, force: true });
+  });
+
+  it('inlines small content', () => {
+    const result = stageInput('small diff', { cwd: TMP });
+    assert.equal(result.mode, 'inline');
+    assert.equal(result.content, 'small diff');
+  });
+
+  it('writes large content to file', () => {
+    const large = 'x'.repeat(10_000);
+    const result = stageInput(large, { cwd: TMP });
+    assert.equal(result.mode, 'file');
+    assert.ok(result.filePath);
+    assert.ok(result.relativePath.startsWith('.openairev/tmp/'));
+    assert.ok(existsSync(result.filePath));
+    assert.equal(readFileSync(result.filePath, 'utf-8'), large);
+  });
+
+  it('buildInputReference returns inline content for small input', () => {
+    const staged = { mode: 'inline', content: 'diff here' };
+    const ref = buildInputReference(staged);
+    assert.ok(ref.includes('diff here'));
+    assert.ok(ref.includes('--- DIFF ---'));
+  });
+
+  it('buildInputReference returns file path for large input', () => {
+    const staged = { mode: 'file', relativePath: '.openairev/tmp/test.diff' };
+    const ref = buildInputReference(staged);
+    assert.ok(ref.includes('.openairev/tmp/test.diff'));
+    assert.ok(ref.includes('Read that file'));
+  });
+
+  it('uses custom label for filename', () => {
+    const large = 'y'.repeat(10_000);
+    const result = stageInput(large, { cwd: TMP, label: 'my-review' });
+    assert.ok(result.relativePath.includes('my-review'));
+  });
+});

package/src/review/prompt-loader.js

@@ -0,0 +1,29 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const cache = new Map();
+
+/**
+ * Load a prompt file with caching. Checks .openairev/prompts/ first, then builtin prompts/.
+ */
+export function loadPromptFile(filename, cwd) {
+  const key = `${cwd}:${filename}`;
+  if (cache.has(key)) return cache.get(key);
+
+  const userPath = join(cwd, '.openairev', 'prompts', filename);
+  const builtinPath = join(cwd, 'prompts', filename);
+
+  let content = '';
+  try {
+    content = readFileSync(userPath, 'utf-8').trim();
+  } catch {
+    try {
+      content = readFileSync(builtinPath, 'utf-8').trim();
+    } catch {
+      // No prompt file found
+    }
+  }
+
+  cache.set(key, content);
+  return content;
+}

package/src/review/review-runner.js

@@ -0,0 +1,82 @@
+import { createAdapter } from '../agents/registry.js';
+import { stageInput, buildInputReference } from './input-stager.js';
+import { loadPromptFile } from './prompt-loader.js';
+
+export async function runReview(content, {
+  config,
+  reviewerName,
+  promptFile = 'reviewer.md',
+  taskDescription,
+  specRef,
+  cwd = process.cwd(),
+  sessionId = null,
+}) {
+  const adapter = createAdapter(reviewerName, config, { cwd });
+
+  if (sessionId) {
+    adapter.restoreSession(sessionId);
+  }
+
+  const reviewerPrompt = loadPromptFile(promptFile, cwd);
+  const staged = stageInput(content, { cwd });
+  const inputRef = buildInputReference(staged);
+
+  let prompt = reviewerPrompt;
+  if (taskDescription) {
+    prompt = `Task: ${taskDescription}\n\n${prompt}`;
+  }
+  if (specRef) {
+    prompt += `\n\nSpec reference: ${specRef}\nRead the spec file for requirements and acceptance criteria.`;
+  }
+  prompt = `${prompt}${inputRef}`;
+
+  const schemaFile = promptFile === 'plan-reviewer.md' ? 'plan-verdict-schema.json' : 'verdict-schema.json';
+
+  const result = await adapter.run(prompt, {
+    useSchema: true,
+    schemaFile,
+    continueSession: !!sessionId,
+    sessionName: sessionId ? undefined : `review-${Date.now()}`,
+  });
+
+  const verdict = extractVerdict(result);
+  const executorFeedback = buildExecutorFeedback(verdict, cwd);
+
+  return {
+    reviewer: reviewerName,
+    verdict,
+    executor_feedback: executorFeedback,
+    session_id: adapter.sessionName || adapter.sessionId,
+  };
+}
+
+function buildExecutorFeedback(verdict, cwd) {
+  const feedbackPrompt = loadPromptFile('executor-feedback.md', cwd);
+  if (!verdict) return null;
+  return `${feedbackPrompt}\n\`\`\`json\n${JSON.stringify(verdict, null, 2)}\n\`\`\``;
+}
+
+function extractVerdict(result) {
+  if (!result) return null;
+
+  if (result.structured_output) return result.structured_output;
+  if (result.result && typeof result.result === 'object' && result.result.status) return result.result;
+
+  if (result.status && ['approved', 'needs_changes', 'reject'].includes(result.status)) {
+    return result;
+  }
+
+  const raw = result.result || result.raw || '';
+  if (typeof raw === 'string') {
+    const jsonMatch = raw.match(/\{[\s\S]*"status"\s*:\s*"(approved|needs_changes|reject)"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[0]);
+      } catch {
+        // fall through
+      }
+    }
+  }
+
+  return null;
+}

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

@@ -0,0 +1,79 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Test verdict extraction logic (mirrors the function in review-runner.js)
+
+describe('verdict extraction', () => {
+  function extractVerdict(result) {
+    if (!result) return null;
+
+    if (result.structured_output) return result.structured_output;
+    if (result.result && typeof result.result === 'object' && result.result.status) return result.result;
+
+    if (result.status && ['approved', 'needs_changes', 'reject'].includes(result.status)) {
+      return result;
+    }
+
+    const raw = result.result || result.raw || '';
+    if (typeof raw === 'string') {
+      const jsonMatch = raw.match(/\{[\s\S]*"status"\s*:\s*"(approved|needs_changes|reject)"[\s\S]*\}/);
+      if (jsonMatch) {
+        try {
+          return JSON.parse(jsonMatch[0]);
+        } catch {
+          // fall through
+        }
+      }
+    }
+
+    return null;
+  }
+
+  it('extracts from structured_output (claude --json-schema)', () => {
+    const verdict = extractVerdict({
+      structured_output: { status: 'approved', confidence: 0.95, critical_issues: [], risk_level: 'low' },
+      result: 'some text',
+      session_id: 'abc',
+    });
+    assert.equal(verdict.status, 'approved');
+    assert.equal(verdict.confidence, 0.95);
+  });
+
+  it('extracts from nested result object (codex)', () => {
+    const verdict = extractVerdict({
+      result: { status: 'needs_changes', confidence: 0.7, critical_issues: ['bug'], risk_level: 'high' },
+      session_id: 'def',
+    });
+    assert.equal(verdict.status, 'needs_changes');
+    assert.equal(verdict.critical_issues[0], 'bug');
+  });
+
+  it('extracts direct verdict object', () => {
+    const verdict = extractVerdict(
+      { status: 'reject', confidence: 0.3, critical_issues: [], risk_level: 'high' },
+    );
+    assert.equal(verdict.status, 'reject');
+  });
+
+  it('extracts from raw text containing JSON', () => {
+    const verdict = extractVerdict({
+      raw: 'Here is my verdict:\n{"status": "approved", "critical_issues": [], "risk_level": "low", "confidence": 0.9}\nDone.',
+    });
+    assert.equal(verdict.status, 'approved');
+  });
+
+  it('returns null for missing result', () => {
+    assert.equal(extractVerdict(null), null);
+    assert.equal(extractVerdict(undefined), null);
+  });
+
+  it('returns null for unrecognized format', () => {
+    const verdict = extractVerdict({ raw: 'no json here at all' });
+    assert.equal(verdict, null);
+  });
+
+  it('returns null for invalid status in raw JSON', () => {
+    const verdict = extractVerdict({ raw: '{"status": "unknown_status"}' });
+    assert.equal(verdict, null);
+  });
+});