@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/tools/line-anchors.js

@@ -0,0 +1,151 @@
+import { createHash } from "crypto";
+const HASH_LENGTH = 2;
+const LINE_ANCHOR_PATTERN = /^([1-9]\d*)#([0-9a-f]{2})$/;
+export function hashLine(line) {
+    return createHash("sha256").update(line, "utf-8").digest("hex").slice(0, HASH_LENGTH);
+}
+export function formatLineAnchor(lineNumber, line) {
+    return `${lineNumber}#${hashLine(line)}`;
+}
+export function formatRange(start, end = start) {
+    const startId = `${start.line}#${start.hash}`;
+    const endId = `${end.line}#${end.hash}`;
+    return startId === endId ? startId : `${startId}..${endId}`;
+}
+export function looksLikeRange(value) {
+    try {
+        parseRange(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function parseRange(range) {
+    const trimmed = range.trim();
+    if (!trimmed) {
+        throw new Error("range must not be empty.");
+    }
+    const parts = trimmed.split("..");
+    if (parts.length > 2) {
+        throw new Error(`Invalid range "${range}". Expected <line>#<hash> or <start>#<hash>..<end>#<hash>.`);
+    }
+    const start = parseLineAnchor(parts[0], range);
+    const end = parseLineAnchor(parts[1] ?? parts[0], range);
+    if (start.line > end.line) {
+        throw new Error(`Invalid range "${range}". Start line must be before or equal to end line.`);
+    }
+    return { start, end };
+}
+export function buildLineRecords(content) {
+    if (content.length === 0) {
+        return [
+            {
+                lineNumber: 1,
+                text: "",
+                startIndex: 0,
+                contentEndIndex: 0,
+                replacementEndIndex: 0,
+                hash: hashLine(""),
+            },
+        ];
+    }
+    const records = [];
+    let startIndex = 0;
+    let lineNumber = 1;
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] !== "\n")
+            continue;
+        const text = content.slice(startIndex, i);
+        records.push({
+            lineNumber,
+            text,
+            startIndex,
+            contentEndIndex: i,
+            replacementEndIndex: i + 1,
+            hash: hashLine(text),
+        });
+        startIndex = i + 1;
+        lineNumber++;
+    }
+    if (startIndex < content.length) {
+        const text = content.slice(startIndex);
+        records.push({
+            lineNumber,
+            text,
+            startIndex,
+            contentEndIndex: content.length,
+            replacementEndIndex: content.length,
+            hash: hashLine(text),
+        });
+    }
+    return records;
+}
+export function annotateTextWithLineAnchors(text, startLine = 1) {
+    const lines = text.split("\n");
+    if (text.endsWith("\n")) {
+        lines.pop();
+    }
+    if (lines.length === 0) {
+        return "";
+    }
+    return lines.map((line, index) => `${formatLineAnchor(startLine + index, line)} | ${line}`).join("\n");
+}
+export function resolveRange(content, range, path) {
+    const anchor = parseRange(range);
+    const records = buildLineRecords(content);
+    const length = anchor.end.line - anchor.start.line + 1;
+    const direct = resolveByRecordIndex(records, anchor.start.line - 1, length, anchor);
+    if (direct) {
+        return buildResolvedRange(content, range, records, direct.startIndex, direct.endIndex, false);
+    }
+    const candidates = [];
+    for (let i = 0; i <= records.length - length; i++) {
+        const candidate = resolveByRecordIndex(records, i, length, anchor);
+        if (candidate) {
+            candidates.push(candidate);
+        }
+    }
+    if (candidates.length === 1) {
+        return buildResolvedRange(content, range, records, candidates[0].startIndex, candidates[0].endIndex, true);
+    }
+    if (candidates.length > 1) {
+        throw new Error(`range ${range} is ambiguous in ${path}. Re-read a smaller region and use current line anchors.`);
+    }
+    throw new Error(`range ${range} is stale in ${path}. Re-read the file and use current line anchors.`);
+}
+function parseLineAnchor(value, originalRange) {
+    const match = value?.match(LINE_ANCHOR_PATTERN);
+    if (!match) {
+        throw new Error(`Invalid range "${originalRange}". Expected <line>#<2-hex-hash> or <start>#<hash>..<end>#<hash>.`);
+    }
+    return {
+        line: Number(match[1]),
+        hash: match[2],
+    };
+}
+function resolveByRecordIndex(records, startIndex, length, anchor) {
+    if (startIndex < 0)
+        return undefined;
+    const endIndex = startIndex + length - 1;
+    if (endIndex >= records.length)
+        return undefined;
+    const start = records[startIndex];
+    const end = records[endIndex];
+    if (start.hash !== anchor.start.hash || end.hash !== anchor.end.hash)
+        return undefined;
+    return { startIndex, endIndex };
+}
+function buildResolvedRange(content, range, records, startRecordIndex, endRecordIndex, usedRelocation) {
+    const start = records[startRecordIndex];
+    const end = records[endRecordIndex];
+    return {
+        range,
+        startLine: start.lineNumber,
+        endLine: end.lineNumber,
+        startIndex: start.startIndex,
+        endIndex: end.replacementEndIndex,
+        existingText: content.slice(start.startIndex, end.replacementEndIndex),
+        usedRelocation,
+    };
+}

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

