@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/modes/print-mode.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Print mode (single-shot): Send prompts, output result, exit.
+ *
+ * Used for:
+ * - `pizza -p "prompt"` - text output
+ * - `pizza --mode json "prompt"` - JSON event stream
+ */
+import type { ImageContent } from "@earendil-works/pi-ai/compat";
+import type { SessionFacade } from "../core/session-facade.js";
+/**
+ * Options for print mode.
+ */
+export interface PrintModeOptions {
+    /** Output mode: "text" for final response only, "json" for all events */
+    mode: "text" | "json";
+    /** Array of additional prompts to send after initialMessage */
+    messages?: string[];
+    /** First message to send (may contain @file content) */
+    initialMessage?: string;
+    /** Images to attach to the initial message */
+    initialImages?: ImageContent[];
+}
+/**
+ * Run print mode against the event-sourced facade.
+ * JSON mode emits raw TypedEvent JSON lines; text mode prints the final assistant text.
+ */
+export declare function runPrintModeWithFacade(facade: SessionFacade, options: PrintModeOptions): Promise<number>;

package/dist/modes/print-mode.js

@@ -0,0 +1,102 @@
+/**
+ * Print mode (single-shot): Send prompts, output result, exit.
+ *
+ * Used for:
+ * - `pizza -p "prompt"` - text output
+ * - `pizza --mode json "prompt"` - JSON event stream
+ */
+import { flushRawStdout, writeRawStdout } from "../core/output-guard.js";
+import { killTrackedDetachedChildren } from "../utils/shell.js";
+function registerPrintModeSignalHandlers(disposeRuntime) {
+    const cleanupHandlers = [];
+    const signals = ["SIGTERM"];
+    if (process.platform !== "win32") {
+        signals.push("SIGHUP");
+    }
+    for (const signal of signals) {
+        const handler = () => {
+            killTrackedDetachedChildren();
+            void disposeRuntime().finally(() => {
+                process.exit(signal === "SIGHUP" ? 129 : 143);
+            });
+        };
+        process.on(signal, handler);
+        cleanupHandlers.push(() => process.off(signal, handler));
+    }
+    return cleanupHandlers;
+}
+function writeFinalAssistantText(messages) {
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.role !== "assistant") {
+        return 0;
+    }
+    const assistantMsg = lastMessage;
+    if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+        console.error(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+        return 1;
+    }
+    for (const content of assistantMsg.content) {
+        if (content.type === "text") {
+            writeRawStdout(`${content.text}\n`);
+        }
+    }
+    return 0;
+}
+function toEventImages(images) {
+    if (!images)
+        return undefined;
+    return images.map((image) => {
+        const eventImage = image;
+        return {
+            type: "image",
+            data: image.data,
+            mime_type: eventImage.mime_type ?? image.mimeType,
+        };
+    });
+}
+/**
+ * Run print mode against the event-sourced facade.
+ * JSON mode emits raw TypedEvent JSON lines; text mode prints the final assistant text.
+ */
+export async function runPrintModeWithFacade(facade, options) {
+    const { mode, messages = [], initialMessage, initialImages } = options;
+    let exitCode = 0;
+    let unsubscribe;
+    let disposed = false;
+    const disposeRuntime = async () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsubscribe?.();
+        await Promise.resolve(facade.dispose());
+    };
+    const signalCleanupHandlers = registerPrintModeSignalHandlers(disposeRuntime);
+    try {
+        unsubscribe = facade.subscribe((event) => {
+            if (mode === "json") {
+                writeRawStdout(`${JSON.stringify(event)}\n`);
+            }
+        });
+        if (initialMessage) {
+            await facade.prompt(initialMessage, toEventImages(initialImages));
+        }
+        for (const message of messages) {
+            await facade.prompt(message);
+        }
+        if (mode === "text") {
+            exitCode = writeFinalAssistantText(facade.getProjection().buildContext().messages);
+        }
+        return exitCode;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    finally {
+        for (const cleanup of signalCleanupHandlers) {
+            cleanup();
+        }
+        await disposeRuntime();
+        await flushRawStdout();
+    }
+}

