@aexol/spectral 0.7.1 → 0.7.5

package/dist/pi/coding-agent/core/tools/bash.js

@@ -0,0 +1,341 @@
+import { existsSync } from "node:fs";
+import { Container, Text, truncateToWidth } from "../../../tui/index.js";
+import { spawn } from "child_process";
+import { Type } from "typebox";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate.js";
+import { theme } from "../../modes/interactive/theme/theme.js";
+import { waitForChildProcess } from "../../utils/child-process.js";
+import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { OutputAccumulator } from "./output-accumulator.js";
+import { getTextOutput, invalidArgText, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const bashSchema = Type.Object({
+    command: Type.String({ description: "Bash command to execute" }),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export function createLocalBashOperations(options) {
+    return {
+        exec: (command, cwd, { onData, signal, timeout, env }) => {
+            return new Promise((resolve, reject) => {
+                const { shell, args } = getShellConfig(options?.shellPath);
+                if (!existsSync(cwd)) {
+                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
+                    return;
+                }
+                const child = spawn(shell, [...args, command], {
+                    cwd,
+                    detached: process.platform !== "win32",
+                    env: env ?? getShellEnv(),
+                    stdio: ["ignore", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+                if (child.pid)
+                    trackDetachedChildPid(child.pid);
+                let timedOut = false;
+                let timeoutHandle;
+                // Set timeout if provided.
+                if (timeout !== undefined && timeout > 0) {
+                    timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        if (child.pid)
+                            killProcessTree(child.pid);
+                    }, timeout * 1000);
+                }
+                // Stream stdout and stderr.
+                child.stdout?.on("data", onData);
+                child.stderr?.on("data", onData);
+                // Handle abort signal by killing the entire process tree.
+                const onAbort = () => {
+                    if (child.pid)
+                        killProcessTree(child.pid);
+                };
+                if (signal) {
+                    if (signal.aborted)
+                        onAbort();
+                    else
+                        signal.addEventListener("abort", onAbort, { once: true });
+                }
+                // Handle shell spawn errors and wait for the process to terminate without hanging
+                // on inherited stdio handles held by detached descendants.
+                waitForChildProcess(child)
+                    .then((code) => {
+                    if (child.pid)
+                        untrackDetachedChildPid(child.pid);
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (signal)
+                        signal.removeEventListener("abort", onAbort);
+                    if (signal?.aborted) {
+                        reject(new Error("aborted"));
+                        return;
+                    }
+                    if (timedOut) {
+                        reject(new Error(`timeout:${timeout}`));
+                        return;
+                    }
+                    resolve({ exitCode: code });
+                })
+                    .catch((err) => {
+                    if (child.pid)
+                        untrackDetachedChildPid(child.pid);
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (signal)
+                        signal.removeEventListener("abort", onAbort);
+                    reject(err);
+                });
+            });
+        },
+    };
+}
+function resolveSpawnContext(command, cwd, spawnHook) {
+    const baseContext = { command, cwd, env: { ...getShellEnv() } };
+    return spawnHook ? spawnHook(baseContext) : baseContext;
+}
+const BASH_PREVIEW_LINES = 5;
+const BASH_UPDATE_THROTTLE_MS = 100;
+class BashResultRenderComponent extends Container {
+    state = {
+        cachedWidth: undefined,
+        cachedLines: undefined,
+        cachedSkipped: undefined,
+    };
+}
+function formatDuration(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatBashCall(args) {
+    const command = str(args?.command);
+    const timeout = args?.timeout;
+    const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+    const commandDisplay = command === null ? invalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
+    return theme.fg("toolTitle", theme.bold(`$ ${commandDisplay}`)) + timeoutSuffix;
+}
+function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
+    const state = component.state;
+    component.clear();
+    let output = getTextOutput(result, showImages).trim();
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+        const footerStart = output.lastIndexOf("\n\n[");
+        if (footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath)) {
+            output = output.slice(0, footerStart).trimEnd();
+        }
+    }
+    if (output) {
+        const styledOutput = output
+            .split("\n")
+            .map((line) => theme.fg("toolOutput", line))
+            .join("\n");
+        if (options.expanded) {
+            component.addChild(new Text(`\n${styledOutput}`, 0, 0));
+        }
+        else {
+            component.addChild({
+                render: (width) => {
+                    if (state.cachedLines === undefined || state.cachedWidth !== width) {
+                        const preview = truncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
+                        state.cachedLines = preview.visualLines;
+                        state.cachedSkipped = preview.skippedCount;
+                        state.cachedWidth = width;
+                    }
+                    if (state.cachedSkipped && state.cachedSkipped > 0) {
+                        const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
+                            ` ${keyHint("app.tools.expand", "to expand")})`;
+                        return ["", truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
+                    }
+                    return ["", ...(state.cachedLines ?? [])];
+                },
+                invalidate: () => {
+                    state.cachedWidth = undefined;
+                    state.cachedLines = undefined;
+                    state.cachedSkipped = undefined;
+                },
+            });
+        }
+    }
+    if (truncation?.truncated || fullOutputPath) {
+        const warnings = [];
+        if (fullOutputPath) {
+            warnings.push(`Full output: ${fullOutputPath}`);
+        }
+        if (truncation?.truncated) {
+            if (truncation.truncatedBy === "lines") {
+                warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+            }
+            else {
+                warnings.push(`Truncated: ${truncation.outputLines} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`);
+            }
+        }
+        component.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
+    }
+    if (startedAt !== undefined) {
+        const label = options.isPartial ? "Elapsed" : "Took";
+        const endTime = endedAt ?? Date.now();
+        component.addChild(new Text(`\n${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
+    }
+}
+export function createBashToolDefinition(cwd, options) {
+    const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
+    const commandPrefix = options?.commandPrefix;
+    const spawnHook = options?.spawnHook;
+    return {
+        name: "bash",
+        label: "bash",
+        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
+        parameters: bashSchema,
+        async execute(_toolCallId, { command, timeout }, signal, onUpdate, _ctx) {
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook);
+            const output = new OutputAccumulator({ tempFilePrefix: "pi-bash" });
+            let updateTimer;
+            let updateDirty = false;
+            let lastUpdateAt = 0;
+            const emitOutputUpdate = () => {
+                if (!onUpdate || !updateDirty)
+                    return;
+                updateDirty = false;
+                lastUpdateAt = Date.now();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                onUpdate({
+                    content: [{ type: "text", text: snapshot.content || "" }],
+                    details: {
+                        truncation: snapshot.truncation.truncated ? snapshot.truncation : undefined,
+                        fullOutputPath: snapshot.fullOutputPath,
+                    },
+                });
+            };
+            const clearUpdateTimer = () => {
+                if (updateTimer) {
+                    clearTimeout(updateTimer);
+                    updateTimer = undefined;
+                }
+            };
+            const scheduleOutputUpdate = () => {
+                if (!onUpdate)
+                    return;
+                updateDirty = true;
+                const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+                if (delay <= 0) {
+                    clearUpdateTimer();
+                    emitOutputUpdate();
+                    return;
+                }
+                updateTimer ??= setTimeout(() => {
+                    updateTimer = undefined;
+                    emitOutputUpdate();
+                }, delay);
+            };
+            if (onUpdate) {
+                onUpdate({ content: [], details: undefined });
+            }
+            const handleData = (data) => {
+                output.append(data);
+                scheduleOutputUpdate();
+            };
+            const finishOutput = async () => {
+                output.finish();
+                clearUpdateTimer();
+                emitOutputUpdate();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                await output.closeTempFile();
+                return snapshot;
+            };
+            const formatOutput = (snapshot, emptyText = "(no output)") => {
+                const truncation = snapshot.truncation;
+                let text = snapshot.content || emptyText;
+                let details;
+                if (truncation.truncated) {
+                    details = { truncation, fullOutputPath: snapshot.fullOutputPath };
+                    const startLine = truncation.totalLines - truncation.outputLines + 1;
+                    const endLine = truncation.totalLines;
+                    if (truncation.lastLinePartial) {
+                        const lastLineSize = formatSize(output.getLastLineBytes());
+                        text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else if (truncation.truncatedBy === "lines") {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                }
+                return { text, details };
+            };
+            const appendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: handleData,
+                        signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    const snapshot = await finishOutput();
+                    const { text } = formatOutput(snapshot, "");
+                    if (err instanceof Error && err.message === "aborted") {
+                        throw new Error(appendStatus(text, "Command aborted"));
+                    }
+                    if (err instanceof Error && err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
+                    }
+                    throw err;
+                }
+                const snapshot = await finishOutput();
+                const { text: outputText, details } = formatOutput(snapshot);
+                if (exitCode !== 0 && exitCode !== null) {
+                    throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
+                }
+                return { content: [{ type: "text", text: outputText }], details };
+            }
+            finally {
+                clearUpdateTimer();
+            }
+        },
+        renderCall(args, _theme, context) {
+            const state = context.state;
+            if (context.executionStarted && state.startedAt === undefined) {
+                state.startedAt = Date.now();
+                state.endedAt = undefined;
+            }
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatBashCall(args));
+            return text;
+        },
+        renderResult(result, options, _theme, context) {
+            const state = context.state;
+            if (state.startedAt !== undefined && options.isPartial && !state.interval) {
+                state.interval = setInterval(() => context.invalidate(), 1000);
+            }
+            if (!options.isPartial || context.isError) {
+                state.endedAt ??= Date.now();
+                if (state.interval) {
+                    clearInterval(state.interval);
+                    state.interval = undefined;
+                }
+            }
+            const component = context.lastComponent ?? new BashResultRenderComponent();
+            rebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt);
+            component.invalidate();
+            return component;
+        },
+    };
+}
+export function createBashTool(cwd, options) {
+    return wrapToolDefinition(createBashToolDefinition(cwd, options));
+}

package/dist/pi/coding-agent/core/tools/edit-diff.js

@@ -0,0 +1,344 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ */
+import * as Diff from "diff";
+import { constants } from "fs";
+import { access, readFile } from "fs/promises";
+import { resolveToCwd } from "./path-utils.js";
+export function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    if (lfIdx === -1)
+        return "\n";
+    if (crlfIdx === -1)
+        return "\n";
+    return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+export function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+/**
+ * Normalize text for fuzzy matching. Applies progressive transformations:
+ * - Strip trailing whitespace from each line
+ * - Normalize smart quotes to ASCII equivalents
+ * - Normalize Unicode dashes/hyphens to ASCII hyphen
+ * - Normalize special Unicode spaces to regular space
+ */
+export function normalizeForFuzzyMatch(text) {
+    return (text
+        .normalize("NFKC")
+        // Strip trailing whitespace per line
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        // Smart single quotes → '
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        // Smart double quotes → "
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        // Various dashes/hyphens → -
+        // U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
+        // U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        // Special spaces → regular space
+        // U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
+        // U+205F medium math space, U+3000 ideographic space
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+}
+/**
+ * Find oldText in content, trying exact match first, then fuzzy match.
+ * When fuzzy matching is used, the returned contentForReplacement is the
+ * fuzzy-normalized version of the content (trailing whitespace stripped,
+ * Unicode quotes/dashes normalized to ASCII).
+ */
+export function fuzzyFindText(content, oldText) {
+    // Try exact match first
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    // Try fuzzy match - work entirely in normalized space
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    // When fuzzy matching, we work in the normalized space for replacement.
+    // This means the output will have normalized whitespace/quotes/dashes,
+    // which is acceptable since we're fixing minor formatting differences anyway.
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent,
+    };
+}
+/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
+export function stripBom(content) {
+    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function countOccurrences(content, oldText) {
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    return fuzzyContent.split(fuzzyOldText).length - 1;
+}
+function getNotFoundError(path, editIndex, totalEdits) {
+    if (totalEdits === 1) {
+        return new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`);
+    }
+    return new Error(`Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`);
+}
+function getDuplicateError(path, editIndex, totalEdits, occurrences) {
+    if (totalEdits === 1) {
+        return new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`);
+    }
+    return new Error(`Found ${occurrences} occurrences of edits[${editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`);
+}
+function getEmptyOldTextError(path, editIndex, totalEdits) {
+    if (totalEdits === 1) {
+        return new Error(`oldText must not be empty in ${path}.`);
+    }
+    return new Error(`edits[${editIndex}].oldText must not be empty in ${path}.`);
+}
+function getNoChangeError(path, totalEdits) {
+    if (totalEdits === 1) {
+        return new Error(`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`);
+    }
+    return new Error(`No changes made to ${path}. The replacements produced identical content.`);
+}
+/**
+ * Apply one or more exact-text replacements to LF-normalized content.
+ *
+ * All edits are matched against the same original content. Replacements are
+ * then applied in reverse order so offsets remain stable. If any edit needs
+ * fuzzy matching, the operation runs in fuzzy-normalized content space to
+ * preserve current single-edit behavior.
+ */
+export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
+    const normalizedEdits = edits.map((edit) => ({
+        oldText: normalizeToLF(edit.oldText),
+        newText: normalizeToLF(edit.newText),
+    }));
+    for (let i = 0; i < normalizedEdits.length; i++) {
+        if (normalizedEdits[i].oldText.length === 0) {
+            throw getEmptyOldTextError(path, i, normalizedEdits.length);
+        }
+    }
+    const initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));
+    const baseContent = initialMatches.some((match) => match.usedFuzzyMatch)
+        ? normalizeForFuzzyMatch(normalizedContent)
+        : normalizedContent;
+    const matchedEdits = [];
+    for (let i = 0; i < normalizedEdits.length; i++) {
+        const edit = normalizedEdits[i];
+        const matchResult = fuzzyFindText(baseContent, edit.oldText);
+        if (!matchResult.found) {
+            throw getNotFoundError(path, i, normalizedEdits.length);
+        }
+        const occurrences = countOccurrences(baseContent, edit.oldText);
+        if (occurrences > 1) {
+            throw getDuplicateError(path, i, normalizedEdits.length, occurrences);
+        }
+        matchedEdits.push({
+            editIndex: i,
+            matchIndex: matchResult.index,
+            matchLength: matchResult.matchLength,
+            newText: edit.newText,
+        });
+    }
+    matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);
+    for (let i = 1; i < matchedEdits.length; i++) {
+        const previous = matchedEdits[i - 1];
+        const current = matchedEdits[i];
+        if (previous.matchIndex + previous.matchLength > current.matchIndex) {
+            throw new Error(`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`);
+        }
+    }
+    let newContent = baseContent;
+    for (let i = matchedEdits.length - 1; i >= 0; i--) {
+        const edit = matchedEdits[i];
+        newContent =
+            newContent.substring(0, edit.matchIndex) +
+                edit.newText +
+                newContent.substring(edit.matchIndex + edit.matchLength);
+    }
+    if (baseContent === newContent) {
+        throw getNoChangeError(path, normalizedEdits.length);
+    }
+    return { baseContent, newContent };
+}
+/** Generate a standard unified patch. */
+export function generateUnifiedPatch(path, oldContent, newContent, contextLines = 4) {
+    return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+        context: contextLines,
+        headerOptions: Diff.FILE_HEADERS_ONLY,
+    });
+}
+/**
+ * Generate a display-oriented diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export function generateDiffString(oldContent, newContent, contextLines = 4) {
+    const parts = Diff.diffLines(oldContent, newContent);
+    const output = [];
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const maxLineNum = Math.max(oldLines.length, newLines.length);
+    const lineNumWidth = String(maxLineNum).length;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    let firstChangedLine;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const raw = part.value.split("\n");
+        if (raw[raw.length - 1] === "") {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            // Capture the first changed line (in the new file)
+            if (firstChangedLine === undefined) {
+                firstChangedLine = newLineNum;
+            }
+            // Show the change
+            for (const line of raw) {
+                if (part.added) {
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    output.push(`+${lineNum} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    // removed
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(`-${lineNum} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            // Context lines - only show a few before/after changes
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            const hasLeadingChange = lastWasChange;
+            const hasTrailingChange = nextPartIsChange;
+            if (hasLeadingChange && hasTrailingChange) {
+                if (raw.length <= contextLines * 2) {
+                    for (const line of raw) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                }
+                else {
+                    const leadingLines = raw.slice(0, contextLines);
+                    const trailingLines = raw.slice(raw.length - contextLines);
+                    const skippedLines = raw.length - leadingLines.length - trailingLines.length;
+                    for (const line of leadingLines) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                    for (const line of trailingLines) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                }
+            }
+            else if (hasLeadingChange) {
+                const shownLines = raw.slice(0, contextLines);
+                const skippedLines = raw.length - shownLines.length;
+                for (const line of shownLines) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                if (skippedLines > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                }
+            }
+            else if (hasTrailingChange) {
+                const skippedLines = Math.max(0, raw.length - contextLines);
+                if (skippedLines > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                }
+                for (const line of raw.slice(skippedLines)) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+            }
+            else {
+                // Skip these context lines entirely
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join("\n"), firstChangedLine };
+}
+/**
+ * Compute the diff for one or more edit operations without applying them.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export async function computeEditsDiff(path, edits, cwd) {
+    const absolutePath = resolveToCwd(path, cwd);
+    try {
+        // Check if file exists and is readable
+        try {
+            await access(absolutePath, constants.R_OK);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+            return { error: `Could not edit file: ${path}. ${errorMessage}.` };
+        }
+        // Read the file
+        const rawContent = await readFile(absolutePath, "utf-8");
+        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+        const { text: content } = stripBom(rawContent);
+        const normalizedContent = normalizeToLF(content);
+        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+        // Generate the diff
+        return generateDiffString(baseContent, newContent);
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Compute the diff for a single edit operation without applying it.
+ * Kept as a convenience wrapper for single-edit callers.
+ */
+export async function computeEditDiff(path, oldText, newText, cwd) {
+    return computeEditsDiff(path, [{ oldText, newText }], cwd);
+}