cc-pipeline 0.5.2 → 0.6.0

package/bin/cc-pipeline.js

@@ -1,8 +1,18 @@
 #!/usr/bin/env node
+// Register tsx as an in-process ESM loader, then import and run the TypeScript CLI
+// directly in this process. This keeps everything single-process so signal handlers
+// registered by the engine work correctly (no subprocess forwarding needed).
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 
-import { run } from '../src/cli.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
-run(process.argv.slice(2)).catch(err => {
-  console.error(err.message);
-  process.exit(1);
-});
+// Load tsx's programmatic ESM registration API
+const { register } = await import(
+  join(__dirname, '../node_modules/tsx/dist/esm/api/index.mjs')
+);
+register();
+
+// Now TypeScript imports resolve correctly in this process
+const { run } = await import('../src/cli.ts');
+await run(process.argv.slice(2));

package/package.json

@@ -1,13 +1,20 @@
 {
   "name": "cc-pipeline",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Autonomous Claude Code pipeline engine. Install into any repo, write a BRIEF.md, and let Claude build your project phase by phase.",
   "type": "module",
   "bin": {
     "cc-pipeline": "bin/cc-pipeline.js"
   },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ],
   "scripts": {
-    "test": "node --test src/**/*.test.js"
+    "start": "tsx src/cli.ts",
+    "test": "node --import tsx/esm --test 'src/**/*.test.ts'",
+    "build": "tsc"
   },
   "repository": {
     "type": "git",
@@ -31,6 +38,16 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.50",
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "tsx": "^4.21.0",
     "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.9.3"
   }
 }

package/src/agents/{base.js → base.ts}

@@ -1,36 +1,65 @@
 import { EventEmitter } from 'node:events';
 
