@automagik/genie 0.260201.2240

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@automagik/genie",
+  "version": "0.260201.2240",
+  "description": "Dual CLI: claudio (Claude profiles) + term (terminal orchestration)",
+  "type": "module",
+  "bin": {
+    "claudio": "./dist/claudio.js",
+    "term": "./dist/term.js",
+    "genie": "./dist/genie.js"
+  },
+  "scripts": {
+    "dev:claudio": "bun --watch src/claudio.ts",
+    "dev:term": "bun --watch src/term.ts",
+    "version": "bun run scripts/version.ts",
+    "prebuild": "bun run version",
+    "build": "bun build src/claudio.ts src/term.ts src/genie.ts --outdir dist --target bun --minify && chmod +x dist/*.js",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "commander": "^12.1.0",
+    "zod": "^3.22.4",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "@types/node": "^20.10.5",
+    "typescript": "^5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/namastexlabs/genie-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/version.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+
+/**
+ * Pre-build script: generates datetime-based version and updates files
+ * Format: 0.YYMMDD.HHMM (e.g., 0.260201.1430 = Feb 1, 2026 at 14:30)
+ */
+
+import { readFile, writeFile } from 'fs/promises';
+import { join, dirname } from 'path';
+
+// Generate version from current datetime
+function generateVersion(): string {
+  const now = new Date();
+  const yy = String(now.getFullYear()).slice(-2);
+  const mm = String(now.getMonth() + 1).padStart(2, '0');
+  const dd = String(now.getDate()).padStart(2, '0');
+  const hh = String(now.getHours()).padStart(2, '0');
+  const min = String(now.getMinutes()).padStart(2, '0');
+
+  return `0.${yy}${mm}${dd}.${hh}${min}`;
+}
+
+async function main() {
+  const version = generateVersion();
+  const rootDir = join(dirname(import.meta.path), '..');
+
+  // Update package.json
+  const packagePath = join(rootDir, 'package.json');
+  const packageJson = JSON.parse(await readFile(packagePath, 'utf-8'));
+  packageJson.version = version;
+  await writeFile(packagePath, JSON.stringify(packageJson, null, 2) + '\n');
+
+  // Update src/lib/version.ts
+  const versionPath = join(rootDir, 'src/lib/version.ts');
+  const versionContent = await readFile(versionPath, 'utf-8');
+  const updatedContent = versionContent.replace(
+    /export const VERSION = '[^']+';/,
+    `export const VERSION = '${version}';`
+  );
+  await writeFile(versionPath, updatedContent);
+
+  console.log(`Version: ${version}`);
+}
+
+main().catch((err) => {
+  console.error('Version script failed:', err);
+  process.exit(1);
+});

