golem-cc 2.1.2 → 3.0.0

package/.golem/lib/config.mjs

@@ -0,0 +1,421 @@
+import { readFile, writeFile, access, readdir } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+
+const DEFAULTS = {
+  model: 'opus',
+  autoCommit: true,
+  simplifyOnBuild: true,
+  documentOnBuild: false,
+  docsPath: 'docs/',
+  maxRetries: 3,
+  rateLimitWarnThreshold: 80,
+  gates: [
+    { name: 'tests', command: 'node --test', enabled: true },
+    { name: 'lint', command: 'npx eslint .', enabled: false },
+    { name: 'typecheck', command: 'npx tsc --noEmit', enabled: false },
+  ],
+  worktree: {
+    dir: '~/code/.worktrees',
+    copies: ['.golem/', '.claude/', '.env'],
+    excludes: ['.golem/IMPLEMENTATION_PLAN.md', '.golem/specs/', '.golem/HANDOFF.md', '.golem/SECURITY_REPORT.md'],
+    setup: 'pnpm install',
+  },
+};
+
+function golemDir() {
+  return join(process.cwd(), '.golem');
+}
+
+export async function loadConfig() {
+  try {
+    const raw = await readFile(join(golemDir(), 'config.json'), 'utf-8');
+    const userConfig = JSON.parse(raw);
+    // Deep merge for nested objects like worktree
+    return {
+      ...DEFAULTS,
+      ...userConfig,
+      worktree: { ...DEFAULTS.worktree, ...(userConfig.worktree || {}) },
+    };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export async function saveConfig(config) {
+  await writeFile(join(golemDir(), 'config.json'), JSON.stringify(config, null, 2) + '\n');
+}
+
+export async function setConfigValue(key, value) {
+  const config = await loadConfig();
+
+  // Handle nested keys like worktree.dir
+  if (key.includes('.')) {
+    const [parent, child] = key.split('.');
+    if (!(parent in DEFAULTS)) {
+      throw new Error(`Unknown config key: ${parent}. Valid keys: ${Object.keys(DEFAULTS).join(', ')}`);
+    }
+    if (typeof DEFAULTS[parent] !== 'object' || Array.isArray(DEFAULTS[parent])) {
+      throw new Error(`Config key ${parent} is not a nested object`);
+    }
+    if (!(child in DEFAULTS[parent])) {
+      throw new Error(`Unknown nested config key: ${key}. Valid keys for ${parent}: ${Object.keys(DEFAULTS[parent]).join(', ')}`);
+    }
+
+    const defaultVal = DEFAULTS[parent][child];
+    if (typeof defaultVal === 'boolean') {
+      value = value === 'true';
+    } else if (typeof defaultVal === 'number') {
+      value = Number(value);
+    } else if (Array.isArray(defaultVal)) {
+      value = typeof value === 'string' ? JSON.parse(value) : value;
+    }
+
+    config[parent] = { ...config[parent], [child]: value };
+  } else {
+    if (!(key in DEFAULTS)) {
+      throw new Error(`Unknown config key: ${key}. Valid keys: ${Object.keys(DEFAULTS).join(', ')}`);
+    }
+    const defaultVal = DEFAULTS[key];
+    if (typeof defaultVal === 'boolean') {
+      value = value === 'true';
+    } else if (typeof defaultVal === 'number') {
+      value = Number(value);
+    } else if (Array.isArray(defaultVal)) {
+      value = typeof value === 'string' ? JSON.parse(value) : value;
+    }
+    config[key] = value;
+  }
+
+  await saveConfig(config);
+  return config;
+}
+
+export async function detectFramework() {
+  const checks = [
+    { file: 'nuxt.config.ts', framework: 'nuxt' },
+    { file: 'nuxt.config.js', framework: 'nuxt' },
+    { file: 'next.config.ts', framework: 'next' },
+    { file: 'next.config.js', framework: 'next' },
+    { file: 'next.config.mjs', framework: 'next' },
+  ];
+  for (const { file, framework } of checks) {
+    if (await fileExists(join(process.cwd(), file))) return framework;
+  }
+  return null;
+}
+
+const _detectionCache = new Map();
+
+export function resetDetectionCache() {
+  _detectionCache.clear();
+}
+
+export async function detectProject(root) {
+  const dir = root || process.cwd();
+
+  if (_detectionCache.has(dir)) return _detectionCache.get(dir);
+
+  const [language, framework, moduleSystem, databaseTooling] = await Promise.all([
+    detectLanguage(dir),
+    detectFrameworkFull(dir),
+    detectModuleSystem(dir),
+    detectDatabaseTooling(dir),
+  ]);
+
+  const inlineDocStandard = mapDocStandard(language);
+
+  const result = { language, framework, moduleSystem, databaseTooling, inlineDocStandard };
+  _detectionCache.set(dir, result);
+  return result;
+}
+
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+async function hasFilesWithExt(dir, extensions) {
+  try {
+    const entries = await readdir(dir);
+    return entries.some(e => extensions.some(ext => e.endsWith(ext)));
+  } catch {
+    return false;
+  }
+}
+
+async function detectLanguage(dir) {
+  if (await fileExists(join(dir, 'tsconfig.json'))) return 'typescript';
+  if (await hasFilesWithExt(dir, ['.ts', '.tsx'])) return 'typescript';
+
+  for (const f of ['pyproject.toml', 'setup.py', 'requirements.txt']) {
+    if (await fileExists(join(dir, f))) return 'python';
+  }
+  if (await hasFilesWithExt(dir, ['.py'])) return 'python';
+
+  return 'javascript';
+}
+
+async function detectFrameworkFull(dir) {
+  const pkg = await readJson(join(dir, 'package.json'));
+  const deps = { ...(pkg?.dependencies || {}), ...(pkg?.devDependencies || {}) };
+
+  for (const ext of ['.ts', '.js', '.mjs']) {
+    if (await fileExists(join(dir, `nuxt.config${ext}`))) return 'nuxt';
+  }
+  if (deps.nuxt) return 'nuxt';
+
+  for (const ext of ['.ts', '.js', '.mjs']) {
+    if (await fileExists(join(dir, `next.config${ext}`))) return 'next';
+  }
+  if (deps.next) return 'next';
+
+  if (deps.vue) return 'vue';
+  if (await hasFilesWithExt(dir, ['.vue'])) return 'vue';
+
+  if (deps.react) return 'react';
+  if (await hasFilesWithExt(dir, ['.jsx', '.tsx'])) return 'react';
+
+  return 'none';
+}
+
+async function detectModuleSystem(dir) {
+  const pkg = await readJson(join(dir, 'package.json'));
+  const lang = await detectLanguage(dir);
+  if (lang === 'python') return 'n/a';
+
+  if (pkg?.type === 'module') return 'esm';
+  if (await hasFilesWithExt(dir, ['.mjs'])) return 'esm';
+  if (pkg) return 'commonjs';
+
+  return 'n/a';
+}
+
+async function detectDatabaseTooling(dir) {
+  if (await fileExists(join(dir, 'prisma', 'schema.prisma'))) return 'prisma';
+  if (await fileExists(join(dir, 'prisma'))) return 'prisma';
+
+  if (await fileExists(join(dir, 'drizzle.config.ts'))) return 'drizzle';
+  if (await fileExists(join(dir, 'drizzle.config.js'))) return 'drizzle';
+
+  if (await fileExists(join(dir, 'knexfile.js'))) return 'knex';
+  if (await fileExists(join(dir, 'knexfile.ts'))) return 'knex';
+
+  if (await fileExists(join(dir, 'alembic'))) return 'alembic';
+  if (await fileExists(join(dir, 'alembic.ini'))) return 'alembic';
+
+  const pyproject = await readFile(join(dir, 'pyproject.toml'), 'utf-8').catch(() => null);
+  if (pyproject && /sqlalchemy/i.test(pyproject)) return 'sqlalchemy';
+
+  if (await hasFilesWithExt(dir, ['.sql'])) return 'raw-sql';
+  if (await fileExists(join(dir, 'migrations'))) return 'raw-sql';
+
+  return 'none';
+}
+
+function mapDocStandard(language) {
+  return { typescript: 'tsdoc', python: 'google-docstring' }[language] || 'jsdoc';
+}
+
+export async function detectWorkspace(root) {
+  const dir = root || process.cwd();
+  const subDirs = await findMonorepoPackages(dir);
+
+  if (subDirs.length === 0) {
+    return { '.': await detectProject(dir) };
+  }
+
+  const entries = await Promise.all(
+    subDirs.map(async (sub) => [sub, await detectProject(join(dir, sub))]),
+  );
+  return Object.fromEntries(entries);
+}
+
+async function findMonorepoPackages(dir) {
+  const manifests = ['package.json', 'pyproject.toml'];
+
+  if (await fileExists(join(dir, 'pnpm-workspace.yaml'))) {
+    return collectSubPackages(dir, await parsePnpmWorkspace(dir), manifests);
+  }
+
+  const lerna = await readJson(join(dir, 'lerna.json'));
+  if (lerna) {
+    return collectSubPackages(dir, lerna.packages || ['packages/*'], manifests);
+  }
+
+  const pkg = await readJson(join(dir, 'package.json'));
+  if (pkg?.workspaces) {
+    const patterns = Array.isArray(pkg.workspaces)
+      ? pkg.workspaces
+      : pkg.workspaces.packages || [];
+    return collectSubPackages(dir, patterns, manifests);
+  }
+
+  const candidates = [];
+  for (const name of ['packages', 'apps']) {
+    const subDir = join(dir, name);
+    try {
+      const entries = await readdir(subDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const childPath = join(subDir, entry.name);
+        for (const manifest of manifests) {
+          if (await fileExists(join(childPath, manifest))) {
+            candidates.push(`${name}/${entry.name}`);
+            break;
+          }
+        }
+      }
+    } catch {}
+  }
+  return candidates;
+}
+
+async function parsePnpmWorkspace(dir) {
+  try {
+    const content = await readFile(join(dir, 'pnpm-workspace.yaml'), 'utf-8');
+    const patterns = [];
+    let inPackages = false;
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed === 'packages:') {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (/^\s*-\s/.test(line)) {
+          const val = trimmed.replace(/^-\s*/, '').replace(/^['"]|['"]$/g, '');
+          if (val) patterns.push(val);
+        } else if (trimmed && !trimmed.startsWith('#')) {
+          break;
+        }
+      }
+    }
+    return patterns.length > 0 ? patterns : ['packages/*'];
+  } catch {
+    return ['packages/*'];
+  }
+}
+
+async function collectSubPackages(dir, patterns, manifests) {
+  const results = [];
+  for (const pattern of patterns) {
+    const base = pattern.replace(/\/\*\*?$/, '');
+    const baseDir = join(dir, base);
+    try {
+      const entries = await readdir(baseDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const childPath = join(baseDir, entry.name);
+        for (const manifest of manifests) {
+          if (await fileExists(join(childPath, manifest))) {
+            results.push(`${base}/${entry.name}`);
+            break;
+          }
+        }
+      }
+    } catch {}
+  }
+  return results;
+}
+
+export function getDefaults() {
+  return {
+    ...DEFAULTS,
+    gates: DEFAULTS.gates.map(g => ({ ...g })),
+    worktree: {
+      ...DEFAULTS.worktree,
+      copies: [...DEFAULTS.worktree.copies],
+      excludes: [...DEFAULTS.worktree.excludes],
+    },
+  };
+}
+
+function toolInstalled(name) {
+  try {
+    execSync(`which ${name}`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function expandTilde(path) {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+export function getRepoName() {
+  try {
+    const remoteUrl = execSync('git remote get-url origin', {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+      encoding: 'utf-8'
+    }).trim();
+
+    // Parse repo name from URL
+    // Examples:
+    // - https://github.com/user/repo.git -> repo
+    // - git@github.com:user/repo.git -> repo
+    // - ssh://git@example.com/repo.git -> repo
+    const lastSegment = remoteUrl.split('/').pop();
+    return lastSegment.replace(/\.git$/, '');
+  } catch {
+    // No remote or git not available — fallback to directory name
+    return basename(process.cwd());
+  }
+}
+
+export async function gatherShowInfo() {
+  const config = await loadConfig();
+  const framework = await detectFramework();
+  const cwd = process.cwd();
+
+  const securityTools = ['gitleaks', 'semgrep', 'trivy'].map(t => ({
+    name: t,
+    installed: toolInstalled(t),
+  }));
+
+  let agentsSummary = null;
+  try {
+    const content = await readFile(join(golemDir(), 'AGENTS.md'), 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim()).slice(0, 5);
+    agentsSummary = lines.join('\n');
+  } catch {}
+
+  const commands = ['build', 'plan', 'security', 'simplify', 'doctor', 'config', 'init', 'status', 'help'];
+
+  return {
+    config,
+    framework,
+    paths: {
+      project: cwd,
+      golem: golemDir(),
+      config: join(golemDir(), 'config.json'),
+    },
+    securityTools,
+    agentsSummary,
+    commands,
+    worktree: {
+      dir: config.worktree.dir,
+      copies: config.worktree.copies,
+      excludes: config.worktree.excludes,
+      setup: config.worktree.setup,
+    },
+  };
+}

package/.golem/lib/display.mjs

@@ -0,0 +1,191 @@
+import chalk from 'chalk';
+import { spinner as createSpinner, info, success, fail } from './output.mjs';
+
+/**
+ * Attach display handlers to a claude event emitter.
+ * @param {EventEmitter} emitter
+ * @param {{ tui?: object }} opts - pass tui for full-screen mode
+ * Returns a context object with { spinner, stats }.
+ */
+export function attachDisplay(emitter, opts = {}) {
+  const tui = opts.tui || null;
+  let inThinkingBlock = false;
+
+  const ctx = {
+    spinner: null,
+    stats: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheCreation: 0,
+      cost: 0,
+      durationMs: 0,
+      filesModified: [],
+    },
+  };
+
+  const closeThinkingBlock = () => {
+    if (inThinkingBlock && tui) {
+      tui.appendLog(chalk.dim('  ─'));
+      inThinkingBlock = false;
+    }
+  };
+
+  emitter.on('init', (event) => {
+    const model = event.model || 'unknown';
+    if (tui) {
+      tui.appendLog(chalk.bold.cyan(`Golem building (${model})`));
+      if (tui.setTaskModel) tui.setTaskModel(model);
+    } else {
+      ctx.spinner = createSpinner(`Claude (${model})`);
+    }
+  });
+
+  emitter.on('assistant', (event) => {
+    const msg = event.message;
+    if (!msg?.content) return;
+
+    // Update model from actual response (detects fallback)
+    if (tui && tui.setTaskModel && msg.model) {
+      tui.setTaskModel(msg.model);
+    }
+
+    for (const block of msg.content) {
+      if (block.type === 'text' && block.text) {
+        if (tui) {
+          const lines = block.text.split('\n').filter(l => l);
+          for (const line of lines) {
+            if (!inThinkingBlock) {
+              inThinkingBlock = true;
+              tui.appendLog(chalk.dim('  ─'));
+              tui.appendLog(chalk.bold.cyan('[Golem]') + ' ' + chalk.white(line));
+            } else {
+              tui.appendLog('        ' + chalk.white(line));
+            }
+          }
+        } else {
+          const preview = block.text.slice(0, 80).replace(/\n/g, ' ');
+          if (ctx.spinner) ctx.spinner.text = preview;
+        }
+      }
+
+      if (block.type === 'tool_use') {
+        closeThinkingBlock();
+        const name = block.name;
+        let label;
+
+        if (name === 'Read') {
+          const filePath = block.input?.file_path || block.input?.path || '';
+          const short = filePath ? filePath.replace(process.cwd() + '/', '') : '';
+          label = chalk.blue(`[Read]`) + ` ${chalk.blue(short)}`;
+        } else if (name === 'Edit') {
+          const filePath = block.input?.file_path || block.input?.path || '';
+          const short = filePath ? filePath.replace(process.cwd() + '/', '') : '';
+          if (short && !ctx.stats.filesModified.includes(short)) {
+            ctx.stats.filesModified.push(short);
+          }
+          label = chalk.yellow(`[Edit]`) + ` ${chalk.yellow(short)}`;
+        } else if (name === 'Write') {
+          const filePath = block.input?.file_path || block.input?.path || '';
+          const short = filePath ? filePath.replace(process.cwd() + '/', '') : '';
+          if (short && !ctx.stats.filesModified.includes(short)) {
+            ctx.stats.filesModified.push(short);
+          }
+          label = chalk.green(`[Write]`) + ` ${chalk.green(short)}`;
+        } else if (name === 'Bash') {
+          const cmd = block.input?.command || '';
+          const preview = cmd.slice(0, 60).replace(/\n/g, ' ');
+          label = chalk.magenta(`[Bash]`) + ` ${chalk.dim(preview)}`;
+        } else if (name === 'Glob' || name === 'Grep') {
+          const pattern = block.input?.pattern || block.input?.glob || '';
+          label = chalk.cyan(`[${name}]`) + ` ${chalk.dim(pattern)}`;
+        } else {
+          label = chalk.dim(`[${name}]`);
+        }
+
+        if (tui) {
+          tui.appendLog(label);
+        } else {
+          if (ctx.spinner) ctx.spinner.text = label;
+        }
+      }
+
+      if (block.type === 'tool_result') {
+        closeThinkingBlock();
+        if (tui && block.content && typeof block.content === 'string') {
+          // Show truncated result in TUI
+          const lines = block.content.split('\n');
+          const maxLines = 8;
+          const shown = lines.slice(0, maxLines);
+          for (const line of shown) {
+            tui.appendLog(chalk.dim('  ' + line.slice(0, 120)));
+          }
+          if (lines.length > maxLines) {
+            tui.appendLog(chalk.dim(`  ... (${lines.length - maxLines} more lines)`));
+          }
+        } else if (!tui) {
+          if (block.content && typeof block.content === 'string') {
+            if (block.content.includes('FAIL') || block.content.includes('Error')) {
+              if (ctx.spinner) ctx.spinner.text = chalk.red('Tests failing...');
+            }
+          }
+        }
+      }
+    }
+
+    // Track token usage from message
+    if (msg.usage) {
+      const input = msg.usage.input_tokens || 0;
+      const output = msg.usage.output_tokens || 0;
+      ctx.stats.inputTokens += input;
+      ctx.stats.outputTokens += output;
+      ctx.stats.cacheRead += msg.usage.cache_read_input_tokens || 0;
+      ctx.stats.cacheCreation += msg.usage.cache_creation_input_tokens || 0;
+
+      if (tui) tui.updateTokens(input, output);
+    }
+  });
+
+  emitter.on('result', (event) => {
+    ctx.stats.durationMs = event.duration_ms || 0;
+    ctx.stats.cost = event.total_cost_usd || 0;
+
+    if (event.usage) {
+      ctx.stats.inputTokens = event.usage.input_tokens || ctx.stats.inputTokens;
+      ctx.stats.outputTokens = event.usage.output_tokens || ctx.stats.outputTokens;
+    }
+
+    if (tui) {
+      // TUI mode: just log completion, build.mjs handles summary
+      const status = event.is_error ? chalk.red('Error') : chalk.green('Completed');
+      tui.appendLog(`${status} — ${(ctx.stats.durationMs / 1000).toFixed(1)}s | $${ctx.stats.cost.toFixed(4)}`);
+    } else {
+      if (ctx.spinner) ctx.spinner.stop();
+
+      if (event.is_error) {
+        fail(`Claude error: ${event.result}`);
+      } else {
+        success('Claude completed');
+      }
+
+      const secs = (ctx.stats.durationMs / 1000).toFixed(1);
+      const tokens = ctx.stats.inputTokens + ctx.stats.outputTokens;
+      const cost = ctx.stats.cost.toFixed(4);
+      info(`${secs}s | ${tokens} tokens | $${cost}`);
+
+      if (ctx.stats.filesModified.length > 0) {
+        info(`Files modified: ${ctx.stats.filesModified.join(', ')}`);
+      }
+    }
+  });
+
+  emitter.on('error', (err) => {
+    if (tui) {
+      tui.appendLog(chalk.red(`Error: ${err.message}`));
+    } else {
+      if (ctx.spinner) ctx.spinner.fail(err.message);
+    }
+  });
+
+  return ctx;
+}