@backendkit-labs/agent-core 0.14.0

package/dist/commands/builtin.js

@@ -0,0 +1,694 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuiltinCommands = registerBuiltinCommands;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const result_1 = require("@backendkit-labs/result");
+const manager_1 = require("../skills/manager");
+const parse_md_skill_1 = require("../skills/parse-md-skill");
+const project_key_1 = require("../shared/utils/project-key");
+const atomic_write_1 = require("../shared/utils/atomic-write");
+const checkpoint_1 = require("../checkpoint");
+const workspace_1 = require("../workspace");
+// ── Internal helper ───────────────────────────────────────────────────────────
+async function doSwitch(wsName, projectName, config, appName, emit, injectContext, onCwdChange) {
+    const ws = config[wsName];
+    if (!ws) {
+        emit(`Workspace "${wsName}" not found.`);
+        return;
+    }
+    const target = ws.projects.find(p => p.name === projectName);
+    if (!target) {
+        emit(`Project "${projectName}" not found in workspace "${wsName}".`);
+        return;
+    }
+    // Persist the new active state
+    const updated = (0, workspace_1.setActiveProject)(config, wsName, target.name);
+    await (0, workspace_1.saveWorkspaces)(appName, updated);
+    // Inject workspace context into agent memory
+    const context = await (0, workspace_1.buildWorkspaceContext)(wsName, updated[wsName], appName);
+    injectContext?.(context);
+    if (onCwdChange) {
+        onCwdChange(target.cwd);
+        emit(`Switched to workspace "${wsName}" — project: ${target.name}`);
+    }
+    else {
+        emit(`Workspace "${wsName}" loaded — project: ${target.name} (${target.cwd})`);
+    }
+}
+// ── Registry ──────────────────────────────────────────────────────────────────
+/**
+ * Registers the framework's built-in slash commands into the given registry.
+ * Call this once when bootstrapping the app — before registering app-specific commands.
+ */
+function registerBuiltinCommands(registry) {
+    registry.register('/help', 'List available commands', async (ctx) => {
+        const cmds = registry.getAll();
+        const list = cmds.map(c => `- ${c.name.padEnd(22)} ${c.description}`).join('\n');
+        ctx.emit(`Available commands:\n${list}`);
+    });
+    registry.register('/agents', 'List agents or switch active agent', async (ctx) => {
+        if (!ctx.agents?.length) {
+            ctx.emit('No agents loaded.');
+            return;
+        }
+        const active = ctx.effectiveAgentId;
+        if (ctx.prompt) {
+            const options = ctx.agents.map(a => {
+                const icon = a.icon ? `${a.icon} ` : '';
+                const badge = a.id === active ? ' [activo]' : '';
+                const label = `${icon}${a.name}${badge}`;
+                const desc = a.description ? ` — ${a.description}` : '';
+                return { label: `${label.padEnd(28)}${desc}`, value: a.id };
+            });
+            const selected = await ctx.prompt('Seleccionar agente:', options);
+            if (!selected)
+                return;
+            if (selected === active) {
+                ctx.emit(`Ya estás usando ${selected}.`);
+                return;
+            }
+            // Switch via engine so the bridge/engine updates the active agent
+            await ctx.runEngine?.(`/agent ${selected}`);
+            ctx.emit(`Agente cambiado → ${selected}`);
+        }
+        else {
+            const lines = ctx.agents.map(a => {
+                const icon = a.icon ? `${a.icon} ` : '';
+                const marker = a.id === active ? ' ◀ activo' : '';
+                return `  ${icon}${a.id.padEnd(20)} ${a.name}${marker}`;
+            });
+            ctx.emit('Agentes disponibles:\n' + lines.join('\n') +
+                '\n\nUsa /agents para el picker interactivo o /agent <id> para cambiar directamente.');
+        }
+    });
+    registry.register('/skills', 'Gestionar skills: list, install, create, generate, update, uninstall, reload', async (ctx) => {
+        const parts = ctx.args.trim().split(/\s+/);
+        const sub = parts[0];
+        // ── /skills install <url> [--global] ─────────────────────────────────
+        if (sub === 'install') {
+            const source = parts[1];
+            if (!source) {
+                ctx.emit('Uso: /skills install <url> [--global]\n' +
+                    '  /skills install https://skills.sh/owner/repo\n' +
+                    '  /skills install https://github.com/owner/repo\n' +
+                    '  /skills install https://skills.sh/owner/repo --global\n\n' +
+                    'Sin --global, el pack se instala solo para este proyecto.');
+                return;
+            }
+            const isGlobal = parts.includes('--global');
+            const appName = ctx.appName ?? 'bk-agent';
+            const manager = (0, manager_1.createSkillManager)(appName);
+            try {
+                ctx.emit(`Instalando skill desde: ${source}…`);
+                await manager.install(source, {
+                    projectDir: isGlobal ? undefined : ctx.projectDir,
+                });
+                const scope = isGlobal ? 'global' : 'proyecto';
+                await ctx.reloadSkills?.();
+                ctx.emit(`✓ Skill instalada (scope: ${scope}).`);
+            }
+            catch (err) {
+                ctx.emit(`✗ Error al instalar: ${err.message}`);
+            }
+            return;
+        }
+        // ── /skills create <nombre> [--global] ───────────────────────────────
+        if (sub === 'create') {
+            const name = parts[1];
+            if (!name) {
+                ctx.emit('Uso: /skills create <nombre> [--global]\n' +
+                    '  /skills create mi-skill           → crea en el proyecto actual\n' +
+                    '  /skills create mi-skill --global  → crea en el directorio global\n\n' +
+                    'El nombre debe ser kebab-case (ej: code-review-nestjs, deploy-docker).');
+                return;
+            }
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+                ctx.emit('✗ El nombre debe ser kebab-case (solo letras minúsculas, números y guiones).');
+                return;
+            }
+            const isGlobal = parts.includes('--global');
+            const appName = ctx.appName ?? 'bk-agent';
+            const dir = isGlobal || !ctx.projectDir
+                ? path.join((0, project_key_1.getFrameworkDir)(appName), 'skills', 'global')
+                : path.join(ctx.projectDir, 'skills');
+            const filePath = path.join(dir, `${name}.md`);
+            const exists = await (0, result_1.run)(() => fs.access(filePath));
+            if ((0, result_1.isOk)(exists)) {
+                ctx.emit(`✗ Ya existe una skill con ese nombre: ${filePath}`);
+                return;
+            }
+            const template = [
+                '---',
+                `name: ${name}`,
+                'version: 1.0.0',
+                'description: ',
+                'triggers:',
+                '  - ',
+                '---',
+                '',
+                '',
+            ].join('\n');
+            await fs.mkdir(dir, { recursive: true });
+            await (0, atomic_write_1.atomicWrite)(filePath, template);
+            await ctx.reloadSkills?.();
+            ctx.emit(`✓ Skill creada: ${filePath}`);
+            return;
+        }
+        // ── /skills generate <descripción> [--global] ────────────────────────
+        if (sub === 'generate') {
+            const isGlobal = parts.includes('--global');
+            const description = parts.slice(1).filter(p => p !== '--global').join(' ');
+            if (!description) {
+                ctx.emit('Uso: /skills generate <descripción> [--global]\n' +
+                    '  /skills generate "proceso de code review para NestJS"\n' +
+                    '  /skills generate "flujo de deploy con Docker Compose" --global');
+                return;
+            }
+            if (!ctx.llm) {
+                ctx.emit('✗ LLM no disponible en este contexto.\n' +
+                    'Usá /skills create <nombre> para crear la skill manualmente.');
+                return;
+            }
+            const appName = ctx.appName ?? 'bk-agent';
+            const dir = isGlobal || !ctx.projectDir
+                ? path.join((0, project_key_1.getFrameworkDir)(appName), 'skills', 'global')
+                : path.join(ctx.projectDir, 'skills');
+            ctx.emit('Generando skill…');
+            const prompt = `Generate a skill file in .md format with YAML frontmatter.\n` +
+                `Output raw file content only — no markdown code fences, no extra explanation.\n\n` +
+                `Required format:\n` +
+                `---\n` +
+                `name: <kebab-case name, max 4 words>\n` +
+                `version: 1.0.0\n` +
+                `description: <one concise line>\n` +
+                `triggers:\n` +
+                `  - <keyword1>\n` +
+                `  - <keyword2>\n` +
+                `  - <keyword3>\n` +
+                `---\n\n` +
+                `<Clear step-by-step instructions in markdown>\n\n` +
+                `Description: "${description.slice(0, 500)}"`;
+            let md;
+            try {
+                const raw = await ctx.llm(prompt);
+                md = raw.replace(/^```(?:md|markdown)?\n?/im, '').replace(/```\s*$/m, '').trim();
+            }
+            catch (err) {
+                ctx.emit(`✗ Error generando skill: ${err.message}`);
+                return;
+            }
+            const skill = (0, parse_md_skill_1.parseMdSkill)(md);
+            if (!skill?.name) {
+                ctx.emit('✗ La respuesta del LLM no tiene el formato esperado.\n' +
+                    'Usá /skills create <nombre> para crear la skill manualmente.');
+                return;
+            }
+            const filePath = path.join(dir, `${skill.name}.md`);
+            const exists = await (0, result_1.run)(() => fs.access(filePath));
+            if ((0, result_1.isOk)(exists)) {
+                ctx.emit(`✗ Ya existe una skill con ese nombre: ${filePath}`);
+                return;
+            }
+            await fs.mkdir(dir, { recursive: true });
+            await (0, atomic_write_1.atomicWrite)(filePath, md);
+            await ctx.reloadSkills?.();
+            ctx.emit(`✓ Skill "${skill.name}" generada: ${filePath}`);
+            return;
+        }
+        // ── /skills uninstall <pack> ──────────────────────────────────────────
+        if (sub === 'uninstall') {
+            const pack = parts[1];
+            const appName = ctx.appName ?? 'bk-agent';
+            const manager = (0, manager_1.createSkillManager)(appName);
+            if (!pack) {
+                const packs = await manager.list();
+                if (!packs.length) {
+                    ctx.emit('No hay packs instalados.\nUsá /skills install <url> para instalar uno.');
+                    return;
+                }
+                if (ctx.prompt) {
+                    const options = packs.map(p => ({
+                        label: `${p.pack.padEnd(26)} skills: ${p.skills.join(', ')}`,
+                        value: p.pack,
+                    }));
+                    const selected = await ctx.prompt('Seleccioná el pack a desinstalar:', options);
+                    if (!selected)
+                        return;
+                    try {
+                        await manager.uninstall(selected);
+                        ctx.emit(`✓ Pack "${selected}" desinstalado.`);
+                    }
+                    catch (err) {
+                        ctx.emit(`✗ Error: ${err.message}`);
+                    }
+                }
+                else {
+                    const lines = packs.map(p => `  ${p.pack.padEnd(26)} ${p.skills.join(', ')}`);
+                    ctx.emit('Packs instalados:\n' + lines.join('\n') + '\n\nUsá: /skills uninstall <pack>');
+                }
+                return;
+            }
+            try {
+                await manager.uninstall(pack);
+                ctx.emit(`✓ Pack "${pack}" desinstalado.`);
+            }
+            catch (err) {
+                ctx.emit(`✗ Error: ${err.message}`);
+            }
+            return;
+        }
+        // ── /skills update <pack> ─────────────────────────────────────────────
+        if (sub === 'update') {
+            const pack = parts[1];
+            const appName = ctx.appName ?? 'bk-agent';
+            const manager = (0, manager_1.createSkillManager)(appName);
+            if (!pack) {
+                const packs = await manager.list();
+                if (!packs.length) {
+                    ctx.emit('No hay packs instalados.\nUsá /skills install <url> para instalar uno.');
+                    return;
+                }
+                if (ctx.prompt) {
+                    const options = packs.map(p => ({
+                        label: `${p.pack.padEnd(26)} instalado: ${p.installedAt.slice(0, 10)}`,
+                        value: p.pack,
+                    }));
+                    const selected = await ctx.prompt('Seleccioná el pack a actualizar:', options);
+                    if (!selected)
+                        return;
+                    try {
+                        ctx.emit(`Actualizando "${selected}"…`);
+                        await manager.update(selected);
+                        ctx.emit(`✓ Pack "${selected}" actualizado. Reinicia para aplicar los cambios.`);
+                    }
+                    catch (err) {
+                        ctx.emit(`✗ Error: ${err.message}`);
+                    }
+                }
+                else {
+                    const lines = packs.map(p => `  ${p.pack.padEnd(26)} instalado: ${p.installedAt.slice(0, 10)}`);
+                    ctx.emit('Packs instalados:\n' + lines.join('\n') + '\n\nUsá: /skills update <pack>');
+                }
+                return;
+            }
+            try {
+                ctx.emit(`Actualizando "${pack}"…`);
+                await manager.update(pack);
+                ctx.emit(`✓ Pack "${pack}" actualizado. Reinicia para aplicar los cambios.`);
+            }
+            catch (err) {
+                ctx.emit(`✗ Error: ${err.message}`);
+            }
+            return;
+        }
+        // ── /skills reload ────────────────────────────────────────────────────
+        if (sub === 'reload') {
+            if (!ctx.reloadSkills) {
+                ctx.emit('✗ Reload no disponible en este contexto.');
+                return;
+            }
+            ctx.emit('Recargando skills…');
+            await ctx.reloadSkills();
+            ctx.emit('✓ Skills recargadas.');
+            return;
+        }
+        // ── /skills list (default) ────────────────────────────────────────────
+        const SUBCOMMANDS_HINT = '\n\nSubcomandos: install | create | generate | update | uninstall | reload';
+        if (!ctx.skills?.length) {
+            ctx.emit('No skills cargadas.' + SUBCOMMANDS_HINT);
+            return;
+        }
+        if (ctx.prompt) {
+            const options = ctx.skills.map(s => ({
+                label: `${s.name.padEnd(26)} ${s.description}`,
+                value: s.name,
+            }));
+            const INSTALL = '__install__';
+            const selected = await ctx.prompt('Skills disponibles:', [
+                ...options,
+                { label: '+ Instalar pack desde URL...', value: INSTALL },
+            ]);
+            if (!selected || selected === INSTALL) {
+                if (selected === INSTALL) {
+                    ctx.emit('Para instalar un pack escribí:\n  /skills install https://skills.sh/owner/repo');
+                }
+                return;
+            }
+            const skill = ctx.skills.find(s => s.name === selected);
+            if (skill) {
+                ctx.emit([
+                    `Skill: ${skill.name}`,
+                    `Descripción: ${skill.description}`,
+                    skill.triggers.length ? `Triggers: ${skill.triggers.join(', ')}` : '',
+                    skill.language?.length ? `Lenguajes: ${skill.language.join(', ')}` : '',
+                    `Scope: ${skill.scope ?? '—'}`,
+                ].filter(Boolean).join('\n'));
+            }
+        }
+        else {
+            const lines = ctx.skills.map(s => `  ${s.name.padEnd(26)} ${s.description}${s.scope === 'project' ? ' [proyecto]' : ''}`);
+            ctx.emit('Skills:\n' + lines.join('\n') + SUBCOMMANDS_HINT);
+        }
+    });
+    registry.register('/status', 'Show current agent and model', async (ctx) => {
+        ctx.emit([
+            `Agent     : ${ctx.effectiveAgentId ?? '—'}`,
+            `Model     : ${ctx.model ?? '—'}`,
+            `Iteration : ${ctx.getIterationMode?.() ?? '—'}`,
+        ].join('\n'));
+    });
+    registry.register('/iteration', 'Change or show the iteration mode', async (ctx) => {
+        const MODES = [
+            { value: 'interactive', label: 'interactive', description: 'Pauses every N iterations — you decide whether to continue' },
+            { value: 'auto', label: 'auto', description: 'Never pauses — runs until done or global cap (1000)' },
+            { value: 'step-by-step', label: 'step-by-step', description: 'Pauses after every single iteration for maximum control' },
+        ];
+        const current = ctx.getIterationMode?.();
+        // Arg directo: /iteration auto | /iteration step-by-step | /iteration interactive
+        if (ctx.args) {
+            const arg = ctx.args.trim();
+            if (MODES.some(m => m.value === arg)) {
+                ctx.setIterationMode?.(arg);
+                ctx.emit(`Iteration mode → ${arg}`);
+            }
+            else {
+                ctx.emit(`Unknown mode "${arg}". Options: interactive | auto | step-by-step`);
+            }
+            return;
+        }
+        // Sin arg: mostrar modo actual y permitir elegir
+        if (ctx.prompt) {
+            const selected = await ctx.prompt(`Iteration mode (current: ${current ?? '—'}):`, MODES.map(m => ({
+                label: `${m.value.padEnd(16)} ${m.description}`,
+                value: m.value,
+            })));
+            if (selected) {
+                ctx.setIterationMode?.(selected);
+                ctx.emit(`Iteration mode → ${selected}`);
+            }
+        }
+        else {
+            const lines = MODES.map(m => `  ${(current === m.value ? '▶ ' : '  ')}${m.value.padEnd(16)} ${m.description}`);
+            ctx.emit(`Iteration mode (current: ${current ?? '—'}):\n${lines.join('\n')}\n\nUse /iteration <mode> to change.`);
+        }
+    });
+    registry.register('/workspace', 'Manage multi-project workspaces', async (ctx) => {
+        const { args, emit, appName, injectContext, onCwdChange } = ctx;
+        if (!appName) {
+            emit('appName not set in CommandContext.');
+            return;
+        }
+        const parts = (args ?? '').split(' ').filter(Boolean);
+        const sub = parts[0];
+        // ── /workspace  or  /workspace list ──────────────────────────────────
+        if (!sub || sub === 'list') {
+            const config = await (0, workspace_1.loadWorkspaces)(appName);
+            const names = Object.keys(config);
+            if (!names.length) {
+                emit('No hay workspaces configurados.\n\n' +
+                    'Comandos disponibles:\n' +
+                    '  /workspace create <name>               Crear workspace nuevo\n' +
+                    '  /workspace add <ws> <cwd> [name]       Agregar proyecto existente\n' +
+                    '  /workspace import <cwd> [ws] [name]    Importar proyecto (crea ws si no existe)\n' +
+                    '  /workspace switch <ws> [project]       Cambiar workspace/proyecto activo\n' +
+                    '  /workspace remove <ws> <project>       Quitar proyecto del workspace\n' +
+                    '  /workspace delete <name>               Eliminar workspace\n' +
+                    '  /workspace list                        Listar workspaces');
+                return;
+            }
+            if (ctx.prompt && !sub) {
+                // Interactive: let the user pick a workspace+project to switch to directly
+                const options = names.flatMap(wsName => {
+                    const ws = config[wsName];
+                    return ws.projects.map(p => ({
+                        label: `${wsName.padEnd(18)} ${p.name}${p.name === ws.active ? ' *' : ''}`,
+                        value: `${wsName}::${p.name}`,
+                    }));
+                });
+                const selected = await ctx.prompt('Workspaces — select to switch:', options);
+                if (!selected)
+                    return;
+                const [wsName, projectName] = selected.split('::');
+                sub === undefined && await doSwitch(wsName, projectName, config, appName, emit, injectContext, onCwdChange);
+                return;
+            }
+            const lines = names.map(n => {
+                const ws = config[n];
+                const projects = ws.projects
+                    .map(p => `${p.name}${p.name === ws.active ? '*' : ''}`)
+                    .join(', ') || '(vacío)';
+                return `  ${n.padEnd(20)} ${projects}`;
+            });
+            emit('Workspaces (* = proyecto activo):\n' + lines.join('\n') + '\n\n' +
+                'Comandos:\n' +
+                '  /workspace create <name>               Crear workspace\n' +
+                '  /workspace add <ws> <cwd> [name]       Agregar proyecto\n' +
+                '  /workspace import <cwd> [ws] [name]    Importar proyecto\n' +
+                '  /workspace switch <ws> [project]       Cambiar activo\n' +
+                '  /workspace remove <ws> <project>       Quitar proyecto\n' +
+                '  /workspace delete <name>               Eliminar workspace');
+            return;
+        }
+        // ── /workspace create <name> ──────────────────────────────────────────
+        if (sub === 'create') {
+            const name = parts[1];
+            if (!name) {
+                emit('Usage: /workspace create <name>');
+                return;
+            }
+            const config = await (0, workspace_1.loadWorkspaces)(appName);
+            if (config[name]) {
+                emit(`Workspace "${name}" already exists.`);
+                return;
+            }
+            await (0, workspace_1.saveWorkspaces)(appName, (0, workspace_1.createWorkspace)(config, name));
+            emit(`Workspace "${name}" created.`);
+            return;
+        }
+        // ── /workspace add <workspace> <cwd> [name] ──────────────────────────
+        if (sub === 'add') {
+            const [, wsName, cwd, projectName] = parts;
+            if (!wsName || !cwd) {
+                emit('Usage: /workspace add <workspace> <cwd> [name]');
+                return;
+            }
+            const resolvedCwd = path.resolve(cwd);
+            const name = projectName ?? (0, workspace_1.deriveProjectName)(resolvedCwd);
+            try {
+                const config = await (0, workspace_1.loadWorkspaces)(appName);
+                await (0, workspace_1.saveWorkspaces)(appName, (0, workspace_1.addProject)(config[wsName] ? config : (0, workspace_1.createWorkspace)(config, wsName), wsName, { name, cwd: resolvedCwd }));
+                emit(`Added "${name}" to workspace "${wsName}".\n  cwd: ${resolvedCwd}`);
+            }
+            catch (e) {
+                emit(`Error: ${e.message}`);
+            }
+            return;
+        }
+        // ── /workspace import <cwd> [workspace] [name] ───────────────────────
+        // Like add but auto-creates the workspace if missing. Useful for quick onboarding.
+        if (sub === 'import') {
+            const [, cwd, wsName, projectName] = parts;
+            if (!cwd) {
+                emit('Usage: /workspace import <cwd> [workspace] [name]');
+                return;
+            }
+            const resolvedCwd = path.resolve(cwd);
+            const name = projectName ?? (0, workspace_1.deriveProjectName)(resolvedCwd);
+            const ws = wsName ?? name;
+            try {
+                const config = await (0, workspace_1.loadWorkspaces)(appName);
+                await (0, workspace_1.saveWorkspaces)(appName, (0, workspace_1.importProject)(config, ws, { name, cwd: resolvedCwd }));
+                emit(`Imported "${name}" into workspace "${ws}".\n  cwd: ${resolvedCwd}`);
+            }
+            catch (e) {
+                emit(`Error: ${e.message}`);
+            }
+            return;
+        }
+        // ── /workspace remove <workspace> <project> ───────────────────────────
+        if (sub === 'remove') {
+            const [, wsName, projectName] = parts;
+            if (!wsName || !projectName) {
+                emit('Usage: /workspace remove <workspace> <project>');
+                return;
+            }
+            const config = await (0, workspace_1.loadWorkspaces)(appName);
+            if (!config[wsName]) {
+                emit(`Workspace "${wsName}" not found.`);
+                return;
+            }
+            try {
+                await (0, workspace_1.saveWorkspaces)(appName, (0, workspace_1.removeProject)(config, wsName, projectName));
+                emit(`Removed "${projectName}" from workspace "${wsName}".`);
+            }
+            catch (e) {
+                emit(`Error: ${e.message}`);
+            }
+            return;
+        }
+        // ── /workspace delete <name> ──────────────────────────────────────────
+        if (sub === 'delete') {
+            const name = parts[1];
+            if (!name) {
+                emit('Usage: /workspace delete <name>');
+                return;
+            }
+            const config = await (0, workspace_1.loadWorkspaces)(appName);
+            if (!config[name]) {
+                emit(`Workspace "${name}" not found.`);
+                return;
+            }
+            await (0, workspace_1.saveWorkspaces)(appName, (0, workspace_1.deleteWorkspace)(config, name));
+            emit(`Workspace "${name}" deleted.`);
+            return;
+        }
+        // ── /workspace switch <workspace> [project] ───────────────────────────
+        if (sub === 'switch') {
+            const [, wsName, projectName] = parts;
+            const config = await (0, workspace_1.loadWorkspaces)(appName);
+            // No args after switch → interactive picker
+            if (!wsName && ctx.prompt) {
+                const names = Object.keys(config);
+                if (!names.length) {
+                    emit('No workspaces configured.');
+                    return;
+                }
+                const options = names.flatMap(wn => {
+                    const ws = config[wn];
+                    return ws.projects.map(p => ({
+                        label: `${wn.padEnd(18)} ${p.name}${p.name === ws.active ? ' *' : ''}`,
+                        value: `${wn}::${p.name}`,
+                    }));
+                });
+                const selected = await ctx.prompt('Switch to:', options);
+                if (!selected)
+                    return;
+                const [selWs, selProject] = selected.split('::');
+                await doSwitch(selWs, selProject, config, appName, emit, injectContext, onCwdChange);
+                return;
+            }
+            if (!wsName) {
+                emit('Usage: /workspace switch <workspace> [project]');
+                return;
+            }
+            const ws = config[wsName];
+            if (!ws) {
+                emit(`Workspace "${wsName}" not found.`);
+                return;
+            }
+            if (!ws.projects.length) {
+                emit(`Workspace "${wsName}" has no projects.`);
+                return;
+            }
+            const target = projectName
+                ? ws.projects.find(p => p.name === projectName)
+                : (ws.projects.find(p => p.name === ws.active) ?? ws.projects[0]);
+            if (!target) {
+                emit(`Project "${projectName}" not found in workspace "${wsName}".`);
+                return;
+            }
+            await doSwitch(wsName, target.name, config, appName, emit, injectContext, onCwdChange);
+            return;
+        }
+        emit([
+            'Usage:',
+            '  /workspace list',
+            '  /workspace create <name>',
+            '  /workspace add <workspace> <cwd> [name]',
+            '  /workspace import <cwd> [workspace] [name]',
+            '  /workspace remove <workspace> <project>',
+            '  /workspace delete <name>',
+            '  /workspace switch [workspace] [project]',
+        ].join('\n'));
+    });
+    registry.register('/checkpoint', 'Create / list / load session checkpoints', async (ctx) => {
+        const { args, emit, projectDir, sessionContent, injectContext } = ctx;
+        if (!projectDir) {
+            emit('No active project directory.');
+            return;
+        }
+        // /checkpoint list
+        if (args === 'list') {
+            const all = await (0, checkpoint_1.listCheckpoints)(projectDir);
+            if (!all.length) {
+                emit('No checkpoints saved.');
+                return;
+            }
+            const latest = (0, checkpoint_1.getLatestCheckpoints)(all);
+            const lines = latest.map((cp, i) => {
+                const count = all.filter(c => c.feature === cp.feature).length;
+                const label = (cp.feature || '(unnamed)').padEnd(24);
+                const timeDisplay = cp.time ? `${cp.time.slice(0, 2)}:${cp.time.slice(2)}` : '';
+                const versions = count > 1 ? `  (${count} versions)` : '';
+                return `  ${i + 1}. ${label} ${cp.date} ${timeDisplay}${versions}`;
+            });
+            emit(lines.join('\n'));
+            return;
+        }
+        // /checkpoint load [feature]
+        if (args === 'load' || args.startsWith('load ')) {
+            const target = args.slice(4).trim();
+            const all = await (0, checkpoint_1.listCheckpoints)(projectDir);
+            if (!all.length) {
+                emit('No checkpoints saved.');
+                return;
+            }
+            let match = target
+                ? all.find(cp => cp.feature === target || cp.feature.includes(target))
+                : all[0]; // most recent overall
+            if (!match) {
+                emit(`Checkpoint not found: ${target}`);
+                return;
+            }
+            const raw = await (0, checkpoint_1.readCheckpoint)(projectDir, match.filename);
+            if (raw) {
+                const session = (0, checkpoint_1.extractSessionFromCheckpoint)(raw);
+                const timeDisplay = match.time ? `${match.time.slice(0, 2)}:${match.time.slice(2)}` : '';
+                const label = match.feature || 'unnamed';
+                injectContext?.(`## Checkpoint: ${label} (${match.date} ${timeDisplay})\n\n${session}`);
+                emit(`Checkpoint loaded: ${label}`);
+            }
+            return;
+        }
+        // /checkpoint [name] — create (name optional)
+        const featureName = args ?? '';
+        const cpPath = await (0, checkpoint_1.createCheckpoint)(projectDir, featureName, '', sessionContent ?? '');
+        const label = featureName || '(unnamed)';
+        emit(`Checkpoint saved: ${label}\n${cpPath}`);
+    });
+}
+//# sourceMappingURL=builtin.js.map