package/src/claudio.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander';
+import { setupCommand } from './commands/setup.js';
+import { launchProfile, launchDefaultProfile, type LaunchOptions } from './commands/launch.js';
+import {
+  profilesListCommand,
+  profilesAddCommand,
+  profilesRemoveCommand,
+  profilesDefaultCommand,
+  profilesShowCommand,
+} from './commands/profiles.js';
+import { modelsCommand, configCommand } from './commands/models.js';
+
+const program = new Command();
+
+program
+  .name('claudio')
+  .description('Launch Claude Code with custom LLM router profiles')
+  .version('0.2.0')
+  .option('--hooks <presets>', 'Override hooks (comma-separated: collaborative,supervised,sandboxed,audited)')
+  .option('--no-hooks', 'Disable all hooks');
+
+// Setup command
+program
+  .command('setup')
+  .description('First-time setup wizard')
+  .action(async () => {
+    await setupCommand();
+  });
+
+// 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) => {
+    const options: LaunchOptions = {
+      hooks: cmdOptions.hooks,
+      noHooks: cmdOptions.noHooks,
+    };
+
+    if (profile) {
+      await launchProfile(profile, options);
+    } else {
+      await launchDefaultProfile(options);
+    }
+  });
+
+// Profiles command with subcommands
+const profiles = program
+  .command('profiles')
+  .description('Manage profiles');
+
+profiles
+  .command('list', { isDefault: true })
+  .description('List all profiles (* = default)')
+  .action(async () => {
+    await profilesListCommand();
+  });
+
+profiles
+  .command('add')
+  .description('Add new profile (interactive picker)')
+  .action(async () => {
+    await profilesAddCommand();
+  });
+
+profiles
+  .command('rm <name>')
+  .description('Delete profile')
+  .action(async (name: string) => {
+    await profilesRemoveCommand(name);
+  });
+
+profiles
+  .command('default <name>')
+  .description('Set default profile')
+  .action(async (name: string) => {
+    await profilesDefaultCommand(name);
+  });
+
+profiles
+  .command('show <name>')
+  .description('Show profile details')
+  .action(async (name: string) => {
+    await profilesShowCommand(name);
+  });
+
+// Models command
+program
+  .command('models')
+  .description('List available models from router')
+  .action(async () => {
+    await modelsCommand();
+  });
+
+// Config command
+program
+  .command('config')
+  .description('Show current config (URL, default profile)')
+  .action(async () => {
+    await configCommand();
+  });
+
+// 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;
+
+  const launchOptions: LaunchOptions = {
+    hooks: options.hooks,
+    noHooks: options.hooks === false, // --no-hooks sets hooks to false
+  };
+
+  if (args.length === 0) {
+    // No arguments - launch default profile
+    await launchDefaultProfile(launchOptions);
+    return;
+  }
+
+  // Profile name provided - launch named profile
+  const profileName = args[0];
+  await launchProfile(profileName, launchOptions);
+});
+
+program.parse();

package/src/commands/launch.ts

