agent-dir 0.5.0 → 1.1.0

package/dist/src/server.d.ts

@@ -2,9 +2,9 @@ import type { ServerOptions } from "./types.js";
 export interface ServerHandle {
     close: () => Promise<void>;
 }
-export declare function startServer({ root, port, token, commandConfig, telemetry, }: ServerOptions): Promise<ServerHandle>;
+export declare function startServer({ root, port, token, commandConfig, telemetry, codeGraph, }: ServerOptions): Promise<ServerHandle>;
 export declare function validateMcpHeaders(request: Request, message: Record<string, unknown> | null): Response | undefined;
-export declare function getMcpLog(body: Buffer): {
+export declare function getMcpLog(body: Buffer, responseBody?: unknown): {
     name: string;
     detail: string;
 } | undefined;

package/dist/src/server.js

@@ -3,15 +3,14 @@ import { authenticate, unauthorized } from "./auth.js";
 import { logRequest } from "./logging.js";
 import { createMcpHandler } from "./mcp.js";
 import { TelemetryRecorder } from "./telemetry/recorder.js";
-import { deleteFile, listFiles, readFile, writeFile } from "./tools/files.js";
 const MAX_BODY_BYTES = 10 * 1024 * 1024;
 const REQUEST_BODY_TIMEOUT_MS = 30_000;
 const REQUEST_TIMEOUT_MS = 120_000;
 const HEADERS_TIMEOUT_MS = 30_000;
 const KEEP_ALIVE_TIMEOUT_MS = 5_000;
 const HEALTH_PATH = "/__health";
-export function startServer({ root, port, token, commandConfig = {}, telemetry = { level: "none" }, }) {
-    const mcp = createMcpHandler(root, commandConfig, telemetry);
+export function startServer({ root, port, token, commandConfig = {}, telemetry = { level: "none" }, codeGraph, }) {
+    const mcp = createMcpHandler(root, commandConfig, telemetry, codeGraph);
     const httpTelemetry = new TelemetryRecorder({
         level: telemetry.level,
         persist: telemetry.persist ?? false,
@@ -83,9 +82,13 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                     return;
                 }
                 const response = await mcp(request);
+                const mcpResponseBody = await response
+                    .clone()
+                    .json()
+                    .catch(() => undefined);
                 const errorDetail = await getResponseErrorDetail(response);
+                const mcpLog = getMcpLog(body, mcpResponseBody);
                 await sendResponse(res, response);
-                const mcpLog = getMcpLog(body);
                 const mcpErrorContext = response.status >= 400 ? getMcpErrorContext(body, request) : undefined;
                 logRequest({
                     method: req.method,
@@ -99,50 +102,6 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 recordHttpTelemetry(httpTelemetry, req.method, url.pathname, response.status, authenticated, startedAt);
                 return;
             }
-            if (url.pathname === "/__tree" && req.method === "GET") {
-                const tree = await listFiles(root);
-                sendText(res, 200, JSON.stringify(tree, null, 2), "application/json; charset=utf-8");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "directory" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            const relative = decodeURIComponent(url.pathname.slice(1));
-            if (!relative) {
-                sendText(res, 200, "agent-dir\n");
-                logRequest({
-                    method: req.method ?? "UNKNOWN",
-                    path: url.pathname,
-                    status: 200,
-                    detail: "server",
-                });
-                recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "GET") {
-                sendText(res, 200, await readFile(root, relative), "text/plain; charset=utf-8");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "REST GET" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "PUT") {
-                await writeFile(root, relative, body.toString("utf8"));
-                sendText(res, 200, "File updated successfully\n");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "REST PUT" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "DELETE") {
-                await deleteFile(root, relative);
-                sendText(res, 200, "File deleted successfully\n");
-                logRequest({
-                    method: req.method,
-                    path: url.pathname,
-                    status: 200,
-                    detail: "REST DELETE",
-                });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
             sendText(res, 404, "Not found\n");
             logRequest({
                 method: req.method ?? "UNKNOWN",
@@ -179,10 +138,15 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
     return new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(port, "127.0.0.1", () => resolve({
-            close: () => new Promise((done) => {
+            close: async () => {
                 mcp.closeSubscriptions();
-                server.close(() => done());
-            }),
+                try {
+                    await new Promise((done) => server.close(() => done()));
+                }
+                finally {
+                    await codeGraph?.close();
+                }
+            },
         }));
     });
 }
@@ -324,7 +288,7 @@ async function getResponseErrorDetail(response) {
     }
     return undefined;
 }
-export function getMcpLog(body) {
+export function getMcpLog(body, responseBody) {
     try {
         const message = JSON.parse(body.toString("utf8"));
         if (typeof message.method !== "string")
@@ -337,20 +301,7 @@ export function getMcpLog(body) {
         const name = message.params.name;
         const args = isRecordValue(message.params.arguments) ? message.params.arguments : {};
         const detail = (() => {
-            const paths = Array.isArray(args.paths)
-                ? args.paths.filter((value) => typeof value === "string")
-                : [];
-            const files = Array.isArray(args.files)
-                ? args.files
-                    .filter((value) => typeof value === "object" && value !== null)
-                    .map((value) => value.path)
-                    .filter((value) => typeof value === "string")
-                : [];
             switch (name) {
-                case "list_files":
-                    return "all project files";
-                case "list_dirs":
-                    return paths.join(", ");
                 case "read_range": {
                     const path = typeof args.path === "string" ? args.path : "";
                     const startLine = typeof args.startLine === "number" ? args.startLine : undefined;
@@ -359,21 +310,12 @@ export function getMcpLog(body) {
                         ? `${path}:${startLine}-${endLine}`
                         : path;
                 }
-                case "read_files":
-                case "delete_files":
-                case "git_stage":
-                case "git_unstage":
-                    return paths.join(", ");
-                case "write_files":
-                case "patch_files":
-                    return files.join(", ");
                 case "run_npm_batch": {
                     const scripts = Array.isArray(args.scripts)
                         ? args.scripts.filter((value) => typeof value === "string")
                         : [];
                     return scripts.map((script) => `npm run ${script}`).join(", ");
                 }
-                case "search_files":
                 case "search_code": {
                     const query = typeof args.query === "string" ? args.query : "";
                     const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
@@ -397,15 +339,6 @@ export function getMcpLog(body) {
                             : `symbol: ${symbol}`
                         : "";
                 }
-                case "find_definition": {
-                    const symbol = typeof args.symbol === "string" ? args.symbol : "";
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return symbol
-                        ? maxResults !== undefined
-                            ? `definition: ${symbol} (max ${maxResults})`
-                            : `definition: ${symbol}`
-                        : "";
-                }
                 case "find_references": {
                     const symbol = typeof args.symbol === "string" ? args.symbol : "";
                     const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
@@ -415,36 +348,36 @@ export function getMcpLog(body) {
                             : `references: ${symbol}`
                         : "";
                 }
-                case "git_commit":
-                    return "commit (message omitted)";
-                case "find_imports": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `all imports (max ${maxResults})` : "all imports";
-                }
-                case "find_exports": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `all exports (max ${maxResults})` : "all exports";
-                }
-                case "diagnostics": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `max ${maxResults}` : "";
-                }
-                case "git_restore":
-                    return paths.join(", ");
-                case "git_push":
-                    return "push (remote/branch omitted)";
-                case "git_diff": {
-                    const staged = args.staged === true ? "staged" : "working tree";
-                    const path = typeof args.path === "string" ? args.path : "";
-                    return path ? `${staged}: ${path}` : staged;
-                }
-                case "git_log": {
-                    const limit = typeof args.limit === "number" ? args.limit : 20;
-                    const path = typeof args.path === "string" ? args.path : "";
-                    return path ? `last ${limit}: ${path}` : `last ${limit}`;
-                }
                 case "file_info":
                     return typeof args.path === "string" ? args.path : "";
+                case "apply_changes": {
+                    const response = isRecordValue(responseBody) ? responseBody : undefined;
+                    const result = response && isRecordValue(response.result) ? response.result : undefined;
+                    if (result?.isError === true || response?.error !== undefined)
+                        return "change failed";
+                    const applied = Array.isArray(result?.structuredContent) ? result.structuredContent : [];
+                    if (applied.length) {
+                        const entries = applied
+                            .filter((item) => isRecordValue(item) && item.changed === true)
+                            .map((item) => {
+                            const kind = item.kind === "write" || item.kind === "patch" || item.kind === "delete"
+                                ? item.kind
+                                : "change";
+                            const path = typeof item.path === "string" ? item.path : "(unknown path)";
+                            return `${kind} ${path}`;
+                        });
+                        if (!entries.length)
+                            return args.dryRun === true ? "preview: no file changes" : "no file changes";
+                        const shown = entries.slice(0, 5);
+                        const suffix = entries.length > shown.length ? ` • +${entries.length - shown.length} more` : "";
+                        return `${args.dryRun === true ? "preview" : "changed"}: ${shown.join(" • ")}${suffix}`;
+                    }
+                    const changes = Array.isArray(args.changes) ? args.changes : [];
+                    const paths = changes
+                        .filter((item) => isRecordValue(item))
+                        .map((item) => (typeof item.path === "string" ? item.path : "(unknown path)"));
+                    return `requested: ${paths.slice(0, 5).join(" • ")}${paths.length > 5 ? ` • +${paths.length - 5} more` : ""}`;
+                }
                 case "run_command_batch": {
                     const commands = Array.isArray(args.commands) ? args.commands : [];
                     return commands
@@ -464,33 +397,7 @@ export function getMcpLog(body) {
 }
 function getMcpMethodDetail(method, params) {
     const value = params ?? {};
-    const capabilities = isRecordValue(value.capabilities)
-        ? Object.keys(value.capabilities).sort()
-        : [];
-    const clientInfo = isRecordValue(value.clientInfo) ? value.clientInfo : undefined;
-    const clientName = typeof clientInfo?.name === "string" ? clientInfo.name : undefined;
-    const clientVersion = typeof clientInfo?.version === "string" ? clientInfo.version : undefined;
-    const protocol = typeof value.protocolVersion === "string"
-        ? value.protocolVersion
-        : isRecordValue(value._meta) &&
-            typeof value._meta["io.modelcontextprotocol/protocolVersion"] === "string"
-            ? value._meta["io.modelcontextprotocol/protocolVersion"]
-            : undefined;
     switch (method) {
-        case "initialize": {
-            const client = clientName
-                ? clientVersion
-                    ? `${clientName} v${clientVersion}`
-                    : clientName
-                : undefined;
-            return ([
-                protocol ? `protocol: ${protocol}` : undefined,
-                client ? `client: ${client}` : undefined,
-                capabilities.length ? `capabilities: ${capabilities.join(", ")}` : undefined,
-            ]
-                .filter((part) => Boolean(part))
-                .join(" • ") || "initialization handshake");
-        }
         case "notifications/initialized":
             return "initialization complete";
         case "tools/list":
@@ -535,15 +442,7 @@ function formatCommand(command, args) {
     return count ? `${command} (args: ${count})` : command;
 }
 function recordHttpTelemetry(recorder, method, pathname, status, authenticated, startedAt) {
-    const route = pathname === "/mcp"
-        ? "mcp"
-        : pathname === "/__tree"
-            ? "tree"
-            : pathname === "/"
-                ? "root"
-                : pathname.startsWith("/") && pathname.length > 1
-                    ? "file"
-                    : "other";
+    const route = pathname === "/mcp" ? "mcp" : "other";
     recorder.record({
         event: "http_request",
         method,

package/dist/src/telemetry/privacy.js

@@ -31,6 +31,8 @@ export function sanitizeAnonymousEvent(event) {
             method: sanitizeMcpMethod(event.method),
             success: event.success === true,
             durationMs: boundedNumber(event.durationMs),
+            ...optionalNumber("responseBytes", event.responseBytes),
+            ...optionalNumber("estimatedResponseTokens", event.estimatedResponseTokens),
             ...(event.errorCategory === undefined
                 ? {}
                 : { errorCategory: sanitizeErrorCategory(event.errorCategory) }),

package/dist/src/telemetry/types.d.ts

@@ -20,6 +20,8 @@ export interface TelemetryMcpRequestEvent {
     method: string;
     success: boolean;
     durationMs: number;
+    responseBytes?: number;
+    estimatedResponseTokens?: number;
     errorCategory?: string;
 }
 export interface TelemetryFileMetric {

package/dist/src/tools/code.d.ts

@@ -8,19 +8,7 @@ export interface SymbolMatch extends SearchMatch {
     symbol: string;
     kind: string;
 }
-export interface ImportMatch extends SearchMatch {
-    module: string;
-    kind: "import" | "require";
-}
-export interface ExportMatch extends SearchMatch {
-    symbol: string;
-    kind: "export";
-}
-export declare function searchFiles(root: string, query: string, regex?: boolean, maxResults?: number, maxBytes?: number): Promise<SearchMatch[]>;
 export declare function searchCode(root: string, query: string, regex?: boolean, maxResults?: number, maxBytes?: number): Promise<SearchMatch[]>;
 export declare function findFiles(root: string, pattern: string, maxResults?: number): Promise<string[]>;
 export declare function findSymbol(root: string, symbol: string, maxResults?: number, maxBytes?: number): Promise<SymbolMatch[]>;
-export declare function findDefinition(root: string, symbol: string, maxResults?: number, maxBytes?: number): Promise<SymbolMatch[]>;
 export declare function findReferences(root: string, symbol: string, maxResults?: number, maxBytes?: number): Promise<SearchMatch[]>;
-export declare function findImports(root: string, maxResults?: number, maxBytes?: number): Promise<ImportMatch[]>;
-export declare function findExports(root: string, maxResults?: number, maxBytes?: number): Promise<ExportMatch[]>;

package/dist/src/tools/code.js

@@ -34,7 +34,8 @@ const CODE_EXTENSIONS = new Set([
     ".yaml",
     ".yml",
 ]);
-const DEFAULT_OUTPUT_BYTES = 32_000;
+const DEFAULT_OUTPUT_BYTES = 8_000;
+const MAX_SEARCH_FILE_BYTES = 1_000_000;
 function truncateUtf8(value, maxBytes) {
     if (Buffer.byteLength(value, "utf8") <= maxBytes)
         return value;
@@ -84,7 +85,13 @@ async function readMatches(root, query, options = {}) {
             break;
         let content;
         try {
-            content = await fs.readFile(await safePath(root, relativePath), "utf8");
+            const target = await safePath(root, relativePath);
+            const stat = await fs.stat(target);
+            if (!stat.isFile() || stat.size > MAX_SEARCH_FILE_BYTES)
+                continue;
+            content = await fs.readFile(target, "utf8");
+            if (content.includes(String.fromCharCode(0)))
+                continue;
         }
         catch {
             continue;
@@ -101,11 +108,6 @@ async function readMatches(root, query, options = {}) {
     }
     return matches;
 }
-export async function searchFiles(root, query, regex = false, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
-    if (!query.trim())
-        throw new Error("Search query cannot be empty.");
-    return boundMatches(await readMatches(root, query, { regex, maxResults }), maxBytes);
-}
 export async function searchCode(root, query, regex = false, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
     if (!query.trim())
         throw new Error("Search query cannot be empty.");
@@ -132,34 +134,12 @@ export async function findSymbol(root, symbol, maxResults = 100, maxBytes = DEFA
     const matches = (await readMatches(root, pattern.source, { codeOnly: true, regex: true, maxResults })).map((match) => ({ ...match, symbol, kind: symbolKind(match.text) }));
     return boundMatches(matches, maxBytes);
 }
-export function findDefinition(root, symbol, maxResults = 100, maxBytes = DEFAULT_OUTPUT_BYTES) {
-    return findSymbol(root, symbol, maxResults, maxBytes);
-}
 export function findReferences(root, symbol, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
     if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(symbol))
         throw new Error("Symbol must be a valid identifier.");
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return searchCode(root, `\\b${escaped}\\b`, true, maxResults, maxBytes);
 }
-export async function findImports(root, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
-    const matches = await readMatches(root, String.raw `(?:^|[;{}])\s*import\s*(?:[^"'\n]*?from\s*)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)`, { codeOnly: true, regex: true, maxResults });
-    return boundMatches(matches.map((match) => {
-        const captured = match.text.match(/(?:from\s*)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)/);
-        return {
-            ...match,
-            module: captured?.[1] ?? captured?.[2] ?? match.text,
-            kind: /require\s*\(/.test(match.text) ? "require" : "import",
-        };
-    }), maxBytes);
-}
-export async function findExports(root, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
-    const matches = await readMatches(root, String.raw `\bexport\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][A-Za-z0-9_$]*)`, { codeOnly: true, regex: true, maxResults });
-    return boundMatches(matches.map((match) => ({
-        ...match,
-        symbol: match.text.match(/(?:function|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][A-Za-z0-9_$]*)/)?.[1] ?? "default",
-        kind: "export",
-    })), maxBytes);
-}
 function symbolKind(line) {
     if (/\bclass\b/i.test(line))
         return "class";

package/dist/src/tools/diagnostics.js

@@ -8,7 +8,9 @@ export async function diagnostics(root, maxResults = 200) {
     const entries = await listFiles(root);
     const results = [];
     for (const entry of entries) {
-        if (results.length >= maxResults || entry.type !== "file")
+        if (results.length >= maxResults)
+            break;
+        if (entry.type !== "file")
             continue;
         const target = path.join(resolvedRoot, entry.path);
         let stat;

package/dist/src/tools/files.d.ts

@@ -9,33 +9,14 @@ export interface FilePatch {
     count?: number;
 }
 export declare function listFiles(root: string): Promise<FileEntry[]>;
-export declare function listDir(root: string, relativePath?: string): Promise<FileEntry[]>;
-export declare function listDirs(root: string, relativePaths: string[]): Promise<Array<{
-    path: string;
-    entries: FileEntry[];
-}>>;
 export declare function readFile(root: string, relativePath: string): Promise<string>;
-export declare function readRange(root: string, relativePath: string, startLine: number, endLine: number): Promise<{
+export declare function readRange(root: string, relativePath: string, startLine: number, endLine: number, maxBytes?: number): Promise<{
     path: string;
     startLine: number;
     endLine: number;
     content: string;
+    truncated: boolean;
 }>;
-export declare function writeFile(root: string, relativePath: string, content: string): Promise<void>;
-export declare function patchFiles(root: string, files: Array<{
-    path: string;
-    patches: FilePatch[];
-}>): Promise<Array<{
-    path: string;
-    applied: number;
-    content: string;
-}>>;
-export declare function patchFile(root: string, relativePath: string, patches: FilePatch[]): Promise<{
-    path: string;
-    applied: number;
-    content: string;
-}>;
-export declare function deleteFile(root: string, relativePath: string): Promise<void>;
 export type FileChange = {
     kind: "write";
     path: string;

package/dist/src/tools/files.js

@@ -1,5 +1,6 @@
-import { promises as fs } from "node:fs";
+import { createReadStream, promises as fs } from "node:fs";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 const IGNORED = new Set([".git", "node_modules", ".next", "dist", "build", "coverage"]);
 export async function safePath(root, relativePath = ".", allowMissing = false) {
     const resolvedRoot = await fs.realpath(root);
@@ -55,30 +56,10 @@ export async function listFiles(root) {
     };
     return walk(resolvedRoot);
 }
-export async function listDir(root, relativePath = ".") {
-    const resolvedRoot = await fs.realpath(root);
-    const directory = await safePath(resolvedRoot, relativePath);
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    return entries
-        .filter((entry) => !IGNORED.has(entry.name))
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map((entry) => ({
-        path: path.relative(resolvedRoot, path.join(directory, entry.name)),
-        type: entry.isDirectory() ? "directory" : "file",
-    }));
-}
-export async function listDirs(root, relativePaths) {
-    if (relativePaths.length === 0)
-        throw new Error("At least one directory is required.");
-    return Promise.all(relativePaths.map(async (relativePath) => ({
-        path: relativePath,
-        entries: await listDir(root, relativePath),
-    })));
-}
 export function readFile(root, relativePath) {
     return safePath(root, relativePath).then((target) => fs.readFile(target, "utf8"));
 }
-export async function readRange(root, relativePath, startLine, endLine) {
+export async function readRange(root, relativePath, startLine, endLine, maxBytes = 8_000) {
     if (!Number.isInteger(startLine) ||
         !Number.isInteger(endLine) ||
         startLine < 1 ||
@@ -86,58 +67,92 @@ export async function readRange(root, relativePath, startLine, endLine) {
         throw new Error("Line range must use positive integers with endLine >= startLine.");
     if (endLine - startLine > 2000)
         throw new Error("A read range may contain at most 2000 lines.");
-    const content = await readFile(root, relativePath);
-    const lines = content.split(/\r?\n/);
-    return {
-        path: relativePath,
-        startLine,
-        endLine: Math.min(endLine, lines.length),
-        content: lines.slice(startLine - 1, endLine).join("\n"),
-    };
-}
-export async function writeFile(root, relativePath, content) {
-    const target = await safePath(root, relativePath, true);
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await fs.writeFile(target, content, "utf8");
-}
-export async function patchFiles(root, files) {
-    if (files.length === 0)
-        throw new Error("At least one file is required.");
-    return Promise.all(files.map(({ path: relativePath, patches }) => patchFile(root, relativePath, patches)));
-}
-export async function patchFile(root, relativePath, patches) {
-    if (patches.length === 0)
-        throw new Error("At least one patch is required.");
+    if (!Number.isInteger(maxBytes) || maxBytes < 1)
+        throw new Error("maxBytes must be a positive integer.");
     const target = await safePath(root, relativePath);
-    let content = await fs.readFile(target, "utf8");
-    for (const patch of patches) {
-        if (!patch.search)
-            throw new Error("Patch search text cannot be empty.");
-        const occurrences = content.split(patch.search).length - 1;
-        if (occurrences === 0)
-            throw new Error(`Patch text was not found in '${relativePath}'.`);
-        const count = patch.count ?? 1;
-        if (!Number.isInteger(count) || count < 1)
-            throw new Error("Patch count must be a positive integer.");
-        if (occurrences < count)
-            throw new Error(`Patch text occurs ${occurrences} time(s), but ${count} replacement(s) were requested.`);
+    const decoder = new StringDecoder("utf8");
+    const stream = createReadStream(target, { highWaterMark: 64 * 1024 });
+    const output = [];
+    let line = "";
+    let lineNumber = 1;
+    let outputBytes = 0;
+    let truncated = false;
+    const marker = "…[truncated]";
+    const finishLine = () => {
+        if (lineNumber >= startLine && lineNumber <= endLine) {
+            if (truncated && line.endsWith(marker)) {
+                output.push(line);
+                outputBytes = maxBytes;
+                lineNumber++;
+                line = "";
+                return;
+            }
+            const value = line.endsWith("\r") ? line.slice(0, -1) : line;
+            const separatorBytes = output.length ? 1 : 0;
+            const remaining = maxBytes - outputBytes - separatorBytes;
+            if (Buffer.byteLength(value, "utf8") > remaining) {
+                const allowance = Math.max(0, remaining - Buffer.byteLength(marker, "utf8") - 1);
+                let clipped = Buffer.from(value, "utf8").subarray(0, allowance).toString("utf8");
+                while (clipped.endsWith("\uFFFD"))
+                    clipped = clipped.slice(0, -1);
+                output.push(`${clipped}\n${marker}`);
+                outputBytes = maxBytes;
+                truncated = true;
+            }
+            else {
+                output.push(value);
+                outputBytes += separatorBytes + Buffer.byteLength(value, "utf8");
+            }
+        }
+        lineNumber++;
+        line = "";
+    };
+    for await (const chunk of stream) {
+        const text = decoder.write(chunk);
         let offset = 0;
-        for (let i = 0; i < count; i++) {
-            const index = content.indexOf(patch.search, offset);
-            content =
-                content.slice(0, index) + patch.replace + content.slice(index + patch.search.length);
-            offset = index + patch.replace.length;
+        while (offset < text.length) {
+            const newline = text.indexOf("\n", offset);
+            const end = newline === -1 ? text.length : newline;
+            if (lineNumber >= startLine && lineNumber <= endLine && !truncated) {
+                const piece = text.slice(offset, end);
+                const remaining = maxBytes - outputBytes - Buffer.byteLength(line, "utf8");
+                if (remaining <= 0) {
+                    line = "";
+                    truncated = true;
+                    break;
+                }
+                if (Buffer.byteLength(piece, "utf8") > remaining) {
+                    const allowance = Math.max(0, remaining - Buffer.byteLength(marker, "utf8") - 1);
+                    let clipped = Buffer.from(piece, "utf8").subarray(0, allowance).toString("utf8");
+                    while (clipped.endsWith("\uFFFD"))
+                        clipped = clipped.slice(0, -1);
+                    line += `${clipped}\n${marker}`;
+                    truncated = true;
+                }
+                else
+                    line += piece;
+            }
+            if (newline === -1)
+                break;
+            finishLine();
+            offset = newline + 1;
         }
+        if (lineNumber > endLine || truncated)
+            break;
     }
-    await fs.writeFile(target, content, "utf8");
-    return { path: relativePath, applied: patches.length, content };
-}
-export async function deleteFile(root, relativePath) {
-    const target = await safePath(root, relativePath);
-    const stat = await fs.stat(target);
-    if (!stat.isFile())
-        throw new Error("delete_files only deletes files.");
-    await fs.unlink(target);
+    stream.destroy();
+    const tail = decoder.end();
+    if (tail && lineNumber >= startLine && lineNumber <= endLine && !truncated)
+        line += tail;
+    if (lineNumber >= startLine && lineNumber <= endLine && !(truncated && line.length === 0))
+        finishLine();
+    return {
+        path: relativePath,
+        startLine,
+        endLine: Math.min(endLine, lineNumber - 1),
+        content: output.join("\n"),
+        truncated,
+    };
 }
 export async function applyFileChanges(root, changes, dryRun = false) {
     if (changes.length === 0)

package/dist/src/tools/git.d.ts

@@ -4,11 +4,4 @@ export interface GitResult {
     stdout: string;
     stderr: string;
 }
-export declare function gitStage(root: string, paths: string[]): Promise<GitResult>;
-export declare function gitUnstage(root: string, paths: string[]): Promise<GitResult>;
-export declare function gitCommit(root: string, message: string): Promise<GitResult>;
-export declare function gitPush(root: string, remote?: string, branch?: string): Promise<GitResult>;
 export declare function gitStatus(root: string): Promise<GitResult>;
-export declare function gitDiff(root: string, staged?: boolean, pathspec?: string): Promise<GitResult>;
-export declare function gitRestore(root: string, paths: string[], staged?: boolean): Promise<GitResult>;
-export declare function gitLog(root: string, limit?: number, pathspec?: string): Promise<GitResult>;