anyclaude-sdk 0.1.0

package/dist/tools/fileTypes.js

@@ -0,0 +1,166 @@
+// File-type detection and byte helpers for the read_file subsystem.
+// Browser-safe: no node 'fs'/'buffer'/'path' imports — pure string/byte ops.
+/**
+ * Binary file extensions to skip for text-based reads. Ported from Claude
+ * Code's constants/files.ts. `.pdf` and image types are included here, but
+ * read_file dispatches those to dedicated handlers before the binary check.
+ */
+export const BINARY_EXTENSIONS = new Set([
+    // Images
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.tiff', '.tif',
+    // Videos
+    '.mp4', '.mov', '.avi', '.mkv', '.webm', '.wmv', '.flv', '.m4v', '.mpeg', '.mpg',
+    // Audio
+    '.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a', '.wma', '.aiff', '.opus',
+    // Archives
+    '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar', '.xz', '.z', '.tgz', '.iso',
+    // Executables / binaries
+    '.exe', '.dll', '.so', '.dylib', '.bin', '.o', '.a', '.obj', '.lib', '.app',
+    '.msi', '.deb', '.rpm',
+    // Documents
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.odt', '.ods', '.odp',
+    // Fonts
+    '.ttf', '.otf', '.woff', '.woff2', '.eot',
+    // Bytecode / VM artifacts
+    '.pyc', '.pyo', '.class', '.jar', '.war', '.ear', '.node', '.wasm', '.rlib',
+    // Databases
+    '.sqlite', '.sqlite3', '.db', '.mdb', '.idx',
+    // Design / 3D
+    '.psd', '.ai', '.eps', '.sketch', '.fig', '.xd', '.blend', '.3ds', '.max',
+    // Flash
+    '.swf', '.fla',
+    // Lock / profiling data
+    '.lockb', '.dat', '.data',
+]);
+export const IMAGE_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp',
+]);
+export const NOTEBOOK_EXTENSION = '.ipynb';
+export const PDF_EXTENSION = '.pdf';
+/** Default read caps (mirrors Claude Code: 256 KB / 25k tokens / 20 PDF pages). */
+export const DEFAULT_FILE_READ_LIMITS = {
+    maxSizeBytes: 256 * 1024,
+    maxTokens: 25_000,
+    maxImageBytes: Math.round(3.75 * 1024 * 1024),
+    maxPdfPages: 20,
+};
+/** Lowercased extension including the leading dot, or '' if none. */
+export function extOf(path) {
+    const slash = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
+    const base = slash === -1 ? path : path.slice(slash + 1);
+    const dot = base.lastIndexOf('.');
+    if (dot <= 0)
+        return ''; // no dot, or dotfile like ".bashrc"
+    return base.slice(dot).toLowerCase();
+}
+export function hasBinaryExtension(path) {
+    return BINARY_EXTENSIONS.has(extOf(path));
+}
+export function isImageExtension(path) {
+    return IMAGE_EXTENSIONS.has(extOf(path));
+}
+export function isPdfExtension(path) {
+    return extOf(path) === PDF_EXTENSION;
+}
+export function isNotebookExtension(path) {
+    return extOf(path) === NOTEBOOK_EXTENSION;
+}
+/** Map an image extension to its MIME type. */
+export function imageMediaType(ext) {
+    switch (ext) {
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.webp':
+            return 'image/webp';
+        case '.bmp':
+            return 'image/bmp';
+        default:
+            return 'application/octet-stream';
+    }
+}
+/** Detect image MIME type from magic bytes, or null if unrecognized. */
+export function detectImageFormatFromBytes(bytes) {
+    if (bytes.length < 4)
+        return null;
+    // PNG: 89 50 4E 47
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+        return 'image/png';
+    }
+    // JPEG: FF D8 FF
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    // GIF: "GIF8"
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) {
+        return 'image/gif';
+    }
+    // BMP: "BM"
+    if (bytes[0] === 0x42 && bytes[1] === 0x4d) {
+        return 'image/bmp';
+    }
+    // WEBP: "RIFF"...."WEBP"
+    if (bytes.length >= 12 &&
+        bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+        bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50) {
+        return 'image/webp';
+    }
+    return null;
+}
+/** Heuristic: a NUL byte in the first 8 KB means the file is binary. */
+export function looksBinary(bytes) {
+    const n = Math.min(bytes.length, 8192);
+    for (let i = 0; i < n; i++) {
+        if (bytes[i] === 0)
+            return true;
+    }
+    return false;
+}
+/** Rough token estimate (~4 chars/token). */
+export function roughTokenCount(text) {
+    return Math.ceil(text.length / 4);
+}
+const hasBtoa = typeof btoa === 'function';
+const hasAtob = typeof atob === 'function';
+/** Base64-encode bytes. Works in browser (btoa) and Node (Buffer). */
+export function bytesToBase64(bytes) {
+    if (hasBtoa) {
+        let binary = '';
+        const chunk = 0x8000; // 32 KB chunks to avoid call-stack overflow
+        for (let i = 0; i < bytes.length; i += chunk) {
+            binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+        }
+        return btoa(binary);
+    }
+    // Node fallback
+    const B = globalThis.Buffer;
+    if (B)
+        return B.from(bytes).toString('base64');
+    throw new Error('No base64 encoder available in this environment');
+}
+/** Base64-decode to bytes. Works in browser (atob) and Node (Buffer). */
+export function base64ToBytes(b64) {
+    if (hasAtob) {
+        const binary = atob(b64);
+        const out = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            out[i] = binary.charCodeAt(i);
+        return out;
+    }
+    const B = globalThis.Buffer;
+    if (B)
+        return new Uint8Array(B.from(b64, 'base64'));
+    throw new Error('No base64 decoder available in this environment');
+}
+/** Human-readable byte size. */
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/tools/glob.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const glob: Tool;