@@ -0,0 +1,245 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, getDefaultProfile, configExists } from '../lib/config.js';
+import { loadGenieConfig, genieConfigExists, getGenieDir, ensureGenieDir } from '../lib/genie-config.js';
+import { describeEnabledHooks, hasEnabledHooks, parseHookNames } from '../lib/hooks/index.js';
+import * as tmux from '../lib/tmux.js';
+
+const SESSION_NAME = 'genie';
+
+export interface LaunchOptions {
+  hooks?: string;
+  noHooks?: boolean;
+}
+
+/**
+ * Get the AGENTS.md system prompt if it exists in the current directory
+ */
+function getAgentsSystemPrompt(): string | null {
+  const agentsPath = join(process.cwd(), 'AGENTS.md');
+  if (existsSync(agentsPath)) {
+    return readFileSync(agentsPath, 'utf-8');
+  }
+  return null;
+}
+
+/**
+ * Get Claude CLI arguments including system prompt if AGENTS.md exists
+ */
+function getClaudeArgs(): string[] {
+  const prompt = getAgentsSystemPrompt();
+  if (prompt) {
+    return ['--system-prompt', prompt];
+  }
+  return [];
+}
+
+/**
+ * Get the Claude command string for shell execution
+ */
+function getClaudeCommand(): string {
+  const prompt = getAgentsSystemPrompt();
+  if (prompt) {
+    // Escape for shell: replace single quotes with '\''
+    const escaped = prompt.replace(/'/g, "'\\''");
+    return `claude --system-prompt '${escaped}'`;
+  }
+  return 'claude';
+}
+
+/**
+ * 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}`);
+      }
+    }
+  }
+}
+
+/**
+ * Write a shell-sourceable hooks environment file
+ * This can be sourced before running claude to set up hook-related env vars
+ */
+async function writeHooksEnvFile(): Promise<string | null> {
+  if (!genieConfigExists()) {
+    return null;
+  }
+
+  const genieConfig = await loadGenieConfig();
+  if (!hasEnabledHooks(genieConfig)) {
+    return null;
+  }
+
+  ensureGenieDir();
+  const envFile = join(getGenieDir(), 'hooks-env.sh');
+
+  // For now, we just export a marker that hooks are configured
+  // The actual hooks run in SDK applications, not the CLI
+  const content = `# Genie hooks environment
+# Generated by claudio launch
+# This file indicates hooks are configured in ~/.genie/config.json
+export GENIE_HOOKS_ENABLED="${genieConfig.hooks.enabled.join(',')}"
+`;
+
+  writeFileSync(envFile, content, 'utf-8');
+  return envFile;
+}
+
+export async function launchProfile(profileName: string, options: LaunchOptions = {}): Promise<void> {
+  const config = await loadConfig();
+  const profile = config.profiles[profileName];
+
+  if (!profile) {
+    console.error(`❌ Profile "${profileName}" not found`);
+    console.log(`\nAvailable profiles: ${Object.keys(config.profiles).join(', ')}`);
+    process.exit(1);
+  }
+
+  // Display hook information
+  await displayHookInfo(options);
+
+  // Write hooks environment file
+  const hooksEnvFile = await writeHooksEnvFile();
+
+  const isInsideTmux = !!process.env.TMUX;
+
+  // Environment setup command
+  const envSetupParts = [
+    `export LC_ALL=C.UTF-8`,
+    `export LANG=C.UTF-8`,
+    `export ANTHROPIC_BASE_URL="${config.apiUrl}"`,
+    `export ANTHROPIC_AUTH_TOKEN="${config.apiKey}"`,
+    `export ANTHROPIC_DEFAULT_OPUS_MODEL="${profile.opus}"`,
+    `export ANTHROPIC_DEFAULT_SONNET_MODEL="${profile.sonnet}"`,
+    `export ANTHROPIC_DEFAULT_HAIKU_MODEL="${profile.haiku}"`,
+  ];
+
+  // Source hooks env file if it exists
+  if (hooksEnvFile) {
+    envSetupParts.push(`source "${hooksEnvFile}"`);
+  }
+
+  envSetupParts.push(getClaudeCommand());
+
+  const envSetup = envSetupParts.join('; ');
+
+  if (isInsideTmux) {
+    // Already inside tmux - run directly in current terminal
+    console.log(`🚀 Launching "${profileName}"...`);
+
+    // Set environment variables
+    process.env.LC_ALL = 'C.UTF-8';
+    process.env.LANG = 'C.UTF-8';
+    process.env.ANTHROPIC_BASE_URL = config.apiUrl;
+    process.env.ANTHROPIC_AUTH_TOKEN = config.apiKey;
+    process.env.ANTHROPIC_DEFAULT_OPUS_MODEL = profile.opus;
+    process.env.ANTHROPIC_DEFAULT_SONNET_MODEL = profile.sonnet;
+    process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = profile.haiku;
+
+    // Spawn claude with inherited stdio (replaces this process)
+    const child = spawn('claude', getClaudeArgs(), {
+      stdio: 'inherit',
+      env: process.env,
+    });
+
+    child.on('error', (error) => {
+      console.error(`❌ Failed to launch: ${error.message}`);
+      process.exit(1);
+    });
+
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+  } else {
+    // Outside tmux - create or reuse "genie" session
+    let session = await tmux.findSessionByName(SESSION_NAME);
+
+    if (session) {
+      // Session exists - add a new window
+      console.log(`🚀 Adding "${profileName}" to session "${SESSION_NAME}"...`);
+
+      const window = await tmux.createWindow(session.id, profileName);
+      if (!window) {
+        console.error('❌ Failed to create window');
+        process.exit(1);
+      }
+
+      const panes = await tmux.listPanes(window.id);
+      await tmux.executeCommand(panes[0].id, envSetup);
+    } else {
+      // No session - create it
+      console.log(`🚀 Creating session "${SESSION_NAME}" with "${profileName}"...`);
+
+      session = await tmux.createSession(SESSION_NAME);
+      if (!session) {
+        console.error('❌ Failed to create tmux session');
+        process.exit(1);
+      }
+
+      // Rename the default window to the profile name
+      const windows = await tmux.listWindows(session.id);
+      await tmux.renameWindow(windows[0].id, profileName);
+
+      const panes = await tmux.listPanes(windows[0].id);
+      await tmux.executeCommand(panes[0].id, envSetup);
+    }
+
+    console.log(`✅ Ready`);
+    console.log(`\nAttaching to session...`);
+
+    // Attach to session
+    const child = spawn('tmux', ['attach', '-t', SESSION_NAME], {
+      stdio: 'inherit',
+    });
+
+    child.on('error', (error) => {
+      console.error(`❌ Failed to attach: ${error.message}`);
+      process.exit(1);
+    });
+
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+  }
+}
+
+export async function launchDefaultProfile(options: LaunchOptions = {}): Promise<void> {
+  if (!configExists()) {
+    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.log('\nRun `claudio setup` to configure, or use `claudio <profile>` to launch a specific profile.');
+    process.exit(1);
+  }
+
+  await launchProfile(defaultProfile, options);
+}

package/src/commands/models.ts

@@ -0,0 +1,43 @@
+import { loadConfig, configExists, getDefaultProfile } from '../lib/config.js';
+import { testConnection } from '../lib/api-client.js';
+
+export async function modelsCommand(): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  process.stdout.write('Fetching models... ');
+  const result = await testConnection(config.apiUrl, config.apiKey);
+
+  if (!result.success) {
+    console.log('❌');
+    console.error(`\n❌ ${result.message}`);
+    process.exit(1);
+  }
+
+  console.log(`✓\n`);
+  console.log(`Available models (${result.modelCount}):\n`);
+
+  for (const model of result.models) {
+    console.log(`  ${model.id}`);
+  }
+}
+
+export async function configCommand(): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const profileCount = Object.keys(config.profiles).length;
+
+  console.log('\nClaudio Config\n');
+  console.log(`  API URL:         ${config.apiUrl}`);
+  console.log(`  API Key:         ${config.apiKey.slice(0, 8)}...${config.apiKey.slice(-4)}`);
+  console.log(`  Default Profile: ${config.defaultProfile || '(none)'}`);
+  console.log(`  Profiles:        ${profileCount}`);
+}

