codeep 1.2.27 → 1.2.29

package/dist/acp/commands.d.ts

@@ -1,10 +1,25 @@
+import { Message } from '../config/index.js';
+export interface AcpSession {
+    sessionId: string;
+    workspaceRoot: string;
+    /** In-memory message history for the ACP conversation */
+    history: Message[];
+    /** Codeep session name (maps to .codeep/sessions/<name>.json) */
+    codeepSessionId: string;
+}
 export interface CommandResult {
     handled: boolean;
     response: string;
 }
 /**
- * Try to handle a slash command. Returns { handled: true, response } if the
- * input was a command, or { handled: false, response: '' } to let it pass
- * through to the agent loop.
+ * Ensure workspace has a .codeep folder, initialise it as a project if needed,
+ * and load the most recent session (or start a new one).
+ *
+ * Returns the welcome message to stream back to the client.
  */
-export declare function handleCommand(input: string): CommandResult;
+export declare function initWorkspace(workspaceRoot: string): {
+    codeepSessionId: string;
+    history: Message[];
+    welcomeText: string;
+};
+export declare function handleCommand(input: string, session: AcpSession): CommandResult;

package/dist/acp/commands.js

@@ -1,43 +1,157 @@
-// src/acp/commands.ts
+// acp/commands.ts
 // Slash command handler for ACP sessions.
-// Commands are intercepted before the agent loop and handled directly.
-import { config, setProvider, getModelsForCurrentProvider, setApiKey, getMaskedApiKey } from '../config/index.js';
-import { PROVIDERS } from '../config/providers.js';
+// Mirrors CLI commands from renderer/commands.ts but returns plain text
+// responses (no TUI) suitable for streaming back via session/update.
+import { config, getCurrentProvider, getModelsForCurrentProvider, setProvider, setApiKey, isConfigured, listSessionsWithInfo, startNewSession, loadSession, saveSession, initializeAsProject, isManuallyInitializedProject, setProjectPermission, hasWritePermission, hasReadPermission, } from '../config/index.js';
+import { getProviderList, getProvider } from '../config/providers.js';
+import { getProjectContext } from '../utils/project.js';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+// ─── Workspace / session init (called on session/new) ─────────────────────────
 /**
- * Try to handle a slash command. Returns { handled: true, response } if the
- * input was a command, or { handled: false, response: '' } to let it pass
- * through to the agent loop.
+ * Ensure workspace has a .codeep folder, initialise it as a project if needed,
+ * and load the most recent session (or start a new one).
+ *
+ * Returns the welcome message to stream back to the client.
  */
