@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/exec.js

@@ -0,0 +1,74 @@
+/**
+ * Shared command execution utilities for extensions and custom tools.
+ */
+import { spawn } from "node:child_process";
+import { waitForChildProcess } from "../utils/child-process.js";
+/**
+ * Execute a shell command and return stdout/stderr/code.
+ * Supports timeout and abort signal.
+ */
+export async function execCommand(command, args, cwd, options) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, args, {
+            cwd,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        let timeoutId;
+        const killProcess = () => {
+            if (!killed) {
+                killed = true;
+                proc.kill("SIGTERM");
+                // Force kill after 5 seconds if SIGTERM doesn't work
+                setTimeout(() => {
+                    if (!proc.killed) {
+                        proc.kill("SIGKILL");
+                    }
+                }, 5000);
+            }
+        };
+        // Handle abort signal
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                killProcess();
+            }
+            else {
+                options.signal.addEventListener("abort", killProcess, { once: true });
+            }
+        }
+        // Handle timeout
+        if (options?.timeout && options.timeout > 0) {
+            timeoutId = setTimeout(() => {
+                killProcess();
+            }, options.timeout);
+        }
+        proc.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        // Wait for process termination without hanging on inherited stdio handles
+        // held open by detached descendants.
+        waitForChildProcess(proc)
+            .then((code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (options?.signal) {
+                options.signal.removeEventListener("abort", killProcess);
+            }
+            resolve({ stdout, stderr, code: code ?? 0, killed });
+        })
+            .catch((_err) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (options?.signal) {
+                options.signal.removeEventListener("abort", killProcess);
+            }
+            resolve({ stdout, stderr, code: 1, killed });
+        });
+    });
+}

package/dist/core/export-html/ansi-to-html.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ANSI escape code to HTML converter.
+ *
+ * Converts terminal ANSI color/style codes to HTML with inline styles.
+ * Supports:
+ * - Standard foreground colors (30-37) and bright variants (90-97)
+ * - Standard background colors (40-47) and bright variants (100-107)
+ * - 256-color palette (38;5;N and 48;5;N)
+ * - RGB true color (38;2;R;G;B and 48;2;R;G;B)
+ * - Text styles: bold (1), dim (2), italic (3), underline (4)
+ * - Reset (0)
+ */
+/**
+ * Convert ANSI-escaped text to HTML with inline styles.
+ */
+export declare function ansiToHtml(text: string): string;
+/**
+ * Convert array of ANSI-escaped lines to HTML.
+ * Each line is wrapped in a div element.
+ */
+export declare function ansiLinesToHtml(lines: string[]): string;

package/dist/core/export-html/ansi-to-html.js

