@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/tools/edit.js

@@ -0,0 +1,340 @@
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+import { renderDiff } from "../../modes/interactive/components/diff.js";
+import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { invalidArgText, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const rangeEditSchema = Type.Object({
+    op: Type.Union([
+        Type.Literal("replace"),
+        Type.Literal("insert_before"),
+        Type.Literal("insert_after"),
+        Type.Literal("delete"),
+    ], { description: "Edit operation to apply to the anchored range." }),
+    range: Type.String({
+        description: "Hashline range from read output. Use <line>#<hash> for one line or <start>#<hash>..<end>#<hash> for a line range.",
+    }),
+    new: Type.Optional(Type.String({
+        description: 'New text for replace, insert_before, and insert_after. Omit for op="delete". Missing trailing newlines are normalized for whole-line edits.',
+    })),
+}, { additionalProperties: false });
+const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+    edits: Type.Array(rangeEditSchema, {
+        description: "One or more edits using ranges from read output. Each edit is resolved against the original file, not incrementally. Do not include overlapping or nested ranges. If two changes touch the same block or nearby lines, merge them into one range edit instead.",
+    }),
+}, { additionalProperties: false });
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+};
+function prepareEditArguments(input) {
+    if (!input || typeof input !== "object") {
+        return input;
+    }
+    const args = input;
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array
+    if (typeof args.edits === "string") {
+        try {
+            const parsed = JSON.parse(args.edits);
+            if (Array.isArray(parsed))
+                args.edits = parsed;
+        }
+        catch { }
+    }
+    return args;
+}
+function isValidEditEntry(edit) {
+    if (!edit || typeof edit !== "object") {
+        return false;
+    }
+    const record = edit;
+    if (record.op !== "replace" &&
+        record.op !== "insert_before" &&
+        record.op !== "insert_after" &&
+        record.op !== "delete") {
+        return false;
+    }
+    if (typeof record.range !== "string") {
+        return false;
+    }
+    return record.op === "delete" || typeof record.new === "string";
+}
+function validateEditInput(input) {
+    if (!Array.isArray(input.edits) || input.edits.length === 0) {
+        throw new Error("Edit tool input is invalid. edits must contain at least one edit.");
+    }
+    if (!input.edits.every(isValidEditEntry)) {
+        throw new Error('Edit tool input is invalid. Each edit must include op and range, plus new unless op is "delete".');
+    }
+    return { path: input.path, edits: input.edits };
+}
+function createEditCallRenderComponent() {
+    return Object.assign(new Box(1, 1, (text) => text), {
+        preview: undefined,
+        previewArgsKey: undefined,
+        previewPending: false,
+        settledError: false,
+    });
+}
+function getEditCallRenderComponent(state, lastComponent) {
+    if (lastComponent instanceof Box) {
+        const component = lastComponent;
+        state.callComponent = component;
+        return component;
+    }
+    if (state.callComponent) {
+        return state.callComponent;
+    }
+    const component = createEditCallRenderComponent();
+    state.callComponent = component;
+    return component;
+}
+function getRenderablePreviewInput(args) {
+    if (!args) {
+        return null;
+    }
+    const path = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : null;
+    if (!path) {
+        return null;
+    }
+    if (Array.isArray(args.edits) &&
+        args.edits.length > 0 &&
+        args.edits.every((edit) => isValidEditEntry(edit))) {
+        return { path, edits: args.edits };
+    }
+    return null;
+}
+function formatEditCall(args, theme) {
+    const invalidArg = invalidArgText(theme);
+    const rawPath = str(args?.file_path ?? args?.path);
+    const path = rawPath !== null ? shortenPath(rawPath) : null;
+    const pathDisplay = path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+    return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
+}
+function formatEditResult(args, preview, result, theme, isError) {
+    const rawPath = str(args?.file_path ?? args?.path);
+    const previewDiff = preview && !("error" in preview) ? preview.diff : undefined;
+    const previewError = preview && "error" in preview ? preview.error : undefined;
+    if (isError) {
+        const errorText = result.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text || "")
+            .join("\n");
+        if (!errorText || errorText === previewError) {
+            return undefined;
+        }
+        return theme.fg("error", errorText);
+    }
+    const resultDiff = result.details?.diff;
+    if (resultDiff && resultDiff !== previewDiff) {
+        return renderDiff(resultDiff, { filePath: rawPath ?? undefined });
+    }
+    return undefined;
+}
+function getEditHeaderBg(preview, settledError, theme) {
+    if (preview) {
+        if ("error" in preview) {
+            return (text) => theme.bg("toolErrorBg", text);
+        }
+        return (text) => theme.bg("toolSuccessBg", text);
+    }
+    if (settledError) {
+        return (text) => theme.bg("toolErrorBg", text);
+    }
+    return (text) => theme.bg("toolPendingBg", text);
+}
+function buildEditCallComponent(component, args, theme) {
+    component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme));
+    component.clear();
+    component.addChild(new Text(formatEditCall(args, theme), 0, 0));
+    if (!component.preview) {
+        return component;
+    }
+    const body = "error" in component.preview ? theme.fg("error", component.preview.error) : renderDiff(component.preview.diff);
+    component.addChild(new Spacer(1));
+    component.addChild(new Text(body, 0, 0));
+    return component;
+}
+function setEditPreview(component, preview, argsKey) {
+    const current = component.preview;
+    const changed = current === undefined ||
+        ("error" in current && "error" in preview
+            ? current.error !== preview.error
+            : "error" in current !== "error" in preview) ||
+        (!("error" in current) &&
+            !("error" in preview) &&
+            (current.diff !== preview.diff || current.firstChangedLine !== preview.firstChangedLine));
+    component.preview = preview;
+    component.previewArgsKey = argsKey;
+    component.previewPending = false;
+    return changed;
+}
+export function createEditToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: "edit",
+        label: "edit",
+        description: "Edit a single file using range anchors from read output. Supports replace, insert_before, insert_after, and delete for one line or a continuous whole-line range. Ranges fail safely if the referenced lines changed or became ambiguous. If two changes affect the same block or nearby lines, merge them into one range edit instead of emitting overlapping edits.",
+        promptSnippet: "Make precise file edits with read range anchors, including multiple disjoint edits in one call",
+        promptGuidelines: [
+            "Use edits[].range from read output for every edit.",
+            "Use op=insert_after or op=insert_before instead of repeating the anchored line.",
+            "For partial-line changes, use op=replace and replace the whole line with the updated line.",
+            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+            "Each edit is resolved against the original file, not after earlier edits are applied. Do not emit overlapping or nested ranges. Merge nearby changes into one edit.",
+        ],
+        parameters: editSchema,
+        renderShell: "self",
+        prepareArguments: prepareEditArguments,
+        async execute(_toolCallId, input, signal, _onUpdate, _ctx) {
+            const { path, edits } = validateEditInput(input);
+            const absolutePath = resolveToCwd(path, cwd);
+            return withFileMutationQueue(absolutePath, () => new Promise((resolve, reject) => {
+                // Check if already aborted.
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler.
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error("Operation aborted"));
+                };
+                if (signal) {
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+                // Perform the edit operation.
+                void (async () => {
+                    try {
+                        // Check if file exists.
+                        try {
+                            await ops.access(absolutePath);
+                        }
+                        catch {
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`File not found: ${path}`));
+                            return;
+                        }
+                        // Check if aborted before reading.
+                        if (aborted) {
+                            return;
+                        }
+                        // Read the file.
+                        const buffer = await ops.readFile(absolutePath);
+                        const rawContent = buffer.toString("utf-8");
+                        // Check if aborted after reading.
+                        if (aborted) {
+                            return;
+                        }
+                        // Strip BOM before resolving line anchors.
+                        const { bom, text: content } = stripBom(rawContent);
+                        const originalEnding = detectLineEnding(content);
+                        const normalizedContent = normalizeToLF(content);
+                        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+                        // Check if aborted before writing.
+                        if (aborted) {
+                            return;
+                        }
+                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                        await ops.writeFile(absolutePath, finalContent);
+                        // Check if aborted after writing.
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler.
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        const diffResult = generateDiffString(baseContent, newContent);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Successfully applied ${edits.length} edit(s) in ${path}.`,
+                                },
+                            ],
+                            details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+                        });
+                    }
+                    catch (error) {
+                        // Clean up abort handler.
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error instanceof Error ? error : new Error(String(error)));
+                        }
+                    }
+                })();
+            }));
+        },
+        renderCall(args, theme, context) {
+            const component = getEditCallRenderComponent(context.state, context.lastComponent);
+            const previewInput = getRenderablePreviewInput(args);
+            const argsKey = previewInput
+                ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits })
+                : undefined;
+            if (component.previewArgsKey !== argsKey) {
+                component.preview = undefined;
+                component.previewArgsKey = argsKey;
+                component.previewPending = false;
+                component.settledError = false;
+            }
+            if (context.argsComplete && previewInput && !component.preview && !component.previewPending) {
+                component.previewPending = true;
+                const requestKey = argsKey;
+                void computeEditsDiff(previewInput.path, previewInput.edits, context.cwd).then((preview) => {
+                    if (component.previewArgsKey === requestKey) {
+                        setEditPreview(component, preview, requestKey);
+                        context.invalidate();
+                    }
+                });
+            }
+            return buildEditCallComponent(component, args, theme);
+        },
+        renderResult(result, _options, theme, context) {
+            const callComponent = context.state.callComponent;
+            const previewInput = getRenderablePreviewInput(context.args);
+            const argsKey = previewInput
+                ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits })
+                : undefined;
+            const typedResult = result;
+            const resultDiff = !context.isError ? typedResult.details?.diff : undefined;
+            let changed = false;
+            if (callComponent) {
+                if (typeof resultDiff === "string") {
+                    changed =
+                        setEditPreview(callComponent, { diff: resultDiff, firstChangedLine: typedResult.details?.firstChangedLine }, argsKey) || changed;
+                }
+                if (callComponent.settledError !== context.isError) {
+                    callComponent.settledError = context.isError;
+                    changed = true;
+                }
+                if (changed) {
+                    context.invalidate();
+                }
+            }
+            const output = formatEditResult(context.args, callComponent?.preview, typedResult, theme, context.isError);
+            const component = context.lastComponent ?? new Container();
+            component.clear();
+            if (!output) {
+                return component;
+            }
+            component.addChild(new Spacer(1));
+            component.addChild(new Text(output, 1, 0));
+            return component;
+        },
+    };
+}
+export function createEditTool(cwd, options) {
+    return wrapToolDefinition(createEditToolDefinition(cwd, options));
+}

package/dist/core/tools/file-mutation-queue.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Serialize file mutation operations targeting the same file.
+ * Operations for different files still run in parallel.
+ */
+export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;

package/dist/core/tools/file-mutation-queue.js

@@ -0,0 +1,36 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+const fileMutationQueues = new Map();
+function getMutationQueueKey(filePath) {
+    const resolvedPath = resolve(filePath);
+    try {
+        return realpathSync.native(resolvedPath);
+    }
+    catch {
+        return resolvedPath;
+    }
+}
+/**
+ * Serialize file mutation operations targeting the same file.
+ * Operations for different files still run in parallel.
+ */
+export async function withFileMutationQueue(filePath, fn) {
+    const key = getMutationQueueKey(filePath);
+    const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
+    let releaseNext;
+    const nextQueue = new Promise((resolveQueue) => {
+        releaseNext = resolveQueue;
+    });
+    const chainedQueue = currentQueue.then(() => nextQueue);
+    fileMutationQueues.set(key, chainedQueue);
+    await currentQueue;
+    try {
+        return await fn();
+    }
+    finally {
+        releaseNext();
+        if (fileMutationQueues.get(key) === chainedQueue) {
+            fileMutationQueues.delete(key);
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { AgentTool } from "../agent/types.js";
+import { type Static } from "@sinclair/typebox";
+import type { ToolDefinition } from "../extensions/types.js";
+import { type TruncationResult } from "./truncate.js";
+declare const findSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type FindToolInput = Static<typeof findSchema>;
+export interface FindToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+}
+/**
+ * Pluggable operations for the find tool.
+ * Override these to delegate file search to remote systems (for example SSH).
+ */
+export interface FindOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Find files matching glob pattern. Returns relative or absolute paths. */
+    glob: (pattern: string, cwd: string, options: {
+        ignore: string[];
+        limit: number;
+    }) => Promise<string[]> | string[];
+}
+export interface FindToolOptions {
+    /** Custom operations for find. Default: local filesystem plus fd */
+    operations?: FindOperations;
+}
+export declare function createFindToolDefinition(cwd: string, options?: FindToolOptions): ToolDefinition<typeof findSchema, FindToolDetails | undefined>;
+export declare function createFindTool(cwd: string, options?: FindToolOptions): AgentTool<typeof findSchema>;
+export {};