codeep 2.0.0 → 2.0.1

package/dist/renderer/App.js

@@ -82,6 +82,15 @@ const COMMAND_DESCRIPTIONS = {
     'profile': 'Save/load settings profiles',
     'tasks': 'Show pending tasks from codeep.dev dashboard',
     'sync': 'Sync learning preferences and profiles to codeep.dev',
+    // 2.0 — surfaced for `/` autocomplete; documented in /help too.
+    'compact': 'Summarize older messages to free up context',
+    'commands': 'List custom slash commands in .codeep/commands/*.md',
+    'checkpoint': 'Snapshot the session (conversation + provider/model + git HEAD)',
+    'checkpoints': 'List saved checkpoints for this workspace',
+    'rewind': 'Restore conversation from a saved checkpoint',
+    'hooks': 'List installed lifecycle hooks (.codeep/hooks/<event>.sh)',
+    'mcp': 'Manage MCP servers (browse, install, add, remove, resources, prompts)',
+    'openrouter': 'Tune OpenRouter routing (preferred / ignore providers, fallbacks, privacy)',
 };
 import { helpCategories, keyboardShortcuts } from './components/Help.js';
 import { handleSettingsKey, SETTINGS } from './components/Settings.js';
@@ -217,6 +226,10 @@ export class App {
         'provider', 'model', 'protocol', 'lang', 'grant', 'login', 'logout',
         'context-save', 'context-load', 'context-clear', 'learn',
         'cost', 'tasks', 'account', 'sync',
+        // 2.0 — extensions, checkpoints, MCP, custom commands, OpenRouter prefs.
+        // Keep in lockstep with COMMAND_DESCRIPTIONS below and helpCategories.
+        'compact', 'commands', 'checkpoint', 'checkpoints', 'rewind',
+        'hooks', 'mcp', 'openrouter',
         'c', 't', 'd', 'r', 'f', 'e', 'o', 'b', 'p',
     ];
     constructor(options) {

package/dist/renderer/commands.js

@@ -1685,6 +1685,296 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             ctx.app.addMessage({ role: 'system', content: formatCommandList(loadCustomCommands(ctx.projectPath)) });
             break;
         }
