codeep 1.2.19 → 1.2.20

package/README.md

@@ -764,3 +764,37 @@ Contributions are welcome! Please open an issue or submit a pull request on [Git
 ## Support
 
 - **Issues**: [GitHub Issues](https://github.com/VladoIvankovic/Codeep/issues)
+
+## Zed Editor Integration (ACP)
+
+Codeep supports the [Agent Client Protocol (ACP)](https://agentclientprotocol.com), letting you use it as an AI coding agent directly inside [Zed](https://zed.dev).
+
+### Setup
+
+1. Install Codeep globally:
+
+```bash
+npm install -g codeep
+```
+
+2. Add to your Zed `settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "Codeep": {
+      "type": "custom",
+      "command": "codeep",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+3. Make sure your API key is set in the environment Zed uses:
+
+```bash
+export DEEPSEEK_API_KEY=your_key   # or whichever provider
+```
+
+4. Open Zed's AI panel and select **Codeep** as the agent.

package/dist/acp/protocol.d.ts

@@ -0,0 +1,54 @@
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+export interface InitializeParams {
+    capabilities?: Record<string, unknown>;
+    workspaceFolders?: {
+        uri: string;
+        name: string;
+    }[];
+}
+export interface InitializeResult {
+    capabilities: {
+        streaming?: boolean;
+        fileEditing?: boolean;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface AgentRunParams {
+    prompt: string;
+    workspaceRoot?: string;
+    conversationId?: string;
+}
+export interface AgentStreamParams {
+    conversationId: string;
+    text: string;
+    done?: boolean;
+}
+export interface ApplyEditParams {
+    changes: {
+        uri: string;
+        newText: string;
+    }[];
+}
+export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;

package/dist/acp/protocol.js

@@ -0,0 +1,3 @@
+// acp/protocol.ts
+// ACP JSON-RPC message types for Zed Agent Client Protocol
+export {};

package/dist/acp/server.d.ts

@@ -0,0 +1 @@
+export declare function startAcpServer(): Promise<void>;

package/dist/acp/server.js

@@ -0,0 +1,81 @@
+// src/acp/server.ts
+// Codeep ACP adapter — started via `codeep acp` CLI subcommand
+import { StdioTransport } from './transport.js';
+import { runAgentSession } from './session.js';
+export function startAcpServer() {
+    const transport = new StdioTransport();
+    const activeSessions = new Map();
+    transport.start((msg) => {
+        switch (msg.method) {
+            case 'initialize':
+                handleInitialize(msg);
+                break;
+            case 'initialized':
+                // no-op acknowledgment
+                break;
+            case 'agent/run':
+                handleAgentRun(msg);
+                break;
+            case 'agent/cancel':
+                handleAgentCancel(msg);
+                break;
+            default:
+                transport.error(msg.id, -32601, `Method not found: ${msg.method}`);
+        }
+    });
+    function handleInitialize(msg) {
+        const _params = msg.params;
+        const result = {
+            capabilities: {
+                streaming: true,
+                fileEditing: true,
+            },
+            serverInfo: {
+                name: 'codeep',
+                version: '1.0.0',
+            },
+        };
+        transport.respond(msg.id, result);
+    }
+    function handleAgentRun(msg) {
+        const params = msg.params;
+        const conversationId = params.conversationId ?? String(msg.id);
+        const abortController = new AbortController();
+        activeSessions.set(conversationId, abortController);
+        runAgentSession({
+            prompt: params.prompt,
+            workspaceRoot: params.workspaceRoot ?? process.cwd(),
+            conversationId,
+            abortSignal: abortController.signal,
+            onChunk: (text) => {
+                transport.notify('agent/stream', { conversationId, text });
+            },
+            onFileEdit: (uri, newText) => {
+                transport.notify('workspace/applyEdit', {
+                    changes: [{ uri, newText }],
+                });
+            },
+        }).then(() => {
+            transport.respond(msg.id, { done: true });
+        }).catch((err) => {
+            if (err.name === 'AbortError') {
+                transport.respond(msg.id, { cancelled: true });
+            }
+            else {
+                transport.error(msg.id, -32000, err.message);
+            }
+        }).finally(() => {
+            activeSessions.delete(conversationId);
+        });
+    }
+    function handleAgentCancel(msg) {
+        const { conversationId } = msg.params;
+        activeSessions.get(conversationId)?.abort();
+        activeSessions.delete(conversationId);
+        transport.respond(msg.id, { cancelled: true });
+    }
+    // Keep process alive until stdin closes (Zed terminates us)
+    return new Promise((resolve) => {
+        process.stdin.on('end', resolve);
+    });
+}

package/dist/acp/session.d.ts

@@ -0,0 +1,15 @@
+export interface AgentSessionOptions {
+    prompt: string;
+    workspaceRoot: string;
+    conversationId: string;
+    abortSignal: AbortSignal;
+    onChunk: (text: string) => void;
+    onFileEdit: (uri: string, newText: string) => void;
+}
+/**
+ * Run a single agent session driven by ACP parameters.
+ *
+ * onFileEdit is reserved for future use (v1 emits everything via onChunk).
+ */
+export declare function runAgentSession(opts: AgentSessionOptions): Promise<void>;
+export declare function pathToUri(absolutePath: string): string;

package/dist/acp/session.js

@@ -0,0 +1,61 @@
+// acp/session.ts
+// Bridges ACP parameters to the Codeep agent loop.
+import { pathToFileURL } from 'url';
+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) {
+    const ctx = getProjectContext(workspaceRoot);
+    if (ctx) {
+        return ctx;
+    }
+    // Minimal fallback so runAgent never receives null
+    return {
+        root: workspaceRoot,
+        name: workspaceRoot.split('/').pop() ?? 'workspace',
+        type: 'Unknown',
+        structure: '',
+        keyFiles: [],
+        fileCount: 0,
+        summary: `Workspace at ${workspaceRoot}`,
+    };
+}
+/**
+ * Run a single agent session driven by ACP parameters.
+ *
+ * onFileEdit is reserved for future use (v1 emits everything via onChunk).
+ */
+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);
+        },
+    });
+    // Emit the final response text if present
+    if (result.finalResponse) {
+        opts.onChunk(result.finalResponse);
+    }
+    // Surface errors as thrown exceptions so index.ts can handle them correctly
+    if (!result.success && !result.aborted) {
+        throw new Error(result.error ?? 'Agent run failed without a specific error message');
+    }
+    if (result.aborted) {
+        const abortError = new Error('Agent session was cancelled');
+        abortError.name = 'AbortError';
+        throw abortError;
+    }
+}
+// Utility: convert an absolute file-system path to a file:// URI string.
+// Exported for use by callers that need to construct applyEdit URIs.
+export function pathToUri(absolutePath) {
+    return pathToFileURL(absolutePath).href;
+}

package/dist/acp/transport.d.ts

@@ -0,0 +1,13 @@
+import { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './protocol.js';
+type MessageHandler = (msg: JsonRpcRequest) => void;
+export declare class StdioTransport {
+    private buffer;
+    private handler;
+    start(handler: MessageHandler): void;
+    private onData;
+    send(msg: JsonRpcResponse | JsonRpcNotification): void;
+    respond(id: number | string, result: unknown): void;
+    error(id: number | string, code: number, message: string): void;
+    notify(method: string, params: unknown): void;
+}
+export {};

package/dist/acp/transport.js

@@ -0,0 +1,41 @@
+// acp/transport.ts
+// Newline-delimited JSON-RPC over stdio
+export class StdioTransport {
+    buffer = '';
+    handler = null;
+    start(handler) {
+        this.handler = handler;
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => this.onData(chunk));
+        process.stdin.on('end', () => process.exit(0));
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                this.handler?.(msg);
+            }
+            catch {
+                // ignore malformed messages
+            }
+        }
+    }
+    send(msg) {
+        process.stdout.write(JSON.stringify(msg) + '\n');
+    }
+    respond(id, result) {
+        this.send({ jsonrpc: '2.0', id, result });
+    }
+    error(id, code, message) {
+        this.send({ jsonrpc: '2.0', id, error: { code, message } });
+    }
+    notify(method, params) {
+        this.send({ jsonrpc: '2.0', method, params });
+    }
+}

package/dist/renderer/main.js

@@ -321,6 +321,7 @@ Codeep - AI-powered coding assistant TUI
 
 Usage:
   codeep              Start interactive chat
+  codeep acp          Start ACP server (for Zed editor integration)
   codeep --version    Show version
   codeep --help       Show this help
 
@@ -332,6 +333,12 @@ Commands (in chat):
     `);
         process.exit(0);
     }
+    // ACP server mode — started by Zed via Agent Client Protocol
+    if (args[0] === 'acp') {
+        const { startAcpServer } = await import('../acp/server.js');
+        await startAcpServer();
+        return;
+    }
     await loadAllApiKeys();
     let apiKey = await loadApiKey();
     if (!apiKey) {

package/dist/utils/agent.d.ts

@@ -4,8 +4,10 @@
  * Private chat/stream logic lives in agentChat.ts and agentStream.ts.
  */
 import { ProjectContext } from './project';
-import { loadProjectRules, formatChatHistoryForAgent, AgentChatResponse } from './agentChat';
-export { loadProjectRules, formatChatHistoryForAgent, AgentChatResponse };
+import { loadProjectRules, formatChatHistoryForAgent } from './agentChat';
+import type { AgentChatResponse } from './agentChat';
+export { loadProjectRules, formatChatHistoryForAgent };
+export type { AgentChatResponse };
 import { ToolCall, ToolResult, ActionLog } from './tools';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';

package/dist/utils/agentChat.d.ts

@@ -13,8 +13,8 @@
  */
 import { ProjectContext } from './project';
 import { Message } from '../config/index';
-import { AgentChatResponse } from './agentStream';
-export { AgentChatResponse };
+import type { AgentChatResponse } from './agentStream';
+export type { AgentChatResponse };
 /**
  * Custom error class for timeout
  */

package/package.json

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