+export interface AgentContext {
+  projectDir: string;
+  config: any;
+  logFile: string | null;
+}
+
+export interface AgentResult {
+  exitCode: number;
+  outputPath: string | null;
+  error?: string;
+  usage?: { costUSD: number };
+}
+
+export interface StepDef {
+  name: string;
+  agent: string;
+  prompt?: string;
+  model?: string;
+  command?: string;
+  skipUnless?: string;
+  output?: string;
+  testGate?: boolean;
+  description?: string;
+  continueOnError?: boolean;
+}
+
 /**
  * Shared state for tracking the current child process
  * The engine signal handler needs access to this to kill the process on Ctrl-C
  */
 class AgentState extends EventEmitter {
+  currentChild: any;
+  interrupted: boolean;
+
   constructor() {
     super();
     this.currentChild = null;
     this.interrupted = false;
   }
 
-  setChild(child) {
+  setChild(child: any): void {
     this.currentChild = child;
   }
 
-  getChild() {
+  getChild(): any {
     return this.currentChild;
   }
 
-  clearChild() {
+  clearChild(): void {
     this.currentChild = null;
   }
 
-  setInterrupted(value) {
+  setInterrupted(value: boolean): void {
     this.interrupted = value;
     if (value) {
       this.emit('interrupt');
     }
   }
 
-  isInterrupted() {
+  isInterrupted(): boolean {
     return this.interrupted;
   }
 }
@@ -41,16 +70,9 @@ export const agentState = new AgentState();
 /**
  * Base interface for all agents.
  * All agents must implement the run() method with this signature.
- *
- * @param {number} phase - Current phase number
- * @param {object} step - Step definition from workflow.yaml
- * @param {string} promptPath - Relative path to prompt file (for claude agents)
- * @param {string} model - Model name to use
- * @param {object} context - { projectDir, config, logFile }
- * @returns {Promise<{exitCode: number, outputPath: string|null}>}
  */
 export class BaseAgent {
-  async run(phase, step, promptPath, model, context) {
+  async run(phase: number, step: StepDef, promptPath: string | null, model: string, context: AgentContext): Promise<AgentResult> {
     throw new Error('Agent must implement run() method');
   }
 }

package/src/agents/bash.ts

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { BaseAgent, agentState, AgentContext, AgentResult, StepDef } from './base.js';
+
+/**
+ * Bash agent - executes shell commands
+ * Ports run_bash from run.sh: substitute {{PHASE}} and execute via spawn
+ */
+export class BashAgent extends BaseAgent {
+  async run(phase: number, step: StepDef, promptPath: string | null, model: string, context: AgentContext): Promise<AgentResult> {
+    const { command } = step;
+
+    if (!command) {
+      throw new Error('Bash agent requires a command in step definition');
+    }
+
+    // Substitute {{PHASE}} placeholder
+    const cmd = command.replace(/\{\{PHASE\}\}/g, phase.toString());
+
+    console.log(`  Executing: ${cmd}`);
+
+    const outputPath = join(context.projectDir, '.pipeline', 'step-output.log');
+    writeFileSync(outputPath, `$ ${cmd}\n`, 'utf-8');
+
+    return new Promise((resolve) => {
+      // Pipe stdout/stderr so output is captured for TUI and not swallowed
+      const child = spawn(cmd, {
+        shell: true,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        cwd: context.projectDir
+      });
+
+      // Track child process for signal handling
+      agentState.setChild(child);
+
+      const onData = (chunk: Buffer) => {
+        try { appendFileSync(outputPath, chunk.toString(), 'utf-8'); } catch (_) {}
+      };
+
+      child.stdout?.on('data', onData);
+      child.stderr?.on('data', onData);
+
+      child.on('close', (code) => {
+        agentState.clearChild();
+        resolve({
+          exitCode: code ?? 1,
+          outputPath
+        });
+      });
+
+      child.on('error', (err) => {
+        agentState.clearChild();
+        const msg = `Bash agent error: ${err.message}\n`;
+        try { appendFileSync(outputPath, msg, 'utf-8'); } catch (_) {}
+        resolve({
+          exitCode: 1,
+          outputPath
+        });
+      });
+    });
+  }
+}

package/src/agents/claudecode.ts

@@ -0,0 +1,142 @@
+import { writeFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { BaseAgent, agentState, AgentContext, AgentResult, StepDef } from './base.js';
+import { generatePrompt } from '../prompts.js';
+import { pipelineEvents } from '../events.js';
+
+/**
+ * ClaudeCode Agent
+ * Runs all AI pipeline steps via the Agent SDK query() API.
+ * Handles spec/research/plan/review/reflect (text streaming) and
+ * build/fix (tool-heavy) steps with the same implementation.
+ */
+export class ClaudeCodeAgent extends BaseAgent {
+  async run(phase: number, step: StepDef, promptPath: string | null, model: string, context: AgentContext): Promise<AgentResult> {
+    const { projectDir, config, logFile } = context;
+    const pipelineDir = join(projectDir, '.pipeline');
+    const outputPath = join(pipelineDir, 'step-output.log');
+
+    const promptText = generatePrompt(projectDir, config, phase, promptPath);
+    writeFileSync(join(pipelineDir, 'current-prompt.md'), promptText, 'utf-8');
+
+    if (agentState.interrupted) {
+      return { exitCode: 130, outputPath };
+    }
+
+    const controller = new AbortController();
+    const onInterrupt = () => controller.abort();
+    agentState.on('interrupt', onInterrupt);
+
+    // Clear output file so TUI file-tailer sees only this step's content
+    writeFileSync(outputPath, '', 'utf-8');
+
+    const logLine = (msg: string) => {
+      if (logFile) {
+        try { appendFileSync(logFile, msg + '\n', 'utf-8'); } catch (_) {}
+      }
+    };
+    const appendOutput = (line: string) => {
+      try { appendFileSync(outputPath, line + '\n', 'utf-8'); } catch (_) {}
+    };
+
+    const outputChunks: string[] = [];
+    let stepCostUSD = 0;
+
+    try {
+      const queryOptions: any = {
+        maxTurns: 500,
+        permissionMode: 'bypassPermissions',
+        // Unset CLAUDECODE to prevent SDK conflict when running inside Claude Code
+        env: { ...process.env, CLAUDECODE: undefined },
+        hooks: {
+          PreToolUse: [{ hooks: [async (data: any) => {
+            const line = `[tool:start] ${data.tool_name} ${JSON.stringify(data.tool_input ?? {}).slice(0, 120)}`;
+            logLine(line);
+            appendOutput(line);
+          }] }],
+          PostToolUse: [{ hooks: [async (data: any) => {
+            const success = !data.tool_response?.is_error;
+            const line = `[tool:done]  ${data.tool_name} ${success ? '✓' : '✗'}`;
+            logLine(line);
+            appendOutput(line);
+          }] }],
+          SubagentStart: [{ hooks: [async (data: any) => {
+            const line = `[subagent:start] ${data.agent_id ?? ''}`;
+            logLine(line);
+            appendOutput(line);
+          }] }],
+          SubagentStop: [{ hooks: [async (data: any) => {
+            const line = `[subagent:done]  ${data.agent_id ?? ''}`;
+            logLine(line);
+            appendOutput(line);
+          }] }],
+          Stop: [{ hooks: [async (_data: any) => {
+            logLine(`[session:stop]`);
+          }] }],
+        },
+      };
+
+      if (model && model !== 'default') {
+        queryOptions.model = model;
+      }
+
+      queryOptions.abortController = controller;
+      for await (const event of query({
+        prompt: promptText,
+        options: queryOptions,
+      })) {
+        if ((event as any).type === 'assistant' && (event as any).message?.role === 'assistant') {
+          for (const block of (event as any).message.content ?? []) {
+            if ((block as any).type === 'text') {
+              const text: string = (block as any).text;
+              outputChunks.push(text);
+              // Stream text lines to output file for TUI file-tailing
+              const textLines = text
+                .split('\n')
+                .map(l => l.trim())
+                .filter(l => l.length > 0)
+                .map(l => '[text] ' + l)
+                .join('\n');
+              if (textLines) appendOutput(textLines);
+              pipelineEvents.emit('text:chunk', { phase, step: step.name, text });
+            }
+          }
+        }
+        if ((event as any).type === 'result') {
+          stepCostUSD = (event as any).total_cost_usd ?? 0;
+          const reason = (event as any).stop_reason ?? 'end_turn';
+          pipelineEvents.emit('session:stop', { phase, step: step.name, reason });
+        }
+      }
+    } catch (err: any) {
+      agentState.off('interrupt', onInterrupt);
+
+      if (agentState.interrupted || controller.signal.aborted) {
+        appendOutput(outputChunks.join('\n'));
+        return { exitCode: 130, outputPath };
+      }
+
+      const errorText = `Error: ${err.message}\n${err.stack ?? ''}`;
+      writeFileSync(outputPath, errorText, 'utf-8');
+      return { exitCode: 1, outputPath };
+    }
+
+    agentState.off('interrupt', onInterrupt);
+
+    // Write final collected output (for steps without streaming, e.g. build)
+    if (outputChunks.length > 0) {
+      writeFileSync(outputPath, outputChunks.join('\n'), 'utf-8');
+    }
+
+    if (agentState.interrupted) {
+      return { exitCode: 130, outputPath };
+    }
+
+    return { exitCode: 0, outputPath, usage: { costUSD: stepCostUSD } };
+  }
+}
+
+export function createAgent(): ClaudeCodeAgent {
+  return new ClaudeCodeAgent();
+}

package/src/agents/codex.ts

@@ -0,0 +1,132 @@
+import { spawn, ChildProcess } from 'node:child_process';
+import { appendFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { BaseAgent, agentState, AgentContext, AgentResult, StepDef } from './base.js';
+import { generatePrompt } from '../prompts.js';
+
+const MAX_ATTEMPTS = 3;
+const INACTIVITY_MS = 5 * 60 * 1000; // 5 minutes
+const INACTIVITY_CHECK_MS = 30_000;   // poll every 30 s
+
+/**
+ * Codex agent — shells out to the `codex` CLI with --yolo.
+ * Always runs in auto-approval mode. Model can be set per-step or left to
+ * the codex CLI default.
+ *
+ * An inactivity timeout kills and retries the process if no output is seen
+ * for INACTIVITY_MS. After MAX_ATTEMPTS consecutive inactivity failures the
+ * step is marked as an error with all accumulated output preserved.
+ *
+ * Usage in workflow.yaml:
+ *   agent: codex
+ *   model: o4-mini   # optional — omit to use codex's default model
+ */
+export class CodexAgent extends BaseAgent {
+  async run(phase: number, step: StepDef, promptPath: string | null, model: string, context: AgentContext): Promise<AgentResult> {
+    const { projectDir } = context;
+    const pipelineDir = join(projectDir, '.pipeline');
+    const outputPath = join(pipelineDir, 'step-output.log');
+
+    const promptText = generatePrompt(projectDir, context.config, phase, promptPath);
+    writeFileSync(join(pipelineDir, 'current-prompt.md'), promptText, 'utf-8');
+    writeFileSync(outputPath, '', 'utf-8');
+
+    if (agentState.interrupted) {
+      return { exitCode: 130, outputPath };
+    }
+
+    const args = ['exec', '--yolo'];
+    if (model && model !== 'default') {
+      args.push('--model', model);
+    }
+    args.push(promptText);
+
+    const header = `$ codex exec --yolo${model && model !== 'default' ? ` --model ${model}` : ''} "<prompt>"\n`;
+    writeFileSync(outputPath, header, 'utf-8');
+
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      if (agentState.interrupted) {
+        return { exitCode: 130, outputPath };
+      }
+
+      if (attempt > 1) {
+        const sep = `\n--- codex: attempt ${attempt}/${MAX_ATTEMPTS} (previous attempt had no activity for ${INACTIVITY_MS / 60000} min) ---\n\n`;
+        try { appendFileSync(outputPath, sep, 'utf-8'); } catch (_) {}
+      }
+
+      const { exitCode, timedOut } = await this.spawnOnce(args, projectDir, outputPath);
+
+      if (!timedOut) {
+        // Normal exit (success or non-inactivity error) — return immediately.
+        return { exitCode, outputPath };
+      }
+
+      // Inactivity timeout — log and loop to next attempt.
+      const msg = `[codex: no output for ${INACTIVITY_MS / 60000} min — attempt ${attempt}/${MAX_ATTEMPTS} aborted]\n`;
+      try { appendFileSync(outputPath, msg, 'utf-8'); } catch (_) {}
+    }
+
+    // All attempts exhausted.
+    try {
+      appendFileSync(outputPath, `\n[codex: all ${MAX_ATTEMPTS} attempts timed out due to inactivity — giving up]\n`, 'utf-8');
+    } catch (_) {}
+    return { exitCode: 1, outputPath };
+  }
+
+  private spawnOnce(
+    args: string[],
+    projectDir: string,
+    outputPath: string,
+  ): Promise<{ exitCode: number; timedOut: boolean }> {
+    return new Promise((resolve) => {
+      let settled = false;
+      let lastActivity = Date.now();
+
+      const settle = (result: { exitCode: number; timedOut: boolean }) => {
+        if (settled) return;
+        settled = true;
+        clearInterval(inactivityTimer);
+        agentState.clearChild();
+        resolve(result);
+      };
+
+      const child: ChildProcess = spawn('codex', args, {
+        shell: false,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        cwd: projectDir,
+      });
+
+      agentState.setChild(child);
+
+      const onData = (chunk: Buffer) => {
+        lastActivity = Date.now();
+        try { appendFileSync(outputPath, chunk.toString(), 'utf-8'); } catch (_) {}
+      };
+
+      child.stdout?.on('data', onData);
+      child.stderr?.on('data', onData);
+
+      const inactivityTimer = setInterval(() => {
+        if (Date.now() - lastActivity < INACTIVITY_MS) return;
+        // No output for too long — kill the process.
+        try { process.kill(child.pid!, 'SIGTERM'); } catch (_) {}
+        setTimeout(() => {
+          try { process.kill(child.pid!, 'SIGKILL'); } catch (_) {}
+        }, 2000);
+        settle({ exitCode: 1, timedOut: true });
+      }, INACTIVITY_CHECK_MS);
+
+      child.on('close', (code) => settle({ exitCode: code ?? 1, timedOut: false }));
+
+      child.on('error', (err) => {
+        const msg = `Codex agent error: ${err.message}\n`;
+        try { appendFileSync(outputPath, msg, 'utf-8'); } catch (_) {}
+        settle({ exitCode: 1, timedOut: false });
+      });
+    });
+  }
+}
+
+export function createAgent(): CodexAgent {
+  return new CodexAgent();
+}