@useactor/core 0.1.0 → 0.2.3

package/dist/tools/local-tools.js

@@ -0,0 +1,944 @@
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { rgPath } from "@vscode/ripgrep";
+const listFilesOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["files", "truncated"],
+    properties: {
+        files: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["name", "relativePath", "kind", "size", "mtimeMs"],
+                properties: {
+                    name: { type: "string" },
+                    relativePath: { type: "string" },
+                    kind: { type: "string", enum: ["directory", "file"] },
+                    size: { type: "number" },
+                    mtimeMs: { type: "number" },
+                },
+            },
+        },
+        truncated: { type: "boolean" },
+    },
+};
+const readFileOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["content", "relativePath", "offset", "lineCount", "truncated"],
+    properties: {
+        content: { type: "string" },
+        relativePath: { type: "string" },
+        offset: { type: "number" },
+        lineCount: { type: "number" },
+        truncated: { type: "boolean" },
+        nextOffset: { type: "number" },
+    },
+};
+const searchOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["matches", "truncated"],
+    properties: {
+        matches: {
+            type: "array",
+            items: { type: "string" },
+        },
+        truncated: { type: "boolean" },
+    },
+};
+const globOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["files", "truncated"],
+    properties: {
+        files: {
+            type: "array",
+            items: { type: "string" },
+        },
+        truncated: { type: "boolean" },
+    },
+};
+const writeFileOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["relativePath"],
+    properties: {
+        relativePath: { type: "string" },
+    },
+};
+const editFileOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["relativePath", "changed", "diff", "additions", "deletions", "replacements"],
+    properties: {
+        relativePath: { type: "string" },
+        changed: { type: "boolean" },
+        diff: { type: "string" },
+        additions: { type: "number" },
+        deletions: { type: "number" },
+        replacements: { type: "number" },
+    },
+};
+const bashOutputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["stdout", "stderr", "exitCode", "risk", "sandboxProfile", "workdir"],
+    properties: {
+        stdout: { type: "string" },
+        stderr: { type: "string" },
+        exitCode: { type: "number" },
+        risk: { type: "string", enum: ["normal", "destructive"] },
+        sandboxProfile: {
+            type: "string",
+            enum: ["read-only", "workspace-write", "network", "external-write", "destructive"],
+        },
+        workdir: { type: "string" },
+    },
+};
+export class PathGuardError extends Error {
+    code = "path_outside_root";
+}
+export async function resolveSafePath(root, requestedPath = ".") {
+    const rootPath = path.resolve(root.rootPath);
+    const absolutePath = path.resolve(rootPath, requestedPath);
+    if (!isWithin(rootPath, absolutePath))
+        throw new PathGuardError("Path escapes approved root.");
+    const rootRealPath = await realpath(rootPath);
+    const existingPath = await nearestExistingPath(absolutePath);
+    const existingRealPath = await realpath(existingPath);
+    if (!isWithin(rootRealPath, existingRealPath))
+        throw new PathGuardError("Path escapes approved root.");
+    return {
+        rootPath,
+        absolutePath,
+        relativePath: path.relative(rootPath, absolutePath) || ".",
+    };
+}
+export async function resolveReadablePath(root, requestedPath = ".") {
+    const rootPath = path.resolve(root.rootPath);
+    const absolutePath = path.resolve(rootPath, requestedPath);
+    const existingPath = await nearestExistingPath(absolutePath);
+    await realpath(existingPath);
+    return {
+        rootPath,
+        absolutePath,
+        relativePath: displayPath(rootPath, absolutePath),
+    };
+}
+export async function listFiles(input) {
+    const safePath = await resolveReadablePath(input, input.path);
+    const entries = await readdir(safePath.absolutePath, { withFileTypes: true });
+    const limit = input.limit ?? 200;
+    const files = await Promise.all(entries.slice(0, limit).map(async (entry) => {
+        const absolutePath = path.join(safePath.absolutePath, entry.name);
+        const info = await stat(absolutePath);
+        return {
+            name: entry.name,
+            relativePath: displayPath(safePath.rootPath, absolutePath),
+            kind: entry.isDirectory() ? "directory" : "file",
+            size: info.size,
+            mtimeMs: info.mtimeMs,
+        };
+    }));
+    return { files, truncated: entries.length > limit };
+}
+export function createListFilesTool(options = {}) {
+    return {
+        id: options.id ?? "list_files",
+        name: "List files",
+        description: "List local files and folders. Reads are allowed outside the project root when the OS allows them.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Directory to list. Omit to list the project root.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum entries to return. Omit to use the default limit of 200.",
+                },
+            },
+        },
+        outputSchema: listFilesOutputSchema,
+        permissionPolicy: "never",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const requestedPath = optionalString(input, "path");
+            const limit = optionalNumber(input, "limit");
+            const result = await listFiles({
+                rootPath,
+                ...(requestedPath !== undefined ? { path: requestedPath } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            });
+            return jsonToolResult(result);
+        },
+    };
+}
+export async function readTextFile(input) {
+    const maxBytes = input.maxBytes ?? 256_000;
+    const raw = await readRawTextFile({ ...input, maxBytes });
+    const offset = input.offset ?? 1;
+    const limit = input.limit ?? 2_000;
+    if (offset < 1)
+        throw new Error("offset must be at least 1.");
+    if (limit < 0)
+        throw new Error("limit must be at least 0.");
+    const lines = splitTextLines(raw.content);
+    const startIndex = offset - 1;
+    const selectedLines = lines.slice(startIndex, startIndex + limit);
+    const numberedContent = selectedLines
+        .map((line, index) => `${offset + index}: ${line}`)
+        .join("\n");
+    if (Buffer.byteLength(numberedContent, "utf8") > maxBytes) {
+        throw new Error("File is too large to read.");
+    }
+    const nextOffset = offset + selectedLines.length;
+    const truncated = nextOffset <= lines.length;
+    return {
+        content: numberedContent,
+        relativePath: raw.relativePath,
+        offset,
+        lineCount: selectedLines.length,
+        truncated,
+        ...(truncated ? { nextOffset } : {}),
+    };
+}
+async function readRawTextFile(input) {
+    const safePath = await resolveReadablePath(input, input.path);
+    if (input.maxBytes !== undefined) {
+        const info = await stat(safePath.absolutePath);
+        if (info.size > input.maxBytes)
+            throw new Error("File is too large to read.");
+    }
+    const buffer = await readFile(safePath.absolutePath);
+    if (buffer.includes(0))
+        throw new Error("Binary files are not supported.");
+    return {
+        content: buffer.toString("utf8"),
+        relativePath: safePath.relativePath,
+    };
+}
+export function createReadFileTool(options = {}) {
+    return {
+        id: options.id ?? "read_file",
+        name: "Read file",
+        description: "Read a local text file. Reads are allowed outside the project root when the OS allows them.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path"],
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Text file path to read. Relative paths resolve from the project root.",
+                },
+                offset: {
+                    type: "number",
+                    description: "1-indexed line number to start reading from. Omit to start at line 1.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum lines to return. Omit to use the default limit of 2000.",
+                },
+                maxBytes: {
+                    type: "number",
+                    description: "Maximum file bytes to read. Omit to use the default cap of 256000.",
+                },
+            },
+        },
+        outputSchema: readFileOutputSchema,
+        permissionPolicy: "never",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const filePath = requiredString(input, "path");
+            const offset = optionalNumber(input, "offset");
+            const limit = optionalNumber(input, "limit");
+            const maxBytes = optionalNumber(input, "maxBytes");
+            const result = await readTextFile({
+                rootPath,
+                path: filePath,
+                ...(offset !== undefined ? { offset } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+                ...(maxBytes !== undefined ? { maxBytes } : {}),
+            });
+            return jsonToolResult(result);
+        },
+    };
+}
+export async function writeTextFile(input) {
+    const safePath = await resolveSafePath(input, input.path);
+    await mkdir(path.dirname(safePath.absolutePath), { recursive: true });
+    await writeFile(safePath.absolutePath, input.content, "utf8");
+    return { relativePath: safePath.relativePath };
+}
+export function createWriteFileTool(options = {}) {
+    return {
+        id: options.id ?? "write_file",
+        name: "Write file",
+        description: "Create or overwrite a text file inside the approved project folder.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path", "content"],
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Destination file path inside the approved project folder.",
+                },
+                content: {
+                    type: "string",
+                    description: "Full UTF-8 text content to write to the destination file.",
+                },
+            },
+        },
+        outputSchema: writeFileOutputSchema,
+        permissionPolicy: "on-request",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const filePath = requiredString(input, "path");
+            const content = requiredString(input, "content");
+            const result = await writeTextFile({ rootPath, path: filePath, content });
+            return jsonToolResult(result, {
+                artifactKind: "local_file",
+                artifactPath: result.relativePath,
+                bytes: Buffer.byteLength(content, "utf8"),
+            });
+        },
+    };
+}
+export async function editTextFile(input) {
+    await resolveSafePath(input, input.path);
+    const current = await readRawTextFile(input);
+    const matches = countOccurrences(current.content, input.search);
+    if (matches === 0)
+        throw new Error("Search text was not found.");
+    if (matches > 1 && !input.replaceAll) {
+        throw new Error("Search text matched multiple times. Use replaceAll to replace all matches.");
+    }
+    const next = input.replaceAll
+        ? current.content.split(input.search).join(input.replace)
+        : current.content.replace(input.search, input.replace);
+    await writeTextFile({ ...input, content: next });
+    const diff = createUnifiedDiff({
+        path: current.relativePath,
+        before: current.content,
+        after: next,
+    });
+    return {
+        relativePath: current.relativePath,
+        changed: current.content !== next,
+        diff: diff.patch,
+        additions: diff.additions,
+        deletions: diff.deletions,
+        replacements: input.replaceAll ? matches : 1,
+    };
+}
+export function createEditFileTool(options = {}) {
+    return {
+        id: options.id ?? "edit_file",
+        name: "Edit file",
+        description: "Replace text in a file inside the approved project folder.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path", "search", "replace"],
+            properties: {
+                path: {
+                    type: "string",
+                    description: "File path inside the approved project folder to edit.",
+                },
+                search: {
+                    type: "string",
+                    description: "Exact text to replace. It must appear in the file.",
+                },
+                replace: {
+                    type: "string",
+                    description: "Replacement text to insert in place of the search text.",
+                },
+                replaceAll: {
+                    type: "boolean",
+                    description: "Set true to replace every occurrence when search matches multiple times.",
+                },
+            },
+        },
+        outputSchema: editFileOutputSchema,
+        permissionPolicy: "on-request",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const replaceAll = optionalBoolean(input, "replaceAll");
+            const result = await editTextFile({
+                rootPath,
+                path: requiredString(input, "path"),
+                search: requiredString(input, "search"),
+                replace: requiredString(input, "replace"),
+                ...(replaceAll !== undefined ? { replaceAll } : {}),
+            });
+            return jsonToolResult(result, {
+                artifactKind: "local_file",
+                artifactPath: result.relativePath,
+                changed: result.changed,
+                file: result.relativePath,
+                diff: result.diff,
+                additions: result.additions,
+                deletions: result.deletions,
+                replacements: result.replacements,
+            });
+        },
+    };
+}
+export async function applyUnifiedPatch(input) {
+    const safeRoot = await resolveSafePath(input, ".");
+    const changedPaths = parseUnifiedPatchPaths(input.patch);
+    if (changedPaths.length === 0) {
+        throw new Error("Patch does not contain any file changes.");
+    }
+    await Promise.all(changedPaths.map((changedPath) => resolveSafePath(input, changedPath)));
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "actor-patch-"));
+    const patchPath = path.join(tempDir, "change.patch");
+    const exec = input.exec ?? execFileAsync;
+    try {
+        await writeFile(patchPath, input.patch, "utf8");
+        await exec("git", ["apply", "--whitespace=nowarn", patchPath], {
+            cwd: safeRoot.rootPath,
+            timeout: 10_000,
+            maxBuffer: 256_000,
+        });
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    return { changedPaths };
+}
+export function createApplyPatchTool(options = {}) {
+    return {
+        id: options.id ?? "apply_patch",
+        name: "Apply patch",
+        description: "Apply a unified diff patch inside the approved project folder. Use for structured multi-line file edits.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["patch"],
+            properties: {
+                patch: {
+                    type: "string",
+                    description: "Unified diff patch to apply inside the approved project folder.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const result = await applyUnifiedPatch({
+                rootPath,
+                patch: requiredString(input, "patch"),
+            });
+            return jsonToolResult(result, {
+                artifactKind: "local_patch",
+                changedPaths: result.changedPaths,
+            });
+        },
+    };
+}
+export async function ripgrepSearch(input) {
+    const safePath = await resolveReadablePath(input, input.path);
+    const exec = input.exec ?? execFileAsync;
+    try {
+        const result = await exec(rgPath, ["--line-number", "--color", "never", input.query, safePath.relativePath], {
+            cwd: safePath.rootPath,
+            timeout: 5_000,
+            maxBuffer: 256_000,
+        });
+        const lines = result.stdout.split("\n").filter(Boolean);
+        const limit = input.limit ?? 200;
+        return { matches: lines.slice(0, limit), truncated: lines.length > limit };
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error &&
+            "code" in error &&
+            error.code === 1) {
+            return { matches: [], truncated: false };
+        }
+        throw error;
+    }
+}
+export function createRipgrepTool(options = {}) {
+    return {
+        id: options.id ?? "ripgrep",
+        name: "Search files",
+        description: "Search local files with ripgrep. Reads are allowed outside the project root when the OS allows them.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["query"],
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Ripgrep search pattern or literal text to find.",
+                },
+                path: {
+                    type: "string",
+                    description: "Directory or file to search. Omit to search the project root.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum matches to return. Omit to use the default limit of 200.",
+                },
+            },
+        },
+        outputSchema: searchOutputSchema,
+        permissionPolicy: "never",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const requestedPath = optionalString(input, "path");
+            const limit = optionalNumber(input, "limit");
+            const result = await ripgrepSearch({
+                rootPath,
+                query: requiredString(input, "query"),
+                ...(requestedPath !== undefined ? { path: requestedPath } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            });
+            return jsonToolResult(result);
+        },
+    };
+}
+export async function globFiles(input) {
+    const safePath = await resolveReadablePath(input, input.path);
+    const exec = input.exec ?? execFileAsync;
+    try {
+        const result = await exec(rgPath, ["--files", "-g", input.pattern, safePath.relativePath], {
+            cwd: safePath.rootPath,
+            timeout: 5_000,
+            maxBuffer: 256_000,
+        });
+        const files = result.stdout.split("\n").filter(Boolean);
+        const limit = input.limit ?? 200;
+        return { files: files.slice(0, limit), truncated: files.length > limit };
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error &&
+            "code" in error &&
+            error.code === 1) {
+            return { files: [], truncated: false };
+        }
+        throw error;
+    }
+}
+export function createGlobTool(options = {}) {
+    return {
+        id: options.id ?? "glob",
+        name: "Find files",
+        description: "Find local files by glob pattern. Reads are allowed outside the project root when the OS allows them.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["pattern"],
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Glob pattern for file paths, for example **/*.ts.",
+                },
+                path: {
+                    type: "string",
+                    description: "Directory to search within. Omit to search the project root.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum file paths to return. Omit to use the default limit of 200.",
+                },
+            },
+        },
+        outputSchema: globOutputSchema,
+        permissionPolicy: "never",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const requestedPath = optionalString(input, "path");
+            const limit = optionalNumber(input, "limit");
+            const result = await globFiles({
+                rootPath,
+                pattern: requiredString(input, "pattern"),
+                ...(requestedPath !== undefined ? { path: requestedPath } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            });
+            return jsonToolResult(result);
+        },
+    };
+}
+export async function runBashCommand(input) {
+    const safePath = await resolveSafePath(input, input.workdir);
+    const exec = input.exec ?? execFileAsync;
+    let result;
+    try {
+        const success = await exec("bash", ["-lc", input.command], {
+            cwd: safePath.absolutePath,
+            timeout: input.timeoutMs ?? 10_000,
+            maxBuffer: 256_000,
+        });
+        result = { stdout: success.stdout, stderr: success.stderr, exitCode: 0 };
+    }
+    catch (error) {
+        if (!isExecError(error))
+            throw error;
+        result = {
+            stdout: error.stdout ?? "",
+            stderr: error.stderr ?? "",
+            exitCode: typeof error.code === "number" ? error.code : 1,
+        };
+    }
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        risk: classifyDestructiveCommand(input.command),
+        sandboxProfile: classifyShellSandboxProfile(input.command),
+        workdir: safePath.relativePath,
+    };
+}
+export function createBashTool(options = {}) {
+    return {
+        id: "bash",
+        name: "Run shell command",
+        description: "Run a shell command inside the approved project folder.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["command"],
+            properties: {
+                command: {
+                    type: "string",
+                    description: "Shell command to run from the approved project folder.",
+                },
+                workdir: {
+                    type: "string",
+                    description: "Working directory inside the approved project folder. Omit to use the project root.",
+                },
+                description: {
+                    type: "string",
+                    description: "Human-readable 5 to 10 word summary for command previews.",
+                },
+                timeoutMs: {
+                    type: "number",
+                    description: "Maximum runtime in milliseconds. Omit to use the default timeout of 10000.",
+                },
+            },
+        },
+        outputSchema: bashOutputSchema,
+        permissionPolicy: "on-request",
+        async executor(input, context) {
+            const rootPath = resolveToolRootPath(options, context);
+            const workdir = optionalString(input, "workdir");
+            const description = optionalString(input, "description");
+            const timeoutMs = optionalNumber(input, "timeoutMs");
+            const result = await runBashCommand({
+                rootPath,
+                command: requiredString(input, "command"),
+                ...(workdir !== undefined ? { workdir } : {}),
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            });
+            return jsonToolResult(result, {
+                exitCode: result.exitCode,
+                risk: result.risk,
+                sandboxProfile: result.sandboxProfile,
+                workdir: result.workdir,
+                ...(description !== undefined ? { description } : {}),
+            });
+        },
+    };
+}
+export function classifyDestructiveCommand(command) {
+    return /\brm\s+-rf\b|\bgit\s+reset\s+--hard\b|\bchmod\s+-R\b|>\s*\/dev\/sd|:\s*>\s*\S+/.test(command)
+        ? "destructive"
+        : "normal";
+}
+export function classifyShellSandboxProfile(command) {
+    if (classifyDestructiveCommand(command) === "destructive") {
+        return "destructive";
+    }
+    if (/\b(?:sudo|chown|mount|umount|launchctl)\b|(?:^|\s)(?:>|>>)\s*\/|\b(?:cp|mv|mkdir|touch|tee)\b[^\n;&|]*\s\/(?:usr|etc|var|opt|System|Library)\b/u.test(command)) {
+        return "external-write";
+    }
+    if (/\b(?:curl|wget|ssh|scp|rsync)\b|\bgit\s+(?:clone|fetch|pull|push)\b|\b(?:npm|pnpm|yarn|bun)\s+(?:install|add|remove|update|upgrade)\b|\b(?:pip|pipx|uv)\s+install\b|\bbrew\s+(?:install|update|upgrade)\b/u.test(command)) {
+        return "network";
+    }
+    const prefix = splitShellWords(firstShellCommandSegment(command));
+    if (isReadOnlyCommandPrefix(prefix)) {
+        return "read-only";
+    }
+    return "workspace-write";
+}
+function isReadOnlyCommandPrefix(prefix) {
+    const [command, subcommand] = prefix;
+    if (!command)
+        return false;
+    if ([
+        "cat",
+        "date",
+        "find",
+        "grep",
+        "head",
+        "ls",
+        "pwd",
+        "rg",
+        "sed",
+        "tail",
+        "wc",
+    ].includes(command)) {
+        return true;
+    }
+    return command === "git" && typeof subcommand === "string" &&
+        ["diff", "log", "show", "status"].includes(subcommand);
+}
+function firstShellCommandSegment(command) {
+    let quote;
+    let escaped = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (char === "&" || char === "|" || char === ";") {
+            return command.slice(0, index).trim();
+        }
+    }
+    return command.trim();
+}
+function splitShellWords(command) {
+    const words = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (/\s/u.test(char)) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        words.push(current);
+    return words;
+}
+const execFileAsync = promisify(execFile);
+function isExecError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        ("stdout" in error || "stderr" in error || "code" in error));
+}
+function resolveToolRootPath(options, context) {
+    const rootPath = options.rootPath ?? context.project?.rootPath;
+    if (!rootPath)
+        throw new Error("A project rootPath or tool rootPath is required.");
+    return rootPath;
+}
+function jsonToolResult(value, metadata) {
+    return {
+        content: JSON.stringify(value),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function createUnifiedDiff(input) {
+    const beforeLines = splitDiffLines(input.before);
+    const afterLines = splitDiffLines(input.after);
+    const changes = diffLineChanges(beforeLines, afterLines);
+    const additions = changes.filter((change) => change.kind === "add").length;
+    const deletions = changes.filter((change) => change.kind === "remove").length;
+    if (additions === 0 && deletions === 0) {
+        return { patch: "", additions, deletions };
+    }
+    const oldCount = beforeLines.length;
+    const newCount = afterLines.length;
+    const lines = [
+        `diff --git a/${input.path} b/${input.path}`,
+        `--- a/${input.path}`,
+        `+++ b/${input.path}`,
+        `@@ -1,${oldCount} +1,${newCount} @@`,
+        ...changes.map((change) => `${diffMarker(change.kind)}${change.text}`),
+        "",
+    ];
+    return { patch: lines.join("\n"), additions, deletions };
+}
+function splitDiffLines(value) {
+    const normalized = value.replace(/\r\n/gu, "\n");
+    const lines = normalized.split("\n");
+    if (normalized.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
+function splitTextLines(value) {
+    if (value.length === 0)
+        return [];
+    return splitDiffLines(value);
+}
+function countOccurrences(value, search) {
+    if (search.length === 0)
+        return 0;
+    return value.split(search).length - 1;
+}
+function diffLineChanges(before, after) {
+    const lengths = Array.from({ length: before.length + 1 }, () => Array.from({ length: after.length + 1 }, () => 0));
+    for (let left = before.length - 1; left >= 0; left -= 1) {
+        for (let right = after.length - 1; right >= 0; right -= 1) {
+            lengths[left][right] =
+                before[left] === after[right]
+                    ? lengths[left + 1][right + 1] + 1
+                    : Math.max(lengths[left + 1][right], lengths[left][right + 1]);
+        }
+    }
+    const changes = [];
+    let left = 0;
+    let right = 0;
+    while (left < before.length && right < after.length) {
+        if (before[left] === after[right]) {
+            changes.push({ kind: "context", text: before[left] });
+            left += 1;
+            right += 1;
+            continue;
+        }
+        if (lengths[left + 1][right] >= lengths[left][right + 1]) {
+            changes.push({ kind: "remove", text: before[left] });
+            left += 1;
+            continue;
+        }
+        changes.push({ kind: "add", text: after[right] });
+        right += 1;
+    }
+    while (left < before.length) {
+        changes.push({ kind: "remove", text: before[left] });
+        left += 1;
+    }
+    while (right < after.length) {
+        changes.push({ kind: "add", text: after[right] });
+        right += 1;
+    }
+    return changes;
+}
+function diffMarker(kind) {
+    if (kind === "add")
+        return "+";
+    if (kind === "remove")
+        return "-";
+    return " ";
+}
+function inputRecord(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return {};
+    return input;
+}
+function optionalString(input, key) {
+    const value = inputRecord(input)[key];
+    return typeof value === "string" ? value : undefined;
+}
+function requiredString(input, key) {
+    const value = optionalString(input, key);
+    if (!value)
+        throw new Error(`${key} is required.`);
+    return value;
+}
+function optionalNumber(input, key) {
+    const value = inputRecord(input)[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function optionalBoolean(input, key) {
+    const value = inputRecord(input)[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function parseUnifiedPatchPaths(patch) {
+    const paths = new Set();
+    for (const line of patch.split(/\r?\n/u)) {
+        if (!line.startsWith("--- ") && !line.startsWith("+++ "))
+            continue;
+        const filePath = normalizePatchPath(line.slice(4).trim().split(/\s+/u)[0]);
+        if (filePath)
+            paths.add(filePath);
+    }
+    return [...paths];
+}
+function normalizePatchPath(filePath) {
+    if (!filePath || filePath === "/dev/null")
+        return undefined;
+    const withoutPrefix = filePath.replace(/^[ab]\//u, "");
+    if (path.isAbsolute(withoutPrefix) || withoutPrefix.split(/[\\/]+/u).includes("..")) {
+        throw new PathGuardError("Patch path escapes approved root.");
+    }
+    return withoutPrefix;
+}
+async function nearestExistingPath(absolutePath) {
+    let current = absolutePath;
+    while (true) {
+        try {
+            await access(current, constants.F_OK);
+            const info = await lstat(current);
+            return info.isSymbolicLink() ? realpath(current) : current;
+        }
+        catch {
+            const parent = path.dirname(current);
+            if (parent === current)
+                throw new PathGuardError("No existing path found.");
+            current = parent;
+        }
+    }
+}
+function isWithin(rootPath, candidatePath) {
+    const relative = path.relative(rootPath, candidatePath);
+    return (relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative)));
+}
+function displayPath(rootPath, candidatePath) {
+    if (!isWithin(rootPath, candidatePath)) {
+        return candidatePath;
+    }
+    return path.relative(rootPath, candidatePath) || ".";
+}
+//# sourceMappingURL=local-tools.js.map