tarsk 0.4.4 → 0.4.6

package/dist/tools/ast-grep.js

@@ -1,273 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { spawnProcess } from "../core/utils.js";
-import path from "path";
-import { existsSync, readdirSync } from "fs";
-import { fileURLToPath } from "url";
-import { resolveToCwd, validatePathWithinCwd } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, formatSize, GREP_MAX_LINE_LENGTH, truncateHead, truncateLine, } from "./truncate.js";
-const astGrepSchema = Type.Object({
-    command: Type.Union([Type.Literal("run"), Type.Literal("scan")], {
-        description: "Mode: 'run' for simple pattern search, 'scan' for complex rule-based search",
-    }),
-    pattern: Type.Optional(Type.String({
-        description: "AST pattern for 'run' command. Use metavariables like $NAME, $$$ARGS. Example: 'console.log($ARG)'",
-    })),
-    lang: Type.String({
-        description: "Language to parse: javascript, typescript, python, rust, go, java, css, html, etc.",
-    }),
-    rule: Type.Optional(Type.String({
-        description: "YAML rule for 'scan' command. Supports kind, has, inside, all, any, not. Example: 'id: test\\nlanguage: javascript\\nrule:\\n  kind: function_declaration\\n  has:\\n    pattern: await $EXPR\\n    stopBy: end'",
-    })),
-    path: Type.Optional(Type.String({
-        description: "Directory or file to search (default: current directory)",
-    })),
-    limit: Type.Optional(Type.Number({
-        description: "Maximum number of matches to return (default: 50)",
-    })),
-});
-const DEFAULT_LIMIT = 50;
-const PLATFORM_PACKAGES = {
-    "darwin-arm64": "@ast-grep/cli-darwin-arm64",
-    "darwin-x64": "@ast-grep/cli-darwin-x64",
-    "linux-arm64": "@ast-grep/cli-linux-arm64-gnu",
-    "linux-x64": "@ast-grep/cli-linux-x64-gnu",
-    "win32-arm64": "@ast-grep/cli-win32-arm64-msvc",
-    "win32-ia32": "@ast-grep/cli-win32-ia32-msvc",
-    "win32-x64": "@ast-grep/cli-win32-x64-msvc",
-};
-function findBinInNodeModules(startDir, pkg, binName) {
-    const pkgPath = pkg.replace("/", path.sep);
-    let dir = startDir;
-    while (true) {
-        const nmDir = path.join(dir, "node_modules");
-        // Standard layout: node_modules/@ast-grep/cli-darwin-arm64/ast-grep
-        const standardPath = path.join(nmDir, pkgPath, binName);
-        if (existsSync(standardPath))
-            return standardPath;
-        // Bun cache layout: node_modules/.bun/@ast-grep+cli-darwin-arm64@*/node_modules/@ast-grep/cli-darwin-arm64/ast-grep
-        const bunDir = path.join(nmDir, ".bun");
-        if (existsSync(bunDir)) {
-            const bunPrefix = pkg.replace("/", "+");
-            try {
-                const entries = readdirSync(bunDir);
-                const match = entries.find((e) => e.startsWith(bunPrefix + "@"));
-                if (match) {
-                    const bunPath = path.join(bunDir, match, "node_modules", pkgPath, binName);
-                    if (existsSync(bunPath))
-                        return bunPath;
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
-// Resolve from the tarsk app's own install directory (where @ast-grep/cli is a dependency)
-const APP_DIR = path.resolve(fileURLToPath(import.meta.url), "../../..");
-function resolveAstGrepBin(cwd) {
-    const key = `${process.platform}-${process.arch}`;
-    const pkg = PLATFORM_PACKAGES[key];
-    if (!pkg)
-        return null;
-    const binName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-    console.log(`[ast-grep] resolving binary: platform=${key}, pkg=${pkg}, APP_DIR=${APP_DIR}`);
-    // First: search from the tarsk app's own directory (where @ast-grep/cli is installed as a dependency)
-    const appResult = findBinInNodeModules(APP_DIR, pkg, binName);
-    if (appResult)
-        return appResult;
-    // Fallback: search from the user's working directory
-    return findBinInNodeModules(cwd, pkg, binName);
-}
-export function createAstGrepTool(cwd) {
-    return {
-        name: "ast_grep",
-        label: "Code Search",
-        description: `Structural code search using AST patterns. Matches code by structure, not text. Use 'run' for simple pattern matching (e.g. 'console.log($ARG)') or 'scan' for complex YAML rules with kind/has/inside/all/any/not. Output truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB.`,
-        parameters: astGrepSchema,
-        execute: async (_toolCallId, { command, pattern, lang, rule, path: searchDir, limit }, signal) => {
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let settled = false;
-                const settle = (fn) => {
-                    if (!settled) {
-                        settled = true;
-                        fn();
-                    }
-                };
-                void (async () => {
-                    try {
-                        if (command === "run" && !pattern) {
-                            settle(() => reject(new Error("'pattern' is required when command is 'run'")));
-                            return;
-                        }
-                        if (command === "scan" && !rule) {
-                            settle(() => reject(new Error("'rule' is required when command is 'scan'")));
-                            return;
-                        }
-                        const searchPath = resolveToCwd(searchDir ?? ".", cwd);
-                        validatePathWithinCwd(searchPath, cwd);
-                        const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
-                        const args = [];
-                        if (command === "run") {
-                            args.push("run", "--pattern", pattern, "--lang", lang, "--json", searchPath);
-                        }
-                        else {
-                            args.push("scan", "--inline-rules", rule, "--json", searchPath);
-                        }
-                        const binPath = resolveAstGrepBin(cwd);
-                        if (!binPath) {
-                            settle(() => reject(new Error("ast-grep is not available. Install @ast-grep/cli or add it to PATH.")));
-                            return;
-                        }
-                        console.log(`[ast-grep] ${binPath} ${args.join(" ")}`);
-                        const child = spawnProcess(binPath, args, {
-                            stdio: ["ignore", "pipe", "pipe"],
-                        });
-                        const MAX_STDOUT_BYTES = 2 * 1024 * 1024; // 2MB cap on raw stdout
-                        let stdout = "";
-                        let stdoutBytes = 0;
-                        let stderr = "";
-                        let aborted = false;
-                        let killedDueToCap = false;
-                        const onAbort = () => {
-                            aborted = true;
-                            if (!child.killed)
-                                child.kill();
-                        };
-                        signal?.addEventListener("abort", onAbort, { once: true });
-                        child.stdout?.on("data", (chunk) => {
-                            if (killedDueToCap)
-                                return;
-                            stdoutBytes += chunk.length;
-                            if (stdoutBytes > MAX_STDOUT_BYTES) {
-                                killedDueToCap = true;
-                                if (!child.killed)
-                                    child.kill();
-                                return;
-                            }
-                            stdout += chunk.toString();
-                        });
-                        child.stderr?.on("data", (chunk) => {
-                            stderr += chunk.toString();
-                        });
-                        child.on("error", (error) => {
-                            signal?.removeEventListener("abort", onAbort);
-                            settle(() => reject(new Error(`Failed to run ast-grep: ${error.message}`)));
-                        });
-                        child.on("close", (code) => {
-                            signal?.removeEventListener("abort", onAbort);
-                            console.log(`[ast-grep] exit code: ${code}, stdout: ${stdout.length} bytes, stderr: ${stderr.length} bytes`);
-                            if (stderr.trim())
-                                console.log(`[ast-grep] stderr: ${stderr.trim()}`);
-                            if (aborted) {
-                                settle(() => reject(new Error("Operation aborted")));
-                                return;
-                            }
-                            if (!killedDueToCap && code !== 0 && code !== 1) {
-                                const errMsg = stderr.trim() || `ast-grep exited with code ${code}`;
-                                settle(() => reject(new Error(errMsg)));
-                                return;
-                            }
-                            let matches;
-                            try {
-                                matches = JSON.parse(stdout || "[]");
-                            }
-                            catch {
-                                // If killed due to cap, stdout is truncated JSON — try to recover
-                                if (killedDueToCap) {
-                                    const lastBrace = stdout.lastIndexOf("}");
-                                    if (lastBrace > 0) {
-                                        try {
-                                            matches = JSON.parse(stdout.slice(0, lastBrace + 1) + "]");
-                                        }
-                                        catch {
-                                            matches = [];
-                                        }
-                                    }
-                                    else {
-                                        matches = [];
-                                    }
-                                }
-                                else if (!stdout.trim()) {
-                                    settle(() => resolve({
-                                        content: [{ type: "text", text: "No matches found" }],
-                                        details: undefined,
-                                    }));
-                                    return;
-                                }
-                                else {
-                                    settle(() => reject(new Error(`Failed to parse ast-grep JSON output: ${stdout.slice(0, 200)}`)));
-                                    return;
-                                }
-                            }
-                            if (!Array.isArray(matches) || matches.length === 0) {
-                                settle(() => resolve({
-                                    content: [{ type: "text", text: "No matches found" }],
-                                    details: undefined,
-                                }));
-                                return;
-                            }
-                            const matchLimitReached = matches.length > effectiveLimit;
-                            if (matchLimitReached) {
-                                matches = matches.slice(0, effectiveLimit);
-                            }
-                            let linesTruncated = false;
-                            const outputLines = [];
-                            for (const match of matches) {
-                                const filePath = match.file ?? "unknown";
-                                const relativePath = path.relative(searchPath, filePath).replace(/\\/g, "/") || filePath;
-                                const lineNum = (match.range?.start?.line ?? 0) + 1;
-                                const matchText = (match.lines ?? match.text ?? "").trimEnd();
-                                const firstLine = matchText.split("\n")[0] ?? "";
-                                const { text: truncatedText, wasTruncated } = truncateLine(firstLine);
-                                if (wasTruncated)
-                                    linesTruncated = true;
-                                outputLines.push(`${relativePath}:${lineNum}: ${truncatedText}`);
-                            }
-                            const rawOutput = outputLines.join("\n");
-                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-                            let output = truncation.content;
-                            const details = {};
-                            const notices = [];
-                            if (killedDueToCap) {
-                                notices.push(`Output exceeded 2MB cap. Refine your pattern for more precise results`);
-                            }
-                            if (matchLimitReached) {
-                                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
-                                details.matchLimitReached = effectiveLimit;
-                            }
-                            if (truncation.truncated) {
-                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-                                details.truncation = truncation;
-                            }
-                            if (linesTruncated) {
-                                notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
-                                details.linesTruncated = true;
-                            }
-                            if (notices.length > 0)
-                                output += `\n\n[${notices.join(". ")}]`;
-                            settle(() => resolve({
-                                content: [{ type: "text", text: output }],
-                                details: Object.keys(details).length > 0 ? details : undefined,
-                            }));
-                        });
-                    }
-                    catch {
-                        settle(() => reject(new Error("Error processing ast-grep request")));
-                    }
-                })();
-            });
-        },
-    };
-}
-export const astGrepTool = createAstGrepTool(process.cwd());
-//# sourceMappingURL=ast-grep.js.map

package/dist/tools/bash.d.ts

@@ -1,33 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import { type TruncationResult } from "./truncate.js";
-declare const bashSchema: import("@sinclair/typebox").TObject<{
-    command: import("@sinclair/typebox").TString;
-    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-export type BashToolInput = Static<typeof bashSchema>;
-export interface BashToolDetails {
-    truncation?: TruncationResult;
-    fullOutputPath?: string;
-}
-export interface BashOperations {
-    exec: (command: string, cwd: string, options: {
-        onData: (data: Buffer) => void;
-        signal?: AbortSignal;
-        timeout?: number;
-        env?: NodeJS.ProcessEnv;
-    }) => Promise<{
-        exitCode: number | null;
-    }>;
-}
-export interface BashToolOptions {
-    operations?: BashOperations;
-    commandPrefix?: string;
-}
-export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
-export declare const bashTool: AgentTool<import("@sinclair/typebox").TObject<{
-    command: import("@sinclair/typebox").TString;
-    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>, any>;
-export {};
-//# sourceMappingURL=bash.d.ts.map

package/dist/tools/bash.js

@@ -1,186 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { createWriteStream, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Type } from "@sinclair/typebox";
-import { spawnProcess } from "../core/utils.js";
-import { getShellConfig, getShellEnv, killProcessTree } from "./shell.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail, } from "./truncate.js";
-function getTempFilePath() {
-    return join(tmpdir(), `tarsk-bash-${randomBytes(8).toString("hex")}.log`);
-}
-const bashSchema = Type.Object({
-    command: Type.String({ description: "Bash command to execute" }),
-    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
-});
-const defaultBashOperations = {
-    exec: (command, cwd, { onData, signal, timeout, env }) => {
-        return new Promise((resolve, reject) => {
-            const { shell, args } = getShellConfig();
-            if (!existsSync(cwd)) {
-                reject(new Error(`Working directory does not exist: ${cwd}`));
-                return;
-            }
-            const child = spawnProcess(shell, [...args, command], {
-                cwd,
-                detached: true,
-                env: (env
-                    ? Object.fromEntries(Object.entries(env)
-                        .filter(([_, v]) => v !== undefined)
-                        .map(([k, v]) => [k, v]))
-                    : undefined) ??
-                    Object.fromEntries(Object.entries(getShellEnv())
-                        .filter(([_, v]) => v !== undefined)
-                        .map(([k, v]) => [k, v])),
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let timedOut = false;
-            let timeoutHandle;
-            if (timeout !== undefined && timeout > 0) {
-                timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    if (child.pid)
-                        killProcessTree(child.pid);
-                }, timeout * 1000);
-            }
-            if (child.stdout)
-                child.stdout.on("data", onData);
-            if (child.stderr)
-                child.stderr.on("data", onData);
-            child.on("error", (err) => {
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
-                if (signal)
-                    signal.removeEventListener("abort", onAbort);
-                reject(err);
-            });
-            const onAbort = () => {
-                if (child.pid)
-                    killProcessTree(child.pid);
-            };
-            if (signal) {
-                if (signal.aborted)
-                    onAbort();
-                else
-                    signal.addEventListener("abort", onAbort, { once: true });
-            }
-            child.on("close", (code) => {
-                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 });
-            });
-        });
-    },
-};
-export function createBashTool(cwd, options) {
-    const ops = options?.operations ?? defaultBashOperations;
-    const commandPrefix = options?.commandPrefix;
-    return {
-        name: "bash",
-        label: "bash",
-        description: `Execute a bash command in the current working directory. Output truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. Optionally provide a timeout in seconds.`,
-        parameters: bashSchema,
-        execute: async (_toolCallId, { command, timeout }, signal, onUpdate) => {
-            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
-            console.log(`[ai] bash-start: ${resolvedCommand}`);
-            return new Promise((resolve, reject) => {
-                let tempFilePath;
-                let tempFileStream;
-                let totalBytes = 0;
-                const chunks = [];
-                let chunksBytes = 0;
-                const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
-                const handleData = (data) => {
-                    totalBytes += data.length;
-                    if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
-                        tempFilePath = getTempFilePath();
-                        tempFileStream = createWriteStream(tempFilePath);
-                        for (const chunk of chunks)
-                            tempFileStream.write(chunk);
-                    }
-                    if (tempFileStream)
-                        tempFileStream.write(data);
-                    chunks.push(data);
-                    chunksBytes += data.length;
-                    while (chunksBytes > maxChunksBytes && chunks.length > 1) {
-                        const removed = chunks.shift();
-                        chunksBytes -= removed.length;
-                    }
-                    if (onUpdate) {
-                        const fullText = Buffer.concat(chunks).toString("utf-8");
-                        const truncation = truncateTail(fullText);
-                        onUpdate({
-                            content: [{ type: "text", text: truncation.content || "" }],
-                            details: {
-                                truncation: truncation.truncated ? truncation : undefined,
-                                fullOutputPath: tempFilePath,
-                            },
-                        });
-                    }
-                };
-                ops
-                    .exec(resolvedCommand, cwd, { onData: handleData, signal, timeout, env: getShellEnv() })
-                    .then(({ exitCode }) => {
-                    console.log(`[ai] bash-end: ${resolvedCommand}`);
-                    if (tempFileStream)
-                        tempFileStream.end();
-                    const fullOutput = Buffer.concat(chunks).toString("utf-8");
-                    const truncation = truncateTail(fullOutput);
-                    let outputText = truncation.content || "(no output)";
-                    let details;
-                    if (truncation.truncated) {
-                        details = { truncation, fullOutputPath: tempFilePath };
-                        const startLine = truncation.totalLines - truncation.outputLines + 1;
-                        const endLine = truncation.totalLines;
-                        if (truncation.lastLinePartial) {
-                            outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}. Full output: ${tempFilePath}]`;
-                        }
-                        else if (truncation.truncatedBy === "lines") {
-                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
-                        }
-                        else {
-                            outputText += `\n\n[Showing lines ${startLine}-${endLine} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
-                        }
-                    }
-                    if (exitCode !== 0 && exitCode !== null) {
-                        outputText += `\n\nCommand exited with code ${exitCode}`;
-                        reject(new Error(outputText));
-                    }
-                    else {
-                        resolve({ content: [{ type: "text", text: outputText }], details });
-                    }
-                })
-                    .catch((err) => {
-                    console.log(`[ai] bash-end: ${resolvedCommand}`);
-                    if (tempFileStream)
-                        tempFileStream.end();
-                    const output = Buffer.concat(chunks).toString("utf-8");
-                    if (err.message === "aborted") {
-                        reject(new Error(output ? `${output}\n\nCommand aborted` : "Command aborted"));
-                    }
-                    else if (err.message.startsWith("timeout:")) {
-                        const secs = err.message.split(":")[1];
-                        reject(new Error(output
-                            ? `${output}\n\nCommand timed out after ${secs} seconds`
-                            : `Command timed out after ${secs} seconds`));
-                    }
-                    else {
-                        reject(err);
-                    }
-                });
-            });
-        },
-    };
-}
-export const bashTool = createBashTool(process.cwd());
-//# sourceMappingURL=bash.js.map

package/dist/tools/edit-diff.d.ts

@@ -1,24 +0,0 @@
-/**
- * Shared diff computation utilities for the edit tool.
- */
-export declare function detectLineEnding(content: string): "\r\n" | "\n";
-export declare function normalizeToLF(text: string): string;
-export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
-export declare function normalizeForFuzzyMatch(text: string): string;
-export interface FuzzyMatchResult {
-    found: boolean;
-    index: number;
-    matchLength: number;
-    usedFuzzyMatch: boolean;
-    contentForReplacement: string;
-}
-export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
-export declare function stripBom(content: string): {
-    bom: string;
-    text: string;
-};
-export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): {
-    diff: string;
-    firstChangedLine: number | undefined;
-};
-//# sourceMappingURL=edit-diff.d.ts.map

