golem-cc 2.1.2 → 3.0.0

package/.golem/lib/build.mjs

@@ -0,0 +1,557 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { header, success, fail, warn, info, spinner, table } from './output.mjs';
+import { loadConfig } from './config.mjs';
+import { runClaude, checkClaudeCli } from './claude.mjs';
+import { attachDisplay } from './display.mjs';
+import { createTui } from './tui.mjs';
+import { getUsageData } from './usage.mjs';
+import { runGates } from './gates.mjs';
+import { runSecurityScan } from './security.mjs';
+import { fetchUsage, formatResetTime } from './ratelimit.mjs';
+import { runDocument } from './document.mjs';
+
+const PLAN_PATH = join(process.cwd(), '.golem/IMPLEMENTATION_PLAN.md');
+
+export function parseNextTask(planContent) {
+  const lines = planContent.split('\n');
+  let currentStage = '';
+  let stageCommit = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (/^## Stage \d+/.test(line)) {
+      currentStage = line.replace(/^## /, '');
+    }
+    if (/^Commit:/.test(line)) {
+      stageCommit = line.replace(/^Commit:\s*/, '');
+    }
+
+    const match = line.match(/^### \[ \] (\d+\.\d+)\.\s+(.*)/);
+    if (match) {
+      const taskId = match[1];
+      const taskTitle = match[2];
+
+      let details = '';
+      for (let j = i + 1; j < lines.length; j++) {
+        if (/^###\s|^##\s|^---/.test(lines[j])) break;
+        details += lines[j] + '\n';
+      }
+
+      const modelMatch = details.match(/^Model:\s*(\S+)/m);
+
+      return {
+        id: taskId,
+        title: taskTitle,
+        stage: currentStage,
+        commit: stageCommit,
+        details: details.trim(),
+        model: modelMatch ? modelMatch[1] : null,
+        lineIndex: i,
+      };
+    }
+  }
+  return null;
+}
+
+function countTasks(planContent) {
+  const total = (planContent.match(/^### \[[ x]\]/gm) || []).length;
+  const done = (planContent.match(/^### \[x\]/gm) || []).length;
+  return { total, done };
+}
+
+function markTaskComplete(planContent, lineIndex) {
+  const lines = planContent.split('\n');
+  lines[lineIndex] = lines[lineIndex].replace('### [ ]', '### [x]');
+  return lines.join('\n');
+}
+
+export async function buildPrompt(task, config, retryContext) {
+  let prompt;
+  try {
+    prompt = await readFile(join(process.cwd(), '.golem/prompts/build.md'), 'utf-8');
+  } catch {
+    prompt = 'You are an autonomous coding agent. Complete the task below.';
+  }
+
+  const taskBlock = `
+## Current Task: ${task.id}. ${task.title}
+
+Stage: ${task.stage}
+
+${task.details}
+`;
+
+  return `${prompt}\n${taskBlock}${retryContext
+    ? formatGateErrors(retryContext.gateResults, retryContext.attempt, retryContext.maxRetries)
+    : ''}`;
+}
+
+function formatGateErrors(gateResult, attempt, maxRetries) {
+  let ctx = `\n## Previous Attempt Failed (attempt ${attempt} of ${maxRetries})\n\nThe following quality gates failed:\n`;
+  for (const r of gateResult.results) {
+    if (r.skipped) continue;
+    if (!r.passed) {
+      ctx += `\n### ${r.name} (exit code ${r.exitCode})\n\`\`\`\n${r.output}\n\`\`\`\n`;
+    }
+  }
+  ctx += '\nFix the issues above and try again. Do not repeat the same mistakes.\n';
+  return ctx;
+}
+
+function logGateResults(tui, gateResults) {
+  const maxNameLen = Math.max(...gateResults.map(r => r.name.length));
+
+  for (const r of gateResults) {
+    const dots = '.'.repeat(Math.max(1, maxNameLen - r.name.length + 3));
+    const durationStr = chalk.dim(` (${(r.duration / 1000).toFixed(1)}s)`);
+    let status;
+    if (r.skipped) {
+      status = chalk.dim('skipped');
+    } else if (r.passed) {
+      status = chalk.green('PASS') + durationStr;
+    } else {
+      status = chalk.red('FAIL') + durationStr;
+    }
+    tui.appendLog(`${chalk.white('[Gate]')} ${r.name} ${chalk.dim(dots)} ${status}`);
+
+    if (!r.passed && !r.skipped && r.output) {
+      for (const line of r.output.split('\n').filter(l => l.trim()).slice(0, 5)) {
+        tui.appendLog(chalk.dim(`  ${line}`));
+      }
+    }
+  }
+}
+
+const SKIP_SIMPLIFY = [
+  /\.test\.\w+$/, /\.spec\.\w+$/, /\.config\.\w+$/, /\.d\.ts$/,
+  /lock\.\w+$/, /\.lock$/, /\.generated\./, /node_modules\//, /dist\//, /\.min\.\w+$/,
+  /^\.golem\//, /^\.claude\//,
+];
+
+function getChangedFiles() {
+  try {
+    return execSync('git diff --name-only HEAD', gitOpts())
+      .toString().trim().split('\n').filter(Boolean);
+  } catch {
+    return execSync('git status --porcelain', gitOpts())
+      .toString().trim().split('\n')
+      .map(l => l.slice(3).trim()).filter(Boolean);
+  }
+}
+
+async function runSimplifyPass(files, config, tui) {
+  const targets = files.filter(f => !SKIP_SIMPLIFY.some(p => p.test(f)));
+  if (targets.length === 0) return;
+
+  tui.appendLog(chalk.cyan(`[Simplify] ${targets.length} file(s)`));
+
+  let prompt;
+  try {
+    prompt = await readFile(join(process.cwd(), '.golem/prompts/simplify.md'), 'utf-8');
+  } catch {
+    prompt = 'Simplify the given files. Run tests after each change. Revert on failure.';
+  }
+
+  const fileList = targets.map(f => `- ${f}`).join('\n');
+  const fullPrompt = prompt.replace('{{FILES}}', fileList) + '\n\n## Test Command\n\n`node --test`\n';
+
+  const emitter = runClaude(fullPrompt, { model: 'sonnet' });
+  attachDisplay(emitter, { tui });
+
+  await new Promise((resolve) => {
+    emitter.on('close', resolve);
+    emitter.on('error', resolve);
+  });
+}
+
+async function runSecurityCheck(tui) {
+  tui.appendLog(chalk.cyan('[Security] Running scan...'));
+  const { verdict, findings } = await runSecurityScan();
+
+  const critical = findings.filter(f => f.severity === 'CRITICAL');
+  const high = findings.filter(f => f.severity === 'HIGH');
+
+  if (verdict === 'PASS') {
+    tui.appendLog(chalk.green('[Security] PASS — no issues'));
+  } else if (critical.length > 0 || high.length > 0) {
+    tui.appendLog(chalk.red(`[Security] FAIL — ${critical.length} critical, ${high.length} high`));
+    for (const f of [...critical, ...high].slice(0, 5)) {
+      tui.appendLog(chalk.dim(`  ${f.severity}: ${f.message.slice(0, 60)} (${f.file})`));
+    }
+  } else {
+    tui.appendLog(chalk.yellow(`[Security] PARTIAL — ${findings.length} finding(s), none critical`));
+  }
+
+  return { verdict, findings, critical, high };
+}
+
+function gitOpts() {
+  return { cwd: process.cwd(), stdio: 'pipe' };
+}
+
+export function gitSnapshot() {
+  return execSync('git rev-parse HEAD', gitOpts()).toString().trim();
+}
+
+export function gitRestore(sha) {
+  execSync('git checkout .', gitOpts());
+  execSync('git clean -fd', gitOpts());
+  execSync(`git reset --hard ${sha}`, gitOpts());
+}
+
+export function gitHasChanges() {
+  return execSync('git status --porcelain', gitOpts()).toString().length > 0;
+}
+
+function gitDiffStats() {
+  try {
+    const out = execSync('git diff --cached --stat', gitOpts()).toString();
+    const lines = out.trim().split('\n');
+    const summary = lines[lines.length - 1] || '';
+    const extract = (pattern) => {
+      const match = summary.match(pattern);
+      return match ? parseInt(match[1]) : 0;
+    };
+    return {
+      files: extract(/(\d+) files? changed/),
+      ins: extract(/(\d+) insertions?/),
+      del: extract(/(\d+) deletions?/),
+    };
+  } catch {
+    return { files: 0, ins: 0, del: 0 };
+  }
+}
+
+function gitCommit(message) {
+  try {
+    execSync('git add -A', gitOpts());
+    const stats = gitDiffStats();
+    execSync(`git commit -m "${message}"`, gitOpts());
+    const hash = execSync('git rev-parse --short HEAD', gitOpts()).toString().trim();
+    return { hash, ...stats };
+  } catch {
+    return null;
+  }
+}
+
+export async function runBuild(opts = {}) {
+  if (!checkClaudeCli()) {
+    fail('Claude CLI not found. Install it from https://docs.anthropic.com/en/docs/claude-code');
+    process.exit(1);
+  }
+
+  try {
+    const specsDir = join(process.cwd(), '.golem/specs');
+    const specs = (await readdir(specsDir)).filter(f => f.endsWith('.md'));
+    if (specs.length === 0) {
+      warn('No spec files found in .golem/specs/. Run /golem:spec first to create specs.');
+    }
+  } catch {
+    warn('No .golem/specs/ directory found. Run golem init first.');
+  }
+
+  const config = await loadConfig();
+  const maxRetries = opts.retry === false ? 1 : (opts.retries || config.maxRetries || 3);
+  const maxTasks = opts.tasks || Infinity;
+  let tasksProcessed = 0;
+  let claudeCalls = 0;
+  let stopping = false;
+  let buildSucceeded = false;
+  const summaryRows = [];
+  let tui = null;
+
+  const onSigint = () => {
+    if (stopping) {
+      if (tui) tui.destroy();
+      warn('Force quitting...');
+      process.exit(1);
+    }
+    stopping = true;
+    if (tui) {
+      tui.appendLog('\nStopping after current task... (Ctrl+C again to force quit)');
+    } else {
+      warn('Stopping after current task... (Ctrl+C again to force quit)');
+    }
+  };
+  process.on('SIGINT', onSigint);
+
+  if (opts.dryRun) {
+    header('Golem Build Loop');
+
+    let plan;
+    try {
+      plan = await readFile(PLAN_PATH, 'utf-8');
+    } catch {
+      fail('No implementation plan found. Run /golem:plan first.');
+      process.exit(1);
+    }
+
+    const { total, done } = countTasks(plan);
+    const task = parseNextTask(plan);
+
+    if (!task) {
+      success(`All ${total} tasks complete!`);
+      return;
+    }
+
+    header(`Task ${task.id}: ${task.title}`);
+    info(`Progress: ${done}/${total} tasks (${Math.round(done / total * 100)}%)`);
+    info('Dry run — showing next task:');
+    console.log();
+    console.log(task.details);
+    return;
+  }
+
+  let usageData;
+  try {
+    usageData = await getUsageData();
+  } catch {
+    usageData = null;
+  }
+
+  let plan;
+  try {
+    plan = await readFile(PLAN_PATH, 'utf-8');
+  } catch {
+    fail('No implementation plan found. Run /golem:plan first.');
+    process.exit(1);
+  }
+
+  const initialCounts = countTasks(plan);
+  const firstTask = parseNextTask(plan);
+
+  if (!firstTask) {
+    success(`All ${initialCounts.total} tasks complete!`);
+    return;
+  }
+
+  tui = createTui();
+  tui.init({
+    taskId: firstTask.id,
+    taskTitle: firstTask.title,
+    stage: firstTask.stage,
+    done: initialCounts.done,
+    total: initialCounts.total,
+  }, usageData);
+
+  try {
+    while (tasksProcessed < maxTasks && !stopping) {
+      plan = await readFile(PLAN_PATH, 'utf-8');
+      const { total, done } = countTasks(plan);
+      const task = parseNextTask(plan);
+
+      if (!task) {
+        tui.appendLog(`\nAll ${total} tasks complete!`);
+        buildSucceeded = true;
+        break;
+      }
+
+      const snapshot = gitSnapshot();
+      tasksProcessed++;
+
+      tui.updateTask({
+        taskId: task.id,
+        taskTitle: task.title,
+        stage: task.stage,
+        done,
+        total,
+      });
+
+      const taskModel = task.model || config.model;
+      tui.appendLog(`\n--- Task ${tasksProcessed} — ${task.id}: ${task.title} ---`);
+      tui.appendLog(chalk.dim(`[Model] ${taskModel} (fallback: sonnet)`));
+      tui.setTaskModel(taskModel);
+
+      // Pre-task rate limit check (informational — fallback is automatic)
+      const usage = await fetchUsage();
+      if (usage) {
+        tui.updateRateLimit(usage);
+
+        if (usage.fiveHour.utilization >= config.rateLimitWarnThreshold) {
+          const resetTime = formatResetTime(usage.fiveHour.resetsAt);
+          tui.appendLog(chalk.yellow(`[Rate Limit] 5h at ${Math.round(usage.fiveHour.utilization)}% — resets ${resetTime}, will fallback to sonnet`));
+        }
+      }
+
+      let passed = false;
+      let lastGateOutput = null;
+      let lastDisplay = null;
+      const attemptHistory = [];
+
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        if (stopping) break;
+
+        tui.resetTimer();
+        tui.updateTask({ attempt, maxAttempts: maxRetries });
+
+        if (attempt > 1) {
+          gitRestore(snapshot);
+          tui.appendLog(chalk.dim(`\n── Retrying task ${task.id} (attempt ${attempt}/${maxRetries}) ──`));
+        }
+
+        const retryContext = (attempt > 1 && lastGateOutput)
+          ? { attempt: attempt - 1, maxRetries, gateResults: lastGateOutput }
+          : null;
+        const prompt = await buildPrompt(task, config, retryContext);
+
+        claudeCalls++;
+        tui.updateTask({ claudeCalls });
+        const fallback = taskModel === 'sonnet' ? undefined : 'sonnet';
+        const emitter = runClaude(prompt, { model: taskModel, fallbackModel: fallback });
+        lastDisplay = attachDisplay(emitter, { tui });
+
+        const result = await new Promise((resolve) => {
+          let resultEvent = null;
+          emitter.on('result', (event) => { resultEvent = event; });
+          emitter.on('close', () => { resolve(resultEvent); });
+          emitter.on('error', (err) => {
+            tui.appendLog(`Error: ${err.message}`);
+            resolve(null);
+          });
+        });
+
+        if (!result || result.is_error) {
+          tui.appendLog(`Task ${task.id} — Claude error (attempt ${attempt}/${maxRetries})`);
+          break;
+        }
+
+        if (opts.skipGates) {
+          passed = true;
+          break;
+        }
+
+        const gateResult = await runGates(config);
+        if (gateResult.results.length > 0) {
+          logGateResults(tui, gateResult.results);
+        }
+
+        if (gateResult.passed) {
+          passed = true;
+          break;
+        }
+
+        lastGateOutput = gateResult;
+        attemptHistory.push({
+          attempt,
+          failedGate: gateResult.failedGate,
+          summary: `${gateResult.failedGate} failed`,
+        });
+      }
+
+      const elapsed = (tui.getCumulativeElapsed() / 1000).toFixed(1);
+
+      if (passed) {
+        const finalAttempt = attemptHistory.length + 1;
+        if (finalAttempt > 1) {
+          tui.appendLog(chalk.green(`Task ${task.id} PASSED on attempt ${finalAttempt}/${maxRetries}`));
+        }
+
+        if (config.simplifyOnBuild && !opts.skipGates) {
+          const changedFiles = getChangedFiles();
+          if (changedFiles.length > 0) {
+            claudeCalls++;
+            tui.updateTask({ claudeCalls });
+            const preSimplifySnapshot = gitSnapshot();
+            await runSimplifyPass(changedFiles, config, tui);
+
+            const postSimplifyGates = await runGates(config);
+            if (!postSimplifyGates.passed) {
+              tui.appendLog(chalk.yellow('[Simplify] Broke tests — reverting simplification'));
+              gitRestore(preSimplifySnapshot);
+            }
+          }
+        }
+
+        if (!opts.skipGates) {
+          const sec = await runSecurityCheck(tui);
+          if (sec.critical.length > 0 || sec.high.length > 0) {
+            tui.appendLog(chalk.red(`[Security] Blocking commit — ${sec.critical.length + sec.high.length} critical/high issue(s)`));
+            gitRestore(snapshot);
+            summaryRows.push([task.id, task.title.slice(0, 35), `${elapsed}s`, 'SECURITY', '-']);
+            buildSucceeded = false;
+            break; // Hard stop
+          }
+        }
+
+        plan = await readFile(PLAN_PATH, 'utf-8');
+        const updatedPlan = markTaskComplete(plan, task.lineIndex);
+        await writeFile(PLAN_PATH, updatedPlan);
+        tui.appendLog(`Task ${task.id} marked complete`);
+
+        let commitInfo = null;
+        if (config.autoCommit) {
+          const commitMsg = task.commit || `feat: complete task ${task.id} — ${task.title}`;
+          commitInfo = gitCommit(commitMsg);
+          if (commitInfo) {
+            tui.appendLog(`Committed: ${commitInfo.hash} ${commitMsg}`);
+          } else {
+            tui.appendLog('No changes to commit');
+          }
+        }
+
+        const changes = commitInfo
+          ? `${commitInfo.files}f +${commitInfo.ins} -${commitInfo.del}`
+          : lastDisplay?.stats.filesModified.length
+            ? `${lastDisplay.stats.filesModified.length} files`
+            : '-';
+        const commit = commitInfo ? commitInfo.hash : '-';
+
+        summaryRows.push([
+          task.id,
+          task.title.slice(0, 35),
+          `${elapsed}s`,
+          changes,
+          commit,
+        ]);
+
+        try {
+          usageData = await getUsageData();
+          tui.updateUsage(usageData);
+        } catch {}
+
+        const newCounts = countTasks(await readFile(PLAN_PATH, 'utf-8'));
+        tui.updateTask({ done: newCounts.done });
+        buildSucceeded = true;
+      } else {
+        gitRestore(snapshot);
+        tui.appendLog(chalk.red(`\nTask ${task.id} FAILED after ${maxRetries} attempts`));
+        for (const h of attemptHistory) {
+          tui.appendLog(chalk.dim(`  Attempt ${h.attempt}: ${h.summary}`));
+        }
+        summaryRows.push([
+          task.id,
+          task.title.slice(0, 35),
+          `${elapsed}s`,
+          'FAILED',
+          '-',
+        ]);
+        buildSucceeded = false;
+        break; // Hard stop
+      }
+    }
+
+    // Post-build documentation pass
+    if (buildSucceeded && config.documentOnBuild) {
+      tui.appendLog(chalk.cyan('\n[Document] Running post-build documentation pass...'));
+      try {
+        await runDocument({ model: config.model });
+        tui.appendLog(chalk.green('[Document] Documentation pass complete'));
+      } catch (err) {
+        tui.appendLog(chalk.yellow(`[Document] Documentation pass failed: ${err.message}`));
+      }
+    }
+  } finally {
+    if (tui) tui.destroy();
+    process.removeListener('SIGINT', onSigint);
+  }
+
+  if (summaryRows.length > 0) {
+    console.log();
+    header('Build Summary');
+    table(['Task', 'Title', 'Time', 'Changes', 'Commit'], summaryRows);
+  }
+}

package/.golem/lib/claude.mjs

@@ -0,0 +1,95 @@
+import { spawn, execSync } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+
+/**
+ * Check if the claude CLI is installed and accessible.
+ * Returns the version string if found, null otherwise.
+ */
+export function checkClaudeCli() {
+  try {
+    return execSync('claude --version', { stdio: 'pipe', encoding: 'utf-8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run claude -p with stream-json output.
+ * Returns an EventEmitter that emits:
+ *   'init'    - { session_id, model, tools }
+ *   'assistant' - { message } (content blocks: text, tool_use, tool_result)
+ *   'result'  - { result, duration_ms, total_cost_usd, usage, is_error }
+ *   'error'   - Error
+ *   'close'   - { code }
+ */
+export function runClaude(prompt, opts = {}) {
+  const emitter = new EventEmitter();
+  const args = ['-p', '--output-format', 'stream-json'];
+
+  if (opts.model) {
+    args.push('--model', opts.model);
+  }
+  if (opts.fallbackModel) {
+    args.push('--fallback-model', opts.fallbackModel);
+  }
+  if (opts.allowedTools) {
+    for (const tool of opts.allowedTools) {
+      args.push('--allowedTools', tool);
+    }
+  }
+
+  const proc = spawn('claude', args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: opts.cwd || process.cwd(),
+  });
+
+  let stderrBuf = '';
+
+  proc.stdout.on('data', (chunk) => {
+    const lines = chunk.toString().split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        switch (event.type) {
+          case 'system':
+            emitter.emit('init', event);
+            break;
+          case 'assistant':
+            emitter.emit('assistant', event);
+            break;
+          case 'result':
+            emitter.emit('result', event);
+            break;
+          default:
+            emitter.emit(event.type, event);
+        }
+      } catch {
+        // partial JSON line, ignore
+      }
+    }
+  });
+
+  proc.stderr.on('data', (chunk) => {
+    stderrBuf += chunk.toString();
+  });
+
+  proc.on('close', (code) => {
+    if (code !== 0 && stderrBuf) {
+      emitter.emit('error', new Error(stderrBuf.trim()));
+    }
+    emitter.emit('close', { code });
+  });
+
+  proc.on('error', (err) => {
+    emitter.emit('error', err);
+  });
+
+  // Write prompt to stdin and close
+  proc.stdin.write(prompt);
+  proc.stdin.end();
+
+  // Expose process for kill/signal handling
+  emitter.process = proc;
+
+  return emitter;
+}