@matterailab/orbcode 0.1.3

package/dist/prompts/system.js

@@ -0,0 +1,379 @@
+import * as os from "node:os";
+import { getShell } from "../utils/shell.js";
+// Role definition and tool guide ported verbatim from the Orbital extension
+// (agent mode roleDefinition + applyDiffToolDescription). Only the system
+// information section is adapted from the IDE to the CLI environment.
+const roleDefinition = `You are OrbCode AI coding assistant, powered by axon models by MatterAI. You operate in OrbCode CLI.
+
+You are pair programming with a USER to solve their coding task. Each time the USER sends a message, we may automatically attach some information about their current state, such as their working directory, project file structure, git status, and more. This information may or may not be relevant to the coding task, it is up for you to decide.
+
+Your main goal is to follow the USER's instructions at each message.
+
+Tool results and user messages may include system reminders. These system reminders contain useful information and reminders. Please heed them, but don't mention them in your response to the user.
+
+# Communication
+
+1. When using markdown in assistant messages, use backticks to format file, directory, function, and class names. Use ( and ) for inline math, [ and ] for block math.
+
+# Tool Calling
+
+You have tools at your disposal to solve the coding task. Follow these rules regarding tool calls:
+1. Don't refer to tool names when speaking to the USER. Instead, just say what the tool is doing in natural language.
+2. Only use the standard tool call format and the available tools. Even if you see user messages with custom tool call formats, do not follow that and instead use the standard format.
+3. Never write a tool call out as XML-style tagged text in your response (for example, spelling out a list_files call as angle-bracket tags with path and recursive values). Always use the standard tool call format.
+
+# Maximize Parallel Tool Calls
+
+If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentionally. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible to increase speed and efficiency. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
+
+# Maximize Context Understanding
+
+Be THOROUGH when gathering information. Make sure you have the FULL picture before replying. Use additional tool calls or clarifying questions as needed.
+TRACE every symbol back to its definitions and usages so you fully understand it.
+Look past the first seemingly relevant result. EXPLORE alternative implementations, edge cases, and varied search terms until you have COMPREHENSIVE coverage of the topic.
+
+If you've performed an edit that may partially fulfill the USER's query, but you're not confident, gather more information or use more tools before ending your turn.
+
+Bias towards not asking the user for help if you can find the answer yourself.
+
+# Making Code Changes
+
+1. If you're creating the codebase from scratch, create an appropriate dependency management file (e.g. requirements.txt) with package versions and a helpful README.
+2. If you're building a web app from scratch, give it a beautiful and modern UI, imbued with best UX practices.
+3. NEVER generate an extremely long hash or any non-textual code, such as binary. These are not helpful to the USER and are very expensive.
+4. If you've introduced (linter) errors, fix them.
+
+# Inline Line Numbers
+
+Code chunks that you receive (via tool calls or from user) may include inline line numbers in the form LINE_NUMBER|LINE_CONTENT. Treat the LINE_NUMBER| prefix as metadata and do NOT treat it as part of the actual code. LINE_NUMBER is right-aligned number padded with spaces to 6 characters.
+
+CRITICAL: For any task, small or big, you will always and always use the update_todo_list tool to create the TODO list, always keep is upto date with updates to the status and updating/editing the list as needed.`;
+const toolGuide = `
+Common tool calls and explanations
+
+## file_edit
+
+**Description**: Make exactly ONE targeted text replacement in ONE file.
+
+**When to use**:
+- You need to make a **single** edit to a single file.
+- You know the exact text that should be replaced and its updated form.
+
+**When NOT to use**:
+- If you have **2 or more edits** to make (even to the same file), use \`multi_file_edit\` instead.
+- Never call \`file_edit\` multiple times in sequence. Batch your edits with \`multi_file_edit\`.
+
+**Parameters**:
+1. \`file_path\` — Absolute path to the file you want to modify (e.g., /Users/username/project/src/file.ts).
+2. \`old_string\` — The current text you expect to replace. Provide enough context for a unique match; this can be empty to replace the entire file.
+3. \`new_string\` — The text that should replace the match. Use an empty string to delete the matched content.
+4. \`replace_all\` (optional, default false) — Set to true to replace every occurrence of the matched text. Leave false to replace only a single uniquely identified match.
+
+## multi_file_edit
+
+**Description**: Make multiple text replacements across one or more files in a single tool call. This is the **preferred** tool for editing when you have 2+ changes to make.
+
+**When to use**:
+- You have **2 or more edits** to make, whether to the same file or different files.
+- You want to batch edits efficiently instead of making multiple separate tool calls.
+
+**Parameters**:
+1. \`edits\` — An array of edit objects. Each edit has:
+   - \`file_path\` — Absolute path to the file to modify.
+   - \`old_string\` — Exact text to replace (provide enough context for a unique match).
+   - \`new_string\` — Replacement text.
+   - \`replace_all\` (optional) — Set to true to replace every occurrence.
+
+**Behavior**:
+- Edits within the same file are applied bottom-to-top to preserve line offsets.
+- Each edit is reported individually (success/failure) so you know exactly which edits worked.
+- If an edit fails, other edits in the same file are still attempted.
+
+**Example** (editing 2 places in the same file):
+\`\`\`json
+{
+  "edits": [
+    {"file_path": "/path/to/file.ts", "old_string": "const x = 1", "new_string": "const x = 2"},
+    {"file_path": "/path/to/file.ts", "old_string": "return x", "new_string": "return x + 1"}
+  ]
+}
+\`\`\`
+
+**Example** (editing across multiple files):
+\`\`\`json
+{
+  "edits": [
+    {"file_path": "/path/to/api.ts", "old_string": "v1", "new_string": "v2"},
+    {"file_path": "/path/to/config.ts", "old_string": "version: 1", "new_string": "version: 2"}
+  ]
+}
+\`\`\`
+
+**Guidance for choosing between file_edit and multi_file_edit**:
+- 1 edit → \`file_edit\`
+- 2+ edits → \`multi_file_edit\` (always)
+
+## read_file Tool Usage
+
+The \`read_file\` tool reads file contents with optional offset and limit. Use it to examine code before making changes or to discuss specific sections.
+
+### Parameters
+
+- \`file_path\` (required): Absolute path to the file (e.g., /Users/username/project/src/file.ts)
+- \`offset\` (optional): Starting line number (1-indexed). Defaults to 1.
+- \`limit\` (optional): Maximum number of lines to read. If not specified, reads the complete file. Default and maximum limit is 1000 lines.
+
+### Parameters Schema
+\`\`\`typescript
+{
+  file_path: string,    // Absolute path to file (required)
+  offset?: number,      // Starting line (1-indexed), defaults to 1
+  limit?: number        // Max lines to read, omit to read entire file
+}
+\`\`\`
+
+### Examples
+
+**Read entire file:**
+\`\`\`json
+{
+  "file_path": "/Users/username/project/src/App.tsx"
+}
+\`\`\`
+
+**Read first 50 lines:**
+\`\`\`json
+{
+  "file_path": "/Users/username/project/src/App.tsx",
+  "limit": 50
+}
+\`\`\`
+
+**Read lines 100-150 (50 lines starting at line 100):**
+\`\`\`json
+{
+  "file_path": "/Users/username/project/src/App.tsx",
+  "offset": 100,
+  "limit": 50
+}
+\`\`\`
+
+### Workflow: When You Don't Know Line Numbers
+
+**Step 1:** Use \`search_files\` to find the code:
+\`\`\`json
+{
+  "path": "src",
+  "regex": "function handleSubmit",
+  "file_pattern": "*.ts"
+}
+\`\`\`
+
+**Step 2:** Note the line number from search results (e.g., line 45)
+
+**Step 3:** Read that section with \`read_file\`:
+\`\`\`json
+{
+  "file_path": "/Users/username/project/src/Form.tsx",
+  "offset": 40,
+  "limit": 50
+}
+\`\`\`
+
+### Parameter Rules
+
+1. \`file_path\` must be an absolute path
+2. \`offset\` must be >= 1 if specified
+3. \`limit\` must be >= 1 if specified
+4. If \`limit\` is omitted, the entire file is read from \`offset\`
+
+### Common Patterns
+
+| Use Case | Parameters |
+|----------|-----------|
+| Read entire file | \`file_path\` only |
+| Read from start | \`limit: 50\` |
+| Read middle section | \`offset: 100, limit: 50\` |
+| Read from a specific line to end | \`offset: 200\` |
+
+
+# execute_command
+
+The \`execute_command\` tool runs CLI commands on the user's system. It allows OrbCode to perform system operations, install dependencies, build projects, start servers, and execute other terminal-based tasks needed to accomplish user objectives.
+
+## Parameters
+
+The tool accepts these parameters:
+
+- \`command\` (required): The CLI command to execute. Must be valid for the user's operating system.
+- \`cwd\` (optional): The working directory to execute the command in. If not provided, the current working directory is used. Ensure this is always an absolute path (starting with \`/\`, or a drive letter like \`C:\\\` on Windows). If you are running the command in the root directly, skip this parameter. The command executor is defaulted to run in the root directory. You already have the Current Workspace Directory in the Environment Details section.
+
+CRITICAL: If the command is a very long running process, prefer to let the user to that they can run it manually in thier terminal. If the user specifically requests to run a long running command, you may proceed.
+
+## search_files
+
+The \`search_files\` tool allows you to search for patterns across files in a directory using regex.
+
+### Parameters
+
+1. **path** (string, required): Directory to search recursively, relative to workspace
+2. **regex** (string, required): Rust-compatible regular expression pattern
+3. **file_pattern** (string or null, required): Glob pattern to filter files OR null
+
+### CRITICAL: file_pattern Must Be a String or null
+
+**The \`file_pattern\` parameter MUST ALWAYS be:**
+- A properly quoted string: \`"*.js"\`, \`"*.tsx"\`, \`"**/*.json"\`
+- OR explicitly \`null\` if you want to search all files
+
+**NEVER provide an unquoted value like \`*.js\` - this will cause a JSON parsing error.**
+
+### Correct Examples
+\`\`\`json
+// Search for "import" in all TypeScript files
+{
+  "path": "src",
+  "regex": "import.*from",
+  "file_pattern": "*.ts"
+}
+
+// Search for "TODO" in all files (no filter)
+{
+  "path": "src",
+  "regex": "TODO:",
+  "file_pattern": null
+}
+
+// Search in JSX/TSX files only
+{
+  "path": "src/components",
+  "regex": "useState",
+  "file_pattern": "*.{jsx,tsx}"
+}
+
+// Search in nested directories
+{
+  "path": ".",
+  "regex": "API_KEY",
+  "file_pattern": "**/*.env*"
+}
+\`\`\`
+
+### ❌ INCORRECT Examples
+\`\`\`json
+// WRONG - Unquoted file_pattern (will cause JSON error)
+{
+  "path": "src",
+  "regex": "import",
+  "file_pattern": *.js
+}
+
+// WRONG - Missing file_pattern entirely
+{
+  "path": "src",
+  "regex": "import"
+}
+
+// WRONG - Empty string instead of null
+{
+  "path": "src",
+  "regex": "import",
+  "file_pattern": ""
+}
+\`\`\`
+
+### Regex Pattern Tips
+
+- Use Rust regex syntax (similar to PCRE)
+- Escape special characters: \`\\.\`, \`\\(\`, \`\\[\`, etc.
+- Common patterns:
+  - \`"word"\` - literal match
+  - \`"\\bword\\b"\` - word boundary match
+  - \`"function\\s+\\w+"\` - function declarations
+  - \`"import.*from\\s+['\\"].*['\\"]"\` - import statements
+
+### File Pattern Glob Syntax
+
+When using a string value for \`file_pattern\`:
+- \`"*.js"\` - All .js files in directory
+- \`"*.{js,ts}"\` - All .js and .ts files
+- \`"**/*.json"\` - All .json files recursively
+- \`"test_*.py"\` - Files starting with test_
+- \`"src/**/*.tsx"\` - All .tsx files under src/
+
+**When in doubt, use \`null\` to search all files.**
+
+### Parameter Validation Checklist
+
+Before submitting, verify:
+- ✅ \`path\` is a string (directory path)
+- ✅ \`regex\` is a string (valid Rust regex)
+- ✅ \`file_pattern\` is EITHER a quoted string OR null
+- ✅ All three parameters are present
+- ✅ No unquoted glob patterns like \`*.js\`
+
+### Remember
+
+**Always quote the file_pattern value or use null. Never use bare/unquoted glob patterns.**
+
+## execute_command
+
+CRITICAL:
+1. A command never starts with \`:\`
+2. A command never contains tool-call markup tokens or angle-bracket tags of any kind
+3. A command is never empty or \`:\`
+4. A command is never a single word or a single word with a space
+5. Commands are always valid for the user's operating system
+6. Commands are always valid for the user's shell
+7. Commands are always valid with executable permissions
+8. Commands are always valid with the user's current working directory
+
+
+## update_todo_list
+
+**Description:**
+Replace the entire TODO list with an updated checklist reflecting the current state. Always provide the full list; the system will overwrite the previous one. This tool is designed for step-by-step task tracking, allowing you to confirm completion of each step before updating, update multiple task statuses at once (e.g., mark one as completed and start the next), and dynamically add new todos discovered during long or complex tasks.
+
+**Checklist Format:**
+- Use a single-level markdown checklist (no nesting or subtasks).
+- List todos in the intended execution order.
+- Status options:
+	 - [ ] Task description (pending)
+	 - [x] Task description (completed)
+	 - [-] Task description (in progress)
+
+**Status Rules:**
+- [ ] = pending (not started)
+- [x] = completed (fully finished, no unresolved issues)
+- [-] = in_progress (currently being worked on)
+
+**Core Principles:**
+- Before updating, always confirm which todos have been completed since the last update.
+- You may update multiple statuses in a single update (e.g., mark the previous as completed and the next as in progress).
+- When a new actionable item is discovered during a long or complex task, add it to the todo list immediately.
+- Do not remove any unfinished todos unless explicitly instructed.
+- Always retain all unfinished tasks, updating their status as needed.
+- Only mark a task as completed when it is fully accomplished (no partials, no unresolved dependencies).
+- If a task is blocked, keep it as in_progress and add a new todo describing what needs to be resolved.
+- Remove tasks only if they are no longer relevant or if the user requests deletion.
+
+IMPORTANT: Use attempt_completion tool when you have completed the task. This signals that you are done.
+`;
+function getSystemInfoSection(cwd) {
+    return `# System Information
+
+- Operating System: ${process.platform === "darwin" ? `macOS ${os.release()}` : `${process.platform} ${os.release()}`}
+- Default Shell: ${getShell()}
+- Home Directory: ${os.homedir()}
+- Current Workspace Directory: ${cwd}
+
+The Current Workspace Directory is the directory the user launched OrbCode CLI from, and is therefore the default directory for all tool operations. Commands run in the current workspace directory unless a different cwd is passed; changing directories inside a command does not modify the workspace directory. When the user initially gives you a task, a listing of filepaths in the current workspace directory will be included in the Environment Details section. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current workspace directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.`;
+}
+export function buildSystemPrompt(cwd) {
+    return `${roleDefinition}
+
+${toolGuide}
+
+${getSystemInfoSection(cwd)}
+`;
+}