package/dist/tools/edit-diff.js

@@ -1,136 +0,0 @@
-/**
- * Shared diff computation utilities for the edit tool.
- */
-import * as Diff from "diff";
-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;
-}
-export function normalizeForFuzzyMatch(text) {
-    return text
-        .split("\n")
-        .map((line) => line.trimEnd())
-        .join("\n")
-        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
-        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
-        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
-        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
-}
-export function fuzzyFindText(content, oldText) {
-    const exactIndex = content.indexOf(oldText);
-    if (exactIndex !== -1) {
-        return {
-            found: true,
-            index: exactIndex,
-            matchLength: oldText.length,
-            usedFuzzyMatch: false,
-            contentForReplacement: content,
-        };
-    }
-    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,
-        };
-    }
-    return {
-        found: true,
-        index: fuzzyIndex,
-        matchLength: fuzzyOldText.length,
-        usedFuzzyMatch: true,
-        contentForReplacement: fuzzyContent,
-    };
-}
-export function stripBom(content) {
-    return content.startsWith("\uFEFF")
-        ? { bom: "\uFEFF", text: content.slice(1) }
-        : { bom: "", text: content };
-}
-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) {
-            firstChangedLine ??= newLineNum;
-            for (const line of raw) {
-                if (part.added) {
-                    output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
-                    newLineNum++;
-                }
-                else {
-                    output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-                    oldLineNum++;
-                }
-            }
-            lastWasChange = true;
-        }
-        else {
-            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
-            if (lastWasChange || nextPartIsChange) {
-                let linesToShow = raw;
-                let skipStart = 0;
-                let skipEnd = 0;
-                if (!lastWasChange) {
-                    skipStart = Math.max(0, raw.length - contextLines);
-                    linesToShow = raw.slice(skipStart);
-                }
-                if (!nextPartIsChange && linesToShow.length > contextLines) {
-                    skipEnd = linesToShow.length - contextLines;
-                    linesToShow = linesToShow.slice(0, contextLines);
-                }
-                if (skipStart > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-                    oldLineNum += skipStart;
-                    newLineNum += skipStart;
-                }
-                for (const line of linesToShow) {
-                    output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-                    oldLineNum++;
-                    newLineNum++;
-                }
-                if (skipEnd > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-                    oldLineNum += skipEnd;
-                    newLineNum += skipEnd;
-                }
-            }
-            else {
-                oldLineNum += raw.length;
-                newLineNum += raw.length;
-            }
-            lastWasChange = false;
-        }
-    }
-    return { diff: output.join("\n"), firstChangedLine };
-}
-//# sourceMappingURL=edit-diff.js.map