golem-cc 2.1.2 → 3.0.0

package/.golem/lib/gates.mjs

@@ -0,0 +1,78 @@
+import { spawn } from 'node:child_process';
+
+const TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_LINES = 200;
+
+function truncateOutput(text) {
+  const lines = text.split('\n');
+  if (lines.length <= MAX_OUTPUT_LINES) return text;
+  return lines.slice(0, MAX_OUTPUT_LINES).join('\n') + `\n... (truncated ${lines.length - MAX_OUTPUT_LINES} lines)`;
+}
+
+function runCommand(command, timeoutMs) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const child = spawn('sh', ['-c', command], { stdio: 'pipe' });
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      const duration = Date.now() - start;
+      const output = truncateOutput((stdout + stderr).trimEnd());
+
+      if (killed) {
+        resolve({ exitCode: 1, output: output + `\n[TIMEOUT] Gate killed after ${timeoutMs / 1000}s`, duration });
+      } else {
+        resolve({ exitCode: code ?? 1, output, duration });
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ exitCode: 1, output: err.message, duration: Date.now() - start });
+    });
+  });
+}
+
+export async function runGates(config, { timeoutMs = TIMEOUT_MS } = {}) {
+  const gates = config.gates;
+  if (!gates || gates.length === 0) {
+    return { passed: true, results: [], failedGate: null };
+  }
+
+  const results = [];
+
+  for (let i = 0; i < gates.length; i++) {
+    const gate = gates[i];
+    if (!gate.enabled) {
+      results.push({ name: gate.name, passed: true, exitCode: 0, output: '', duration: 0, skipped: true });
+      continue;
+    }
+
+    const { exitCode, output, duration } = await runCommand(gate.command, timeoutMs);
+    const passed = exitCode === 0;
+    results.push({ name: gate.name, passed, exitCode, output, duration });
+
+    if (!passed) {
+      for (let j = i + 1; j < gates.length; j++) {
+        if (gates[j].enabled) {
+          results.push({ name: gates[j].name, passed: false, exitCode: -1, output: '', duration: 0, skipped: true });
+        }
+      }
+      return { passed: false, results, failedGate: gate.name };
+    }
+  }
+
+  return { passed: true, results, failedGate: null };
+}

package/.golem/lib/init.mjs