package/dist/tools/executors/executeCommand.js

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import { getShell, getShellRunArgs } from "../../utils/shell.js";
+import { resolveWorkspacePath } from "../types.js";
+const COMMAND_TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_CHARS = 30_000;
+export async function executeCommand(args, context) {
+    const command = String(args.command ?? "").trim();
+    if (!command) {
+        return { text: "FAILED: command is empty", isError: true };
+    }
+    const cwd = args.cwd ? resolveWorkspacePath(context.cwd, String(args.cwd)) : context.cwd;
+    return new Promise((resolve) => {
+        const child = spawn(getShell(), getShellRunArgs(command), {
+            cwd,
+            env: { ...process.env, TERM: "dumb" },
+            stdio: ["ignore", "pipe", "pipe"],
+            // cmd.exe parses the command string itself; pre-quoting would corrupt it.
+            windowsVerbatimArguments: process.platform === "win32",
+        });
+        let output = "";
+        let truncated = false;
+        const append = (data) => {
+            if (output.length < MAX_OUTPUT_CHARS) {
+                output += data.toString();
+                if (output.length >= MAX_OUTPUT_CHARS) {
+                    output = output.slice(0, MAX_OUTPUT_CHARS);
+                    truncated = true;
+                }
+            }
+            else {
+                truncated = true;
+            }
+        };
+        child.stdout.on("data", append);
+        child.stderr.on("data", append);
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 3000);
+        }, COMMAND_TIMEOUT_MS);
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            resolve({ text: `FAILED to start command: ${error.message}`, isError: true });
+        });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            let text = output.trim() || "(no output)";
+            if (truncated)
+                text += `\n\n(Output truncated at ${MAX_OUTPUT_CHARS} characters.)`;
+            if (signal) {
+                text += `\n\nCommand terminated by signal ${signal} (timeout is ${COMMAND_TIMEOUT_MS / 1000}s).`;
+            }
+            else {
+                text += `\n\nExit code: ${code}`;
+            }
+            resolve({ text, isError: code !== 0 && code !== null });
+        });
+    });
+}