@@ -0,0 +1,36 @@
+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 lsSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type LsToolInput = Static<typeof lsSchema>;
+export interface LsToolDetails {
+    truncation?: TruncationResult;
+    entryLimitReached?: number;
+}
+/**
+ * Pluggable operations for the ls tool.
+ * Override these to delegate directory listing to remote systems (for example SSH).
+ */
+export interface LsOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Get file or directory stats. Throws if not found. */
+    stat: (absolutePath: string) => Promise<{
+        isDirectory: () => boolean;
+    }> | {
+        isDirectory: () => boolean;
+    };
+    /** Read directory entries */
+    readdir: (absolutePath: string) => Promise<string[]> | string[];
+}
+export interface LsToolOptions {
+    /** Custom operations for directory listing. Default: local filesystem */
+    operations?: LsOperations;
+}
+export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition<typeof lsSchema, LsToolDetails | undefined>;
+export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
+export {};

package/dist/core/tools/ls.js

@@ -0,0 +1,268 @@
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { existsSync, readdirSync, statSync } from "fs";
+import { minimatch } from "minimatch";
+import nodePath from "path";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { resolveToCwd } from "./path-utils.js";
+import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+const lsSchema = Type.Object({
+    path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
+});
+const DEFAULT_LIMIT = 500;
+const GLOB_PATTERN_RE = /[*?[\]{}]/;
+const defaultLsOperations = {
+    exists: existsSync,
+    stat: statSync,
+    readdir: readdirSync,
+};
+function toPosixPath(value) {
+    return value.split(nodePath.sep).join("/");
+}
+function hasGlobPattern(value) {
+    return GLOB_PATTERN_RE.test(value);
+}
+function splitGlobPath(rawPath) {
+    let root = rawPath;
+    while (root && hasGlobPattern(root)) {
+        const parent = nodePath.dirname(root);
+        if (parent === root)
+            break;
+        root = parent;
+    }
+    if (!root || root === rawPath)
+        root = ".";
+    return {
+        root,
+        pattern: toPosixPath(nodePath.relative(root, rawPath)),
+    };
+}
+async function listGlobEntries(rawPath, cwd, ops, effectiveLimit, signal) {
+    const { root, pattern } = splitGlobPath(rawPath);
+    const rootPath = resolveToCwd(root, cwd);
+    if (!(await ops.exists(rootPath))) {
+        throw new Error(`Path not found: ${rootPath}`);
+    }
+    const rootStat = await ops.stat(rootPath);
+    if (!rootStat.isDirectory()) {
+        throw new Error(`Not a directory: ${rootPath}`);
+    }
+    const results = [];
+    let entryLimitReached = false;
+    const isAbsoluteInput = nodePath.isAbsolute(rawPath);
+    const displayRoot = root === "." ? "" : root;
+    const walk = async (dirPath) => {
+        if (signal?.aborted)
+            throw new Error("Operation aborted");
+        if (results.length >= effectiveLimit) {
+            entryLimitReached = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = await ops.readdir(dirPath);
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        for (const entry of entries) {
+            if (results.length >= effectiveLimit) {
+                entryLimitReached = true;
+                return;
+            }
+            const fullPath = nodePath.join(dirPath, entry);
+            let entryStat;
+            try {
+                entryStat = await ops.stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            const relativeFromRoot = toPosixPath(nodePath.relative(rootPath, fullPath));
+            if (minimatch(relativeFromRoot, pattern, { dot: true })) {
+                const suffix = entryStat.isDirectory() ? "/" : "";
+                if (isAbsoluteInput) {
+                    results.push(toPosixPath(fullPath) + suffix);
+                }
+                else {
+                    const displayPath = displayRoot ? nodePath.join(displayRoot, relativeFromRoot) : relativeFromRoot;
+                    results.push(toPosixPath(displayPath) + suffix);
+                }
+            }
+            if (entryStat.isDirectory()) {
+                await walk(fullPath);
+            }
+        }
+    };
+    await walk(rootPath);
+    return { results, entryLimitReached };
+}
+function formatLsCall(args, theme) {
+    const rawPath = str(args?.path);
+    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
+    const limit = args?.limit;
+    const invalidArg = invalidArgText(theme);
+    let text = `${theme.fg("toolTitle", theme.bold("ls"))} ${path === null ? invalidArg : theme.fg("accent", path)}`;
+    if (limit !== undefined) {
+        text += theme.fg("toolOutput", ` (limit ${limit})`);
+    }
+    return text;
+}
+function formatLsResult(result, options, theme, showImages) {
+    const output = getTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 20;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")})`;
+        }
+    }
+    const entryLimit = result.details?.entryLimitReached;
+    const truncation = result.details?.truncation;
+    if (entryLimit || truncation?.truncated) {
+        const warnings = [];
+        if (entryLimit)
+            warnings.push(`${entryLimit} entries limit`);
+        if (truncation?.truncated)
+            warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export function createLsToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultLsOperations;
+    return {
+        name: "ls",
+        label: "ls",
+        description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
+        promptSnippet: "List directory contents",
+        parameters: lsSchema,
+        async execute(_toolCallId, { path, limit }, signal, _onUpdate, _ctx) {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                const onAbort = () => reject(new Error("Operation aborted"));
+                signal?.addEventListener("abort", onAbort, { once: true });
+                (async () => {
+                    try {
+                        const dirPath = resolveToCwd(path || ".", cwd);
+                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+                        let results = [];
+                        let entryLimitReached = false;
+                        if (path && hasGlobPattern(path)) {
+                            try {
+                                const globResult = await listGlobEntries(path, cwd, ops, effectiveLimit, signal);
+                                results = globResult.results;
+                                entryLimitReached = globResult.entryLimitReached;
+                            }
+                            catch (error) {
+                                reject(error);
+                                return;
+                            }
+                        }
+                        else {
+                            // Check if path exists.
+                            if (!(await ops.exists(dirPath))) {
+                                reject(new Error(`Path not found: ${dirPath}`));
+                                return;
+                            }
+                            // Check if path is a directory.
+                            const stat = await ops.stat(dirPath);
+                            if (!stat.isDirectory()) {
+                                reject(new Error(`Not a directory: ${dirPath}`));
+                                return;
+                            }
+                            // Read directory entries.
+                            let entries;
+                            try {
+                                entries = await ops.readdir(dirPath);
+                            }
+                            catch (e) {
+                                reject(new Error(`Cannot read directory: ${e.message}`));
+                                return;
+                            }
+                            // Sort alphabetically, case-insensitive.
+                            entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+                            // Format entries with directory indicators.
+                            for (const entry of entries) {
+                                if (results.length >= effectiveLimit) {
+                                    entryLimitReached = true;
+                                    break;
+                                }
+                                const fullPath = nodePath.join(dirPath, entry);
+                                let suffix = "";
+                                try {
+                                    const entryStat = await ops.stat(fullPath);
+                                    if (entryStat.isDirectory())
+                                        suffix = "/";
+                                }
+                                catch {
+                                    // Skip entries we cannot stat.
+                                    continue;
+                                }
+                                results.push(entry + suffix);
+                            }
+                        }
+                        signal?.removeEventListener("abort", onAbort);
+                        if (results.length === 0) {
+                            resolve({
+                                content: [{ type: "text", text: path && hasGlobPattern(path) ? "No entries found matching pattern" : "(empty directory)" }],
+                                details: undefined,
+                            });
+                            return;
+                        }
+                        const rawOutput = results.join("\n");
+                        // Apply byte truncation. There is no separate line limit because entry count is already capped.
+                        const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+                        let output = truncation.content;
+                        const details = {};
+                        // Build actionable notices for truncation and entry limits.
+                        const notices = [];
+                        if (entryLimitReached) {
+                            notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+                            details.entryLimitReached = effectiveLimit;
+                        }
+                        if (truncation.truncated) {
+                            notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+                            details.truncation = truncation;
+                        }
+                        if (notices.length > 0) {
+                            output += `\n\n[${notices.join(". ")}]`;
+                        }
+                        resolve({
+                            content: [{ type: "text", text: output }],
+                            details: Object.keys(details).length > 0 ? details : undefined,
+                        });
+                    }
+                    catch (e) {
+                        signal?.removeEventListener("abort", onAbort);
+                        reject(e);
+                    }
+                })();
+            });
+        },
+        renderCall(args, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatLsCall(args, theme));
+            return text;
+        },
+        renderResult(result, options, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatLsResult(result, options, theme, context.showImages));
+            return text;
+        },
+    };
+}
+export function createLsTool(cwd, options) {
+    return wrapToolDefinition(createLsToolDefinition(cwd, options));
+}