@@ -0,0 +1,166 @@
+import { readFile, writeFile, access, mkdir } from 'node:fs/promises';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { header, success, warn, info } from './output.mjs';
+import { saveConfig, loadConfig, detectFramework } from './config.mjs';
+
+async function fileExists(path) {
+  try { await access(path); return true; } catch { return false; }
+}
+
+function readPkg(dir) {
+  try { return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8')); }
+  catch { return null; }
+}
+
+export function detectTestCommand(dir) {
+  const pkg = readPkg(dir);
+  const testScript = pkg?.scripts?.test;
+  if (testScript && testScript !== 'echo "Error: no test specified" && exit 1') return testScript;
+  if (existsSync(join(dir, 'vitest.config.ts')) || existsSync(join(dir, 'vitest.config.js'))) return 'npx vitest run';
+  if (existsSync(join(dir, 'jest.config.ts')) || existsSync(join(dir, 'jest.config.js')) || existsSync(join(dir, 'jest.config.mjs'))) return 'npx jest';
+  return 'node --test';
+}
+
+export function detectBuildCommand(dir, framework) {
+  if (framework === 'nuxt') return 'npx nuxt build';
+  if (framework === 'next') return 'npx next build';
+  if (readPkg(dir)?.scripts?.build) return 'npm run build';
+  return '# No build step — ESM modules run directly';
+}
+
+export function detectLintCommand(dir) {
+  if (readPkg(dir)?.scripts?.lint) return 'npm run lint';
+  for (const f of ['eslint.config.js', 'eslint.config.mjs', '.eslintrc.json', '.eslintrc.js', '.eslintrc.yml']) {
+    if (existsSync(join(dir, f))) return 'npx eslint .';
+  }
+  if (existsSync(join(dir, 'biome.json'))) return 'npx biome check .';
+  return '# TBD — will be set up during implementation';
+}
+
+export function detectTypeCheck(dir) {
+  if (existsSync(join(dir, 'tsconfig.json'))) return 'npx tsc --noEmit';
+  return '# N/A — plain JavaScript, no TypeScript';
+}
+
+export function generateAgentsMd(dir, framework) {
+  const testCmd = detectTestCommand(dir);
+  const buildCmd = detectBuildCommand(dir, framework);
+  const lintCmd = detectLintCommand(dir);
+  const typeCheck = detectTypeCheck(dir);
+
+  const pkg = readPkg(dir);
+  const learnings = [];
+  if (framework) learnings.push(`Project uses ${framework} framework`);
+  if (pkg?.type === 'module') learnings.push('Project uses ESM (type: module in package.json)');
+  if (!framework && pkg?.type !== 'module') learnings.push('Standard Node.js project');
+
+  return `# Operational Commands
+
+## Testing
+
+\`\`\`bash
+${testCmd}
+\`\`\`
+
+## Type Checking
+
+\`\`\`bash
+${typeCheck}
+\`\`\`
+
+## Linting
+
+\`\`\`bash
+${lintCmd}
+\`\`\`
+
+## Build
+
+\`\`\`bash
+${buildCmd}
+\`\`\`
+
+## Learnings
+
+${learnings.map(l => `- ${l}`).join('\n')}
+`;
+}
+
+async function ensureGitignore(dir) {
+  const giPath = join(dir, '.gitignore');
+  const entries = ['.env', '.claude/*', '!.claude/commands/', '!.claude/commands/**'];
+  let content = '';
+
+  if (await fileExists(giPath)) {
+    content = await readFile(giPath, 'utf-8');
+  }
+
+  const lines = content.split('\n');
+  const missing = entries.filter(e => !lines.some(l => l.trim() === e));
+
+  if (missing.length === 0) return false;
+
+  const addition = '\n# Golem\n' + missing.join('\n') + '\n';
+  await writeFile(giPath, content.trimEnd() + addition);
+  return true;
+}
+
+export async function runInit() {
+  const cwd = process.cwd();
+
+  header('Golem Init');
+  info('Analyzing project...');
+
+  // Detect framework
+  const framework = await detectFramework();
+  if (framework) {
+    success(`Detected framework: ${framework}`);
+  } else {
+    info('No framework detected (plain Node.js project)');
+  }
+
+  // Detect tools
+  const testCmd = detectTestCommand(cwd);
+  const buildCmd = detectBuildCommand(cwd, framework);
+  const lintCmd = detectLintCommand(cwd);
+  const typeCheck = detectTypeCheck(cwd);
+
+  info(`Test: ${testCmd}`);
+  info(`Build: ${buildCmd}`);
+  info(`Lint: ${lintCmd}`);
+  info(`Type check: ${typeCheck}`);
+
+  // Ensure .golem/ directories exist
+  for (const dir of ['specs', 'prompts', 'agents', 'lib', 'bin']) {
+    await mkdir(join(cwd, '.golem', dir), { recursive: true });
+  }
+  success('Ensured .golem/ directory structure');
+
+  // Generate AGENTS.md
+  const agentsPath = join(cwd, '.golem', 'AGENTS.md');
+  if (await fileExists(agentsPath)) {
+    warn('AGENTS.md already exists — overwriting with detected settings');
+  }
+  await writeFile(agentsPath, generateAgentsMd(cwd, framework));
+  success('Generated AGENTS.md');
+
+  // Create/update config.json
+  const config = await loadConfig();
+  if (framework) config.framework = framework;
+  await saveConfig(config);
+  success('Updated .golem/config.json');
+
+  // Ensure .gitignore entries
+  if (await ensureGitignore(cwd)) {
+    success('Updated .gitignore');
+  }
+
+  console.log();
+  success('Init complete! Next steps:');
+  info('  1. Run /golem:spec in Claude Code to build your specs');
+  info('  2. Run /golem:plan to generate an implementation plan');
+  info('  3. Run npx golem build to start building');
+
+  return { framework, testCmd, buildCmd, lintCmd, typeCheck };
+}

package/.golem/lib/output.mjs

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+
+export function header(text) {
+  console.log();
+  console.log(chalk.bold.cyan(`◆ ${text}`));
+  console.log(chalk.dim('─'.repeat(60)));
+}
+
+export function success(text) {
+  console.log(chalk.green(`✓ ${text}`));
+}
+
+export function fail(text) {
+  console.log(chalk.red(`✗ ${text}`));
+}
+
+export function warn(text) {
+  console.log(chalk.yellow(`⚠ ${text}`));
+}
+
+export function info(text) {
+  console.log(chalk.blue(`ℹ ${text}`));
+}
+
+export function spinner(text) {
+  return ora({ text, color: 'cyan' }).start();
+}
+
+export function table(headers, rows) {
+  const t = new Table({
+    head: headers.map(h => chalk.cyan(h)),
+    style: { head: [], border: ['dim'] },
+  });
+  for (const row of rows) {
+    t.push(row);
+  }
+  console.log(t.toString());
+}

package/.golem/lib/ratelimit.mjs

@@ -0,0 +1,86 @@
+import { execSync } from 'node:child_process';
+
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+let cache = { data: null, fetchedAt: 0 };
+
+function getOAuthToken() {
+  try {
+    const raw = execSync(
+      'security find-generic-password -s "Claude Code-credentials" -w',
+      { stdio: 'pipe', encoding: 'utf-8' },
+    ).trim();
+    const parsed = JSON.parse(raw);
+    // Nested format: { claudeAiOauth: { accessToken } } or flat: { accessToken }
+    return parsed.claudeAiOauth?.accessToken || parsed.accessToken || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchUsage() {
+  const now = Date.now();
+  if (cache.data && (now - cache.fetchedAt) < CACHE_TTL_MS) {
+    return cache.data;
+  }
+
+  const token = getOAuthToken();
+  if (!token) return null;
+
+  try {
+    const res = await fetch(USAGE_URL, {
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'anthropic-beta': 'oauth-2025-04-20',
+      },
+    });
+    if (!res.ok) return null;
+
+    const body = await res.json();
+
+    function parseBucket(bucket) {
+      if (!bucket) return null;
+      return {
+        utilization: bucket.utilization ?? 0,
+        resetsAt: bucket.resets_at ?? null,
+      };
+    }
+
+    const extra = body.extra_usage;
+
+    const data = {
+      fiveHour: parseBucket(body.five_hour) || { utilization: 0, resetsAt: null },
+      sevenDay: parseBucket(body.seven_day) || { utilization: 0, resetsAt: null },
+      opus: parseBucket(body.seven_day_opus),
+      sonnet: parseBucket(body.seven_day_sonnet),
+      extraUsage: extra ? {
+        enabled: extra.is_enabled,
+        limit: extra.monthly_limit / 100,
+        used: extra.used_credits / 100,
+        utilization: extra.utilization,
+      } : null,
+    };
+
+    cache = { data, fetchedAt: now };
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function clearUsageCache() {
+  cache = { data: null, fetchedAt: 0 };
+}
+
+export function formatResetTime(isoString) {
+  if (!isoString) return 'unknown';
+  const reset = new Date(isoString);
+  const diff = reset - Date.now();
+  if (diff <= 0) return 'now';
+  const mins = Math.ceil(diff / 60_000);
+  if (mins < 60) return `${mins}m`;
+  const h = Math.floor(mins / 60);
+  const m = mins % 60;
+  return `${h}h ${m}m`;
+}