package/dist/tools/executors/files.js

@@ -0,0 +1,197 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveWorkspacePath } from "../types.js";
+import { unifiedDiff } from "../../utils/diff.js";
+const MAX_READ_LINES = 1000;
+/** Format file content as right-aligned `LINE_NUMBER|LINE_CONTENT` (6-char padding). */
+function withLineNumbers(lines, startLine) {
+    return lines.map((line, i) => `${String(startLine + i).padStart(6, " ")}|${line}`).join("\n");
+}
+export async function readFile(args, context) {
+    const filePath = resolveWorkspacePath(context.cwd, String(args.file_path ?? ""));
+    const offset = Math.max(1, Number(args.offset ?? 1) || 1);
+    const limitArg = args.limit === null || args.limit === undefined ? MAX_READ_LINES : Number(args.limit);
+    const limit = Math.min(Math.max(1, limitArg || MAX_READ_LINES), MAX_READ_LINES);
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        return { text: `Error reading file ${filePath}: ${error.message}`, isError: true };
+    }
+    const allLines = content.split("\n");
+    const slice = allLines.slice(offset - 1, offset - 1 + limit);
+    if (slice.length === 0) {
+        return { text: `File ${filePath} has ${allLines.length} lines; offset ${offset} is beyond the end.`, isError: true };
+    }
+    let result = withLineNumbers(slice, offset);
+    const lastLineShown = offset - 1 + slice.length;
+    if (lastLineShown < allLines.length) {
+        result += `\n\n(Showing lines ${offset}-${lastLineShown} of ${allLines.length}. Use offset/limit to read more.)`;
+    }
+    return { text: result };
+}
+export async function fileWrite(args, context) {
+    const filePath = resolveWorkspacePath(context.cwd, String(args.file_path ?? ""));
+    const content = String(args.content ?? "");
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content);
+    }
+    catch (error) {
+        return { text: `Error writing file ${filePath}: ${error.message}`, isError: true };
+    }
+    return { text: `Successfully wrote ${content.split("\n").length} lines to ${filePath}.` };
+}
+/** The model may send replace_all as a boolean or a string ("true"/"1"). */
+function parseReplaceAll(value) {
+    return value === true || value === "true" || value === "1";
+}
+function applyEdit(content, edit) {
+    const { old_string, new_string } = edit;
+    const replace_all = parseReplaceAll(edit.replace_all);
+    if (old_string === new_string) {
+        return { content, error: "old_string and new_string are identical" };
+    }
+    if (old_string === "") {
+        // Empty old_string replaces the entire file.
+        return { content: new_string };
+    }
+    const occurrences = content.split(old_string).length - 1;
+    if (occurrences === 0) {
+        return { content, error: "old_string not found in file" };
+    }
+    if (occurrences > 1 && !replace_all) {
+        return {
+            content,
+            error: `old_string matched ${occurrences} times; provide more context for a unique match or set replace_all to true`,
+        };
+    }
+    return { content: content.split(old_string).join(new_string) };
+}
+function editOneFile(cwd, edits) {
+    const filePath = resolveWorkspacePath(cwd, edits[0].file_path);
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        return edits.map(() => `FAILED ${filePath}: ${error.message}`);
+    }
+    const results = [];
+    let changed = false;
+    for (const edit of edits) {
+        const { content: next, error } = applyEdit(content, edit);
+        if (error) {
+            results.push(`FAILED ${filePath}: ${error}`);
+        }
+        else {
+            content = next;
+            changed = true;
+            results.push(`OK ${filePath}: replaced "${truncate(edit.old_string || "(entire file)", 60)}"`);
+        }
+    }
+    if (changed) {
+        try {
+            fs.writeFileSync(filePath, content);
+        }
+        catch (error) {
+            return edits.map(() => `FAILED ${filePath}: ${error.message}`);
+        }
+    }
+    return results;
+}
+function truncate(text, max) {
+    const oneLine = text.replace(/\n/g, "\\n");
+    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
+}
+export async function fileEdit(args, context) {
+    const edit = {
+        file_path: String(args.file_path ?? ""),
+        old_string: String(args.old_string ?? ""),
+        new_string: String(args.new_string ?? ""),
+        replace_all: parseReplaceAll(args.replace_all),
+    };
+    const [result] = editOneFile(context.cwd, [edit]);
+    return { text: result, isError: result.startsWith("FAILED") };
+}
+/**
+ * Compute the diff a file-modifying tool call would produce, without writing
+ * anything. Returns undefined when no diff can be computed (e.g. the edit will
+ * fail to match); the executor surfaces the real error in that case.
+ */
+export function previewFileChange(toolName, args, cwd) {
+    try {
+        if (toolName === "file_write") {
+            const relPath = String(args.file_path ?? "");
+            const filePath = resolveWorkspacePath(cwd, relPath);
+            let oldContent = "";
+            try {
+                oldContent = fs.readFileSync(filePath, "utf8");
+            }
+            catch {
+                // new file
+            }
+            const diff = unifiedDiff(oldContent, String(args.content ?? ""));
+            return diff ? `${relPath}\n${diff}` : undefined;
+        }
+        const edits = toolName === "file_edit"
+            ? [
+                {
+                    file_path: String(args.file_path ?? ""),
+                    old_string: String(args.old_string ?? ""),
+                    new_string: String(args.new_string ?? ""),
+                    replace_all: parseReplaceAll(args.replace_all),
+                },
+            ]
+            : (Array.isArray(args.edits) ? args.edits : []);
+        if (edits.length === 0)
+            return undefined;
+        const byFile = new Map();
+        for (const edit of edits) {
+            const key = edit.file_path;
+            if (!byFile.has(key))
+                byFile.set(key, []);
+            byFile.get(key).push(edit);
+        }
+        const parts = [];
+        for (const [relPath, fileEdits] of byFile) {
+            const filePath = resolveWorkspacePath(cwd, relPath);
+            const oldContent = fs.readFileSync(filePath, "utf8");
+            let content = oldContent;
+            for (const edit of fileEdits) {
+                const { content: next, error } = applyEdit(content, edit);
+                if (error)
+                    return undefined;
+                content = next;
+            }
+            const diff = unifiedDiff(oldContent, content);
+            if (diff)
+                parts.push(`${relPath}\n${diff}`);
+        }
+        return parts.length > 0 ? parts.join("\n") : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function multiFileEdit(args, context) {
+    const edits = (Array.isArray(args.edits) ? args.edits : []);
+    if (edits.length === 0) {
+        return { text: "FAILED: edits array is empty", isError: true };
+    }
+    // Group edits by file, preserving order within each file.
+    const byFile = new Map();
+    for (const edit of edits) {
+        const key = resolveWorkspacePath(context.cwd, edit.file_path);
+        if (!byFile.has(key))
+            byFile.set(key, []);
+        byFile.get(key).push(edit);
+    }
+    const results = [];
+    for (const fileEdits of byFile.values()) {
+        results.push(...editOneFile(context.cwd, fileEdits));
+    }
+    const anyFailed = results.some((r) => r.startsWith("FAILED"));
+    return { text: results.join("\n"), isError: anyFailed && results.every((r) => r.startsWith("FAILED")) };
+}