@automagik/genie 0.260201.2240

package/src/genie-commands/hooks.ts

@@ -0,0 +1,317 @@
+/**
+ * Genie Hooks Commands
+ *
+ * Commands to install, uninstall, and test hooks in Claude Code.
+ * Bridges the gap between genie config and Claude Code settings.
+ */
+
+import {
+  loadClaudeSettings,
+  saveClaudeSettings,
+  isGenieHookInstalled,
+  addGenieHook,
+  removeGenieHook,
+  getClaudeSettingsPath,
+  contractClaudePath,
+} from '../lib/claude-settings.js';
+import {
+  hookScriptExists,
+  writeHookScript,
+  removeHookScript,
+  testHookScript,
+  getHookScriptDisplayPath,
+} from '../lib/hook-script.js';
+import {
+  loadGenieConfig,
+  getGenieConfigPath,
+} from '../lib/genie-config.js';
+import { describeEnabledHooks, hasEnabledHooks } from '../lib/hooks/index.js';
+import { checkCommand } from '../lib/system-detect.js';
+
+/**
+ * Print a boxed success message
+ */
+function printSuccessBox(lines: string[]): void {
+  const maxLen = Math.max(...lines.map((l) => l.length));
+  const width = maxLen + 4;
+
+  console.log();
+  console.log('\x1b[32m' + '+' + '-'.repeat(width) + '+' + '\x1b[0m');
+  for (const line of lines) {
+    const padding = ' '.repeat(maxLen - line.length);
+    console.log('\x1b[32m' + '|  ' + '\x1b[0m' + line + padding + '\x1b[32m  |' + '\x1b[0m');
+  }
+  console.log('\x1b[32m' + '+' + '-'.repeat(width) + '+' + '\x1b[0m');
+  console.log();
+}
+
+/**
+ * Check required dependencies
+ */
+async function checkDependencies(): Promise<{
+  jq: boolean;
+  tmux: boolean;
+  term: boolean;
+  errors: string[];
+}> {
+  const errors: string[] = [];
+
+  const jqCheck = await checkCommand('jq');
+  const tmuxCheck = await checkCommand('tmux');
+  const termCheck = await checkCommand('term');
+
+  if (!jqCheck.exists) {
+    errors.push('jq is required but not installed. Install with: brew install jq (or apt install jq)');
+  }
+
+  return {
+    jq: jqCheck.exists,
+    tmux: tmuxCheck.exists,
+    term: termCheck.exists,
+    errors,
+  };
+}
+
+/**
+ * Install hooks into Claude Code
+ */
+export async function installHooksCommand(options: { force?: boolean } = {}): Promise<void> {
+  console.log();
+  console.log('\x1b[1m Installing Genie Hooks\x1b[0m');
+  console.log();
+
+  // Step 1: Check dependencies
+  console.log('\x1b[2mChecking dependencies...\x1b[0m');
+  const deps = await checkDependencies();
+
+  if (deps.jq) {
+    console.log('  \x1b[32m+\x1b[0m jq');
+  } else {
+    console.log('  \x1b[31m-\x1b[0m jq (required)');
+  }
+
+  if (deps.tmux) {
+    console.log('  \x1b[32m+\x1b[0m tmux');
+  } else {
+    console.log('  \x1b[33m-\x1b[0m tmux (recommended for collaborative mode)');
+  }
+
+  if (deps.term) {
+    console.log('  \x1b[32m+\x1b[0m term');
+  } else {
+    console.log('  \x1b[33m-\x1b[0m term (required for collaborative mode)');
+  }
+
+  if (deps.errors.length > 0) {
+    console.log();
+    for (const error of deps.errors) {
+      console.log('\x1b[31mError:\x1b[0m ' + error);
+    }
+    process.exit(1);
+  }
+
+  console.log();
+
+  // Step 2: Load genie config and check presets
+  console.log('\x1b[2mLoading configuration...\x1b[0m');
+  const config = await loadGenieConfig();
+
+  if (!hasEnabledHooks(config)) {
+    console.log();
+    console.log('\x1b[33mNo hook presets are enabled.\x1b[0m');
+    console.log('Run \x1b[36mgenie setup\x1b[0m to configure hook presets first.');
+    console.log();
+    process.exit(1);
+  }
+
+  const descriptions = describeEnabledHooks(config);
+  console.log('  \x1b[32m+\x1b[0m Enabled presets: ' + config.hooks.enabled.join(', '));
+  console.log();
+
+  // Step 3: Check if collaborative preset needs tmux
+  if (config.hooks.enabled.includes('collaborative')) {
+    if (!deps.tmux) {
+      console.log('\x1b[33mWarning:\x1b[0m Collaborative mode enabled but tmux not found.');
+      console.log('Install tmux for the best experience: brew install tmux (or apt install tmux)');
+      console.log();
+    }
+    if (!deps.term) {
+      console.log('\x1b[33mWarning:\x1b[0m Collaborative mode enabled but term not found.');
+      console.log('The term command is required for collaborative mode to work.');
+      console.log();
+    }
+  }
+
+  // Step 4: Check if already installed
+  const settings = await loadClaudeSettings();
+  if (isGenieHookInstalled(settings) && !options.force) {
+    console.log('\x1b[33mGenie hooks are already installed.\x1b[0m');
+    console.log('Use \x1b[36m--force\x1b[0m to reinstall.');
+    console.log();
+    return;
+  }
+
+  // Step 5: Write the hook script
+  console.log('\x1b[2mWriting hook script...\x1b[0m');
+  await writeHookScript();
+  console.log('  \x1b[32m+\x1b[0m ' + getHookScriptDisplayPath());
+  console.log();
+
+  // Step 6: Update Claude settings
+  console.log('\x1b[2mUpdating Claude Code settings...\x1b[0m');
+  const updatedSettings = addGenieHook(settings);
+  await saveClaudeSettings(updatedSettings);
+  console.log('  \x1b[32m+\x1b[0m Hook registered in ' + contractClaudePath(getClaudeSettingsPath()));
+  console.log();
+
+  // Step 7: Print success
+  const sessionName = config.hooks.collaborative?.sessionName || 'genie';
+  printSuccessBox([
+    '\x1b[32m+\x1b[0m Installation complete!',
+    '',
+    'Restart Claude Code for changes to take effect.',
+    '',
+    'After restart, all Bash commands will run in tmux.',
+    `Watch with: tmux attach -t ${sessionName}`,
+  ]);
+}
+
+/**
+ * Uninstall hooks from Claude Code
+ */
+export async function uninstallHooksCommand(options: { keepScript?: boolean } = {}): Promise<void> {
+  console.log();
+  console.log('\x1b[1m Uninstalling Genie Hooks\x1b[0m');
+  console.log();
+
+  // Step 1: Remove from Claude settings
+  console.log('\x1b[2mRemoving from Claude Code settings...\x1b[0m');
+  const settings = await loadClaudeSettings();
+
+  if (!isGenieHookInstalled(settings)) {
+    console.log('  \x1b[33m-\x1b[0m No genie hooks found in settings');
+  } else {
+    const updatedSettings = removeGenieHook(settings);
+    await saveClaudeSettings(updatedSettings);
+    console.log('  \x1b[32m+\x1b[0m Hook removed from ' + contractClaudePath(getClaudeSettingsPath()));
+  }
+  console.log();
+
+  // Step 2: Remove hook script (unless --keep-script)
+  if (!options.keepScript) {
+    console.log('\x1b[2mRemoving hook script...\x1b[0m');
+    if (hookScriptExists()) {
+      removeHookScript();
+      console.log('  \x1b[32m+\x1b[0m Deleted ' + getHookScriptDisplayPath());
+    } else {
+      console.log('  \x1b[33m-\x1b[0m Hook script not found');
+    }
+    console.log();
+  } else {
+    console.log('\x1b[2mKeeping hook script (--keep-script)\x1b[0m');
+    console.log();
+  }
+
+  // Step 3: Print success
+  printSuccessBox([
+    '\x1b[32m+\x1b[0m Uninstallation complete!',
+    '',
+    'Restart Claude Code for changes to take effect.',
+  ]);
+}
+
+/**
+ * Test the hook script
+ */
+export async function testHooksCommand(): Promise<void> {
+  console.log();
+  console.log('\x1b[1m Testing Genie Hooks\x1b[0m');
+  console.log();
+
+  // Check if script exists
+  if (!hookScriptExists()) {
+    console.log('\x1b[31mError:\x1b[0m Hook script not found.');
+    console.log('Run \x1b[36mgenie hooks install\x1b[0m first.');
+    console.log();
+    process.exit(1);
+  }
+
+  console.log('Script location: ' + getHookScriptDisplayPath());
+  console.log();
+
+  // Run test
+  console.log('\x1b[2mTesting with sample Bash input...\x1b[0m');
+  const result = await testHookScript();
+
+  if (result.success) {
+    console.log('\x1b[32m+\x1b[0m Hook script works correctly!');
+    console.log();
+    console.log('\x1b[2mSample output:\x1b[0m');
+    try {
+      const parsed = JSON.parse(result.output || '{}');
+      console.log(JSON.stringify(parsed, null, 2));
+    } catch {
+      console.log(result.output);
+    }
+  } else {
+    console.log('\x1b[31m-\x1b[0m Hook script test failed!');
+    console.log();
+    console.log('\x1b[31mError:\x1b[0m ' + result.error);
+    if (result.output) {
+      console.log();
+      console.log('\x1b[2mOutput:\x1b[0m');
+      console.log(result.output);
+    }
+    process.exit(1);
+  }
+
+  console.log();
+}
+
+/**
+ * Show current hook configuration (moved from setup.ts)
+ */
+export async function showHooksCommand(): Promise<void> {
+  const config = await loadGenieConfig();
+  const descriptions = describeEnabledHooks(config);
+
+  console.log();
+  console.log('\x1b[1m Current Hook Configuration\x1b[0m');
+  console.log(`   Genie config: ${contractClaudePath(getGenieConfigPath())}`);
+  console.log(`   Claude settings: ${contractClaudePath(getClaudeSettingsPath())}`);
+  console.log();
+
+  // Show enabled presets
+  if (descriptions.length === 0) {
+    console.log('\x1b[33m   No hook presets enabled.\x1b[0m');
+    console.log('   Run \x1b[36mgenie setup\x1b[0m to configure hooks.');
+  } else {
+    console.log('\x1b[2m   Enabled presets:\x1b[0m');
+    for (const desc of descriptions) {
+      console.log(`   \x1b[32m+\x1b[0m ${desc}`);
+    }
+  }
+  console.log();
+
+  // Show installation status
+  const settings = await loadClaudeSettings();
+  const installed = isGenieHookInstalled(settings);
+  const scriptExists = hookScriptExists();
+
+  console.log('\x1b[2m   Installation status:\x1b[0m');
+  if (installed && scriptExists) {
+    console.log('   \x1b[32m+\x1b[0m Hooks installed in Claude Code');
+    console.log('   \x1b[32m+\x1b[0m Hook script exists');
+  } else if (installed && !scriptExists) {
+    console.log('   \x1b[33m!\x1b[0m Hook registered but script missing');
+    console.log('   Run \x1b[36mgenie hooks install --force\x1b[0m to fix');
+  } else if (!installed && scriptExists) {
+    console.log('   \x1b[33m!\x1b[0m Script exists but hook not registered');
+    console.log('   Run \x1b[36mgenie hooks install\x1b[0m to register');
+  } else {
+    console.log('   \x1b[33m-\x1b[0m Hooks not installed');
+    console.log('   Run \x1b[36mgenie hooks install\x1b[0m to install');
+  }
+
+  console.log();
+}