package/dist/tools/glob.js

@@ -0,0 +1,53 @@
+import { globToRegExp, walk } from './walk.js';
+const MAX_RESULTS = 100;
+const DESCRIPTION = `Finds files matching a glob pattern by walking the workspace tree.
+
+Supports \`**\` (any depth), \`*\` (within a path segment), and \`?\` (single char).
+Example patterns: \`**/*.ts\`, \`src/**/*.test.js\`, \`*.json\`.
+Returns matching paths relative to the search root (node_modules/.git/dist are ignored).`;
+export const glob = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'glob',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Glob pattern to match.' },
+                    path: {
+                        type: 'string',
+                        description: 'Directory to search from (default ".").',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const pattern = String(input.pattern ?? '');
+        if (!pattern)
+            return { content: 'Error: `pattern` is required.', isError: true };
+        const root = input.path ? String(input.path) : '.';
+        const re = globToRegExp(pattern);
+        const matches = [];
+        let truncated = false;
+        for await (const entry of walk(ctx.fs, root, { signal: ctx.signal })) {
+            if (entry.isDir)
+                continue;
+            if (re.test(entry.path)) {
+                matches.push(entry.path);
+                if (matches.length >= MAX_RESULTS) {
+                    truncated = true;
+                    break;
+                }
+            }
+        }
+        if (matches.length === 0) {
+            return { content: `No files match ${pattern} under ${root}.` };
+        }
+        matches.sort();
+        const note = truncated ? `\n\n[truncated to first ${MAX_RESULTS} matches]` : '';
+        return { content: matches.join('\n') + note };
+    },
+};

package/dist/tools/grep.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const grep: Tool;

package/dist/tools/grep.js