@@ -0,0 +1,248 @@
+/**
+ * ANSI escape code to HTML converter.
+ *
+ * Converts terminal ANSI color/style codes to HTML with inline styles.
+ * Supports:
+ * - Standard foreground colors (30-37) and bright variants (90-97)
+ * - Standard background colors (40-47) and bright variants (100-107)
+ * - 256-color palette (38;5;N and 48;5;N)
+ * - RGB true color (38;2;R;G;B and 48;2;R;G;B)
+ * - Text styles: bold (1), dim (2), italic (3), underline (4)
+ * - Reset (0)
+ */
+// Standard ANSI color palette (0-15)
+const ANSI_COLORS = [
+    "#000000", // 0: black
+    "#800000", // 1: red
+    "#008000", // 2: green
+    "#808000", // 3: yellow
+    "#000080", // 4: blue
+    "#800080", // 5: magenta
+    "#008080", // 6: cyan
+    "#c0c0c0", // 7: white
+    "#808080", // 8: bright black
+    "#ff0000", // 9: bright red
+    "#00ff00", // 10: bright green
+    "#ffff00", // 11: bright yellow
+    "#0000ff", // 12: bright blue
+    "#ff00ff", // 13: bright magenta
+    "#00ffff", // 14: bright cyan
+    "#ffffff", // 15: bright white
+];
+/**
+ * Convert 256-color index to hex.
+ */
+function color256ToHex(index) {
+    // Standard colors (0-15)
+    if (index < 16) {
+        return ANSI_COLORS[index];
+    }
+    // Color cube (16-231): 6x6x6 = 216 colors
+    if (index < 232) {
+        const cubeIndex = index - 16;
+        const r = Math.floor(cubeIndex / 36);
+        const g = Math.floor((cubeIndex % 36) / 6);
+        const b = cubeIndex % 6;
+        const toComponent = (n) => (n === 0 ? 0 : 55 + n * 40);
+        const toHex = (n) => toComponent(n).toString(16).padStart(2, "0");
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    // Grayscale (232-255): 24 shades
+    const gray = 8 + (index - 232) * 10;
+    const grayHex = gray.toString(16).padStart(2, "0");
+    return `#${grayHex}${grayHex}${grayHex}`;
+}
+/**
+ * Escape HTML special characters.
+ */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+function createEmptyStyle() {
+    return {
+        fg: null,
+        bg: null,
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false,
+    };
+}
+function styleToInlineCSS(style) {
+    const parts = [];
+    if (style.fg)
+        parts.push(`color:${style.fg}`);
+    if (style.bg)
+        parts.push(`background-color:${style.bg}`);
+    if (style.bold)
+        parts.push("font-weight:bold");
+    if (style.dim)
+        parts.push("opacity:0.6");
+    if (style.italic)
+        parts.push("font-style:italic");
+    if (style.underline)
+        parts.push("text-decoration:underline");
+    return parts.join(";");
+}
+function hasStyle(style) {
+    return style.fg !== null || style.bg !== null || style.bold || style.dim || style.italic || style.underline;
+}
+/**
+ * Parse ANSI SGR (Select Graphic Rendition) codes and update style.
+ */
+function applySgrCode(params, style) {
+    let i = 0;
+    while (i < params.length) {
+        const code = params[i];
+        if (code === 0) {
+            // Reset all
+            style.fg = null;
+            style.bg = null;
+            style.bold = false;
+            style.dim = false;
+            style.italic = false;
+            style.underline = false;
+        }
+        else if (code === 1) {
+            style.bold = true;
+        }
+        else if (code === 2) {
+            style.dim = true;
+        }
+        else if (code === 3) {
+            style.italic = true;
+        }
+        else if (code === 4) {
+            style.underline = true;
+        }
+        else if (code === 22) {
+            // Reset bold/dim
+            style.bold = false;
+            style.dim = false;
+        }
+        else if (code === 23) {
+            style.italic = false;
+        }
+        else if (code === 24) {
+            style.underline = false;
+        }
+        else if (code >= 30 && code <= 37) {
+            // Standard foreground colors
+            style.fg = ANSI_COLORS[code - 30];
+        }
+        else if (code === 38) {
+            // Extended foreground color
+            if (params[i + 1] === 5 && params.length > i + 2) {
+                // 256-color: 38;5;N
+                style.fg = color256ToHex(params[i + 2]);
+                i += 2;
+            }
+            else if (params[i + 1] === 2 && params.length > i + 4) {
+                // RGB: 38;2;R;G;B
+                const r = params[i + 2];
+                const g = params[i + 3];
+                const b = params[i + 4];
+                style.fg = `rgb(${r},${g},${b})`;
+                i += 4;
+            }
+        }
+        else if (code === 39) {
+            // Default foreground
+            style.fg = null;
+        }
+        else if (code >= 40 && code <= 47) {
+            // Standard background colors
+            style.bg = ANSI_COLORS[code - 40];
+        }
+        else if (code === 48) {
+            // Extended background color
+            if (params[i + 1] === 5 && params.length > i + 2) {
+                // 256-color: 48;5;N
+                style.bg = color256ToHex(params[i + 2]);
+                i += 2;
+            }
+            else if (params[i + 1] === 2 && params.length > i + 4) {
+                // RGB: 48;2;R;G;B
+                const r = params[i + 2];
+                const g = params[i + 3];
+                const b = params[i + 4];
+                style.bg = `rgb(${r},${g},${b})`;
+                i += 4;
+            }
+        }
+        else if (code === 49) {
+            // Default background
+            style.bg = null;
+        }
+        else if (code >= 90 && code <= 97) {
+            // Bright foreground colors
+            style.fg = ANSI_COLORS[code - 90 + 8];
+        }
+        else if (code >= 100 && code <= 107) {
+            // Bright background colors
+            style.bg = ANSI_COLORS[code - 100 + 8];
+        }
+        // Ignore unrecognized codes
+        i++;
+    }
+}
+// Match ANSI escape sequences: ESC[ followed by params and ending with 'm'
+const ANSI_REGEX = /\x1b\[([\d;]*)m/g;
+/**
+ * Convert ANSI-escaped text to HTML with inline styles.
+ */
+export function ansiToHtml(text) {
+    const style = createEmptyStyle();
+    let result = "";
+    let lastIndex = 0;
+    let inSpan = false;
+    // Reset regex state
+    ANSI_REGEX.lastIndex = 0;
+    let match = ANSI_REGEX.exec(text);
+    while (match !== null) {
+        // Add text before this escape sequence
+        const beforeText = text.slice(lastIndex, match.index);
+        if (beforeText) {
+            result += escapeHtml(beforeText);
+        }
+        // Parse SGR parameters
+        const paramStr = match[1];
+        const params = paramStr ? paramStr.split(";").map((p) => parseInt(p, 10) || 0) : [0];
+        // Close existing span if we have one
+        if (inSpan) {
+            result += "</span>";
+            inSpan = false;
+        }
+        // Apply the codes
+        applySgrCode(params, style);
+        // Open new span if we have any styling
+        if (hasStyle(style)) {
+            result += `<span style="${styleToInlineCSS(style)}">`;
+            inSpan = true;
+        }
+        lastIndex = match.index + match[0].length;
+        match = ANSI_REGEX.exec(text);
+    }
+    // Add remaining text
+    const remainingText = text.slice(lastIndex);
+    if (remainingText) {
+        result += escapeHtml(remainingText);
+    }
+    // Close any open span
+    if (inSpan) {
+        result += "</span>";
+    }
+    return result;
+}
+/**
+ * Convert array of ANSI-escaped lines to HTML.
+ * Each line is wrapped in a div element.
+ */
+export function ansiLinesToHtml(lines) {
+    return lines.map((line) => `<div class="ansi-line">${ansiToHtml(line) || "&nbsp;"}</div>`).join("\n");
+}

package/dist/core/export-html/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Interface for rendering custom tools to HTML.
+ * Used by the session facade to pre-render extension tool output.
+ */
+export interface ToolHtmlRenderer {
+    /** Render a tool call to HTML. Returns undefined if tool has no custom renderer. */
+    renderCall(toolCallId: string, toolName: string, args: unknown): string | undefined;
+    /** Render a tool result to HTML. Returns collapsed/expanded or undefined if tool has no custom renderer. */
+    renderResult(toolCallId: string, toolName: string, result: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>, details: unknown, isError: boolean): {
+        collapsed?: string;
+        expanded?: string;
+    } | undefined;
+}
+export interface ExportOptions {
+    outputPath?: string;
+    themeName?: string;
+    /** Optional tool renderer for custom tools */
+    toolRenderer?: ToolHtmlRenderer;
+}
+/**
+ * Export a persisted event session to HTML (standalone, without AgentState).
+ * Used by CLI for exporting a session reference or exact session id.
+ */
+export declare function exportFromFile(inputPath: string, options?: ExportOptions | string): Promise<string>;

package/dist/core/export-html/index.js

@@ -0,0 +1,186 @@
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { APP_NAME, getExportTemplateDir } from "../../config.js";
+import { getResolvedThemeColors, getThemeExportColors } from "../../modes/interactive/theme/theme.js";
+import { readSessionForExport } from "../session-reader.js";
+function sanitizeFileNameSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "session";
+}
+/** Parse a color string to RGB values. Supports hex (#RRGGBB) and rgb(r,g,b) formats. */
+function parseColor(color) {
+    const hexMatch = color.match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+    if (hexMatch) {
+        return {
+            r: Number.parseInt(hexMatch[1], 16),
+            g: Number.parseInt(hexMatch[2], 16),
+            b: Number.parseInt(hexMatch[3], 16),
+        };
+    }
+    const rgbMatch = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+    if (rgbMatch) {
+        return {
+            r: Number.parseInt(rgbMatch[1], 10),
+            g: Number.parseInt(rgbMatch[2], 10),
+            b: Number.parseInt(rgbMatch[3], 10),
+        };
+    }
+    return undefined;
+}
+/** Calculate relative luminance of a color (0-1, higher = lighter). */
+function getLuminance(r, g, b) {
+    const toLinear = (c) => {
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+/** Adjust color brightness. Factor > 1 lightens, < 1 darkens. */
+function adjustBrightness(color, factor) {
+    const parsed = parseColor(color);
+    if (!parsed)
+        return color;
+    const adjust = (c) => Math.min(255, Math.max(0, Math.round(c * factor)));
+    return `rgb(${adjust(parsed.r)}, ${adjust(parsed.g)}, ${adjust(parsed.b)})`;
+}
+/** Derive export background colors from a base color (e.g., userMessageBg). */
+function deriveExportColors(baseColor) {
+    const parsed = parseColor(baseColor);
+    if (!parsed) {
+        return {
+            pageBg: "rgb(24, 24, 30)",
+            cardBg: "rgb(30, 30, 36)",
+            infoBg: "rgb(60, 55, 40)",
+        };
+    }
+    const luminance = getLuminance(parsed.r, parsed.g, parsed.b);
+    const isLight = luminance > 0.5;
+    if (isLight) {
+        return {
+            pageBg: adjustBrightness(baseColor, 0.96),
+            cardBg: baseColor,
+            infoBg: `rgb(${Math.min(255, parsed.r + 10)}, ${Math.min(255, parsed.g + 5)}, ${Math.max(0, parsed.b - 20)})`,
+        };
+    }
+    return {
+        pageBg: adjustBrightness(baseColor, 0.7),
+        cardBg: adjustBrightness(baseColor, 0.85),
+        infoBg: `rgb(${Math.min(255, parsed.r + 20)}, ${Math.min(255, parsed.g + 15)}, ${parsed.b})`,
+    };
+}
+/**
+ * Generate CSS custom property declarations from theme colors.
+ */
+function generateThemeVars(themeName) {
+    const colors = getResolvedThemeColors(themeName);
+    const lines = [];
+    for (const [key, value] of Object.entries(colors)) {
+        lines.push(`--${key}: ${value};`);
+    }
+    // Use explicit theme export colors if available, otherwise derive from userMessageBg
+    const themeExport = getThemeExportColors(themeName);
+    const userMessageBg = colors.userMessageBg || "#343541";
+    const derivedColors = deriveExportColors(userMessageBg);
+    lines.push(`--exportPageBg: ${themeExport.pageBg ?? derivedColors.pageBg};`);
+    lines.push(`--exportCardBg: ${themeExport.cardBg ?? derivedColors.cardBg};`);
+    lines.push(`--exportInfoBg: ${themeExport.infoBg ?? derivedColors.infoBg};`);
+    return lines.join("\n      ");
+}
+/**
+ * Core HTML generation logic shared by both export functions.
+ */
+function generateHtml(sessionData, themeName) {
+    const templateDir = getExportTemplateDir();
+    const template = readFileSync(join(templateDir, "template.html"), "utf-8");
+    const templateCss = readFileSync(join(templateDir, "template.css"), "utf-8");
+    const templateJs = readFileSync(join(templateDir, "template.js"), "utf-8");
+    const markedJs = readFileSync(join(templateDir, "vendor", "marked.min.js"), "utf-8");
+    const hljsJs = readFileSync(join(templateDir, "vendor", "highlight.min.js"), "utf-8");
+    const themeVars = generateThemeVars(themeName);
+    const colors = getResolvedThemeColors(themeName);
+    const themeExport = getThemeExportColors(themeName);
+    const derivedExportColors = deriveExportColors(colors.userMessageBg || "#343541");
+    const bodyBg = themeExport.pageBg ?? derivedExportColors.pageBg;
+    const containerBg = themeExport.cardBg ?? derivedExportColors.cardBg;
+    const infoBg = themeExport.infoBg ?? derivedExportColors.infoBg;
+    // Base64 encode session data to avoid escaping issues
+    const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
+    // Build the CSS with theme variables injected
+    const css = templateCss
+        .replace("{{THEME_VARS}}", themeVars)
+        .replace("{{BODY_BG}}", bodyBg)
+        .replace("{{CONTAINER_BG}}", containerBg)
+        .replace("{{INFO_BG}}", infoBg);
+    return template
+        .replace("{{CSS}}", css)
+        .replace("{{JS}}", templateJs)
+        .replace("{{SESSION_DATA}}", sessionDataBase64)
+        .replace("{{MARKED_JS}}", markedJs)
+        .replace("{{HIGHLIGHT_JS}}", hljsJs);
+}
+/** Tools rendered directly by the HTML template (not pre-rendered via TUI→ANSI→HTML pipeline) */
+const TEMPLATE_RENDERED_TOOLS = new Set(["cli", "bash", "read", "write", "edit", "ls"]);
+/**
+ * Pre-render custom tools to HTML using their TUI renderers.
+ */
+function preRenderCustomTools(entries, toolRenderer) {
+    const renderedTools = {};
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const msg = entry.message;
+        // Find tool calls in assistant messages
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === "toolCall" && !TEMPLATE_RENDERED_TOOLS.has(block.name)) {
+                    const callHtml = toolRenderer.renderCall(block.id, block.name, block.arguments);
+                    if (callHtml) {
+                        renderedTools[block.id] = { callHtml };
+                    }
+                }
+            }
+        }
+        // Find tool results
+        if (msg.role === "toolResult" && msg.toolCallId) {
+            const toolName = msg.toolName || "";
+            // Only render if we have a pre-rendered call OR it's not template-rendered
+            const existing = renderedTools[msg.toolCallId];
+            if (existing || !TEMPLATE_RENDERED_TOOLS.has(toolName)) {
+                const rendered = toolRenderer.renderResult(msg.toolCallId, toolName, msg.content, msg.details, msg.isError || false);
+                if (rendered) {
+                    renderedTools[msg.toolCallId] = {
+                        ...existing,
+                        resultHtmlCollapsed: rendered.collapsed,
+                        resultHtmlExpanded: rendered.expanded,
+                    };
+                }
+            }
+        }
+    }
+    return renderedTools;
+}
+/**
+ * Export a persisted event session to HTML (standalone, without AgentState).
+ * Used by CLI for exporting a session reference or exact session id.
+ */
+export async function exportFromFile(inputPath, options) {
+    const opts = typeof options === "string" ? { outputPath: options } : options || {};
+    if (inputPath.includes("/") || inputPath.includes("\\") || inputPath.endsWith(".jsonl")) {
+        throw new Error("Legacy JSONL session export is no longer supported; pass an event session reference instead.");
+    }
+    const { header, entries, leafId, sessionId } = readSessionForExport(inputPath);
+    const sessionData = {
+        header,
+        entries,
+        leafId,
+        systemPrompt: undefined,
+        tools: undefined,
+    };
+    const html = generateHtml(sessionData, opts.themeName);
+    let outputPath = opts.outputPath;
+    if (!outputPath) {
+        const inputBasename = sanitizeFileNameSegment(sessionId || inputPath);
+        outputPath = `${APP_NAME}-session-${inputBasename}.html`;
+    }
+    writeFileSync(outputPath, html, "utf8");
+    return outputPath;
+}