dont-hallucinate 0.1.3

package/src/cli.js

@@ -0,0 +1,599 @@
+// cli.js — main CLI (port of cli.py, using commander instead of click)
+
+import { Command } from 'commander';
+import { spawnSync, execFileSync, execSync } from 'child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { platform } from 'process';
+
+import { classifyFailure, extractCmdName } from './parser.js';
+import { detectAgent, loadSnarkMap, pickRoast } from './burn.js';
+import { verifyCommand, VerificationResult } from './verifier.js';
+import { appendJsonl, defaultStreamFile, ensureRuntimeDir, utcTimestamp, workspaceRoot } from './runtime.js';
+import { runUi } from './ui.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, '..');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function hookPath(shell) {
+  const hooksDir = join(PACKAGE_ROOT, 'dont_hallucinate', 'hooks');
+  const map = {
+    powershell: join(hooksDir, 'hook.ps1'),
+    bash: join(hooksDir, 'hook.sh'),
+    'agent-bash': join(hooksDir, 'hook_noninteractive.sh'),
+  };
+  return map[shell] ?? null;
+}
+
+function quotePowershell(value) {
+  return "'" + value.replace(/'/g, "''") + "'";
+}
+
+function quoteBash(value) {
+  return "'" + value.replace(/'/g, "'\"'\"'") + "'";
+}
+
+function toBashPath(p) {
+  const abs = resolve(p);
+  if (abs.length >= 3 && abs[1] === ':' && abs[2] === '\\') {
+    const drive = abs[0].toLowerCase();
+    const tail = abs.slice(2).replace(/\\/g, '/');
+    return `/${drive}${tail}`;
+  }
+  return abs.replace(/\\/g, '/');
+}
+
+function commandDisplay(args) {
+  if (platform === 'win32') {
+    return args.map(a => (a.includes(' ') ? `"${a}"` : a)).join(' ');
+  }
+  return args.join(' ');
+}
+
+function which(cmd) {
+  try {
+    const result = execFileSync(platform === 'win32' ? 'where' : 'which', [cmd], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return result.trim().split('\n')[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+function realBashPath() {
+  return process.env.HALLUCINATE_REAL_BASH || which('bash');
+}
+
+function prepareEnv(workspace, stream, actor) {
+  return {
+    ...process.env,
+    HALLUCINATE_WORKSPACE_ROOT: workspace,
+    HALLUCINATE_STREAM_FILE: stream,
+    HALLUCINATE_ACTOR: actor,
+  };
+}
+
+function shimDir(ws) {
+  return join(ws, '.hallucinate', 'bin');
+}
+
+function readJsonFile(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    return (data && typeof data === 'object' && !Array.isArray(data)) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeJsonFile(path, payload) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(payload, null, 2) + '\n', 'utf8');
+}
+
+function readTextFile(path) {
+  if (!existsSync(path)) return '';
+  return readFileSync(path, 'utf8');
+}
+
+function writeTextFile(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, 'utf8');
+}
+
+function appendBlockOnce(filePath, beginMarker, endMarker, block) {
+  const current = readTextFile(filePath);
+  if (current.includes(beginMarker) && current.includes(endMarker)) {
+    const start = current.indexOf(beginMarker);
+    const end = current.indexOf(endMarker, start) + endMarker.length;
+    const replacement = block.trimEnd();
+    const before = current.slice(0, start).trimEnd();
+    const after = current.slice(end).replace(/^\r?\n/, '');
+    const updated = (before ? before + '\n\n' : '') + replacement + '\n' + after;
+    writeTextFile(filePath, updated);
+    return false;
+  }
+  const normalized = current.trimEnd();
+  const updated = (normalized ? normalized + '\n\n' : '') + block.trimEnd() + '\n';
+  writeTextFile(filePath, updated);
+  return true;
+}
+
+// ── TOML helpers (for Codex config) ──────────────────────────────────────────
+
+function findTomlTable(lines, tableName) {
+  const header = `[${tableName}]`;
+  let start = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === header) { start = i; break; }
+  }
+  if (start === null) return [null, null];
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    const s = lines[i].trim();
+    if (s.startsWith('[') && s.endsWith(']')) { end = i; break; }
+  }
+  return [start, end];
+}
+
+function ensureTomlTable(lines, tableName) {
+  let [start, end] = findTomlTable(lines, tableName);
+  if (start !== null) return [start, end];
+  if (lines.length && lines[lines.length - 1].trim()) lines.push('');
+  lines.push(`[${tableName}]`);
+  return [lines.length - 1, lines.length];
+}
+
+function upsertTomlAssignment(lines, tableName, key, value) {
+  const [start, end] = ensureTomlTable(lines, tableName);
+  const assignment = `${key} = ${value}`;
+  for (let i = start + 1; i < end; i++) {
+    if (lines[i].trim().startsWith(`${key} =`)) { lines[i] = assignment; return lines; }
+  }
+  lines.splice(end, 0, assignment);
+  return lines;
+}
+
+function codexConfigWithHook(existing, streamFile, hookFile) {
+  const lines = existing.split('\n');
+  const [shellStart, shellEnd] = ensureTomlTable(lines, 'shell_environment_policy');
+  for (let i = shellStart + 1; i < shellEnd; i++) {
+    if (lines[i].trim().startsWith('set =')) {
+      throw new Error('Existing [shell_environment_policy] uses inline `set = {...}`. Please migrate it to [shell_environment_policy.set] before installing the Codex hook.');
+    }
+  }
+  upsertTomlAssignment(lines, 'shell_environment_policy', 'inherit', '"all"');
+  upsertTomlAssignment(lines, 'shell_environment_policy.set', 'BASH_ENV', JSON.stringify(toBashPath(hookFile)));
+  upsertTomlAssignment(lines, 'shell_environment_policy.set', 'HALLUCINATE_STREAM_FILE', JSON.stringify(streamFile));
+  upsertTomlAssignment(lines, 'shell_environment_policy.set', 'HALLUCINATE_ACTOR', JSON.stringify('agent'));
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+// ── Bash shim ────────────────────────────────────────────────────────────────
+
+function installBashShim(ws, actor) {
+  const sDir = shimDir(ws);
+  mkdirSync(sDir, { recursive: true });
+
+  const shimSh = join(sDir, 'bash');
+  const shimCmd = join(sDir, 'bash.cmd');
+
+  writeFileSync(shimSh, `#!/usr/bin/env sh\nexec dont-hallucinate bash --workspace ${quoteBash(ws)} --actor ${quoteBash(actor)} -- "$@"\n`, 'utf8');
+  try { chmodSync(shimSh, 0o755); } catch { /* skip on Windows */ }
+
+  writeFileSync(shimCmd, `@echo off\r\ndont-hallucinate bash --workspace "${ws}" --actor "${actor}" -- %*\r\n`, 'utf8');
+
+  return sDir;
+}
+
+// ── Core execution ────────────────────────────────────────────────────────────
+
+function buildFailureReport(commandText, actor, stderrText, exitCode) {
+  const parsed = classifyFailure(commandText, stderrText, exitCode);
+
+  let verification;
+  if (parsed.errorType === 'invalid_flag') {
+    verification = verifyCommand(commandText, parsed.hallucinatedFlag);
+  } else {
+    verification = new VerificationResult({ availableFlags: [], suggestedFlag: null, correctedCommand: null, source: 'none' });
+  }
+
+  const agent = detectAgent();
+  const cmdName = extractCmdName(commandText);
+  const roast = pickRoast(loadSnarkMap(), parsed.errorType, {
+    agent,
+    cmdName,
+    flag: parsed.hallucinatedFlag || 'that flag',
+    missing: parsed.missingCommand || cmdName || 'that',
+  });
+
+  const lines = [];
+  if (stderrText) lines.push(stderrText.trimEnd());
+  lines.push('');
+  lines.push(`[dont-hallucinate/${actor}] caught: ${commandText}`);
+  lines.push(`[dont-hallucinate/${actor}] type: ${parsed.errorType}`);
+  if (verification.correctedCommand) {
+    lines.push(`[dont-hallucinate/${actor}] try: ${verification.correctedCommand}`);
+  } else if (verification.suggestedFlag) {
+    lines.push(`[dont-hallucinate/${actor}] maybe: ${verification.suggestedFlag}`);
+  }
+  lines.push(`[dont-hallucinate/${actor}] roast: ${roast}`);
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+function logExecEvent(stream, ws, actor, commandText, exitCode, stderrText) {
+  appendJsonl(stream, {
+    ts: utcTimestamp(),
+    shell: 'exec',
+    actor,
+    session: process.pid,
+    pid: process.pid,
+    cwd: ws,
+    workspace_root: ws,
+    exit_code: exitCode,
+    command: commandText,
+    stderr: stderrText,
+  });
+}
+
+function runWrappedCommand(ws, actor, args, useShell = false) {
+  ensureRuntimeDir(ws);
+  const stream = defaultStreamFile(ws);
+  const commandText = useShell ? args[0] : commandDisplay(args);
+
+  const result = spawnSync(useShell ? args[0] : args[0], useShell ? [] : args.slice(1), {
+    cwd: ws,
+    shell: useShell,
+    stdio: ['inherit', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  });
+
+  if (result.stdout) process.stdout.write(result.stdout);
+
+  const stderrText = result.stderr || '';
+  const exitCode = result.status ?? 1;
+
+  if (exitCode !== 0) {
+    const decorated = buildFailureReport(commandText, actor, stderrText, exitCode);
+    process.stderr.write(decorated);
+    logExecEvent(stream, ws, actor, commandText, exitCode, stderrText);
+    process.exit(exitCode);
+  }
+
+  if (stderrText) process.stderr.write(stderrText);
+  logExecEvent(stream, ws, actor, commandText, 0, stderrText);
+}
+
+// ── Claude hook script (Node.js) ─────────────────────────────────────────────
+
+const HOOK_SCRIPT = `#!/usr/bin/env node
+// PreToolUse hook: wraps every Bash tool call through dont-hallucinate exec.
+let input = '';
+process.stdin.on('data', c => input += c);
+process.stdin.on('end', () => {
+  const data = JSON.parse(input);
+  const cmd = (data?.tool_input?.command) || '';
+  if (!cmd || cmd.trimStart().startsWith('hallucinate')) {
+    process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'allow'}}) + '\\n');
+    process.exit(0);
+  }
+  const quoted = cmd.replace(/'/g, "'\\"'\\''");
+  const wrapped = \`dont-hallucinate exec --shell --actor agent -- '\${quoted}'\`;
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      updatedInput: { command: wrapped },
+    }
+  }) + '\\n');
+});
+`;
+
+function mergeClaudeHook(settings, scriptPath) {
+  const hooks = settings.hooks ?? (settings.hooks = {});
+  const pre = hooks.PreToolUse ?? (hooks.PreToolUse = []);
+  for (const entry of pre) {
+    if (entry.matcher === 'Bash' && (entry.hooks || []).some(h => h.command?.includes('hallucinate_hook'))) {
+      return settings;
+    }
+  }
+  pre.push({ matcher: 'Bash', hooks: [{ type: 'command', command: `node ${JSON.stringify(scriptPath)}` }] });
+  return settings;
+}
+
+function installClaudeHook(globalInstall) {
+  const claudeDir = globalInstall
+    ? join(homedir(), '.claude')
+    : join(process.cwd(), '.claude');
+  const scriptPathInSettings = globalInstall
+    ? join(claudeDir, 'hallucinate_hook.js')
+    : '.claude/hallucinate_hook.js';
+
+  mkdirSync(claudeDir, { recursive: true });
+  const settingsFile = join(claudeDir, 'settings.json');
+  const hookScript = join(claudeDir, 'hallucinate_hook.js');
+  writeFileSync(hookScript, HOOK_SCRIPT, 'utf8');
+
+  const settings = readJsonFile(settingsFile);
+  mergeClaudeHook(settings, scriptPathInSettings);
+  writeJsonFile(settingsFile, settings);
+  return [hookScript, settingsFile];
+}
+
+function codexConfigPath(globalInstall) {
+  return globalInstall
+    ? join(homedir(), '.codex', 'config.toml')
+    : join(process.cwd(), '.codex', 'config.toml');
+}
+
+function agentStreamFile(agentName) {
+  return join(homedir(), '.dont-hallucinate', agentName, 'stream.jsonl');
+}
+
+function installCodexHook(globalInstall) {
+  const configPath = codexConfigPath(globalInstall);
+  const streamFile = agentStreamFile('codex');
+  const hookFile = hookPath('agent-bash');
+
+  mkdirSync(dirname(streamFile), { recursive: true });
+  const updated = codexConfigWithHook(readTextFile(configPath), streamFile, hookFile);
+  writeTextFile(configPath, updated);
+  return [configPath, streamFile];
+}
+
+function cursorBashBlock(streamFile, hookFile) {
+  return [
+    '# >>> dont-hallucinate cursor >>>',
+    'if [ -n "${CURSOR_AGENT:-}" ]; then',
+    `  export HALLUCINATE_ACTOR=${quoteBash('agent')}`,
+    `  export HALLUCINATE_STREAM_FILE=${quoteBash(streamFile)}`,
+    `  source ${quoteBash(toBashPath(hookFile))}`,
+    'fi',
+    '# <<< dont-hallucinate cursor <<<',
+  ].join('\n');
+}
+
+function cursorPowershellBlock(streamFile, hookFile) {
+  return [
+    '# >>> dont-hallucinate cursor >>>',
+    'if ($env:CURSOR_AGENT) {',
+    "    $env:HALLUCINATE_ACTOR = 'agent'",
+    `    $env:HALLUCINATE_STREAM_FILE = ${quotePowershell(streamFile)}`,
+    `    . ${quotePowershell(hookFile)}`,
+    '}',
+    '# <<< dont-hallucinate cursor <<<',
+  ].join('\n');
+}
+
+function installCursorHook() {
+  const streamFile = agentStreamFile('cursor');
+  const bashHook = hookPath('bash');
+  const psHook = hookPath('powershell');
+
+  mkdirSync(dirname(streamFile), { recursive: true });
+  const touched = [];
+
+  const psProfile = join(homedir(), 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1');
+  appendBlockOnce(psProfile, '# >>> dont-hallucinate cursor >>>', '# <<< dont-hallucinate cursor <<<', cursorPowershellBlock(streamFile, psHook));
+  touched.push(psProfile);
+
+  for (const profile of [join(homedir(), '.bashrc'), join(homedir(), '.zshrc')]) {
+    appendBlockOnce(profile, '# >>> dont-hallucinate cursor >>>', '# <<< dont-hallucinate cursor <<<', cursorBashBlock(streamFile, bashHook));
+    touched.push(profile);
+  }
+
+  return [touched, streamFile];
+}
+
+// ── CLI definition ────────────────────────────────────────────────────────────
+
+export function createCli() {
+  const program = new Command();
+
+  program
+    .name('dont-hallucinate')
+    .description('mocks your coding agent when they get it wrong')
+    .action(() => {
+      const ws = workspaceRoot();
+      const stream = defaultStreamFile(ws);
+      ensureRuntimeDir(ws);
+      runUi({ streamFile: stream, pollInterval: 200, fromStart: true, workspace: ws });
+    });
+
+  // watch
+  program
+    .command('watch')
+    .description('run the terminal watcher UI')
+    .option('--stream-file <path>', 'JSONL stream file path')
+    .option('--poll-interval <ms>', 'file polling interval in ms', v => Number(v), 200)
+    .option('--from-start', 'read existing events first instead of seeking to EOF', false)
+    .option('--workspace <dir>', 'workspace root to watch', process.cwd())
+    .action(opts => {
+      const ws = workspaceRoot(opts.workspace);
+      ensureRuntimeDir(ws);
+      const stream = opts.streamFile ? resolve(opts.streamFile) : defaultStreamFile(ws);
+      runUi({ streamFile: stream, pollInterval: opts.pollInterval, fromStart: opts.fromStart, workspace: ws });
+    });
+
+  // activate
+  program
+    .command('activate')
+    .description('print shell commands to activate the hook for the current workspace')
+    .requiredOption('--shell <type>', 'shell type: powershell | bash | agent-bash')
+    .option('--workspace <dir>', 'workspace root', process.cwd())
+    .option('--stream-file <path>', 'override the JSONL stream path')
+    .option('--actor <type>', 'tag events: human | agent')
+    .action(opts => {
+      const ws = workspaceRoot(opts.workspace);
+      ensureRuntimeDir(ws);
+      const stream = opts.streamFile ? resolve(opts.streamFile) : defaultStreamFile(ws);
+      const hook = resolve(hookPath(opts.shell));
+      const actor = opts.actor ?? (opts.shell === 'agent-bash' ? 'agent' : 'human');
+      const sDir = installBashShim(ws, actor);
+      const realBash = realBashPath();
+
+      let snippet;
+      if (opts.shell === 'powershell') {
+        const parts = [
+          `$env:HALLUCINATE_WORKSPACE_ROOT = ${quotePowershell(ws)}`,
+          `$env:HALLUCINATE_STREAM_FILE = ${quotePowershell(stream)}`,
+          `$env:HALLUCINATE_ACTOR = ${quotePowershell(actor)}`,
+          `$env:PATH = ${quotePowershell(sDir + ';')} + $env:PATH`,
+          ...(realBash ? [`$env:HALLUCINATE_REAL_BASH = ${quotePowershell(realBash)}`] : []),
+          `. ${quotePowershell(hook)}`,
+        ];
+        snippet = parts.join('; ');
+      } else if (opts.shell === 'bash') {
+        const parts = [
+          `export HALLUCINATE_WORKSPACE_ROOT=${quoteBash(toBashPath(ws))}`,
+          `export HALLUCINATE_STREAM_FILE=${quoteBash(toBashPath(stream))}`,
+          `export HALLUCINATE_ACTOR=${quoteBash(actor)}`,
+          `export PATH=${quoteBash(toBashPath(sDir))}:$PATH`,
+          ...(realBash ? [`export HALLUCINATE_REAL_BASH=${quoteBash(toBashPath(realBash))}`] : []),
+          `source ${quoteBash(toBashPath(hook))}`,
+        ];
+        snippet = parts.join('\n');
+      } else {
+        const parts = [
+          `export HALLUCINATE_WORKSPACE_ROOT=${quoteBash(toBashPath(ws))}`,
+          `export HALLUCINATE_STREAM_FILE=${quoteBash(toBashPath(stream))}`,
+          `export HALLUCINATE_ACTOR=${quoteBash(actor)}`,
+          `export PATH=${quoteBash(toBashPath(sDir))}:$PATH`,
+          ...(realBash ? [`export HALLUCINATE_REAL_BASH=${quoteBash(toBashPath(realBash))}`] : []),
+          `export BASH_ENV=${quoteBash(toBashPath(hook))}`,
+        ];
+        snippet = parts.join('\n');
+      }
+      process.stdout.write(snippet + '\n');
+    });
+
+  // shell
+  program
+    .command('shell')
+    .description('spawn a shell with hallucinate already activated')
+    .option('--shell <type>', 'powershell | bash', platform === 'win32' ? 'powershell' : 'bash')
+    .option('--workspace <dir>', 'workspace root', process.cwd())
+    .option('--actor <type>', 'human | agent', 'human')
+    .action(opts => {
+      const ws = workspaceRoot(opts.workspace);
+      ensureRuntimeDir(ws);
+      const stream = defaultStreamFile(ws);
+      const env = prepareEnv(ws, stream, opts.actor);
+      const sDir = installBashShim(ws, opts.actor);
+      env.PATH = sDir + (platform === 'win32' ? ';' : ':') + (env.PATH || '');
+      const realBash = realBashPath();
+      if (realBash) env.HALLUCINATE_REAL_BASH = realBash;
+
+      if (opts.shell === 'powershell') {
+        const ps = which('powershell') || which('pwsh');
+        if (!ps) { console.error('PowerShell is not available on PATH.'); process.exit(1); }
+        const hook = resolve(hookPath('powershell'));
+        const cmd = `. ${quotePowershell(hook)}; Set-Location ${quotePowershell(ws)}`;
+        const result = spawnSync(ps, ['-NoExit', '-ExecutionPolicy', 'Bypass', '-Command', cmd], { stdio: 'inherit', env });
+        process.exit(result.status ?? 1);
+      }
+
+      const bash = which('bash');
+      if (!bash) { console.error('bash is not available on PATH.'); process.exit(1); }
+      const hook = resolve(hookPath('bash'));
+      env.HALLUCINATE_WORKSPACE_ROOT = toBashPath(ws);
+      env.HALLUCINATE_STREAM_FILE = toBashPath(stream);
+      const result = spawnSync(bash, ['--noprofile', '--rcfile', toBashPath(hook), '-i'], { cwd: ws, stdio: 'inherit', env });
+      process.exit(result.status ?? 1);
+    });
+
+  // bash
+  program
+    .command('bash [args...]')
+    .description('run the real bash through dont-hallucinate')
+    .option('--workspace <dir>', 'workspace root', process.cwd())
+    .option('--actor <type>', 'human | agent', 'agent')
+    .allowUnknownOption()
+    .action((args, opts) => {
+      const realBash = realBashPath();
+      if (!realBash) { console.error('A real bash binary could not be found. Set HALLUCINATE_REAL_BASH or install bash.'); process.exit(1); }
+      const ws = workspaceRoot(opts.workspace);
+      runWrappedCommand(ws, opts.actor, [realBash, ...args]);
+    });
+
+  // exec
+  program
+    .command('exec <command...>')
+    .description('run a command through dont-hallucinate and decorate failures')
+    .option('--workspace <dir>', 'workspace root', process.cwd())
+    .option('--actor <type>', 'human | agent', 'agent')
+    .option('--shell', 'run via system shell instead of direct exec', false)
+    .allowUnknownOption()
+    .action((command, opts) => {
+      const ws = workspaceRoot(opts.workspace);
+      runWrappedCommand(ws, opts.actor, command, opts.shell);
+    });
+
+  // explain
+  program
+    .command('explain')
+    .description('render the dont-hallucinate failure report for a command')
+    .option('--actor <name>', 'actor label', 'agent')
+    .requiredOption('--command <text>', 'command text that failed')
+    .requiredOption('--exit-code <n>', 'exit code from the failed command', v => Number(v))
+    .option('--stderr-file <path>', 'path to a stderr capture file')
+    .option('--stderr-text <text>', 'fallback stderr text', '')
+    .action(opts => {
+      const stderrValue = opts.stderrFile
+        ? readFileSync(opts.stderrFile, { encoding: 'utf8', flag: 'r' })
+        : (opts.stderrText || '');
+      process.stdout.write(buildFailureReport(opts.command, opts.actor, stderrValue, opts.exitCode));
+    });
+
+  // install-hook-claude (+ alias install-hook)
+  for (const cmdName of ['install-hook-claude', 'install-hook']) {
+    program
+      .command(cmdName)
+      .description('install the Claude Code PreToolUse hook for automatic bash interception')
+      .option('--global', 'install into ~/.claude/settings.json', false)
+      .action(opts => {
+        const [hookScript, settingsFile] = installClaudeHook(opts.global);
+        console.log(`Wrote ${hookScript}`);
+        console.log(`Updated ${settingsFile}`);
+        const scope = opts.global ? 'all projects (global)' : 'this project';
+        console.log(`Done. Hallucinate will intercept bash commands for ${scope}.`);
+        console.log('Restart Claude Code to activate.');
+      });
+  }
+
+  // install-hook-codex
+  program
+    .command('install-hook-codex')
+    .description('install a Codex CLI shell hook via shell_environment_policy')
+    .option('--global', 'install into ~/.codex/config.toml', true)
+    .option('--project', 'install project-locally', false)
+    .action(opts => {
+      const globalInstall = !opts.project;
+      const [configPath, streamFile] = installCodexHook(globalInstall);
+      const scope = globalInstall ? 'global' : 'project-local';
+      console.log(`Updated ${configPath}`);
+      console.log(`Stream file: ${streamFile}`);
+      console.log(`Done. Hallucinate will intercept Codex bash subprocess failures (${scope}).`);
+      console.log('Restart Codex sessions to activate.');
+    });
+
+  // install-hook-cursor
+  program
+    .command('install-hook-cursor')
+    .description('install shell-profile hooks that activate only inside Cursor agent terminals')
+    .action(() => {
+      const [touched, streamFile] = installCursorHook();
+      for (const p of touched) console.log(`Updated ${p}`);
+      console.log(`Stream file: ${streamFile}`);
+      console.log('Done. Hallucinate will activate when Cursor sets CURSOR_AGENT in the terminal.');
+      console.log('Restart Cursor terminals to activate.');
+    });
+
+  return program;
+}