@@ -0,0 +1,110 @@
+import { globToRegExp, joinPath, walk } from './walk.js';
+const MAX_MATCHES = 200;
+const DESCRIPTION = `Searches file contents for a regular expression by walking the workspace tree.
+
+- \`pattern\` is a JavaScript regular expression.
+- \`glob\` optionally restricts which files are searched (e.g. \`**/*.ts\`).
+- \`output_mode\`: "files_with_matches" (default) lists matching paths, "content" shows \`path:line:text\`, "count" shows per-file match counts.
+Binary-looking files and node_modules/.git/dist are skipped.`;
+/**
+ * Heuristic: treat content containing a NUL byte (char code 0) as binary.
+ * Only the first chunk is scanned to keep this cheap on large files.
+ */
+function looksBinary(text) {
+    const limit = Math.min(text.length, 8000);
+    for (let i = 0; i < limit; i++) {
+        if (text.charCodeAt(i) === 0)
+            return true;
+    }
+    return false;
+}
+export const grep = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Regular expression to search for.' },
+                    path: { type: 'string', description: 'Directory to search from (default ".").' },
+                    glob: { type: 'string', description: 'Glob filter for filenames.' },
+                    case_insensitive: { type: 'boolean', description: 'Case-insensitive match.' },
+                    output_mode: {
+                        type: 'string',
+                        enum: ['content', 'files_with_matches', 'count'],
+                        description: 'Output format (default "files_with_matches").',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const pattern = String(input.pattern ?? '');
+        if (!pattern)
+            return { content: 'Error: `pattern` is required.', isError: true };
+        const root = input.path ? String(input.path) : '.';
+        const mode = input.output_mode === 'content' || input.output_mode === 'count'
+            ? input.output_mode
+            : 'files_with_matches';
+        let re;
+        try {
+            re = new RegExp(pattern, input.case_insensitive ? 'i' : '');
+        }
+        catch (err) {
+            return { content: `Error: invalid regex: ${err.message}`, isError: true };
+        }
+        const globFilter = input.glob ? globToRegExp(String(input.glob)) : null;
+        const contentLines = [];
+        const fileMatches = [];
+        const counts = [];
+        let total = 0;
+        let truncated = false;
+        for await (const entry of walk(ctx.fs, root, { signal: ctx.signal })) {
+            if (entry.isDir)
+                continue;
+            if (globFilter && !globFilter.test(entry.path))
+                continue;
+            const full = root === '.' ? entry.path : joinPath(root, entry.path);
+            const text = await ctx.fs.readFile(full);
+            if (text === null || looksBinary(text))
+                continue;
+            const lines = text.split('\n');
+            let fileCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                if (re.test(lines[i])) {
+                    fileCount++;
+                    total++;
+                    if (mode === 'content' && contentLines.length < MAX_MATCHES) {
+                        contentLines.push(`${full}:${i + 1}:${lines[i]}`);
+                    }
+                    if (total >= MAX_MATCHES) {
+                        truncated = true;
+                        break;
+                    }
+                }
+            }
+            if (fileCount > 0) {
+                fileMatches.push(full);
+                counts.push({ path: full, count: fileCount });
+            }
+            if (truncated)
+                break;
+        }
+        if (total === 0) {
+            return { content: `No matches for /${pattern}/ under ${root}.` };
+        }
+        const note = truncated ? `\n\n[truncated at ${MAX_MATCHES} matches]` : '';
+        if (mode === 'content') {
+            return { content: contentLines.join('\n') + note };
+        }
+        if (mode === 'count') {
+            const body = counts.map((c) => `${c.path}:${c.count}`).join('\n');
+            return { content: body + note };
+        }
+        fileMatches.sort();
+        return { content: fileMatches.join('\n') + note };
+    },
+};

package/dist/tools/imageProcessor.d.ts

@@ -0,0 +1,15 @@
+export interface ProcessedImage {
+    /** Base64 payload (no `data:` prefix). */
+    data: string;
+    media_type: string;
+    width?: number;
+    height?: number;
+    /** Set when the image could not be downsampled (e.g. no canvas) but is oversized. */
+    note?: string;
+}
+/**
+ * Decode, optionally downscale (fit within MAX_DIMENSION, no enlargement) and
+ * re-encode an image so the result stays under `maxBytes`. Falls back to the
+ * original bytes when DOM imaging APIs are unavailable.
+ */
+export declare function processImage(bytes: Uint8Array, mediaType: string, maxBytes: number): Promise<ProcessedImage>;

