@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/tools/bash.js

@@ -0,0 +1,513 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { spawn } from "child_process";
+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 { injectPizzaPathShims } from "../../utils/path-shims.js";
+import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { getTextOutput, invalidArgText, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail } from "./truncate.js";
+import { BUILTIN_COMMANDS, getBuiltinCommandHelpForArgs, parseBuiltinCommand, parseBuiltinToolInput, } from "./builtin-commands.js";
+import { createEditToolDefinition } from "./edit.js";
+import { createReadToolDefinition } from "./read.js";
+import { createWriteToolDefinition } from "./write.js";
+/**
+ * Generate a unique temp file path for bash output.
+ */
+function getTempFilePath() {
+    const id = randomBytes(8).toString("hex");
+    return join(tmpdir(), `pizza-bash-${id}.log`);
+}
+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 Pizza's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want Pizza'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 childEnv = injectPizzaPathShims(env ?? getShellEnv());
+                const child = spawn(shell, [...args, command], {
+                    cwd,
+                    detached: true,
+                    env: childEnv,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                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;
+class BashResultRenderComponent extends Container {
+    constructor() {
+        super(...arguments);
+        this.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();
+    const output = getTextOutput(result, showImages).trim();
+    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;
+                },
+            });
+        }
+    }
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    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));
+    }
+}
+function parseBashBuiltinCommand(command) {
+    const parsed = parseBuiltinCommand(command);
+    const builtinName = parsed.command.toLowerCase();
+    if (!BUILTIN_COMMANDS.includes(builtinName)) {
+        return null;
+    }
+    if (!canRouteAsBuiltin(command, parsed)) {
+        return null;
+    }
+    if (getBuiltinCommandHelpForArgs(builtinName, parsed.args)) {
+        return null;
+    }
+    return parseBuiltinToolInput(builtinName, parsed.args, parsed.heredoc);
+}
+function canRouteAsBuiltin(command, parsed) {
+    if (parsed.heredoc !== undefined) {
+        return parsed.command.toLowerCase() === "write";
+    }
+    return !hasShellControlSyntax(command);
+}
+function hasShellControlSyntax(command) {
+    let quote;
+    let escaped = false;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (char === "|" || char === "&" || char === ";" || char === "<" || char === ">" || char === "\n") {
+            return true;
+        }
+    }
+    return false;
+}
+function builtinKey(builtin) {
+    if ("command" in builtin) {
+        return JSON.stringify({ name: builtin.command, args: builtin.input });
+    }
+    return JSON.stringify({ name: builtin.name, args: builtin.args });
+}
+function resetBuiltinRendererStateIfNeeded(state, key) {
+    if (state.builtinKey === key)
+        return;
+    state.builtinKey = key;
+    state.builtinCallComponent = undefined;
+    state.builtinResultComponent = undefined;
+    state.builtinRendererState = {};
+}
+function makeBuiltinRenderContext(context, args, lastComponent, state) {
+    state.builtinRendererState ??= {};
+    return {
+        ...context,
+        args,
+        lastComponent,
+        state: state.builtinRendererState,
+    };
+}
+export function createBashToolDefinition(cwd, options) {
+    const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
+    const commandPrefix = options?.commandPrefix;
+    const spawnHook = options?.spawnHook;
+    const readDefinition = createReadToolDefinition(cwd, options?.read);
+    const writeDefinition = createWriteToolDefinition(cwd, options?.write);
+    const editDefinition = createEditToolDefinition(cwd, options?.edit);
+    return {
+        name: "cli",
+        label: "cli",
+        description: `Execute a CLI command in the current working directory. Built-in file commands are routed internally: read, write, and edit. Other commands execute through the system shell (grep, find, ls, git, npm, etc.). Truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB.`,
+        promptSnippet: "Execute CLI commands: read/write/edit built-ins, or shell commands (grep, find, ls, git, npm, etc.)",
+        parameters: bashSchema,
+        async execute(toolCallId, { command, timeout }, signal, onUpdate, ctx) {
+            // Direct command routing: if command starts with a built-in command name,
+            // execute it internally. Otherwise fall through to bash.
+            const trimmedCommand = command.trim();
+            const parsedCommand = parseBuiltinCommand(trimmedCommand);
+            const help = getBuiltinCommandHelpForArgs(parsedCommand.command, parsedCommand.args);
+            if (help) {
+                return { content: [{ type: "text", text: help }], details: undefined };
+            }
+            const builtin = parseBashBuiltinCommand(trimmedCommand);
+            if (builtin) {
+                switch (builtin.command) {
+                    case "read": {
+                        const result = await readDefinition.execute(toolCallId, builtin.input, signal, undefined, ctx);
+                        return {
+                            content: result.content,
+                            details: { builtin: { name: "read", args: builtin.input, details: result.details } },
+                        };
+                    }
+                    case "write": {
+                        const result = await writeDefinition.execute(toolCallId, builtin.input, signal, undefined, ctx);
+                        return {
+                            content: result.content,
+                            details: { builtin: { name: "write", args: builtin.input, details: result.details } },
+                        };
+                    }
+                    case "edit": {
+                        const prepared = editDefinition.prepareArguments
+                            ? editDefinition.prepareArguments(builtin.input)
+                            : builtin.input;
+                        const result = await editDefinition.execute(toolCallId, prepared, signal, undefined, ctx);
+                        return {
+                            content: result.content,
+                            details: { builtin: { name: "edit", args: prepared, details: result.details } },
+                        };
+                    }
+                }
+            }
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook);
+            if (onUpdate) {
+                onUpdate({ content: [], details: undefined });
+            }
+            return new Promise((resolve, reject) => {
+                let tempFilePath;
+                let tempFileStream;
+                let totalBytes = 0;
+                const chunks = [];
+                let chunksBytes = 0;
+                const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
+                const ensureTempFile = () => {
+                    if (tempFilePath)
+                        return;
+                    tempFilePath = getTempFilePath();
+                    tempFileStream = createWriteStream(tempFilePath);
+                    for (const chunk of chunks)
+                        tempFileStream.write(chunk);
+                };
+                const handleData = (data) => {
+                    totalBytes += data.length;
+                    // Start writing to a temp file once output exceeds the in-memory threshold.
+                    if (totalBytes > DEFAULT_MAX_BYTES) {
+                        ensureTempFile();
+                    }
+                    // Write to temp file if we have one.
+                    if (tempFileStream)
+                        tempFileStream.write(data);
+                    // Keep a rolling buffer of recent output for tail truncation.
+                    chunks.push(data);
+                    chunksBytes += data.length;
+                    // Trim old chunks if the rolling buffer grows too large.
+                    while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+                        const removed = chunks.shift();
+                        chunksBytes -= removed.length;
+                    }
+                    // Stream partial output using the rolling tail buffer.
+                    if (onUpdate) {
+                        const fullBuffer = Buffer.concat(chunks);
+                        const fullText = fullBuffer.toString("utf-8");
+                        const truncation = truncateTail(fullText);
+                        if (truncation.truncated) {
+                            ensureTempFile();
+                        }
+                        onUpdate({
+                            content: [{ type: "text", text: truncation.content || "" }],
+                            details: {
+                                truncation: truncation.truncated ? truncation : undefined,
+                                fullOutputPath: tempFilePath,
+                            },
+                        });
+                    }
+                };
+                ops.exec(spawnContext.command, spawnContext.cwd, {
+                    onData: handleData,
+                    signal,
+                    timeout,
+                    env: spawnContext.env,
+                })
+                    .then(({ exitCode }) => {
+                    // Combine the rolling buffer chunks.
+                    const fullBuffer = Buffer.concat(chunks);
+                    const fullOutput = fullBuffer.toString("utf-8");
+                    // Apply tail truncation for the final display payload.
+                    const truncation = truncateTail(fullOutput);
+                    if (truncation.truncated) {
+                        ensureTempFile();
+                    }
+                    // Close temp file stream before building the final result.
+                    if (tempFileStream)
+                        tempFileStream.end();
+                    let outputText = truncation.content || "(no output)";
+                    let details;
+                    if (truncation.truncated) {
+                        // Build truncation details and an actionable notice.
+                        details = { truncation, fullOutputPath: tempFilePath };
+                        const startLine = truncation.totalLines - truncation.outputLines + 1;
+                        const endLine = truncation.totalLines;
+                        if (truncation.lastLinePartial) {
+                            // Edge case: the last line alone is larger than the byte limit.
+                            const lastLineSize = formatSize(Buffer.byteLength(fullOutput.split("\n").pop() || "", "utf-8"));
+                            outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). 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} of ${truncation.totalLines} (${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) => {
+                    // Close temp file stream and include buffered output in the error message.
+                    if (tempFileStream)
+                        tempFileStream.end();
+                    const fullBuffer = Buffer.concat(chunks);
+                    let output = fullBuffer.toString("utf-8");
+                    if (err.message === "aborted") {
+                        if (output)
+                            output += "\n\n";
+                        output += "Command aborted";
+                        reject(new Error(output));
+                    }
+                    else if (err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        if (output)
+                            output += "\n\n";
+                        output += `Command timed out after ${timeoutSecs} seconds`;
+                        reject(new Error(output));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        },
+        renderCall(args, renderTheme, context) {
+            const state = context.state;
+            if (context.executionStarted && state.startedAt === undefined) {
+                state.startedAt = Date.now();
+                state.endedAt = undefined;
+            }
+            const command = str(args?.command);
+            if (command) {
+                try {
+                    const builtin = parseBashBuiltinCommand(command);
+                    if (builtin) {
+                        const key = builtinKey(builtin);
+                        resetBuiltinRendererStateIfNeeded(state, key);
+                        const definition = builtin.command === "read"
+                            ? readDefinition
+                            : builtin.command === "write"
+                                ? writeDefinition
+                                : editDefinition;
+                        const renderContext = makeBuiltinRenderContext(context, builtin.input, state.builtinCallComponent, state);
+                        const component = definition.renderCall?.(builtin.input, renderTheme, renderContext);
+                        if (component) {
+                            state.builtinCallComponent = component;
+                            return component;
+                        }
+                    }
+                }
+                catch {
+                    // Fall back to the bash call renderer for malformed built-in commands.
+                }
+            }
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatBashCall(args));
+            return text;
+        },
+        renderResult(result, options, renderTheme, 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 builtin = result.details?.builtin;
+            if (builtin) {
+                const key = builtinKey(builtin);
+                resetBuiltinRendererStateIfNeeded(state, key);
+                const renderContext = makeBuiltinRenderContext(context, builtin.args, state.builtinResultComponent, state);
+                const component = builtin.name === "read"
+                    ? readDefinition.renderResult?.({ content: result.content, details: builtin.details }, options, renderTheme, renderContext)
+                    : builtin.name === "write"
+                        ? writeDefinition.renderResult?.({ content: result.content, details: builtin.details }, options, renderTheme, renderContext)
+                        : editDefinition.renderResult?.({ content: result.content, details: builtin.details }, options, renderTheme, renderContext);
+                if (component) {
+                    state.builtinResultComponent = component;
+                    return component;
+                }
+            }
+            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/core/tools/builtin-commands.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Built-in CLI commands for file operations.
+ * These are exposed to the LLM via the cli tool.
+ *
+ * Supports heredoc syntax for multi-line content:
+ *   write <path> <<EOF
+ *   line1
+ *   line2
+ *   EOF
+ */
+import { type Edit } from "./edit-diff.js";
+export interface BuiltinCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ParsedBuiltinCommand {
+    command: string;
+    args: string[];
+    heredoc?: string;
+}
+export type ParsedBuiltinToolInput = {
+    command: "read";
+    input: {
+        path: string;
+        offset?: number;
+        limit?: number;
+        anchors?: "line" | "none";
+    };
+} | {
+    command: "write";
+    input: {
+        path: string;
+        content: string;
+    };
+} | {
+    command: "edit";
+    input: {
+        path: string;
+        edits: Edit[];
+    };
+};
+/**
+ * Parse builtin command with optional heredoc.
+ * Supports:
+ *   write <path> <<EOF
+ *   line1
+ *   line2
+ *   EOF
+ */
+export declare function parseBuiltinCommandWithHeredoc(input: string): ParsedBuiltinCommand | null;
+export declare function parseBuiltinCommand(input: string): ParsedBuiltinCommand;
+export declare function parseBuiltinToolInput(command: string, args: string[], heredoc?: string): ParsedBuiltinToolInput | null;
+export declare function getBuiltinCommandHelp(command: string): string | undefined;
+export declare function getBuiltinCommandHelpForArgs(command: string, args: string[]): string | undefined;
+/** @deprecated Use parseBuiltinCommandWithHeredoc */
+export declare const parseCommandWithHeredoc: typeof parseBuiltinCommandWithHeredoc;
+export interface BuiltinCommandContext {
+    cwd: string;
+}
+export declare function executeBuiltinCommand(command: string, args: string[], context: BuiltinCommandContext): Promise<BuiltinCommandResult>;
+export declare const BUILTIN_COMMANDS: readonly ["read", "write", "edit"];
+export type BuiltinCommand = (typeof BUILTIN_COMMANDS)[number];
+/** @deprecated Use BuiltinCommandResult */
+export type NativeCommandResult = BuiltinCommandResult;
+/** @deprecated Use ParsedBuiltinCommand */
+export type ParsedCommand = ParsedBuiltinCommand;
+/** @deprecated Use BuiltinCommandContext */
+export type NativeCommandContext = BuiltinCommandContext;
+/** @deprecated Use executeBuiltinCommand */
+export declare const executeNativeCommand: typeof executeBuiltinCommand;
+/** @deprecated Use BUILTIN_COMMANDS */
+export declare const NATIVE_COMMANDS: readonly ["read", "write", "edit"];
+/** @deprecated Use BuiltinCommand */
+export type NativeCommand = BuiltinCommand;