@calliopelabs/cli 0.8.20 → 2.0.2

package/dist/{cli.js → cli/commands.js}

@@ -1,210 +1,35 @@
 /**
- * Calliope CLI - Interactive REPL
+ * CLI Command Handlers
  *
- * Main interactive command-line interface.
+ * Slash command processing, help text, and upgrade flow.
  */
-import * as readline from 'readline';
 import * as path from 'path';
-import * as config from './config.js';
-import { chat, getAvailableProviders, selectProvider } from './providers.js';
-import { TOOLS, executeTool } from './tools.js';
-import { getSystemPrompt, DEFAULT_MODELS } from './types.js';
-import { checkForUpdates, getVersion, getLatestVersion, performUpgrade } from './version-check.js';
-import { selectModelInteractively } from './model-detection.js';
-import * as memory from './memory.js';
-import * as hooks from './hooks.js';
-import * as modelRouter from './model-router.js';
-import * as summarization from './summarization.js';
-import * as themes from './themes.js';
-import * as branching from './branching.js';
-import * as fuzzySearch from './fuzzy-search.js';
-import { MODE_CONFIG } from './types.js';
-import * as storage from './storage.js';
-import { addToScope, removeFromScope, getScopeSummary, getScopeDetails, resetScope } from './scope.js';
-// Debug logging helper
-const DEBUG = process.env.CALLIOPE_DEBUG === '1';
-function debugLog(message, ...args) {
-    if (DEBUG)
-        console.log(`[DEBUG:cli] ${message}`, ...args);
+import * as config from '../config.js';
+import { getAvailableProviders, selectProvider } from '../providers/index.js';
+import { getSystemPrompt, DEFAULT_MODELS, MODE_CONFIG } from '../types.js';
+import { getVersion, getLatestVersion, performUpgrade } from '../version-check.js';
+import { selectModelInteractively } from '../model-detection.js';
+import * as memory from '../memory.js';
+import * as hooks from '../hooks.js';
+import * as modelRouter from '../model-router.js';
+import * as summarization from '../summarization.js';
+import * as themes from '../themes.js';
+import * as branching from '../branching.js';
+import * as fuzzySearch from '../fuzzy-search.js';
+import * as storage from '../storage.js';
+import { addToScope, removeFromScope, getScopeSummary, getScopeDetails, resetScope } from '../scope.js';
+import { color } from '../styles.js';
+import { getCurrentSkin, getCurrentPalette, applySkin, applyPalette, listSkins, listPalettes } from '../hud/api.js';
+import { getCurrentCompanion, applyCompanion, listCompanions, getMoodText } from '../companions.js';
+import { applyThemePack, listThemePacks, getCurrentPack, getCompanionMode, setCompanionMode } from '../hud/theme-packs/api.js';
+import { isDockerAvailable } from '../sandbox.js';
+import { getSandboxStatus } from '../sandbox-native.js';
+// Forward declaration — injected by index.ts to avoid circular imports
+let _startLoop;
+export function setStartLoop(fn) {
+    _startLoop = fn;
 }
-// ANSI colors
-const c = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    cyan: '\x1b[36m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    red: '\x1b[31m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    brightCyan: '\x1b[96m',
-};
-function color(text, style) {
-    return `${c[style]}${text}${c.reset}`;
-}
-// Spinner frames
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const BANNER = `
-${color(' ██████╗ █████╗ ██╗     ██╗     ██╗ ██████╗ ██████╗ ███████╗', 'brightCyan')}
-${color('██╔════╝██╔══██╗██║     ██║     ██║██╔═══██╗██╔══██╗██╔════╝', 'brightCyan')}
-${color('██║     ███████║██║     ██║     ██║██║   ██║██████╔╝█████╗  ', 'cyan')}
-${color('██║     ██╔══██║██║     ██║     ██║██║   ██║██╔═══╝ ██╔══╝  ', 'cyan')}
-${color('╚██████╗██║  ██║███████╗███████╗██║╚██████╔╝██║     ███████╗', 'brightCyan')}
-${color(' ╚═════╝╚═╝  ╚═╝╚══════╝╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚══════╝', 'cyan')}
-
-        ${color('The Muse of Digital Eloquence', 'dim')}
-`;
-// Slash commands
-const COMMANDS = [
-    '/help', '/h', '/provider', '/p', '/model', '/m', '/models', '/persona',
-    '/clear', '/c', '/status', '/s', '/loop', '/cancel-loop',
-    '/setup', '/config', '/upgrade', '/exit', '/quit', '/q',
-    '/memory', '/hooks', '/route', '/summarize', '/theme', '/branch', '/find', '/search',
-    '/mode', '/work', '/plan', '/debug', '/set', '/confirm',
-    '/scope', '/add-dir', '/remove-dir', '/cost', '/costs', '/session', '/context',
-];
-/**
- * Start the CLI
- */
-export async function startCLI(options = {}) {
-    const state = {
-        provider: config.get('defaultProvider'),
-        model: config.get('defaultModel'),
-        persona: config.get('persona'),
-        messages: [],
-        cwd: process.cwd(),
-        running: true,
-        skipPermissions: options.skipPermissions ?? false,
-        loopActive: false,
-        loopPrompt: '',
-        loopIteration: 0,
-        loopMaxIterations: 50,
-        autoRoute: false,
-        currentBranch: 'main',
-        mode: 'hybrid',
-        confirmMode: true,
-        debugEnabled: process.env.CALLIOPE_DEBUG === '1',
-        sessionCost: 0,
-    };
-    // Add system message with memory context
-    const systemPrompt = getSystemPrompt(state.persona);
-    const memoryContext = memory.buildMemoryContext(process.cwd());
-    const fullPrompt = memoryContext.trim()
-        ? systemPrompt + '\n\n--- Project Context ---\n' + memoryContext
-        : systemPrompt;
-    state.messages.push({
-        role: 'system',
-        content: fullPrompt,
-    });
-    // Execute session start hooks
-    hooks.executeHooks('session-start', {}).catch((err) => {
-        debugLog('session-start hook failed:', err instanceof Error ? err.message : err);
-    });
-    // Setup readline
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-        completer: (line) => {
-            if (line.startsWith('/')) {
-                const hits = COMMANDS.filter(cmd => cmd.startsWith(line));
-                return [hits.length ? hits : COMMANDS, line];
-            }
-            return [[], line];
-        },
-    });
-    // Check for updates (do this early, it's cached)
-    let hasUpdate = false;
-    // Print welcome
-    if (config.get('fancyOutput')) {
-        console.log(BANNER);
-        const actualProvider = selectProvider(state.provider);
-        const model = state.model || DEFAULT_MODELS[actualProvider];
-        console.log(`  ${color('v' + getVersion(), 'dim')}`);
-        console.log();
-        console.log(`  ${color('Provider:', 'dim')} ${color(actualProvider, 'cyan')} (${color(model, 'dim')})`);
-        console.log(`  ${color('Persona:', 'dim')} ${color(state.persona, 'cyan')}`);
-        console.log(`  ${color('Directory:', 'dim')} ${color(state.cwd, 'dim')}`);
-        // Check for updates
-        hasUpdate = await checkForUpdates().catch(() => false);
-        console.log(color('  ─────────────────────────────────────────────────────────────────', 'dim'));
-        console.log(`  ${color('TAB', 'cyan')} ${color('autocomplete', 'dim')} ${color('│', 'dim')} ${color('/help', 'cyan')} ${color('│', 'dim')} ${color('/loop', 'cyan')} ${color('│', 'dim')} ${color('/provider', 'cyan')} ${color('│', 'dim')} ${color('ESC', 'cyan')} ${color('stop', 'dim')}`);
-        console.log(color('  ─────────────────────────────────────────────────────────────────', 'dim'));
-    }
-    else {
-        console.log('Calliope CLI');
-        console.log(`Provider: ${selectProvider(state.provider)}`);
-        console.log('/help for commands');
-        hasUpdate = await checkForUpdates(true).catch(() => false); // silent in non-fancy mode
-    }
-    console.log();
-    // Prompt function
-    const promptUser = () => {
-        const promptStr = `${color('calliope', 'cyan')}${color('>', 'dim')} `;
-        rl.question(promptStr, async (input) => {
-            input = input.trim();
-            if (!input) {
-                promptUser();
-                return;
-            }
-            // Handle commands
-            if (input.startsWith('/')) {
-                await handleCommand(input, state, rl);
-                if (state.running)
-                    promptUser();
-                return;
-            }
-            // Run agent
-            await runAgent(input, state);
-            if (state.running)
-                promptUser();
-        });
-    };
-    // Handle Ctrl+C
-    rl.on('close', () => {
-        console.log();
-        console.log(color('  Farewell...', 'cyan'));
-        console.log();
-        process.exit(0);
-    });
-    // If update available and autoUpgrade enabled, prompt user
-    if (hasUpdate && config.get('autoUpgrade')) {
-        rl.question(`${color('Upgrade now? (y/N/never)', 'cyan')} `, async (answer) => {
-            const a = answer.toLowerCase().trim();
-            if (a === 'y' || a === 'yes') {
-                const success = await performUpgrade();
-                if (success) {
-                    console.log();
-                    console.log(color('Upgrade complete! Restarting...', 'green'));
-                    const { spawn } = await import('child_process');
-                    const child = spawn(process.argv[0], process.argv.slice(1), {
-                        stdio: 'inherit',
-                        detached: true,
-                    });
-                    child.unref();
-                    process.exit(0);
-                }
-                else {
-                    console.log(color('Upgrade failed. Use /upgrade to try again.', 'red'));
-                }
-            }
-            else if (a === 'never') {
-                config.set('autoUpgrade', false);
-                console.log(color('Auto-upgrade disabled. Use /upgrade to update manually.', 'dim'));
-            }
-            console.log();
-            promptUser();
-        });
-    }
-    else {
-        promptUser();
-    }
-}
-/**
- * Handle slash commands
- */
-async function handleCommand(input, state, rl) {
+export async function handleCommand(input, state, rl) {
     const parts = input.split(/\s+/);
     const cmd = parts[0].toLowerCase();
     switch (cmd) {
@@ -215,7 +40,7 @@ async function handleCommand(input, state, rl) {
         case '/provider':
         case '/p':
             if (parts[1]) {
-                const validProviders = ['anthropic', 'google', 'openai', 'together', 'openrouter', 'groq', 'fireworks', 'mistral', 'ollama', 'ai21', 'huggingface', 'litellm', 'auto'];
+                const validProviders = ['anthropic', 'google', 'openai', 'together', 'openrouter', 'groq', 'fireworks', 'mistral', 'ollama', 'ai21', 'huggingface', 'litellm', 'bedrock', 'auto'];
                 const requested = parts[1].toLowerCase();
                 if (validProviders.includes(requested)) {
                     state.provider = requested;
@@ -241,7 +66,6 @@ async function handleCommand(input, state, rl) {
                 console.log();
             }
             else {
-                // Interactive model selection
                 const actualProvider = selectProvider(state.provider);
                 console.log(`Current model: ${color(state.model || DEFAULT_MODELS[actualProvider], 'cyan')}`);
                 console.log();
@@ -267,14 +91,14 @@ async function handleCommand(input, state, rl) {
             }
             break;
         case '/persona':
-            if (parts[1] && ['calliope', 'professional', 'minimal'].includes(parts[1])) {
+            if (parts[1] && ['calliope', 'muse', 'minimal'].includes(parts[1])) {
                 state.persona = parts[1];
                 state.messages = [{ role: 'system', content: getSystemPrompt(state.persona) }];
                 console.log(color(`Persona set to: ${parts[1]}`, 'green'));
             }
             else {
                 console.log(`Current: ${color(state.persona, 'magenta')}`);
-                console.log('Options: calliope, professional, minimal');
+                console.log('Options: calliope, muse, minimal');
             }
             console.log();
             break;
@@ -294,7 +118,7 @@ async function handleCommand(input, state, rl) {
             console.log();
             break;
         case '/loop':
-            await startLoop(parts.slice(1).join(' '), state);
+            await _startLoop(parts.slice(1).join(' '), state);
             break;
         case '/cancel-loop':
             if (state.loopActive) {
@@ -307,7 +131,7 @@ async function handleCommand(input, state, rl) {
             console.log();
             break;
         case '/setup':
-            const { reconfigure } = await import('./setup.js');
+            const { reconfigure } = await import('../setup.js');
             await reconfigure();
             break;
         case '/config':
@@ -428,9 +252,193 @@ async function handleCommand(input, state, rl) {
             }
             console.log();
             break;
+        case '/skin':
+            if (parts[1] === 'list' || !parts[1]) {
+                const skins = listSkins();
+                const currentSkin = getCurrentSkin();
+                console.log(`Skins: ${skins.map(s => s.name === currentSkin.name ? color(s.name, 'green') : s.name).join(', ')}`);
+                if (!parts[1])
+                    console.log(`Current: ${color(currentSkin.name, 'cyan')} — ${currentSkin.description}`);
+            }
+            else {
+                applySkin(parts[1]);
+                const newSkin = getCurrentSkin();
+                if (newSkin.name === parts[1]) {
+                    config.set('activeSkin', parts[1]);
+                    console.log(color(`Skin set to: ${parts[1]}`, 'green'));
+                }
+                else {
+                    console.log(color(`Skin not found: ${parts[1]}. Using: ${newSkin.name}`, 'yellow'));
+                }
+            }
+            console.log();
+            break;
+        case '/palette':
+            if (parts[1] === 'list' || !parts[1]) {
+                const palettes = listPalettes();
+                const currentPal = getCurrentPalette();
+                console.log(`Palettes: ${palettes.map(p => p.name === currentPal.name ? color(p.name, 'green') : p.name).join(', ')}`);
+                if (!parts[1])
+                    console.log(`Current: ${color(currentPal.name, 'cyan')} — ${currentPal.description}`);
+            }
+            else {
+                applyPalette(parts[1]);
+                const newPal = getCurrentPalette();
+                if (newPal.name === parts[1]) {
+                    config.set('activePalette', parts[1]);
+                    console.log(color(`Palette set to: ${parts[1]}`, 'green'));
+                }
+                else {
+                    console.log(color(`Palette not found: ${parts[1]}. Using: ${newPal.name}`, 'yellow'));
+                }
+            }
+            console.log();
+            break;
+        case '/companion':
+            if (parts[1] === 'list' || !parts[1]) {
+                const companions = listCompanions();
+                const currentComp = getCurrentCompanion();
+                console.log(`Companions: ${companions.map(comp => comp.name === currentComp.name ? color(comp.name, 'green') : comp.name).join(', ')}`);
+                if (!parts[1])
+                    console.log(`Current: ${color(currentComp.name, 'cyan')} — ${currentComp.description}`);
+            }
+            else {
+                applyCompanion(parts[1]);
+                const newComp = getCurrentCompanion();
+                if (newComp.name === parts[1]) {
+                    config.set('activeCompanion', parts[1]);
+                    state.messages = [{ role: 'system', content: getSystemPrompt(state.persona) }];
+                    console.log(color(`Companion set to: ${parts[1]}`, 'green'));
+                    console.log(color(`  "${newComp.greeting}"`, 'dim'));
+                }
+                else {
+                    console.log(color(`Companion not found: ${parts[1]}. Using: ${newComp.name}`, 'yellow'));
+                }
+            }
+            console.log();
+            break;
+        case '/hud':
+            {
+                const hudSkin = getCurrentSkin();
+                const hudPalette = getCurrentPalette();
+                const hudCompanion = getCurrentCompanion();
+                const hudPack = getCurrentPack();
+                const hudIntensity = getCompanionMode();
+                console.log(color('HUD Configuration', 'bold'));
+                if (hudPack)
+                    console.log(`  Pack:      ${color(hudPack.name, 'cyan')} — ${hudPack.description}`);
+                console.log(`  Skin:      ${color(hudSkin.name, 'cyan')} — ${hudSkin.description}`);
+                console.log(`  Palette:   ${color(hudPalette.name, 'cyan')} — ${hudPalette.description}`);
+                console.log(`  Companion: ${color(hudCompanion.name, 'cyan')} — ${hudCompanion.description}`);
+                console.log(`  Intensity: ${hudIntensity}`);
+                console.log(`  Emojis:    ${config.get('useEmojis') !== false ? 'ON' : 'OFF'}`);
+                console.log(`  Mood:      ${getMoodText()}`);
+                console.log();
+                console.log(color('  /pack <name>  /intensity <pro|immersive>  /emoji [on|off]', 'dim'));
+                console.log(color('  /skin <name>  /palette <name>  /companion <name>', 'dim'));
+            }
+            console.log();
+            break;
+        case '/pack':
+            if (parts[1] === 'list' || !parts[1]) {
+                const category = parts[2];
+                const packs = listThemePacks(category || undefined);
+                const currentP = getCurrentPack();
+                const grouped = new Map();
+                for (const p of packs) {
+                    const group = grouped.get(p.category) || [];
+                    group.push(p);
+                    grouped.set(p.category, group);
+                }
+                console.log(color('Theme Packs:', 'bold'));
+                for (const [cat, catPacks] of grouped) {
+                    console.log(color(`\n  [${cat}]`, 'dim'));
+                    for (const p of catPacks) {
+                        const marker = currentP && p.name === currentP.name ? color(' *', 'green') : '';
+                        console.log(`    ${p.name}${marker} — ${p.description}`);
+                    }
+                }
+                console.log(color('\n  /pack <name>', 'dim'));
+            }
+            else {
+                const success = applyThemePack(parts[1], getCompanionMode());
+                if (success) {
+                    const pack = getCurrentPack();
+                    config.set('activeThemePack', parts[1]);
+                    config.set('activeSkin', pack.skin.name);
+                    config.set('activePalette', pack.palette.name);
+                    const companion = getCompanionMode() === 'professional'
+                        ? pack.companions.professional
+                        : pack.companions.immersive;
+                    config.set('activeCompanion', companion.name);
+                    // Reset system prompt to use the companion's persona
+                    state.messages = [{ role: 'system', content: getSystemPrompt(state.persona) }];
+                    console.log(color(`Theme pack: ${parts[1]}`, 'green'));
+                    console.log(color(`  "${companion.greeting}"`, 'dim'));
+                }
+                else {
+                    console.log(color(`Theme pack not found: ${parts[1]}`, 'yellow'));
+                }
+            }
+            console.log();
+            break;
+        case '/intensity':
+            if (parts[1] === 'professional' || parts[1] === 'pro') {
+                const success = setCompanionMode('professional');
+                if (success) {
+                    const pack = getCurrentPack();
+                    config.set('companionIntensity', 'professional');
+                    config.set('activeCompanion', pack.companions.professional.name);
+                    state.messages = [{ role: 'system', content: getSystemPrompt(state.persona) }];
+                    console.log(color(`Switched to professional mode`, 'green'));
+                }
+                else {
+                    console.log(color('No theme pack active. Use /pack <name> first.', 'yellow'));
+                }
+            }
+            else if (parts[1] === 'immersive' || parts[1] === 'imm') {
+                const success = setCompanionMode('immersive');
+                if (success) {
+                    const pack = getCurrentPack();
+                    config.set('companionIntensity', 'immersive');
+                    config.set('activeCompanion', pack.companions.immersive.name);
+                    state.messages = [{ role: 'system', content: getSystemPrompt(state.persona) }];
+                    console.log(color(`Switched to immersive mode`, 'green'));
+                }
+                else {
+                    console.log(color('No theme pack active. Use /pack <name> first.', 'yellow'));
+                }
+            }
+            else {
+                console.log(`Intensity: ${getCompanionMode()}`);
+                console.log(color('Options: /intensity professional (pro), /intensity immersive (imm)', 'dim'));
+            }
+            console.log();
+            break;
+        case '/emoji': {
+            const emojiArg = parts[1];
+            const emojiCurrent = config.get('useEmojis') !== false;
+            if (emojiArg === 'on') {
+                config.set('useEmojis', true);
+                console.log(color('Emojis enabled', 'green'));
+            }
+            else if (emojiArg === 'off') {
+                config.set('useEmojis', false);
+                console.log(color('Emojis disabled — text fallbacks will be used', 'green'));
+            }
+            else if (emojiArg === 'toggle') {
+                config.set('useEmojis', !emojiCurrent);
+                console.log(color(`Emojis ${!emojiCurrent ? 'enabled' : 'disabled'}`, 'green'));
+            }
+            else {
+                console.log(`Emojis: ${emojiCurrent ? 'ON' : 'OFF'}`);
+                console.log(color('Usage: /emoji [on|off|toggle]', 'dim'));
+            }
+            console.log();
+            break;
+        }
         case '/branch':
             {
-                // Use a simple session ID for the legacy CLI
                 const sessionId = 'default-session';
                 if (parts[1] === 'list') {
                     const branches = branching.listBranches(sessionId);
@@ -638,11 +646,68 @@ async function handleCommand(input, state, rl) {
             }
             console.log();
             break;
+        case '/sandbox':
+            {
+                const sandboxArg = parts[1];
+                const validModes = ['auto', 'native', 'docker', 'off'];
+                if (sandboxArg && validModes.includes(sandboxArg)) {
+                    config.set('sandboxMode', sandboxArg);
+                    console.log(color(`Sandbox mode set to: ${sandboxArg}`, 'green'));
+                }
+                else if (sandboxArg && !validModes.includes(sandboxArg)) {
+                    console.log(color(`Invalid sandbox mode: ${sandboxArg}`, 'red'));
+                    console.log(`Available modes: ${validModes.join(', ')}`);
+                }
+                else {
+                    // Show sandbox status
+                    const currentMode = config.get('sandboxMode') || 'auto';
+                    const nativeStatus = getSandboxStatus();
+                    const dockerReady = isDockerAvailable();
+                    console.log(color('Sandbox Configuration', 'bold'));
+                    console.log(`  Mode:     ${color(currentMode, 'cyan')}`);
+                    console.log();
+                    console.log(color('  Backends:', 'bold'));
+                    console.log(`  Docker:   ${dockerReady ? color('available', 'green') : color('not available', 'dim')}`);
+                    console.log(`  Native:   ${nativeStatus.available ? color('available', 'green') : color('not available', 'dim')}`);
+                    if (nativeStatus.available) {
+                        console.log(`            ${nativeStatus.description}`);
+                    }
+                    console.log(`  Platform: ${nativeStatus.platform}`);
+                    console.log();
+                    // Show effective behaviour
+                    let effective;
+                    switch (currentMode) {
+                        case 'auto':
+                            if (nativeStatus.available)
+                                effective = `native (${nativeStatus.backend}) for shell commands`;
+                            else
+                                effective = 'unsandboxed (no native backend available)';
+                            if (dockerReady)
+                                effective += ', Docker for code execution';
+                            break;
+                        case 'native':
+                            effective = nativeStatus.available ? `${nativeStatus.backend}` : 'ERROR: native not available';
+                            break;
+                        case 'docker':
+                            effective = dockerReady ? 'Docker' : 'ERROR: Docker not available';
+                            break;
+                        case 'off':
+                            effective = 'all sandboxing disabled';
+                            break;
+                        default:
+                            effective = 'unknown';
+                    }
+                    console.log(`  Effective: ${effective}`);
+                    console.log();
+                    console.log(color('  /sandbox <auto|native|docker|off>', 'dim'));
+                }
+            }
+            console.log();
+            break;
         case '/exit':
         case '/quit':
-        case '/q':
             console.log();
-            console.log(color('  Until we meet again...', 'cyan'));
+            console.log(color(`  ${getCurrentCompanion().farewell}`, 'cyan'));
             console.log();
             state.running = false;
             rl.close();
@@ -653,9 +718,6 @@ async function handleCommand(input, state, rl) {
             console.log();
     }
 }
-/**
- * Handle upgrade command
- */
 async function handleUpgrade(rl) {
     console.log();
     console.log(color('Checking for updates...', 'cyan'));
@@ -685,7 +747,6 @@ async function handleUpgrade(rl) {
     console.log();
     console.log(`${color('Update available:', 'yellow')} v${currentVersion} → ${color('v' + latestVersion, 'green')}`);
     console.log();
-    // Prompt for confirmation
     rl.question(`${color('Upgrade now? (y/N)', 'cyan')} `, async (answer) => {
         if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
             console.log();
@@ -695,7 +756,6 @@ async function handleUpgrade(rl) {
                 console.log(color('Upgrade complete!', 'green'));
                 console.log(color('Restarting Calliope...', 'dim'));
                 console.log();
-                // Restart the CLI
                 const { spawn } = await import('child_process');
                 const child = spawn(process.argv[0], process.argv.slice(1), {
                     stdio: 'inherit',
@@ -717,9 +777,6 @@ async function handleUpgrade(rl) {
         }
     });
 }
-/**
- * Print help
- */
 function printHelp() {
     console.log();
     console.log(color('Commands:', 'bold'));
@@ -750,6 +807,7 @@ function printHelp() {
     console.log('  /scope [details|reset]  Show/manage file access scope');
     console.log('  /add-dir <path>    Add directory to scope');
     console.log('  /remove-dir <path> Remove directory from scope');
+    console.log('  /sandbox [mode]    Sandbox status or set mode (auto|native|docker|off)');
     console.log();
     console.log(color('Navigation:', 'bold'));
     console.log('  /find <pattern>    Fuzzy file search');
@@ -759,7 +817,13 @@ function printHelp() {
     console.log('  /hooks [init|list] Pre/post tool hooks');
     console.log('  /theme [name|list] Color themes');
     console.log();
-    console.log(color('Ralph Wiggum Loop:', 'bold'));
+    console.log(color('HUD:', 'bold'));
+    console.log('  /skin [name|list]      Switch visual skin');
+    console.log('  /palette [name|list]   Switch color palette');
+    console.log('  /companion [name|list] Switch AI companion');
+    console.log('  /hud               Show HUD status');
+    console.log();
+    console.log(color('Agent Loop:', 'bold'));
     console.log('  /loop "<prompt>"   Start autonomous loop');
     console.log('    --max-iterations N');
     console.log('    --completion-promise "text"');
@@ -774,205 +838,4 @@ function printHelp() {
     console.log('  /exit              Exit');
     console.log();
 }
-/**
- * Run the agent with a prompt
- */
-async function runAgent(prompt, state) {
-    // Add user message
-    state.messages.push({ role: 'user', content: prompt });
-    // Spinner setup
-    let spinnerIdx = 0;
-    const spinnerInterval = setInterval(() => {
-        process.stdout.write(`\r${color(SPINNER[spinnerIdx], 'cyan')} ${color('Thinking...', 'dim')}`);
-        spinnerIdx = (spinnerIdx + 1) % SPINNER.length;
-    }, 80);
-    // Helper to clean up spinner
-    const clearSpinner = () => {
-        clearInterval(spinnerInterval);
-        process.stdout.write('\r\x1b[K'); // Clear line
-    };
-    try {
-        const maxIterations = config.get('maxIterations');
-        let iteration = 0;
-        let finalResponse = '';
-        while (iteration < maxIterations) {
-            iteration++;
-            // Call LLM
-            const response = await chat(state.provider, state.messages, TOOLS, state.model);
-            // Handle tool calls
-            if (response.toolCalls && response.toolCalls.length > 0) {
-                clearSpinner();
-                // Add assistant message with tool calls
-                state.messages.push({
-                    role: 'assistant',
-                    content: response.content,
-                    toolCalls: response.toolCalls,
-                });
-                // Execute tools
-                for (const toolCall of response.toolCalls) {
-                    // Execute pre-tool hooks
-                    const preHookResult = await hooks.checkHooksAllow('pre-tool', {
-                        tool: toolCall.name,
-                        toolArgs: toolCall.arguments,
-                    });
-                    if (!preHookResult.allowed) {
-                        console.log(`${color('│', 'dim')}  ${color(`Blocked by hook: ${preHookResult.reason}`, 'red')}`);
-                        state.messages.push({
-                            role: 'tool',
-                            content: `[Blocked by hook: ${preHookResult.reason}]`,
-                            toolCallId: toolCall.id,
-                        });
-                        continue;
-                    }
-                    printToolCall(toolCall);
-                    const result = await executeTool(toolCall, state.cwd);
-                    printToolResult(toolCall.name, result.result);
-                    // Execute post-tool hooks
-                    hooks.executeHooks('post-tool', {
-                        tool: toolCall.name,
-                        toolArgs: toolCall.arguments,
-                        toolResult: result.result,
-                    }).catch((err) => {
-                        debugLog(`post-tool hook failed for ${toolCall.name}:`, err instanceof Error ? err.message : err);
-                    });
-                    state.messages.push({
-                        role: 'tool',
-                        content: result.result,
-                        toolCallId: toolCall.id,
-                    });
-                }
-                // Continue loop for next response
-                continue;
-            }
-            // No tool calls - final response
-            clearSpinner();
-            state.messages.push({
-                role: 'assistant',
-                content: response.content,
-            });
-            finalResponse = response.content;
-            console.log();
-            console.log(`${color('✧', 'cyan')} ${color('Calliope:', 'dim')}`);
-            console.log();
-            printOutput(response.content);
-            console.log();
-            break;
-        }
-        return finalResponse;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        console.log();
-        console.log(`${color('✗', 'red')} ${color(`Error: ${msg}`, 'red')}`);
-        console.log();
-        return '';
-    }
-    finally {
-        // Ensure spinner is always cleaned up
-        clearInterval(spinnerInterval);
-    }
-}
-/**
- * Start an autonomous loop
- */
-async function startLoop(args, state) {
-    // Parse args
-    const maxIterMatch = args.match(/--max-iterations\s+(\d+)/);
-    const completionMatch = args.match(/--completion-promise\s+"([^"]+)"/);
-    let prompt = args
-        .replace(/--max-iterations\s+\d+/, '')
-        .replace(/--completion-promise\s+"[^"]+"/, '')
-        .trim();
-    const quotedMatch = prompt.match(/^"([^"]+)"$/);
-    if (quotedMatch)
-        prompt = quotedMatch[1];
-    if (!prompt) {
-        console.log(color('Usage: /loop "<prompt>" [--max-iterations N] [--completion-promise "text"]', 'red'));
-        console.log();
-        return;
-    }
-    state.loopActive = true;
-    state.loopPrompt = prompt;
-    state.loopIteration = 0;
-    state.loopMaxIterations = maxIterMatch ? parseInt(maxIterMatch[1], 10) : 50;
-    state.loopCompletionPromise = completionMatch ? completionMatch[1] : undefined;
-    console.log();
-    console.log(`${color('╭─', 'dim')} ${color('🔄 Ralph Loop Started', 'bold')}`);
-    console.log(`${color('│', 'dim')}  ${color('Max:', 'dim')} ${color(String(state.loopMaxIterations), 'cyan')}`);
-    if (state.loopCompletionPromise) {
-        console.log(`${color('│', 'dim')}  ${color('Promise:', 'dim')} ${color(state.loopCompletionPromise, 'green')}`);
-    }
-    console.log(`${color('╰─', 'dim')} ${color('/cancel-loop to stop', 'dim')}`);
-    console.log();
-    // Run loop
-    while (state.loopActive && state.loopIteration < state.loopMaxIterations) {
-        state.loopIteration++;
-        console.log(`${color('╭─', 'cyan')} ${color(`Iteration ${state.loopIteration}/${state.loopMaxIterations}`, 'bold')}`);
-        const result = await runAgent(state.loopPrompt, state);
-        // Check completion promise
-        if (state.loopCompletionPromise && result.includes(state.loopCompletionPromise)) {
-            console.log(`${color('🎉 Completion promise detected!', 'green')}`);
-            state.loopActive = false;
-            break;
-        }
-        if (!state.loopActive)
-            break;
-        // Delay between iterations
-        await new Promise(r => setTimeout(r, 1000));
-    }
-    if (state.loopIteration >= state.loopMaxIterations) {
-        console.log(`${color('⚠️ Max iterations reached', 'yellow')}`);
-    }
-    state.loopActive = false;
-    console.log();
-}
-/**
- * Print tool call
- */
-function printToolCall(toolCall) {
-    const icons = {
-        shell: '⚡',
-        read_file: '📄',
-        write_file: '✍️',
-        list_files: '📁',
-        think: '💭',
-    };
-    console.log();
-    console.log(`${color('╭─', 'dim')} ${icons[toolCall.name] || '⚙️'} ${color(toolCall.name, 'yellow')}`);
-    if (toolCall.name === 'shell' && toolCall.arguments.command) {
-        console.log(`${color('│', 'dim')}  ${color('$', 'green')} ${toolCall.arguments.command}`);
-    }
-    else if (toolCall.name === 'think' && toolCall.arguments.thought) {
-        const thought = String(toolCall.arguments.thought);
-        const preview = thought.length > 80 ? thought.substring(0, 80) + '...' : thought;
-        console.log(`${color('│', 'dim')}  ${color(preview, 'dim')}`);
-    }
-}
-/**
- * Print tool result
- */
-function printToolResult(name, result) {
-    if (name === 'think') {
-        console.log(`${color('╰─', 'dim')} ${color('✓', 'green')}`);
-        return;
-    }
-    const lines = result.split('\n').slice(0, 10);
-    for (const line of lines) {
-        console.log(`${color('│', 'dim')}  ${color(line.substring(0, 100), 'dim')}`);
-    }
-    if (result.split('\n').length > 10) {
-        console.log(`${color('│', 'dim')}  ${color(`... (${result.split('\n').length - 10} more lines)`, 'dim')}`);
-    }
-    const success = !result.toLowerCase().includes('error');
-    console.log(`${color('╰─', 'dim')} ${success ? color('✓', 'green') : color('✗', 'red')}`);
-}
-/**
- * Print output with indentation
- */
-function printOutput(text) {
-    const lines = text.split('\n');
-    for (const line of lines) {
-        console.log(`${color('│', 'blue')} ${line}`);
-    }
-}
-//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=commands.js.map