@tomsun28/pizza 0.0.8 → 0.1.0

package/dist/extension/core.js

@@ -1,319 +1,134 @@
 /**
- * Core logic for pizza-mode: [CLI] tag parsing, tool execution helpers,
- * and conversation history rewriting.
+ * Core logic for pizza-mode.
+ *
+ * Protocol:
+ *   [CLI id=N] <shell command>[/CLI]
+ *     — execute an arbitrary shell command; the full unix toolbelt is available
+ *       (ls, cat, rg, fd, find, grep, sed, awk, jq, git, gh, curl, node, python, …).
+ *
+ *   [WRITE id=N path=<path>]
+ *   <full file contents>
+ *   [/WRITE]
+ *     — overwrite a file with the exact body between the tags.
+ *
+ *   [EDIT id=N path=<path>]
+ *   <<<<<<< SEARCH
+ *   <exact existing text>
+ *   =======
+ *   <replacement text>
+ *   >>>>>>> REPLACE
+ *   [/EDIT]
+ *     — targeted replacement; SEARCH text must match exactly and appear exactly once.
+ *
+ * Results are always returned as [RESULT id=N kind=<bash|write|edit> …]…[/RESULT].
  */
-import { readFile, writeFile, mkdir, readdir, stat } from "node:fs/promises";
-import { resolve, isAbsolute, dirname, join, relative } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { resolve, isAbsolute, dirname } from "node:path";
 import { spawn } from "node:child_process";
 // ─── Constants ────────────────────────────────────────────────────────────────
-export const MAX_CALLS_PER_TURN = 5;
+export const MAX_CALLS_PER_TURN = 10;
 export const MAX_OUTPUT_BYTES = 128 * 1024;
 export const MAX_OUTPUT_LINES = 1000;
-export const MAX_FILE_BYTES = 256 * 1024;
-export const MAX_FILE_LINES = 2000;
-export const MAX_GREP_RESULTS = 200;
-export const MAX_GREP_FILE_SIZE = 1024 * 1024;
-// ─── [CLI] tag parsing ────────────────────────────────────────────────────────
+// ─── Attribute parsing ────────────────────────────────────────────────────────
 /**
- * Parse [CLI] toolName args[/CLI] blocks from model text output.
- * Returns all calls found and the text before the first call.
+ * Parse `key=value` attribute strings, supporting quoted values.
+ * Example input: ` id=1 path="src/foo.ts"` → { id: "1", path: "src/foo.ts" }
  */
-export function parseCLICalls(text) {
-    const regex = /\[CLI(?:\s+id=(\d+))?\]([\s\S]*?)\[\/CLI\]/g;
-    const calls = [];
-    let firstMatchStart = -1;
-    let autoId = 1;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        if (firstMatchStart === -1)
-            firstMatchStart = match.index;
-        const explicitId = match[1] ? parseInt(match[1], 10) : undefined;
-        const inner = match[2].trim();
-        const spaceIdx = inner.search(/\s/);
-        const toolName = spaceIdx === -1 ? inner : inner.slice(0, spaceIdx);
-        const rawArgs = spaceIdx === -1 ? "" : inner.slice(spaceIdx + 1).trim();
-        if (toolName) {
-            calls.push({ id: explicitId ?? autoId, toolName, rawArgs });
-            autoId++;
-        }
+function parseAttrs(raw) {
+    const attrs = {};
+    const re = /(\w+)=(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|([^\s\]]+))/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        const key = m[1];
+        const value = m[2] ?? m[3] ?? m[4] ?? "";
+        attrs[key] = value;
     }
-    const textBeforeCalls = firstMatchStart >= 0 ? text.substring(0, firstMatchStart).trimEnd() : text;
-    return { calls, textBeforeCalls };
+    return attrs;
 }
-// ─── Shell-style arg parser ───────────────────────────────────────────────────
+// ─── Block parsing ────────────────────────────────────────────────────────────
 /**
- * Parse a shell-style args string into a Record.
- * Handles: --key "value", --key value, --flag, positional args.
+ * Parse all [CLI], [WRITE], [EDIT] blocks from assistant text, preserving order.
+ * Auto-assigns ids when not explicit. Ids are independent per kind so that
+ * result rendering can reference them back without collision.
  */
