@automagik/genie 0.260201.2240

package/src/genie-commands/setup.ts

@@ -0,0 +1,282 @@
+/**
+ * Genie Setup Command
+ *
+ * Interactive wizard for configuring genie hooks and settings.
+ * Teaches users about hooks and lets them choose which to enable.
+ */
+
+import { checkbox, confirm, input } from '@inquirer/prompts';
+import {
+  loadGenieConfig,
+  saveGenieConfig,
+  genieConfigExists,
+  getGenieConfigPath,
+} from '../lib/genie-config.js';
+import {
+  GenieConfig,
+  PresetName,
+  PRESET_DESCRIPTIONS,
+} from '../types/genie-config.js';
+import { describeEnabledHooks } from '../lib/hooks/index.js';
+import { installShortcuts, isShortcutsInstalled } from '../term-commands/shortcuts.js';
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Print the header banner
+ */
+function printHeader(): void {
+  console.log();
+  console.log('\x1b[1m\x1b[36m' + '╔' + '═'.repeat(62) + '╗' + '\x1b[0m');
+  console.log('\x1b[1m\x1b[36m' + '║  ' + '\x1b[0m\x1b[1m🧞 Genie Setup - Configure Your AI Assistant' + ' '.repeat(16) + '\x1b[36m║\x1b[0m');
+  console.log('\x1b[1m\x1b[36m' + '╚' + '═'.repeat(62) + '╝' + '\x1b[0m');
+  console.log();
+}
+
+/**
+ * Print the about hooks section
+ */
+function printAboutHooks(): void {
+  console.log('\x1b[1m📚 ABOUT HOOKS\x1b[0m');
+  console.log('\x1b[2mHooks let you control how the AI uses tools - without wasting\x1b[0m');
+  console.log('\x1b[2mtokens on prompts! Instead of telling the AI "please use term",\x1b[0m');
+  console.log('\x1b[2mhooks automatically enforce the behavior.\x1b[0m');
+  console.log();
+  console.log('\x1b[2m' + '─'.repeat(64) + '\x1b[0m');
+  console.log();
+}
+
+/**
+ * Print available presets in a nice format
+ */
+function printPresetDescriptions(): void {
+  console.log('\x1b[1m🔧 AVAILABLE HOOK PRESETS\x1b[0m');
+  console.log();
+
+  for (let i = 0; i < PRESET_DESCRIPTIONS.length; i++) {
+    const preset = PRESET_DESCRIPTIONS[i];
+    const num = i + 1;
+    const recommended = preset.recommended ? ' \x1b[32m(Recommended)\x1b[0m' : '';
+
+    console.log(`\x1b[1m${num}. ${preset.title}\x1b[0m${recommended}`);
+    console.log(`   ├─ What: ${preset.what}`);
+    console.log(`   ├─ Why:  ${preset.why}`);
+    console.log(`   └─ How:  ${preset.how}`);
+    console.log();
+  }
+
+  console.log('\x1b[2m' + '─'.repeat(64) + '\x1b[0m');
+  console.log();
+}
+
+/**
+ * Format preset choice for checkbox
+ */
+function formatPresetChoice(preset: typeof PRESET_DESCRIPTIONS[0], enabled: boolean): {
+  name: string;
+  value: PresetName;
+  checked: boolean;
+} {
+  const recommended = preset.recommended ? ' \x1b[32m(Recommended)\x1b[0m' : '';
+  return {
+    name: `${preset.title}${recommended} - ${preset.what}`,
+    value: preset.name,
+    checked: enabled,
+  };
+}
+
+/**
+ * Print success message
+ */
+function printSuccess(configPath: string): void {
+  console.log();
+  console.log(`\x1b[32m✓ Configuration saved to ${configPath}\x1b[0m`);
+  console.log();
+  console.log('\x1b[1m💡 TIP:\x1b[0m Claudio will automatically use these hooks.');
+  console.log('   Run: \x1b[36mclaudio launch\x1b[0m');
+  console.log('   Watch: \x1b[36mtmux attach -t genie\x1b[0m');
+  console.log();
+}
+
+/**
+ * Print current configuration
+ */
+function printCurrentConfig(config: GenieConfig): void {
+  const descriptions = describeEnabledHooks(config);
+
+  if (descriptions.length === 0) {
+    console.log('\x1b[33mNo hooks currently enabled.\x1b[0m');
+  } else {
+    console.log('\x1b[1mCurrently enabled hooks:\x1b[0m');
+    for (const desc of descriptions) {
+      console.log(`  • ${desc}`);
+    }
+  }
+  console.log();
+}
+
+/**
+ * Configure sandboxed preset paths
+ */
+async function configureSandbox(config: GenieConfig): Promise<void> {
+  const currentPaths = config.hooks.sandboxed?.allowedPaths || ['~/projects', '/tmp'];
+
+  console.log('\x1b[1mSandbox Configuration\x1b[0m');
+  console.log('\x1b[2mEnter paths where the AI can access files (comma-separated):\x1b[0m');
+
+  const pathsInput = await input({
+    message: 'Allowed paths:',
+    default: currentPaths.join(', '),
+  });
+
+  const allowedPaths = pathsInput
+    .split(',')
+    .map((p) => p.trim())
+    .filter(Boolean);
+
+  config.hooks.sandboxed = { allowedPaths };
+}
+
+/**
+ * Configure audited preset log path
+ */
+async function configureAudit(config: GenieConfig): Promise<void> {
+  const currentPath = config.hooks.audited?.logPath || '~/.genie/audit.log';
+
+  console.log('\x1b[1mAudit Configuration\x1b[0m');
+
+  const logPath = await input({
+    message: 'Audit log path:',
+    default: currentPath,
+  });
+
+  config.hooks.audited = { logPath };
+}
+
+/**
+ * Main setup wizard
+ */
+export async function setupCommand(): Promise<void> {
+  printHeader();
+  printAboutHooks();
+  printPresetDescriptions();
+
+  // Load existing config or defaults
+  const config = await loadGenieConfig();
+  const existingPresets = new Set(config.hooks.enabled);
+
+  // If config exists, show current state
+  if (genieConfigExists()) {
+    console.log('\x1b[1m📋 CURRENT CONFIGURATION\x1b[0m');
+    printCurrentConfig(config);
+  }
+
+  // Build choices for checkbox
+  const choices = PRESET_DESCRIPTIONS.map((preset) =>
+    formatPresetChoice(preset, existingPresets.has(preset.name))
+  );
+
+  // Prompt for preset selection
+  const selectedPresets = await checkbox<PresetName>({
+    message: 'Select hooks to enable (space to toggle, enter to confirm):',
+    choices,
+  });
+
+  // Update config with selections
+  config.hooks.enabled = selectedPresets;
+
+  // If sandboxed is enabled, configure it
+  if (selectedPresets.includes('sandboxed')) {
+    console.log();
+    await configureSandbox(config);
+  }
+
+  // If audited is enabled, optionally configure it
+  if (selectedPresets.includes('audited')) {
+    console.log();
+    const customAudit = await confirm({
+      message: 'Customize audit log path?',
+      default: false,
+    });
+    if (customAudit) {
+      await configureAudit(config);
+    }
+  }
+
+  // Save configuration
+  await saveGenieConfig(config);
+
+  printSuccess(getGenieConfigPath());
+
+  // Show what was configured
+  if (selectedPresets.length > 0) {
+    console.log('\x1b[1mEnabled hooks:\x1b[0m');
+    const descriptions = describeEnabledHooks(config);
+    for (const desc of descriptions) {
+      console.log(`  \x1b[32m✓\x1b[0m ${desc}`);
+    }
+    console.log();
+  }
+
+  // Offer to install tmux shortcuts
+  await offerShortcutsInstall();
+}
+
+/**
+ * Offer to install tmux keyboard shortcuts
+ */
+async function offerShortcutsInstall(): Promise<void> {
+  // Check if already installed
+  const home = homedir();
+  const tmuxConf = join(home, '.tmux.conf');
+
+  if (isShortcutsInstalled(tmuxConf)) {
+    console.log('\x1b[2m✓ Tmux shortcuts already installed\x1b[0m');
+    console.log();
+    return;
+  }
+
+  console.log('\x1b[2m' + '─'.repeat(64) + '\x1b[0m');
+  console.log();
+  console.log('\x1b[1m⌨️  KEYBOARD SHORTCUTS\x1b[0m');
+  console.log('\x1b[2mOptional: Install Warp-like tmux shortcuts for quick navigation:\x1b[0m');
+  console.log('  • Ctrl+T → New tab (window)');
+  console.log('  • Ctrl+S → Vertical split');
+  console.log('  • Alt+S  → Horizontal split');
+  console.log();
+
+  const installShortcutsChoice = await confirm({
+    message: 'Install tmux keyboard shortcuts?',
+    default: false,
+  });
+
+  if (installShortcutsChoice) {
+    console.log();
+    await installShortcuts();
+  } else {
+    console.log();
+    console.log('\x1b[2mSkipped. Run \x1b[0m\x1b[36mgenie shortcuts install\x1b[0m\x1b[2m later to add them.\x1b[0m');
+    console.log();
+  }
+}
+
+/**
+ * Quick setup with recommended defaults
+ */
+export async function quickSetupCommand(): Promise<void> {
+  console.log('\x1b[1m🧞 Quick Setup - Using recommended defaults\x1b[0m');
+  console.log();
+
+  const config = await loadGenieConfig();
+
+  // Enable recommended presets
+  config.hooks.enabled = ['collaborative', 'audited'];
+
+  await saveGenieConfig(config);
+
+  console.log('\x1b[32m✓ Enabled:\x1b[0m collaborative, audited');
+  console.log();
+  console.log('Run \x1b[36mgenie setup\x1b[0m to customize further.');
+  console.log();
+}
+

