codeep 1.2.29 → 1.2.31

package/dist/acp/commands.d.ts

@@ -6,10 +6,19 @@ export interface AcpSession {
     history: Message[];
     /** Codeep session name (maps to .codeep/sessions/<name>.json) */
     codeepSessionId: string;
+    /** Files added to context via /add */
+    addedFiles: Map<string, {
+        relativePath: string;
+        content: string;
+    }>;
 }
 export interface CommandResult {
+    /** true if the input was a slash command (even if it failed) */
     handled: boolean;
+    /** Markdown text to stream back to the client */
     response: string;
+    /** If true, server should stream response chunks as they arrive (skills) */
+    streaming?: boolean;
 }
 /**
  * Ensure workspace has a .codeep folder, initialise it as a project if needed,
@@ -22,4 +31,11 @@ export declare function initWorkspace(workspaceRoot: string): {
     history: Message[];
     welcomeText: string;
 };
-export declare function handleCommand(input: string, session: AcpSession): CommandResult;
+/**
+ * Try to handle a slash command. Async because skills and diff/review
+ * need to call the AI API or run shell commands.
+ *
+ * onChunk is called for streaming output (skills). For simple commands
+ * the full response is returned in CommandResult.response.
+ */
+export declare function handleCommand(input: string, session: AcpSession, onChunk: (text: string) => void, abortSignal?: AbortSignal): Promise<CommandResult>;

package/dist/acp/commands.js

@@ -7,6 +7,8 @@ import { getProviderList, getProvider } from '../config/providers.js';
 import { getProjectContext } from '../utils/project.js';
 import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
+import { chat } from '../api/index.js';
+import { runAgent } from '../utils/agent.js';
 // ─── Workspace / session init (called on session/new) ─────────────────────────
 /**
  * Ensure workspace has a .codeep folder, initialise it as a project if needed,
@@ -66,10 +68,21 @@ export function initWorkspace(workspaceRoot) {
         '',
         'Type `/help` to see available commands.',
     ];
+    if (history.length > 0) {
+        lines.push('', '---', '');
+        lines.push(...formatSessionPreviewLines(history));
+    }
     return { codeepSessionId, history, welcomeText: lines.join('\n') };
 }
 // ─── Command dispatch ─────────────────────────────────────────────────────────
-export function handleCommand(input, session) {
+/**
+ * Try to handle a slash command. Async because skills and diff/review
+ * need to call the AI API or run shell commands.
+ *
+ * onChunk is called for streaming output (skills). For simple commands
+ * the full response is returned in CommandResult.response.
+ */
+export async function handleCommand(input, session, onChunk, abortSignal) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/'))
         return { handled: false, response: '' };
