prism-mcp-server 20.0.6 → 20.0.7

package/dist/agent/platformUtils.js

@@ -0,0 +1,470 @@
+/**
+ * Platform Utilities — Cross-platform abstractions for Prism CLI
+ * ================================================================
+ *
+ * Provides OS-aware implementations for shell commands, file operations,
+ * and system tools. Supports macOS, Linux, and Windows 10+.
+ *
+ * Key design decisions:
+ * - Never hardcode paths like /tmp/ or /opt/homebrew/
+ * - Always auto-detect binary locations via PATH
+ * - Use PowerShell on Windows for complex pipelines
+ * - Provide graceful fallbacks on every platform
+ */
+import { execSync } from 'child_process';
+import * as os from 'os';
+import * as path from 'path';
+export const IS_WINDOWS = process.platform === 'win32';
+export const IS_MAC = process.platform === 'darwin';
+export const IS_LINUX = process.platform === 'linux';
+// ---------------------------------------------------------------------------
+// ANSI / Terminal
+// ---------------------------------------------------------------------------
+/**
+ * Enable ANSI escape sequence processing on Windows.
+ * Windows Terminal supports ANSI natively, but legacy cmd.exe and
+ * ConHost need ENABLE_VIRTUAL_TERMINAL_PROCESSING (0x0004) set
+ * on the console output handle. Node.js does NOT set this by default.
+ *
+ * Call this once at CLI startup.
+ */
+export function enableAnsiOnWindows() {
+    if (!IS_WINDOWS)
+        return;
+    // Windows Terminal already supports ANSI — check via WT_SESSION env
+    if (process.env.WT_SESSION)
+        return;
+    try {
+        // Use PowerShell to flip the VT processing bit on the console
+        execSync(`powershell -NoProfile -Command "` +
+            `$k = Add-Type -MemberDefinition '` +
+            `[DllImport(\\\"kernel32.dll\\\")]public static extern IntPtr GetStdHandle(int h);` +
+            `[DllImport(\\\"kernel32.dll\\\")]public static extern bool GetConsoleMode(IntPtr h,out int m);` +
+            `[DllImport(\\\"kernel32.dll\\\")]public static extern bool SetConsoleMode(IntPtr h,int m);` +
+            `' -Name K -PassThru;` +
+            `$h=[K]::GetStdHandle(-11);$m=0;[K]::GetConsoleMode($h,[ref]$m);` +
+            `[K]::SetConsoleMode($h,$m -bor 4)"`, { stdio: 'pipe', timeout: 5000 });
+    }
+    catch {
+        // Silently fail — colors just won't render in legacy terminals
+    }
+}
+/** Whether the terminal likely supports ANSI colors */
+export function supportsAnsi() {
+    if (IS_WINDOWS) {
+        // Windows Terminal, VS Code terminal, or ConEmu
+        return !!(process.env.WT_SESSION || process.env.TERM_PROGRAM || process.env.ConEmuANSI);
+    }
+    return process.stdout.isTTY === true;
+}
+// ---------------------------------------------------------------------------
+// Temp directory — NEVER use /tmp/ directly
+// ---------------------------------------------------------------------------
+/** Get a cross-platform temp file path */
+export function tempPath(filename) {
+    return path.join(os.tmpdir(), filename);
+}
+// ---------------------------------------------------------------------------
+// Shell / Command helpers
+// ---------------------------------------------------------------------------
+/** The shell to use for PowerShell commands on Windows */
+export function windowsShell() {
+    return IS_WINDOWS ? 'powershell.exe' : undefined;
+}
+/** Open a URL in the default browser */
+export function openUrlCommand(url) {
+    if (IS_WINDOWS)
+        return `start "" "${url}"`;
+    if (IS_MAC)
+        return `open "${url}"`;
+    return `xdg-open "${url}"`; // Linux
+}
+/**
+ * Locate a CLI binary on any platform.
+ * Returns the resolved path or null if not found.
+ */
+export function findBinary(name) {
+    try {
+        const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
+        const result = execSync(cmd, { stdio: 'pipe', timeout: 5000 }).toString().trim();
+        // `where` on Windows may return multiple lines — take the first
+        return result.split('\n')[0]?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve a CLI tool path — tries PATH first, then common install locations.
+ * Falls back to bare command name (relies on PATH at runtime).
+ */
+export function resolveCli(name) {
+    // Try PATH first
+    const inPath = findBinary(name);
+    if (inPath)
+        return `"${inPath}"`;
+    // macOS Homebrew fallback locations
+    if (IS_MAC) {
+        const homebrewPaths = [
+            `/opt/homebrew/bin/${name}`,
+            `/usr/local/bin/${name}`,
+        ];
+        for (const p of homebrewPaths) {
+            try {
+                execSync(`test -f "${p}"`, { stdio: 'pipe' });
+                return `"${p}"`;
+            }
+            catch { /* not found */ }
+        }
+    }
+    // Windows: try common install paths
+    if (IS_WINDOWS) {
+        const winPaths = [
+            path.join(os.homedir(), 'AppData', 'Roaming', 'npm', `${name}.cmd`),
+            path.join(os.homedir(), 'AppData', 'Local', 'Programs', name, `${name}.exe`),
+            path.join('C:', 'Program Files', name, `${name}.exe`),
+            path.join(os.homedir(), 'scoop', 'shims', `${name}.exe`),
+        ];
+        for (const p of winPaths) {
+            try {
+                execSync(`if exist "${p}" echo found`, { stdio: 'pipe', shell: 'cmd.exe' });
+                return `"${p}"`;
+            }
+            catch { /* not found */ }
+        }
+    }
+    // Bare name — hope it's in PATH at runtime
+    return name;
+}
+// ---------------------------------------------------------------------------
+// fetch_url — cross-platform HTML fetching
+// ---------------------------------------------------------------------------
+/**
+ * Build the shell command to fetch and strip HTML from a URL.
+ * Uses curl on Unix, PowerShell Invoke-WebRequest on Windows.
+ */
+export function fetchUrlCommand(url) {
+    const safeUrl = url.replace(/"/g, '\\"');
+    if (IS_WINDOWS) {
+        // PowerShell pipeline: strip HTML tags, collapse whitespace
+        const psUrl = url.replace(/'/g, "''");
+        return (`powershell -NoProfile -Command "& { ` +
+            `$r = Invoke-WebRequest -Uri '${psUrl}' -UseBasicParsing -TimeoutSec 15; ` +
+            `$t = $r.Content -replace '<script[^>]*>[\\s\\S]*?</script>','' ` +
+            `-replace '<style[^>]*>[\\s\\S]*?</style>','' ` +
+            `-replace '<[^>]+>','' -replace '\\s+',' '; ` +
+            `$t.Substring(0, [Math]::Min($t.Length, 8000)) }"`);
+    }
+    // macOS / Linux: curl + sed pipeline
+    const curlBase = `curl -sL --max-time 15 --max-filesize 1048576 -H "User-Agent: Mozilla/5.0" "${safeUrl}"`;
+    return (`${curlBase} | ` +
+        `sed 's/<script[^>]*>.*<\\/script>//gi' | ` +
+        `sed 's/<style[^>]*>.*<\\/style>//gi' | ` +
+        `sed 's/<[^>]*>//g' | ` +
+        `tr -s '[:space:]' '\\n' | ` +
+        `sed '/^$/d' | head -300`);
+}
+// ---------------------------------------------------------------------------
+// list_files — cross-platform directory listing
+// ---------------------------------------------------------------------------
+export function listFilesCommand(dir, maxDepth, pattern) {
+    if (IS_WINDOWS) {
+        // PowerShell: Get-ChildItem with depth and exclusions
+        const psDir = dir.replace(/'/g, "''");
+        let cmd = `powershell -NoProfile -Command "Get-ChildItem -Path '${psDir}' -Recurse -Depth ${maxDepth}`;
+        cmd += ` | Where-Object { $_.FullName -notmatch 'node_modules|\\.git' }`;
+        if (pattern) {
+            cmd += ` | Where-Object { $_.Name -like '${pattern.replace(/'/g, "''")}' }`;
+        }
+        cmd += ` | Select-Object -First 100 -ExpandProperty FullName"`;
+        return cmd;
+    }
+    // macOS / Linux: find
+    let cmd = `find "${dir}" -maxdepth ${maxDepth} -not -path '*/node_modules/*' -not -path '*/.git/*'`;
+    if (pattern) {
+        cmd += ` -name "${pattern}"`;
+    }
+    cmd += ' | head -100 | sort';
+    return cmd;
+}
+// ---------------------------------------------------------------------------
+// search_files — cross-platform text search
+// ---------------------------------------------------------------------------
+export function searchFilesCommand(query, dir, maxResults, filePattern) {
+    const escapedQuery = query.replace(/"/g, '\\"');
+    // Try ripgrep first (cross-platform, fast)
+    if (findBinary('rg')) {
+        let cmd = `rg --no-heading --line-number --max-count=${maxResults}`;
+        if (filePattern)
+            cmd += ` -g "${filePattern}"`;
+        cmd += ` "${escapedQuery}" "${dir}" 2>${IS_WINDOWS ? 'NUL' : '/dev/null'}`;
+        cmd += IS_WINDOWS ? '' : ' | head -50';
+        return cmd;
+    }
+    // Windows fallback: findstr
+    if (IS_WINDOWS) {
+        return `findstr /S /N /I /C:"${escapedQuery}" "${dir}\\*${filePattern || '.*'}"`;
+    }
+    // Unix fallback: grep -r
+    let cmd = `grep -rn "${escapedQuery}" "${dir}"`;
+    if (filePattern)
+        cmd += ` --include="${filePattern}"`;
+    cmd += ' | head -50';
+    return cmd;
+}
+// ---------------------------------------------------------------------------
+// Multimodal — cross-platform voice/camera/TTS/clipboard
+// ---------------------------------------------------------------------------
+/** TTS command: read text aloud */
+export function ttsCommand(text, rate = 190) {
+    const safe = text.replace(/"/g, '\\"').slice(0, 3000);
+    if (IS_MAC) {
+        return `say -r ${rate} "${safe}"`;
+    }
+    if (IS_WINDOWS) {
+        // PowerShell System.Speech (built into Windows, no install needed)
+        const psText = safe.replace(/'/g, "''");
+        const psRate = Math.max(-10, Math.min(10, Math.round((rate - 150) / 25)));
+        return (`powershell -NoProfile -Command "` +
+            `Add-Type -AssemblyName System.Speech; ` +
+            `$s = New-Object System.Speech.Synthesis.SpeechSynthesizer; ` +
+            `$s.Rate = ${psRate}; ` +
+            `$s.Speak('${psText}')"`);
+    }
+    // Linux: try espeak-ng first (modern), then espeak, then spd-say
+    if (findBinary('espeak-ng')) {
+        return `espeak-ng -s ${rate} "${safe}"`;
+    }
+    if (findBinary('espeak')) {
+        return `espeak -s ${rate} "${safe}"`;
+    }
+    if (findBinary('spd-say')) {
+        return `spd-say "${safe}"`;
+    }
+    return `echo "TTS unavailable — install espeak-ng: sudo apt install espeak-ng"`;
+}
+/** Clipboard paste image to file path */
+export function clipboardImageCommand(outputPath) {
+    if (IS_MAC) {
+        if (findBinary('pngpaste')) {
+            return { cmd: `pngpaste "${outputPath}"`, available: true };
+        }
+        return { cmd: '', available: false };
+    }
+    if (IS_WINDOWS) {
+        // PowerShell: save clipboard image — works on all Windows 10+
+        const psPath = outputPath.replace(/'/g, "''");
+        const ps = (`Add-Type -AssemblyName System.Windows.Forms; ` +
+            `$img = [System.Windows.Forms.Clipboard]::GetImage(); ` +
+            `if ($img) { $img.Save('${psPath}') } ` +
+            `else { throw 'No image in clipboard' }`);
+        return { cmd: `powershell -NoProfile -Command "${ps}"`, available: true };
+    }
+    // Linux: xclip → xsel → wl-paste (Wayland)
+    if (findBinary('xclip')) {
+        return { cmd: `xclip -selection clipboard -t image/png -o > "${outputPath}"`, available: true };
+    }
+    if (findBinary('wl-paste')) {
+        return { cmd: `wl-paste --type image/png > "${outputPath}"`, available: true };
+    }
+    return { cmd: '', available: false };
+}
+/**
+ * Camera capture command — auto-detects webcam device on each platform.
+ *
+ * macOS: imagesnap (simple, reliable)
+ * Windows: ffmpeg with DirectShow — auto-lists devices to find webcam name
+ * Linux: ffmpeg with v4l2 — uses /dev/video0 by default
+ */
+export function cameraCaptureCommand(outputPath) {
+    if (IS_MAC) {
+        if (findBinary('imagesnap')) {
+            return { cmd: `imagesnap -w 1 "${outputPath}"`, available: true, waitMs: 3000 };
+        }
+        // ffmpeg fallback on macOS
+        if (findBinary('ffmpeg')) {
+            return {
+                cmd: `ffmpeg -f avfoundation -framerate 30 -i "0" -frames:v 1 -y "${outputPath}" 2>/dev/null`,
+                available: true,
+                waitMs: 3000,
+            };
+        }
+        return { cmd: '', available: false, waitMs: 0 };
+    }
+    if (IS_WINDOWS) {
+        if (findBinary('ffmpeg')) {
+            // Auto-detect webcam device name via DirectShow listing
+            let deviceName = 'Integrated Camera'; // sensible default
+            try {
+                const listOutput = execSync('ffmpeg -list_devices true -f dshow -i dummy 2>&1', { stdio: 'pipe', timeout: 5000, shell: 'cmd.exe' }).toString();
+                // Parse: DirectShow video devices — find first video device
+                const videoMatch = listOutput.match(/\] "([^"]+)"\s*\n.*Alternative name/);
+                if (videoMatch?.[1]) {
+                    deviceName = videoMatch[1];
+                }
+            }
+            catch (e) {
+                // ffmpeg -list_devices returns exit code 1 but stderr has the data
+                const stderr = e?.stderr?.toString() || '';
+                const videoMatch = stderr.match(/\] "([^"]+)"\s*\r?\n.*Alternative name/);
+                if (videoMatch?.[1]) {
+                    deviceName = videoMatch[1];
+                }
+            }
+            return {
+                cmd: `ffmpeg -f dshow -i video="${deviceName}" -frames:v 1 -y "${outputPath}" 2>NUL`,
+                available: true,
+                waitMs: 5000,
+            };
+        }
+        return { cmd: '', available: false, waitMs: 0 };
+    }
+    // Linux: ffmpeg with v4l2 — auto-detect video device
+    if (findBinary('ffmpeg')) {
+        let device = '/dev/video0';
+        try {
+            // Check if v4l2-ctl is available for better detection
+            if (findBinary('v4l2-ctl')) {
+                const devOutput = execSync('v4l2-ctl --list-devices 2>/dev/null', {
+                    stdio: 'pipe',
+                    timeout: 3000,
+                }).toString();
+                const devMatch = devOutput.match(/(\/dev\/video\d+)/);
+                if (devMatch?.[1])
+                    device = devMatch[1];
+            }
+        }
+        catch { /* use default */ }
+        return {
+            cmd: `ffmpeg -f v4l2 -i ${device} -frames:v 1 -y "${outputPath}" 2>/dev/null`,
+            available: true,
+            waitMs: 3000,
+        };
+    }
+    return { cmd: '', available: false, waitMs: 0 };
+}
+// ---------------------------------------------------------------------------
+// Voice recording — cross-platform
+// ---------------------------------------------------------------------------
+/** Voice recording binary path per platform */
+export function avlistenPath() {
+    if (IS_WINDOWS) {
+        return path.join(os.homedir(), '.cache', 'synalux', 'avlisten.exe');
+    }
+    return path.join(os.homedir(), '.cache', 'synalux', 'avlisten');
+}
+/**
+ * Cross-platform audio recording command.
+ * Used as a FALLBACK when avlisten is not available.
+ *
+ * Records a WAV file that can be sent to Gemini for transcription.
+ * Returns { cmd, available, outputPath }.
+ */
+export function audioRecordCommand(durationSec) {
+    const outPath = tempPath('prism-voice-recording.wav');
+    if (IS_MAC) {
+        // SoX (brew install sox) — most reliable
+        if (findBinary('sox')) {
+            return {
+                cmd: `sox -d -r 16000 -c 1 -b 16 "${outPath}" trim 0 ${durationSec}`,
+                available: true,
+                outputPath: outPath,
+                format: 'audio/wav',
+            };
+        }
+        // ffmpeg with AVFoundation
+        if (findBinary('ffmpeg')) {
+            return {
+                cmd: `ffmpeg -f avfoundation -i ":0" -t ${durationSec} -ar 16000 -ac 1 -y "${outPath}" 2>/dev/null`,
+                available: true,
+                outputPath: outPath,
+                format: 'audio/wav',
+            };
+        }
+        return { cmd: '', available: false, outputPath: '', format: '' };
+    }
+    if (IS_WINDOWS) {
+        // SoX for Windows
+        if (findBinary('sox')) {
+            return {
+                cmd: `sox -d -r 16000 -c 1 -b 16 "${outPath}" trim 0 ${durationSec}`,
+                available: true,
+                outputPath: outPath,
+                format: 'audio/wav',
+            };
+        }
+        // ffmpeg with DirectShow audio
+        if (findBinary('ffmpeg')) {
+            // Auto-detect microphone
+            let micName = 'Microphone';
+            try {
+                const listOutput = execSync('ffmpeg -list_devices true -f dshow -i dummy 2>&1', { stdio: 'pipe', timeout: 5000, shell: 'cmd.exe' }).toString();
+                const audioMatch = listOutput.match(/DirectShow audio devices[\s\S]*?\] "([^"]+)"/);
+                if (audioMatch?.[1])
+                    micName = audioMatch[1];
+            }
+            catch (e) {
+                const stderr = e?.stderr?.toString() || '';
+                const audioMatch = stderr.match(/DirectShow audio devices[\s\S]*?\] "([^"]+)"/);
+                if (audioMatch?.[1])
+                    micName = audioMatch[1];
+            }
+            return {
+                cmd: `ffmpeg -f dshow -i audio="${micName}" -t ${durationSec} -ar 16000 -ac 1 -y "${outPath}" 2>NUL`,
+                available: true,
+                outputPath: outPath,
+                format: 'audio/wav',
+            };
+        }
+        // PowerShell + .NET AudioEndpoints as last resort
+        return {
+            cmd: `powershell -NoProfile -Command "Add-Type -AssemblyName System.Speech; $r = New-Object System.Speech.Recognition.SpeechRecognitionEngine; $r.SetInputToDefaultAudioDevice(); $r.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar)); $result = $r.Recognize((New-Object TimeSpan(0,0,${durationSec}))); if($result){$result.Text}else{'(no speech detected)'}"`,
+            available: true,
+            outputPath: '', // returns text directly, not a file
+            format: 'text',
+        };
+    }
+    // Linux
+    // arecord (ALSA) — most common on Linux
+    if (findBinary('arecord')) {
+        return {
+            cmd: `arecord -d ${durationSec} -f cd -t wav "${outPath}" 2>/dev/null`,
+            available: true,
+            outputPath: outPath,
+            format: 'audio/wav',
+        };
+    }
+    // SoX
+    if (findBinary('sox')) {
+        return {
+            cmd: `sox -d -r 16000 -c 1 -b 16 "${outPath}" trim 0 ${durationSec}`,
+            available: true,
+            outputPath: outPath,
+            format: 'audio/wav',
+        };
+    }
+    // ffmpeg PulseAudio
+    if (findBinary('ffmpeg')) {
+        return {
+            cmd: `ffmpeg -f pulse -i default -t ${durationSec} -ar 16000 -ac 1 -y "${outPath}" 2>/dev/null`,
+            available: true,
+            outputPath: outPath,
+            format: 'audio/wav',
+        };
+    }
+    return { cmd: '', available: false, outputPath: '', format: '' };
+}
+/**
+ * Get install instructions for voice recording tools.
+ */
+export function voiceInstallInstructions() {
+    if (IS_MAC)
+        return 'Install SoX: brew install sox';
+    if (IS_WINDOWS)
+        return 'Install SoX: choco install sox  OR  winget install sox  OR install ffmpeg';
+    return 'Install arecord (ALSA): sudo apt install alsa-utils  OR  SoX: sudo apt install sox';
+}
+/** Dev null path by platform */
+export function devNull() {
+    return IS_WINDOWS ? 'NUL' : '/dev/null';
+}

package/dist/agent/terminalUI.js

@@ -0,0 +1,198 @@
+/**
+ * Terminal UI — ANSI Color Formatting for Prism Agent Terminal
+ * =============================================================
+ *
+ * Provides rich terminal output matching the Synalux VS Code extension's
+ * purple/cyan/green color scheme. Uses ANSI escape codes for colors,
+ * bold, dim, italic, and underline formatting.
+ */
+// ---------------------------------------------------------------------------
+// ANSI Escape Codes
+// ---------------------------------------------------------------------------
+const ESC = '\x1b[';
+export const c = {
+    // Reset
+    reset: `${ESC}0m`,
+    // Styles
+    bold: `${ESC}1m`,
+    dim: `${ESC}2m`,
+    italic: `${ESC}3m`,
+    underline: `${ESC}4m`,
+    // Brand colors (256-color mode)
+    purple: `${ESC}38;5;141m`, // Primary brand — headers, prompts
+    cyan: `${ESC}38;5;81m`, // Tools, actions
+    green: `${ESC}38;5;114m`, // Success, code
+    yellow: `${ESC}38;5;221m`, // Warnings
+    red: `${ESC}38;5;203m`, // Errors
+    blue: `${ESC}38;5;75m`, // Info, links
+    white: `${ESC}38;5;255m`, // AI response text
+    gray: `${ESC}38;5;245m`, // Dim text, timestamps
+    orange: `${ESC}38;5;215m`, // Highlights
+    // Backgrounds
+    bgPurple: `${ESC}48;5;141m`,
+    bgCyan: `${ESC}48;5;81m`,
+    bgDim: `${ESC}48;5;236m`,
+};
+// ---------------------------------------------------------------------------
+// Formatting Helpers
+// ---------------------------------------------------------------------------
+/** Calculate the visible terminal width of a string (strips ANSI, accounts for double-width chars) */
+function visibleWidth(str) {
+    // Strip ANSI escape codes
+    const stripped = str.replace(/\x1b\[[0-9;]*m/g, '');
+    let width = 0;
+    for (const char of stripped) {
+        const cp = char.codePointAt(0) || 0;
+        // Surrogate pair / astral plane characters (emoji, symbols) = 2 columns
+        if (cp > 0xFFFF) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+/** Pad a visible string to a fixed column width */
+function padLine(visible, targetWidth) {
+    const w = visibleWidth(visible);
+    const padding = Math.max(0, targetWidth - w);
+    return visible + ' '.repeat(padding);
+}
+/** Print the startup header — compact VS Code-style top bar */
+export function printBanner(opts) {
+    console.log('');
+    // ─── Top bar: Prism Agent  CLOUD  ✨ Model  👤 user  PLAN ──
+    const cloudBadge = `${c.bgCyan}${c.bold} CLOUD ${c.reset}`;
+    const modelChip = opts.model ? `${c.bgDim} ✨ ${c.bold}${opts.model} ${c.reset}` : '';
+    const userStr = opts.name || opts.email || '';
+    const userChip = userStr ? `  ${c.dim}👤${c.reset} ${userStr}` : '';
+    const planBadge = opts.plan ? `  ${c.bgPurple}${c.bold} ${opts.plan.toUpperCase()} ${c.reset}` : '';
+    console.log(`  ${c.bold}${c.purple}Prism Agent${c.reset}  ${cloudBadge}  ${modelChip}${userChip}${planBadge}`);
+    // ─── Sub-bar: project · cwd · tools ───────────────────────
+    const cwdShort = opts.cwd.length > 30 ? '...' + opts.cwd.slice(-27) : opts.cwd;
+    const mcpStr = opts.mcpServers ? `  ${c.dim}·${c.reset}  ${opts.mcpServers} MCP` : '';
+    console.log(`  ${c.dim}📂 ${opts.project}  ·  📁 ${cwdShort}  ·  🔧 ${opts.toolCount} tools${mcpStr}${c.reset}`);
+    console.log('');
+}
+/** Build the input prompt string — clean prompt for the text input line */
+export function buildPromptStr() {
+    return `${c.purple}${c.bold}❯${c.reset} `;
+}
+/** Action button definitions with keyboard shortcuts */
+export const ACTION_BUTTONS = [
+    { icon: '📂', label: 'Image', cmd: '/image', key: '^I' },
+    { icon: '📎', label: 'Paste', cmd: '/paste', key: '^P' },
+    { icon: '🎤', label: 'Voice', cmd: '/voice', key: '^V' },
+    { icon: '💬', label: 'Speak', cmd: '/speak', key: '^S' },
+];
+/**
+ * Print the action buttons bar with keyboard shortcuts underneath.
+ * Example output:
+ *    📂 Image   📎 Paste   🎤 Voice   💬 Speak
+ *      ^I         ^P         ^V         ^S
+ */
+export function printActionBar() {
+    // Top line: icons + labels
+    const topParts = ACTION_BUTTONS.map(b => `${c.bgDim} ${b.icon} ${c.cyan}${b.label}${c.reset}${c.bgDim} ${c.reset}`);
+    console.log(`  ${topParts.join(' ')}`);
+    // Bottom line: keyboard shortcuts aligned under each button
+    const shortcutParts = ACTION_BUTTONS.map(b => {
+        // Pad shortcut to match button width: " icon label " = 2+label.length+2 = label.length+4
+        const btnWidth = b.label.length + 4; // space + emoji(2) + space + label
+        const pad = Math.max(0, Math.floor((btnWidth - b.key.length) / 2));
+        return ' '.repeat(pad) + `${c.dim}${b.key}${c.reset}` + ' '.repeat(Math.max(0, btnWidth - pad - b.key.length));
+    });
+    console.log(`  ${shortcutParts.join(' ')}`);
+    console.log(`  ${c.dim}Enter for menu · / + Tab for commands${c.reset}`);
+    console.log('');
+}
+/** Show readline-based action menu as fallback (Enter on empty line) */
+export function showActionMenu(rl) {
+    return new Promise((resolve) => {
+        console.log(`\n  ${c.bold}${c.purple}⚡ Actions${c.reset}`);
+        for (let i = 0; i < ACTION_BUTTONS.length; i++) {
+            const item = ACTION_BUTTONS[i];
+            console.log(`  ${c.cyan}${c.bold}${i + 1}${c.reset} ${item.icon}  ${item.label}`);
+        }
+        console.log('');
+        rl.question(`  ${c.dim}Select (1-${ACTION_BUTTONS.length}) or Enter to cancel:${c.reset} `, (answer) => {
+            const num = parseInt(answer.trim(), 10);
+            if (num >= 1 && num <= ACTION_BUTTONS.length) {
+                resolve(ACTION_BUTTONS[num - 1].cmd);
+            }
+            else {
+                resolve(null);
+            }
+        });
+    });
+}
+/** Format a tool call for display */
+export function formatToolCall(name, args) {
+    const argsStr = JSON.stringify(args);
+    const truncated = argsStr.length > 80 ? argsStr.substring(0, 77) + '...' : argsStr;
+    return `  ${c.cyan}${c.bold}⚡ ${name}${c.reset}${c.dim}(${truncated})${c.reset}`;
+}
+/** Format a tool result summary */
+export function formatToolResult(name, success) {
+    return success
+        ? `  ${c.green}✓${c.reset} ${c.dim}${name} completed${c.reset}`
+        : `  ${c.red}✗${c.reset} ${c.dim}${name} failed${c.reset}`;
+}
+/** Format an AI response */
+export function formatResponse(text) {
+    // Highlight code blocks with green
+    let formatted = text.replace(/```(\w+)?\n([\s\S]*?)```/g, (_, lang, code) => `${c.dim}┌─ ${lang || 'code'} ──${c.reset}\n${c.green}${code.trimEnd()}${c.reset}\n${c.dim}└──────${c.reset}`);
+    // Highlight inline code with cyan
+    formatted = formatted.replace(/`([^`]+)`/g, `${c.cyan}$1${c.reset}`);
+    // Highlight bold with white bold
+    formatted = formatted.replace(/\*\*([^*]+)\*\*/g, `${c.bold}${c.white}$1${c.reset}`);
+    return `\n${formatted}\n`;
+}
+/** Format an error */
+export function formatError(message) {
+    return `\n${c.red}${c.bold}✗ Error:${c.reset} ${c.red}${message}${c.reset}\n`;
+}
+/** Format a success message */
+export function formatSuccess(message) {
+    return `${c.green}✓${c.reset} ${message}`;
+}
+/** Format a warning */
+export function formatWarning(message) {
+    return `${c.yellow}⚠${c.reset} ${c.yellow}${message}${c.reset}`;
+}
+/** Format the help menu */
+export function printHelp() {
+    console.log('');
+    console.log(`  ${c.bold}${c.purple}Commands:${c.reset}`);
+    console.log(`  ${c.cyan}/image ${c.dim}<path> [question]${c.reset}  — Analyze an image`);
+    console.log(`  ${c.cyan}/voice ${c.dim}[seconds]${c.reset}          — Record & transcribe speech`);
+    console.log(`  ${c.cyan}/camera ${c.dim}[question]${c.reset}        — Capture photo & analyze`);
+    console.log(`  ${c.cyan}/speak${c.reset}                    — Toggle text-to-speech`);
+    console.log(`  ${c.cyan}/paste${c.reset}                    — Paste clipboard image`);
+    console.log(`  ${c.cyan}/search ${c.dim}<query>${c.reset}            — Search Prism memory`);
+    console.log(`  ${c.cyan}/todos${c.reset}                    — Show open TODOs`);
+    console.log(`  ${c.cyan}/context${c.reset}                  — Show loaded context`);
+    console.log(`  ${c.cyan}/tools${c.reset}                    — List available tools`);
+    console.log(`  ${c.cyan}/exit${c.reset}                     — Quit`);
+    console.log('');
+}
+/** Format MCP connection status */
+export function formatMcpConnect(name, tools, success) {
+    if (success) {
+        return `  ${c.green}✓${c.reset} ${c.bold}${name}${c.reset} ${c.dim}— ${tools.length} tool(s):${c.reset} ${c.cyan}${tools.join(', ')}${c.reset}`;
+    }
+    return `  ${c.red}✗${c.reset} ${c.bold}${name}${c.reset} ${c.dim}— connection failed${c.reset}`;
+}
+/** Format context loaded */
+export function formatContextLoaded(todoCount, keywordCount) {
+    return formatSuccess(`Loaded ${c.bold}${todoCount}${c.reset} TODOs, ${c.bold}${keywordCount}${c.reset} keywords`);
+}
+/** Print thinking indicator on its own line */
+export function printThinking() {
+    console.log(`${c.dim}${c.italic}  thinking...${c.reset}`);
+}
+/** Clear thinking indicator — move cursor up one line and erase it */
+export function clearThinking() {
+    process.stdout.write('\x1b[1A\x1b[2K');
+}