@researchcomputer/pista 0.1.2

package/dist/commands.js

@@ -0,0 +1,673 @@
+import { randomUUID } from 'node:crypto';
+import { describeConfig, parseCompatApiStyle, parsePermissionMode, parseThinkingLevel, } from './config.js';
+import { normalizeAgentName, normalizeEndpoint, errorMessage, saveApiKey, getApiKeyPath, getStoredApiKey, loadStoredPreferences, saveStoredPreferences, resolveConfiguredSkills, fetchGitHubSkill, fetchGitHubSkillIndex, } from './utils.js';
+const SLASH_COMMANDS = [
+    { id: 'help', usage: '/help', description: 'Show this help message', allowWhileRunning: true, section: 'commands' },
+    { id: 'init', usage: '/init', description: 'Analyze codebase and generate AGENTS.md', section: 'commands' },
+    { id: 'name', usage: '/name [name]', description: 'Show or change agent name', section: 'commands' },
+    { id: 'abort', usage: '/abort', description: 'Stop current agent execution', allowWhileRunning: true, section: 'commands' },
+    { id: 'clear', usage: '/clear', description: 'Clear the terminal transcript', section: 'commands' },
+    { id: 'reset', usage: '/reset', description: 'Reset agent conversation state', section: 'commands' },
+    { id: 'cost', usage: '/cost', description: 'Show current session token usage', section: 'commands' },
+    { id: 'key', usage: '/key', description: 'Update your stored API key', section: 'commands' },
+    { id: 'jump', usage: '/jump <target>', description: 'Jump transcript to latest | error | tool', insertText: '/jump ', section: 'commands' },
+    { id: 'permissions', usage: '/permissions', description: 'Change tool permission mode', aliases: ['permission-mode'], section: 'commands' },
+    { id: 'thinking', usage: '/thinking', description: 'Change reasoning intensity', section: 'commands' },
+    { id: 'quit', usage: '/quit', description: 'Exit the application', aliases: ['exit'], section: 'commands' },
+    { id: 'plugins', usage: '/plugins', description: 'List installed plugins', aliases: ['skills'], section: 'plugins' },
+    { id: 'plugins add', usage: '/plugins add', description: 'Add a new plugin (prompt or MCP)', insertText: '/plugins add ', section: 'plugins' },
+    { id: 'plugins install', usage: '/plugins install', description: 'Install from GitHub (owner/repo/path)', insertText: '/plugins install ', aliases: ['plugins add-github', 'plugins github'], section: 'plugins' },
+    { id: 'plugins browse', usage: '/plugins browse', description: 'Browse a GitHub skill repo', insertText: '/plugins browse ', section: 'plugins' },
+    { id: 'plugins remove', usage: '/plugins remove', description: 'Remove a plugin', insertText: '/plugins remove ', aliases: ['plugins rm'], section: 'plugins' },
+    { id: 'plugins enable', usage: '/plugins enable', description: 'Enable a disabled plugin', insertText: '/plugins enable ', section: 'plugins' },
+    { id: 'plugins disable', usage: '/plugins disable', description: 'Disable a plugin', insertText: '/plugins disable ', section: 'plugins' },
+    { id: 'session', usage: '/session [new]', description: 'Show session info or start a fresh one', section: 'session' },
+    { id: 'config', usage: '/config', description: 'Show current configuration', section: 'session' },
+    { id: 'model', usage: '/model [id]', description: 'Change model id', section: 'model' },
+    { id: 'endpoint', usage: '/endpoint [url]', description: 'Change API endpoint URL', section: 'model' },
+    { id: 'api', usage: '/api [style]', description: 'Set API style (chat or responses)', aliases: ['api-style'], section: 'model' },
+];
+const SLASH_COMMAND_SECTION_TITLES = {
+    commands: 'COMMANDS',
+    plugins: 'PLUGINS',
+    session: 'SESSION & CONFIG',
+    model: 'MODEL & ENDPOINT',
+};
+export function parseSlashCommand(input) {
+    const withoutSlash = input.slice(1).trim();
+    const [command = '', ...args] = withoutSlash.split(/\s+/);
+    return { command: command.toLowerCase(), args, rest: args.join(' ').trim() };
+}
+export function getSlashCommandSuggestions(input, running, limit = 6) {
+    const query = getSlashSuggestionQuery(input);
+    if (query === null)
+        return [];
+    const normalizedQuery = query.toLowerCase();
+    const candidates = SLASH_COMMANDS
+        .filter((item) => !running || item.allowWhileRunning)
+        .map((item, index) => {
+        const aliases = item.aliases ?? [];
+        const searchTerms = [
+            item.id,
+            item.usage.replace(/^\//, ''),
+            ...aliases,
+        ].map((term) => term.toLowerCase());
+        let rank = normalizedQuery ? 3 : 1;
+        if (normalizedQuery) {
+            if (searchTerms.some((term) => term === normalizedQuery)) {
+                rank = 0;
+            }
+            else if (searchTerms.some((term) => term.startsWith(normalizedQuery))) {
+                rank = 1;
+            }
+            else if (searchTerms.some((term) => term.includes(normalizedQuery))) {
+                rank = 2;
+            }
+            else {
+                return null;
+            }
+        }
+        return {
+            index,
+            rank,
+            suggestion: {
+                id: item.id,
+                label: item.usage,
+                description: item.description,
+                insertText: item.insertText ?? getCommandText(item),
+                commandText: getCommandText(item),
+            },
+        };
+    })
+        .filter((item) => Boolean(item))
+        .sort((a, b) => a.rank - b.rank || a.index - b.index)
+        .slice(0, limit)
+        .map((item) => item.suggestion);
+    return candidates;
+}
+function getSlashSuggestionQuery(input) {
+    const trimmedStart = input.trimStart();
+    if (!trimmedStart.startsWith('/'))
+        return null;
+    if (trimmedStart.includes('\n'))
+        return null;
+    if (/\s$/.test(trimmedStart))
+        return null;
+    return trimmedStart.slice(1).trimStart();
+}
+function getCommandText(item) {
+    return item.usage
+        .split(' ')
+        .filter((token) => !token.startsWith('<') && !token.startsWith('['))
+        .join(' ');
+}
+export async function handleSlashCommand(input, ctx) {
+    const { command, args, rest } = parseSlashCommand(input);
+    const { config } = ctx;
+    if (command !== 'abort' && command !== 'help' && ctx.running) {
+        ctx.appendLog('error', 'Agent busy', 'Only /abort and /help are available while the agent is running.');
+        return;
+    }
+    switch (command) {
+        case 'help':
+            ctx.appendLog('system', 'Commands', helpText());
+            return;
+        case 'abort':
+            if (!ctx.running) {
+                ctx.appendLog('system', 'Abort', 'No active run to abort.');
+                return;
+            }
+            ctx.cancelPendingRequest();
+            ctx.abortAgent();
+            ctx.appendLog('system', 'Abort requested', 'Waiting for the current run to stop.');
+            return;
+        case 'clear':
+            ctx.clearLogs();
+            ctx.appendLog('system', 'Transcript cleared', 'Conversation state is preserved. Use /reset to clear the agent context too.');
+            return;
+        case 'reset':
+            ctx.resetAgent();
+            ctx.appendLog('system', 'Conversation reset', 'Agent messages were cleared for the current session.');
+            return;
+        case 'cost': {
+            const summary = ctx.getCostSummary();
+            if (!summary) {
+                ctx.appendLog('error', 'No agent', 'The agent has not been created yet.');
+                return;
+            }
+            ctx.appendLog('system', 'Usage', `Tokens ${summary.tokens}\nCost $${summary.cost.toFixed(4)}`);
+            return;
+        }
+        case 'session':
+            if (rest === 'new') {
+                const nextConfig = { ...config, sessionId: randomUUID() };
+                await ctx.rebuildAgent(nextConfig, `Started a new session: ${nextConfig.sessionId}`);
+                return;
+            }
+            ctx.appendLog('system', 'Session', [
+                `ID ${config.sessionId}`,
+                `CWD ${config.cwd}`,
+                `Permissions ${config.permissionMode}`,
+                `Thinking ${config.thinkingLevel}`,
+            ].join('\n'));
+            return;
+        case 'config':
+            ctx.appendLog('system', 'Configuration', describeConfig(config));
+            return;
+        case 'jump': {
+            const target = args[0]?.toLowerCase();
+            if (target !== 'latest' && target !== 'error' && target !== 'tool') {
+                ctx.appendLog('error', 'Unknown jump target', 'Use /jump latest, /jump error, or /jump tool.');
+                return;
+            }
+            const jumped = ctx.jumpTranscript(target);
+            ctx.appendLog(jumped ? 'system' : 'error', jumped ? 'Transcript jumped' : 'Transcript target missing', jumped ? `Moved transcript view to the latest ${target} entry.` : `No ${target} entry is available yet.`);
+            return;
+        }
+        case 'permissions':
+        case 'permission-mode': {
+            const nextMode = args[0] ?? await ctx.openPicker({
+                title: 'Permission mode',
+                description: 'Choose how aggressively the agent may run tools.',
+                items: [
+                    { id: 'default', label: 'default', description: 'Ask when the SDK needs approval.' },
+                    { id: 'allowAll', label: 'allowAll', description: 'Allow all tool calls without prompts.' },
+                    { id: 'rulesOnly', label: 'rulesOnly', description: 'Allow only rules-backed tool calls, deny the rest.' },
+                ],
+                selectedId: config.permissionMode,
+            });
+            if (!nextMode)
+                return;
+            const parsedMode = parsePermissionMode(nextMode);
+            if (!parsedMode) {
+                ctx.appendLog('error', 'Unknown permission mode', nextMode);
+                return;
+            }
+            await ctx.rebuildAgent({ ...config, permissionMode: parsedMode }, `Permission mode set to ${parsedMode}.`);
+            return;
+        }
+        case 'thinking': {
+            const nextLevel = args[0] ?? await ctx.openPicker({
+                title: 'Thinking level',
+                description: 'Higher levels may improve answers, but they usually cost more and respond slower.',
+                items: [
+                    { id: 'off', label: 'off', description: 'No extra reasoning budget.' },
+                    { id: 'minimal', label: 'minimal', description: 'Small reasoning budget.' },
+                    { id: 'low', label: 'low', description: 'Low reasoning budget.' },
+                    { id: 'medium', label: 'medium', description: 'Balanced reasoning budget.' },
+                    { id: 'high', label: 'high', description: 'More deliberate reasoning.' },
+                    { id: 'xhigh', label: 'xhigh', description: 'Maximum reasoning budget.' },
+                ],
+                selectedId: config.thinkingLevel,
+            });
+            if (!nextLevel)
+                return;
+            const parsedLevel = parseThinkingLevel(nextLevel);
+            if (!parsedLevel) {
+                ctx.appendLog('error', 'Unknown thinking level', nextLevel);
+                return;
+            }
+            await ctx.rebuildAgent({ ...config, thinkingLevel: parsedLevel }, `Thinking level set to ${parsedLevel}.`);
+            return;
+        }
+        case 'name': {
+            const nextName = rest || await ctx.openPrompt({
+                title: 'Agent name',
+                description: 'Pick a short and cute name for this coding agent.',
+                initialValue: config.agentName,
+                placeholder: 'Example: Pista',
+            });
+            if (!nextName)
+                return;
+            const normalizedName = normalizeAgentName(nextName);
+            ctx.setConfig((current) => ({ ...current, agentName: normalizedName }));
+            ctx.appendLog('system', 'Agent renamed', `${normalizedName} is now your coding agent.`);
+            return;
+        }
+        case 'model': {
+            let nextModel = rest;
+            if (!nextModel) {
+                try {
+                    const apiKey = getStoredApiKey();
+                    const response = await fetch(`${config.selection.endpoint}/models`, {
+                        headers: apiKey ? { 'Authorization': `Bearer ${apiKey}` } : {},
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        const models = data.data.map(m => m.id);
+                        if (models.length > 0) {
+                            nextModel = await ctx.openPicker({
+                                title: 'Select Model',
+                                items: models.map(id => ({ id, label: id })),
+                                selectedId: config.selection.model,
+                                emptyMessage: 'No models returned from endpoint.',
+                            }) || '';
+                        }
+                    }
+                }
+                catch (error) {
+                    ctx.appendLog('error', 'Fetch models failed', errorMessage(error));
+                }
+            }
+            if (!nextModel && !rest) {
+                const prompted = await ctx.openPrompt({
+                    title: 'Model id',
+                    description: 'Enter the model id exposed by the endpoint.',
+                    initialValue: config.selection.model,
+                });
+                nextModel = prompted || '';
+            }
+            if (!nextModel)
+                return;
+            await ctx.rebuildAgent({
+                ...config,
+                selection: {
+                    ...config.selection,
+                    model: nextModel.trim(),
+                },
+            }, `Using model ${nextModel.trim()}.`);
+            return;
+        }
+        case 'endpoint': {
+            const nextEndpoint = rest || await ctx.openPrompt({
+                title: 'API endpoint',
+                description: 'Example: https://api.research.computer/v1',
+                initialValue: config.selection.endpoint,
+            });
+            if (!nextEndpoint)
+                return;
+            try {
+                const normalizedEndpoint = normalizeEndpoint(nextEndpoint);
+                const nextSelection = {
+                    ...config.selection,
+                    endpoint: normalizedEndpoint,
+                };
+                await ctx.rebuildAgent({ ...config, selection: nextSelection }, `Connected to ${normalizedEndpoint}.`);
+            }
+            catch (error) {
+                ctx.appendLog('error', 'Invalid endpoint', errorMessage(error));
+            }
+            return;
+        }
+        case 'api':
+        case 'api-style': {
+            const nextStyle = args[0] ?? await ctx.openPicker({
+                title: 'Pick API style',
+                items: [
+                    { id: 'chat', label: 'chat', description: 'OpenAI-compatible chat/completions API' },
+                    { id: 'responses', label: 'responses', description: 'OpenAI-compatible responses API' },
+                ],
+                selectedId: config.selection.apiStyle,
+            });
+            if (!nextStyle)
+                return;
+            const parsedStyle = parseCompatApiStyle(nextStyle);
+            if (!parsedStyle) {
+                ctx.appendLog('error', 'Unknown API style', nextStyle);
+                return;
+            }
+            const nextSelection = {
+                ...config.selection,
+                apiStyle: parsedStyle,
+            };
+            await ctx.rebuildAgent({ ...config, selection: nextSelection }, `Using ${nextStyle} API style.`);
+            return;
+        }
+        case 'key': {
+            const nextKey = await ctx.openPrompt({
+                title: 'Update API Key',
+                description: `Enter your new API key. It will be saved to ${getApiKeyPath()}.`,
+                placeholder: 'Paste your API key here',
+                secret: true,
+            });
+            if (!nextKey)
+                return;
+            saveApiKey(nextKey);
+            ctx.appendLog('system', 'API Key Updated', `Key has been saved to ${getApiKeyPath()}. Rebuilding agent...`);
+            await ctx.rebuildAgent(config, 'Agent rebuilt with new API key.');
+            return;
+        }
+        case 'init': {
+            ctx.appendLog('system', 'Initializing project', 'Asking the agent to analyze the codebase and generate AGENTS.md...');
+            const initPrompt = [
+                'Analyze this codebase and create an AGENTS.md file in the project root.',
+                'Follow these steps iteratively:',
+                '',
+                '1. Read the top-level directory structure and any existing README, package.json, or config files.',
+                '2. Identify the primary language(s), frameworks, build system, and project layout.',
+                '3. Explore the main source directories to understand the architecture — key modules, entry points, data flow.',
+                '4. Look at test setup, CI config, and dev tooling if present.',
+                '5. Check for existing contribution guidelines, coding conventions, or linter configs.',
+                '',
+                'Then write AGENTS.md with these sections:',
+                '',
+                '- **Project Overview**: What this project does, in 2-3 sentences.',
+                '- **Architecture**: High-level structure, key directories, and how components connect.',
+                '- **Tech Stack**: Languages, frameworks, major dependencies.',
+                '- **Build & Run**: How to install dependencies, build, run, and test.',
+                '- **Code Conventions**: Naming, formatting, patterns observed in the code.',
+                '- **Key Files**: The most important files an agent or new contributor should read first.',
+                '- **Common Tasks**: How to add a feature, fix a bug, or run specific workflows.',
+                '',
+                'Be concise and factual. Only include what you can verify from the code.',
+                'Do NOT ask me questions — explore the codebase yourself and make your best judgment.',
+            ].join('\n');
+            await ctx.promptAgent(initPrompt);
+            return;
+        }
+        case 'plugins':
+        case 'skills': {
+            const subcommand = args[0]?.toLowerCase();
+            if (subcommand === 'list' || !subcommand) {
+                const storedPrefs = loadStoredPreferences();
+                const projectPrefs = loadStoredPreferences(config.cwd);
+                const allSkills = [
+                    ...(storedPrefs.skills ?? []).map((s) => ({ ...s, scope: 'global' })),
+                    ...(projectPrefs.skills ?? []).map((s) => ({ ...s, scope: 'project' })),
+                ];
+                if (allSkills.length === 0) {
+                    ctx.appendLog('system', 'Plugins', 'No plugins installed. Use /plugins add to add one.');
+                    return;
+                }
+                const lines = allSkills.map((s) => {
+                    const status = s.enabled === false ? '(disabled)' : '(enabled)';
+                    const scope = `[${s.scope}]`;
+                    const desc = s.description ? ` — ${s.description}` : '';
+                    return `  ${s.id} ${status} ${scope}${desc}`;
+                });
+                ctx.appendLog('system', 'Plugins', lines.join('\n'));
+                return;
+            }
+            if (subcommand === 'add') {
+                const id = rest.slice(4).trim() || await ctx.openPrompt({
+                    title: 'Plugin ID',
+                    description: 'A unique identifier for this plugin (e.g. "typescript-style", "my-mcp-server").',
+                    placeholder: 'my-plugin',
+                });
+                if (!id)
+                    return;
+                const description = await ctx.openPrompt({
+                    title: 'Description',
+                    description: `Describe what "${id}" does.`,
+                    placeholder: 'Optional description',
+                });
+                const promptText = await ctx.openPrompt({
+                    title: 'Prompt sections',
+                    description: 'System prompt instructions for this plugin. Use \\n for multiple lines. Leave empty to skip.',
+                    placeholder: 'e.g. Always use strict TypeScript',
+                });
+                const mcpChoice = await ctx.openPicker({
+                    title: 'Add an MCP server?',
+                    items: [
+                        { id: 'no', label: 'No', description: 'Just a prompt-based plugin' },
+                        { id: 'stdio', label: 'stdio', description: 'Local command (e.g. npx, python)' },
+                        { id: 'sse', label: 'sse', description: 'SSE endpoint URL' },
+                        { id: 'http', label: 'http', description: 'HTTP endpoint URL' },
+                    ],
+                });
+                if (!mcpChoice)
+                    return;
+                const skill = { id: id.trim() };
+                if (description)
+                    skill.description = description;
+                if (promptText) {
+                    skill.promptSections = promptText.split('\\n').map((s) => s.trim()).filter(Boolean);
+                }
+                if (mcpChoice !== 'no') {
+                    const transport = mcpChoice;
+                    if (transport === 'stdio') {
+                        const command = await ctx.openPrompt({
+                            title: 'Command',
+                            description: 'The command to run (e.g. "npx", "python").',
+                            placeholder: 'npx',
+                        });
+                        if (!command)
+                            return;
+                        const argsStr = await ctx.openPrompt({
+                            title: 'Arguments',
+                            description: 'Space-separated arguments for the command.',
+                            placeholder: '-y @modelcontextprotocol/server-filesystem /',
+                        });
+                        skill.mcpServers = [{
+                                name: id.trim(),
+                                transport,
+                                command,
+                                args: argsStr ? argsStr.split(/\s+/) : [],
+                            }];
+                    }
+                    else {
+                        const url = await ctx.openPrompt({
+                            title: 'Server URL',
+                            description: `The ${transport.toUpperCase()} endpoint URL.`,
+                            placeholder: 'https://example.com/mcp',
+                        });
+                        if (!url)
+                            return;
+                        skill.mcpServers = [{ name: id.trim(), transport, url }];
+                    }
+                }
+                const scope = await ctx.openPicker({
+                    title: 'Scope',
+                    description: 'Where to save this plugin.',
+                    items: [
+                        { id: 'global', label: 'Global', description: 'Available in all projects (~/.pista/preferences.json)' },
+                        { id: 'project', label: 'Project', description: 'Only this project (<cwd>/.pista/preferences.json)' },
+                    ],
+                });
+                if (!scope)
+                    return;
+                const baseDir = scope === 'project' ? config.cwd : undefined;
+                const prefs = loadStoredPreferences(baseDir);
+                const updatedSkills = [...(prefs.skills ?? []), skill];
+                saveStoredPreferences({ ...prefs, skills: updatedSkills }, baseDir);
+                await ctx.rebuildAgent({ ...config, skills: resolveConfiguredSkills(updatedSkills) }, `Plugin "${id.trim()}" added (${scope}).`);
+                return;
+            }
+            if (subcommand === 'add-github' || subcommand === 'github' || subcommand === 'install') {
+                const source = rest.slice(subcommand.length + 1).trim() || await ctx.openPrompt({
+                    title: 'GitHub source',
+                    description: 'Enter owner/repo or owner/repo/path/to/skill (e.g. "anthropics/skills/skills/pdf").',
+                    placeholder: 'anthropics/skills/skills/pdf',
+                });
+                if (!source)
+                    return;
+                ctx.appendLog('system', 'Fetching plugin', `Downloading SKILL.md from ${source}...`);
+                try {
+                    const skill = await fetchGitHubSkill(source);
+                    const scope = await ctx.openPicker({
+                        title: 'Scope',
+                        description: `Install "${skill.id}" to:`,
+                        items: [
+                            { id: 'global', label: 'Global', description: 'Available in all projects' },
+                            { id: 'project', label: 'Project', description: 'Only this project' },
+                        ],
+                    });
+                    if (!scope)
+                        return;
+                    const baseDir = scope === 'project' ? config.cwd : undefined;
+                    const prefs = loadStoredPreferences(baseDir);
+                    const existing = (prefs.skills ?? []).filter((s) => s.id !== skill.id);
+                    const updatedSkills = [...existing, skill];
+                    saveStoredPreferences({ ...prefs, skills: updatedSkills }, baseDir);
+                    const mergedPrefs = loadStoredPreferences();
+                    const mergedProjectPrefs = loadStoredPreferences(config.cwd);
+                    const finalSkills = resolveConfiguredSkills([
+                        ...(mergedPrefs.skills ?? []),
+                        ...(mergedProjectPrefs.skills ?? []),
+                    ]);
+                    await ctx.rebuildAgent({ ...config, skills: finalSkills }, `Plugin "${skill.id}" installed from GitHub (${scope}).${skill.description ? '\n' + skill.description : ''}`);
+                }
+                catch (error) {
+                    ctx.appendLog('error', 'Install failed', errorMessage(error));
+                }
+                return;
+            }
+            if (subcommand === 'browse') {
+                const source = rest.slice(7).trim() || await ctx.openPrompt({
+                    title: 'GitHub repository',
+                    description: 'Enter owner/repo to browse available skills (e.g. "anthropics/skills").',
+                    placeholder: 'anthropics/skills',
+                });
+                if (!source)
+                    return;
+                const parts = source.replace(/https?:\/\/github\.com\//, '').split('/');
+                const owner = parts[0];
+                const repo = parts[1]?.replace(/\.git$/, '');
+                if (!owner || !repo) {
+                    ctx.appendLog('error', 'Invalid source', 'Expected owner/repo format.');
+                    return;
+                }
+                ctx.appendLog('system', 'Browsing', `Fetching skill index from ${owner}/${repo}...`);
+                try {
+                    const plugins = await fetchGitHubSkillIndex(owner, repo);
+                    if (!plugins || plugins.length === 0) {
+                        ctx.appendLog('error', 'No index found', `No .claude-plugin/marketplace.json found in ${owner}/${repo}. Try /plugins install ${owner}/${repo}/path/to/skill instead.`);
+                        return;
+                    }
+                    const allSkills = plugins.flatMap((p) => p.skills.map((skillPath) => {
+                        const cleanPath = skillPath.replace(/^\.\//, '');
+                        const label = cleanPath.split('/').pop() || cleanPath;
+                        return {
+                            id: `${owner}/${repo}/${cleanPath}`,
+                            label,
+                            description: `${p.name} — ${cleanPath}`,
+                        };
+                    }));
+                    const selected = await ctx.openPicker({
+                        title: `Skills in ${owner}/${repo}`,
+                        description: 'Choose a skill to install.',
+                        items: allSkills,
+                        emptyMessage: 'No skills found in the marketplace manifest.',
+                    });
+                    if (!selected)
+                        return;
+                    ctx.appendLog('system', 'Fetching plugin', `Downloading SKILL.md from ${selected}...`);
+                    const skill = await fetchGitHubSkill(selected);
+                    const scope = await ctx.openPicker({
+                        title: 'Scope',
+                        description: `Install "${skill.id}" to:`,
+                        items: [
+                            { id: 'global', label: 'Global', description: 'Available in all projects' },
+                            { id: 'project', label: 'Project', description: 'Only this project' },
+                        ],
+                    });
+                    if (!scope)
+                        return;
+                    const baseDir = scope === 'project' ? config.cwd : undefined;
+                    const prefs = loadStoredPreferences(baseDir);
+                    const existing = (prefs.skills ?? []).filter((s) => s.id !== skill.id);
+                    const updatedSkills = [...existing, skill];
+                    saveStoredPreferences({ ...prefs, skills: updatedSkills }, baseDir);
+                    const mergedPrefs = loadStoredPreferences();
+                    const mergedProjectPrefs = loadStoredPreferences(config.cwd);
+                    const finalSkills = resolveConfiguredSkills([
+                        ...(mergedPrefs.skills ?? []),
+                        ...(mergedProjectPrefs.skills ?? []),
+                    ]);
+                    await ctx.rebuildAgent({ ...config, skills: finalSkills }, `Plugin "${skill.id}" installed from GitHub (${scope}).${skill.description ? '\n' + skill.description : ''}`);
+                }
+                catch (error) {
+                    ctx.appendLog('error', 'Browse failed', errorMessage(error));
+                }
+                return;
+            }
+            if (subcommand === 'remove' || subcommand === 'rm') {
+                const globalPrefs = loadStoredPreferences();
+                const projectPrefs = loadStoredPreferences(config.cwd);
+                const allSkills = [
+                    ...(globalPrefs.skills ?? []).map((s) => ({ ...s, scope: 'global' })),
+                    ...(projectPrefs.skills ?? []).map((s) => ({ ...s, scope: 'project' })),
+                ];
+                if (allSkills.length === 0) {
+                    ctx.appendLog('system', 'Plugins', 'No plugins to remove.');
+                    return;
+                }
+                const targetId = args[1] || await ctx.openPicker({
+                    title: 'Remove plugin',
+                    items: allSkills.map((s) => ({
+                        id: `${s.scope}:${s.id}`,
+                        label: `${s.id} [${s.scope}]`,
+                        description: s.description,
+                    })),
+                });
+                if (!targetId)
+                    return;
+                const [targetScope, ...idParts] = targetId.split(':');
+                const skillId = idParts.join(':');
+                const baseDir = targetScope === 'project' ? config.cwd : undefined;
+                const prefs = loadStoredPreferences(baseDir);
+                const updatedSkills = (prefs.skills ?? []).filter((s) => s.id !== skillId);
+                saveStoredPreferences({ ...prefs, skills: updatedSkills }, baseDir);
+                const mergedPrefs = loadStoredPreferences();
+                const mergedProjectPrefs = loadStoredPreferences(config.cwd);
+                const finalSkills = resolveConfiguredSkills([
+                    ...(mergedPrefs.skills ?? []),
+                    ...(mergedProjectPrefs.skills ?? []),
+                ]);
+                await ctx.rebuildAgent({ ...config, skills: finalSkills }, `Plugin "${skillId}" removed.`);
+                return;
+            }
+            if (subcommand === 'enable' || subcommand === 'disable') {
+                const enabling = subcommand === 'enable';
+                const globalPrefs = loadStoredPreferences();
+                const projectPrefs = loadStoredPreferences(config.cwd);
+                const allSkills = [
+                    ...(globalPrefs.skills ?? []).map((s) => ({ ...s, scope: 'global' })),
+                    ...(projectPrefs.skills ?? []).map((s) => ({ ...s, scope: 'project' })),
+                ];
+                const filtered = allSkills.filter((s) => enabling ? s.enabled === false : s.enabled !== false);
+                if (filtered.length === 0) {
+                    ctx.appendLog('system', 'Plugins', `No plugins to ${subcommand}.`);
+                    return;
+                }
+                const targetId = args[1] || await ctx.openPicker({
+                    title: `${enabling ? 'Enable' : 'Disable'} plugin`,
+                    items: filtered.map((s) => ({
+                        id: `${s.scope}:${s.id}`,
+                        label: `${s.id} [${s.scope}]`,
+                        description: s.description,
+                    })),
+                });
+                if (!targetId)
+                    return;
+                const [targetScope, ...idParts] = targetId.split(':');
+                const skillId = idParts.join(':');
+                const baseDir = targetScope === 'project' ? config.cwd : undefined;
+                const prefs = loadStoredPreferences(baseDir);
+                const updatedSkills = (prefs.skills ?? []).map((s) => s.id === skillId ? { ...s, enabled: enabling ? undefined : false } : s);
+                saveStoredPreferences({ ...prefs, skills: updatedSkills }, baseDir);
+                const mergedPrefs = loadStoredPreferences();
+                const mergedProjectPrefs = loadStoredPreferences(config.cwd);
+                const finalSkills = resolveConfiguredSkills([
+                    ...(mergedPrefs.skills ?? []),
+                    ...(mergedProjectPrefs.skills ?? []),
+                ]);
+                await ctx.rebuildAgent({ ...config, skills: finalSkills }, `Plugin "${skillId}" ${enabling ? 'enabled' : 'disabled'}.`);
+                return;
+            }
+            ctx.appendLog('error', 'Unknown subcommand', `Usage: /plugins [list|add|install|browse|remove|enable|disable]`);
+            return;
+        }
+        case 'quit':
+        case 'exit':
+            ctx.exit();
+            return;
+        default:
+            ctx.appendLog('error', 'Unknown command', command);
+    }
+}
+function helpText() {
+    const sectionOrder = ['commands', 'plugins', 'session', 'model'];
+    const lines = [];
+    for (const section of sectionOrder) {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(SLASH_COMMAND_SECTION_TITLES[section]);
+        const sectionCommands = SLASH_COMMANDS.filter((item) => item.section === section);
+        const maxUsageLength = sectionCommands.reduce((max, item) => Math.max(max, item.usage.length), 0);
+        for (const item of sectionCommands) {
+            lines.push(`  ${item.usage.padEnd(maxUsageLength)}  ${item.description}`);
+        }
+    }
+    return lines.join('\n');
+}