package/dist/core/tools/path-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function expandPath(filePath: string): string;
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function resolveReadPath(filePath: string, cwd: string): string;

package/dist/core/tools/path-utils.js

@@ -0,0 +1,80 @@
+import { accessSync, constants } from "node:fs";
+import * as os from "node:os";
+import { isAbsolute, resolve as resolvePath } from "node:path";
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const NARROW_NO_BREAK_SPACE = "\u202F";
+function normalizeUnicodeSpaces(str) {
+    return str.replace(UNICODE_SPACES, " ");
+}
+function tryMacOSScreenshotPath(filePath) {
+    return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNFDVariant(filePath) {
+    // macOS stores filenames in NFD (decomposed) form, try converting user input to NFD
+    return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+    // macOS uses U+2019 (right single quotation mark) in screenshot names like "Capture d'écran"
+    // Users typically type U+0027 (straight apostrophe)
+    return filePath.replace(/'/g, "\u2019");
+}
+function fileExists(filePath) {
+    try {
+        accessSync(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeAtPrefix(filePath) {
+    return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+export function expandPath(filePath) {
+    const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+    if (normalized === "~") {
+        return os.homedir();
+    }
+    if (normalized.startsWith("~/")) {
+        return os.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export function resolveToCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (isAbsolute(expanded)) {
+        return expanded;
+    }
+    return resolvePath(cwd, expanded);
+}
+export function resolveReadPath(filePath, cwd) {
+    const resolved = resolveToCwd(filePath, cwd);
+    if (fileExists(resolved)) {
+        return resolved;
+    }
+    // Try macOS AM/PM variant (narrow no-break space before AM/PM)
+    const amPmVariant = tryMacOSScreenshotPath(resolved);
+    if (amPmVariant !== resolved && fileExists(amPmVariant)) {
+        return amPmVariant;
+    }
+    // Try NFD variant (macOS stores filenames in NFD form)
+    const nfdVariant = tryNFDVariant(resolved);
+    if (nfdVariant !== resolved && fileExists(nfdVariant)) {
+        return nfdVariant;
+    }
+    // Try curly quote variant (macOS uses U+2019 in screenshot names)
+    const curlyVariant = tryCurlyQuoteVariant(resolved);
+    if (curlyVariant !== resolved && fileExists(curlyVariant)) {
+        return curlyVariant;
+    }
+    // Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+    const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+    if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
+        return nfdCurlyVariant;
+    }
+    return resolved;
+}

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

@@ -0,0 +1,35 @@
+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 readSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    anchors: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"line">, import("@sinclair/typebox").TLiteral<"none">]>>;
+}>;
+export type ReadToolInput = Static<typeof readSchema>;
+export interface ReadToolDetails {
+    truncation?: TruncationResult;
+}
+/**
+ * Pluggable operations for the read tool.
+ * Override these to delegate file reading to remote systems (for example SSH).
+ */
+export interface ReadOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Check if file is readable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+    /** Detect image MIME type, return null or undefined for non-images */
+    detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
+}
+export interface ReadToolOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+    /** Custom operations for file reading. Default: local filesystem */
+    operations?: ReadOperations;
+}
+export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined>;
+export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
+export {};