-export function parseCliArgs(raw) {
-    const args = {};
-    const positional = [];
-    const tokens = [];
-    let i = 0;
-    while (i < raw.length) {
-        while (i < raw.length && /\s/.test(raw[i]))
-            i++;
-        if (i >= raw.length)
+export function parseBlocks(text) {
+    const blocks = [];
+    const counters = { bash: 1, write: 1, edit: 1 };
+    // Use a single scanner that finds whichever tag opens next, then consumes
+    // to its matching close tag. This preserves source order across kinds.
+    const openRe = /\[(CLI|WRITE|EDIT)((?:\s+[^\]]*)?)\]/g;
+    let m;
+    while ((m = openRe.exec(text)) !== null) {
+        const tag = m[1];
+        const attrs = parseAttrs(m[2] ?? "");
+        const closeTag = `[/${tag}]`;
+        const closeIdx = text.indexOf(closeTag, openRe.lastIndex);
+        if (closeIdx === -1)
             break;
-        if (raw[i] === '"' || raw[i] === "'") {
-            const quote = raw[i++];
-            let val = "";
-            while (i < raw.length && raw[i] !== quote) {
-                if (raw[i] === "\\" && i + 1 < raw.length) {
-                    i++;
-                    val += raw[i++];
-                }
-                else {
-                    val += raw[i++];
-                }
-            }
-            i++;
-            tokens.push(val);
-        }
-        else {
-            let val = "";
-            while (i < raw.length && !/\s/.test(raw[i])) {
-                val += raw[i++];
-            }
-            tokens.push(val);
+        const body = text.slice(openRe.lastIndex, closeIdx);
+        openRe.lastIndex = closeIdx + closeTag.length;
+        const explicitId = attrs.id ? parseInt(attrs.id, 10) : undefined;
+        if (tag === "CLI") {
+            const command = body.trim();
+            if (!command)
+                continue;
+            blocks.push({
+                kind: "bash",
+                id: explicitId ?? counters.bash++,
+                command,
+            });
         }
-    }
-    let ti = 0;
-    while (ti < tokens.length) {
-        const tok = tokens[ti];
-        if (tok.startsWith("--")) {
-            const key = tok.slice(2);
-            if (ti + 1 < tokens.length && !tokens[ti + 1].startsWith("--")) {
-                args[key] = tokens[ti + 1];
-                ti += 2;
-            }
-            else {
-                args[key] = true;
-                ti++;
+        else if (tag === "WRITE") {
+            if (!attrs.path) {
+                blocks.push({
+                    kind: "write",
+                    id: explicitId ?? counters.write++,
+                    path: "",
+                    content: body,
+                });
+                continue;
             }
+            blocks.push({
+                kind: "write",
+                id: explicitId ?? counters.write++,
+                path: attrs.path,
+                content: stripLeadingNewline(body),
+            });
         }
-        else {
-            positional.push(tok);
-            ti++;
-        }
-    }
-    if (positional.length > 0) {
-        if (!("path" in args) && !("command" in args) && !("pattern" in args)) {
-            args._positional = positional.join(" ");
+        else if (tag === "EDIT") {
+            const parsed = parseEditBody(body);
+            blocks.push({
+                kind: "edit",
+                id: explicitId ?? counters.edit++,
+                path: attrs.path ?? "",
+                search: parsed?.search ?? "",
+                replace: parsed?.replace ?? "",
+            });
         }
     }
-    return args;
+    return blocks;
 }
-/**
- * Map parsed args to tool-specific argument schema.
- */
-export function mapArgsToTool(toolName, rawArgs) {
-    const args = parseCliArgs(rawArgs);
-    const pos = args._positional;
-    delete args._positional;
-    switch (toolName) {
-        case "ls":
-            if (pos && !args.path)
-                args.path = pos;
-            break;
-        case "read":
-            if (pos && !args.path)
-                args.path = pos;
-            break;
-        case "write":
-            // --path and --content required
-            break;
-        case "edit":
-            if (args.old) {
-                args.oldText = args.old;
-                delete args.old;
-            }
-            if (args.new) {
-                args.newText = args.new;
-                delete args.new;
-            }
-            if (pos && !args.path)
-                args.path = pos;
-            break;
-        case "grep":
-            if (pos && !args.pattern)
-                args.pattern = pos;
-            break;
-        case "bash":
-            if (rawArgs && !args.command)
-                args.command = rawArgs;
-            break;
-        default:
-            if (pos)
-                args.input = pos;
-    }
-    return args;
+function stripLeadingNewline(s) {
+    return s.startsWith("\n") ? s.slice(1) : s;
 }
 /**
- * Convert tool call arguments back to CLI flag string for history reconstruction.
+ * Extract SEARCH / REPLACE halves from the body of an [EDIT] block.
+ * Accepts Aider-style markers:
+ *   <<<<<<< SEARCH
+ *   ...
+ *   =======
+ *   ...
+ *   >>>>>>> REPLACE
  */
-export function argsToCliString(toolName, arguments_) {
-    if (toolName === "bash") {
-        return arguments_.command ?? "";
-    }
-    if (toolName === "ls" || toolName === "read") {
-        const path = arguments_.path;
-        const rest = Object.entries(arguments_)
-            .filter(([k]) => k !== "path")
-            .map(([k, v]) => `--${k} "${String(v).replace(/"/g, '\\"')}"`)
-            .join(" ");
-        return path ? (rest ? `${path} ${rest}` : path) : rest;
-    }
-    if (toolName === "edit") {
-        const mapped = { ...arguments_ };
-        if (mapped.oldText !== undefined) {
-            mapped.old = mapped.oldText;
-            delete mapped.oldText;
-        }
-        if (mapped.newText !== undefined) {
-            mapped.new = mapped.newText;
-            delete mapped.newText;
-        }
-        return Object.entries(mapped)
-            .map(([k, v]) => {
-            if (v === true)
-                return `--${k}`;
-            const s = String(v);
-            return s.includes(" ") || s.includes('"') || s.includes("\n")
-                ? `--${k} "${s.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`
-                : `--${k} ${s}`;
-        })
-            .join(" ");
-    }
-    return Object.entries(arguments_)
-        .map(([k, v]) => {
-        if (v === true)
-            return `--${k}`;
-        const s = String(v);
-        return s.includes(" ") || s.includes('"') || s.includes("\n")
-            ? `--${k} "${s.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`
-            : `--${k} ${s}`;
-    })
-        .join(" ");
+function parseEditBody(body) {
+    const re = /<{5,}\s*SEARCH\s*\r?\n([\s\S]*?)\r?\n={5,}\s*\r?\n([\s\S]*?)\r?\n>{5,}\s*REPLACE/;
+    const m = re.exec(body);
+    if (!m)
+        return null;
+    return { search: m[1], replace: m[2] };
 }
 // ─── Tool implementations ─────────────────────────────────────────────────────
-export async function execLs(cwd, args) {
-    const dirPath = args.path
-        ? isAbsolute(args.path) ? args.path : resolve(cwd, args.path)
-        : cwd;
-    const entries = await readdir(dirPath);
-    const lines = [];
-    for (const entry of entries.sort()) {
-        try {
-            const fullPath = join(dirPath, entry);
-            const s = await stat(fullPath);
-            const type = s.isDirectory() ? "dir" : "file";
-            const size = s.isDirectory() ? "-" : formatSize(s.size);
-            lines.push(`${type}\t${size}\t${entry}`);
-        }
-        catch {
-            lines.push(`?\t?\t${entry}`);
-        }
-    }
-    return {
-        output: lines.length === 0 ? "(empty directory)" : lines.join("\n"),
-        isError: false,
-    };
-}
-export async function execRead(cwd, args) {
-    const absolutePath = args.path
-        ? (isAbsolute(args.path) ? args.path : resolve(cwd, args.path))
-        : resolve(cwd, ".");
-    const buffer = await readFile(absolutePath);
-    const text = buffer.toString("utf-8");
-    const allLines = text.split("\n");
-    const totalLines = allLines.length;
-    const offset = args.offset ? Number(args.offset) : undefined;
-    const limit = args.limit ? Number(args.limit) : undefined;
-    const startLine = offset ? Math.max(0, offset - 1) : 0;
-    if (startLine >= totalLines) {
-        throw new Error(`Offset ${offset} is beyond end of file (${totalLines} lines)`);
-    }
-    let selected = limit !== undefined
-        ? allLines.slice(startLine, startLine + limit)
-        : allLines.slice(startLine);
-    if (selected.length > MAX_FILE_LINES) {
-        selected = selected.slice(0, MAX_FILE_LINES);
-    }
-    let output = selected.join("\n");
-    if (Buffer.byteLength(output, "utf-8") > MAX_FILE_BYTES) {
-        const buf = Buffer.from(output, "utf-8");
-        output = buf.subarray(0, MAX_FILE_BYTES).toString("utf-8");
-    }
-    const shownLines = output.split("\n").length;
-    const remaining = totalLines - startLine - shownLines;
-    if (remaining > 0) {
-        const nextOffset = startLine + shownLines + 1;
-        output += `\n\n[Showing ${shownLines} of ${totalLines} lines. Use --offset ${nextOffset} to continue.]`;
-    }
-    return { output, isError: false };
-}
-export async function execWrite(cwd, args) {
-    if (!args.path)
-        throw new Error("write requires --path");
-    if (args.content === undefined)
-        throw new Error("write requires --content");
-    const absolutePath = isAbsolute(args.path) ? args.path : resolve(cwd, args.path);
-    await mkdir(dirname(absolutePath), { recursive: true });
-    await writeFile(absolutePath, args.content, "utf-8");
-    return {
-        output: `Wrote ${String(args.content).length} bytes to ${args.path}`,
-        isError: false,
-    };
-}
-export async function execEdit(cwd, args) {
-    if (!args.path)
-        throw new Error("edit requires --path");
-    if (args.oldText === undefined)
-        throw new Error("edit requires --old");
-    if (args.newText === undefined)
-        throw new Error("edit requires --new");
-    const absolutePath = isAbsolute(args.path) ? args.path : resolve(cwd, args.path);
-    const content = await readFile(absolutePath, "utf-8");
-    const index = content.indexOf(args.oldText);
-    if (index === -1) {
-        throw new Error(`Could not find the exact text in ${args.path}. The --old text must match exactly including whitespace.`);
-    }
-    const second = content.indexOf(args.oldText, index + 1);
-    if (second !== -1) {
-        throw new Error(`Found multiple occurrences of the text in ${args.path}. Provide more context to make it unique.`);
-    }
-    const newContent = content.substring(0, index) + args.newText + content.substring(index + args.oldText.length);
-    await writeFile(absolutePath, newContent, "utf-8");
-    return { output: `Edited ${args.path}`, isError: false };
-}
-export async function execGrep(cwd, args) {
-    if (!args.pattern)
-        throw new Error("grep requires a pattern");
-    const searchDir = args.path
-        ? (isAbsolute(args.path) ? args.path : resolve(cwd, args.path))
-        : cwd;
-    let regex;
-    try {
-        regex = new RegExp(args.pattern, "g");
-    }
-    catch (e) {
-        throw new Error(`Invalid regex pattern: ${e.message}`);
-    }
-    const extFilter = args.include ? parseExtFilter(args.include) : null;
-    const results = [];
-    await grepDirectory(searchDir, regex, extFilter, results, cwd);
-    if (results.length === 0) {
-        return { output: "No matches found.", isError: false };
-    }
-    let output = results.join("\n");
-    if (results.length >= MAX_GREP_RESULTS) {
-        output += `\n\n[Truncated at ${MAX_GREP_RESULTS} results]`;
-    }
-    return { output, isError: false };
-}
-export async function execBash(cwd, args, signal) {
-    const command = args.command;
+export async function execBash(cwd, command, signal) {
     if (!command)
         throw new Error("bash requires a command");
     return new Promise((resolve_, reject) => {
@@ -329,12 +144,10 @@ export async function execBash(cwd, args, signal) {
             setTimeout(() => child.kill("SIGKILL"), 2000);
         };
         if (signal) {
-            if (signal.aborted) {
+            if (signal.aborted)
                 onAbort();
-            }
-            else {
+            else
                 signal.addEventListener("abort", onAbort, { once: true });
-            }
         }
         child.stdout?.on("data", (d) => chunks.push(d));
         child.stderr?.on("data", (d) => chunks.push(d));
@@ -353,104 +166,95 @@ export async function execBash(cwd, args, signal) {
         });
     });
 }
+export async function execWrite(cwd, path, content) {
+    if (!path)
+        throw new Error("[WRITE] requires path= attribute");
+    const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, content, "utf-8");
+    return {
+        output: `Wrote ${Buffer.byteLength(content, "utf-8")} bytes to ${path}`,
+        isError: false,
+    };
+}
+export async function execEdit(cwd, path, search, replace) {
+    if (!path)
+        throw new Error("[EDIT] requires path= attribute");
+    if (!search) {
+        throw new Error("[EDIT] requires a SEARCH/REPLACE body. Use <<<<<<< SEARCH … ======= … >>>>>>> REPLACE");
+    }
+    const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+    const content = await readFile(absolutePath, "utf-8");
+    const index = content.indexOf(search);
+    if (index === -1) {
+        throw new Error(`Could not find the SEARCH text in ${path}. It must match exactly, including whitespace.`);
+    }
+    const second = content.indexOf(search, index + 1);
+    if (second !== -1) {
+        throw new Error(`SEARCH text occurs multiple times in ${path}. Provide more surrounding context to make it unique.`);
+    }
+    const newContent = content.substring(0, index) + replace + content.substring(index + search.length);
+    await writeFile(absolutePath, newContent, "utf-8");
+    return { output: `Edited ${path}`, isError: false };
+}
 // ─── Dispatch ─────────────────────────────────────────────────────────────────
-export async function dispatchTool(toolName, rawArgs, cwd, signal) {
-    const args = mapArgsToTool(toolName, rawArgs);
-    switch (toolName) {
-        case "ls": return execLs(cwd, args);
-        case "read": return execRead(cwd, args);
-        case "write": return execWrite(cwd, args);
-        case "edit": return execEdit(cwd, args);
-        case "grep": return execGrep(cwd, args);
-        case "bash": return execBash(cwd, args, signal);
-        default: {
-            // Fallback: treat unknown commands as bash
-            const bashCmd = `${toolName}${rawArgs ? " " + rawArgs : ""}`;
-            return execBash(cwd, { command: bashCmd }, signal);
-        }
+export async function dispatchBlock(block, cwd, signal) {
+    switch (block.kind) {
+        case "bash":
+            return execBash(cwd, block.command, signal);
+        case "write":
+            return execWrite(cwd, block.path, block.content);
+        case "edit":
+            return execEdit(cwd, block.path, block.search, block.replace);
     }
 }
 // ─── Result formatting ────────────────────────────────────────────────────────
-export function buildResultBlock(output, isError, id, total, cliCommand) {
-    const idAttr = id !== undefined ? ` id=${id}` : "";
-    const cliAttr = cliCommand ? ` cli="${cliCommand.replace(/"/g, '\\"')}"` : "";
+export function buildResultBlock(output, isError, id, kind, label) {
+    const labelAttr = label ? ` label="${label.replace(/"/g, '\\"')}"` : "";
     const errAttr = isError ? " error=true" : "";
-    return `[RESULT${idAttr}${cliAttr}${errAttr}]\n${output}\n[/RESULT]`;
+    return `[RESULT id=${id} kind=${kind}${labelAttr}${errAttr}]\n${output}\n[/RESULT]`;
+}
+export function labelForBlock(block) {
+    switch (block.kind) {
+        case "bash":
+            return truncateLabel(block.command);
+        case "write":
+            return `write ${block.path}`;
+        case "edit":
+            return `edit ${block.path}`;
+    }
+}
+function truncateLabel(s) {
+    const oneLine = s.replace(/\s+/g, " ").trim();
+    return oneLine.length > 120 ? oneLine.slice(0, 117) + "…" : oneLine;
 }
 // ─── History rewriting ────────────────────────────────────────────────────────
 /**
- * Reconstruct the [CLI] text that the model originally emitted for a tool call.
+ * Reconstruct assistant-visible text for a native tool_use call of one of our
+ * built-in operations (used only if an older session recorded them as native
+ * tool calls). For bash we render [CLI]; for write/edit we render fenced blocks.
  */
-export function reconstructCliText(toolName, arguments_) {
-    const cliArgs = argsToCliString(toolName, arguments_);
-    const inner = cliArgs ? `${toolName} ${cliArgs}` : toolName;
-    return `[CLI] ${inner}[/CLI]`;
-}
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function formatSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-function parseExtFilter(include) {
-    if (include.startsWith("*."))
-        return include.substring(1);
-    return include;
-}
-const SKIP_DIRS = new Set([
-    "node_modules", ".git", "dist", "build", ".next", "__pycache__",
-    ".venv", "venv", ".cache", "coverage",
-]);
-async function grepDirectory(dir, regex, extFilter, results, cwd) {
-    if (results.length >= MAX_GREP_RESULTS)
-        return;
-    let entries;
-    try {
-        entries = await readdir(dir);
+export function reconstructBlockText(toolName, args) {
+    if (toolName === "bash" && typeof args.command === "string") {
+        return `[CLI] ${args.command}[/CLI]`;
     }
-    catch {
-        return;
+    if (toolName === "write" && typeof args.path === "string") {
+        const content = typeof args.content === "string" ? args.content : "";
+        return `[WRITE path="${escapeAttr(args.path)}"]\n${content}\n[/WRITE]`;
     }
-    for (const entry of entries) {
-        if (results.length >= MAX_GREP_RESULTS)
-            return;
-        const fullPath = join(dir, entry);
-        let s;
-        try {
-            s = await stat(fullPath);
-        }
-        catch {
-            continue;
-        }
-        if (s.isDirectory()) {
-            if (!SKIP_DIRS.has(entry)) {
-                await grepDirectory(fullPath, regex, extFilter, results, cwd);
-            }
-        }
-        else if (s.isFile()) {
-            if (s.size > MAX_GREP_FILE_SIZE)
-                continue;
-            if (extFilter && !entry.endsWith(extFilter))
-                continue;
-            try {
-                const content = await readFile(fullPath, "utf-8");
-                const lines = content.split("\n");
-                const relPath = relative(cwd, fullPath);
-                for (let i = 0; i < lines.length; i++) {
-                    regex.lastIndex = 0;
-                    if (regex.test(lines[i])) {
-                        results.push(`${relPath}:${i + 1}: ${lines[i].trimEnd()}`);
-                        if (results.length >= MAX_GREP_RESULTS)
-                            return;
-                    }
-                }
-            }
-            catch { /* skip binary/unreadable */ }
-        }
+    if (toolName === "edit" && typeof args.path === "string") {
+        const oldText = args.oldText ?? args.old ?? "";
+        const newText = args.newText ?? args.new ?? "";
+        return (`[EDIT path="${escapeAttr(args.path)}"]\n` +
+            `<<<<<<< SEARCH\n${oldText}\n=======\n${newText}\n>>>>>>> REPLACE\n` +
+            `[/EDIT]`);
     }
+    return null;
+}
+function escapeAttr(s) {
+    return s.replace(/"/g, '\\"');
 }
+// ─── Helpers ──────────────────────────────────────────────────────────────────
 function truncateOutput(text) {
     const lines = text.split("\n");
     if (lines.length > MAX_OUTPUT_LINES) {