package/src/genie-commands/shortcuts.ts

@@ -0,0 +1,62 @@
+/**
+ * Genie Shortcuts Commands
+ *
+ * Commands to install, uninstall, and show keyboard shortcuts.
+ */
+
+import {
+  displayShortcuts,
+  installShortcuts,
+  uninstallShortcuts,
+  isShortcutsInstalled,
+} from '../term-commands/shortcuts.js';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Show shortcuts info (default action)
+ */
+export async function shortcutsShowCommand(): Promise<void> {
+  displayShortcuts();
+
+  // Also show installation status
+  const home = homedir();
+  const tmuxConf = join(home, '.tmux.conf');
+  const zshrc = join(home, '.zshrc');
+  const bashrc = join(home, '.bashrc');
+
+  console.log('Installation status:');
+
+  if (isShortcutsInstalled(tmuxConf)) {
+    console.log('  \x1b[32m✓\x1b[0m tmux.conf');
+  } else {
+    console.log('  \x1b[33m-\x1b[0m tmux.conf');
+  }
+
+  const shellRc = existsSync(zshrc) ? zshrc : bashrc;
+  if (isShortcutsInstalled(shellRc)) {
+    console.log(`  \x1b[32m✓\x1b[0m ${shellRc.replace(home, '~')}`);
+  } else {
+    console.log(`  \x1b[33m-\x1b[0m ${shellRc.replace(home, '~')}`);
+  }
+
+  console.log();
+  console.log('Run \x1b[36mgenie shortcuts install\x1b[0m to install shortcuts.');
+  console.log('Run \x1b[36mgenie shortcuts uninstall\x1b[0m to remove shortcuts.');
+  console.log();
+}
+
+/**
+ * Install shortcuts to config files
+ */
+export async function shortcutsInstallCommand(): Promise<void> {
+  await installShortcuts();
+}
+
+/**
+ * Uninstall shortcuts from config files
+ */
+export async function shortcutsUninstallCommand(): Promise<void> {
+  await uninstallShortcuts();
+}