package/dist/tools/imageProcessor.js

@@ -0,0 +1,83 @@
+// Browser-first image downsampling for read_file. Uses createImageBitmap +
+// OffscreenCanvas when available (browser / web worker); degrades gracefully in
+// Node-without-DOM by passing the image through unmodified. Never throws.
+import { bytesToBase64 } from './fileTypes.js';
+const MAX_DIMENSION = 2000;
+function canResize() {
+    return (typeof createImageBitmap === 'function' &&
+        typeof globalThis.OffscreenCanvas === 'function');
+}
+async function blobToBytes(blob) {
+    return new Uint8Array(await blob.arrayBuffer());
+}
+/**
+ * Decode, optionally downscale (fit within MAX_DIMENSION, no enlargement) and
+ * re-encode an image so the result stays under `maxBytes`. Falls back to the
+ * original bytes when DOM imaging APIs are unavailable.
+ */
+export async function processImage(bytes, mediaType, maxBytes) {
+    if (!canResize()) {
+        if (bytes.length <= maxBytes) {
+            return { data: bytesToBase64(bytes), media_type: mediaType };
+        }
+        return {
+            data: bytesToBase64(bytes),
+            media_type: mediaType,
+            note: `Image is ${(bytes.length / (1024 * 1024)).toFixed(1)} MB and could not be resized in this runtime (no canvas). It may exceed model limits.`,
+        };
+    }
+    try {
+        const OffscreenCanvasCtor = globalThis.OffscreenCanvas;
+        const srcBlob = new Blob([bytes], { type: mediaType });
+        const bitmap = await createImageBitmap(srcBlob);
+        const { width: ow, height: oh } = bitmap;
+        const needsResize = bytes.length > maxBytes || ow > MAX_DIMENSION || oh > MAX_DIMENSION;
+        if (!needsResize) {
+            bitmap.close?.();
+            return { data: bytesToBase64(bytes), media_type: mediaType, width: ow, height: oh };
+        }
+        // Keep alpha for PNG; otherwise prefer JPEG for better compression.
+        const keepPng = mediaType === 'image/png';
+        const outType = keepPng ? 'image/png' : 'image/jpeg';
+        let scale = Math.min(1, MAX_DIMENSION / Math.max(ow, oh));
+        let quality = 0.8;
+        let best = null;
+        for (let attempt = 0; attempt < 6; attempt++) {
+            const w = Math.max(1, Math.round(ow * scale));
+            const h = Math.max(1, Math.round(oh * scale));
+            const canvas = new OffscreenCanvasCtor(w, h);
+            const cctx = canvas.getContext('2d');
+            if (!cctx)
+                break;
+            cctx.drawImage(bitmap, 0, 0, w, h);
+            const outBlob = await canvas.convertToBlob(outType === 'image/jpeg' ? { type: outType, quality } : { type: outType });
+            const outBytes = await blobToBytes(outBlob);
+            best = { data: outBytes, w, h };
+            if (outBytes.length <= maxBytes)
+                break;
+            // Shrink further: drop quality first (jpeg), then scale.
+            if (outType === 'image/jpeg' && quality > 0.4)
+                quality -= 0.15;
+            else
+                scale *= 0.75;
+        }
+        bitmap.close?.();
+        if (best) {
+            return {
+                data: bytesToBase64(best.data),
+                media_type: outType,
+                width: best.w,
+                height: best.h,
+                note: best.data.length > maxBytes ? 'Image still exceeds the size cap after downsampling.' : undefined,
+            };
+        }
+    }
+    catch {
+        // fall through to pass-through below
+    }
+    return {
+        data: bytesToBase64(bytes),
+        media_type: mediaType,
+        note: bytes.length > maxBytes ? 'Image could not be resized; passed through at original size.' : undefined,
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,28 @@
+import type { ToolDef } from '../types/index.js';
+import { bash } from './bash.js';
+import { deleteFile } from './delete_file.js';
+import { editFile } from './edit_file.js';
+import { glob } from './glob.js';
+import { grep } from './grep.js';
+import { listFiles } from './list_files.js';
+import { multiEdit } from './multi_edit.js';
+import { notebookEdit } from './notebook_edit.js';
+import { readFile } from './read_file.js';
+import { todoWrite } from './todo_write.js';
+import type { Tool } from './types.js';
+import { webFetch } from './web_fetch.js';
+import { webSearch } from './web_search.js';
+import { toolSearch } from './tool_search.js';
+import { config } from './config.js';
+import { writeFile } from './write_file.js';
+export type { Tool, ToolContext, ToolResult, FileReadLimits } from './types.js';
+export { bash, readFile, writeFile, editFile, deleteFile, listFiles, glob, grep };
+export { multiEdit, notebookEdit, todoWrite, webFetch, webSearch, toolSearch, config };
+export { walk, globToRegExp, joinPath, DEFAULT_IGNORE } from './walk.js';
+export { defineTool, type DefineToolSpec } from './define.js';
+/** Every built-in Claude Code tool, ready to pass to `query()`. */
+export declare const ALL_CLAUDE_CODE_TOOLS: Tool[];
+/** Extract the OpenAI-shape definitions to send to the LLM. */
+export declare function toolDefs(tools: Tool[]): ToolDef[];
+/** Build a name→tool lookup for dispatching tool calls. */
+export declare function toolByName(tools: Tool[]): Map<string, Tool>;

package/dist/tools/index.js

@@ -0,0 +1,45 @@
+import { bash } from './bash.js';
+import { deleteFile } from './delete_file.js';
+import { editFile } from './edit_file.js';
+import { glob } from './glob.js';
+import { grep } from './grep.js';
+import { listFiles } from './list_files.js';
+import { multiEdit } from './multi_edit.js';
+import { notebookEdit } from './notebook_edit.js';
+import { readFile } from './read_file.js';
+import { todoWrite } from './todo_write.js';
+import { webFetch } from './web_fetch.js';
+import { webSearch } from './web_search.js';
+import { toolSearch } from './tool_search.js';
+import { config } from './config.js';
+import { writeFile } from './write_file.js';
+export { bash, readFile, writeFile, editFile, deleteFile, listFiles, glob, grep };
+export { multiEdit, notebookEdit, todoWrite, webFetch, webSearch, toolSearch, config };
+export { walk, globToRegExp, joinPath, DEFAULT_IGNORE } from './walk.js';
+export { defineTool } from './define.js';
+/** Every built-in Claude Code tool, ready to pass to `query()`. */
+export const ALL_CLAUDE_CODE_TOOLS = [
+    bash,
+    readFile,
+    writeFile,
+    editFile,
+    multiEdit,
+    deleteFile,
+    listFiles,
+    glob,
+    grep,
+    notebookEdit,
+    todoWrite,
+    webFetch,
+    webSearch,
+    toolSearch,
+    config,
+];
+/** Extract the OpenAI-shape definitions to send to the LLM. */
+export function toolDefs(tools) {
+    return tools.map((t) => t.def);
+}
+/** Build a name→tool lookup for dispatching tool calls. */
+export function toolByName(tools) {
+    return new Map(tools.map((t) => [t.def.function.name, t]));
+}

package/dist/tools/list_files.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const listFiles: Tool;

package/dist/tools/list_files.js

@@ -0,0 +1,42 @@
+const DESCRIPTION = `Lists the entries of a directory in the workspace.
+
+Returns a sorted listing with directories suffixed by \`/\`. Defaults to the workspace root.`;
+export const listFiles = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'list_files',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory to list (default ".").',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const path = input.path ? String(input.path) : '.';
+        const entries = await ctx.fs.readdir(path);
+        if (!entries) {
+            return { content: `Error: directory not found: ${path}`, isError: true };
+        }
+        if (entries.length === 0) {
+            return { content: `(empty directory: ${path})` };
+        }
+        // Directories first, then files; each group alphabetized.
+        const sorted = [...entries].sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        const listing = sorted
+            .map((e) => (e.isDir ? `${e.name}/` : e.name))
+            .join('\n');
+        return { content: listing };
+    },
+};