-export function handleCommand(input) {
+export function initWorkspace(workspaceRoot) {
+    // 1. Ensure .codeep directory exists
+    const codeepDir = join(workspaceRoot, '.codeep');
+    if (!existsSync(codeepDir)) {
+        mkdirSync(codeepDir, { recursive: true });
+    }
+    // 2. Auto-initialize as project if not already (workspace root is always a project in ACP context)
+    if (!isManuallyInitializedProject(workspaceRoot)) {
+        initializeAsProject(workspaceRoot);
+    }
+    // 3. Grant read+write permission for this workspace (ACP always has access)
+    if (!hasReadPermission(workspaceRoot)) {
+        setProjectPermission(workspaceRoot, true, true);
+    }
+    // 4. Load most recent session, or start fresh
+    const sessions = listSessionsWithInfo(workspaceRoot);
+    let codeepSessionId;
+    let history = [];
+    if (sessions.length > 0) {
+        const latest = sessions[0]; // already sorted newest-first
+        const loaded = loadSession(latest.name, workspaceRoot);
+        if (loaded) {
+            codeepSessionId = latest.name;
+            history = loaded;
+        }
+        else {
+            codeepSessionId = startNewSession();
+        }
+    }
+    else {
+        codeepSessionId = startNewSession();
+    }
+    // 5. Build welcome text
+    const provider = getCurrentProvider();
+    const model = config.get('model');
+    const projectCtx = getProjectContext(workspaceRoot);
+    const hasWrite = hasWritePermission(workspaceRoot);
+    const lines = [
+        `**Codeep** • ${provider.name} • \`${model}\``,
+        '',
+        `**Workspace:** ${workspaceRoot}`,
+        projectCtx
+            ? `**Project:** ${projectCtx.name} (${projectCtx.type})`
+            : '**Project:** detected',
+        hasWrite ? '**Access:** Read & Write' : '**Access:** Read only',
+        '',
+        sessions.length > 0
+            ? `**Session:** ${codeepSessionId} (${history.length} messages restored)`
+            : '**Session:** new',
+        '',
+        'Type `/help` to see available commands.',
+    ];
+    return { codeepSessionId, history, welcomeText: lines.join('\n') };
+}
+// ─── Command dispatch ─────────────────────────────────────────────────────────
+export function handleCommand(input, session) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/'))
         return { handled: false, response: '' };
-    const [cmd, ...args] = trimmed.slice(1).split(/\s+/);
-    switch (cmd.toLowerCase()) {
+    const [rawCmd, ...args] = trimmed.slice(1).split(/\s+/);
+    const cmd = rawCmd.toLowerCase();
+    switch (cmd) {
         case 'help':
             return { handled: true, response: buildHelp() };
-        case 'settings':
-            return { handled: true, response: buildSettings() };
+        case 'status':
+            return { handled: true, response: buildStatus(session) };
+        case 'version': {
+            const provider = getCurrentProvider();
+            const model = config.get('model');
+            return { handled: true, response: `Codeep • ${provider.name} • \`${model}\`` };
+        }
         case 'provider': {
-            const id = args[0];
-            if (!id)
+            if (!args.length)
                 return { handled: true, response: buildProviderList() };
-            return { handled: true, response: setProviderCmd(id) };
+            return { handled: true, response: setProviderCmd(args[0]) };
         }
         case 'model': {
-            const id = args[0];
-            if (!id)
+            if (!args.length)
                 return { handled: true, response: buildModelList() };
-            return { handled: true, response: setModelCmd(id) };
+            return { handled: true, response: setModelCmd(args[0]) };
         }
         case 'apikey': {
-            const key = args[0];
-            if (!key)
+            if (!args.length)
                 return { handled: true, response: showApiKey() };
-            return { handled: true, response: setApiKeyCmd(key) };
+            return { handled: true, response: setApiKeyCmd(args[0]) };
+        }
+        case 'login': {
+            // In ACP context login = set API key for a provider
+            // Usage: /login <providerId> <apiKey>
+            const [providerId, apiKey] = args;
+            if (!providerId || !apiKey) {
+                return { handled: true, response: 'Usage: `/login <providerId> <apiKey>`\n\n' + buildProviderList() };
+            }
+            return { handled: true, response: loginCmd(providerId, apiKey) };
+        }
+        case 'sessions': {
+            return { handled: true, response: buildSessionList(session.workspaceRoot) };
+        }
+        case 'session': {
+            const sub = args[0];
+            if (sub === 'new') {
+                const id = startNewSession();
+                session.codeepSessionId = id;
+                session.history = [];
+                return { handled: true, response: `New session started: \`${id}\`` };
+            }
+            if (sub === 'load' && args[1]) {
+                const loaded = loadSession(args[1], session.workspaceRoot);
+                if (loaded) {
+                    session.codeepSessionId = args[1];
+                    session.history = loaded;
+                    return { handled: true, response: `Session loaded: \`${args[1]}\` (${session.history.length} messages)` };
+                }
+                return { handled: true, response: `Session not found: \`${args[1]}\`` };
+            }
+            return { handled: true, response: 'Usage: `/session new` or `/session load <name>`' };
+        }
+        case 'save': {
+            const name = args.length ? args.join('-') : session.codeepSessionId;
+            if (saveSession(name, session.history, session.workspaceRoot)) {
+                session.codeepSessionId = name;
+                return { handled: true, response: `Session saved as: \`${name}\`` };
+            }
+            return { handled: true, response: 'Failed to save session.' };
+        }
+        case 'grant': {
+            setProjectPermission(session.workspaceRoot, true, true);
+            const ctx = getProjectContext(session.workspaceRoot);
+            return { handled: true, response: `Write access granted for \`${ctx?.name || session.workspaceRoot}\`` };
+        }
+        case 'lang': {
+            if (!args.length) {
+                const current = config.get('language') || 'auto';
+                return { handled: true, response: `Current language: \`${current}\`. Usage: \`/lang <code>\` (e.g. \`en\`, \`hr\`, \`auto\`)` };
+            }
+            config.set('language', args[0]);
+            return { handled: true, response: `Language set to \`${args[0]}\`` };
         }
-        case 'status':
-            return { handled: true, response: buildSettings() };
         default:
             return {
                 handled: true,
@@ -45,7 +159,7 @@ export function handleCommand(input) {
             };
     }
 }
-// ─── renderers ────────────────────────────────────────────────────────────────
+// ─── Renderers ────────────────────────────────────────────────────────────────
 function buildHelp() {
     return [
         '## Codeep Commands',
@@ -53,50 +167,58 @@ function buildHelp() {
         '| Command | Description |',
         '|---------|-------------|',
         '| `/help` | Show this help |',
-        '| `/settings` | Show current configuration |',
+        '| `/status` | Show current configuration and session info |',
+        '| `/version` | Show version and current model |',
         '| `/provider` | List available providers |',
-        '| `/provider <id>` | Switch to a provider (e.g. `/provider anthropic`) |',
+        '| `/provider <id>` | Switch provider (e.g. `/provider anthropic`) |',
         '| `/model` | List models for current provider |',
         '| `/model <id>` | Switch model (e.g. `/model claude-opus-4-5`) |',
+        '| `/login <providerId> <apiKey>` | Set API key for a provider |',
+        '| `/apikey` | Show masked API key for current provider |',
         '| `/apikey <key>` | Set API key for current provider |',
-        '| `/apikey` | Show masked API key |',
-        '| `/status` | Same as /settings |',
+        '| `/sessions` | List saved sessions |',
+        '| `/session new` | Start a new session |',
+        '| `/session load <name>` | Load a saved session |',
+        '| `/save [name]` | Save current session |',
+        '| `/grant` | Grant write access for current workspace |',
+        '| `/lang <code>` | Set response language (e.g. `en`, `hr`, `auto`) |',
     ].join('\n');
 }
-function buildSettings() {
-    const provider = config.get('provider');
+function buildStatus(session) {
+    const provider = getCurrentProvider();
     const model = config.get('model');
-    const protocol = config.get('protocol');
-    const maskedKey = getMaskedApiKey(provider);
-    const providerConfig = PROVIDERS[provider];
+    const lang = config.get('language') || 'auto';
+    const hasWrite = hasWritePermission(session.workspaceRoot);
+    const configured = isConfigured();
     return [
-        '## Current Configuration',
+        '## Current Status',
         '',
-        `- **Provider:** ${providerConfig?.name ?? provider} (\`${provider}\`)`,
+        `- **Provider:** ${provider.name} (\`${provider.id}\`)`,
         `- **Model:** \`${model}\``,
-        `- **Protocol:** \`${protocol}\``,
-        `- **API Key:** ${maskedKey ? `\`${maskedKey}\`` : '_not set_'}`,
-        '',
-        'Use `/provider`, `/model`, or `/apikey` to change settings.',
+        `- **API Key:** ${configured ? 'configured' : '_not set_ — use `/login` or `/apikey`_'}`,
+        `- **Language:** \`${lang}\``,
+        `- **Workspace:** \`${session.workspaceRoot}\``,
+        `- **Access:** ${hasWrite ? 'Read & Write' : 'Read only'}`,
+        `- **Session:** \`${session.codeepSessionId}\` (${session.history.length} messages)`,
     ].join('\n');
 }
 function buildProviderList() {
-    const current = config.get('provider');
+    const current = getCurrentProvider();
+    const providers = getProviderList();
     const lines = ['## Available Providers', ''];
-    for (const [id, p] of Object.entries(PROVIDERS)) {
-        const marker = id === current ? ' ✓' : '';
-        lines.push(`- \`${id}\`${marker} — **${p.name}**: ${p.description}`);
+    for (const p of providers) {
+        const marker = p.id === current.id ? ' ✓' : '';
+        lines.push(`- \`${p.id}\`${marker} — **${p.name}**: ${p.description || ''}`);
     }
     lines.push('', 'Use `/provider <id>` to switch.');
     return lines.join('\n');
 }
 function setProviderCmd(id) {
-    if (!PROVIDERS[id]) {
+    const provider = getProvider(id);
+    if (!provider)
         return `Provider \`${id}\` not found.\n\n${buildProviderList()}`;
-    }
     setProvider(id);
-    const p = PROVIDERS[id];
-    return `Switched to **${p.name}** (\`${id}\`). Default model: \`${p.defaultModel}\`.`;
+    return `Switched to **${provider.name}** (\`${id}\`). Default model: \`${provider.defaultModel}\`.`;
 }
 function buildModelList() {
     const current = config.get('model');
@@ -111,21 +233,40 @@ function buildModelList() {
 }
 function setModelCmd(id) {
     const models = getModelsForCurrentProvider();
-    if (!models[id]) {
-        return `Model \`${id}\` not available for current provider.\n\n${buildModelList()}`;
-    }
+    if (!models[id])
+        return `Model \`${id}\` not available.\n\n${buildModelList()}`;
     config.set('model', id);
     return `Model set to \`${id}\`.`;
 }
 function showApiKey() {
-    const provider = config.get('provider');
-    const masked = getMaskedApiKey(provider);
-    return masked
-        ? `API key for \`${provider}\`: \`${masked}\``
-        : `No API key set for \`${provider}\`. Use \`/apikey <key>\` to set one.`;
+    const providerId = getCurrentProvider().id;
+    const configured = isConfigured(providerId);
+    return configured
+        ? `API key for \`${providerId}\`: configured (use \`/apikey <key>\` to update)`
+        : `No API key set for \`${providerId}\`. Use \`/apikey <key>\` to set one.`;
 }
 function setApiKeyCmd(key) {
-    const provider = config.get('provider');
-    setApiKey(key, provider);
-    return `API key for \`${provider}\` saved.`;
+    const providerId = getCurrentProvider().id;
+    // setApiKey is async (keychain) — fire-and-forget, config cache updated synchronously
+    setApiKey(key, providerId);
+    return `API key for \`${providerId}\` saved.`;
+}
+function loginCmd(providerId, apiKey) {
+    const provider = getProvider(providerId);
+    if (!provider)
+        return `Provider \`${providerId}\` not found.\n\n${buildProviderList()}`;
+    setProvider(providerId);
+    setApiKey(apiKey, providerId);
+    return `Logged in as **${provider.name}** (\`${providerId}\`). Model: \`${provider.defaultModel}\`.`;
+}
+function buildSessionList(workspaceRoot) {
+    const sessions = listSessionsWithInfo(workspaceRoot);
+    if (sessions.length === 0)
+        return 'No saved sessions. Start chatting to create one.';
+    const lines = ['## Saved Sessions', ''];
+    for (const s of sessions) {
+        lines.push(`- \`${s.name}\` — ${s.messageCount} messages — ${new Date(s.createdAt).toLocaleString()}`);
+    }
+    lines.push('', 'Use `/session load <name>` to restore.');
+    return lines.join('\n');
 }

package/dist/acp/server.js

@@ -3,9 +3,11 @@
 import { randomUUID } from 'crypto';
 import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
+import { initWorkspace, handleCommand } from './commands.js';
+import { autoSaveSession } from '../config/index.js';
 export function startAcpServer() {
     const transport = new StdioTransport();
-    // sessionId → { workspaceRoot, abortController }
+    // ACP sessionId → full AcpSession (includes history + codeep session tracking)
     const sessions = new Map();
     transport.start((msg) => {
         switch (msg.method) {
@@ -46,9 +48,46 @@ export function startAcpServer() {
     }
     function handleSessionNew(msg) {
         const params = msg.params;
-        const sessionId = randomUUID();
-        sessions.set(sessionId, { workspaceRoot: params.cwd, abortController: null });
-        transport.respond(msg.id, { sessionId });
+        const acpSessionId = randomUUID();
+        // Initialise workspace: create .codeep folder, load/create codeep session
+        const { codeepSessionId, history, welcomeText } = initWorkspace(params.cwd);
+        sessions.set(acpSessionId, {
+            sessionId: acpSessionId,
+            workspaceRoot: params.cwd,
+            history,
+            codeepSessionId,
+            abortController: null,
+        });
+        transport.respond(msg.id, { sessionId: acpSessionId });
+        // Advertise available slash commands to Zed
+        transport.notify('session/update', {
+            sessionId: acpSessionId,
+            update: {
+                sessionUpdate: 'available_commands_update',
+                availableCommands: [
+                    { name: 'help', description: 'Show available commands' },
+                    { name: 'status', description: 'Show current configuration and session info' },
+                    { name: 'version', description: 'Show version and current model' },
+                    { name: 'provider', description: 'List or switch AI provider', input: { hint: '<provider-id>' } },
+                    { name: 'model', description: 'List or switch model', input: { hint: '<model-id>' } },
+                    { name: 'login', description: 'Set API key for a provider', input: { hint: '<providerId> <apiKey>' } },
+                    { name: 'apikey', description: 'Show or set API key for current provider', input: { hint: '<key>' } },
+                    { name: 'sessions', description: 'List saved sessions' },
+                    { name: 'session', description: 'Manage sessions: new or load', input: { hint: 'new | load <name>' } },
+                    { name: 'save', description: 'Save current session', input: { hint: '[name]' } },
+                    { name: 'grant', description: 'Grant write access for current workspace' },
+                    { name: 'lang', description: 'Set response language', input: { hint: '<code> (e.g. en, hr, auto)' } },
+                ],
+            },
+        });
+        // Stream welcome message so the client sees it immediately after session/new
+        transport.notify('session/update', {
+            sessionId: acpSessionId,
+            update: {
+                sessionUpdate: 'agent_message_chunk',
+                content: { type: 'text', text: welcomeText },
+            },
+        });
     }
     function handleSessionPrompt(msg) {
         const params = msg.params;
@@ -62,6 +101,19 @@ export function startAcpServer() {
             .filter((b) => b.type === 'text')
             .map((b) => b.text)
             .join('\n');
+        // Handle slash commands — no agent loop needed
+        const cmd = handleCommand(prompt, session);
+        if (cmd.handled) {
+            transport.notify('session/update', {
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: 'agent_message_chunk',
+                    content: { type: 'text', text: cmd.response },
+                },
+            });
+            transport.respond(msg.id, { stopReason: 'end_turn' });
+            return;
+        }
         const abortController = new AbortController();
         session.abortController = abortController;
         runAgentSession({
@@ -82,6 +134,9 @@ export function startAcpServer() {
                 // file edits are streamed via onChunk for now
             },
         }).then(() => {
+            // Persist conversation history after each agent turn
+            session.history.push({ role: 'user', content: prompt });
+            autoSaveSession(session.history, session.workspaceRoot);
             transport.respond(msg.id, { stopReason: 'end_turn' });
         }).catch((err) => {
             if (err.name === 'AbortError') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.27",
+  "version": "1.2.29",
   "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",