package/src/genie-commands/update.ts

@@ -0,0 +1,228 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { mkdir, copyFile, chmod } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const GENIE_HOME = process.env.GENIE_HOME || join(homedir(), '.genie');
+const GENIE_SRC = join(GENIE_HOME, 'src');
+const GENIE_BIN = join(GENIE_HOME, 'bin');
+const LOCAL_BIN = join(homedir(), '.local', 'bin');
+
+function log(message: string): void {
+  console.log(`\x1b[32m▸\x1b[0m ${message}`);
+}
+
+function success(message: string): void {
+  console.log(`\x1b[32m✔\x1b[0m ${message}`);
+}
+
+function error(message: string): void {
+  console.log(`\x1b[31m✖\x1b[0m ${message}`);
+}
+
+function warn(message: string): void {
+  console.log(`\x1b[33m⚠\x1b[0m ${message}`);
+}
+
+async function runCommand(command: string, args: string[], cwd?: string): Promise<{ success: boolean; output: string }> {
+  return new Promise((resolve) => {
+    const output: string[] = [];
+
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ['inherit', 'pipe', 'pipe'],
+      env: { ...process.env, FORCE_COLOR: '1' },
+    });
+
+    child.stdout?.on('data', (data) => {
+      const str = data.toString();
+      output.push(str);
+      process.stdout.write(str);
+    });
+
+    child.stderr?.on('data', (data) => {
+      const str = data.toString();
+      output.push(str);
+      process.stderr.write(str);
+    });
+
+    child.on('close', (code) => {
+      resolve({ success: code === 0, output: output.join('') });
+    });
+
+    child.on('error', (err) => {
+      error(err.message);
+      resolve({ success: false, output: err.message });
+    });
+  });
+}
+
+async function getGitInfo(cwd: string): Promise<{ branch: string; commit: string; commitDate: string } | null> {
+  try {
+    const branchResult = await runCommandSilent('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const commitResult = await runCommandSilent('git', ['rev-parse', '--short', 'HEAD'], cwd);
+    const dateResult = await runCommandSilent('git', ['log', '-1', '--format=%ci'], cwd);
+
+    if (branchResult.success && commitResult.success && dateResult.success) {
+      return {
+        branch: branchResult.output.trim(),
+        commit: commitResult.output.trim(),
+        commitDate: dateResult.output.trim().split(' ')[0], // Just the date part
+      };
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+async function runCommandSilent(command: string, args: string[], cwd?: string): Promise<{ success: boolean; output: string }> {
+  return new Promise((resolve) => {
+    const output: string[] = [];
+
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    child.stdout?.on('data', (data) => {
+      output.push(data.toString());
+    });
+
+    child.stderr?.on('data', (data) => {
+      output.push(data.toString());
+    });
+
+    child.on('close', (code) => {
+      resolve({ success: code === 0, output: output.join('') });
+    });
+
+    child.on('error', (err) => {
+      resolve({ success: false, output: err.message });
+    });
+  });
+}
+
+async function symlinkOrCopy(src: string, dest: string): Promise<void> {
+  const { symlink, unlink } = await import('fs/promises');
+
+  try {
+    // Remove existing symlink/file if present
+    if (existsSync(dest)) {
+      await unlink(dest);
+    }
+    await symlink(src, dest);
+  } catch {
+    // Fallback to copy if symlink fails
+    await copyFile(src, dest);
+  }
+}
+
+export async function updateCommand(): Promise<void> {
+  console.log();
+  console.log('\x1b[1m🧞 Genie CLI Update\x1b[0m');
+  console.log('\x1b[2m────────────────────────────────────\x1b[0m');
+  console.log();
+
+  // Check if installed via install.sh (has ~/.genie/src)
+  if (!existsSync(GENIE_SRC) || !existsSync(join(GENIE_SRC, '.git'))) {
+    error('Genie CLI was not installed via install.sh');
+    console.log();
+    console.log('To install Genie CLI properly, run:');
+    console.log('\x1b[36m  curl -fsSL https://raw.githubusercontent.com/namastexlabs/genie-cli/main/install.sh | bash\x1b[0m');
+    console.log();
+    process.exit(1);
+  }
+
+  // Get current version info before update
+  const beforeInfo = await getGitInfo(GENIE_SRC);
+  if (beforeInfo) {
+    console.log(`Current: \x1b[2m${beforeInfo.branch}@${beforeInfo.commit} (${beforeInfo.commitDate})\x1b[0m`);
+    console.log();
+  }
+
+  // Step 1: Fetch and reset to origin/main
+  log('Fetching latest changes...');
+  const fetchResult = await runCommand('git', ['fetch', 'origin'], GENIE_SRC);
+  if (!fetchResult.success) {
+    error('Failed to fetch from origin');
+    process.exit(1);
+  }
+
+  log('Resetting to origin/main...');
+  const resetResult = await runCommand('git', ['reset', '--hard', 'origin/main'], GENIE_SRC);
+  if (!resetResult.success) {
+    error('Failed to reset to origin/main');
+    process.exit(1);
+  }
+  console.log();
+
+  // Get new version info
+  const afterInfo = await getGitInfo(GENIE_SRC);
+
+  // Check if anything changed
+  if (beforeInfo && afterInfo && beforeInfo.commit === afterInfo.commit) {
+    success('Already up to date!');
+    console.log();
+    return;
+  }
+
+  // Step 2: Install dependencies
+  log('Installing dependencies...');
+  const installResult = await runCommand('bun', ['install'], GENIE_SRC);
+  if (!installResult.success) {
+    error('Failed to install dependencies');
+    process.exit(1);
+  }
+  console.log();
+
+  // Step 3: Build
+  log('Building...');
+  const buildResult = await runCommand('bun', ['run', 'build'], GENIE_SRC);
+  if (!buildResult.success) {
+    error('Failed to build');
+    process.exit(1);
+  }
+  console.log();
+
+  // Step 4: Copy binaries and update symlinks
+  log('Installing binaries...');
+
+  try {
+    await mkdir(GENIE_BIN, { recursive: true });
+    await mkdir(LOCAL_BIN, { recursive: true });
+
+    const binaries = ['genie.js', 'term.js', 'claudio.js'];
+    const names = ['genie', 'term', 'claudio'];
+
+    for (let i = 0; i < binaries.length; i++) {
+      const src = join(GENIE_SRC, 'dist', binaries[i]);
+      const binDest = join(GENIE_BIN, binaries[i]);
+      const linkDest = join(LOCAL_BIN, names[i]);
+
+      // Copy to GENIE_BIN
+      await copyFile(src, binDest);
+      await chmod(binDest, 0o755);
+
+      // Symlink to LOCAL_BIN
+      await symlinkOrCopy(binDest, linkDest);
+    }
+
+    success('Binaries installed');
+  } catch (err) {
+    error(`Failed to install binaries: ${err}`);
+    process.exit(1);
+  }
+
+  // Print success
+  console.log();
+  console.log('\x1b[2m────────────────────────────────────\x1b[0m');
+  success('Genie CLI updated successfully!');
+  console.log();
+
+  if (afterInfo) {
+    console.log(`Version: \x1b[36m${afterInfo.branch}@${afterInfo.commit}\x1b[0m (${afterInfo.commitDate})`);
+    console.log();
+  }
+}

package/src/genie.ts

@@ -0,0 +1,106 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander';
+import { installCommand } from './genie-commands/install.js';
+import { setupCommand, quickSetupCommand } from './genie-commands/setup.js';
+import { updateCommand } from './genie-commands/update.js';
+import {
+  showHooksCommand,
+  installHooksCommand,
+  uninstallHooksCommand,
+  testHooksCommand,
+} from './genie-commands/hooks.js';
+import {
+  shortcutsShowCommand,
+  shortcutsInstallCommand,
+  shortcutsUninstallCommand,
+} from './genie-commands/shortcuts.js';
+
+const program = new Command();
+
+program
+  .name('genie')
+  .description('Genie CLI - Setup and utilities for AI-assisted development')
+  .version('0.1.0');
+
+// Install command - check/install prerequisites
+program
+  .command('install')
+  .description('Verify and install prerequisites')
+  .option('--check', 'Only check prerequisites, do not install')
+  .option('--yes', 'Auto-approve all installations')
+  .action(installCommand);
+
+// Setup command - interactive hook configuration
+program
+  .command('setup')
+  .description('Configure hooks and settings (interactive wizard)')
+  .option('--quick', 'Use recommended defaults without prompts')
+  .action(async (options) => {
+    if (options.quick) {
+      await quickSetupCommand();
+    } else {
+      await setupCommand();
+    }
+  });
+
+// Update command - pull latest and rebuild
+program
+  .command('update')
+  .description('Update Genie CLI to the latest version')
+  .action(updateCommand);
+
+// Hooks command group - manage Claude Code hooks
+const hooks = program
+  .command('hooks')
+  .description('Manage Claude Code hooks');
+
+// Make 'show' the default action for bare `genie hooks`
+hooks.action(showHooksCommand);
+
+hooks
+  .command('show')
+  .description('Show current hook configuration')
+  .action(showHooksCommand);
+
+hooks
+  .command('install')
+  .description('Install hooks into Claude Code')
+  .option('--force', 'Overwrite existing hooks')
+  .action(installHooksCommand);
+
+hooks
+  .command('uninstall')
+  .description('Remove hooks from Claude Code')
+  .option('--keep-script', 'Keep the hook script file')
+  .action(uninstallHooksCommand);
+
+hooks
+  .command('test')
+  .description('Test the hook script')
+  .action(testHooksCommand);
+
+// Shortcuts command group - manage tmux keyboard shortcuts
+const shortcuts = program
+  .command('shortcuts')
+  .description('Manage tmux keyboard shortcuts');
+
+// Make 'show' the default action for bare `genie shortcuts`
+shortcuts.action(shortcutsShowCommand);
+
+shortcuts
+  .command('show')
+  .description('Show available shortcuts and installation status')
+  .action(shortcutsShowCommand);
+
+shortcuts
+  .command('install')
+  .description('Install shortcuts to config files (~/.tmux.conf, shell rc)')
+  .action(shortcutsInstallCommand);
+
+shortcuts
+  .command('uninstall')
+  .description('Remove shortcuts from config files')
+  .action(shortcutsUninstallCommand);
+
+program.parse();