@ape-egg/claude-code-acp 0.0.0-stage → 0.16.2

package/dist/tools.js

@@ -0,0 +1,622 @@
+import { SYSTEM_REMINDER } from "./mcp-server.js";
+import * as diff from "diff";
+const acpUnqualifiedToolNames = {
+    read: "Read",
+    edit: "Edit",
+    write: "Write",
+    bash: "Bash",
+    killShell: "KillShell",
+    bashOutput: "BashOutput",
+};
+export const ACP_TOOL_NAME_PREFIX = "mcp__acp__";
+export const acpToolNames = {
+    read: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.read,
+    edit: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.edit,
+    write: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.write,
+    bash: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.bash,
+    killShell: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.killShell,
+    bashOutput: ACP_TOOL_NAME_PREFIX + acpUnqualifiedToolNames.bashOutput,
+};
+export const EDIT_TOOL_NAMES = [acpToolNames.edit, acpToolNames.write];
+export function toolInfoFromToolUse(toolUse) {
+    const name = toolUse.name;
+    const input = toolUse.input;
+    switch (name) {
+        case "Task":
+            return {
+                title: input?.description ? input.description : "Task",
+                kind: "think",
+                content: input && input.prompt
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.prompt },
+                        },
+                    ]
+                    : [],
+            };
+        case "NotebookRead":
+            return {
+                title: input?.notebook_path ? `Read Notebook ${input.notebook_path}` : "Read Notebook",
+                kind: "read",
+                content: [],
+                locations: input?.notebook_path ? [{ path: input.notebook_path }] : [],
+            };
+        case "NotebookEdit":
+            return {
+                title: input?.notebook_path ? `Edit Notebook ${input.notebook_path}` : "Edit Notebook",
+                kind: "edit",
+                content: input && input.new_source
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.new_source },
+                        },
+                    ]
+                    : [],
+                locations: input?.notebook_path ? [{ path: input.notebook_path }] : [],
+            };
+        case "Bash":
+        case acpToolNames.bash:
+            return {
+                title: input?.command ? "`" + input.command.replaceAll("`", "\\`") + "`" : "Terminal",
+                kind: "execute",
+                content: input && input.description
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.description },
+                        },
+                    ]
+                    : [],
+            };
+        case "BashOutput":
+        case acpToolNames.bashOutput:
+            return {
+                title: "Tail Logs",
+                kind: "execute",
+                content: [],
+            };
+        case "KillShell":
+        case acpToolNames.killShell:
+            return {
+                title: "Kill Process",
+                kind: "execute",
+                content: [],
+            };
+        case acpToolNames.read: {
+            let limit = "";
+            if (input.limit) {
+                limit =
+                    " (" + ((input.offset ?? 0) + 1) + " - " + ((input.offset ?? 0) + input.limit) + ")";
+            }
+            else if (input.offset) {
+                limit = " (from line " + (input.offset + 1) + ")";
+            }
+            return {
+                title: "Read " + (input.file_path ?? "File") + limit,
+                kind: "read",
+                locations: input.file_path
+                    ? [
+                        {
+                            path: input.file_path,
+                            line: input.offset ?? 0,
+                        },
+                    ]
+                    : [],
+                content: [],
+            };
+        }
+        case "Read":
+            return {
+                title: "Read File",
+                kind: "read",
+                content: [],
+                locations: input.file_path
+                    ? [
+                        {
+                            path: input.file_path,
+                            line: input.offset ?? 0,
+                        },
+                    ]
+                    : [],
+            };
+        case "LS":
+            return {
+                title: `List the ${input?.path ? "`" + input.path + "`" : "current"} directory's contents`,
+                kind: "search",
+                content: [],
+                locations: [],
+            };
+        case acpToolNames.edit:
+        case "Edit": {
+            const path = input?.file_path ?? input?.file_path;
+            return {
+                title: path ? `Edit \`${path}\`` : "Edit",
+                kind: "edit",
+                content: input && path
+                    ? [
+                        {
+                            type: "diff",
+                            path,
+                            oldText: input.old_string ?? null,
+                            newText: input.new_string ?? "",
+                        },
+                    ]
+                    : [],
+                locations: path ? [{ path }] : undefined,
+            };
+        }
+        case acpToolNames.write: {
+            let content = [];
+            if (input && input.file_path) {
+                content = [
+                    {
+                        type: "diff",
+                        path: input.file_path,
+                        oldText: null,
+                        newText: input.content,
+                    },
+                ];
+            }
+            else if (input && input.content) {
+                content = [
+                    {
+                        type: "content",
+                        content: { type: "text", text: input.content },
+                    },
+                ];
+            }
+            return {
+                title: input?.file_path ? `Write ${input.file_path}` : "Write",
+                kind: "edit",
+                content,
+                locations: input?.file_path ? [{ path: input.file_path }] : [],
+            };
+        }
+        case "Write":
+            return {
+                title: input?.file_path ? `Write ${input.file_path}` : "Write",
+                kind: "edit",
+                content: input && input.file_path
+                    ? [
+                        {
+                            type: "diff",
+                            path: input.file_path,
+                            oldText: null,
+                            newText: input.content,
+                        },
+                    ]
+                    : [],
+                locations: input?.file_path ? [{ path: input.file_path }] : [],
+            };
+        case "Glob": {
+            let label = "Find";
+            if (input.path) {
+                label += ` \`${input.path}\``;
+            }
+            if (input.pattern) {
+                label += ` \`${input.pattern}\``;
+            }
+            return {
+                title: label,
+                kind: "search",
+                content: [],
+                locations: input.path ? [{ path: input.path }] : [],
+            };
+        }
+        case "Grep": {
+            let label = "grep";
+            if (input["-i"]) {
+                label += " -i";
+            }
+            if (input["-n"]) {
+                label += " -n";
+            }
+            if (input["-A"] !== undefined) {
+                label += ` -A ${input["-A"]}`;
+            }
+            if (input["-B"] !== undefined) {
+                label += ` -B ${input["-B"]}`;
+            }
+            if (input["-C"] !== undefined) {
+                label += ` -C ${input["-C"]}`;
+            }
+            if (input.output_mode) {
+                switch (input.output_mode) {
+                    case "FilesWithMatches":
+                        label += " -l";
+                        break;
+                    case "Count":
+                        label += " -c";
+                        break;
+                    case "Content":
+                    default:
+                        break;
+                }
+            }
+            if (input.head_limit !== undefined) {
+                label += ` | head -${input.head_limit}`;
+            }
+            if (input.glob) {
+                label += ` --include="${input.glob}"`;
+            }
+            if (input.type) {
+                label += ` --type=${input.type}`;
+            }
+            if (input.multiline) {
+                label += " -P";
+            }
+            if (input.pattern) {
+                label += ` "${input.pattern}"`;
+            }
+            if (input.path) {
+                label += ` ${input.path}`;
+            }
+            return {
+                title: label,
+                kind: "search",
+                content: [],
+            };
+        }
+        case "WebFetch":
+            return {
+                title: input?.url ? `Fetch ${input.url}` : "Fetch",
+                kind: "fetch",
+                content: input && input.prompt
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.prompt },
+                        },
+                    ]
+                    : [],
+            };
+        case "WebSearch": {
+            let label = `"${input.query}"`;
+            if (input.allowed_domains && input.allowed_domains.length > 0) {
+                label += ` (allowed: ${input.allowed_domains.join(", ")})`;
+            }
+            if (input.blocked_domains && input.blocked_domains.length > 0) {
+                label += ` (blocked: ${input.blocked_domains.join(", ")})`;
+            }
+            return {
+                title: label,
+                kind: "fetch",
+                content: [],
+            };
+        }
+        case "TodoWrite":
+            return {
+                title: Array.isArray(input?.todos)
+                    ? `Update TODOs: ${input.todos.map((todo) => todo.content).join(", ")}`
+                    : "Update TODOs",
+                kind: "think",
+                content: [],
+            };
+        case "ExitPlanMode":
+            return {
+                title: "Ready to code?",
+                kind: "switch_mode",
+                content: input && input.plan
+                    ? [{ type: "content", content: { type: "text", text: input.plan } }]
+                    : [],
+            };
+        case "Other": {
+            let output;
+            try {
+                output = JSON.stringify(input, null, 2);
+            }
+            catch {
+                output = typeof input === "string" ? input : "{}";
+            }
+            return {
+                title: name || "Unknown Tool",
+                kind: "other",
+                content: [
+                    {
+                        type: "content",
+                        content: {
+                            type: "text",
+                            text: `\`\`\`json\n${output}\`\`\``,
+                        },
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                title: name || "Unknown Tool",
+                kind: "other",
+                content: [],
+            };
+    }
+}
+export function toolUpdateFromToolResult(toolResult, toolUse) {
+    if ("is_error" in toolResult &&
+        toolResult.is_error &&
+        toolResult.content &&
+        toolResult.content.length > 0) {
+        // Only return errors
+        return toAcpContentUpdate(toolResult.content, true);
+    }
+    switch (toolUse?.name) {
+        case "Read":
+        case acpToolNames.read:
+            if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
+                return {
+                    content: toolResult.content.map((content) => ({
+                        type: "content",
+                        content: content.type === "text"
+                            ? {
+                                type: "text",
+                                text: markdownEscape(content.text.replace(SYSTEM_REMINDER, "")),
+                            }
+                            : content,
+                    })),
+                };
+            }
+            else if (typeof toolResult.content === "string" && toolResult.content.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: "content",
+                            content: {
+                                type: "text",
+                                text: markdownEscape(toolResult.content.replace(SYSTEM_REMINDER, "")),
+                            },
+                        },
+                    ],
+                };
+            }
+            return {};
+        case acpToolNames.edit: {
+            const content = [];
+            const locations = [];
+            if (Array.isArray(toolResult.content) &&
+                toolResult.content.length > 0 &&
+                "text" in toolResult.content[0] &&
+                typeof toolResult.content[0].text === "string") {
+                const patches = diff.parsePatch(toolResult.content[0].text);
+                console.error(JSON.stringify(patches));
+                for (const { oldFileName, newFileName, hunks } of patches) {
+                    for (const { lines, newStart } of hunks) {
+                        const oldText = [];
+                        const newText = [];
+                        for (const line of lines) {
+                            if (line.startsWith("-")) {
+                                oldText.push(line.slice(1));
+                            }
+                            else if (line.startsWith("+")) {
+                                newText.push(line.slice(1));
+                            }
+                            else {
+                                oldText.push(line.slice(1));
+                                newText.push(line.slice(1));
+                            }
+                        }
+                        if (oldText.length > 0 || newText.length > 0) {
+                            locations.push({ path: newFileName || oldFileName, line: newStart });
+                            content.push({
+                                type: "diff",
+                                path: newFileName || oldFileName,
+                                oldText: oldText.join("\n") || null,
+                                newText: newText.join("\n"),
+                            });
+                        }
+                    }
+                }
+            }
+            const result = {};
+            if (content.length > 0) {
+                result.content = content;
+            }
+            if (locations.length > 0) {
+                result.locations = locations;
+            }
+            return result;
+        }
+        case acpToolNames.bash:
+        case "edit":
+        case "Edit":
+        case acpToolNames.write:
+        case "Write": {
+            return {};
+        }
+        case "ExitPlanMode": {
+            return { title: "Exited Plan Mode" };
+        }
+        case "Task":
+        case "NotebookEdit":
+        case "NotebookRead":
+        case "TodoWrite":
+        case "exit_plan_mode":
+        case "Bash":
+        case "BashOutput":
+        case "KillBash":
+        case "LS":
+        case "Glob":
+        case "Grep":
+        case "WebFetch":
+        case "WebSearch":
+        case "Other":
+        default: {
+            return toAcpContentUpdate(toolResult.content, "is_error" in toolResult ? toolResult.is_error : false);
+        }
+    }
+}
+function toAcpContentUpdate(content, isError = false) {
+    if (Array.isArray(content) && content.length > 0) {
+        return {
+            content: content.map((c) => ({
+                type: "content",
+                content: toAcpContentBlock(c, isError),
+            })),
+        };
+    }
+    else if (typeof content === "object" && content !== null && "type" in content) {
+        return {
+            content: [
+                {
+                    type: "content",
+                    content: toAcpContentBlock(content, isError),
+                },
+            ],
+        };
+    }
+    else if (typeof content === "string" && content.length > 0) {
+        return {
+            content: [
+                {
+                    type: "content",
+                    content: {
+                        type: "text",
+                        text: isError ? `\`\`\`\n${content}\n\`\`\`` : content,
+                    },
+                },
+            ],
+        };
+    }
+    return {};
+}
+function toAcpContentBlock(content, isError) {
+    const wrapText = (text) => ({
+        type: "text",
+        text: isError ? `\`\`\`\n${text}\n\`\`\`` : text,
+    });
+    switch (content.type) {
+        case "text":
+            return {
+                type: "text",
+                text: isError ? `\`\`\`\n${content.text}\n\`\`\`` : content.text,
+            };
+        case "image":
+            if (content.source.type === "base64") {
+                return {
+                    type: "image",
+                    data: content.source.data,
+                    mimeType: content.source.media_type,
+                };
+            }
+            // URL and file-based images can't be converted to ACP format (requires data)
+            return wrapText(content.source.type === "url"
+                ? `[image: ${content.source.url}]`
+                : "[image: file reference]");
+        case "tool_reference":
+            return wrapText(`Tool: ${content.tool_name}`);
+        case "tool_search_tool_search_result":
+            return wrapText(`Tools found: ${content.tool_references.map((r) => r.tool_name).join(", ") || "none"}`);
+        case "tool_search_tool_result_error":
+            return wrapText(`Error: ${content.error_code}${content.error_message ? ` - ${content.error_message}` : ""}`);
+        case "web_search_result":
+            return wrapText(`${content.title} (${content.url})`);
+        case "web_search_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "web_fetch_result":
+            return wrapText(`Fetched: ${content.url}`);
+        case "web_fetch_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "code_execution_result":
+            return wrapText(`Output: ${content.stdout || content.stderr || ""}`);
+        case "bash_code_execution_result":
+            return wrapText(`Output: ${content.stdout || content.stderr || ""}`);
+        case "code_execution_tool_result_error":
+        case "bash_code_execution_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "text_editor_code_execution_view_result":
+            return wrapText(content.content);
+        case "text_editor_code_execution_create_result":
+            return wrapText(content.is_file_update ? "File updated" : "File created");
+        case "text_editor_code_execution_str_replace_result":
+            return wrapText(content.lines?.join("\n") || "");
+        case "text_editor_code_execution_tool_result_error":
+            return wrapText(`Error: ${content.error_code}${content.error_message ? ` - ${content.error_message}` : ""}`);
+        default:
+            return wrapText(JSON.stringify(content));
+    }
+}
+export function planEntries(input) {
+    return input.todos.map((input) => ({
+        content: input.content,
+        status: input.status,
+        priority: "medium",
+    }));
+}
+export function markdownEscape(text) {
+    let escape = "```";
+    for (const [m] of text.matchAll(/^```+/gm)) {
+        while (m.length >= escape.length) {
+            escape += "`";
+        }
+    }
+    return escape + "\n" + text + (text.endsWith("\n") ? "" : "\n") + escape;
+}
+/* A global variable to store callbacks that should be executed when receiving hooks from Claude Code */
+const toolUseCallbacks = {};
+/* Setup callbacks that will be called when receiving hooks from Claude Code */
+export const registerHookCallback = (toolUseID, { onPostToolUseHook, }) => {
+    toolUseCallbacks[toolUseID] = {
+        onPostToolUseHook,
+    };
+};
+/* A callback for Claude Code that is called when receiving a PostToolUse hook */
+export const createPostToolUseHook = (logger = console, options) => async (input, toolUseID) => {
+    if (input.hook_event_name === "PostToolUse") {
+        // Handle EnterPlanMode tool - notify client of mode change after successful execution
+        if (input.tool_name === "EnterPlanMode" && options?.onEnterPlanMode) {
+            await options.onEnterPlanMode();
+        }
+        if (toolUseID) {
+            const onPostToolUseHook = toolUseCallbacks[toolUseID]?.onPostToolUseHook;
+            if (onPostToolUseHook) {
+                await onPostToolUseHook(toolUseID, input.tool_input, input.tool_response);
+                delete toolUseCallbacks[toolUseID]; // Cleanup after execution
+            }
+            else {
+                logger.error(`No onPostToolUseHook found for tool use ID: ${toolUseID}`);
+                delete toolUseCallbacks[toolUseID];
+            }
+        }
+    }
+    return { continue: true };
+};
+/**
+ * Creates a PreToolUse hook that checks permissions using the SettingsManager.
+ * This runs before the SDK's built-in permission rules, allowing us to enforce
+ * our own permission settings for ACP-prefixed tools.
+ */
+export const createPreToolUseHook = (settingsManager, logger = console) => async (input, _toolUseID) => {
+    if (input.hook_event_name !== "PreToolUse") {
+        return { continue: true };
+    }
+    const toolName = input.tool_name;
+    const toolInput = input.tool_input;
+    const permissionCheck = settingsManager.checkPermission(toolName, toolInput);
+    if (permissionCheck.decision !== "ask") {
+        logger.log(`[PreToolUseHook] Tool: ${toolName}, Decision: ${permissionCheck.decision}, Rule: ${permissionCheck.rule}`);
+    }
+    switch (permissionCheck.decision) {
+        case "allow":
+            return {
+                continue: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "allow",
+                    permissionDecisionReason: `Allowed by settings rule: ${permissionCheck.rule}`,
+                },
+            };
+        case "deny":
+            return {
+                continue: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: `Denied by settings rule: ${permissionCheck.rule}`,
+                },
+            };
+        case "ask":
+        default:
+            // Let the normal permission flow continue
+            return { continue: true };
+    }
+};

