@automagik/genie 0.260202.530 → 0.260202.1607

package/install.sh

@@ -903,13 +903,49 @@ ensure_path() {
 }
 
 run_setup() {
-    # Run genie setup if available
-    if check_command genie; then
-        log "Running genie setup..."
-        genie setup --quick 2>/dev/null || true
-    elif [[ -x "$GENIE_BIN/genie.js" ]]; then
-        log "Running genie setup..."
-        "$GENIE_BIN/genie.js" setup --quick 2>/dev/null || true
+    # Skip for updates
+    if [[ "$INSTALL_MODE" == "update" ]]; then
+        return 0
+    fi
+
+    # Check if already configured
+    if [[ -f "$GENIE_HOME/config.json" ]]; then
+        local complete
+        if check_command jq; then
+            complete=$(jq -r '.setupComplete // false' "$GENIE_HOME/config.json" 2>/dev/null)
+        else
+            # Fallback: simple grep check
+            if grep -q '"setupComplete"[[:space:]]*:[[:space:]]*true' "$GENIE_HOME/config.json" 2>/dev/null; then
+                complete="true"
+            else
+                complete="false"
+            fi
+        fi
+        if [[ "$complete" == "true" ]]; then
+            log "Setup already complete, skipping"
+            return 0
+        fi
+    fi
+
+    # Run setup
+    if [[ "$AUTO_YES" == true ]]; then
+        if check_command genie; then
+            log "Running genie setup (quick mode)..."
+            genie setup --quick 2>/dev/null || true
+        elif [[ -x "$GENIE_BIN/genie.js" ]]; then
+            log "Running genie setup (quick mode)..."
+            "$GENIE_BIN/genie.js" setup --quick 2>/dev/null || true
+        fi
+    else
+        if confirm "Run genie setup now?"; then
+            if check_command genie; then
+                genie setup
+            elif [[ -x "$GENIE_BIN/genie.js" ]]; then
+                "$GENIE_BIN/genie.js" setup
+            fi
+        else
+            info "Skipped. Run 'genie setup' later to configure."
+        fi
     fi
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/genie",
-  "version": "0.260202.0530",
+  "version": "0.260202.1607",
   "description": "Collaborative terminal toolkit for human + AI workflows",
   "type": "module",
   "bin": {

package/src/claudio.ts

@@ -13,14 +13,29 @@ import {
 } from './commands/profiles.js';
 import { modelsCommand, configCommand } from './commands/models.js';
 
+// Extract Claude passthrough args (everything after --)
+// Must be done before Commander parses argv
+const separatorIndex = process.argv.indexOf('--');
+const claudePassthroughArgs: string[] = separatorIndex !== -1
+  ? process.argv.slice(separatorIndex + 1)
+  : [];
+const claudioArgs = separatorIndex !== -1
+  ? process.argv.slice(0, separatorIndex)
+  : process.argv;
+
+// Special case: "claudio -- <claude args>" with no claudio args
+// Launch default profile directly, bypassing Commander
+if (claudePassthroughArgs.length > 0 && claudioArgs.length === 2) {
+  // Only have [node, script] before --, so just launch with passthrough
+  await launchDefaultProfile({ claudeArgs: claudePassthroughArgs });
+} else {
+
 const program = new Command();
 
 program
   .name('claudio')
   .description('Launch Claude Code with custom LLM router profiles')
-  .version(VERSION)
-  .option('--hooks <presets>', 'Override hooks (comma-separated: collaborative,supervised,sandboxed,audited)')
-  .option('--no-hooks', 'Disable all hooks');
+  .version(VERSION);
 
 // Setup command
 program
@@ -33,13 +48,10 @@ program
 // Launch command (explicit)
 program
   .command('launch [profile]')
-  .description('Launch Claude Code with optional profile')
-  .option('--hooks <presets>', 'Override hooks (comma-separated)')
-  .option('--no-hooks', 'Disable all hooks')
-  .action(async (profile: string | undefined, cmdOptions) => {
+  .description('Launch Claude Code with optional profile (use -- to pass args to Claude)')
+  .action(async (profile: string | undefined) => {
     const options: LaunchOptions = {
-      hooks: cmdOptions.hooks,
-      noHooks: cmdOptions.noHooks,
+      claudeArgs: claudePassthroughArgs,
     };
 
     if (profile) {
@@ -107,23 +119,21 @@ program
 
 // Handle profile launch (no args = default, or named profile)
 // This is the default action when no command is specified
-program.action(async (options, command) => {
-  const args = command.args;
+program.action(async (_options, command) => {
+  const args = command.args as string[];
+  const profileName = args[0];
 
   const launchOptions: LaunchOptions = {
-    hooks: options.hooks,
-    noHooks: options.hooks === false, // --no-hooks sets hooks to false
+    claudeArgs: claudePassthroughArgs,
   };
 
-  if (args.length === 0) {
-    // No arguments - launch default profile
+  if (profileName) {
+    await launchProfile(profileName, launchOptions);
+  } else {
     await launchDefaultProfile(launchOptions);
-    return;
   }
-
-  // Profile name provided - launch named profile
-  const profileName = args[0];
-  await launchProfile(profileName, launchOptions);
 });
 
-program.parse();
+program.parse(claudioArgs);
+
+} // end else block for special case

package/src/commands/launch.ts

@@ -2,12 +2,9 @@ import { spawn } from 'child_process';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { loadConfig, getDefaultProfile, configExists } from '../lib/config.js';
-import { loadGenieConfig, genieConfigExists } from '../lib/genie-config.js';
-import { describeEnabledHooks, hasEnabledHooks, parseHookNames } from '../lib/hooks/index.js';
 
 export interface LaunchOptions {
-  hooks?: string;
-  noHooks?: boolean;
+  claudeArgs?: string[];
 }
 
 /**
@@ -24,61 +21,14 @@ function getAgentsSystemPrompt(): string | null {
 /**
  * Get Claude CLI arguments including system prompt if AGENTS.md exists
  */
-function getClaudeArgs(): string[] {
+function getClaudeArgs(passthroughArgs: string[] = []): string[] {
+  const args: string[] = [];
   const prompt = getAgentsSystemPrompt();
   if (prompt) {
-    return ['--system-prompt', prompt];
+    args.push('--system-prompt', prompt);
   }
-  return [];
-}
-
-/**
- * Display hook information before launch
- */
-async function displayHookInfo(options: LaunchOptions): Promise<void> {
-  // Handle --no-hooks
-  if (options.noHooks) {
-    console.log('\x1b[33m⚠️  Hooks disabled via --no-hooks\x1b[0m');
-    return;
-  }
-
-  // Handle --hooks override
-  if (options.hooks) {
-    const presets = parseHookNames(options.hooks);
-    if (presets.length > 0) {
-      console.log(`\x1b[36m🪝 Using hooks: ${presets.join(', ')}\x1b[0m`);
-    }
-    return;
-  }
-
-  // Load from genie config
-  if (genieConfigExists()) {
-    const genieConfig = await loadGenieConfig();
-    if (hasEnabledHooks(genieConfig)) {
-      const descriptions = describeEnabledHooks(genieConfig);
-      console.log('\x1b[36m🪝 Active hooks:\x1b[0m');
-      for (const desc of descriptions) {
-        console.log(`   ${desc}`);
-      }
-    }
-  }
-}
-
-/**
- * Set hooks environment variables directly in process.env
- * This ensures Claude inherits the hooks configuration
- */
-async function setHooksEnvVars(): Promise<void> {
-  if (!genieConfigExists()) {
-    return;
-  }
-
-  const genieConfig = await loadGenieConfig();
-  if (!hasEnabledHooks(genieConfig)) {
-    return;
-  }
-
-  process.env.GENIE_HOOKS_ENABLED = genieConfig.hooks.enabled.join(',');
+  args.push(...passthroughArgs);
+  return args;
 }
 
 export async function launchProfile(profileName: string, options: LaunchOptions = {}): Promise<void> {
@@ -86,18 +36,12 @@ export async function launchProfile(profileName: string, options: LaunchOptions
   const profile = config.profiles[profileName];
 
   if (!profile) {
-    console.error(`❌ Profile "${profileName}" not found`);
+    console.error(`Profile "${profileName}" not found`);
     console.log(`\nAvailable profiles: ${Object.keys(config.profiles).join(', ')}`);
     process.exit(1);
   }
 
-  // Display hook information
-  await displayHookInfo(options);
-
-  // Set hooks environment variables
-  await setHooksEnvVars();
-
-  console.log(`🚀 Launching "${profileName}"...`);
+  console.log(`Launching "${profileName}"...`);
 
   // Set environment variables
   process.env.LC_ALL = 'C.UTF-8';
@@ -109,13 +53,13 @@ export async function launchProfile(profileName: string, options: LaunchOptions
   process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = profile.haiku;
 
   // Spawn claude with inherited stdio
-  const child = spawn('claude', getClaudeArgs(), {
+  const child = spawn('claude', getClaudeArgs(options.claudeArgs || []), {
     stdio: 'inherit',
     env: process.env,
   });
 
   child.on('error', (error) => {
-    console.error(`❌ Failed to launch: ${error.message}`);
+    console.error(`Failed to launch: ${error.message}`);
     process.exit(1);
   });
 
@@ -126,14 +70,14 @@ export async function launchProfile(profileName: string, options: LaunchOptions
 
 export async function launchDefaultProfile(options: LaunchOptions = {}): Promise<void> {
   if (!configExists()) {
-    console.error('❌ No config found. Run `claudio setup` first.');
+    console.error('No config found. Run `claudio setup` first.');
     process.exit(1);
   }
 
   const defaultProfile = await getDefaultProfile();
 
   if (!defaultProfile) {
-    console.error('❌ No default profile set.');
+    console.error('No default profile set.');
     console.log('\nRun `claudio setup` to configure, or use `claudio <profile>` to launch a specific profile.');
     process.exit(1);
   }

package/src/genie-commands/doctor.ts

@@ -0,0 +1,327 @@
+/**
+ * Genie Doctor Command
+ *
+ * Diagnostic tool to check the health of the genie installation.
+ * Checks prerequisites, configuration, and tmux connectivity.
+ */
+
+import {
+  checkCommand,
+} from '../lib/system-detect.js';
+import {
+  getClaudeSettingsPath,
+  contractClaudePath,
+} from '../lib/claude-settings.js';
+import {
+  loadGenieConfig,
+  genieConfigExists,
+  getGenieConfigPath,
+  isSetupComplete,
+} from '../lib/genie-config.js';
+import { $ } from 'bun';
+import { existsSync } from 'fs';
+
+interface CheckResult {
+  name: string;
+  status: 'pass' | 'fail' | 'warn';
+  message?: string;
+  suggestion?: string;
+}
+
+/**
+ * Print section header
+ */
+function printSectionHeader(title: string): void {
+  console.log();
+  console.log(`\x1b[1m${title}:\x1b[0m`);
+}
+
+/**
+ * Print a check result
+ */
+function printCheckResult(result: CheckResult): void {
+  const icons = {
+    pass: '\x1b[32m\u2713\x1b[0m',
+    fail: '\x1b[31m\u2717\x1b[0m',
+    warn: '\x1b[33m!\x1b[0m',
+  };
+
+  const icon = icons[result.status];
+  const message = result.message ? ` ${result.message}` : '';
+  console.log(`  ${icon} ${result.name}${message}`);
+
+  if (result.suggestion) {
+    console.log(`    \x1b[2m${result.suggestion}\x1b[0m`);
+  }
+}
+
+/**
+ * Check prerequisites (tmux, jq, bun, Claude Code)
+ */
+async function checkPrerequisites(): Promise<CheckResult[]> {
+  const results: CheckResult[] = [];
+
+  // Check tmux
+  const tmuxCheck = await checkCommand('tmux');
+  if (tmuxCheck.exists) {
+    results.push({
+      name: 'tmux',
+      status: 'pass',
+      message: tmuxCheck.version || '',
+    });
+  } else {
+    results.push({
+      name: 'tmux',
+      status: 'fail',
+      suggestion: 'Install with: brew install tmux (or apt install tmux)',
+    });
+  }
+
+  // Check jq
+  const jqCheck = await checkCommand('jq');
+  if (jqCheck.exists) {
+    results.push({
+      name: 'jq',
+      status: 'pass',
+      message: jqCheck.version || '',
+    });
+  } else {
+    results.push({
+      name: 'jq',
+      status: 'fail',
+      suggestion: 'Install with: brew install jq (or apt install jq)',
+    });
+  }
+
+  // Check bun
+  const bunCheck = await checkCommand('bun');
+  if (bunCheck.exists) {
+    results.push({
+      name: 'bun',
+      status: 'pass',
+      message: bunCheck.version || '',
+    });
+  } else {
+    results.push({
+      name: 'bun',
+      status: 'fail',
+      suggestion: 'Install with: curl -fsSL https://bun.sh/install | bash',
+    });
+  }
+
+  // Check Claude Code
+  const claudeCheck = await checkCommand('claude');
+  if (claudeCheck.exists) {
+    results.push({
+      name: 'Claude Code',
+      status: 'pass',
+      message: claudeCheck.version || '',
+    });
+  } else {
+    results.push({
+      name: 'Claude Code',
+      status: 'warn',
+      suggestion: 'Install with: npm install -g @anthropic-ai/claude-code',
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check configuration
+ */
+async function checkConfiguration(): Promise<CheckResult[]> {
+  const results: CheckResult[] = [];
+
+  // Check if genie config exists
+  if (genieConfigExists()) {
+    results.push({
+      name: 'Genie config exists',
+      status: 'pass',
+      message: contractClaudePath(getGenieConfigPath()),
+    });
+  } else {
+    results.push({
+      name: 'Genie config exists',
+      status: 'warn',
+      message: 'not found',
+      suggestion: 'Run: genie setup',
+    });
+  }
+
+  // Check if setup is complete
+  if (isSetupComplete()) {
+    results.push({
+      name: 'Setup complete',
+      status: 'pass',
+    });
+  } else {
+    results.push({
+      name: 'Setup complete',
+      status: 'warn',
+      message: 'not completed',
+      suggestion: 'Run: genie setup',
+    });
+  }
+
+  // Check if claudio config exists
+  const claudeSettingsPath = getClaudeSettingsPath();
+  if (existsSync(claudeSettingsPath)) {
+    results.push({
+      name: 'Claude settings exists',
+      status: 'pass',
+      message: contractClaudePath(claudeSettingsPath),
+    });
+  } else {
+    results.push({
+      name: 'Claude settings exists',
+      status: 'warn',
+      message: 'not found',
+      suggestion: 'Claude Code creates this on first run',
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check tmux status
+ */
+async function checkTmux(): Promise<CheckResult[]> {
+  const results: CheckResult[] = [];
+
+  // Check if tmux server is running
+  try {
+    const serverResult = await $`tmux list-sessions 2>/dev/null`.quiet();
+    if (serverResult.exitCode === 0) {
+      results.push({
+        name: 'Server running',
+        status: 'pass',
+      });
+    } else {
+      results.push({
+        name: 'Server running',
+        status: 'warn',
+        message: 'no sessions',
+        suggestion: 'Start with: tmux new-session -d -s genie',
+      });
+      return results;
+    }
+  } catch {
+    results.push({
+      name: 'Server running',
+      status: 'warn',
+      message: 'could not check',
+    });
+    return results;
+  }
+
+  // Check if genie session exists
+  const config = await loadGenieConfig();
+  const sessionName = config.session.name;
+
+  try {
+    const sessionResult = await $`tmux has-session -t ${sessionName} 2>/dev/null`.quiet();
+    if (sessionResult.exitCode === 0) {
+      results.push({
+        name: `Session '${sessionName}' exists`,
+        status: 'pass',
+      });
+    } else {
+      results.push({
+        name: `Session '${sessionName}' exists`,
+        status: 'warn',
+        suggestion: `Start with: tmux new-session -d -s ${sessionName}`,
+      });
+    }
+  } catch {
+    results.push({
+      name: `Session '${sessionName}' exists`,
+      status: 'warn',
+      message: 'could not check',
+    });
+  }
+
+  // Check if term exec works
+  try {
+    const termCheck = await checkCommand('term');
+    if (termCheck.exists) {
+      results.push({
+        name: 'term command available',
+        status: 'pass',
+      });
+    } else {
+      results.push({
+        name: 'term command available',
+        status: 'fail',
+        suggestion: 'Ensure genie-cli is properly installed',
+      });
+    }
+  } catch {
+    results.push({
+      name: 'term command available',
+      status: 'warn',
+      message: 'could not check',
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Main doctor command
+ */
+export async function doctorCommand(): Promise<void> {
+  console.log();
+  console.log('\x1b[1mGenie Doctor\x1b[0m');
+  console.log('\x1b[2m' + '\u2500'.repeat(40) + '\x1b[0m');
+
+  let hasErrors = false;
+  let hasWarnings = false;
+
+  // Prerequisites
+  printSectionHeader('Prerequisites');
+  const prereqResults = await checkPrerequisites();
+  for (const result of prereqResults) {
+    printCheckResult(result);
+    if (result.status === 'fail') hasErrors = true;
+    if (result.status === 'warn') hasWarnings = true;
+  }
+
+  // Configuration
+  printSectionHeader('Configuration');
+  const configResults = await checkConfiguration();
+  for (const result of configResults) {
+    printCheckResult(result);
+    if (result.status === 'fail') hasErrors = true;
+    if (result.status === 'warn') hasWarnings = true;
+  }
+
+  // Tmux
+  printSectionHeader('Tmux');
+  const tmuxResults = await checkTmux();
+  for (const result of tmuxResults) {
+    printCheckResult(result);
+    if (result.status === 'fail') hasErrors = true;
+    if (result.status === 'warn') hasWarnings = true;
+  }
+
+  // Summary
+  console.log();
+  console.log('\x1b[2m' + '\u2500'.repeat(40) + '\x1b[0m');
+
+  if (hasErrors) {
+    console.log('\x1b[31mSome checks failed.\x1b[0m Run \x1b[36mgenie setup\x1b[0m to fix.');
+  } else if (hasWarnings) {
+    console.log('\x1b[33mSome warnings detected.\x1b[0m Everything should still work.');
+  } else {
+    console.log('\x1b[32mAll checks passed!\x1b[0m');
+  }
+
+  console.log();
+
+  if (hasErrors) {
+    process.exit(1);
+  }
+}