package/src/commands/profiles.ts

@@ -0,0 +1,95 @@
+import {
+  listProfiles,
+  removeProfile,
+  setDefaultProfile,
+  getProfile,
+  configExists,
+} from '../lib/config.js';
+import { runAddProfileWizard } from '../lib/wizard.js';
+import { promptConfirm } from '../lib/picker.js';
+
+export async function profilesListCommand(): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  const profiles = await listProfiles();
+
+  if (profiles.length === 0) {
+    console.log('No profiles configured.');
+    console.log('Run `claudio profiles add` to create one.');
+    return;
+  }
+
+  console.log('\nProfiles:\n');
+  for (const { name, profile, isDefault } of profiles) {
+    const marker = isDefault ? ' *' : '';
+    console.log(`  ${name}${marker}`);
+    console.log(`    opus:   ${profile.opus}`);
+    console.log(`    sonnet: ${profile.sonnet}`);
+    console.log(`    haiku:  ${profile.haiku}`);
+    console.log('');
+  }
+
+  console.log('(* = default)');
+}
+
+export async function profilesAddCommand(): Promise<void> {
+  await runAddProfileWizard();
+}
+
+export async function profilesRemoveCommand(name: string): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  const profile = await getProfile(name);
+  if (!profile) {
+    console.error(`❌ Profile "${name}" not found`);
+    process.exit(1);
+  }
+
+  const confirmed = await promptConfirm(`Delete profile "${name}"?`);
+  if (!confirmed) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  await removeProfile(name);
+  console.log(`✓ Profile "${name}" deleted`);
+}
+
+export async function profilesDefaultCommand(name: string): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  try {
+    await setDefaultProfile(name);
+    console.log(`✓ Default profile set to "${name}"`);
+  } catch (error: any) {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function profilesShowCommand(name: string): Promise<void> {
+  if (!configExists()) {
+    console.error('❌ No config found. Run `claudio setup` first.');
+    process.exit(1);
+  }
+
+  const profile = await getProfile(name);
+  if (!profile) {
+    console.error(`❌ Profile "${name}" not found`);
+    process.exit(1);
+  }
+
+  console.log(`\nProfile: ${name}\n`);
+  console.log(`  opus:   ${profile.opus}`);
+  console.log(`  sonnet: ${profile.sonnet}`);
+  console.log(`  haiku:  ${profile.haiku}`);
+}

package/src/commands/setup.ts

@@ -0,0 +1,5 @@
+import { runSetupWizard } from '../lib/wizard.js';
+
+export async function setupCommand(): Promise<void> {
+  await runSetupWizard();
+}