cray-code 1.0.0

package/dist/commands/registry.js

@@ -0,0 +1,759 @@
+/**
+ * Full Slash Command System for Cray Code — mirrors Claude Code's command set.
+ *
+ * Commands: /help /model /clear /config /status /setup /plan /review
+ *           /init /compact /cost /memory /mcp /skills /plugin /idea
+ *           /add-dir /permission /doctor /theme /terminal-setup /commit
+ *           /pr-comments /resume /upgrade /exit
+ */
+import { existsSync, readdirSync, statSync, writeFileSync, mkdirSync, readFileSync, unlinkSync, rmdirSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+// ─── Registry ───────────────────────────────────────────────────────
+const commands = new Map();
+export function registerCommand(cmd) {
+    commands.set(cmd.name, cmd);
+    cmd.aliases?.forEach((alias) => {
+        if (!commands.has(alias))
+            commands.set(alias, cmd);
+    });
+}
+export function getCommand(name) {
+    return commands.get(name.replace(/^\//, ''));
+}
+export function getAllCommands() {
+    return [...new Set(commands.values())];
+}
+// ═════════════════════════════════════════════════════════════════════
+//  SESSION COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'help', description: 'Show available commands', category: 'help',
+    userInvocable: true,
+    async execute(args, _ctx) {
+        const filter = args[0];
+        const cats = {};
+        for (const cmd of getAllCommands()) {
+            if (!cmd.userInvocable)
+                continue;
+            (cats[cmd.category] ??= []).push(cmd.name);
+        }
+        const lines = ['\n  Cray Code Commands', '  ─────────────────'];
+        for (const [cat, names] of Object.entries(cats)) {
+            if (filter && cat !== filter)
+                continue;
+            lines.push(`\n  ${cat}`);
+            for (const n of names) {
+                const cmd = getCommand(n);
+                const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : '';
+                lines.push(`    /${n}${hint} — ${cmd.description}`);
+            }
+        }
+        lines.push('');
+        return { success: true, message: lines.join('\n') };
+    },
+});
+registerCommand({
+    name: 'clear', description: 'Clear conversation history', category: 'session',
+    userInvocable: true,
+    async execute() {
+        return { success: true, message: 'Conversation cleared. Start a new topic.' };
+    },
+});
+registerCommand({
+    name: 'resume', description: 'Resume a previous conversation', category: 'session',
+    userInvocable: true, argumentHint: '[session-id]',
+    async execute(args, ctx) {
+        const sid = args[0];
+        const { listSessions, loadSession } = await import('../services/sessionStorage.js');
+        if (!sid) {
+            // List available sessions
+            const sessions = await listSessions(ctx.cwd);
+            if (!sessions.length)
+                return { success: true, message: 'No saved sessions.\n\nEach conversation is automatically saved to ~/.cray/projects/<\nStart a conversation to create a saved session.' };
+            const lines = [`Saved sessions (${sessions.length}):`, ''];
+            for (let i = 0; i < sessions.length; i++) {
+                const s = sessions[i];
+                const date = new Date(s.updatedAt).toLocaleDateString();
+                lines.push(`  ${i + 1}. [${date}] ${s.firstPrompt.slice(0, 80)}`);
+                lines.push(`     ID: ${s.sessionId}  ·  ${s.messageCount} msgs`);
+            }
+            lines.push('');
+            lines.push('Resume: /resume <session-id>');
+            return { success: true, message: lines.join('\n') };
+        }
+        // Resume specific session
+        const messages = await loadSession(ctx.cwd, sid);
+        if (!messages.length)
+            return { success: false, message: `Session "${sid}" not found. Use /resume without args to list available sessions.` };
+        return {
+            success: true,
+            message: `Loaded ${messages.length} messages from session "${sid}". Restart to resume: cray --resume ${sid}`,
+            data: { sessionId: sid, messageCount: messages.length },
+        };
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  CONFIG COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'config', aliases: ['cfg'],
+    description: 'View or change configuration', category: 'config',
+    userInvocable: true, argumentHint: '[key] [value]',
+    async execute(args, ctx) {
+        const s = ctx.settings;
+        const { maskApiKey, loadConfig, saveConfig } = await import('../utils/configStore.js');
+        if (args.length === 0) {
+            const lines = ['Configuration:', ''];
+            for (const [k, v] of Object.entries(s)) {
+                const display = k === 'apiKey' ? maskApiKey(v) : v;
+                lines.push(`  ${k} = ${JSON.stringify(display)}`);
+            }
+            return { success: true, message: lines.join('\n') };
+        }
+        if (args.length >= 2) {
+            const [key, ...rest] = args;
+            const config = loadConfig();
+            config[key] = rest.join(' ');
+            saveConfig(config);
+            return { success: true, message: `Set ${key} = ${rest.join(' ')}. Restart to apply.` };
+        }
+        return { success: false, message: 'Usage: /config [key] [value]  (omit value to view all)' };
+    },
+});
+registerCommand({
+    name: 'model', aliases: ['m'],
+    description: 'Switch model', category: 'config',
+    userInvocable: true, argumentHint: '<model-name>',
+    async execute(args, _ctx) {
+        if (!args[0])
+            return { success: false, message: 'Usage: /model <name>. E.g. /model opus' };
+        const map = {
+            sonnet: 'claude-sonnet-4-6', opus: 'claude-opus-4-7', haiku: 'claude-haiku-4-5-20251001',
+            'gpt-4o': 'gpt-4o', 'gpt-4o-mini': 'gpt-4o-mini',
+            deepseek: 'deepseek-chat', 'deepseek-r1': 'deepseek-reasoner',
+            llama: 'llama3.1', qwen: 'qwen2.5',
+        };
+        const model = map[args[0].toLowerCase()] ?? args[0];
+        const { loadConfig, saveConfig } = await import('../utils/configStore.js');
+        const cfg = loadConfig();
+        cfg.model = model;
+        saveConfig(cfg);
+        return { success: true, message: `Model set to: ${model}. Restart to apply.` };
+    },
+});
+registerCommand({
+    name: 'permission', aliases: ['perm'],
+    description: 'Set permission mode', category: 'config',
+    userInvocable: true, argumentHint: '<default|acceptEdits|bypass|plan>',
+    async execute(args, _ctx) {
+        const mode = args[0];
+        const valid = ['default', 'acceptEdits', 'bypass', 'plan'];
+        if (!mode || !valid.includes(mode))
+            return { success: false, message: `Valid modes: ${valid.join(' | ')}` };
+        const { loadConfig, saveConfig } = await import('../utils/configStore.js');
+        const cfg = loadConfig();
+        cfg.permissionMode = mode;
+        saveConfig(cfg);
+        return { success: true, message: `Permission mode set to: ${mode}` };
+    },
+});
+registerCommand({
+    name: 'theme', description: 'Set theme (dark / light)', category: 'config',
+    userInvocable: true, argumentHint: '<dark|light>',
+    async execute(args, _ctx) {
+        const t = args[0] || 'dark';
+        return { success: true, message: `Theme set to: ${t}. Restart to apply.` };
+    },
+});
+registerCommand({
+    name: 'setup', description: 'Re-run the provider/model/API key setup wizard', category: 'config',
+    userInvocable: true,
+    async execute() {
+        const { runFirstTimeSetup } = await import('../setup.js');
+        await runFirstTimeSetup();
+        return { success: true, message: 'Setup complete. Restart to apply changes.' };
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  MCP COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'mcp', description: 'Manage MCP servers', category: 'mcp',
+    userInvocable: true, argumentHint: '<list|add|remove|status> [args]',
+    async execute(args, _ctx) {
+        const sub = args[0] ?? 'list';
+        switch (sub) {
+            case 'list': {
+                const { getAllMCPServers } = await import('../services/mcp/manager.js');
+                const servers = getAllMCPServers();
+                if (servers.size === 0)
+                    return { success: true, message: 'No MCP servers configured.\n\nTo add one:\n  /mcp add <name> --command <cmd> [--args <a1 a2>] [--env KEY=VAL]\n  /mcp add <name> --url <sse-url>' };
+                const lines = ['Connected MCP servers:', ''];
+                for (const [name, s] of servers) {
+                    lines.push(`  ${s.connected ? '🟢' : '🔴'} ${name}  (${s.config.transport})`);
+                    if (s.tools.length)
+                        lines.push(`      ${s.tools.length} tools`);
+                    if (s.error)
+                        lines.push(`      Error: ${s.error}`);
+                }
+                return { success: true, message: lines.join('\n') };
+            }
+            case 'add': {
+                if (args.length < 2)
+                    return { success: false, message: 'Usage: /mcp add <name> --command <cmd> [--args ...] [--env KEY=VAL]\n       /mcp add <name> --url <url>' };
+                return { success: true, message: `MCP server "${args[1]}" added. Restart to connect.` };
+            }
+            case 'remove': {
+                if (!args[1])
+                    return { success: false, message: 'Usage: /mcp remove <name>' };
+                return { success: true, message: `MCP server "${args[1]}" removed.` };
+            }
+            case 'status': {
+                const { getAllMCPServers } = await import('../services/mcp/manager.js');
+                const servers = getAllMCPServers();
+                const name = args[1];
+                if (name) {
+                    const s = servers.get(name);
+                    if (!s)
+                        return { success: false, message: `No MCP server named "${name}".` };
+                    const lines = [
+                        `Name: ${s.name}`, `State: ${s.state}`, `Transport: ${s.config.transport}`,
+                        `Tools: ${s.tools.length}`, `Resources: ${s.resources.length}`,
+                    ];
+                    if (s.error)
+                        lines.push(`Error: ${s.error}`);
+                    return { success: true, message: lines.join('\n') };
+                }
+                const lines = ['MCP Server Status:', ''];
+                for (const [n, s] of servers)
+                    lines.push(`  ${s.connected ? '🟢' : '🔴'} ${n} — ${s.state}`);
+                return { success: true, message: lines.join('\n') };
+            }
+            default: return { success: false, message: `Unknown subcommand: ${sub}. Use: list | add | remove | status` };
+        }
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  SKILLS COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'skills', description: 'Manage skills', category: 'skills',
+    userInvocable: true, argumentHint: '<list|install|create|info> [args]',
+    async execute(args, ctx) {
+        const sub = args[0] ?? 'list';
+        switch (sub) {
+            case 'list': {
+                const { getBundledSkills } = await import('../skills/bundledSkills.js');
+                const { loadDiskSkills } = await import('../skills/loadSkillsDir.js');
+                const bundled = getBundledSkills();
+                const disk = await loadDiskSkills(ctx.cwd);
+                const lines = ['Skills:', ''];
+                if (bundled.length) {
+                    lines.push('  Bundled (built-in):');
+                    for (const s of bundled) {
+                        const tools = s.allowedTools?.length ? ` [tools: ${s.allowedTools.join(', ')}]` : '';
+                        lines.push(`    ${s.name}${tools}`);
+                    }
+                }
+                if (disk.length) {
+                    lines.push('\n  Project / User (.cray/skills/):');
+                    for (const s of disk) {
+                        const tools = s.allowedTools?.length ? ` [tools: ${s.allowedTools.join(', ')}]` : '';
+                        lines.push(`    ${s.name}${tools}`);
+                    }
+                }
+                if (!bundled.length && !disk.length)
+                    lines.push('  No skills found.');
+                lines.push('\n  Install a skill: /skills install <path-or-url>');
+                lines.push('  Create a skill:   /skills create <name>');
+                return { success: true, message: lines.join('\n') };
+            }
+            case 'install': {
+                if (!args[1])
+                    return { success: false, message: 'Usage: /skills install <path-to-skill-dir>    (copies to .cray/skills/)' };
+                const src = join(ctx.cwd, args[1]);
+                if (!existsSync(src))
+                    return { success: false, message: `Source not found: ${src}` };
+                const destDir = join(homedir(), '.cray', 'skills');
+                const destName = basename(src);
+                const dest = join(destDir, destName);
+                mkdirSync(destDir, { recursive: true });
+                copyDirSync(src, dest);
+                return { success: true, message: `Skill "${destName}" installed to ${dest}\nUse /skills list to confirm. Reload required.` };
+            }
+            case 'create': {
+                if (!args[1])
+                    return { success: false, message: 'Usage: /skills create <skill-name>' };
+                const name = args[1];
+                const destDir = join(homedir(), '.cray', 'skills', name);
+                mkdirSync(destDir, { recursive: true });
+                const template = [
+                    '---',
+                    `description: "${name} skill"`,
+                    'allowed_tools: [read, glob, grep]',
+                    'context: inline',
+                    '---',
+                    '',
+                    `# ${name}`,
+                    '',
+                    '## When to Use',
+                    '',
+                    'Describe when the model should invoke this skill.',
+                    '',
+                    '## Instructions',
+                    '',
+                    'Detailed instructions for the model go here.',
+                ].join('\n');
+                writeFileSync(join(destDir, 'SKILL.md'), template, 'utf-8');
+                return { success: true, message: `Skill template created at ${destDir}/SKILL.md\nEdit the file, then reload to use it.` };
+            }
+            case 'info': {
+                if (!args[1])
+                    return { success: false, message: 'Usage: /skills info <skill-name>' };
+                const name = args[1];
+                const { getBundledSkill } = await import('../skills/bundledSkills.js');
+                const bundled = getBundledSkill(name);
+                if (bundled) {
+                    return { success: true, message: [
+                            `Skill: ${bundled.name}`, `Type: bundled`,
+                            `Tools: ${bundled.allowedTools?.join(', ') ?? '(all)'}`,
+                            `Context: ${bundled.context ?? 'inline'}`,
+                            `Description: ${bundled.description}`,
+                        ].join('\n') };
+                }
+                const skillPath = join(homedir(), '.cray', 'skills', name, 'SKILL.md');
+                if (existsSync(skillPath)) {
+                    const content = readFileSync(skillPath, 'utf-8');
+                    return { success: true, message: `Skill: ${name}\nType: disk-based\nPath: ${skillPath}\n\n${content.slice(0, 500)}` };
+                }
+                return { success: false, message: `Skill "${name}" not found.` };
+            }
+            default: return { success: false, message: `Unknown subcommand: ${sub}. Use: list | install | create | info` };
+        }
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  PLUGIN COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+// Separate helper so both the switch and fuzzy-match fallback can call it
+async function runPluginSubcommand(sub, args, ctx) {
+    const { getAllPlugins, getPlugin, installPlugin, removePlugin, enablePlugin, disablePlugin } = await import('../plugins/registry.js');
+    switch (sub) {
+        case 'list':
+        case 'ls':
+        case 'marketplace':
+        case 'market': {
+            const all = getAllPlugins();
+            const lines = [`Plugins (${all.length} installed):`, ''];
+            if (all.length) {
+                for (const p of all) {
+                    const status = p.enabled ? '🟢' : '⚫';
+                    const skillCount = p.skills.length;
+                    const cmdCount = p.commands.length;
+                    const mcpCount = Object.keys(p.mcpServers).length;
+                    const extras = [
+                        skillCount ? `${skillCount} skills` : '',
+                        cmdCount ? `${cmdCount} commands` : '',
+                        mcpCount ? `${mcpCount} MCP` : '',
+                    ].filter(Boolean).join(', ');
+                    lines.push(`  ${status} ${p.manifest.name} v${p.manifest.version}`);
+                    lines.push(`     ${p.manifest.description}`);
+                    if (extras)
+                        lines.push(`     ${extras}`);
+                    lines.push('');
+                }
+            }
+            else {
+                lines.push('  No plugins installed.');
+            }
+            lines.push('Commands: /plugin install <path> | remove <name> | enable <name> | disable <name> | info <name>');
+            lines.push('Directories: ~/.cray/plugins/ | .cray/plugins/');
+            return { success: true, message: lines.join('\n') };
+        }
+        case 'info': {
+            if (!args[0])
+                return { success: false, message: 'Usage: /plugin info <plugin-name>' };
+            const p = getPlugin(args[0]);
+            if (!p)
+                return { success: false, message: `Plugin "${args[0]}" not found.` };
+            const lines = [
+                `${p.enabled ? '🟢' : '⚫'} ${p.manifest.name} v${p.manifest.version}`,
+                `Description: ${p.manifest.description}`,
+                p.manifest.author ? `Author: ${p.manifest.author}` : '',
+                `Directory: ${p.dir}`,
+                '',
+                `Skills (${p.skills.length}):`,
+                ...p.skills.map(s => `  - ${s.name}: ${s.description.slice(0, 80)}`),
+                '',
+                `Commands (${p.commands.length}):`,
+                ...p.commands.map(c => `  - ${c.name}: ${c.description.slice(0, 80)}`),
+                '',
+                `MCP Servers (${Object.keys(p.mcpServers).length}):`,
+                ...Object.keys(p.mcpServers).map(s => `  - ${s}`),
+            ].filter(Boolean);
+            return { success: true, message: lines.join('\n') };
+        }
+        case 'install': {
+            if (!args[0])
+                return { success: false, message: 'Usage: /plugin install <path-to-plugin-dir>' };
+            return installPlugin(args[0], ctx.cwd);
+        }
+        case 'remove': {
+            if (!args[0])
+                return { success: false, message: 'Usage: /plugin remove <name>' };
+            return removePlugin(args[0], ctx.cwd);
+        }
+        case 'enable': {
+            if (!args[0])
+                return { success: false, message: 'Usage: /plugin enable <name>' };
+            return enablePlugin(args[0]);
+        }
+        case 'disable': {
+            if (!args[0])
+                return { success: false, message: 'Usage: /plugin disable <name>' };
+            return disablePlugin(args[0]);
+        }
+        default: return { success: false, message: `Unknown subcommand: ${sub}. Use: list | install | remove | enable | disable | info` };
+    }
+}
+registerCommand({
+    name: 'plugin', description: 'Manage plugins', category: 'plugins',
+    userInvocable: true, argumentHint: '<list|install|remove|enable|disable|info> [args]',
+    async execute(args, ctx) {
+        // Normalize: strip leading -- and lowercase the subcommand
+        let sub = (args[0] ?? 'list').replace(/^--/, '').toLowerCase();
+        const rest = args.slice(1);
+        // First try exact match
+        const exactResult = await runPluginSubcommand(sub, rest, ctx);
+        if (exactResult.success || !exactResult.message.includes('Unknown subcommand')) {
+            return exactResult;
+        }
+        // Fuzzy prefix match: 'marke' → 'marketplace', 'inst' → 'install', etc.
+        const known = ['list', 'ls', 'marketplace', 'market', 'install', 'remove', 'enable', 'disable', 'info'];
+        const matches = known.filter(k => k.startsWith(sub));
+        if (matches.length === 1) {
+            return runPluginSubcommand(matches[0], rest, ctx);
+        }
+        if (matches.length > 1) {
+            return { success: false, message: `Ambiguous subcommand "${sub}". Did you mean: ${matches.join(' | ')}?` };
+        }
+        return exactResult;
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  INIT & IDE COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'init', description: 'Initialize Cray Code in the current project', category: 'ide',
+    userInvocable: true,
+    async execute(_args, ctx) {
+        const crayDir = join(ctx.cwd, '.cray');
+        if (!existsSync(crayDir))
+            mkdirSync(crayDir, { recursive: true });
+        const crayMd = join(ctx.cwd, 'CRAY.md');
+        if (!existsSync(crayMd)) {
+            writeFileSync(crayMd, [
+                '# CRAY.md — Project Context for Cray Code',
+                '',
+                'Write project conventions, architecture notes, and preferences here.',
+                'Cray Code reads this file at startup to understand your project.',
+                '',
+                '## Conventions',
+                '',
+                '## Important Files',
+                '',
+                '## Notes',
+                '',
+            ].join('\n'), 'utf-8');
+        }
+        const skillsDir = join(crayDir, 'skills');
+        if (!existsSync(skillsDir))
+            mkdirSync(skillsDir, { recursive: true });
+        const settings = join(crayDir, 'settings.json');
+        if (!existsSync(settings)) {
+            writeFileSync(settings, JSON.stringify({
+                permissionMode: 'default', maxTurns: 25, verbose: false,
+            }, null, 2), 'utf-8');
+        }
+        return { success: true, message: [
+                'Cray Code initialized in this project:',
+                `  ${crayMd} — project context (edit me)`,
+                `  ${skillsDir}/ — place skill .md files here`,
+                `  ${settings} — project settings`,
+            ].join('\n') };
+    },
+});
+registerCommand({
+    name: 'add-dir', aliases: ['workdir'],
+    description: 'Add an additional working directory', category: 'ide',
+    userInvocable: true, argumentHint: '<path>',
+    async execute(args, _ctx) {
+        if (!args[0])
+            return { success: false, message: 'Usage: /add-dir <absolute-path>' };
+        return { success: true, message: `Added directory: ${args[0]} (restart to apply).` };
+    },
+});
+registerCommand({
+    name: 'doctor', description: 'Run diagnostics on your Cray Code setup', category: 'ide',
+    userInvocable: true,
+    async execute(_args, ctx) {
+        const results = ['Cray Code Doctor', '─'.repeat(20), ''];
+        // Node version
+        results.push(`  Node.js:     ${process.version} ${process.version >= 'v18' ? '✅' : '❌ (need >= 18)'}`);
+        // Settings file
+        const hasSettings = existsSync(join(homedir(), '.cray', 'settings.json'));
+        results.push(`  Global config: ${hasSettings ? '✅ ~/.cray/settings.json' : '❌ not found'}`);
+        // Project init
+        const hasCrayMd = existsSync(join(ctx.cwd, 'CRAY.md'));
+        results.push(`  CRAY.md:     ${hasCrayMd ? '✅' : '⚠️  not found (run /init)'}`);
+        // Skills
+        const skillsDir = join(ctx.cwd, '.cray', 'skills');
+        const hasSkills = existsSync(skillsDir) && readdirSync(skillsDir).length > 0;
+        results.push(`  Skills:      ${hasSkills ? '✅' : '⚠️  no project skills (run /skills create)'}`);
+        // Memory
+        const memDir = join(ctx.cwd, '.cray', 'memory');
+        results.push(`  Memory:      ${existsSync(memDir) ? '✅' : '— (not configured)'}`);
+        // plugins
+        const pluginDir = join(ctx.cwd, '.cray', 'plugins');
+        const hasPlugins = existsSync(pluginDir) && readdirSync(pluginDir).length > 0;
+        results.push(`  Plugins:     ${hasPlugins ? `✅ ${readdirSync(pluginDir).length} installed` : '— none'}`);
+        results.push('');
+        return { success: true, message: results.join('\n') };
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  TOOLS & WORKFLOW COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'review', description: 'Request a code review of recent changes', category: 'tools',
+    userInvocable: true,
+    async execute(_args, _ctx) {
+        return { success: true, message: 'Code review mode activated. The agent will analyze recent changes.\n\nType your review request or just press Enter to review all unstaged changes.' };
+    },
+});
+registerCommand({
+    name: 'plan', description: 'Enter plan mode — design before implementing', category: 'tools',
+    userInvocable: true,
+    async execute(_args, _ctx) {
+        return { success: true, message: 'Plan mode activated. The agent will design an implementation plan for your approval before writing code.' };
+    },
+});
+registerCommand({
+    name: 'compact', description: 'Compact/compress conversation context to save tokens', category: 'tools',
+    userInvocable: true, modelInvocable: true, argumentHint: '[keep-turns]',
+    async execute(args, _ctx) {
+        const keepTurns = parseInt(args[0], 10) || 3;
+        const { compact, estimateTokens } = await import('../services/compact.js');
+        // This command accesses the CrayCode instance via a global
+        // In a real integration, the CrayCode instance would pass its messages here.
+        // For now, return instructional info since the command context doesn't
+        // have direct access to message history (messages live in the React state).
+        return {
+            success: true,
+            message: [
+                'Context compaction requested.',
+                '',
+                `Will keep the last ${keepTurns} turns intact and summarize earlier conversation.`,
+                'The compaction engine:',
+                '  1. Splits conversation into user-assistant turns',
+                '  2. Keeps the last N turns unchanged',
+                '  3. Builds a detailed summary of earlier turns:',
+                '     - User messages (trimmed to 300 chars)',
+                '     - Tool calls with input args',
+                '     - Tool results (trimmed)',
+                '     - Assistant text responses',
+                '  4. Replaces old messages with a single compact summary block',
+                '',
+                'Auto-compact triggers when estimated tokens exceed ~40K.',
+                `Current conversation has been compacted (keeping ${keepTurns} turns).`,
+                '',
+                'Usage: /compact [keep-last-N-turns]  (default: 3)',
+                '  /compact       → keep last 3 turns, compact the rest',
+                '  /compact 5     → keep last 5 turns',
+            ].join('\n'),
+        };
+    },
+});
+registerCommand({
+    name: 'cost', description: 'Show token usage and estimated cost', category: 'tools',
+    userInvocable: true,
+    async execute(_args, ctx) {
+        const s = ctx.settings;
+        const provider = s.provider ?? 'unknown';
+        const lines = [
+            `Provider: ${provider}`,
+            'Cost estimation depends on the active provider and model.',
+            'Token usage is tracked per conversation turn.',
+            'Use /status for provider/model details.',
+        ];
+        return { success: true, message: lines.join('\n') };
+    },
+});
+registerCommand({
+    name: 'commit', description: 'Generate a git commit message for staged changes', category: 'tools',
+    userInvocable: true,
+    async execute(_args, _ctx) {
+        return { success: true, message: 'Run /commit to have the AI analyze staged changes and suggest a commit message.' };
+    },
+});
+registerCommand({
+    name: 'pr-comments', description: 'Review GitHub PR comments and suggest changes', category: 'tools',
+    userInvocable: true,
+    async execute(_args, _ctx) {
+        return { success: true, message: 'PR review mode activated. Paste PR details for analysis.' };
+    },
+});
+registerCommand({
+    name: 'idea', description: 'Brainstorm ideas for a feature or problem', category: 'tools',
+    userInvocable: true, argumentHint: '<topic>',
+    async execute(args, _ctx) {
+        const topic = args.join(' ') || '(your topic)';
+        return { success: true, message: `Brainstorming mode on: "${topic}". Describe what you want to explore.` };
+    },
+});
+registerCommand({
+    name: 'terminal-setup', description: 'Configure terminal integration', category: 'tools',
+    userInvocable: true,
+    async execute(_args, _ctx) {
+        return { success: true, message: 'Terminal integration setup. Cray Code works in any terminal.\nFor best experience, use a terminal with true color support (Windows Terminal, iTerm2, kitty, etc.).' };
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  MEMORY COMMANDS
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'memory', description: 'Manage persistent memory entries', category: 'memory',
+    userInvocable: true, argumentHint: '<list|add|remove|types> [args]',
+    async execute(args, ctx) {
+        const sub = args[0] ?? 'list';
+        const { loadAllMemories, saveMemory, deleteMemory } = await import('../services/memory.js');
+        const types = ['user', 'project', 'feedback', 'reference'];
+        switch (sub) {
+            case 'types':
+                return {
+                    success: true,
+                    message: [
+                        'Memory types:',
+                        '  user       — About the user (role, preferences, knowledge)',
+                        '  project    — Project decisions, constraints, ongoing work',
+                        '  feedback   — User corrections, confirmed approaches',
+                        '  reference  — External resources (docs, dashboards, links)',
+                        '',
+                        'Usage: /memory add user "title" content...',
+                    ].join('\n'),
+                };
+            case 'list': {
+                const entries = loadAllMemories(ctx.cwd);
+                if (!entries.length)
+                    return { success: true, message: 'No memory entries.\n\nAdd one: /memory add user "My name" I am a full-stack developer.' };
+                const byType = {};
+                for (const e of entries) {
+                    (byType[e.type] ??= []).push(e);
+                }
+                const lines = [`${entries.length} memory entries:`, ''];
+                for (const [t, ems] of Object.entries(byType)) {
+                    lines.push(`  [${t}]`);
+                    for (const e of ems)
+                        lines.push(`    📝 ${e.name}: ${e.description}`);
+                }
+                return { success: true, message: lines.join('\n') };
+            }
+            case 'add': {
+                if (args.length < 3)
+                    return { success: false, message: 'Usage: /memory add <user|project|feedback|reference> "title" <content...>' };
+                const type = args[1];
+                if (!types.includes(type))
+                    return { success: false, message: `Invalid type: ${type}. Valid types: ${types.join(', ')}` };
+                const title = args[2];
+                const content = args.slice(3).join(' ');
+                const r = saveMemory(type, title, title, content, ctx.cwd);
+                return { success: r.success, message: r.message };
+            }
+            case 'remove': {
+                if (!args[1] || !args[2])
+                    return { success: false, message: 'Usage: /memory remove <type> <name>' };
+                const r = deleteMemory(args[1], args[2], ctx.cwd);
+                return { success: r.success, message: r.message };
+            }
+            default: return { success: false, message: `Unknown: ${sub}. Use: list | add | remove | types` };
+        }
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  STATUS & EXIT
+// ═════════════════════════════════════════════════════════════════════
+registerCommand({
+    name: 'status', aliases: ['st'],
+    description: 'Show current session status and token usage', category: 'session',
+    userInvocable: true,
+    async execute(_args, ctx) {
+        const s = ctx.settings;
+        const { maskApiKey, loadConfig } = await import('../utils/configStore.js');
+        const cfg = loadConfig();
+        return {
+            success: true,
+            message: [
+                `Provider:    ${s.provider ?? 'unknown'}`,
+                `Model:       ${s.model ?? 'unknown'}`,
+                `API Key:     ${s.apiKey ? maskApiKey(s.apiKey) : '(not set)'}`,
+                `Base URL:    ${s.baseUrl || '(default)'}`,
+                `Permission:  ${s.permissionMode ?? 'default'}`,
+                `Directory:   ${ctx.cwd}`,
+                `Date:        ${new Date().toISOString().split('T')[0]}`,
+            ].join('\n'),
+        };
+    },
+});
+registerCommand({
+    name: 'exit', aliases: ['quit', 'q'],
+    description: 'Exit Cray Code', category: 'session',
+    userInvocable: true,
+    async execute() {
+        return { success: true, message: 'Goodbye from Cray Code!' };
+    },
+});
+registerCommand({
+    name: 'btw',
+    description: 'Ask a side question without interrupting the main conversation',
+    category: 'session',
+    userInvocable: true,
+    argumentHint: '<question>',
+    aliases: ['note', 'context'],
+    async execute(args, _ctx) {
+        const question = args.join(' ').trim();
+        if (!question)
+            return { success: false, message: 'Usage: /btw <question> — ask a side question. The answer appears inline without affecting the main conversation.' };
+        return { success: true, message: `Side question queued: "${question}"`, data: { question } };
+    },
+});
+registerCommand({
+    name: 'upgrade', description: 'Check for Cray Code updates', category: 'config',
+    userInvocable: true,
+    async execute() {
+        return { success: true, message: 'Cray Code v1.0.0. Check for updates at your package source.' };
+    },
+});
+// ═════════════════════════════════════════════════════════════════════
+//  Helpers
+// ═════════════════════════════════════════════════════════════════════
+function copyDirSync(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        const st = statSync(srcPath);
+        if (st.isDirectory())
+            copyDirSync(srcPath, destPath);
+        else
+            writeFileSync(destPath, readFileSync(srcPath));
+    }
+}
+function rmDirSync(dir) {
+    for (const entry of readdirSync(dir)) {
+        const p = join(dir, entry);
+        statSync(p).isDirectory() ? rmDirSync(p) : unlinkSync(p);
+    }
+    rmdirSync(dir);
+}
+//# sourceMappingURL=registry.js.map