package/dist/modes/rpc/jsonl.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from "node:stream";
+/**
+ * Serialize a single strict JSONL record.
+ *
+ * Framing is LF-only. Payload strings may contain other Unicode separators such as
+ * U+2028 and U+2029. Clients must split records on `\n` only.
+ */
+export declare function serializeJsonLine(value: unknown): string;
+/**
+ * Attach an LF-only JSONL reader to a stream.
+ *
+ * This intentionally does not use Node readline. Readline splits on additional
+ * Unicode separators that are valid inside JSON strings and therefore does not
+ * implement strict JSONL framing.
+ */
+export declare function attachJsonlLineReader(stream: Readable, onLine: (line: string) => void): () => void;

package/dist/modes/rpc/jsonl.js

@@ -0,0 +1,48 @@
+import { StringDecoder } from "node:string_decoder";
+/**
+ * Serialize a single strict JSONL record.
+ *
+ * Framing is LF-only. Payload strings may contain other Unicode separators such as
+ * U+2028 and U+2029. Clients must split records on `\n` only.
+ */
+export function serializeJsonLine(value) {
+    return `${JSON.stringify(value)}\n`;
+}
+/**
+ * Attach an LF-only JSONL reader to a stream.
+ *
+ * This intentionally does not use Node readline. Readline splits on additional
+ * Unicode separators that are valid inside JSON strings and therefore does not
+ * implement strict JSONL framing.
+ */
+export function attachJsonlLineReader(stream, onLine) {
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    const emitLine = (line) => {
+        onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+    };
+    const onData = (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            emitLine(buffer.slice(0, newlineIndex));
+            buffer = buffer.slice(newlineIndex + 1);
+        }
+    };
+    const onEnd = () => {
+        buffer += decoder.end();
+        if (buffer.length > 0) {
+            emitLine(buffer);
+            buffer = "";
+        }
+    };
+    stream.on("data", onData);
+    stream.on("end", onEnd);
+    return () => {
+        stream.off("data", onData);
+        stream.off("end", onEnd);
+    };
+}

package/dist/modes/rpc/rpc-client.d.ts