package/dist/tools/multi_edit.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare const multiEdit: Tool;

package/dist/tools/multi_edit.js

@@ -0,0 +1,112 @@
+const DESCRIPTION = `Applies multiple exact string replacements to a single file in one atomic operation.
+
+- You must read the file with read_file at least once before editing it; otherwise this tool errors.
+- Provide an ordered list of edits. Each edit is applied in sequence to the result of the previous one.
+- Each \`old_string\` must match the current file contents exactly (including whitespace) and must be unique unless that edit sets \`replace_all\`.
+- Edits are all-or-nothing: if any edit fails (not found, not unique, or identical strings), NO changes are written and the failing edit index is reported.
+- Prefer this over multiple edit_file calls when making several changes to the same file.`;
+/** Count non-overlapping occurrences of needle in haystack. */
+function countOccurrences(haystack, needle) {
+    if (needle === '')
+        return 0;
+    let count = 0;
+    let idx = haystack.indexOf(needle);
+    while (idx !== -1) {
+        count++;
+        idx = haystack.indexOf(needle, idx + needle.length);
+    }
+    return count;
+}
+export const multiEdit = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'multi_edit',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to edit.' },
+                    edits: {
+                        type: 'array',
+                        description: 'Ordered list of edits to apply sequentially and atomically.',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                old_string: { type: 'string', description: 'Exact text to find.' },
+                                new_string: {
+                                    type: 'string',
+                                    description: 'Replacement text (must differ from old_string).',
+                                },
+                                replace_all: {
+                                    type: 'boolean',
+                                    description: 'Replace every occurrence instead of requiring uniqueness.',
+                                },
+                            },
+                            required: ['old_string', 'new_string'],
+                        },
+                    },
+                },
+                required: ['path', 'edits'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const path = String(input.path ?? '');
+        if (!path)
+            return { content: 'Error: `path` is required.', isError: true };
+        if (!Array.isArray(input.edits) || input.edits.length === 0) {
+            return { content: 'Error: `edits` must be a non-empty array.', isError: true };
+        }
+        if (!ctx.readFiles.has(path)) {
+            return {
+                content: `Error: you must read ${path} with read_file before editing it.`,
+                isError: true,
+            };
+        }
+        const edits = input.edits;
+        const original = await ctx.fs.readFile(path);
+        if (original === null) {
+            return { content: `Error: file not found: ${path}`, isError: true };
+        }
+        let text = original;
+        for (let i = 0; i < edits.length; i++) {
+            const e = edits[i];
+            const oldString = typeof e?.old_string === 'string' ? e.old_string : '';
+            const newString = typeof e?.new_string === 'string' ? e.new_string : '';
+            const replaceAll = e?.replace_all === true;
+            if (oldString === newString) {
+                return {
+                    content: `Error: edit #${i + 1}: \`old_string\` and \`new_string\` are identical.`,
+                    isError: true,
+                };
+            }
+            const occurrences = countOccurrences(text, oldString);
+            if (occurrences === 0) {
+                return {
+                    content: `Error: edit #${i + 1}: \`old_string\` not found${i > 0 ? ' (after applying earlier edits)' : ''}.`,
+                    isError: true,
+                };
+            }
+            if (!replaceAll && occurrences > 1) {
+                return {
+                    content: `Error: edit #${i + 1}: \`old_string\` is not unique (found ${occurrences} occurrences). Provide more context or set replace_all: true.`,
+                    isError: true,
+                };
+            }
+            text = replaceAll
+                ? text.split(oldString).join(newString)
+                : text.replace(oldString, newString);
+        }
+        try {
+            await ctx.fs.writeFile(path, text);
+        }
+        catch (err) {
+            return {
+                content: `Error writing ${path}: ${err.message}`,
+                isError: true,
+            };
+        }
+        return { content: `Applied ${edits.length} edit${edits.length === 1 ? '' : 's'} to ${path}.` };
+    },
+};