@sudocode-ai/claude-code-acp 0.12.10 → 0.13.2

package/README.md

@@ -4,13 +4,13 @@
 
 Use [Claude Code](https://www.anthropic.com/claude-code) from [ACP-compatible](https://agentclientprotocol.com) clients such as [Zed](https://zed.dev)!
 
-This tool implements an ACP agent by using the official [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-overview), supporting:
+This tool implements an ACP agent by using the official [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview), supporting:
 
 - Context @-mentions
 - Images
 - Tool calls (with permission requests)
 - Following
-- Edit review
+- Edit reviewddddd
 - TODO lists
 - Interactive (and background) terminals
 - Custom [Slash commands](https://docs.anthropic.com/en/docs/claude-code/slash-commands)
@@ -32,20 +32,14 @@ Read the docs on [External Agent](https://zed.dev/docs/ai/external-agents) suppo
 
 ### Other clients
 
-- Emacs via [agent-shell.el](https://github.com/xenodium/agent-shell)
-- [marimo notebook](https://github.com/marimo-team/marimo)
-- Neovim
-  - via [CodeCompanion.nvim](https://codecompanion.olimorris.dev/configuration/adapters#setup-claude-code-via-acp)
-  - via [yetone/avante.nvim](https://github.com/yetone/avante.nvim)
-
-[Submit a PR](https://github.com/zed-industries/claude-code-acp/pulls) to add yours!
+Or try it with any of the other [ACP compatible clients](https://agentclientprotocol.com/overview/clients)!
 
 #### Installation
 
 Install the adapter from `npm`:
 
 ```bash
-npm install @zed-industries/claude-code-acp
+npm install -g @zed-industries/claude-code-acp
 ```
 
 You can then use `claude-code-acp` as a regular ACP agent:

package/dist/acp-agent.d.ts

@@ -0,0 +1,205 @@
+import { Agent, AgentSideConnection, AuthenticateRequest, CancelNotification, ClientCapabilities, ForkSessionRequest, ForkSessionResponse, InitializeRequest, InitializeResponse, LoadSessionRequest, LoadSessionResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ReadTextFileRequest, ReadTextFileResponse, ResumeSessionRequest, ResumeSessionResponse, SessionNotification, SetSessionModelRequest, SetSessionModelResponse, SetSessionModeRequest, SetSessionModeResponse, TerminalHandle, TerminalOutputResponse, WriteTextFileRequest, WriteTextFileResponse } from "@agentclientprotocol/sdk";
+import { SettingsManager } from "./settings.js";
+import { CanUseTool, Options, PermissionMode, Query, SDKPartialAssistantMessage, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import { Pushable } from "./utils.js";
+import { ContentBlockParam } from "@anthropic-ai/sdk/resources";
+import { BetaContentBlock, BetaRawContentBlockDelta } from "@anthropic-ai/sdk/resources/beta.mjs";
+export declare const CLAUDE_CONFIG_DIR: string;
+/**
+ * Logger interface for customizing logging output
+ */
+export interface Logger {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+type Session = {
+    query: Query;
+    input: Pushable<SDKUserMessage>;
+    cancelled: boolean;
+    permissionMode: PermissionMode;
+    settingsManager: SettingsManager;
+    abortController: AbortController;
+    cwd: string;
+    /** Optional: the actual session file path (for forked sessions where filename differs from sessionId) */
+    sessionFilePath?: string;
+};
+type BackgroundTerminal = {
+    handle: TerminalHandle;
+    status: "started";
+    lastOutput: TerminalOutputResponse | null;
+} | {
+    status: "aborted" | "exited" | "killed" | "timedOut";
+    pendingOutput: TerminalOutputResponse;
+};
+/**
+ * Extra metadata that can be given to Claude Code when creating a new session.
+ */
+export type NewSessionMeta = {
+    claudeCode?: {
+        /**
+         * Options forwarded to Claude Code when starting a new session.
+         * Those parameters will be ignored and managed by ACP:
+         *   - cwd
+         *   - includePartialMessages
+         *   - allowDangerouslySkipPermissions
+         *   - permissionMode
+         *   - canUseTool
+         *   - executable
+         * Those parameters will be used and updated to work with ACP:
+         *   - hooks (merged with ACP's hooks)
+         *   - mcpServers (merged with ACP's mcpServers)
+         */
+        options?: Options;
+    };
+};
+/**
+ * Extra metadata that the agent provides for each tool_call / tool_update update.
+ */
+export type ToolUpdateMeta = {
+    claudeCode?: {
+        toolName: string;
+        toolResponse?: unknown;
+    };
+};
+type ToolUseCache = {
+    [key: string]: {
+        type: "tool_use" | "server_tool_use" | "mcp_tool_use";
+        id: string;
+        name: string;
+        input: any;
+    };
+};
+export declare class ClaudeAcpAgent implements Agent {
+    sessions: {
+        [key: string]: Session;
+    };
+    client: AgentSideConnection;
+    toolUseCache: ToolUseCache;
+    backgroundTerminals: {
+        [key: string]: BackgroundTerminal;
+    };
+    clientCapabilities?: ClientCapabilities;
+    logger: Logger;
+    constructor(client: AgentSideConnection, logger?: Logger);
+    initialize(request: InitializeRequest): Promise<InitializeResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    /**
+     * Fork an existing session to create a new independent session.
+     * This is the ACP protocol method handler for session/fork.
+     * Named unstable_forkSession to match SDK expectations (session/fork routes to this method).
+     */
+    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    /**
+     * Get the directory where session files are stored for a given cwd.
+     */
+    private getSessionDirPath;
+    /**
+     * Extract the internal sessionId from a session JSONL file.
+     * The CLI stores the actual session ID inside the file, which may differ from the filename.
+     * For forked sessions, the filename is "agent-xxx" but the internal sessionId is a UUID.
+     */
+    private extractInternalSessionId;
+    /**
+     * Promote a sidechain session to a regular session by modifying the session file.
+     * Forked sessions have "isSidechain": true which prevents them from being resumed.
+     * This method changes it to false so the session can be resumed/forked again.
+     */
+    private promoteToFullSession;
+    /**
+     * Update the sessionId in all lines of a session JSONL file.
+     * This is used when we need to assign a new unique session ID to avoid collisions.
+     */
+    private updateSessionIdInFile;
+    /**
+     * Discover the CLI-assigned session ID by looking for new session files.
+     * Returns the CLI's session ID if found, or the original sessionId if not.
+     */
+    private discoverCliSessionId;
+    /**
+     * Alias for unstable_forkSession for convenience.
+     */
+    forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    /**
+     * Load an existing session to resume a previous conversation.
+     * This is the ACP protocol method handler for session/load.
+     */
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    /**
+     * Resume an existing session. This delegates to loadSession for enhanced functionality.
+     */
+    unstable_resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    authenticate(_params: AuthenticateRequest): Promise<void>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: CancelNotification): Promise<void>;
+    /**
+     * Handle extension methods from the client.
+     *
+     * Currently supports:
+     * - `_session/inject`: Inject a message into an active session mid-execution
+     * - `_session/flush`: Flush a session to disk for fork-with-flush support
+     */
+    extMethod(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Inject a message into an active session.
+     *
+     * This allows sending additional user input while a prompt() call is actively
+     * processing. The injected message will be queued and processed by the agent
+     * as part of the current conversation turn.
+     *
+     * Use cases:
+     * - Providing clarification while the agent is working
+     * - Adding context mid-execution
+     * - Sending corrections before a tool completes
+     *
+     * @param params.sessionId - The session to inject the message into
+     * @param params.message - Either a string or an array of ContentBlocks (same format as prompt)
+     * @returns Success status and any error message
+     */
+    private handleSessionInject;
+    /**
+     * Flush a session to disk by aborting its query subprocess.
+     *
+     * This is used by the fork-with-flush mechanism to ensure session data
+     * is persisted to disk before forking. When the Claude SDK subprocess
+     * exits (via abort), it writes the session data to:
+     * ~/.claude/projects/<cwd-hash>/<sessionId>.jsonl
+     *
+     * After this method completes, the session is removed from memory and
+     * must be reloaded via loadSession() to continue using it.
+     */
+    private handleSessionFlush;
+    /**
+     * Get the file path where Claude Code stores session data.
+     *
+     * Claude Code stores sessions at:
+     * ~/.claude/projects/<cwd-hash>/<sessionId>.jsonl
+     *
+     * Where <cwd-hash> is the cwd with `/` replaced by `-`
+     * Note: We resolve the real path to handle macOS symlinks like /var -> /private/var
+     */
+    private getSessionFilePath;
+    /**
+     * Wait for a session file to appear on disk.
+     *
+     * @param filePath - Path to the session file
+     * @param timeout - Maximum time to wait in milliseconds
+     * @returns true if file appears, false if timeout
+     */
+    private waitForSessionFile;
+    unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse | void>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse>;
+    writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse>;
+    canUseTool(sessionId: string): CanUseTool;
+    private createSession;
+}
+export declare function promptToClaude(prompt: PromptRequest): SDKUserMessage;
+/**
+ * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
+ * Only handles text, image, and thinking chunks for now.
+ */
+export declare function toAcpNotifications(content: string | ContentBlockParam[] | BetaContentBlock[] | BetaRawContentBlockDelta[], role: "assistant" | "user", sessionId: string, toolUseCache: ToolUseCache, client: AgentSideConnection, logger: Logger): SessionNotification[];
+export declare function streamEventToAcpNotifications(message: SDKPartialAssistantMessage, sessionId: string, toolUseCache: ToolUseCache, client: AgentSideConnection, logger: Logger): SessionNotification[];
+export declare function runAcp(): void;
+export {};
+//# sourceMappingURL=acp-agent.d.ts.map

package/dist/acp-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-agent.d.ts","sourceRoot":"","sources":["../src/acp-agent.ts"],"names":[],"mappings":"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"}

package/dist/acp-agent.js

@@ -54,6 +54,7 @@ export class ClaudeAcpAgent {
                 },
                 sessionCapabilities: {
                     fork: {},
+                    resume: {},
                 },
                 loadSession: true,
             },
@@ -84,7 +85,7 @@ export class ClaudeAcpAgent {
         // Get the session directory to track new files
         const sessionDir = this.getSessionDirPath(params.cwd);
         const beforeFiles = new Set(fs.existsSync(sessionDir)
-            ? fs.readdirSync(sessionDir).filter(f => f.endsWith('.jsonl'))
+            ? fs.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"))
             : []);
         const result = await this.createSession({
             cwd: params.cwd,
@@ -95,7 +96,7 @@ export class ClaudeAcpAgent {
             forkSession: true,
         });
         // Wait briefly for CLI to create the session file
-        await new Promise(resolve => setTimeout(resolve, 200));
+        await new Promise((resolve) => setTimeout(resolve, 200));
         // Find the CLI-assigned session ID by looking for new session files
         const cliSessionId = await this.discoverCliSessionId(sessionDir, beforeFiles, result.sessionId);
         if (cliSessionId && cliSessionId !== result.sessionId) {
@@ -167,13 +168,13 @@ export class ClaudeAcpAgent {
             if (!fs.existsSync(filePath)) {
                 return null;
             }
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const firstLine = content.split('\n').find(line => line.trim().length > 0);
+            const content = fs.readFileSync(filePath, "utf-8");
+            const firstLine = content.split("\n").find((line) => line.trim().length > 0);
             if (!firstLine) {
                 return null;
             }
             const parsed = JSON.parse(firstLine);
-            if (parsed.sessionId && typeof parsed.sessionId === 'string') {
+            if (parsed.sessionId && typeof parsed.sessionId === "string") {
                 // Verify it's a UUID format
                 const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(parsed.sessionId);
                 if (isUuid) {
@@ -197,8 +198,8 @@ export class ClaudeAcpAgent {
             if (!fs.existsSync(filePath)) {
                 return false;
             }
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const lines = content.split('\n');
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
             const modifiedLines = [];
             for (const line of lines) {
                 if (!line.trim()) {
@@ -218,7 +219,7 @@ export class ClaudeAcpAgent {
                     modifiedLines.push(line);
                 }
             }
-            fs.writeFileSync(filePath, modifiedLines.join('\n'), 'utf-8');
+            fs.writeFileSync(filePath, modifiedLines.join("\n"), "utf-8");
             this.logger.log(`[claude-code-acp] Promoted sidechain to full session: ${filePath}`);
             return true;
         }
@@ -236,8 +237,8 @@ export class ClaudeAcpAgent {
             if (!fs.existsSync(filePath)) {
                 return false;
             }
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const lines = content.split('\n');
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
             const modifiedLines = [];
             for (const line of lines) {
                 if (!line.trim()) {
@@ -247,7 +248,7 @@ export class ClaudeAcpAgent {
                 try {
                     const parsed = JSON.parse(line);
                     // Update the sessionId in each line
-                    if (parsed.sessionId && typeof parsed.sessionId === 'string') {
+                    if (parsed.sessionId && typeof parsed.sessionId === "string") {
                         parsed.sessionId = newSessionId;
                     }
                     modifiedLines.push(JSON.stringify(parsed));
@@ -257,7 +258,7 @@ export class ClaudeAcpAgent {
                     modifiedLines.push(line);
                 }
             }
-            fs.writeFileSync(filePath, modifiedLines.join('\n'), 'utf-8');
+            fs.writeFileSync(filePath, modifiedLines.join("\n"), "utf-8");
             this.logger.log(`[claude-code-acp] Updated session ID in file: ${filePath}`);
             return true;
         }
@@ -276,18 +277,18 @@ export class ClaudeAcpAgent {
         const agentPattern = /^agent-[a-f0-9]+\.jsonl$/;
         while (Date.now() - start < timeout) {
             if (fs.existsSync(sessionDir)) {
-                const currentFiles = fs.readdirSync(sessionDir).filter(f => f.endsWith('.jsonl'));
+                const currentFiles = fs.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"));
                 // Only look for new files that match the agent-xxx pattern
                 // This prevents picking up renamed UUID files from previous forks
-                const newFiles = currentFiles.filter(f => !beforeFiles.has(f) && agentPattern.test(f));
+                const newFiles = currentFiles.filter((f) => !beforeFiles.has(f) && agentPattern.test(f));
                 if (newFiles.length === 1) {
                     // Found exactly one new agent session file - this is our fork
                     this.logger.log(`[claude-code-acp] Discovered fork session file: ${newFiles[0]}`);
-                    return newFiles[0].replace('.jsonl', '');
+                    return newFiles[0].replace(".jsonl", "");
                 }
                 else if (newFiles.length > 1) {
                     // Multiple new agent files - try to find the most recent one
-                    let newestFile = '';
+                    let newestFile = "";
                     let newestMtime = 0;
                     for (const file of newFiles) {
                         const filePath = path.join(sessionDir, file);
@@ -299,11 +300,11 @@ export class ClaudeAcpAgent {
                     }
                     if (newestFile) {
                         this.logger.log(`[claude-code-acp] Discovered fork session file (newest of ${newFiles.length}): ${newestFile}`);
-                        return newestFile.replace('.jsonl', '');
+                        return newestFile.replace(".jsonl", "");
                     }
                 }
             }
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
         }
         // Timeout - return fallback
         this.logger.log(`[claude-code-acp] Could not discover CLI session ID, using fallback: ${fallbackId}`);
@@ -330,16 +331,17 @@ export class ClaudeAcpAgent {
         return response;
     }
     /**
-     * @deprecated Use loadSession instead. This is kept for backward compatibility.
+     * Resume an existing session. This delegates to loadSession for enhanced functionality.
      */
     async unstable_resumeSession(params) {
-        const meta = params._meta;
-        return this.loadSession({
-            sessionId: params.sessionId,
-            cwd: meta?.cwd ?? process.cwd(),
-            mcpServers: meta?.mcpServers ?? [],
+        const response = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
             _meta: params._meta,
+        }, {
+            resume: params.sessionId,
         });
+        return response;
     }
     async authenticate(_params) {
         throw new Error("Method not implemented.");
@@ -476,14 +478,62 @@ export class ClaudeAcpAgent {
      * Handle extension methods from the client.
      *
      * Currently supports:
+     * - `_session/inject`: Inject a message into an active session mid-execution
      * - `_session/flush`: Flush a session to disk for fork-with-flush support
      */
     async extMethod(method, params) {
+        if (method === "_session/inject") {
+            return this.handleSessionInject(params);
+        }
         if (method === "_session/flush") {
             return this.handleSessionFlush(params);
         }
         throw RequestError.methodNotFound(method);
     }
+    /**
+     * Inject a message into an active session.
+     *
+     * This allows sending additional user input while a prompt() call is actively
+     * processing. The injected message will be queued and processed by the agent
+     * as part of the current conversation turn.
+     *
+     * Use cases:
+     * - Providing clarification while the agent is working
+     * - Adding context mid-execution
+     * - Sending corrections before a tool completes
+     *
+     * @param params.sessionId - The session to inject the message into
+     * @param params.message - Either a string or an array of ContentBlocks (same format as prompt)
+     * @returns Success status and any error message
+     */
+    handleSessionInject(params) {
+        const { sessionId, message } = params;
+        const session = this.sessions[sessionId];
+        if (!session) {
+            return { success: false, error: `Session ${sessionId} not found` };
+        }
+        if (session.cancelled) {
+            return { success: false, error: `Session ${sessionId} is cancelled` };
+        }
+        try {
+            // Convert string to ContentBlock array if needed
+            const prompt = typeof message === "string" ? [{ type: "text", text: message }] : message;
+            // Create a PromptRequest-like object to reuse promptToClaude
+            const promptRequest = {
+                sessionId,
+                prompt,
+            };
+            // Convert to SDK format and push to the session's input queue
+            const sdkMessage = promptToClaude(promptRequest);
+            session.input.push(sdkMessage);
+            this.logger.log(`[claude-code-acp] Injected message into session ${sessionId}`);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error(`[claude-code-acp] Failed to inject message into session ${sessionId}:`, error);
+            return { success: false, error: String(error) };
+        }
+    }
     /**
      * Flush a session to disk by aborting its query subprocess.
      *
@@ -568,7 +618,7 @@ export class ClaudeAcpAgent {
             if (fs.existsSync(filePath)) {
                 return true;
             }
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
         }
         return false;
     }
@@ -728,9 +778,18 @@ export class ClaudeAcpAgent {
         };
     }
     async createSession(params, creationOpts = {}) {
-        // When forking, generate a new session ID (fork creates a new independent session)
-        // When resuming (not fork), use the original session ID
-        const sessionId = creationOpts.forkSession ? randomUUID() : (creationOpts.resume ?? randomUUID());
+        // We want to create a new session id unless it is resume,
+        // but not resume + forkSession.
+        let sessionId;
+        if (creationOpts.forkSession) {
+            sessionId = randomUUID();
+        }
+        else if (creationOpts.resume) {
+            sessionId = creationOpts.resume;
+        }
+        else {
+            sessionId = randomUUID();
+        }
         const input = new Pushable();
         const settingsManager = new SettingsManager(params.cwd, {
             logger: this.logger,
@@ -785,16 +844,19 @@ export class ClaudeAcpAgent {
         // Extract options from _meta if provided
         const userProvidedOptions = params._meta?.claudeCode?.options;
         const extraArgs = { ...userProvidedOptions?.extraArgs };
-        if (creationOpts?.resume === undefined) {
+        if (creationOpts?.resume === undefined || creationOpts?.forkSession) {
             // Set our own session id if not resuming an existing session.
-            // Note: For forked sessions (resume + fork), Claude CLI assigns its own session ID
-            // which means chain forking (fork of a fork) is not currently supported.
             extraArgs["session-id"] = sessionId;
         }
+        // Configure thinking tokens from environment variable
+        const maxThinkingTokens = process.env.MAX_THINKING_TOKENS
+            ? parseInt(process.env.MAX_THINKING_TOKENS, 10)
+            : undefined;
         const options = {
             systemPrompt,
             settingSources: ["user", "project", "local"],
             stderr: (err) => this.logger.error(err),
+            ...(maxThinkingTokens !== undefined && { maxThinkingTokens }),
             ...userProvidedOptions,
             // Override certain fields that must be controlled by ACP
             cwd: params.cwd,
@@ -812,6 +874,7 @@ export class ClaudeAcpAgent {
             ...(process.env.CLAUDE_CODE_EXECUTABLE && {
                 pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE,
             }),
+            tools: { type: "preset", preset: "claude_code" },
             hooks: {
                 ...userProvidedOptions?.hooks,
                 PreToolUse: [
@@ -830,7 +893,8 @@ export class ClaudeAcpAgent {
             ...creationOpts,
         };
         const allowedTools = [];
-        const disallowedTools = [];
+        // Disable this for now, not a great way to expose this over ACP at the moment (in progress work so we can revisit)
+        const disallowedTools = ["AskUserQuestion"];
         // Check if built-in tools should be disabled
         const disableBuiltInTools = params._meta?.disableBuiltInTools === true;
         if (!disableBuiltInTools) {
@@ -958,7 +1022,13 @@ async function getAvailableSlashCommands(query) {
     const commands = await query.supportedCommands();
     return commands
         .map((command) => {
-        const input = command.argumentHint ? { hint: command.argumentHint } : null;
+        const input = command.argumentHint
+            ? {
+                hint: Array.isArray(command.argumentHint)
+                    ? command.argumentHint.join(" ")
+                    : command.argumentHint,
+            }
+            : null;
         let name = command.name;
         if (command.name.endsWith(" (MCP)")) {
             name = `mcp:${name.replace(" (MCP)", "")}`;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/lib.d.ts

@@ -0,0 +1,7 @@
+export { ClaudeAcpAgent, runAcp, toAcpNotifications, streamEventToAcpNotifications, type ToolUpdateMeta, type NewSessionMeta, } from "./acp-agent.js";
+export { loadManagedSettings, applyEnvironmentSettings, nodeToWebReadable, nodeToWebWritable, Pushable, unreachable, } from "./utils.js";
+export { createMcpServer } from "./mcp-server.js";
+export { toolInfoFromToolUse, planEntries, toolUpdateFromToolResult, createPreToolUseHook, acpToolNames as toolNames, } from "./tools.js";
+export { SettingsManager, type ClaudeCodeSettings, type PermissionSettings, type PermissionDecision, type PermissionCheckResult, type SettingsManagerOptions, } from "./settings.js";
+export type { ClaudePlanEntry } from "./tools.js";
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,MAAM,EACN,kBAAkB,EAClB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,QAAQ,EACR,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,EACpB,YAAY,IAAI,SAAS,GAC1B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,eAAe,CAAC;AAGvB,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/mcp-server.d.ts

@@ -0,0 +1,21 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClaudeAcpAgent } from "./acp-agent.js";
+import { ClientCapabilities } from "@agentclientprotocol/sdk";
+export declare const SYSTEM_REMINDER = "\n\n<system-reminder>\nWhenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.\n</system-reminder>";
+export declare function createMcpServer(agent: ClaudeAcpAgent, sessionId: string, clientCapabilities: ClientCapabilities | undefined): McpServer;
+/**
+ * Replace text in a file and calculate the line numbers where the edits occurred.
+ *
+ * @param fileContent - The full file content
+ * @param edits - Array of edit operations to apply sequentially
+ * @returns the new content and the line numbers where replacements occurred in the final content
+ */
+export declare function replaceAndCalculateLocation(fileContent: string, edits: Array<{
+    oldText: string;
+    newText: string;
+    replaceAll?: boolean;
+}>): {
+    newContent: string;
+    lineNumbers: number[];
+};
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AASpE,OAAO,EAAqB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,EACL,kBAAkB,EAGnB,MAAM,0BAA0B,CAAC;AAQlC,eAAO,MAAM,eAAe,iSAIT,CAAC;AA2BpB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,GACjD,SAAS,CA2nBX;AA+DD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC,GACD;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAyF/C"}