@tomsun28/pizza 0.0.9 → 0.1.1

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

@@ -0,0 +1,59 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ */
+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 type Edit = {
+    op: "replace";
+    range: string;
+    new: string;
+} | {
+    op: "insert_before";
+    range: string;
+    new: string;
+} | {
+    op: "insert_after";
+    range: string;
+    new: string;
+} | {
+    op: "delete";
+    range: string;
+};
+export interface AppliedEditsResult {
+    baseContent: string;
+    newContent: string;
+}
+/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
+export declare function stripBom(content: string): {
+    bom: string;
+    text: string;
+};
+/**
+ * Apply one or more range edits to LF-normalized content.
+ *
+ * All edits are resolved against the same original content. Replacements are
+ * then applied in reverse order so offsets remain stable.
+ */
+export declare function applyEditsToNormalizedContent(normalizedContent: string, edits: Edit[], path: string): AppliedEditsResult;
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): {
+    diff: string;
+    firstChangedLine: number | undefined;
+};
+export interface EditDiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface EditDiffError {
+    error: string;
+}
+/**
+ * Compute the diff for one or more edit operations without applying them.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditsDiff(path: string, edits: Edit[], cwd: string): Promise<EditDiffResult | EditDiffError>;

package/dist/core/tools/edit-diff.js

@@ -0,0 +1,263 @@
+/**
+ * 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 { resolveRange } from "./line-anchors.js";
+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;
+}
+/** 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 getNoChangeError(path, totalEdits) {
+    if (totalEdits === 1) {
+        return new Error(`No changes made to ${path}. The edit produced identical content.`);
+    }
+    return new Error(`No changes made to ${path}. The edits produced identical content.`);
+}
+function normalizeReplacementText(newValue, existingText) {
+    const normalized = normalizeToLF(newValue);
+    if (existingText.endsWith("\n") && normalized.length > 0 && !normalized.endsWith("\n")) {
+        return `${normalized}\n`;
+    }
+    return normalized;
+}
+function normalizeInsertionText(newValue, op, range) {
+    const normalized = normalizeToLF(newValue);
+    if (normalized.length === 0) {
+        return "";
+    }
+    const lineText = normalized.endsWith("\n") ? normalized : `${normalized}\n`;
+    if (op === "insert_after" && range.existingText.length > 0 && !range.existingText.endsWith("\n")) {
+        return `\n${lineText}`;
+    }
+    return lineText;
+}
+/**
+ * Apply one or more range edits to LF-normalized content.
+ *
+ * All edits are resolved against the same original content. Replacements are
+ * then applied in reverse order so offsets remain stable.
+ */
+export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
+    for (let i = 0; i < edits.length; i++) {
+        const edit = edits[i];
+        if (edit.range.trim().length === 0) {
+            throw new Error(`edits[${i}].range must not be empty in ${path}.`);
+        }
+    }
+    const baseContent = normalizedContent;
+    const matchedEdits = [];
+    for (let i = 0; i < edits.length; i++) {
+        const edit = edits[i];
+        const resolved = resolveRange(baseContent, edit.range, path);
+        let matchIndex = resolved.startIndex;
+        let matchLength = resolved.endIndex - resolved.startIndex;
+        let replacement = "";
+        switch (edit.op) {
+            case "replace":
+                replacement = normalizeReplacementText(edit.new, resolved.existingText);
+                break;
+            case "insert_before":
+                matchLength = 0;
+                replacement = normalizeInsertionText(edit.new, edit.op, resolved);
+                break;
+            case "insert_after":
+                matchIndex = resolved.endIndex;
+                matchLength = 0;
+                replacement = normalizeInsertionText(edit.new, edit.op, resolved);
+                break;
+            case "delete":
+                replacement = "";
+                break;
+            default:
+                throw new Error(`edits[${i}].op is invalid in ${path}.`);
+        }
+        matchedEdits.push({
+            editIndex: i,
+            matchIndex,
+            matchLength,
+            replacement,
+        });
+    }
+    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.replacement +
+                newContent.substring(edit.matchIndex + edit.matchLength);
+    }
+    if (baseContent === newContent) {
+        throw getNoChangeError(path, edits.length);
+    }
+    return { baseContent, newContent };
+}
+/**
+ * Generate a unified 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 {
+            return { error: `File not found: ${path}` };
+        }
+        // Read the file
+        const rawContent = await readFile(absolutePath, "utf-8");
+        // Strip BOM before resolving line anchors.
+        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) };
+    }
+}

package/dist/core/tools/edit.d.ts

@@ -0,0 +1,49 @@
+import type { AgentTool } from "../agent/types.js";
+import { Box } from "@earendil-works/pi-tui";
+import { type Static } from "@sinclair/typebox";
+import type { ToolDefinition } from "../extensions/types.js";
+import { type EditDiffError, type EditDiffResult } from "./edit-diff.js";
+type EditPreview = EditDiffResult | EditDiffError;
+type EditRenderState = {
+    callComponent?: EditCallRenderComponent;
+};
+declare const editSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    edits: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        op: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"replace">, import("@sinclair/typebox").TLiteral<"insert_before">, import("@sinclair/typebox").TLiteral<"insert_after">, import("@sinclair/typebox").TLiteral<"delete">]>;
+        range: import("@sinclair/typebox").TString;
+        new: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+}>;
+export type EditToolInput = Static<typeof editSchema>;
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+}
+/**
+ * Pluggable operations for the edit tool.
+ * Override these to delegate file editing to remote systems (for example SSH).
+ */
+export interface EditOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Write content to a file */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Check if file is readable and writable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    /** Custom operations for file editing. Default: local filesystem */
+    operations?: EditOperations;
+}
+type EditCallRenderComponent = Box & {
+    preview?: EditPreview;
+    previewArgsKey?: string;
+    previewPending?: boolean;
+    settledError?: boolean;
+};
+export declare function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition<typeof editSchema, EditToolDetails | undefined, EditRenderState>;
+export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
+export {};