icopilot 2.2.1 → 2.3.2

package/dist/commands/suggest-cmd.js

@@ -1,20 +1,57 @@
+import { execSync } from 'node:child_process';
+import { select, input } from '@inquirer/prompts';
 import { streamChat } from '../api/github-models.js';
 import { theme } from '../ui/theme.js';
+import { box, commandChip } from '../ui/box.js';
+import { copyTextToClipboard } from './clipboard-cmd.js';
 const SUGGEST_SYSTEM_PROMPT = `You translate natural-language requests into exactly one shell command.
 Respond with ONLY the command text.
 Do not explain anything.
 Do not use markdown fences.
 Do not add bullets, labels, or commentary.
 Prefer a safe, direct command that can run in the user's current working directory.`;
-export async function suggestCommand(query, session, signal) {
-    const trimmedQuery = query.trim();
-    if (!trimmedQuery)
-        return theme.warn('usage: /suggest <request>\n');
+const REVISE_SYSTEM_PROMPT = `You are refining a shell command based on user feedback.
+Respond with ONLY the revised command text.
+Do not explain anything.
+Do not use markdown fences.`;
+function detectShell() {
+    const shellEnv = process.env.SHELL ?? '';
+    if (shellEnv.includes('zsh'))
+        return 'zsh';
+    if (shellEnv.includes('fish'))
+        return 'fish';
+    if (shellEnv.includes('bash'))
+        return 'bash';
+    if (process.platform === 'win32')
+        return 'powershell';
+    return 'bash';
+}
+async function pickShell() {
+    const detected = detectShell();
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return detected;
+    }
+    const allShells = [
+        { name: `${detected} (detected)`, value: detected },
+        { name: 'bash', value: 'bash' },
+        { name: 'zsh', value: 'zsh' },
+        { name: 'fish', value: 'fish' },
+        { name: 'powershell', value: 'powershell' },
+        { name: 'cmd', value: 'cmd' },
+    ];
+    return select({
+        message: 'What shell are you targeting?',
+        choices: allShells.filter((c, i) => i === 0 || c.value !== detected),
+    });
+}
+async function generateCommand(query, shell, session, signal, priorCommand, revision) {
     const messages = [
-        { role: 'system', content: SUGGEST_SYSTEM_PROMPT },
+        { role: 'system', content: revision ? REVISE_SYSTEM_PROMPT : SUGGEST_SYSTEM_PROMPT },
         {
             role: 'user',
-            content: `Current working directory: ${session.state.cwd}\nRequest: ${trimmedQuery}`,
+            content: revision
+                ? `Original request: ${query}\nOriginal command: ${priorCommand}\nFeedback: ${revision}\nTarget shell: ${shell}\nCWD: ${session.state.cwd}`
+                : `Target shell: ${shell}\nCurrent working directory: ${session.state.cwd}\nRequest: ${query}`,
         },
     ];
     let suggestion = '';
@@ -27,8 +64,111 @@ export async function suggestCommand(query, session, signal) {
             suggestion += token;
         },
     });