@@ -0,0 +1,219 @@
+/**
+ * RPC Client for programmatic access to the coding agent.
+ *
+ * Spawns the agent in RPC mode and provides a typed API for all operations.
+ */
+import type { AgentMessage, ThinkingLevel } from "../../core/agent/types.js";
+import type { ImageContent } from "@earendil-works/pi-ai/compat";
+import type { SessionStats } from "../../core/session-stats.js";
+import type { BashResult } from "../../core/bash-executor.js";
+import type { CompactionResult } from "../../core/compaction/index.js";
+import type { EventBase } from "../../core/event-store/types.js";
+import type { RpcSessionState, RpcSlashCommand } from "./rpc-types.js";
+export interface RpcClientOptions {
+    /** Path to the CLI entry point (default: searches for dist/cli.js) */
+    cliPath?: string;
+    /** Working directory for the agent */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Provider to use */
+    provider?: string;
+    /** Model ID to use */
+    model?: string;
+    /** Additional CLI arguments */
+    args?: string[];
+}
+export interface ModelInfo {
+    provider: string;
+    id: string;
+    contextWindow: number;
+    reasoning: boolean;
+}
+export type RpcEventListener = (event: EventBase) => void;
+export declare class RpcClient {
+    private options;
+    private process;
+    private stopReadingStdout;
+    private eventListeners;
+    private pendingRequests;
+    private requestId;
+    private stderr;
+    constructor(options?: RpcClientOptions);
+    /**
+     * Start the RPC agent process.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RPC agent process.
+     */
+    stop(): Promise<void>;
+    /**
+     * Subscribe to agent events.
+     */
+    onEvent(listener: RpcEventListener): () => void;
+    /**
+     * Get collected stderr output (useful for debugging).
+     */
+    getStderr(): string;
+    /**
+     * Send a prompt to the agent.
+     * Returns immediately after sending; use onEvent() to receive streaming events.
+     * Use waitForIdle() to wait for completion.
+     */
+    prompt(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a steering message to interrupt the agent mid-run.
+     */
+    steer(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a follow-up message to be processed after the agent finishes.
+     */
+    followUp(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Abort current operation.
+     */
+    abort(): Promise<void>;
+    /**
+     * Rewind to a branch point, or no-op to continue the eternal conversation.
+     * @param targetEventId - Optional event id to fork from
+     */
+    rewind(targetEventId?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Get current session state.
+     */
+    getState(): Promise<RpcSessionState>;
+    /**
+     * Set model by provider and ID.
+     */
+    setModel(provider: string, modelId: string): Promise<{
+        provider: string;
+        id: string;
+    }>;
+    /**
+     * Cycle to next model.
+     */
+    cycleModel(): Promise<{
+        model: {
+            provider: string;
+            id: string;
+        };
+        thinkingLevel: ThinkingLevel;
+        isScoped: boolean;
+    } | null>;
+    /**
+     * Get list of available models.
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Set thinking level.
+     */
+    setThinkingLevel(level: ThinkingLevel): Promise<void>;
+    /**
+     * Cycle thinking level.
+     */
+    cycleThinkingLevel(): Promise<{
+        level: ThinkingLevel;
+    } | null>;
+    /**
+     * Set steering mode.
+     */
+    setSteeringMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Set follow-up mode.
+     */
+    setFollowUpMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Compact session context.
+     */
+    compact(customInstructions?: string): Promise<CompactionResult>;
+    /**
+     * Set auto-compaction enabled/disabled.
+     */
+    setAutoCompaction(enabled: boolean): Promise<void>;
+    /**
+     * Set auto-retry enabled/disabled.
+     */
+    setAutoRetry(enabled: boolean): Promise<void>;
+    /**
+     * Abort in-progress retry.
+     */
+    abortRetry(): Promise<void>;
+    /**
+     * Execute a bash command.
+     */
+    bash(command: string): Promise<BashResult>;
+    /**
+     * Abort running bash command.
+     */
+    abortBash(): Promise<void>;
+    /**
+     * Get session statistics.
+     */
+    getSessionStats(): Promise<SessionStats>;
+    /**
+     * Export session to HTML.
+     */
+    exportHtml(outputPath?: string): Promise<{
+        path: string;
+    }>;
+    /**
+     * Switch to a different session file.
+     * @returns Object with `cancelled: true` if an extension cancelled the switch
+     */
+    switchSession(sessionPath: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Fork from a specific message.
+     * @returns Object with `text` (the message text) and `cancelled` (if extension cancelled)
+     */
+    fork(entryId: string): Promise<{
+        text: string;
+        cancelled: boolean;
+    }>;
+    /**
+     * Clone the current active branch into a new session.
+     * @returns Object with `cancelled: true` if an extension cancelled the clone
+     */
+    clone(): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Get messages available for forking.
+     */
+    getForkMessages(): Promise<Array<{
+        entryId: string;
+        text: string;
+    }>>;
+    /**
+     * Get text of last assistant message.
+     */
+    getLastAssistantText(): Promise<string | null>;
+    /**
+     * Get all messages in the session.
+     */
+    getMessages(): Promise<AgentMessage[]>;
+    /**
+     * Get available commands (extension commands, prompt templates, skills).
+     */
+    getCommands(): Promise<RpcSlashCommand[]>;
+    /**
+     * Wait for agent to become idle (no streaming).
+     * Resolves when AGENT_TURN_COMPLETED is received.
+     */
+    waitForIdle(timeout?: number): Promise<void>;
+    /**
+     * Collect events until agent becomes idle.
+     */
+    collectEvents(timeout?: number): Promise<EventBase[]>;
+    /**
+     * Send prompt and wait for completion, returning all events.
+     */
+    promptAndWait(message: string, images?: ImageContent[], timeout?: number): Promise<EventBase[]>;
+    private handleLine;
+    private send;
+    private getData;
+}