@automagik/genie 0.260202.453 → 0.260202.1607

package/src/genie-commands/uninstall.ts

@@ -0,0 +1,176 @@
+/**
+ * Genie Uninstall Command
+ *
+ * Removes Genie CLI entirely:
+ * - Remove hooks from Claude Code (migration cleanup)
+ * - Delete ~/.genie directory
+ * - Remove symlinks from ~/.local/bin
+ */
+
+import { confirm } from '@inquirer/prompts';
+import { existsSync, rmSync, unlinkSync, lstatSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import {
+  loadClaudeSettings,
+  saveClaudeSettings,
+  isGenieHookInstalled,
+  removeGenieHook,
+  hookScriptExists,
+  removeHookScript,
+} from '../lib/claude-settings.js';
+import { getGenieDir, contractPath } from '../lib/genie-config.js';
+
+const LOCAL_BIN = join(homedir(), '.local', 'bin');
+
+// Symlinks that may have been created by source install
+const SYMLINKS = ['genie', 'term', 'claudio'];
+
+/**
+ * Check if a path is a symlink pointing to genie bin
+ */
+function isGenieSymlink(path: string): boolean {
+  try {
+    if (!existsSync(path)) return false;
+    const stat = lstatSync(path);
+    if (!stat.isSymbolicLink()) return false;
+    // We don't need to check target - if it's our binary name, remove it
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove genie symlinks from ~/.local/bin
+ */
+function removeSymlinks(): string[] {
+  const removed: string[] = [];
+
+  for (const name of SYMLINKS) {
+    const symlinkPath = join(LOCAL_BIN, name);
+    if (isGenieSymlink(symlinkPath)) {
+      try {
+        unlinkSync(symlinkPath);
+        removed.push(name);
+      } catch {
+        // Ignore errors - may not have permission
+      }
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * Uninstall Genie CLI entirely
+ */
+export async function uninstallCommand(): Promise<void> {
+  console.log();
+  console.log('\x1b[1m\x1b[33m Uninstall Genie CLI\x1b[0m');
+  console.log();
+
+  const genieDir = getGenieDir();
+  const hasGenieDir = existsSync(genieDir);
+  const hasHookScript = hookScriptExists();
+
+  // Check what will be removed
+  const settings = await loadClaudeSettings();
+  const hasHookRegistered = isGenieHookInstalled(settings);
+
+  // Count symlinks
+  const existingSymlinks = SYMLINKS.filter((name) =>
+    isGenieSymlink(join(LOCAL_BIN, name))
+  );
+
+  // Show what will be removed
+  console.log('\x1b[2mThis will remove:\x1b[0m');
+  if (hasHookRegistered) {
+    console.log('  \x1b[31m-\x1b[0m Hook registration from Claude Code');
+  }
+  if (hasHookScript) {
+    console.log('  \x1b[31m-\x1b[0m Hook script (~/.claude/hooks/genie-bash-hook.sh)');
+  }
+  if (hasGenieDir) {
+    console.log('  \x1b[31m-\x1b[0m Genie directory (' + contractPath(genieDir) + ')');
+  }
+  if (existingSymlinks.length > 0) {
+    console.log('  \x1b[31m-\x1b[0m Symlinks from ~/.local/bin: ' + existingSymlinks.join(', '));
+  }
+  console.log();
+
+  if (!hasGenieDir && !hasHookScript && !hasHookRegistered && existingSymlinks.length === 0) {
+    console.log('\x1b[33mNothing to uninstall.\x1b[0m');
+    console.log();
+    return;
+  }
+
+  // Confirm with user
+  const proceed = await confirm({
+    message: 'Are you sure you want to uninstall Genie CLI?',
+    default: false,
+  });
+
+  if (!proceed) {
+    console.log();
+    console.log('\x1b[2mUninstall cancelled.\x1b[0m');
+    console.log();
+    return;
+  }
+
+  console.log();
+
+  // 1. Remove hooks from Claude Code
+  if (hasHookRegistered) {
+    console.log('\x1b[2mRemoving hook from Claude Code...\x1b[0m');
+    try {
+      const updatedSettings = removeGenieHook(settings);
+      await saveClaudeSettings(updatedSettings);
+      console.log('  \x1b[32m+\x1b[0m Hook unregistered');
+    } catch (error: any) {
+      console.log('  \x1b[33m!\x1b[0m Could not unregister hook: ' + error.message);
+    }
+  }
+
+  // 2. Remove hook script
+  if (hasHookScript) {
+    console.log('\x1b[2mRemoving hook script...\x1b[0m');
+    try {
+      removeHookScript();
+      console.log('  \x1b[32m+\x1b[0m Hook script removed');
+    } catch (error: any) {
+      console.log('  \x1b[33m!\x1b[0m Could not remove hook script: ' + error.message);
+    }
+  }
+
+  // 3. Remove symlinks
+  if (existingSymlinks.length > 0) {
+    console.log('\x1b[2mRemoving symlinks...\x1b[0m');
+    const removed = removeSymlinks();
+    if (removed.length > 0) {
+      console.log('  \x1b[32m+\x1b[0m Removed: ' + removed.join(', '));
+    }
+  }
+
+  // 4. Delete ~/.genie directory
+  if (hasGenieDir) {
+    console.log('\x1b[2mRemoving genie directory...\x1b[0m');
+    try {
+      rmSync(genieDir, { recursive: true, force: true });
+      console.log('  \x1b[32m+\x1b[0m Directory removed');
+    } catch (error: any) {
+      console.log('  \x1b[33m!\x1b[0m Could not remove directory: ' + error.message);
+    }
+  }
+
+  console.log();
+  console.log('\x1b[32m+\x1b[0m Genie CLI uninstalled.');
+  console.log();
+
+  // Note about npm/bun global package
+  console.log('\x1b[2mNote: If you installed via npm/bun, also run:\x1b[0m');
+  console.log('  \x1b[36mbun remove -g @automagik/genie\x1b[0m');
+  console.log('  \x1b[2mor\x1b[0m');
+  console.log('  \x1b[36mnpm uninstall -g @automagik/genie\x1b[0m');
+  console.log();
+}

package/src/genie.ts

@@ -3,14 +3,10 @@
 import { Command } from 'commander';
 import { VERSION } from './lib/version.js';
 import { installCommand } from './genie-commands/install.js';
-import { setupCommand, quickSetupCommand } from './genie-commands/setup.js';
+import { setupCommand, type SetupOptions } from './genie-commands/setup.js';
 import { updateCommand } from './genie-commands/update.js';
-import {
-  showHooksCommand,
-  installHooksCommand,
-  uninstallHooksCommand,
-  testHooksCommand,
-} from './genie-commands/hooks.js';
+import { uninstallCommand } from './genie-commands/uninstall.js';
+import { doctorCommand } from './genie-commands/doctor.js';
 import {
   shortcutsShowCommand,
   shortcutsInstallCommand,
@@ -32,54 +28,38 @@ program
   .option('--yes', 'Auto-approve all installations')
   .action(installCommand);
 
-// Setup command - interactive hook configuration
+// Setup command - configure genie settings
 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();
-    }
+  .description('Configure genie settings')
+  .option('--quick', 'Accept all defaults')
+  .option('--shortcuts', 'Only configure keyboard shortcuts')
+  .option('--claudio', 'Only configure Claudio integration')
+  .option('--terminal', 'Only configure terminal defaults')
+  .option('--session', 'Only configure session settings')
+  .option('--reset', 'Reset configuration to defaults')
+  .option('--show', 'Show current configuration')
+  .action(async (options: SetupOptions) => {
+    await setupCommand(options);
   });
 
+// Doctor command - diagnostic checks
+program
+  .command('doctor')
+  .description('Run diagnostic checks on genie installation')
+  .action(doctorCommand);
+
 // 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
+// Uninstall command - remove genie CLI
+program
   .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);
+  .description('Remove Genie CLI and clean up hooks')
+  .action(uninstallCommand);
 
 // Shortcuts command group - manage tmux keyboard shortcuts
 const shortcuts = program

package/src/lib/claude-settings.ts

@@ -5,7 +5,7 @@
  * Uses Zod with passthrough() to preserve unknown fields.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { z } from 'zod';
@@ -43,7 +43,7 @@ const ClaudeSettingsSchema = z.object({
 
 export type ClaudeSettings = z.infer<typeof ClaudeSettingsSchema>;
 
-// Constants for the genie hook
+// Constants for the genie hook (used for migration/cleanup)
 export const GENIE_HOOK_SCRIPT_NAME = 'genie-bash-hook.sh';
 export const GENIE_HOOK_MATCHER = 'Bash';
 
@@ -69,7 +69,7 @@ export function getClaudeSettingsPath(): string {
 }
 
 /**
- * Get the path to the genie hook script
+ * Get the path to the genie hook script (for cleanup)
  */
 export function getGenieHookScriptPath(): string {
   return join(CLAUDE_HOOKS_DIR, GENIE_HOOK_SCRIPT_NAME);
@@ -91,16 +91,6 @@ export function ensureClaudeDir(): void {
   }
 }
 
-/**
- * Ensure the Claude hooks directory exists
- */
-export function ensureClaudeHooksDir(): void {
-  ensureClaudeDir();
-  if (!existsSync(CLAUDE_HOOKS_DIR)) {
-    mkdirSync(CLAUDE_HOOKS_DIR, { recursive: true });
-  }
-}
-
 /**
  * Load Claude settings, returning defaults if not found
  */
@@ -136,23 +126,7 @@ export async function saveClaudeSettings(settings: ClaudeSettings): Promise<void
 }
 
 /**
- * Create the genie hook entry for Claude settings
- */
-function createGenieHookEntry(scriptPath: string): z.infer<typeof MatcherHooksSchema> {
-  return {
-    matcher: GENIE_HOOK_MATCHER,
-    hooks: [
-      {
-        type: 'command',
-        command: scriptPath,
-        timeout: 600,
-      },
-    ],
-  };
-}
-
-/**
- * Check if the genie hook is installed in the settings
+ * Check if the genie hook is installed in the settings (for migration cleanup)
  */
 export function isGenieHookInstalled(settings: ClaudeSettings): boolean {
   const preToolUse = settings.hooks?.PreToolUse;
@@ -170,40 +144,7 @@ export function isGenieHookInstalled(settings: ClaudeSettings): boolean {
 }
 
 /**
- * Add the genie hook to Claude settings
- * Returns the modified settings (does not save to disk)
- */
-export function addGenieHook(settings: ClaudeSettings): ClaudeSettings {
-  const scriptPath = getGenieHookScriptPath();
-  const hookEntry = createGenieHookEntry(scriptPath);
-
-  // Initialize hooks structure if needed
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.PreToolUse) {
-    settings.hooks.PreToolUse = [];
-  }
-
-  // Check if already installed
-  if (isGenieHookInstalled(settings)) {
-    return settings;
-  }
-
-  // Remove any existing Bash matcher entries that might conflict
-  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
-    (entry) => !(entry.matcher === GENIE_HOOK_MATCHER &&
-      entry.hooks?.some((h) => h.command?.includes('genie')))
-  );
-
-  // Add the new hook entry
-  settings.hooks.PreToolUse.push(hookEntry);
-
-  return settings;
-}
-
-/**
- * Remove the genie hook from Claude settings
+ * Remove the genie hook from Claude settings (for migration cleanup)
  * Returns the modified settings (does not save to disk)
  */
 export function removeGenieHook(settings: ClaudeSettings): ClaudeSettings {
@@ -237,6 +178,23 @@ export function removeGenieHook(settings: ClaudeSettings): ClaudeSettings {
   return settings;
 }
 
+/**
+ * Check if hook script exists (for cleanup)
+ */
+export function hookScriptExists(): boolean {
+  return existsSync(getGenieHookScriptPath());
+}
+
+/**
+ * Remove the hook script file (for cleanup)
+ */
+export function removeHookScript(): void {
+  const scriptPath = getGenieHookScriptPath();
+  if (existsSync(scriptPath)) {
+    unlinkSync(scriptPath);
+  }
+}
+
 /**
  * Contract home directory to ~ in a path (for display)
  */

package/src/lib/genie-config.ts

@@ -4,13 +4,16 @@ import { join } from 'path';
 import {
   GenieConfig,
   GenieConfigSchema,
-  HooksConfig,
+  GenieConfigV1Schema,
   LoggingConfig,
-  PresetName,
+  TerminalConfig,
+  SessionConfig,
+  ShortcutsConfig,
 } from '../types/genie-config.js';
 
 const GENIE_DIR = join(homedir(), '.genie');
 const GENIE_CONFIG_FILE = join(GENIE_DIR, 'config.json');
+const CONFIG_VERSION = 2;
 
 /**
  * Get the path to the genie config directory
@@ -42,21 +45,70 @@ export function ensureGenieDir(): void {
   }
 }
 
+/**
+ * Migrate v1 config to v2 format
+ */
+export function migrateConfig(oldConfig: unknown): GenieConfig {
+  // Try parsing as v1 config
+  const v1Result = GenieConfigV1Schema.safeParse(oldConfig);
+
+  if (v1Result.success) {
+    const v1 = v1Result.data;
+    return GenieConfigSchema.parse({
+      version: CONFIG_VERSION,
+      session: {
+        name: v1.session.name,
+        defaultWindow: v1.session.defaultWindow,
+        autoCreate: true,
+      },
+      terminal: {
+        execTimeout: 120000,
+        readLines: 100,
+        worktreeBase: '.worktrees',
+      },
+      logging: {
+        tmuxDebug: v1.logging.tmuxDebug,
+        verbose: false,
+      },
+      shell: {
+        preference: 'auto',
+      },
+      shortcuts: {
+        tmuxInstalled: false,
+        shellInstalled: false,
+      },
+      installMethod: v1.installMethod,
+      setupComplete: false,
+    });
+  }
+
+  // If not valid v1, return default config
+  return GenieConfigSchema.parse({});
+}
+
 /**
  * Load genie config, returning defaults if not found
+ * Automatically migrates v1 configs to v2
  */
 export async function loadGenieConfig(): Promise<GenieConfig> {
   if (!existsSync(GENIE_CONFIG_FILE)) {
-    // Return default config
     return GenieConfigSchema.parse({});
   }
 
   try {
     const content = readFileSync(GENIE_CONFIG_FILE, 'utf-8');
     const data = JSON.parse(content);
+
+    // Check if migration is needed (no version or version < 2)
+    if (!data.version || data.version < CONFIG_VERSION) {
+      const migrated = migrateConfig(data);
+      // Save migrated config
+      await saveGenieConfig(migrated);
+      return migrated;
+    }
+
     return GenieConfigSchema.parse(data);
   } catch (error: any) {
-    // If config is invalid, return defaults
     console.warn(`Warning: Invalid genie config, using defaults: ${error.message}`);
     return GenieConfigSchema.parse({});
   }
@@ -84,59 +136,6 @@ export function getDefaultGenieConfig(): GenieConfig {
   return GenieConfigSchema.parse({});
 }
 
-/**
- * Check if a hook preset is enabled
- */
-export function isPresetEnabled(config: GenieConfig, preset: PresetName): boolean {
-  return config.hooks.enabled.includes(preset);
-}
-
-/**
- * Enable a hook preset
- */
-export async function enablePreset(preset: PresetName): Promise<void> {
-  const config = await loadGenieConfig();
-  if (!config.hooks.enabled.includes(preset)) {
-    config.hooks.enabled.push(preset);
-    await saveGenieConfig(config);
-  }
-}
-
-/**
- * Disable a hook preset
- */
-export async function disablePreset(preset: PresetName): Promise<void> {
-  const config = await loadGenieConfig();
-  config.hooks.enabled = config.hooks.enabled.filter((p) => p !== preset);
-  await saveGenieConfig(config);
-}
-
-/**
- * Get enabled presets
- */
-export async function getEnabledPresets(): Promise<PresetName[]> {
-  const config = await loadGenieConfig();
-  return config.hooks.enabled;
-}
-
-/**
- * Set enabled presets (replaces all)
- */
-export async function setEnabledPresets(presets: PresetName[]): Promise<void> {
-  const config = await loadGenieConfig();
-  config.hooks.enabled = presets;
-  await saveGenieConfig(config);
-}
-
-/**
- * Update hooks configuration
- */
-export async function updateHooksConfig(hooks: Partial<HooksConfig>): Promise<void> {
-  const config = await loadGenieConfig();
-  config.hooks = { ...config.hooks, ...hooks };
-  await saveGenieConfig(config);
-}
-
 /**
  * Update logging configuration
  */
@@ -157,6 +156,12 @@ export function loadGenieConfigSync(): GenieConfig {
   try {
     const content = readFileSync(GENIE_CONFIG_FILE, 'utf-8');
     const data = JSON.parse(content);
+
+    // Check if migration is needed
+    if (!data.version || data.version < CONFIG_VERSION) {
+      return migrateConfig(data);
+    }
+
     return GenieConfigSchema.parse(data);
   } catch {
     return GenieConfigSchema.parse({});
@@ -199,3 +204,110 @@ export function contractPath(path: string): string {
   }
   return path;
 }
+
+// ============================================================================
+// New helper functions for v2 config
+// ============================================================================
+
+/**
+ * Get terminal configuration
+ */
+export function getTerminalConfig(): TerminalConfig {
+  const config = loadGenieConfigSync();
+  return config.terminal;
+}
+
+/**
+ * Update terminal configuration
+ */
+export async function updateTerminalConfig(partial: Partial<TerminalConfig>): Promise<void> {
+  const config = await loadGenieConfig();
+  config.terminal = { ...config.terminal, ...partial };
+  await saveGenieConfig(config);
+}
+
+/**
+ * Get session name from config
+ */
+export function getSessionName(): string {
+  const config = loadGenieConfigSync();
+  return config.session.name;
+}
+
+/**
+ * Get session configuration
+ */
+export function getSessionConfig(): SessionConfig {
+  const config = loadGenieConfigSync();
+  return config.session;
+}
+
+/**
+ * Update session configuration
+ */
+export async function updateSessionConfig(partial: Partial<SessionConfig>): Promise<void> {
+  const config = await loadGenieConfig();
+  config.session = { ...config.session, ...partial };
+  await saveGenieConfig(config);
+}
+
+/**
+ * Check if setup has been completed
+ */
+export function isSetupComplete(): boolean {
+  if (!genieConfigExists()) return false;
+  const config = loadGenieConfigSync();
+  return config.setupComplete ?? false;
+}
+
+/**
+ * Mark setup as complete
+ */
+export async function markSetupComplete(): Promise<void> {
+  const config = await loadGenieConfig();
+  config.setupComplete = true;
+  config.lastSetupAt = new Date().toISOString();
+  await saveGenieConfig(config);
+}
+
+/**
+ * Reset config to defaults
+ */
+export async function resetConfig(): Promise<void> {
+  const defaultConfig = getDefaultGenieConfig();
+  await saveGenieConfig(defaultConfig);
+}
+
+/**
+ * Get shortcuts configuration
+ */
+export function getShortcutsConfig(): ShortcutsConfig {
+  const config = loadGenieConfigSync();
+  return config.shortcuts;
+}
+
+/**
+ * Update shortcuts configuration
+ */
+export async function updateShortcutsConfig(partial: Partial<ShortcutsConfig>): Promise<void> {
+  const config = await loadGenieConfig();
+  config.shortcuts = { ...config.shortcuts, ...partial };
+  await saveGenieConfig(config);
+}
+
+/**
+ * Check if claudio integration is enabled
+ */
+export function isClaudioEnabled(): boolean {
+  const config = loadGenieConfigSync();
+  return config.claudio?.enabled ?? false;
+}
+
+/**
+ * Update claudio configuration
+ */
+export async function updateClaudioConfig(enabled: boolean): Promise<void> {
+  const config = await loadGenieConfig();
+  config.claudio = { enabled };
+  await saveGenieConfig(config);
+}

package/src/lib/version.ts

@@ -1,5 +1,5 @@
 // Runtime version (baked in at build time)
-export const VERSION = '0.260202.0453';
+export const VERSION = '0.260202.1607';
 
 // Generate version string from current datetime
 // Format: 0.YYMMDD.HHMM (e.g., 0.260201.1430 = Feb 1, 2026 at 14:30)