@element47/ag 4.4.0

package/dist/cli/repl.js

@@ -0,0 +1,599 @@
+import { createInterface } from 'node:readline';
+import { loadConfig, saveConfig, configPath } from '../core/config.js';
+import { searchRegistry, installSkill, removeSkill, formatInstalls } from '../core/registry.js';
+import { C, renderMarkdown } from '../core/colors.js';
+import { VERSION } from '../core/version.js';
+function truncateCommand(command, maxLen = 80) {
+    const firstLine = command.split('\n')[0];
+    if (firstLine.length <= maxLen) {
+        return command.split('\n').length > 1 ? firstLine + ' ...' : firstLine;
+    }
+    return firstLine.slice(0, maxLen) + '...';
+}
+function formatToolSummary(toolName, args) {
+    switch (toolName) {
+        case 'bash': return `bash: ${truncateCommand(String(args.command || '(empty)'))}`;
+        case 'file': return `file(${args.action}): ${args.path || ''}`;
+        case 'git': return `git(${args.action})${args.message ? `: "${args.message}"` : ''}`;
+        case 'web': return `web(${args.action}): ${args.url || args.query || ''}`;
+        default: return `${toolName}(${JSON.stringify(args).slice(0, 80)})`;
+    }
+}
+export function createConfirmCallback(sharedRl) {
+    const cb = async (toolName, args) => {
+        // Stop any active spinner before prompting
+        if (cb.pauseSpinner) {
+            cb.pauseSpinner();
+            cb.pauseSpinner = null;
+        }
+        const summary = formatToolSummary(toolName, args);
+        if (sharedRl) {
+            return new Promise(resolve => {
+                sharedRl.question(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset} ${C.yellow}(y/n)${C.reset} `, answer => {
+                    resolve(answer.trim().toLowerCase() === 'n' ? 'deny' : 'allow');
+                });
+            });
+        }
+        // Fallback: create a temporary readline (non-REPL usage)
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        return new Promise(resolve => {
+            rl.question(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset} ${C.yellow}(y/n)${C.reset} `, answer => {
+                rl.close();
+                resolve(answer.trim().toLowerCase() === 'n' ? 'deny' : 'allow');
+            });
+        });
+    };
+    cb.pauseSpinner = null;
+    return cb;
+}
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function startSpinner(label) {
+    if (!process.stderr.isTTY)
+        return () => { };
+    let i = 0;
+    process.stderr.write(`  ${C.dim}${SPINNER_FRAMES[0]} ${label}${C.reset}\n`);
+    const id = setInterval(() => {
+        process.stderr.write(`\x1b[A\x1b[K  ${C.dim}${SPINNER_FRAMES[i++ % SPINNER_FRAMES.length]} ${label}${C.reset}\n`);
+    }, 80);
+    return () => { clearInterval(id); process.stderr.write('\x1b[A\x1b[K'); };
+}
+function maskKey(key) {
+    if (key.length <= 8)
+        return '****';
+    return key.slice(0, 8) + '****';
+}
+export class REPL {
+    agent;
+    rl;
+    confirmCb;
+    constructor(agent, confirmCb) {
+        this.agent = agent;
+        this.rl = createInterface({ input: process.stdin, output: process.stderr });
+        // Rebind the confirm callback to use the shared readline
+        if (confirmCb) {
+            const shared = createConfirmCallback(this.rl);
+            shared.pauseSpinner = confirmCb.pauseSpinner;
+            this.confirmCb = shared;
+            this.agent.setConfirmToolCall(shared);
+        }
+        else {
+            this.confirmCb = null;
+        }
+    }
+    async start() {
+        const stats = this.agent.getStats();
+        const skills = this.agent.getSkills();
+        console.error(`${C.bold}ag v${VERSION}${C.reset} ${C.dim}(${this.agent.getModel()} via OpenRouter)${C.reset}`);
+        const loaded = [
+            stats.globalMemory && 'global',
+            stats.projectMemory && 'project',
+            stats.planCount > 0 && `${stats.planCount} plan(s)`,
+            skills.length > 0 && `${skills.length} skill(s)`,
+        ].filter(Boolean);
+        if (loaded.length > 0) {
+            console.error(`${C.dim}Loaded: ${loaded.join(', ')}${C.reset}`);
+        }
+        const activePlan = this.agent.getActivePlanName();
+        if (activePlan) {
+            const label = activePlan.replace(/^\d{4}-\d{2}-\d{2}T[\d-]+-?/, '').replace(/-/g, ' ').trim() || activePlan;
+            console.error(`${C.dim}Plan: ${label}${C.reset}`);
+        }
+        if (stats.historyLines > 0) {
+            console.error(`${C.dim}History: ${stats.historyLines} messages${C.reset}`);
+        }
+        // Resolve context window size
+        const tracker = this.agent.getContextTracker();
+        if (!tracker.getContextLength()) {
+            try {
+                const models = await this.agent.fetchModels(this.agent.getModel());
+                const exact = models.find(m => m.id === this.agent.getModel());
+                const match = exact ?? models[0];
+                if (match?.context_length)
+                    tracker.setContextLength(match.context_length);
+            }
+            catch { /* proceed without — fallback handled by tracker */ }
+        }
+        tracker.estimateFromChars(this.agent.getSystemPromptSize());
+        const ctxLine = this.agent.getContextUsage();
+        console.error(`${C.dim}Commands: /help${C.reset}`);
+        if (ctxLine)
+            console.error(ctxLine);
+        console.error('');
+        while (true) {
+            try {
+                const input = await this.ask(`${C.green}you>${C.reset} `);
+                if (!input.trim())
+                    continue;
+                if (input.startsWith('/')) {
+                    await this.handleCommand(input);
+                    continue;
+                }
+                let hitMaxIterations = false;
+                const processStream = async (stream) => {
+                    let hasText = false;
+                    let hadTools = false;
+                    let stopSpinnerFn = null;
+                    let lineBuf = '';
+                    // Keep confirm callback's pauseSpinner in sync with current spinner
+                    const setSpinner = (fn) => {
+                        stopSpinnerFn = fn;
+                        if (this.confirmCb)
+                            this.confirmCb.pauseSpinner = fn;
+                    };
+                    const clearSpinner = () => {
+                        if (stopSpinnerFn) {
+                            stopSpinnerFn();
+                            setSpinner(null);
+                        }
+                    };
+                    // Render completed lines as markdown, write them out
+                    const flushLines = (final) => {
+                        const parts = lineBuf.split('\n');
+                        // Keep the last partial line in the buffer (unless final flush)
+                        lineBuf = final ? '' : (parts.pop() || '');
+                        for (let i = 0; i < parts.length; i++) {
+                            const rendered = renderMarkdown(parts[i]);
+                            process.stderr.write(rendered + '\n');
+                        }
+                        if (final && lineBuf) {
+                            process.stderr.write(renderMarkdown(lineBuf));
+                            lineBuf = '';
+                        }
+                    };
+                    for await (const chunk of stream) {
+                        switch (chunk.type) {
+                            case 'thinking':
+                                clearSpinner();
+                                if (hasText) {
+                                    flushLines(true);
+                                    process.stderr.write('\n');
+                                    hasText = false;
+                                }
+                                setSpinner(startSpinner(chunk.content || 'thinking'));
+                                break;
+                            case 'text':
+                                clearSpinner();
+                                if (!hasText) {
+                                    if (hadTools)
+                                        process.stderr.write('\n');
+                                    process.stderr.write(`${C.bold}agent>${C.reset} `);
+                                    hasText = true;
+                                }
+                                lineBuf += (chunk.content || '');
+                                if (lineBuf.includes('\n'))
+                                    flushLines(false);
+                                break;
+                            case 'tool_start': {
+                                clearSpinner();
+                                if (hasText) {
+                                    flushLines(true);
+                                    process.stderr.write('\n');
+                                    hasText = false;
+                                }
+                                const cmdPreview = truncateCommand(chunk.content || '', 60);
+                                setSpinner(startSpinner(`[${chunk.toolName}] ${cmdPreview}`));
+                                break;
+                            }
+                            case 'tool_end': {
+                                clearSpinner();
+                                hadTools = true;
+                                // Resolve label at tool_end time — skills may have been activated during this batch
+                                let endLabel = chunk.toolName || '';
+                                const activeSkills = this.agent.getActiveSkillNames();
+                                if (endLabel === 'bash' && activeSkills.length > 0) {
+                                    endLabel = `${endLabel} via ${activeSkills[activeSkills.length - 1]}`;
+                                }
+                                const icon = chunk.success ? `${C.green}✓` : `${C.red}✗`;
+                                const preview = (chunk.content || '').slice(0, 150).split('\n')[0];
+                                process.stderr.write(`  ${icon} ${C.dim}[${endLabel}]${C.reset} ${C.dim}${preview}${(chunk.content || '').length > 150 ? '...' : ''}${C.reset}\n`);
+                                break;
+                            }
+                            case 'done':
+                                clearSpinner();
+                                if (hasText) {
+                                    flushLines(true);
+                                    process.stderr.write('\n\n');
+                                }
+                                else if (!hadTools)
+                                    process.stderr.write(`${C.bold}agent>${C.reset} ${renderMarkdown(chunk.content || '')}\n\n`);
+                                break;
+                            case 'max_iterations':
+                                clearSpinner();
+                                hitMaxIterations = true;
+                                break;
+                        }
+                    }
+                    clearSpinner();
+                };
+                await processStream(this.agent.chatStream(input));
+                while (hitMaxIterations) {
+                    console.error(`${C.yellow}Reached iteration limit.${C.reset}`);
+                    const answer = await this.ask(`${C.yellow}Continue? (y/n)>${C.reset} `);
+                    if (answer.trim().toLowerCase() !== 'y')
+                        break;
+                    hitMaxIterations = false;
+                    await processStream(this.agent.chatStream('continue where you left off'));
+                }
+                const ctx = this.agent.getContextUsage();
+                if (ctx)
+                    console.error(ctx);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(`${C.red}Error: ${msg}${C.reset}\n`);
+            }
+        }
+    }
+    async handleCommand(command) {
+        const [cmd, ...args] = command.slice(1).trim().split(/\s+/);
+        const sub = cmd.toLowerCase();
+        switch (sub) {
+            case 'help':
+                console.error(`${C.bold}Commands:${C.reset}`);
+                console.error(`  ${C.cyan}/help${C.reset}                  Show this help`);
+                console.error(`  ${C.cyan}/model${C.reset}                 Show current model`);
+                console.error(`  ${C.cyan}/model <name>${C.reset}          Switch model (persists)`);
+                console.error(`  ${C.cyan}/model search [query]${C.reset}  Browse OpenRouter models`);
+                console.error(`  ${C.cyan}/memory${C.reset}                Show all memory + stats`);
+                console.error(`  ${C.cyan}/memory global${C.reset}         Show global memory`);
+                console.error(`  ${C.cyan}/memory project${C.reset}        Show project memory`);
+                console.error(`  ${C.cyan}/memory clear <scope>${C.reset}  Clear memory (project or all)`);
+                console.error(`  ${C.cyan}/plan${C.reset}                  Show current plan`);
+                console.error(`  ${C.cyan}/plan list${C.reset}             List all plans`);
+                console.error(`  ${C.cyan}/plan use <name>${C.reset}       Activate an older plan`);
+                console.error(`  ${C.cyan}/context${C.reset}               Show context window usage`);
+                console.error(`  ${C.cyan}/context compact${C.reset}       Force context compaction now`);
+                console.error(`  ${C.cyan}/config${C.reset}                Show config + file paths`);
+                console.error(`  ${C.cyan}/config set <k> <v>${C.reset}    Set a config value`);
+                console.error(`  ${C.cyan}/tools${C.reset}                 List loaded tools`);
+                console.error(`  ${C.cyan}/skill${C.reset}                 List installed skills`);
+                console.error(`  ${C.cyan}/skill search [query]${C.reset}  Search skills.sh`);
+                console.error(`  ${C.cyan}/skill add <source>${C.reset}    Install skill from registry`);
+                console.error(`  ${C.cyan}/skill remove <name>${C.reset}   Uninstall a skill`);
+                console.error(`  ${C.cyan}/exit${C.reset}                  Exit`);
+                console.error('');
+                break;
+            // ── /model ────────────────────────────────────────────────────────
+            case 'model': {
+                const subCmd = args[0]?.toLowerCase();
+                if (subCmd === 'search') {
+                    const query = args.slice(1).join(' ');
+                    console.error(`${C.dim}Fetching models from OpenRouter...${C.reset}`);
+                    try {
+                        const models = await this.agent.fetchModels(query || undefined);
+                        if (models.length === 0) {
+                            console.error(`${C.dim}No models found${query ? ` matching "${query}"` : ''}.${C.reset}\n`);
+                            break;
+                        }
+                        const current = this.agent.getModel();
+                        const shown = models.slice(0, 30);
+                        for (const m of shown) {
+                            const marker = m.id === current ? C.green + '> ' : '  ';
+                            const ctx = m.context_length ? `${C.dim}${Math.round(m.context_length / 1000)}k${C.reset}` : '';
+                            const price = m.pricing?.prompt ? `${C.dim}$${(parseFloat(m.pricing.prompt) * 1_000_000).toFixed(2)}/M${C.reset}` : '';
+                            console.error(`${marker}${C.cyan}${m.id}${C.reset} ${ctx} ${price}`);
+                        }
+                        if (models.length > 30)
+                            console.error(`${C.dim}  ...and ${models.length - 30} more. Filter with /model search <query>${C.reset}`);
+                        console.error(`${C.dim}  Use /model <id> to switch${C.reset}\n`);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        console.error(`${C.red}Error: ${msg}${C.reset}\n`);
+                    }
+                }
+                else if (args[0]) {
+                    this.agent.setModel(args.join('/'));
+                    saveConfig({ model: this.agent.getModel() });
+                    // Resolve context window for new model
+                    const tracker = this.agent.getContextTracker();
+                    if (!tracker.getContextLength()) {
+                        try {
+                            const models = await this.agent.fetchModels(this.agent.getModel());
+                            const exact = models.find(m => m.id === this.agent.getModel());
+                            const match = exact ?? models[0];
+                            if (match?.context_length)
+                                tracker.setContextLength(match.context_length);
+                        }
+                        catch { /* proceed without */ }
+                    }
+                    tracker.estimateFromChars(this.agent.getSystemPromptSize());
+                    const ctxLine = this.agent.getContextUsage();
+                    console.error(`${C.yellow}Model set to: ${this.agent.getModel()} (saved)${C.reset}`);
+                    if (ctxLine)
+                        console.error(ctxLine);
+                    console.error('');
+                }
+                else {
+                    console.error(`${C.dim}Current model: ${this.agent.getModel()}${C.reset}\n`);
+                }
+                break;
+            }
+            // ── /memory ───────────────────────────────────────────────────────
+            case 'memory': {
+                const subCmd = args[0]?.toLowerCase();
+                if (subCmd === 'global') {
+                    const content = this.agent.getGlobalMemory();
+                    console.error(content ? `${C.bold}Global memory:${C.reset}\n${renderMarkdown(content)}\n` : `${C.dim}No global memory. Edit ~/.ag/memory.md${C.reset}\n`);
+                }
+                else if (subCmd === 'project') {
+                    const content = this.agent.getProjectMemory();
+                    console.error(content ? `${C.bold}Project memory:${C.reset}\n${renderMarkdown(content)}\n` : `${C.dim}No project memory yet.${C.reset}\n`);
+                }
+                else if (subCmd === 'clear') {
+                    const scope = args[1]?.toLowerCase();
+                    if (scope === 'project') {
+                        this.agent.clearProject();
+                        console.error(`${C.yellow}Project memory, plans, and history cleared.${C.reset}\n`);
+                    }
+                    else if (scope === 'all') {
+                        this.agent.clearAll();
+                        console.error(`${C.yellow}All memory cleared.${C.reset}\n`);
+                    }
+                    else {
+                        console.error(`${C.dim}Usage: /memory clear project  or  /memory clear all${C.reset}\n`);
+                    }
+                }
+                else {
+                    // Show all memory + stats
+                    const stats = this.agent.getStats();
+                    const global = this.agent.getGlobalMemory();
+                    const project = this.agent.getProjectMemory();
+                    console.error(`${C.bold}Memory${C.reset}`);
+                    console.error(`  Global:  ${stats.globalMemory ? C.green + 'yes' : C.dim + 'none'}${C.reset}`);
+                    console.error(`  Project: ${stats.projectMemory ? C.green + 'yes' : C.dim + 'none'}${C.reset}`);
+                    console.error(`  Plans:   ${C.cyan}${stats.planCount}${C.reset}`);
+                    console.error(`  History: ${C.cyan}${stats.historyLines}${C.reset} messages`);
+                    if (global)
+                        console.error(`\n${C.bold}Global:${C.reset}\n${renderMarkdown(global)}`);
+                    if (project)
+                        console.error(`\n${C.bold}Project:${C.reset}\n${renderMarkdown(project)}`);
+                    console.error('');
+                }
+                break;
+            }
+            // ── /plan ─────────────────────────────────────────────────────────
+            case 'plan': {
+                const subCmd = args[0]?.toLowerCase();
+                if (subCmd === 'list') {
+                    const plans = this.agent.getPlans();
+                    if (plans.length === 0) {
+                        console.error(`${C.dim}No plans yet.${C.reset}\n`);
+                        break;
+                    }
+                    const activeName = this.agent.getActivePlanName();
+                    console.error(`${C.bold}Plans (${plans.length}):${C.reset}`);
+                    plans.forEach(p => console.error(`  ${p.name === activeName ? C.green + '>' : ' '} ${p.name}  ${C.dim}${p.path}${C.reset}`));
+                    console.error('');
+                }
+                else if (subCmd === 'use' && args[1]) {
+                    const name = args.slice(1).join(' ');
+                    const plans = this.agent.getPlans();
+                    const match = plans.find(p => p.name.includes(name));
+                    if (!match) {
+                        console.error(`${C.red}No plan matching "${name}". Use /plan list${C.reset}\n`);
+                        break;
+                    }
+                    this.agent.activatePlan(match.name);
+                    console.error(`${C.yellow}Activated plan: ${match.name}${C.reset}\n`);
+                }
+                else {
+                    const content = this.agent.getPlan();
+                    console.error(content ? `${C.bold}Current plan:${C.reset}\n${renderMarkdown(content)}\n` : `${C.dim}No plans yet.${C.reset}\n`);
+                }
+                break;
+            }
+            // ── /context ──────────────────────────────────────────────────────
+            case 'context': {
+                if (args[0]?.toLowerCase() === 'compact') {
+                    const tracker = this.agent.getContextTracker();
+                    if (!tracker.getContextLength()) {
+                        console.error(`${C.dim}Cannot compact: context window size unknown.${C.reset}\n`);
+                        break;
+                    }
+                    console.error(`${C.dim}Compacting conversation...${C.reset}`);
+                    try {
+                        await this.agent.compactNow();
+                        console.error(`${C.green}Compaction complete.${C.reset}`);
+                        const ctx = this.agent.getContextUsage();
+                        if (ctx)
+                            console.error(ctx);
+                    }
+                    catch (e) {
+                        console.error(`${C.red}Compaction failed: ${e.message}${C.reset}`);
+                    }
+                }
+                else {
+                    console.error(`${C.bold}Context Window${C.reset}`);
+                    console.error(this.agent.getContextDetails());
+                }
+                console.error('');
+                break;
+            }
+            // ── /config ───────────────────────────────────────────────────────
+            case 'config': {
+                if (args[0]?.toLowerCase() === 'set' && args[1]) {
+                    const value = args.slice(2).join(' ');
+                    if (!value) {
+                        console.error(`${C.red}Usage: /config set <key> <value>${C.reset}\n`);
+                        break;
+                    }
+                    const validKeys = ['apiKey', 'model', 'baseURL', 'systemPrompt', 'maxIterations', 'tavilyApiKey', 'autoApprove'];
+                    const keyAliases = {
+                        'tavily_api_key': 'tavilyApiKey',
+                        'openrouter_api_key': 'apiKey',
+                        'api_key': 'apiKey',
+                        'auto_approve': 'autoApprove',
+                        'autoapprove': 'autoApprove',
+                    };
+                    const rawKey = args[1];
+                    const key = keyAliases[rawKey.toLowerCase()] ?? rawKey;
+                    if (!validKeys.includes(key)) {
+                        console.error(`${C.red}Valid keys: ${validKeys.join(', ')}${C.reset}\n`);
+                        break;
+                    }
+                    let parsed = value;
+                    if (key === 'maxIterations') {
+                        parsed = parseInt(value, 10);
+                    }
+                    else if (key === 'autoApprove') {
+                        parsed = ['true', '1', 'yes'].includes(value.toLowerCase());
+                        // Apply immediately: toggle confirmation prompts in this session
+                        if (parsed) {
+                            this.agent.setConfirmToolCall(null);
+                            console.error(`${C.green}Auto-approve enabled — tool calls will no longer prompt.${C.reset}`);
+                        }
+                        else {
+                            const freshCb = createConfirmCallback(this.rl);
+                            if (this.confirmCb)
+                                freshCb.pauseSpinner = this.confirmCb.pauseSpinner;
+                            this.agent.setConfirmToolCall(freshCb);
+                            console.error(`${C.yellow}Auto-approve disabled — tool calls will prompt again.${C.reset}`);
+                        }
+                    }
+                    saveConfig({ [key]: parsed });
+                    const display = (key === 'apiKey' || key === 'tavilyApiKey') ? maskKey(value) : value;
+                    console.error(`${C.yellow}Config: ${key} = ${display} (saved)${C.reset}\n`);
+                }
+                else {
+                    // Show config + file paths
+                    const cfg = loadConfig();
+                    const p = this.agent.getPaths();
+                    console.error(`${C.bold}Config${C.reset} ${C.dim}(${configPath()})${C.reset}`);
+                    if (cfg.apiKey)
+                        console.error(`  apiKey:        ${C.dim}${maskKey(cfg.apiKey)}${C.reset}`);
+                    if (cfg.model)
+                        console.error(`  model:         ${C.cyan}${cfg.model}${C.reset}`);
+                    if (cfg.baseURL)
+                        console.error(`  baseURL:       ${C.dim}${cfg.baseURL}${C.reset}`);
+                    if (cfg.maxIterations)
+                        console.error(`  maxIterations: ${C.cyan}${cfg.maxIterations}${C.reset}`);
+                    if (cfg.tavilyApiKey)
+                        console.error(`  tavilyApiKey:  ${C.dim}${maskKey(cfg.tavilyApiKey)}${C.reset}`);
+                    if (cfg.autoApprove !== undefined)
+                        console.error(`  autoApprove:   ${cfg.autoApprove ? C.green + 'true' : C.dim + 'false'}${C.reset}`);
+                    if (!cfg.apiKey && !cfg.model && !cfg.baseURL && !cfg.maxIterations) {
+                        console.error(`${C.dim}  (using defaults + env vars)${C.reset}`);
+                    }
+                    console.error(`\n${C.bold}Paths${C.reset}`);
+                    console.error(`  Config:  ${configPath()}`);
+                    console.error(`  Global:  ${p.globalMemory}`);
+                    console.error(`  Project: ${p.projectMemory}`);
+                    console.error(`  Plans:   ${p.plansDir}/`);
+                    console.error(`  History: ${p.history}`);
+                    console.error('');
+                }
+                break;
+            }
+            // ── /tools ────────────────────────────────────────────────────────
+            case 'tools': {
+                const tools = this.agent.getTools();
+                console.error(`${C.bold}Tools (${tools.length}):${C.reset}`);
+                for (const t of tools) {
+                    console.error(`  ${C.cyan}${t.name}${C.reset}  ${C.dim}${t.description.slice(0, 60)}${t.description.length > 60 ? '...' : ''}${C.reset}`);
+                }
+                console.error('');
+                break;
+            }
+            // ── /skill ────────────────────────────────────────────────────────
+            case 'skill': {
+                const subCmd = args[0]?.toLowerCase();
+                if (subCmd === 'search') {
+                    const query = args.slice(1).join(' ');
+                    if (!query) {
+                        console.error(`${C.dim}Usage: /skill search <query>${C.reset}\n`);
+                        break;
+                    }
+                    console.error(`${C.dim}Searching skills.sh...${C.reset}`);
+                    try {
+                        const results = await searchRegistry(query);
+                        if (results.length === 0) {
+                            console.error(`${C.dim}No skills found for "${query}".${C.reset}\n`);
+                            break;
+                        }
+                        const shown = results.slice(0, 20);
+                        for (const s of shown) {
+                            console.error(`  ${C.cyan}${s.source}@${s.skillId}${C.reset}  ${C.dim}${formatInstalls(s.installs)} installs${C.reset}`);
+                        }
+                        if (results.length > 20)
+                            console.error(`${C.dim}  ...and ${results.length - 20} more${C.reset}`);
+                        console.error(`${C.dim}  Use /skill add <source>@<name> to install${C.reset}\n`);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        console.error(`${C.red}Error: ${msg}${C.reset}\n`);
+                    }
+                }
+                else if (subCmd === 'add' && args[1]) {
+                    const source = args[1];
+                    const stopSpinner = startSpinner(`Installing ${source}`);
+                    try {
+                        const msg = await installSkill(source);
+                        stopSpinner();
+                        this.agent.refreshSkills();
+                        console.error(`${C.green}${msg}${C.reset}\n`);
+                    }
+                    catch (e) {
+                        stopSpinner();
+                        const msg = e instanceof Error ? e.message : String(e);
+                        console.error(`${C.red}Error: ${msg}${C.reset}\n`);
+                    }
+                }
+                else if (subCmd === 'remove' && args[1]) {
+                    const msg = removeSkill(args[1]);
+                    this.agent.refreshSkills();
+                    console.error(`${C.yellow}${msg}${C.reset}\n`);
+                }
+                else if (!subCmd) {
+                    // List installed skills
+                    const skills = this.agent.getSkills();
+                    if (skills.length === 0) {
+                        console.error(`${C.dim}No skills installed. Use /skill search <query> to browse skills.sh${C.reset}\n`);
+                        break;
+                    }
+                    console.error(`${C.bold}Skills (${skills.length}):${C.reset}`);
+                    for (const s of skills) {
+                        const flags = [s.always && 'always-on', s.hasTools && 'has tools'].filter(Boolean).join(', ');
+                        console.error(`  ${C.cyan}${s.name}${C.reset}  ${C.dim}${s.description.slice(0, 60)}${flags ? ` (${flags})` : ''}${C.reset}`);
+                    }
+                    console.error('');
+                }
+                else {
+                    console.error(`${C.dim}Usage: /skill, /skill search <q>, /skill add <source>, /skill remove <name>${C.reset}\n`);
+                }
+                break;
+            }
+            // ── /exit ─────────────────────────────────────────────────────────
+            case 'exit':
+            case 'quit':
+                console.error(`${C.dim}Goodbye!${C.reset}`);
+                process.exit(0);
+            default:
+                console.error(`${C.red}Unknown command: ${sub}. Type /help${C.reset}\n`);
+        }
+    }
+    ask(prompt) {
+        return new Promise(resolve => this.rl.question(prompt, resolve));
+    }
+}
+//# sourceMappingURL=repl.js.map