package/dist/utils.d.ts

@@ -0,0 +1,33 @@
+import { Readable, Writable } from "node:stream";
+import { WritableStream, ReadableStream } from "node:stream/web";
+import { Logger } from "./acp-agent.js";
+import { ClaudeCodeSettings } from "./settings.js";
+export declare class Pushable<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private done;
+    push(item: T): void;
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export declare function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array>;
+export declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
+export declare function unreachable(value: never, logger?: Logger): void;
+export declare function sleep(time: number): Promise<void>;
+export declare function loadManagedSettings(): ClaudeCodeSettings | null;
+export declare function applyEnvironmentSettings(settings: ClaudeCodeSettings): void;
+export interface ExtractLinesResult {
+    content: string;
+    wasLimited: boolean;
+    linesRead: number;
+}
+/**
+ * Extracts lines from file content with byte limit enforcement.
+ *
+ * @param fullContent - The complete file content
+ * @param maxContentLength - Maximum number of UTF-16 Code Units to return
+ * @returns Object containing extracted content and metadata
+ */
+export declare function extractLinesWithByteLimit(fullContent: string, maxContentLength: number): ExtractLinesResult;
+export declare function encodeProjectPath(cwd: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAA0B,MAAM,eAAe,CAAC;AAG3E,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAclF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,GAAG,IAAI,CAM/D;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAM3E;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,kBAAkB,CA6CpB;AAKD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD"}