package/src/genie-commands/install.ts

@@ -0,0 +1,351 @@
+import { confirm } from '@inquirer/prompts';
+import { spawn } from 'child_process';
+import {
+  detectSystem,
+  checkAllPrerequisites,
+  checkCommand,
+  getDistroDisplayName,
+  type SystemInfo,
+  type PrerequisiteStatus,
+  type PackageManager,
+} from '../lib/system-detect.js';
+import { genieConfigExists } from '../lib/genie-config.js';
+import { setupCommand } from './setup.js';
+
+export interface InstallOptions {
+  check?: boolean;
+  yes?: boolean;
+}
+
+interface InstallStrategy {
+  brew?: string;
+  apt?: string;
+  dnf?: string;
+  yum?: string;
+  pacman?: string;
+  all?: string;
+  none?: string | null;
+}
+
+const STRATEGIES: Record<string, InstallStrategy> = {
+  tmux: {
+    brew: 'brew install tmux',
+    apt: 'sudo apt update && sudo apt install -y tmux',
+    dnf: 'sudo dnf install -y tmux',
+    yum: 'sudo yum install -y tmux',
+    pacman: 'sudo pacman -S --noconfirm tmux',
+    none: null,
+  },
+  bun: {
+    all: 'curl -fsSL https://bun.sh/install | bash',
+  },
+  claude: {
+    all: 'npm install -g @anthropic-ai/claude-code',
+  },
+};
+
+function getInstallCommand(name: string, pm: PackageManager): string | null {
+  const strategy = STRATEGIES[name];
+  if (!strategy) return null;
+
+  // Check for universal installer first
+  if (strategy.all) return strategy.all;
+
+  // Check for package manager specific
+  if (pm !== 'none' && strategy[pm]) return strategy[pm];
+
+  // Check if there's a none/manual fallback
+  if (strategy.none !== undefined) return strategy.none;
+
+  return null;
+}
+
+function getManualInstructions(name: string): string {
+  switch (name) {
+    case 'tmux':
+      return 'Visit https://github.com/tmux/tmux/wiki/Installing for installation instructions';
+    case 'bun':
+      return 'Visit https://bun.sh for installation instructions';
+    case 'claude':
+      return 'Run: npm install -g @anthropic-ai/claude-code (requires Node.js/npm)';
+    default:
+      return `Search for "${name} install" for installation instructions`;
+  }
+}
+
+async function runCommand(command: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    console.log(`\x1b[2m$ ${command}\x1b[0m\n`);
+
+    const child = spawn('bash', ['-c', command], {
+      stdio: 'inherit',
+      env: { ...process.env, FORCE_COLOR: '1' },
+    });
+
+    child.on('close', (code) => {
+      resolve(code === 0);
+    });
+
+    child.on('error', (err) => {
+      console.error(`\x1b[31mError: ${err.message}\x1b[0m`);
+      resolve(false);
+    });
+  });
+}
+
+function printHeader() {
+  console.log();
+  console.log('\x1b[1m🔧 Genie Prerequisites Check\x1b[0m');
+  console.log();
+}
+
+function printSystemInfo(system: SystemInfo) {
+  let osDisplay = system.os === 'macos' ? 'macOS' : 'Linux';
+  if (system.linuxDistro && system.linuxDistro !== 'unknown') {
+    osDisplay = `Linux (${getDistroDisplayName(system.linuxDistro)})`;
+  }
+
+  console.log(`System: ${osDisplay} (${system.arch})`);
+  console.log(`Package Manager: ${system.preferredPM === 'none' ? 'none detected' : system.preferredPM}`);
+  console.log();
+}
+
+function printPrerequisiteStatus(prereqs: PrerequisiteStatus[]) {
+  console.log('Checking prerequisites...');
+  console.log();
+
+  for (const p of prereqs) {
+    if (p.installed) {
+      const versionInfo = p.version ? ` ${p.version}` : '';
+      const pathInfo = p.path ? `\x1b[2m (${p.path})\x1b[0m` : '';
+      console.log(`  \x1b[32m✅\x1b[0m ${p.name}${versionInfo}${pathInfo}`);
+    } else if (p.required) {
+      console.log(`  \x1b[31m❌\x1b[0m ${p.name} \x1b[31mnot found\x1b[0m`);
+    } else {
+      console.log(`  \x1b[33m⚠️\x1b[0m  ${p.name} \x1b[33mnot found\x1b[0m \x1b[2m(optional)\x1b[0m`);
+    }
+  }
+  console.log();
+}
+
+function printSeparator() {
+  console.log('\x1b[2m' + '─'.repeat(40) + '\x1b[0m');
+  console.log();
+}
+
+async function promptAndInstall(
+  prereq: PrerequisiteStatus,
+  command: string | null,
+  options: InstallOptions
+): Promise<'installed' | 'skipped' | 'failed'> {
+  const typeLabel = prereq.required ? '\x1b[31mrequired\x1b[0m' : '\x1b[2moptional, recommended\x1b[0m';
+
+  if (!command) {
+    console.log(`\x1b[33mManual installation required for\x1b[0m ${prereq.name} (${typeLabel})`);
+    console.log(`  ${getManualInstructions(prereq.name)}`);
+    console.log();
+    return 'skipped';
+  }
+
+  console.log(`Install \x1b[1m${prereq.name}\x1b[0m? (${typeLabel})`);
+  console.log(`  Command: \x1b[36m${command}\x1b[0m`);
+
+  let proceed: boolean;
+  if (options.yes) {
+    proceed = true;
+    console.log('\x1b[2mAuto-approved with --yes\x1b[0m');
+  } else {
+    // Default to yes for required, no for optional
+    proceed = await confirm({
+      message: 'Proceed',
+      default: prereq.required,
+    });
+  }
+
+  if (!proceed) {
+    console.log(`\x1b[33mSkipped: ${prereq.name}\x1b[0m`);
+    console.log();
+    return 'skipped';
+  }
+
+  console.log();
+  console.log(`Installing ${prereq.name}...`);
+  console.log();
+
+  const success = await runCommand(command);
+
+  if (success) {
+    // Verify installation
+    const check = await checkCommand(prereq.name);
+    if (check.exists) {
+      const versionInfo = check.version ? ` ${check.version}` : '';
+      console.log();
+      console.log(`\x1b[32m✅ ${prereq.name}${versionInfo} installed\x1b[0m`);
+      console.log();
+      return 'installed';
+    } else {
+      console.log();
+      console.log(`\x1b[33m⚠️  ${prereq.name} installed but not found in PATH\x1b[0m`);
+      console.log('\x1b[2m  You may need to restart your shell or source your profile\x1b[0m');
+      console.log();
+      return 'installed';
+    }
+  } else {
+    console.log();
+    console.log(`\x1b[31m❌ Failed to install ${prereq.name}\x1b[0m`);
+    console.log(`\x1b[2m  ${getManualInstructions(prereq.name)}\x1b[0m`);
+    console.log();
+    return 'failed';
+  }
+}
+
+/**
+ * Prompt to run genie setup after successful installation
+ */
+async function promptForSetup(options: InstallOptions): Promise<void> {
+  // Skip if genie config already exists
+  if (genieConfigExists()) {
+    console.log('\x1b[2m✓ Genie hooks already configured (~/.genie/config.json)\x1b[0m');
+    console.log('  Run \x1b[36mgenie setup\x1b[0m to reconfigure.');
+    console.log();
+    return;
+  }
+
+  console.log();
+  printSeparator();
+  console.log('\x1b[1m🧞 Configure Genie Hooks?\x1b[0m');
+  console.log();
+  console.log('\x1b[2mHooks let you control how AI tools execute - without wasting tokens!\x1b[0m');
+  console.log('\x1b[2mFor example, the "collaborative" hook routes all bash commands through\x1b[0m');
+  console.log('\x1b[2mtmux so you can watch the AI work in real-time.\x1b[0m');
+  console.log();
+
+  let runSetup: boolean;
+  if (options.yes) {
+    runSetup = true;
+    console.log('\x1b[2mAuto-approved with --yes\x1b[0m');
+  } else {
+    runSetup = await confirm({
+      message: 'Would you like to configure genie hooks now?',
+      default: true,
+    });
+  }
+
+  if (runSetup) {
+    console.log();
+    await setupCommand();
+  } else {
+    console.log();
+    console.log('\x1b[2mSkipped. Run \x1b[0m\x1b[36mgenie setup\x1b[0m\x1b[2m anytime to configure hooks.\x1b[0m');
+    console.log();
+  }
+}
+
+export async function installCommand(options: InstallOptions): Promise<void> {
+  printHeader();
+
+  const system = await detectSystem();
+  printSystemInfo(system);
+
+  const prereqs = await checkAllPrerequisites();
+  printPrerequisiteStatus(prereqs);
+
+  const missing = prereqs.filter((p) => !p.installed);
+  const missingRequired = missing.filter((p) => p.required);
+  const missingOptional = missing.filter((p) => !p.required);
+
+  if (missing.length === 0) {
+    console.log('\x1b[32m✅ All prerequisites are installed!\x1b[0m');
+    console.log();
+
+    // Offer to run setup if not already configured
+    await promptForSetup(options);
+
+    console.log(`Run \x1b[36mterm --help\x1b[0m or \x1b[36mclaudio --help\x1b[0m to get started.`);
+    console.log();
+    return;
+  }
+
+  console.log(
+    `Missing: ${missingRequired.length} required, ${missingOptional.length} optional`
+  );
+  console.log();
+
+  if (options.check) {
+    if (missingRequired.length > 0) {
+      console.log('\x1b[31m❌ Missing required prerequisites\x1b[0m');
+      console.log(`Run \x1b[36mgenie install\x1b[0m to install them.`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  printSeparator();
+
+  const results = {
+    installed: [] as string[],
+    skipped: [] as string[],
+    failed: [] as string[],
+  };
+
+  // Install missing prerequisites
+  for (const prereq of missing) {
+    const command = getInstallCommand(prereq.name, system.preferredPM);
+    const result = await promptAndInstall(prereq, command, options);
+
+    if (result === 'installed') {
+      results.installed.push(prereq.name);
+    } else if (result === 'skipped') {
+      results.skipped.push(prereq.name);
+    } else {
+      results.failed.push(prereq.name);
+    }
+
+    if (prereq !== missing[missing.length - 1]) {
+      printSeparator();
+    }
+  }
+
+  // Print summary
+  printSeparator();
+  console.log('\x1b[1mSummary:\x1b[0m');
+
+  const requiredInstalled = results.installed.filter((name) =>
+    missingRequired.some((p) => p.name === name)
+  );
+  const requiredFailed = results.failed.filter((name) =>
+    missingRequired.some((p) => p.name === name)
+  );
+  const optionalSkipped = results.skipped.filter((name) =>
+    missingOptional.some((p) => p.name === name)
+  );
+
+  if (requiredFailed.length > 0) {
+    console.log(`\x1b[31m  ❌ ${requiredFailed.length} required failed: ${requiredFailed.join(', ')}\x1b[0m`);
+  } else if (requiredInstalled.length > 0 || missingRequired.length === 0) {
+    console.log('\x1b[32m  ✅ All required prerequisites installed\x1b[0m');
+  }
+
+  if (results.installed.length > 0) {
+    console.log(`\x1b[32m  ✅ Installed: ${results.installed.join(', ')}\x1b[0m`);
+  }
+
+  if (optionalSkipped.length > 0) {
+    console.log(`\x1b[33m  ⚠️  ${optionalSkipped.length} optional skipped: ${optionalSkipped.join(', ')}\x1b[0m`);
+  }
+
+  console.log();
+
+  if (requiredFailed.length === 0) {
+    // Offer to run setup after successful installation
+    await promptForSetup(options);
+
+    console.log(`Run \x1b[36mterm --help\x1b[0m or \x1b[36mclaudio --help\x1b[0m to get started.`);
+  } else {
+    console.log('\x1b[31mSome required prerequisites could not be installed.\x1b[0m');
+    console.log('Please install them manually and run this command again.');
+    process.exit(1);
+  }
+
+  console.log();
+}