-    const command = sanitizeSuggestion(result.content || suggestion);
-    return `${theme.brand('Suggested command')}\n  ${theme.hl(command)}\n`;
+    return sanitizeSuggestion(result.content || suggestion);
+}
+async function explainCommand(command, session, signal) {
+    const messages = [
+        {
+            role: 'system',
+            content: 'Explain the shell command clearly: 1) one-sentence summary, 2) breakdown of each part, 3) any risks. Be concise.',
+        },
+        { role: 'user', content: `Explain: ${command}` },
+    ];
+    process.stdout.write(box('', { title: 'Explanation', style: 'response' }).slice(0, -1) + '\n');
+    let explanation = '';
+    await streamChat({
+        model: session.state.model,
+        messages,
+        temperature: 0.2,
+        signal,
+        onToken: (token) => {
+            explanation += token;
+            process.stdout.write(token);
+        },
+    });
+    process.stdout.write('\n');
+}
+async function executeCommand(command) {
+    process.stdout.write(theme.dim(`\nRunning: ${command}\n\n`));
+    try {
+        execSync(command, { stdio: 'inherit', cwd: process.cwd() });
+        process.stdout.write(theme.ok('\n✔ Command completed\n'));
+    }
+    catch (err) {
+        process.stdout.write(theme.err(`\n✖ Command failed: ${err?.message ?? String(err)}\n`));
+    }
+}
+export async function suggestCommand(query, session, signal) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery)
+        return theme.warn('usage: /suggest <request>\n');
+    const shell = await pickShell();
+    process.stdout.write(theme.dim(`\nGenerating ${shell} command…\n`));
+    let command = await generateCommand(trimmedQuery, shell, session, signal);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return box(commandChip(command), { title: 'Suggested command', style: 'command' });
+    }
+    // Post-suggestion action loop — mirrors GitHub Copilot CLI's interactive UX
+    let running = true;
+    while (running) {
+        process.stdout.write('\n');
+        process.stdout.write(box(commandChip(command), { title: 'Suggested command', style: 'command' }));
+        let action;
+        try {
+            action = await select({
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Execute this command', value: 'execute' },
+                    { name: 'Copy command to clipboard', value: 'copy' },
+                    { name: 'Explain this command', value: 'explain' },
+                    { name: 'Revise this command', value: 'revise' },
+                    { name: 'Exit', value: 'exit' },
+                ],
+            });
+        }
+        catch {
+            // user Ctrl-C'd the menu
+            running = false;
+            continue;
+        }
+        if (action === 'execute') {
+            await executeCommand(command);
+            running = false;
+        }
+        else if (action === 'copy') {
+            try {
+                await copyTextToClipboard(command);
+                process.stdout.write(theme.ok('✔ Command copied to clipboard\n'));
+            }
+            catch (err) {
+                process.stdout.write(theme.err(`✖ Copy failed: ${err?.message ?? String(err)}\n`));
+            }
+            running = false;
+        }
+        else if (action === 'explain') {
+            await explainCommand(command, session, signal);
+            // continue loop so user can still execute/copy
+        }
+        else if (action === 'revise') {
+            let feedback;
+            try {
+                feedback = await input({ message: 'What should be different?' });
+            }
+            catch {
+                running = false;
+                continue;
+            }
+            if (feedback.trim()) {
+                process.stdout.write(theme.dim('\nRefining command…\n'));
+                command = await generateCommand(trimmedQuery, shell, session, signal, command, feedback);
+            }
+        }
+        else {
+            // exit
+            running = false;
+        }
+    }
+    return '';
 }
 function sanitizeSuggestion(content) {
     const withoutFences = content

package/dist/index.js

@@ -1,5 +1,6 @@
 import './util/perf.js';
 import { enablePerfTrace, markFirstPrompt } from './util/perf.js';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { Command } from 'commander';
 import { runInteractive } from './modes/interactive.js';
@@ -17,6 +18,11 @@ import { openBrowser } from './util/browser.js';
 function friendlyError(err) {
     const message = String(err?.message || err);
     const status = err?.status ?? err?.response?.status;
+    // No token configured at all — catch this before any network error
+    if (!config.token && config.provider === 'github') {
+        return ('Authentication is not configured for provider "github".\n' +
+            '  Set GITHUB_TOKEN, set ICOPILOT_TOKEN, or sign in with `gh auth login`.');
+    }
     if (/GITHUB_TOKEN|ICOPILOT_TOKEN|OPENAI_API_KEY|ANTHROPIC_API_KEY/i.test(message)) {
         if (config.provider === 'github') {
             return ('Authentication is not configured for provider "github".\n' +
@@ -183,12 +189,27 @@ export async function run(opts) {
     });
 }
 export function createProgram() {
+    const _require = createRequire(import.meta.url);
+    // dist/index.js → ../../package.json won't work; resolve from CWD or use __dirname equivalent
+    let pkgVersion = '0.0.0';
+    try {
+        const pkgPath = new URL('../package.json', import.meta.url).pathname;
+        pkgVersion = _require(pkgPath).version;
+    }
+    catch {
+        try {
+            pkgVersion = _require('../../package.json').version;
+        }
+        catch {
+            /* fallback */
+        }
+    }
     const invokedAs = path.basename(process.argv[1] ?? 'icopilot').replace(/\.js$/, '');
     const cliName = ['icopilot', 'icli'].includes(invokedAs) ? invokedAs : 'icopilot';
     const program = new Command()
         .name(cliName)
         .description('iCopilot — terminal-native agentic CLI powered by GitHub Models')
-        .version('2.0.0')
+        .version(pkgVersion)
         .option('-p, --prompt <text>', 'one-shot mode: run a single prompt and exit')
         .option('-m, --model <name>', 'model id (default: gpt-4o-mini)')
         .option('--local', 'use the default local OpenAI-compatible provider (ollama)')

package/dist/modes/interactive.js

@@ -1,4 +1,6 @@
 import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
 import { Session } from '../session/session.js';
 import { theme, banner } from '../ui/theme.js';
 import { createPrompt, prefix } from '../ui/prompt.js';
@@ -35,7 +37,8 @@ export async function runInteractive(initialMode = 'ask', opts = {}) {
     // Apply keybinding configuration
     const keybindingMode = applyKeybindingConfig();
     if (!config.quiet) {
-        process.stdout.write(banner(VERSION, session.state.model));
+        const sessionDir = config.sessionDir ?? path.join(os.homedir(), '.icopilot', 'sessions');
+        process.stdout.write(banner(VERSION, session.state.model, sessionDir));
         if (keybindingMode !== 'default') {
             process.stdout.write(getKeybindingHelp(keybindingMode));
         }

package/dist/modes/tui.js

@@ -85,20 +85,34 @@ export async function runTui(initialMode = 'ask', opts = {}) {
         const chatBottom = Math.max(chatTop, rows - 3);
         const chatHeight = Math.max(1, chatBottom - chatTop + 1);
         writeRaw('\x1b[2J\x1b[H');
-        writeRaw(statusLine(session, cols));
+        writeRaw(statusLine(session, cols, busy));
         const lines = wrapLines(chat.trimEnd(), Math.max(1, cols));
         const visible = lines.slice(-chatHeight);
         for (let i = 0; i < chatHeight; i++) {
             writeRaw(`\x1b[${chatTop + i};1H`);
             writeRaw(pad(visible[i] || '', cols));
         }
+        // separator with thinking indicator
         writeRaw(`\x1b[${Math.max(1, rows - 2)};1H`);
-        writeRaw('─'.repeat(cols));
+        if (busy) {
+            const thinkLabel = ' ◆ Copilot is thinking… ';
+            const sideLen = Math.max(0, Math.floor((cols - thinkLabel.length) / 2));
+            writeRaw('─'.repeat(sideLen) +
+                thinkLabel +
+                '─'.repeat(Math.max(0, cols - sideLen - thinkLabel.length)));
+        }
+        else {
+            writeRaw('─'.repeat(cols));
+        }
         writeRaw(`\x1b[${Math.max(1, rows - 1)};1H`);
-        const prompt = `${busy ? '…' : '❯'} ${rl.line || ''}`;
+        const promptIcon = busy ? '\x1b[33m◆\x1b[0m' : '\x1b[32m❯\x1b[0m';
+        const prompt = `${promptIcon} ${rl.line || ''}`;
         writeRaw(pad(prompt, cols));
         writeRaw(`\x1b[${rows};1H`);
-        writeRaw(pad(busy ? 'Working…' : 'Enter to send • /help for commands', cols));
+        const hint = busy
+            ? '\x1b[2m Ctrl+C to cancel  \x1b[0m'
+            : '\x1b[2m Enter to send  •  /help for commands  •  /suggest for shell commands \x1b[0m';
+        writeRaw(pad(hint, cols));
     };
     const appendCaptured = (chunk) => {
         const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
@@ -240,9 +254,11 @@ export async function runTui(initialMode = 'ask', opts = {}) {
         });
     }
 }
-function statusLine(session, cols) {
+function statusLine(session, cols, busy) {
     const mode = session.state.mode.toUpperCase();
-    const text = ` iCopilot v${VERSION} • model: ${session.state.model} • mode: ${mode}  Ctrl+C to exit`;
+    const modelShort = session.state.model.replace('openai/', '').replace('github/', '');
+    const busyBadge = busy ? ' \x1b[33m◆ WORKING\x1b[0;7m' : '';
+    const text = ` \x1b[1miCopilot\x1b[0;7m v${VERSION}${busyBadge}  │  model: ${modelShort}  │  mode: ${mode}  │  Ctrl+C to exit `;
     return `\x1b[7m${pad(text, cols)}\x1b[0m`;
 }
 function wrapLines(text, width) {

package/dist/tools/shell.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { confirm, input } from '@inquirer/prompts';
+import { select, input } from '@inquirer/prompts';
 import { config } from '../config.js';
 import { theme } from '../ui/theme.js';
 import { toolMemory } from './memory.js';
@@ -8,8 +8,7 @@ import { loadPolicy, shellCommandAllowed } from './policy.js';
 import { assertSandbox } from './sandbox.js';
 import { checkCommandSafety } from './safety.js';
 /**
- * Propose a shell command, require confirmation, then run it.
- * Output is streamed to the terminal AND captured for return.
+ * Propose a shell command with an interactive action menu, then run it.
  */
 export async function proposeAndRun(cmd, opts = {}) {
     const cwd = path.resolve(opts.cwd || config.cwd);
@@ -27,26 +26,35 @@ export async function proposeAndRun(cmd, opts = {}) {
         return { ran: false, exitCode: null, stdout: '', stderr: message };
     }
     if (!config.quiet && !config.jsonOutput) {
-        process.stdout.write('\n' + theme.badge('SHELL') + '\n');
+        process.stdout.write('\n');
+        process.stdout.write(theme.badge('SHELL') + '\n');
         if (opts.explain)
-            process.stdout.write(theme.dim(opts.explain) + '\n');
-        process.stdout.write(theme.hl('  $ ') + cmd + '\n');
+            process.stdout.write(theme.dim('  ' + opts.explain) + '\n');
+        process.stdout.write('\n');
+        process.stdout.write(theme.dim('  ┌─────────────────────────────────────────\n'));
+        process.stdout.write(theme.dim('  │ ') + theme.hl('$ ') + syntaxHighlightShell(cmd) + '\n');
+        process.stdout.write(theme.dim('  └─────────────────────────────────────────\n'));
         process.stdout.write(theme.dim(`  cwd: ${cwd}\n`));
+        process.stdout.write('\n');
     }
     const safety = checkCommandSafety(cmd);
     const remembered = toolMemory.isShellRemembered(cmd);
+    let activeCmd = cmd;
     let ok = false;
     if (config.autoApprove && safety.level !== 'critical') {
         ok = true;
     }
     else if (safety.level === 'critical') {
-        ok = await approveCriticalCommand(safety.reason).catch(() => false);
+        ok = await approveCritical(safety.reason).catch(() => false);
     }
     else if (remembered && safety.level === 'safe') {
         ok = true;
     }
     else {
-        ok = await approveCommand(safety.reason, safety.level === 'warn');
+        const result = await actionMenu(safety.reason, safety.level === 'warn', activeCmd);
+        ok = result.ok;
+        if (result.editedCmd)
+            activeCmd = result.editedCmd;
     }
     if (!ok) {
         if (!config.jsonOutput)
@@ -54,39 +62,139 @@ export async function proposeAndRun(cmd, opts = {}) {
         return { ran: false, exitCode: null, stdout: '', stderr: '' };
     }
     if (!config.autoApprove && !remembered) {
-        const remember = await confirm({
-            message: 'Remember this command for the session?',
-            default: false,
+        const remember = await select({
+            message: 'Remember this command approval for the session?',
+            choices: [
+                { name: 'No', value: false },
+                { name: 'Yes — skip confirmation next time', value: true },
+            ],
         }).catch(() => false);
         if (remember)
-            toolMemory.rememberShell(cmd);
+            toolMemory.rememberShell(activeCmd);
     }
-    return runCaptured(cmd, cwd);
+    return runCaptured(activeCmd, cwd);
 }
-async function approveCommand(reason, warned) {
+/** Interactive 3-choice action menu replacing plain Y/n. */
+async function actionMenu(reason, warned, cmd) {
     if (warned && !config.quiet && !config.jsonOutput) {
-        process.stdout.write(theme.warn(`  Warning: ${reason}\n`));
+        process.stdout.write(theme.warn(`  ⚠  Warning: ${reason}\n\n`));
     }
-    return confirm({
-        message: 'Run this command?',
-        default: false,
+    const action = await select({
+        message: 'What would you like to do?',
+        choices: [
+            { name: '  Run this command', value: 'run' },
+            { name: '  Edit command before running', value: 'edit' },
+            { name: '  Cancel and return to REPL', value: 'cancel' },
+        ],
+    }).catch(() => 'cancel');
+    if (action === 'run')
+        return { ok: true };
+    if (action === 'cancel')
+        return { ok: false };
+    // Edit flow
+    const edited = await input({
+        message: 'Edit command:',
+        default: cmd,
+    }).catch(() => cmd);
+    if (!edited.trim())
+        return { ok: false };
+    process.stdout.write('\n');
+    process.stdout.write(theme.dim('  ┌─────────────────────────────────────────\n'));
+    process.stdout.write(theme.dim('  │ ') + theme.hl('$ ') + syntaxHighlightShell(edited) + '\n');
+    process.stdout.write(theme.dim('  └─────────────────────────────────────────\n\n'));
+    const confirm = await select({
+        message: 'Run the edited command?',
+        choices: [
+            { name: '  Run', value: true },
+            { name: '  Cancel', value: false },
+        ],
     }).catch(() => false);
+    return { ok: Boolean(confirm), editedCmd: edited };
 }
-async function approveCriticalCommand(reason) {
+async function approveCritical(reason) {
     if (config.autoApprove) {
-        if (!config.quiet && !config.jsonOutput) {
-            process.stdout.write(theme.err(`  blocked critical command: ${reason}\n`));
-        }
+        process.stdout.write(theme.err(`  blocked critical command: ${reason}\n`));
         return false;
     }
-    process.stdout.write(theme.err('  !!! CRITICAL COMMAND WARNING !!!\n'));
-    process.stdout.write(theme.err(`  Reason: ${reason}\n`));
+    process.stdout.write(theme.err('\n  !!! CRITICAL COMMAND WARNING !!!\n'));
+    process.stdout.write(theme.err(`  Reason: ${reason}\n\n`));
     const answer = await input({
-        message: 'Type "yes" to run this critical command:',
+        message: 'Type "yes" to proceed with this critical command:',
         default: '',
     }).catch(() => '');
     return answer.trim() === 'yes';
 }
+// ─── Shell syntax highlighter ─────────────────────────────────────────────
+// bright-green command, yellow flags, white strings, purple vars, green paths.
+export function syntaxHighlightShell(line) {
+    // When colors are off, return raw
+    if (process.env.NO_COLOR || config.theme === 'none')
+        return line;
+    const parts = [];
+    let rest = line;
+    let isCmd = true;
+    while (rest.length > 0) {
+        // Whitespace
+        const ws = rest.match(/^(\s+)/);
+        if (ws) {
+            parts.push(ws[1]);
+            rest = rest.slice(ws[1].length);
+            continue;
+        }
+        // Pipeline / logical operators — next word is a command
+        const pipe = rest.match(/^(\|{1,2}|&&|\|\||;;|;)/);
+        if (pipe) {
+            parts.push('\x1b[90m' + pipe[1] + '\x1b[0m');
+            rest = rest.slice(pipe[1].length);
+            isCmd = true;
+            continue;
+        }
+        // Quoted strings (single or double)
+        const str = rest.match(/^(["'])((?:\\.|(?!\1).)*)(\1)/s);
+        if (str) {
+            parts.push('\x1b[97m' + str[0] + '\x1b[0m'); // bright white
+            rest = rest.slice(str[0].length);
+            isCmd = false;
+            continue;
+        }
+        // Variables $VAR or ${VAR}
+        const varT = rest.match(/^(\$\{[^}]+\}|\$\w+)/);
+        if (varT) {
+            parts.push('\x1b[35m' + varT[1] + '\x1b[0m'); // magenta
+            rest = rest.slice(varT[1].length);
+            isCmd = false;
+            continue;
+        }
+        // Flags --flag / -f
+        const flag = rest.match(/^(--?[\w][\w-]*)/);
+        if (flag) {
+            parts.push('\x1b[33m' + flag[1] + '\x1b[0m'); // yellow
+            rest = rest.slice(flag[1].length);
+            isCmd = false;
+            continue;
+        }
+        // Word token (command, path, or plain arg)
+        const word = rest.match(/^([^\s|;&'"$\\]+)/);
+        if (word) {
+            const w = word[1];
+            if (isCmd) {
+                parts.push('\x1b[92m\x1b[1m' + w + '\x1b[0m'); // bright green bold
+                isCmd = false;
+            }
+            else if (/^[./~]/.test(w) || /\//.test(w)) {
+                parts.push('\x1b[32m' + w + '\x1b[0m'); // green (path)
+            }
+            else {
+                parts.push(w);
+            }
+            rest = rest.slice(w.length);
+            continue;
+        }
+        parts.push(rest[0]);
+        rest = rest.slice(1);
+    }
+    return parts.join('');
+}
 function runCaptured(cmd, cwd) {
     return new Promise((resolve) => {
         const isWin = process.platform === 'win32';

package/dist/ui/box.js

@@ -0,0 +1,79 @@
+import { theme } from './theme.js';
+import { size } from './screen.js';
+/**
+ * Render a GitHub Copilot CLI-style bordered panel.
+ *
+ *   ╭─ Copilot ────────────────╮
+ *   │  content line            │
+ *   ╰──────────────────────────╯
+ */
+export function box(content, opts = {}) {
+    const cols = opts.width ?? Math.min(size().cols, 100);
+    const pad = opts.padding ?? 1;
+    const innerWidth = cols - 2; // subtract left/right border chars
+    const title = opts.title ?? '';
+    const topTitle = title ? ` ${title} ` : '';
+    const topFill = innerWidth - topTitle.length;
+    const topLeft = topFill < 0 ? 0 : Math.floor(topFill / 2);
+    const topRight = topFill < 0 ? 0 : topFill - topLeft - (title ? 0 : 0);
+    const top = `╭${'─'.repeat(topLeft)}${topTitle}${'─'.repeat(Math.max(0, topRight))}╮`;
+    const bottom = `╰${'─'.repeat(innerWidth)}╯`;
+    const lines = content.split('\n');
+    const paddingStr = ' '.repeat(pad);
+    const contentWidth = innerWidth - pad * 2;
+    const bodyLines = [];
+    for (const line of lines) {
+        const stripped = stripAnsi(line);
+        if (stripped.length <= contentWidth) {
+            const fill = ' '.repeat(Math.max(0, contentWidth - stripped.length));
+            const colored = line; // keep original ANSI
+            bodyLines.push(`│${paddingStr}${colored}${fill}${paddingStr}│`);
+        }
+        else {
+            // wrap long lines
+            let remaining = line;
+            let remainingStripped = stripped;
+            while (remainingStripped.length > contentWidth) {
+                const chunk = remaining.slice(0, contentWidth);
+                const fill = ' '.repeat(Math.max(0, contentWidth - contentWidth));
+                bodyLines.push(`│${paddingStr}${chunk}${fill}${paddingStr}│`);
+                remaining = remaining.slice(contentWidth);
+                remainingStripped = remainingStripped.slice(contentWidth);
+            }
+            if (remaining.length > 0) {
+                const fill = ' '.repeat(Math.max(0, contentWidth - remainingStripped.length));
+                bodyLines.push(`│${paddingStr}${remaining}${fill}${paddingStr}│`);
+            }
+        }
+    }
+    const styleTop = opts.style === 'command'
+        ? theme.hl(top)
+        : opts.style === 'response'
+            ? theme.brand(top)
+            : theme.dim(top);
+    const styleBottom = opts.style === 'command'
+        ? theme.hl(bottom)
+        : opts.style === 'response'
+            ? theme.brand(bottom)
+            : theme.dim(bottom);
+    const styleSide = (s) => opts.style === 'command'
+        ? theme.hl(s)
+        : opts.style === 'response'
+            ? theme.brand(s)
+            : theme.dim(s);
+    const styledBody = bodyLines.map((l) => {
+        const left = l.slice(0, 1);
+        const right = l.slice(-1);
+        const mid = l.slice(1, -1);
+        return `${styleSide(left)}${mid}${styleSide(right)}`;
+    });
+    return [styleTop, ...styledBody, styleBottom].join('\n') + '\n';
+}
+/** Single-line command display (compact version for inline command rendering). */
+export function commandChip(cmd) {
+    return `${theme.hl('❯')} ${theme.hl(cmd)}`;
+}
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+}