agent-dir 0.4.1 → 1.0.0

package/dist/src/telemetry/storage.js

@@ -0,0 +1,133 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const CONFIG_DIRECTORY = join(homedir(), ".config", "agent-dir");
+export const TELEMETRY_DIRECTORY = join(CONFIG_DIRECTORY, "telemetry");
+export const LEGACY_TELEMETRY_FILE = join(CONFIG_DIRECTORY, "telemetry.jsonl");
+const LEGACY_ARCHIVE_FILE = join(CONFIG_DIRECTORY, "telemetry.legacy-archive.jsonl");
+function safeSegment(value) {
+    const safe = value
+        .replace(/[^A-Za-z0-9._-]/g, "_")
+        .replace(/^\.+$/, "_")
+        .slice(0, 100);
+    return safe || "unknown";
+}
+export function telemetrySessionPath(configId, sessionId) {
+    return join(TELEMETRY_DIRECTORY, safeSegment(configId), `session-${safeSegment(sessionId)}.jsonl`);
+}
+function parseEvents(content) {
+    const events = [];
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (value &&
+                value.schemaVersion === 1 &&
+                typeof value.configId === "string" &&
+                typeof value.sessionId === "string" &&
+                typeof value.timestamp === "string" &&
+                value.event) {
+                events.push(value);
+            }
+        }
+        catch {
+            // Ignore malformed lines without discarding other valid events.
+        }
+    }
+    return events;
+}
+function readFileEvents(path) {
+    try {
+        return parseEvents(readFileSync(path, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+function collectJsonlFiles(directory) {
+    if (!existsSync(directory))
+        return [];
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...collectJsonlFiles(path));
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            files.push(path);
+    }
+    return files;
+}
+/** Migrate the old shared file once, preserving an archive and avoiding duplicate lines. */
+export function migrateLegacyTelemetry() {
+    if (!existsSync(LEGACY_TELEMETRY_FILE))
+        return;
+    const legacyEvents = readFileEvents(LEGACY_TELEMETRY_FILE);
+    mkdirSync(TELEMETRY_DIRECTORY, { recursive: true, mode: 0o700 });
+    const groups = new Map();
+    for (const event of legacyEvents) {
+        const path = telemetrySessionPath(event.configId, event.sessionId);
+        const group = groups.get(path) ?? [];
+        group.push(event);
+        groups.set(path, group);
+    }
+    for (const [path, events] of groups) {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        let existing = new Set();
+        try {
+            existing = new Set(readFileSync(path, "utf8").split("\n").filter(Boolean));
+        }
+        catch {
+            // New session file.
+        }
+        const missing = events
+            .map((event) => JSON.stringify(event))
+            .filter((line) => {
+            if (existing.has(line))
+                return false;
+            existing.add(line);
+            return true;
+        });
+        if (missing.length) {
+            appendFileSync(path, `${missing.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
+            chmodSync(path, 0o600);
+        }
+    }
+    let archive = LEGACY_ARCHIVE_FILE;
+    if (existsSync(archive))
+        archive = `${LEGACY_ARCHIVE_FILE}.${Date.now()}`;
+    renameSync(LEGACY_TELEMETRY_FILE, archive);
+}
+export function readAllTelemetryEvents() {
+    migrateLegacyTelemetry();
+    return collectJsonlFiles(TELEMETRY_DIRECTORY)
+        .flatMap(readFileEvents)
+        .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+export function resetTelemetry(profile, all = false) {
+    if (all) {
+        rmSync(TELEMETRY_DIRECTORY, { recursive: true, force: true });
+        rmSync(LEGACY_TELEMETRY_FILE, { force: true });
+        rmSync(LEGACY_ARCHIVE_FILE, { force: true });
+        for (const entry of existsSync(CONFIG_DIRECTORY)
+            ? readdirSync(CONFIG_DIRECTORY, { withFileTypes: true })
+            : []) {
+            if (entry.isFile() && entry.name.startsWith("telemetry.legacy-archive.jsonl.")) {
+                rmSync(join(CONFIG_DIRECTORY, entry.name), { force: true });
+            }
+        }
+        return;
+    }
+    if (!profile)
+        throw new Error("Specify a profile name or use --all.");
+    rmSync(join(TELEMETRY_DIRECTORY, safeSegment(profile)), { recursive: true, force: true });
+}
+export function ensureTelemetryDirectory() {
+    mkdirSync(TELEMETRY_DIRECTORY, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(TELEMETRY_DIRECTORY, 0o700);
+    }
+    catch {
+        // Best-effort permission hardening.
+    }
+}

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

@@ -20,11 +20,31 @@ export interface TelemetryMcpRequestEvent {
     method: string;
     success: boolean;
     durationMs: number;
+    responseBytes?: number;
+    estimatedResponseTokens?: number;
     errorCategory?: string;
 }
+export interface TelemetryFileMetric {
+    pathHash: string;
+    contentHash?: string;
+    bytes: number;
+}
 export interface TelemetryToolEvent {
     event: "tool_call";
     tool: string;
+    requestIdHash?: string;
+    inputFingerprint?: string;
+    outputFingerprint?: string;
+    /** Full local-only troubleshooting payload, emitted only at diagnostic level. */
+    diagnosticDetails?: Record<string, unknown>;
+    estimatedInputTokens?: number;
+    estimatedOutputTokens?: number;
+    cumulativeOutputBytes?: number;
+    cumulativeEstimatedOutputTokens?: number;
+    duplicateOutputBytes?: number;
+    textOutputBytes?: number;
+    uniqueFileCount?: number;
+    files?: TelemetryFileMetric[];
     success: boolean;
     durationMs: number;
     inputBytes?: number;
@@ -71,6 +91,10 @@ export interface TelemetryRuntimeContext {
     mcpClientName?: string;
     mcpClientVersion?: string;
     nodeVersion?: string;
+    distroId?: string;
+    distroName?: string;
+    distroVersion?: string;
+    kernelVersion?: string;
     hostname?: string;
     username?: string;
     processId?: number;

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(?:[^"'\\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/commands.d.ts

@@ -1,3 +1,10 @@
+import { type ChildProcess } from "node:child_process";
+export declare function appendBoundedOutput(current: string, chunk: Buffer | string): string;
+export declare function commandEnvironment(): NodeJS.ProcessEnv;
+export declare function terminateProcessTree(child: ChildProcess): void;
+export declare function processTreeSpawnOptions(): {
+    detached: boolean;
+};
 export interface CommandResult {
     command: string;
     exitCode: number;

package/dist/src/tools/commands.js

@@ -1,5 +1,58 @@
 import { spawn } from "node:child_process";
 const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+const MAX_CAPTURE_BYTES = 512_000;
+const TRUNCATION_MARKER = "\n…[output truncated at 512 KB]";
+export function appendBoundedOutput(current, chunk) {
+    if (current.endsWith(TRUNCATION_MARKER) ||
+        Buffer.byteLength(current, "utf8") >= MAX_CAPTURE_BYTES)
+        return current;
+    const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const available = MAX_CAPTURE_BYTES - Buffer.byteLength(current, "utf8");
+    if (incoming.byteLength <= available)
+        return current + incoming.toString("utf8");
+    const markerBytes = Buffer.byteLength(TRUNCATION_MARKER, "utf8");
+    const payloadBytes = Math.max(0, available - markerBytes);
+    let payload = incoming.subarray(0, payloadBytes).toString("utf8");
+    while (Buffer.byteLength(payload, "utf8") > payloadBytes)
+        payload = payload.slice(0, -1);
+    return current + payload + TRUNCATION_MARKER;
+}
+export function commandEnvironment() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => !/(?:TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTHORIZATION|ACCESS[_-]?KEY)/i.test(key)));
+}
+const FORCE_KILL_DELAY_MS = 1_000;
+export function terminateProcessTree(child) {
+    const pid = child.pid;
+    if (!pid || child.killed || child.exitCode !== null)
+        return;
+    if (process.platform === "win32") {
+        const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        killer.on("error", () => child.kill("SIGKILL"));
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        child.kill("SIGTERM");
+    }
+    const forceTimer = setTimeout(() => {
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch {
+            child.kill("SIGKILL");
+        }
+    }, FORCE_KILL_DELAY_MS);
+    forceTimer.unref();
+    child.once("close", () => clearTimeout(forceTimer));
+}
+export function processTreeSpawnOptions() {
+    return { detached: process.platform !== "win32" };
+}
 export function isCommandBlacklisted(command, args = [], blacklistedCommands = []) {
     const invocation = [command, ...args];
     return blacklistedCommands.some((entry) => {
@@ -17,7 +70,12 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
     if (!Array.isArray(args) || args.some((arg) => typeof arg !== "string"))
         throw new Error("Command arguments must be strings.");
     return new Promise((resolve, reject) => {
-        const child = spawn(command, args, { cwd: root, shell: false, env: process.env });
+        const child = spawn(command, args, {
+            cwd: root,
+            shell: false,
+            env: commandEnvironment(),
+            ...processTreeSpawnOptions(),
+        });
         let stdout = "";
         let stderr = "";
         let finished = false;
@@ -27,14 +85,14 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
                 return;
             finished = true;
             clearTimeout(timer);
-            child.kill("SIGTERM");
+            terminateProcessTree(child);
             reject(new Error(`Command '${command}' was aborted.`));
         };
         timer = setTimeout(() => {
             if (finished)
                 return;
             finished = true;
-            child.kill("SIGTERM");
+            terminateProcessTree(child);
             signal?.removeEventListener("abort", abort);
             reject(new Error(`Command '${command}' timed out after ${timeoutMs}ms.`));
         }, timeoutMs);
@@ -44,10 +102,10 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
         }
         signal?.addEventListener("abort", abort, { once: true });
         child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
+            stdout = appendBoundedOutput(stdout, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            stderr = appendBoundedOutput(stderr, chunk);
         });
         child.on("error", (error) => {
             if (finished)

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>;