@@ -101,19 +114,17 @@ export function handleCommand(input, session) {
             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 'sessions':
         case 'session': {
             const sub = args[0];
+            if (!sub)
+                return { handled: true, response: buildSessionList(session.workspaceRoot) };
             if (sub === 'new') {
                 const id = startNewSession();
                 session.codeepSessionId = id;
@@ -125,11 +136,11 @@ export function handleCommand(input, session) {
                 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: formatSessionPreview(args[1], session.history) };
                 }
                 return { handled: true, response: `Session not found: \`${args[1]}\`` };
             }
-            return { handled: true, response: 'Usage: `/session new` or `/session load <name>`' };
+            return { handled: true, response: 'Usage: `/session` · `/session new` · `/session load <name>`' };
         }
         case 'save': {
             const name = args.length ? args.join('-') : session.codeepSessionId;
@@ -152,11 +163,241 @@ export function handleCommand(input, session) {
             config.set('language', args[0]);
             return { handled: true, response: `Language set to \`${args[0]}\`` };
         }
-        default:
-            return {
-                handled: true,
-                response: `Unknown command: \`/${cmd}\`\n\nType \`/help\` to see available commands.`,
+        // ─── File context ──────────────────────────────────────────────────────────
+        case 'add': {
+            if (!args.length) {
+                if (session.addedFiles.size === 0)
+                    return { handled: true, response: 'No files in context. Usage: `/add <file> [file2...]`' };
+                const list = [...session.addedFiles.values()].map(f => `- \`${f.relativePath}\``).join('\n');
+                return { handled: true, response: `**Files in context (${session.addedFiles.size}):**\n${list}` };
+            }
+            const { promises: fs } = await import('fs');
+            const pathMod = await import('path');
+            const root = session.workspaceRoot;
+            const added = [];
+            const errors = [];
+            for (const filePath of args) {
+                const fullPath = pathMod.isAbsolute(filePath) ? filePath : pathMod.join(root, filePath);
+                const relativePath = pathMod.relative(root, fullPath);
+                try {
+                    const stat = await fs.stat(fullPath);
+                    if (!stat.isFile()) {
+                        errors.push(`\`${filePath}\`: not a file`);
+                        continue;
+                    }
+                    if (stat.size > 100_000) {
+                        errors.push(`\`${filePath}\`: too large (max 100KB)`);
+                        continue;
+                    }
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    session.addedFiles.set(fullPath, { relativePath, content });
+                    added.push(`\`${relativePath}\``);
+                }
+                catch {
+                    errors.push(`\`${filePath}\`: not found`);
+                }
+            }
+            const parts = [];
+            if (added.length)
+                parts.push(`Added to context: ${added.join(', ')}`);
+            if (errors.length)
+                parts.push(`Errors: ${errors.join(', ')}`);
+            return { handled: true, response: parts.join('\n') };
+        }
+        case 'drop': {
+            if (!args.length) {
+                const count = session.addedFiles.size;
+                session.addedFiles.clear();
+                return { handled: true, response: count ? `Dropped all ${count} file(s) from context.` : 'No files in context.' };
+            }
+            const pathMod = await import('path');
+            const root = session.workspaceRoot;
+            let dropped = 0;
+            for (const filePath of args) {
+                const fullPath = pathMod.isAbsolute(filePath) ? filePath : pathMod.join(root, filePath);
+                if (session.addedFiles.delete(fullPath))
+                    dropped++;
+            }
+            return { handled: true, response: dropped ? `Dropped ${dropped} file(s). ${session.addedFiles.size} remaining.` : 'File not found in context.' };
+        }
+        // ─── Undo ──────────────────────────────────────────────────────────────────
+        case 'undo': {
+            const { undoLastAction } = await import('../utils/agent.js');
+            const result = undoLastAction();
+            return { handled: true, response: result.success ? `Undo: ${result.message}` : `Cannot undo: ${result.message}` };
+        }
+        case 'undo-all': {
+            const { undoAllActions } = await import('../utils/agent.js');
+            const result = undoAllActions();
+            return { handled: true, response: result.success ? `Undone ${result.results.length} action(s).` : 'Nothing to undo.' };
+        }
+        case 'skills': {
+            const { getAllSkills, searchSkills, formatSkillsList } = await import('../utils/skills.js');
+            const query = args.join(' ').toLowerCase();
+            const skills = query ? searchSkills(query) : getAllSkills();
+            if (!skills.length)
+                return { handled: true, response: `No skills matching \`${query}\`.` };
+            return { handled: true, response: formatSkillsList(skills) };
+        }
+        case 'scan': {
+            onChunk('_Scanning project…_\n\n');
+            const { scanProject, saveProjectIntelligence, generateContextFromIntelligence } = await import('../utils/projectIntelligence.js');
+            try {
+                const intelligence = await scanProject(session.workspaceRoot);
+                saveProjectIntelligence(session.workspaceRoot, intelligence);
+                const context = generateContextFromIntelligence(intelligence);
+                onChunk(`## Project Scan\n\n${context}`);
+                return { handled: true, response: '', streaming: true };
+            }
+            catch (err) {
+                return { handled: true, response: `Scan failed: ${err.message}` };
+            }
+        }
+        case 'review': {
+            onChunk('_Running code review…_\n\n');
+            const { performCodeReview, formatReviewResult } = await import('../utils/codeReview.js');
+            const projectCtx = getProjectContext(session.workspaceRoot);
+            if (!projectCtx)
+                return { handled: true, response: 'No project context available.' };
+            const reviewFiles = args.length ? args : undefined;
+            const result = performCodeReview(projectCtx, reviewFiles);
+            return { handled: true, response: formatReviewResult(result) };
+        }
+        case 'learn': {
+            onChunk('_Learning from project…_\n\n');
+            const { learnFromProject, formatPreferencesForPrompt } = await import('../utils/learning.js');
+            const { promises: fs } = await import('fs');
+            const pathMod = await import('path');
+            const extensions = ['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs'];
+            const files = [];
+            const walkDir = async (dir, depth = 0) => {
+                if (depth > 3 || files.length >= 20)
+                    return;
+                try {
+                    const entries = await fs.readdir(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                            continue;
+                        const fullPath = pathMod.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            await walkDir(fullPath, depth + 1);
+                        }
+                        else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                            files.push(pathMod.relative(session.workspaceRoot, fullPath));
+                        }
+                        if (files.length >= 20)
+                            break;
+                    }
+                }
+                catch { /* skip unreadable dirs */ }
             };
+            await walkDir(session.workspaceRoot);
+            if (!files.length)
+                return { handled: true, response: 'No source files found to learn from.' };
+            const prefs = learnFromProject(session.workspaceRoot, files);
+            const formatted = formatPreferencesForPrompt(prefs);
+            return { handled: true, response: `## Learned Preferences\n\n${formatted}\n\n_Learned from ${files.length} file(s)._` };
+        }
+        case 'changes': {
+            const { getCurrentSessionActions } = await import('../utils/agent.js');
+            const actions = getCurrentSessionActions();
+            if (!actions.length)
+                return { handled: true, response: 'No changes in current session.' };
+            const lines = ['## Session Changes', '', ...actions.map(a => `- **${a.type}**: \`${a.target}\` — ${a.result}`)];
+            return { handled: true, response: lines.join('\n') };
+        }
+        // ─── Export ────────────────────────────────────────────────────────────────
+        case 'export': {
+            if (!session.history.length)
+                return { handled: true, response: 'No messages to export.' };
+            const format = (args[0] || 'md').toLowerCase();
+            if (format === 'json') {
+                return { handled: true, response: `\`\`\`json\n${JSON.stringify(session.history, null, 2)}\n\`\`\`` };
+            }
+            if (format === 'txt') {
+                const txt = session.history.map(m => `[${m.role.toUpperCase()}]\n${m.content}`).join('\n\n---\n\n');
+                return { handled: true, response: `\`\`\`\n${txt}\n\`\`\`` };
+            }
+            // default: markdown
+            const md = ['# Codeep Session Export', '', ...session.history.map(m => `## ${m.role === 'user' ? 'You' : m.role === 'assistant' ? 'Codeep' : 'System'}\n\n${m.content}`)].join('\n\n---\n\n');
+            return { handled: true, response: md };
+        }
+        // ─── Git diff ──────────────────────────────────────────────────────────────
+        case 'diff': {
+            const { getGitDiff, formatDiffForDisplay } = await import('../utils/git.js');
+            const staged = args.includes('--staged') || args.includes('-s');
+            const result = getGitDiff(staged, session.workspaceRoot);
+            if (!result.success || !result.diff) {
+                return { handled: true, response: result.error || 'No changes found.' };
+            }
+            const preview = formatDiffForDisplay(result.diff, 60);
+            // Ask AI to review
+            onChunk('_Reviewing diff…_\n\n');
+            const projectCtx = getProjectContext(session.workspaceRoot);
+            let reviewText = '';
+            await chat(`Review this git diff and provide concise feedback:\n\n\`\`\`diff\n${preview}\n\`\`\``, session.history, (chunk) => { reviewText += chunk; onChunk(chunk); }, undefined, projectCtx, undefined);
+            return { handled: true, response: '', streaming: true };
+        }
+        // ─── Skills ────────────────────────────────────────────────────────────────
+        default: {
+            const { findSkill, parseSkillArgs, executeSkill, trackSkillUsage } = await import('../utils/skills.js');
+            const skill = findSkill(cmd);
+            if (!skill) {
+                return { handled: true, response: `Unknown command: \`/${cmd}\`\n\nType \`/help\` for available commands or \`/skills\` to list all skills.` };
+            }
+            if (skill.requiresWriteAccess && !hasWritePermission(session.workspaceRoot)) {
+                return { handled: true, response: 'This skill requires write access. Use `/grant` first.' };
+            }
+            const params = parseSkillArgs(args.join(' '), skill);
+            trackSkillUsage(skill.name);
+            onChunk(`_Running skill **${skill.name}**…_\n\n`);
+            const { spawnSync } = await import('child_process');
+            const projectCtx = getProjectContext(session.workspaceRoot);
+            const skillResult = await executeSkill(skill, params, {
+                onCommand: async (shellCmd) => {
+                    const proc = spawnSync(shellCmd, {
+                        cwd: session.workspaceRoot,
+                        encoding: 'utf-8',
+                        timeout: 60_000,
+                        shell: true,
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    const out = ((proc.stdout || '') + (proc.stderr || '')).trim();
+                    const block = `\`${shellCmd}\`\n\`\`\`\n${out || '(no output)'}\n\`\`\`\n`;
+                    onChunk(block);
+                    if ((proc.status ?? 1) !== 0)
+                        throw new Error(out || `Exit code ${proc.status}`);
+                    return out;
+                },
+                onPrompt: async (prompt) => {
+                    let response = '';
+                    await chat(prompt, session.history, (chunk) => { response += chunk; onChunk(chunk); }, undefined, projectCtx, undefined);
+                    return response;
+                },
+                onAgent: async (task) => {
+                    const { buildProjectContext } = await import('./session.js');
+                    const ctx = buildProjectContext(session.workspaceRoot);
+                    let output = '';
+                    const agentResult = await runAgent(task, ctx, {
+                        abortSignal,
+                        onIteration: (_i, msg) => { onChunk(msg + '\n'); },
+                        onThinking: (text) => { onChunk(text); },
+                    });
+                    if (agentResult.finalResponse) {
+                        output = agentResult.finalResponse;
+                        onChunk(output);
+                    }
+                    return output;
+                },
+                // Skills in ACP auto-confirm (no TUI)
+                onConfirm: async (_message) => true,
+                onNotify: (message) => { onChunk(`> ${message}\n`); },
+            });
+            if (!skillResult.success) {
+                return { handled: true, response: `Skill **${skill.name}** failed: ${skillResult.output}`, streaming: true };
+            }
+            return { handled: true, response: '', streaming: true };
+        }
     }
 }
 // ─── Renderers ────────────────────────────────────────────────────────────────