+        case 'mcp': {
+            // Mirrors the ACP `/mcp` handler in src/acp/commands.ts. In TUI the
+            // session id is the constant `codeep-tui` (the same one main.ts uses
+            // when it spawns project MCP servers in the background) and the
+            // workspace root is ctx.projectPath. Without a project we can still
+            // browse the marketplace, but anything that mutates project config
+            // refuses with a clear message.
+            const sub = args[0]?.toLowerCase();
+            const TUI_SESSION = 'codeep-tui';
+            const projectPath = ctx.projectPath;
+            const requireProject = () => {
+                if (!projectPath) {
+                    ctx.app.notify('Open a project (cd into it before running codeep) to add or modify MCP servers.');
+                    return false;
+                }
+                return true;
+            };
+            const { addProjectMcpServer, removeProjectMcpServer, loadMcpServerConfig } = await import('../utils/mcpConfig.js');
+            const { registerSessionServers } = await import('../utils/mcpRegistry.js');
+            if (sub === 'add') {
+                if (!requireProject())
+                    break;
+                const name = args[1];
+                const command = args[2];
+                if (!name || !command) {
+                    ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp add <name> <command> [args...]` — e.g. `/mcp add fs npx @modelcontextprotocol/server-filesystem /path`' });
+                    break;
+                }
+                const extraArgs = args.slice(3);
+                addProjectMcpServer(projectPath, { name, command, args: extraArgs });
+                ctx.app.notify(`Saved MCP server ${name} to .codeep/mcp_servers.json. Spawning…`);
+                const merged = loadMcpServerConfig(projectPath);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                const ok = registered.filter(t => t.serverName === name);
+                const failed = errors.find(e => e.server === name);
+                ctx.app.addMessage({
+                    role: 'system',
+                    content: failed
+                        ? `Saved \`${name}\` but spawn failed: \`${failed.error}\``
+                        : `Added \`${name}\` (${ok.length} tool${ok.length === 1 ? '' : 's'} available).`,
+                });
+                break;
+            }
+            if (sub === 'remove') {
+                if (!requireProject())
+                    break;
+                const name = args[1];
+                if (!name) {
+                    ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp remove <name>`' });
+                    break;
+                }
+                const removed = removeProjectMcpServer(projectPath, name);
+                if (!removed) {
+                    ctx.app.addMessage({ role: 'system', content: `No project-scoped MCP server named \`${name}\`.` });
+                    break;
+                }
+                const merged = loadMcpServerConfig(projectPath);
+                await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                ctx.app.addMessage({ role: 'system', content: `Removed \`${name}\` from project config and stopped its process.` });
+                break;
+            }
+            if (sub === 'browse') {
+                const { formatMarketplaceList, findMarketplaceEntry, formatMarketplaceEntry, MCP_MARKETPLACE } = await import('../utils/mcpMarketplace.js');
+                const detail = args[1];
+                if (detail) {
+                    const entry = findMarketplaceEntry(detail);
+                    if (!entry) {
+                        ctx.app.addMessage({ role: 'system', content: `Marketplace id not found: \`${detail}\`. Run \`/mcp browse\` for the list.` });
+                    }
+                    else {
+                        const argHints = entry.argHints?.map(h => `<${h.placeholder ?? 'arg'}>`).join(' ') ?? '';
+                        ctx.app.addMessage({ role: 'system', content: formatMarketplaceEntry(entry) + `\n\nInstall with \`/mcp install ${entry.id} ${argHints}\`` });
+                    }
+                    break;
+                }
+                ctx.app.addMessage({ role: 'system', content: formatMarketplaceList() + `\n\nRun \`/mcp browse <id>\` for details or \`/mcp install <id> [args]\` to install. Total: ${MCP_MARKETPLACE.length}.` });
+                break;
+            }
+            if (sub === 'install') {
+                if (!requireProject())
+                    break;
+                const id = args[1];
+                if (!id) {
+                    ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp install <id> [extra args...]` — run `/mcp browse` to see ids.' });
+                    break;
+                }
+                const { findMarketplaceEntry } = await import('../utils/mcpMarketplace.js');
+                const entry = findMarketplaceEntry(id);
+                if (!entry) {
+                    ctx.app.addMessage({ role: 'system', content: `Marketplace id not found: \`${id}\`. Run \`/mcp browse\` for the list.` });
+                    break;
+                }
+                const extraArgs = args.slice(2);
+                const fullArgs = [...(entry.server.args ?? []), ...extraArgs];
+                addProjectMcpServer(projectPath, {
+                    name: entry.id,
+                    command: entry.server.command,
+                    args: fullArgs,
+                    env: entry.server.env,
+                    url: entry.server.url,
+                    headers: entry.server.headers,
+                });
+                ctx.app.notify(`Saved ${entry.id} to project config. Spawning…`);
+                const merged = loadMcpServerConfig(projectPath);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                const failed = errors.find(e => e.server === entry.id);
+                const lines = [];
+                if (failed) {
+                    lines.push(`Saved \`${entry.id}\` but spawn failed: \`${failed.error}\``);
+                }
+                else {
+                    const ok = registered.filter(t => t.serverName === entry.id);
+                    lines.push(`Installed **${entry.name}** (\`${entry.id}\`) — ${ok.length} tool${ok.length === 1 ? '' : 's'} available.`);
+                }
+                if (entry.envNotes?.length) {
+                    lines.push('', '**Environment variables you may need:**');
+                    for (const e of entry.envNotes) {
+                        const req = e.required ? ' (required)' : '';
+                        lines.push(`- \`${e.name}\`${req} — ${e.description}`);
+                    }
+                }
+                ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                break;
+            }
+            if (sub === 'reload') {
+                if (!requireProject())
+                    break;
+                ctx.app.notify('Reloading MCP server config…');
+                const merged = loadMcpServerConfig(projectPath);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                const lines = [`## MCP reloaded`, '', `**${registered.length}** tool${registered.length === 1 ? '' : 's'} from **${merged.length}** server${merged.length === 1 ? '' : 's'}.`];
+                if (errors.length > 0) {
+                    lines.push('', '### Failed servers');
+                    for (const e of errors)
+                        lines.push(`- **${e.server}** — \`${e.error}\``);
+                }
+                ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                break;
+            }
+            if (sub === 'resources') {
+                const { getSessionResources, awaitSessionReady } = await import('../utils/mcpRegistry.js');
+                await awaitSessionReady(TUI_SESSION);
+                const groups = await getSessionResources(TUI_SESSION);
+                if (groups.length === 0) {
+                    ctx.app.addMessage({ role: 'system', content: '_No MCP server in this session exposes resources._' });
+                    break;
+                }
+                const lines = ['## MCP resources', ''];
+                for (const g of groups) {
+                    lines.push(`**${g.serverName}** — ${g.resources.length} resource${g.resources.length === 1 ? '' : 's'}`);
+                    for (const r of g.resources) {
+                        const label = r.name ? `${r.name} — ` : '';
+                        const mime = r.mimeType ? ` (${r.mimeType})` : '';
+                        lines.push(`- ${label}\`${r.uri}\`${mime}${r.description ? ` — ${r.description}` : ''}`);
+                    }
+                    lines.push('');
+                }
+                lines.push('Read one with `/mcp read <uri>`.');
+                ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                break;
+            }
+            if (sub === 'read') {
+                const uri = args[1];
+                if (!uri) {
+                    ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp read <uri>` — run `/mcp resources` to see available URIs.' });
+                    break;
+                }
+                const { readSessionResource } = await import('../utils/mcpRegistry.js');
+                try {
+                    const contents = await readSessionResource(TUI_SESSION, uri);
+                    if (contents.length === 0) {
+                        ctx.app.addMessage({ role: 'system', content: `_No content returned for \`${uri}\`._` });
+                        break;
+                    }
+                    const lines = [`## Resource: \`${uri}\``, ''];
+                    for (const c of contents) {
+                        if (c.text !== undefined) {
+                            const fence = c.mimeType?.includes('json') ? 'json' : c.mimeType?.includes('markdown') ? 'markdown' : '';
+                            lines.push('```' + fence);
+                            lines.push(c.text);
+                            lines.push('```');
+                        }
+                        else if (c.blob) {
+                            lines.push(`_(${c.mimeType ?? 'binary'} blob, ${c.blob.length} base64 chars — not rendered)_`);
+                        }
+                    }
+                    ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                }
+                catch (err) {
+                    ctx.app.addMessage({ role: 'system', content: `Failed to read \`${uri}\`: ${err.message}` });
+                }
+                break;
+            }
+            if (sub === 'prompts') {
+                const { getSessionPrompts, awaitSessionReady } = await import('../utils/mcpRegistry.js');
+                await awaitSessionReady(TUI_SESSION);
+                const groups = await getSessionPrompts(TUI_SESSION);
+                if (groups.length === 0) {
+                    ctx.app.addMessage({ role: 'system', content: '_No MCP server in this session exposes prompt templates._' });
+                    break;
+                }
+                const lines = ['## MCP prompt templates', ''];
+                for (const g of groups) {
+                    lines.push(`**${g.serverName}** — ${g.prompts.length} prompt${g.prompts.length === 1 ? '' : 's'}`);
+                    for (const p of g.prompts) {
+                        const argList = p.arguments?.length
+                            ? ` (${p.arguments.map(a => a.required ? a.name : `[${a.name}]`).join(', ')})`
+                            : '';
+                        lines.push(`- \`${p.name}\`${argList}${p.description ? ` — ${p.description}` : ''}`);
+                    }
+                    lines.push('');
+                }
+                lines.push('Materialise one with `/mcp prompt <server> <name> [key=value...]`.');
+                ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                break;
+            }
+            if (sub === 'prompt') {
+                const serverName = args[1];
+                const name = args[2];
+                if (!serverName || !name) {
+                    ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp prompt <server> <name> [key=value ...]`' });
+                    break;
+                }
+                const promptArgs = {};
+                for (const tok of args.slice(3)) {
+                    const eq = tok.indexOf('=');
+                    if (eq > 0)
+                        promptArgs[tok.slice(0, eq)] = tok.slice(eq + 1);
+                }
+                const { getSessionPrompt } = await import('../utils/mcpRegistry.js');
+                try {
+                    const { description, messages } = await getSessionPrompt(TUI_SESSION, serverName, name, promptArgs);
+                    const lines = [`## Prompt \`${serverName}/${name}\``];
+                    if (description)
+                        lines.push(`_${description}_`);
+                    lines.push('');
+                    for (const m of messages) {
+                        const text = typeof m.content?.text === 'string' ? m.content.text : JSON.stringify(m.content);
+                        lines.push(`**${m.role}:** ${text}`);
+                        lines.push('');
+                    }
+                    ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                }
+                catch (err) {
+                    ctx.app.addMessage({ role: 'system', content: `Failed to materialise prompt: ${err.message}` });
+                }
+                break;
+            }
+            // Default: list servers + tools for the current session.
+            const { getSessionTools, getSessionRegistrationErrors, awaitSessionReady } = await import('../utils/mcpRegistry.js');
+            await awaitSessionReady(TUI_SESSION);
+            const tools = await getSessionTools(TUI_SESSION);
+            const mcpErrors = getSessionRegistrationErrors(TUI_SESSION);
+            if (tools.length === 0 && mcpErrors.length === 0) {
+                ctx.app.addMessage({
+                    role: 'system',
+                    content: [
+                        '_No MCP servers connected to this session._',
+                        '',
+                        'Add one with `/mcp add <name> <command> [args...]` — it persists to `.codeep/mcp_servers.json`.',
+                        'Or browse the marketplace with `/mcp browse` and install with `/mcp install <id>`.',
+                    ].join('\n'),
+                });
+                break;
+            }
+            const lines = ['## MCP servers', ''];
+            if (tools.length > 0) {
+                const byServer = new Map();
+                for (const t of tools) {
+                    if (!byServer.has(t.serverName))
+                        byServer.set(t.serverName, []);
+                    byServer.get(t.serverName).push(t);
+                }
+                for (const [serverName, serverTools] of byServer) {
+                    lines.push(`**${serverName}** — ${serverTools.length} tool${serverTools.length === 1 ? '' : 's'}`);
+                    for (const t of serverTools) {
+                        const desc = t.description ? ` — ${t.description}` : '';
+                        lines.push(`- \`${t.agentName}\`${desc}`);
+                    }
+                    lines.push('');
+                }
+            }
+            if (mcpErrors.length > 0) {
+                lines.push('### Failed servers');
+                for (const e of mcpErrors)
+                    lines.push(`- **${e.server}** — \`${e.error}\``);
+            }
+            ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+            break;
+        }
         default: {
             // 1. Try custom user command (project + global Markdown templates).
             const { findCustomCommand, expandCommand } = await import('../utils/customCommands.js');

package/dist/renderer/components/Help.js

@@ -29,6 +29,16 @@ export const helpCategories = [
             { key: '/rename <name>', description: 'Rename current session' },
             { key: '/search <term>', description: 'Search chat history' },
             { key: '/export [md|json|txt]', description: 'Export chat' },
+            { key: '/compact [keepN]', description: 'AI-summarize older messages to free up context (keeps last N)' },
+        ],
+    },
+    {
+        title: 'Checkpoints (2.0)',
+        items: [
+            { key: '/checkpoint [name]', description: 'Snapshot conversation + provider/model + git HEAD' },
+            { key: '/checkpoints', description: 'List saved checkpoints in this workspace' },
+            { key: '/rewind <id>', description: 'Restore conversation from a checkpoint' },
+            { key: '/checkpoint delete <id>', description: 'Delete a saved checkpoint' },
         ],
     },
     {
@@ -110,6 +120,24 @@ export const helpCategories = [
             { key: '/logout', description: 'Logout from provider' },
             { key: '/profile save <name>', description: 'Save current provider+model as profile' },
             { key: '/profile list', description: 'List saved profiles' },
+            { key: '/openrouter', description: 'OpenRouter routing prefs (prefer/ignore providers, fallbacks, privacy)' },
+        ],
+    },
+    {
+        title: 'Extensions & MCP (2.0)',
+        items: [
+            { key: '/mcp', description: 'List connected MCP servers + their tools' },
+            { key: '/mcp browse [id]', description: 'Browse marketplace (12 servers) or show one' },
+            { key: '/mcp install <id> [args]', description: 'Install a marketplace server into this project' },
+            { key: '/mcp add <name> <cmd>', description: 'Add a custom MCP server (npx, binary, etc.)' },
+            { key: '/mcp remove <name>', description: 'Remove a project-scoped MCP server' },
+            { key: '/mcp reload', description: 'Re-read .codeep/mcp_servers.json (after manual edit)' },
+            { key: '/mcp resources', description: 'List resources exposed by connected servers' },
+            { key: '/mcp read <uri>', description: 'Read one MCP resource' },
+            { key: '/mcp prompts', description: 'List prompt templates exposed by servers' },
+            { key: '/mcp prompt <server> <name>', description: 'Materialize a prompt with arguments (key=value)' },
+            { key: '/hooks', description: 'List installed lifecycle hooks (.codeep/hooks/<event>.sh)' },
+            { key: '/commands', description: 'List custom slash commands (.codeep/commands/*.md)' },
         ],
     },
     {

package/dist/utils/skillBundlesCloud.d.ts

@@ -24,10 +24,13 @@ export interface RemoteSkill {
     updated_at: string;
 }
 /**
- * Publish a project-scoped skill bundle to codeep.dev.
- * The bundle MUST exist under `<workspaceRoot>/.codeep/skills/<slug>/SKILL.md`
- * — global skills aren't publishable from this helper (intentional: users
- * publish work from a project they're owning, not from their global hoard).
+ * Publish a skill bundle to codeep.dev. The bundle may be project-scoped
+ * (`<workspaceRoot>/.codeep/skills/<slug>/SKILL.md`) or global
+ * (`~/.codeep/skills/<slug>/SKILL.md`) — either is publishable. The
+ * `--public` flag (translated into `opts.isPublic`) is the user's
+ * explicit consent gate; we don't gate further on bundle scope. If both
+ * exist with the same slug, the project copy wins (mirrors the rest of
+ * the bundle-loading flow).
  */
 export declare function publishBundle(workspaceRoot: string, slug: string, opts?: {
     isPublic?: boolean;

package/dist/utils/skillBundlesCloud.js

@@ -17,18 +17,24 @@ import { getSyncToken } from '../config/index.js';
 import { findSkillBundle } from './skillBundles.js';
 const API_BASE = 'https://codeep.dev';
 /**
- * Publish a project-scoped skill bundle to codeep.dev.
- * The bundle MUST exist under `<workspaceRoot>/.codeep/skills/<slug>/SKILL.md`
- * — global skills aren't publishable from this helper (intentional: users
- * publish work from a project they're owning, not from their global hoard).
+ * Publish a skill bundle to codeep.dev. The bundle may be project-scoped
+ * (`<workspaceRoot>/.codeep/skills/<slug>/SKILL.md`) or global
+ * (`~/.codeep/skills/<slug>/SKILL.md`) — either is publishable. The
+ * `--public` flag (translated into `opts.isPublic`) is the user's
+ * explicit consent gate; we don't gate further on bundle scope. If both
+ * exist with the same slug, the project copy wins (mirrors the rest of
+ * the bundle-loading flow).
  */
 export async function publishBundle(workspaceRoot, slug, opts = {}) {
     const token = getSyncToken();
     if (!token)
         return { ok: false, error: 'Not linked to codeep.dev — run `codeep account` first.' };
     const bundle = findSkillBundle(slug, workspaceRoot);
-    if (!bundle || bundle.scope !== 'project') {
-        return { ok: false, error: `Skill bundle "${slug}" not found in this project. Run \`/skills create-bundle ${slug}\` first.` };
+    if (!bundle) {
+        return {
+            ok: false,
+            error: `Skill bundle "${slug}" not found in either \`.codeep/skills/${slug}/\` (project) or \`~/.codeep/skills/${slug}/\` (global). Run \`/skills create-bundle ${slug}\` to scaffold one, or check \`/skills bundles\` to see what's available.`,
+        };
     }
     // Build the SKILL.md text we'll publish. We re-serialise from the loaded
     // bundle rather than reading the file again — that way frontmatter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",