@sudocode-ai/claude-code-acp 0.12.9 → 0.13.1

package/dist/acp-agent.js

@@ -20,7 +20,6 @@ export class ClaudeAcpAgent {
         this.sessions = {};
         this.client = client;
         this.toolUseCache = {};
-        this.fileContentCache = {};
         this.logger = logger ?? console;
     }
     async initialize(request) {
@@ -55,6 +54,7 @@ export class ClaudeAcpAgent {
                 },
                 sessionCapabilities: {
                     fork: {},
+                    resume: {},
                 },
                 loadSession: true,
             },
@@ -82,16 +82,233 @@ export class ClaudeAcpAgent {
      * Named unstable_forkSession to match SDK expectations (session/fork routes to this method).
      */
     async unstable_forkSession(params) {
-        // cwd and mcpServers are passed via _meta since they're not in the SDK type yet
-        const meta = params._meta;
-        return await this.createSession({
-            cwd: meta?.cwd ?? process.cwd(),
-            mcpServers: meta?.mcpServers ?? [],
+        // 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"))
+            : []);
+        const result = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
             _meta: params._meta,
         }, {
             resume: params.sessionId,
             forkSession: true,
         });
+        // Wait briefly for CLI to create the session file
+        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) {
+            // Check if the CLI assigned a non-UUID session ID (e.g., "agent-xxx")
+            // If so, we need to extract the internal sessionId from the file
+            const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(cliSessionId);
+            if (!isUuid) {
+                // Read the session file to extract the internal sessionId
+                const oldFilePath = path.join(sessionDir, `${cliSessionId}.jsonl`);
+                const internalSessionId = this.extractInternalSessionId(oldFilePath);
+                if (internalSessionId) {
+                    this.logger.log(`[claude-code-acp] Fork: extracted internal sessionId ${internalSessionId} from ${cliSessionId}`);
+                    // Check if target file already exists (CLI reuses session IDs for forks from same parent)
+                    // If so, generate a new unique session ID to avoid collisions
+                    let finalSessionId = internalSessionId;
+                    let newFilePath = path.join(sessionDir, `${finalSessionId}.jsonl`);
+                    if (fs.existsSync(newFilePath)) {
+                        // Session ID collision - CLI created a fork with the same internal ID
+                        // Generate a new UUID and update the file's internal session ID
+                        finalSessionId = randomUUID();
+                        newFilePath = path.join(sessionDir, `${finalSessionId}.jsonl`);
+                        this.logger.log(`[claude-code-acp] Fork: session ID collision detected, using new ID: ${finalSessionId}`);
+                        // Update the internal session ID in the file before renaming
+                        this.updateSessionIdInFile(oldFilePath, finalSessionId);
+                    }
+                    // Rename the file to match the session ID so CLI can find it
+                    try {
+                        fs.renameSync(oldFilePath, newFilePath);
+                        this.logger.log(`[claude-code-acp] Fork: renamed ${cliSessionId}.jsonl -> ${finalSessionId}.jsonl`);
+                        // Promote sidechain to full session so it can be resumed/forked again
+                        this.promoteToFullSession(newFilePath);
+                    }
+                    catch (err) {
+                        this.logger.error(`[claude-code-acp] Failed to rename session file: ${err}`);
+                        // Continue anyway - the session might still work
+                    }
+                    // Re-register session with the final session ID
+                    const session = this.sessions[result.sessionId];
+                    this.sessions[finalSessionId] = session;
+                    delete this.sessions[result.sessionId];
+                    return { ...result, sessionId: finalSessionId };
+                }
+                // Fall through if we couldn't extract the internal ID
+                this.logger.error(`[claude-code-acp] Could not extract internal sessionId from ${oldFilePath}`);
+            }
+            // Re-register session with the CLI's session ID (if it's already a UUID or extraction failed)
+            this.logger.log(`[claude-code-acp] Fork: remapping session ${result.sessionId} -> ${cliSessionId}`);
+            this.sessions[cliSessionId] = this.sessions[result.sessionId];
+            delete this.sessions[result.sessionId];
+            return { ...result, sessionId: cliSessionId };
+        }
+        return result;
+    }
+    /**
+     * Get the directory where session files are stored for a given cwd.
+     */
+    getSessionDirPath(cwd) {
+        const realCwd = fs.realpathSync(cwd);
+        const cwdHash = realCwd.replace(/[/_]/g, "-");
+        return path.join(os.homedir(), ".claude", "projects", cwdHash);
+    }
+    /**
+     * 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.
+     */
+    extractInternalSessionId(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            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") {
+                // 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) {
+                    return parsed.sessionId;
+                }
+            }
+            return null;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to extract sessionId from ${filePath}: ${err}`);
+            return null;
+        }
+    }
+    /**
+     * 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.
+     */
+    promoteToFullSession(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
+            const modifiedLines = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    modifiedLines.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    // Change isSidechain from true to false
+                    if (parsed.isSidechain === true) {
+                        parsed.isSidechain = false;
+                    }
+                    modifiedLines.push(JSON.stringify(parsed));
+                }
+                catch {
+                    // Keep line as-is if it can't be parsed
+                    modifiedLines.push(line);
+                }
+            }
+            fs.writeFileSync(filePath, modifiedLines.join("\n"), "utf-8");
+            this.logger.log(`[claude-code-acp] Promoted sidechain to full session: ${filePath}`);
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to promote session: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * 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.
+     */
+    updateSessionIdInFile(filePath, newSessionId) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
+            const modifiedLines = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    modifiedLines.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    // Update the sessionId in each line
+                    if (parsed.sessionId && typeof parsed.sessionId === "string") {
+                        parsed.sessionId = newSessionId;
+                    }
+                    modifiedLines.push(JSON.stringify(parsed));
+                }
+                catch {
+                    // Keep line as-is if it can't be parsed
+                    modifiedLines.push(line);
+                }
+            }
+            fs.writeFileSync(filePath, modifiedLines.join("\n"), "utf-8");
+            this.logger.log(`[claude-code-acp] Updated session ID in file: ${filePath}`);
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`[claude-code-acp] Failed to update session ID in file: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * 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.
+     */
+    async discoverCliSessionId(sessionDir, beforeFiles, fallbackId, timeout = 2000) {
+        const start = Date.now();
+        // Pattern for CLI-assigned fork session IDs (agent-xxxxxxx)
+        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"));
+                // 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));
+                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", "");
+                }
+                else if (newFiles.length > 1) {
+                    // Multiple new agent files - try to find the most recent one
+                    let newestFile = "";
+                    let newestMtime = 0;
+                    for (const file of newFiles) {
+                        const filePath = path.join(sessionDir, file);
+                        const stat = fs.statSync(filePath);
+                        if (stat.mtimeMs > newestMtime) {
+                            newestMtime = stat.mtimeMs;
+                            newestFile = file;
+                        }
+                    }
+                    if (newestFile) {
+                        this.logger.log(`[claude-code-acp] Discovered fork session file (newest of ${newFiles.length}): ${newestFile}`);
+                        return newestFile.replace(".jsonl", "");
+                    }
+                }
+            }
+            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}`);
+        return fallbackId;
     }
     /**
      * Alias for unstable_forkSession for convenience.
@@ -191,7 +408,7 @@ export class ClaudeAcpAgent {
                     break;
                 }
                 case "stream_event": {
-                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.client, this.logger)) {
                         await this.client.sessionUpdate(notification);
                     }
                     break;
@@ -233,7 +450,7 @@ export class ClaudeAcpAgent {
                         ? // Handled by stream events above
                             message.message.content.filter((item) => !["text", "thinking"].includes(item.type))
                         : message.message.content;
-                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.client, this.logger)) {
                         await this.client.sessionUpdate(notification);
                     }
                     break;
@@ -256,6 +473,106 @@ export class ClaudeAcpAgent {
         this.sessions[params.sessionId].cancelled = true;
         await this.sessions[params.sessionId].query.interrupt();
     }
+    /**
+     * Handle extension methods from the client.
+     *
+     * Currently supports:
+     * - `_session/flush`: Flush a session to disk for fork-with-flush support
+     */
+    async extMethod(method, params) {
+        if (method === "_session/flush") {
+            return this.handleSessionFlush(params);
+        }
+        throw RequestError.methodNotFound(method);
+    }
+    /**
+     * 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.
+     */
+    async handleSessionFlush(params) {
+        const { sessionId, persistTimeout = 5000 } = params;
+        const session = this.sessions[sessionId];
+        if (!session) {
+            return { success: false, error: `Session ${sessionId} not found` };
+        }
+        try {
+            // Step 1: Mark session as cancelled to stop processing
+            session.cancelled = true;
+            // Step 2: Interrupt any ongoing query work
+            await session.query.interrupt();
+            // Step 3: End the input stream to signal no more input
+            session.input.end();
+            // Step 4: Abort the session using the AbortController
+            // This forces the Claude SDK subprocess to exit, which triggers disk persistence
+            session.abortController.abort();
+            // Step 5: Wait for the session file to appear on disk
+            // Use stored sessionFilePath for forked sessions (where filename differs from sessionId)
+            const sessionFilePath = session.sessionFilePath ?? this.getSessionFilePath(sessionId, session.cwd);
+            this.logger.log(`[claude-code-acp] Waiting for session file at: ${sessionFilePath}`);
+            this.logger.log(`[claude-code-acp] Session cwd: ${session.cwd}`);
+            const persisted = await this.waitForSessionFile(sessionFilePath, persistTimeout);
+            if (!persisted) {
+                this.logger.error(`[claude-code-acp] Session file not found at ${sessionFilePath} after ${persistTimeout}ms`);
+                // Check if file exists at the path
+                const exists = fs.existsSync(sessionFilePath);
+                this.logger.error(`[claude-code-acp] File exists check: ${exists}`);
+                // Still remove the session from memory
+                delete this.sessions[sessionId];
+                return { success: false, error: `Session file not created within timeout` };
+            }
+            // Step 6: Remove session from our map
+            // The client will call loadSession() to reload it from disk
+            delete this.sessions[sessionId];
+            this.logger.log(`[claude-code-acp] Session ${sessionId} flushed to disk at ${sessionFilePath}`);
+            return { success: true, filePath: sessionFilePath };
+        }
+        catch (error) {
+            this.logger.error(`[claude-code-acp] Failed to flush session ${sessionId}:`, error);
+            // Clean up session on error
+            delete this.sessions[sessionId];
+            return { success: false, error: String(error) };
+        }
+    }
+    /**
+     * 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
+     */
+    getSessionFilePath(sessionId, cwd) {
+        // Resolve the real path to handle macOS symlinks like /var -> /private/var
+        const realCwd = fs.realpathSync(cwd);
+        // Claude Code replaces both / and _ with - in the cwd hash
+        const cwdHash = realCwd.replace(/[/_]/g, "-");
+        return path.join(os.homedir(), ".claude", "projects", cwdHash, `${sessionId}.jsonl`);
+    }
+    /**
+     * 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
+     */
+    async waitForSessionFile(filePath, timeout) {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            if (fs.existsSync(filePath)) {
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        return false;
+    }
     async unstable_setSessionModel(params) {
         if (!this.sessions[params.sessionId]) {
             throw new Error("Session not found");
@@ -287,14 +604,10 @@ export class ClaudeAcpAgent {
     }
     async readTextFile(params) {
         const response = await this.client.readTextFile(params);
-        if (!params.limit && !params.line) {
-            this.fileContentCache[params.path] = response.content;
-        }
         return response;
     }
     async writeTextFile(params) {
         const response = await this.client.writeTextFile(params);
-        this.fileContentCache[params.path] = params.content;
         return response;
     }
     canUseTool(sessionId) {
@@ -322,7 +635,7 @@ export class ClaudeAcpAgent {
                     toolCall: {
                         toolCallId: toolUseID,
                         rawInput: toolInput,
-                        title: toolInfoFromToolUse({ name: toolName, input: toolInput }, this.fileContentCache, this.logger).title,
+                        title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
                     },
                 });
                 if (signal.aborted || response.outcome?.outcome === "cancelled") {
@@ -378,7 +691,7 @@ export class ClaudeAcpAgent {
                 toolCall: {
                     toolCallId: toolUseID,
                     rawInput: toolInput,
-                    title: toolInfoFromToolUse({ name: toolName, input: toolInput }, this.fileContentCache, this.logger).title,
+                    title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
                 },
             });
             if (signal.aborted || response.outcome?.outcome === "cancelled") {
@@ -416,9 +729,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,
@@ -473,15 +795,21 @@ 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.
-            // TODO: find a way to make this work for fork
+            // 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,
@@ -499,6 +827,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: [
@@ -517,7 +846,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) {
@@ -543,11 +873,15 @@ export class ClaudeAcpAgent {
         if (disallowedTools.length > 0) {
             options.disallowedTools = disallowedTools;
         }
-        // Handle abort controller from meta options
-        const abortController = userProvidedOptions?.abortController;
-        if (abortController?.signal.aborted) {
+        // Create our own AbortController for session management
+        const sessionAbortController = new AbortController();
+        // Handle abort controller from meta options (user can still provide one)
+        const userAbortController = userProvidedOptions?.abortController;
+        if (userAbortController?.signal.aborted) {
             throw new Error("Cancelled");
         }
+        // Pass the abort controller to the query options
+        options.abortController = sessionAbortController;
         const q = query({
             prompt: input,
             options,
@@ -558,6 +892,8 @@ export class ClaudeAcpAgent {
             cancelled: false,
             permissionMode,
             settingsManager,
+            abortController: sessionAbortController,
+            cwd: params.cwd,
         };
         const availableCommands = await getAvailableSlashCommands(q);
         const models = await getAvailableModels(q);
@@ -639,7 +975,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)", "")}`;
@@ -750,7 +1092,7 @@ export function promptToClaude(prompt) {
  * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
  * Only handles text, image, and thinking chunks for now.
  */
-export function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger) {
+export function toAcpNotifications(content, role, sessionId, toolUseCache, client, logger) {
     if (typeof content === "string") {
         return [
             {
@@ -857,7 +1199,7 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, fileC
                         sessionUpdate: "tool_call",
                         rawInput,
                         status: "pending",
-                        ...toolInfoFromToolUse(chunk, fileContentCache, logger),
+                        ...toolInfoFromToolUse(chunk),
                     };
                 }
                 break;
@@ -908,13 +1250,13 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, fileC
     }
     return output;
 }
-export function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger) {
+export function streamEventToAcpNotifications(message, sessionId, toolUseCache, client, logger) {
     const event = message.event;
     switch (event.type) {
         case "content_block_start":
-            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, client, logger);
         case "content_block_delta":
-            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, client, logger);
         // No content
         case "message_start":
         case "message_delta":

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"}