@@ -164,24 +405,44 @@ function buildHelp() {
     return [
         '## Codeep Commands',
         '',
+        '**Configuration**',
         '| Command | Description |',
         '|---------|-------------|',
-        '| `/help` | Show this help |',
-        '| `/status` | Show current configuration and session info |',
+        '| `/status` | Show current config and session info |',
         '| `/version` | Show version and current model |',
-        '| `/provider` | List available providers |',
-        '| `/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 |',
-        '| `/sessions` | List saved sessions |',
-        '| `/session new` | Start a new session |',
-        '| `/session load <name>` | Load a saved session |',
+        '| `/provider [id]` | List or switch provider |',
+        '| `/model [id]` | List or switch model |',
+        '| `/login <provider> <key>` | Set API key for a provider |',
+        '| `/apikey [key]` | Show or set API key |',
+        '| `/lang [code]` | Set response language (`en`, `hr`, `auto`…) |',
+        '| `/grant` | Grant write access for workspace |',
+        '',
+        '**Sessions**',
+        '| Command | Description |',
+        '|---------|-------------|',
+        '| `/session` | List saved sessions |',
+        '| `/session new` | Start new session |',
+        '| `/session load <name>` | Load a session |',
         '| `/save [name]` | Save current session |',
-        '| `/grant` | Grant write access for current workspace |',
-        '| `/lang <code>` | Set response language (e.g. `en`, `hr`, `auto`) |',
+        '',
+        '**Context & Files**',
+        '| Command | Description |',
+        '|---------|-------------|',
+        '| `/add <file...>` | Add files to agent context |',
+        '| `/drop [file...]` | Remove files from context (no args = clear all) |',
+        '',
+        '**Actions**',
+        '| Command | Description |',
+        '|---------|-------------|',
+        '| `/diff [--staged]` | Git diff with AI review |',
+        '| `/undo` | Undo last agent action |',
+        '| `/undo-all` | Undo all actions in session |',
+        '| `/changes` | Show session changes |',
+        '| `/export [json\\|md\\|txt]` | Export conversation |',
+        '',
+        '**Skills** (type `/skills` to list all)',
+        '`/commit` · `/fix` · `/test` · `/docs` · `/refactor` · `/explain`',
+        '`/optimize` · `/debug` · `/push` · `/pr` · `/build` · `/deploy` …',
     ].join('\n');
 }
 function buildStatus(session) {
@@ -259,6 +520,31 @@ function loginCmd(providerId, apiKey) {
     setApiKey(apiKey, providerId);
     return `Logged in as **${provider.name}** (\`${providerId}\`). Model: \`${provider.defaultModel}\`.`;
 }
+const PREVIEW_MESSAGES = 6; // last N messages to show on session restore
+const PREVIEW_MAX_CHARS = 300; // truncate long messages
+function formatSessionPreviewLines(history) {
+    const recent = history.slice(-PREVIEW_MESSAGES);
+    const lines = [`*Last ${recent.length} message${recent.length !== 1 ? 's' : ''}:*`, ''];
+    for (const msg of recent) {
+        const role = msg.role === 'user' ? '**You**' : msg.role === 'assistant' ? '**Codeep**' : '_system_';
+        const text = msg.content.length > PREVIEW_MAX_CHARS
+            ? msg.content.slice(0, PREVIEW_MAX_CHARS) + '…'
+            : msg.content;
+        // Collapse newlines to keep preview compact
+        lines.push(`${role}: ${text.replace(/\n+/g, ' ')}`);
+    }
+    return lines;
+}
+function formatSessionPreview(name, history) {
+    const lines = [
+        `Session loaded: \`${name}\` (${history.length} messages)`,
+        '',
+        '---',
+        '',
+        ...formatSessionPreviewLines(history),
+    ];
+    return lines.join('\n');
+}
 function buildSessionList(workspaceRoot) {
     const sessions = listSessionsWithInfo(workspaceRoot);
     if (sessions.length === 0)

package/dist/acp/server.js

@@ -5,6 +5,49 @@ import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
 import { initWorkspace, handleCommand } from './commands.js';
 import { autoSaveSession } from '../config/index.js';
+// All advertised slash commands (shown in Zed autocomplete)
+const AVAILABLE_COMMANDS = [
+    // Configuration
+    { name: 'help', description: 'Show available commands' },
+    { name: 'status', description: 'Show current config 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: 'lang', description: 'Set response language', input: { hint: '<code> (en, hr, auto…)' } },
+    { name: 'grant', description: 'Grant write access for workspace' },
+    // Sessions
+    { name: 'session', description: 'List sessions, or: new / load <name>', input: { hint: 'new | load <name>' } },
+    { name: 'save', description: 'Save current session', input: { hint: '[name]' } },
+    // Context
+    { name: 'add', description: 'Add files to agent context', input: { hint: '<file> [file2…]' } },
+    { name: 'drop', description: 'Remove files from context (no args = clear all)', input: { hint: '[file…]' } },
+    // Actions
+    { name: 'diff', description: 'Git diff with AI review', input: { hint: '[--staged]' } },
+    { name: 'undo', description: 'Undo last agent action' },
+    { name: 'undo-all', description: 'Undo all agent actions in session' },
+    { name: 'changes', description: 'Show all changes made in session' },
+    { name: 'export', description: 'Export conversation', input: { hint: 'json | md | txt' } },
+    // Project intelligence
+    { name: 'scan', description: 'Scan project structure and generate summary' },
+    { name: 'review', description: 'Run code review on project or specific files', input: { hint: '[file…]' } },
+    { name: 'learn', description: 'Learn coding preferences from project files' },
+    // Skills
+    { name: 'skills', description: 'List all available skills', input: { hint: '[query]' } },
+    { name: 'commit', description: 'Generate commit message and commit' },
+    { name: 'fix', description: 'Fix bugs or issues' },
+    { name: 'test', description: 'Write or run tests' },
+    { name: 'docs', description: 'Generate documentation' },
+    { name: 'refactor', description: 'Refactor code' },
+    { name: 'explain', description: 'Explain code' },
+    { name: 'optimize', description: 'Optimize code for performance' },
+    { name: 'debug', description: 'Debug an issue' },
+    { name: 'push', description: 'Git push' },
+    { name: 'pr', description: 'Create a pull request' },
+    { name: 'build', description: 'Build the project' },
+    { name: 'deploy', description: 'Deploy the project' },
+];
 export function startAcpServer() {
     const transport = new StdioTransport();
     // ACP sessionId → full AcpSession (includes history + codeep session tracking)
@@ -56,31 +99,19 @@ export function startAcpServer() {
             workspaceRoot: params.cwd,
             history,
             codeepSessionId,
+            addedFiles: new Map(),
             abortController: null,
         });
         transport.respond(msg.id, { sessionId: acpSessionId });
-        // Advertise available slash commands to Zed
+        // Advertise all 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)' } },
-                ],
+                availableCommands: AVAILABLE_COMMANDS,
             },
         });
-        // Stream welcome message so the client sees it immediately after session/new
+        // Stream welcome message
         transport.notify('session/update', {
             sessionId: acpSessionId,
             update: {
@@ -101,51 +132,71 @@ 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) {
+        const abortController = new AbortController();
+        session.abortController = abortController;
+        const sendChunk = (text) => {
             transport.notify('session/update', {
                 sessionId: params.sessionId,
                 update: {
                     sessionUpdate: 'agent_message_chunk',
-                    content: { type: 'text', text: cmd.response },
+                    content: { type: 'text', text },
                 },
             });
-            transport.respond(msg.id, { stopReason: 'end_turn' });
-            return;
-        }
-        const abortController = new AbortController();
-        session.abortController = abortController;
-        runAgentSession({
-            prompt,
-            workspaceRoot: session.workspaceRoot,
-            conversationId: params.sessionId,
-            abortSignal: abortController.signal,
-            onChunk: (text) => {
-                transport.notify('session/update', {
-                    sessionId: params.sessionId,
-                    update: {
-                        sessionUpdate: 'agent_message_chunk',
-                        content: { type: 'text', text },
-                    },
-                });
-            },
-            onFileEdit: (_uri, _newText) => {
-                // 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') {
-                transport.respond(msg.id, { stopReason: 'cancelled' });
+        };
+        // Try slash commands first (async — skills, diff, scan, etc.)
+        handleCommand(prompt, session, sendChunk, abortController.signal)
+            .then((cmd) => {
+            if (cmd.handled) {
+                // For streaming commands (skills, diff), chunks were already sent via onChunk.
+                // For simple commands, send the response now.
+                if (cmd.response)
+                    sendChunk(cmd.response);
+                transport.respond(msg.id, { stopReason: 'end_turn' });
+                return;
             }
-            else {
-                transport.error(msg.id, -32000, err.message);
+            // Not a command — run agent loop
+            // Prepend any added-files context to the prompt
+            let enrichedPrompt = prompt;
+            if (session.addedFiles.size > 0) {
+                const parts = ['[Attached files]'];
+                for (const [, f] of session.addedFiles) {
+                    parts.push(`\nFile: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``);
+                }
+                enrichedPrompt = parts.join('\n') + '\n\n' + prompt;
             }
-        }).finally(() => {
+            runAgentSession({
+                prompt: enrichedPrompt,
+                workspaceRoot: session.workspaceRoot,
+                conversationId: params.sessionId,
+                abortSignal: abortController.signal,
+                onChunk: sendChunk,
+                onFileEdit: (uri, newText) => {
+                    // ACP structured file/edit notification — lets the editor track changed files
+                    transport.notify('file/edit', {
+                        uri,
+                        textChanges: newText
+                            ? [{ range: { start: { line: 0, character: 0 }, end: { line: 999999, character: 0 } }, text: newText }]
+                            : [],
+                    });
+                },
+            }).then(() => {
+                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') {
+                    transport.respond(msg.id, { stopReason: 'cancelled' });
+                }
+                else {
+                    transport.error(msg.id, -32000, err.message);
+                }
+            }).finally(() => {
+                if (session)
+                    session.abortController = null;
+            });
+        })
+            .catch((err) => {
+            transport.error(msg.id, -32000, err.message);
             if (session)
                 session.abortController = null;
         });

package/dist/acp/session.d.ts

@@ -1,3 +1,4 @@
+import { ProjectContext } from '../utils/project.js';
 export interface AgentSessionOptions {
     prompt: string;
     workspaceRoot: string;
@@ -6,6 +7,11 @@ export interface AgentSessionOptions {
     onChunk: (text: string) => void;
     onFileEdit: (uri: string, newText: string) => void;
 }
+/**
+ * Build a ProjectContext from a workspace root directory.
+ * Falls back to a minimal synthetic context if scanning fails.
+ */
+export declare function buildProjectContext(workspaceRoot: string): ProjectContext;
 /**
  * Run a single agent session driven by ACP parameters.
  *

package/dist/acp/session.js

@@ -1,13 +1,14 @@
 // acp/session.ts
 // Bridges ACP parameters to the Codeep agent loop.
 import { pathToFileURL } from 'url';
+import { join, isAbsolute } from 'path';
 import { runAgent } from '../utils/agent.js';
 import { getProjectContext } from '../utils/project.js';
 /**
  * Build a ProjectContext from a workspace root directory.
  * Falls back to a minimal synthetic context if scanning fails.
  */
-function buildProjectContext(workspaceRoot) {
+export function buildProjectContext(workspaceRoot) {
     const ctx = getProjectContext(workspaceRoot);
     if (ctx) {
         return ctx;
@@ -32,13 +33,28 @@ export async function runAgentSession(opts) {
     const projectContext = buildProjectContext(opts.workspaceRoot);
     const result = await runAgent(opts.prompt, projectContext, {
         abortSignal: opts.abortSignal,
-        // Stream iteration status and thinking text back to the caller via onChunk
         onIteration: (_iteration, message) => {
             opts.onChunk(message + '\n');
         },
         onThinking: (text) => {
             opts.onChunk(text);
         },
+        onToolCall: (toolCall) => {
+            // Notify the caller when agent writes or edits a file so ACP can
+            // send a structured file/edit notification to the editor.
+            const name = toolCall.tool;
+            if (name === 'write_file' || name === 'edit_file') {
+                const params = toolCall.parameters;
+                const filePath = params.path ?? '';
+                if (filePath) {
+                    const absPath = isAbsolute(filePath)
+                        ? filePath
+                        : join(opts.workspaceRoot, filePath);
+                    const newText = params.content ?? params.new_text ?? '';
+                    opts.onFileEdit(pathToFileURL(absPath).href, newText);
+                }
+            }
+        },
     });
     // Emit the final response text if present
     if (result.finalResponse) {

package/package.json

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