@tomsun28/pizza 0.0.1 → 0.0.4

package/src/cli-convert.ts

@@ -1,104 +0,0 @@
-/**
- * Custom convertToLlm that transforms tool call/result history into
- * [CLI]/[RESULT] text format that the model can understand.
- *
- * The model never sees native tool_use/tool_result messages.
- * Instead, its own [CLI] calls and our [RESULT] responses appear as
- * plain text in the conversation history.
- */
-
-import type { Message, AssistantMessage, ToolResultMessage, UserMessage } from "@mariozechner/pi-ai";
-import type { AgentMessage } from "@mariozechner/pi-agent-core";
-import { argsToCliString } from "./cli-stream.js";
-
-/**
- * Convert AgentMessage[] to LLM Message[].
- *
- * - User messages: pass through
- * - Assistant messages with toolCalls: reconstruct the [CLI] tag text
- * - ToolResult messages: convert to user messages with [RESULT] tags
- */
-export function convertToLlmWithCLI(messages: AgentMessage[]): Message[] {
-	const result: Message[] = [];
-	let pendingResults: ToolResultMessage[] = [];
-
-	for (const msg of messages) {
-		if (msg.role === "user") {
-			// Flush any pending tool results first
-			flushResults(pendingResults, result);
-			pendingResults = [];
-			result.push(msg as UserMessage);
-		} else if (msg.role === "assistant") {
-			// Flush any pending tool results first
-			flushResults(pendingResults, result);
-			pendingResults = [];
-
-			const assistantMsg = msg as AssistantMessage;
-			const textParts: string[] = [];
-			const toolCalls = assistantMsg.content.filter(c => c.type === "toolCall");
-			const textBlocks = assistantMsg.content.filter(c => c.type === "text");
-
-			// Add text content
-			for (const block of textBlocks) {
-				if (block.type === "text" && block.text.trim()) {
-					textParts.push(block.text);
-				}
-			}
-
-			// Reconstruct [CLI] tags from tool calls
-			for (const tc of toolCalls) {
-				if (tc.type === "toolCall") {
-					const cliArgs = argsToCliString(tc.name, tc.arguments as Record<string, any>);
-					const inner = cliArgs ? `${tc.name} ${cliArgs}` : tc.name;
-					textParts.push(`[CLI] ${inner}[/CLI]`);
-				}
-			}
-
-			if (textParts.length > 0) {
-				result.push({
-					role: "assistant",
-					content: [{ type: "text", text: textParts.join("\n\n") }],
-					api: assistantMsg.api,
-					provider: assistantMsg.provider,
-					model: assistantMsg.model,
-					usage: assistantMsg.usage,
-					stopReason: toolCalls.length > 0 ? "stop" : assistantMsg.stopReason,
-					timestamp: assistantMsg.timestamp,
-				} as AssistantMessage);
-			}
-		} else if (msg.role === "toolResult") {
-			pendingResults.push(msg as ToolResultMessage);
-		}
-	}
-
-	// Flush remaining results
-	flushResults(pendingResults, result);
-
-	return result;
-}
-
-/**
- * Convert accumulated tool results into a single user message with [RESULT] tags.
- */
-function flushResults(results: ToolResultMessage[], output: Message[]): void {
-	if (results.length === 0) return;
-
-	const parts: string[] = [];
-	for (let i = 0; i < results.length; i++) {
-		const r = results[i];
-		const text = r.content
-			.filter(c => c.type === "text")
-			.map(c => (c as any).text)
-			.join("\n");
-
-		const id = results.length > 1 ? ` id=${i + 1}` : "";
-		const errorAttr = r.isError ? " error=true" : "";
-		parts.push(`[RESULT${id}${errorAttr}]\n${text}\n[/RESULT]`);
-	}
-
-	output.push({
-		role: "user",
-		content: parts.join("\n\n"),
-		timestamp: results[0].timestamp,
-	} as UserMessage);
-}

package/src/cli-stream.ts

@@ -1,291 +0,0 @@
-/**
- * Custom stream function that bypasses LLM's native tool calling.
- *
- * New format: [CLI] toolName [args][/CLI]
- * Examples:
- *   [CLI] ls .[/CLI]
- *   [CLI] read src/main.ts[/CLI]
- *   [CLI] write --path "file.ts" --content "hello"[/CLI]
- *   [CLI] bash git status[/CLI]
- */
-
-import {
-	type AssistantMessage,
-	type AssistantMessageEventStream,
-	createAssistantMessageEventStream,
-	type Context,
-	type Model,
-	type SimpleStreamOptions,
-	streamSimple,
-	type ToolCall,
-} from "@mariozechner/pi-ai";
-
-interface ParsedCLICall {
-	toolName: string;
-	rawArgs: string;
-}
-
-/**
- * Parse [CLI] toolName args[/CLI] tags from text.
- */
-function parseCLICalls(text: string): { calls: ParsedCLICall[]; textBeforeCalls: string } {
-	const regex = /\[CLI\]([\s\S]*?)\[\/CLI\]/g;
-	const calls: ParsedCLICall[] = [];
-	let firstMatchStart = -1;
-
-	let match: RegExpExecArray | null;
-	while ((match = regex.exec(text)) !== null) {
-		if (firstMatchStart === -1) firstMatchStart = match.index;
-		const inner = match[1].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({ toolName, rawArgs });
-		}
-	}
-
-	const textBeforeCalls = firstMatchStart >= 0 ? text.substring(0, firstMatchStart).trimEnd() : text;
-	return { calls, textBeforeCalls };
-}
-
-/**
- * Parse shell-style args string into a Record.
- *
- * Handles:
- *   --key "value"   -> { key: "value" }
- *   --key value     -> { key: "value" }
- *   --flag          -> { flag: true }
- *   positional      -> first positional goes to "path", rest to "_args"
- *
- * Quoted strings support escaped quotes inside.
- */
-export function parseCliArgs(raw: string): Record<string, any> {
-	const args: Record<string, any> = {};
-	const positional: string[] = [];
-
-	// Tokenize respecting quotes
-	const tokens: string[] = [];
-	let i = 0;
-	while (i < raw.length) {
-		// Skip whitespace
-		while (i < raw.length && /\s/.test(raw[i])) i++;
-		if (i >= raw.length) break;
-
-		if (raw[i] === '"' || raw[i] === "'") {
-			// Quoted token
-			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++; // closing quote
-			tokens.push(val);
-		} else {
-			// Unquoted token — read until whitespace
-			let val = "";
-			while (i < raw.length && !/\s/.test(raw[i])) {
-				val += raw[i++];
-			}
-			tokens.push(val);
-		}
-	}
-
-	// Parse tokens into args
-	let ti = 0;
-	while (ti < tokens.length) {
-		const tok = tokens[ti];
-		if (tok.startsWith("--")) {
-			const key = tok.slice(2);
-			// Next token is value if it doesn't start with --
-			if (ti + 1 < tokens.length && !tokens[ti + 1].startsWith("--")) {
-				args[key] = tokens[ti + 1];
-				ti += 2;
-			} else {
-				args[key] = true;
-				ti++;
-			}
-		} else {
-			positional.push(tok);
-			ti++;
-		}
-	}
-
-	// Map positional args to tool params
-	if (positional.length > 0) {
-		// First positional is usually a path or command
-		if (!("path" in args) && !("command" in args) && !("pattern" in args)) {
-			args._positional = positional.join(" ");
-		}
-	}
-
-	return args;
-}
-
-/**
- * Map parsed args to tool-specific argument schema.
- * Each tool has a known primary positional argument.
- */
-function mapArgsToTool(toolName: string, rawArgs: string): Record<string, any> {
-	const args = parseCliArgs(rawArgs);
-	const pos = args._positional as string | undefined;
-	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 are required; no positional shorthand
-			break;
-		case "edit":
-			// --path, --old, --new
-			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":
-			// Everything is the command
-			if (rawArgs && !args.command) args.command = rawArgs;
-			break;
-		default:
-			if (pos) args.input = pos;
-	}
-
-	return args;
-}
-
-/**
- * Convert tool call arguments back to CLI flag string for history reconstruction.
- */
-export function argsToCliString(toolName: string, arguments_: Record<string, any>): string {
-	if (toolName === "bash") {
-		return (arguments_.command as string) ?? "";
-	}
-	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;
-	}
-	// Generic: all args as --key "value"
-	return Object.entries(arguments_)
-		.map(([k, v]) => {
-			if (v === true) return `--${k}`;
-			const s = String(v);
-			// Quote if contains spaces or special chars
-			return s.includes(" ") || s.includes('"') || s.includes("\n")
-				? `--${k} "${s.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`
-				: `--${k} ${s}`;
-		})
-		.join(" ");
-}
-
-let callIdCounter = 0;
-function nextCallId(): string {
-	return `cli_${Date.now()}_${callIdCounter++}`;
-}
-
-export function createCLIStreamFn() {
-	return function cliStreamFn(
-		model: Model<any>,
-		context: Context,
-		options?: SimpleStreamOptions,
-	): AssistantMessageEventStream {
-		const output = createAssistantMessageEventStream();
-
-		void (async () => {
-			try {
-				const contextWithoutTools: Context = { ...context, tools: undefined };
-				const upstream = streamSimple(model, contextWithoutTools, options);
-				let fullText = "";
-
-				for await (const event of upstream) {
-					if (event.type === "text_delta") {
-						fullText += event.delta;
-					}
-
-					if (
-						event.type === "start" ||
-						event.type === "text_start" ||
-						event.type === "text_delta" ||
-						event.type === "text_end" ||
-						event.type === "thinking_start" ||
-						event.type === "thinking_delta" ||
-						event.type === "thinking_end"
-					) {
-						output.push(event);
-						continue;
-					}
-
-					if (event.type === "error") {
-						output.push(event);
-						continue;
-					}
-
-					if (event.type === "done") {
-						const { calls, textBeforeCalls } = parseCLICalls(fullText);
-
-						if (calls.length === 0) {
-							output.push(event);
-						} else {
-							const toolCalls: ToolCall[] = calls.map((call) => ({
-								type: "toolCall",
-								id: nextCallId(),
-								name: call.toolName,
-								arguments: mapArgsToTool(call.toolName, call.rawArgs),
-							}));
-
-							const rewritten: AssistantMessage = {
-								...event.message,
-								content: [
-									...(textBeforeCalls ? [{ type: "text" as const, text: textBeforeCalls }] : []),
-									...toolCalls,
-								],
-								stopReason: "toolUse",
-							};
-
-							for (let i = 0; i < toolCalls.length; i++) {
-								const tc = toolCalls[i];
-								const contentIndex = (textBeforeCalls ? 1 : 0) + i;
-								output.push({ type: "toolcall_start", contentIndex, partial: { ...rewritten } });
-								output.push({ type: "toolcall_end", contentIndex, toolCall: tc, partial: { ...rewritten } });
-							}
-
-							output.push({ type: "done", reason: "toolUse", message: rewritten });
-						}
-						continue;
-					}
-				}
-			} catch (err: any) {
-				const errorMessage: AssistantMessage = {
-					role: "assistant",
-					content: [{ type: "text", text: "" }],
-					api: model.api,
-					provider: model.provider,
-					model: model.id,
-					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-					stopReason: "error",
-					errorMessage: err.message || String(err),
-					timestamp: Date.now(),
-				};
-				output.push({ type: "error", reason: "error", error: errorMessage });
-			}
-		})();
-
-		return output;
-	};
-}

package/src/main.ts

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-import { createInterface } from "node:readline";
-import { createPizzaAgent } from "./agent.js";
-import { createRenderer } from "./ui/render.js";
-
-// ANSI helpers
-const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
-const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
-const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
-const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
-
-// Parse CLI args
-function parseArgs(): { provider?: string; model?: string; apiKey?: string } {
-	const args = process.argv.slice(2);
-	const result: Record<string, string> = {};
-
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] === "--provider" && args[i + 1]) {
-			result.provider = args[++i];
-		} else if (args[i] === "--model" && args[i + 1]) {
-			result.model = args[++i];
-		} else if (args[i] === "--api-key" && args[i + 1]) {
-			result.apiKey = args[++i];
-		} else if (args[i] === "--help" || args[i] === "-h") {
-			console.log(`
-${bold("pizza")} - A minimal coding agent
-
-${bold("Usage:")}
-  pizza [options]
-
-${bold("Options:")}
-  --provider <name>    LLM provider (default: zai)
-  --model <id>         Model ID (default: glm-4.5)
-  --api-key <key>      API key (default: from env)
-  -h, --help           Show this help
-
-${bold("Environment:")}
-  ZAI_API_KEY          ZAI API key
-  ANTHROPIC_API_KEY    Anthropic API key
-  OPENAI_API_KEY       OpenAI API key
-`);
-			process.exit(0);
-		}
-	}
-
-	return result;
-}
-
-async function main() {
-	const args = parseArgs();
-
-	console.log(`\n${bold(green("🍕 pizza"))} ${dim("coding agent")}`);
-	console.log(dim(`provider: ${args.provider ?? "zai"} | model: ${args.model ?? "glm-4.7"}`));
-	console.log(dim(`cwd: ${process.cwd()}`));
-	console.log(dim(`Type your message, or "exit" to quit.\n`));
-
-	const { agent, model } = createPizzaAgent({
-		provider: args.provider,
-		model: args.model,
-		apiKey: args.apiKey,
-	});
-
-	const render = createRenderer();
-	agent.subscribe(render);
-
-	const rl = createInterface({
-		input: process.stdin,
-		output: process.stdout,
-	});
-
-	const prompt = () => {
-		rl.question(`${cyan(">")} `, async (input) => {
-			const trimmed = input.trim();
-
-			if (!trimmed) {
-				prompt();
-				return;
-			}
-
-			if (trimmed === "exit" || trimmed === "quit" || trimmed === "/exit" || trimmed === "/quit") {
-				console.log(dim("\nBye!"));
-				rl.close();
-				process.exit(0);
-			}
-
-			try {
-				await agent.prompt(trimmed);
-			} catch (err: any) {
-				console.error(`\n\x1b[31mError: ${err.message}\x1b[0m\n`);
-			}
-
-			prompt();
-		});
-	};
-
-	prompt();
-}
-
-main().catch((err) => {
-	console.error("Fatal:", err);
-	process.exit(1);
-});

package/src/system-prompt.ts

@@ -1,94 +0,0 @@
-export function buildSystemPrompt(cwd: string): string {
-	const date = new Date().toISOString().slice(0, 10);
-
-	return [
-		`You are pizza, a coding assistant running in the user's terminal. CLI is all you need.`,
-		``,
-		`When you need to perform an action, wrap a CLI command in [CLI] ... [/CLI] tags. You can use multiple tags in one response. Results are returned in [RESULT]...[/RESULT] tags.`,
-		``,
-		`## Available Commands`,
-		``,
-		`[CLI] ls <path>[/CLI]`,
-		`[CLI] read <path>[/CLI]`,
-		`[CLI] read <path> --offset <n> --limit <n>[/CLI]`,
-		`[CLI] write --path <path> --content <content>[/CLI]`,
-		`[CLI] edit --path <path> --old <oldText> --new <newText>[/CLI]`,
-		`[CLI] grep <pattern> --path <dir> --include <glob>[/CLI]`,
-		`[CLI] bash <any shell command>[/CLI]`,
-		``,
-		`## Examples`,
-		``,
-		`User: What files are in this project?`,
-		``,
-		`Assistant: Let me check.`,
-		``,
-		`[CLI] ls .[/CLI]`,
-		``,
-		`[RESULT]`,
-		`src/`,
-		`package.json`,
-		`tsconfig.json`,
-		`[/RESULT]`,
-		``,
-		`The project has a src/ directory, package.json, and tsconfig.json.`,
-		``,
-		`---`,
-		``,
-		`User: Read package.json and list src/`,
-		``,
-		`Assistant: I'll do both at once.`,
-		``,
-		`[CLI] read package.json[/CLI]`,
-		`[CLI] ls src[/CLI]`,
-		``,
-		`[RESULT id=1]`,
-		`{"name":"my-app","version":"1.0.0"}`,
-		`[/RESULT]`,
-		``,
-		`[RESULT id=2]`,
-		`index.ts`,
-		`utils.ts`,
-		`[/RESULT]`,
-		``,
-		`The project is called "my-app". src/ contains index.ts and utils.ts.`,
-		``,
-		`---`,
-		``,
-		`User: Add a hello function to src/utils.ts`,
-		``,
-		`Assistant: Let me read the file first.`,
-		``,
-		`[CLI] read src/utils.ts[/CLI]`,
-		``,
-		`[RESULT]`,
-		`export function add(a: number, b: number): number {`,
-		`  return a + b;`,
-		`}`,
-		`[/RESULT]`,
-		``,
-		`[CLI] edit --path src/utils.ts --old "return a + b;
-}" --new "return a + b;
-}
-
-export function hello(name: string): string {
-  return "Hello, " + name;
-}"[/CLI]`,
-		``,
-		`[RESULT]`,
-		`File edited successfully.`,
-		`[/RESULT]`,
-		``,
-		`Done. Added a \`hello\` function to src/utils.ts.`,
-		``,
-		`---`,
-		``,
-		`User: Run git status and install deps`,
-		``,
-		`Assistant:`,
-		``,
-		`[CLI] bash git status[/CLI]`,
-		`[CLI] bash npm install[/CLI]`,
-		`Current directory: ${cwd}`,
-		`Date: ${date}`,
-	].join("\n");
-}

package/src/tools/bash.ts

@@ -1,124 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { Type } from "@sinclair/typebox";
-import { spawn } from "node:child_process";
-
-const MAX_OUTPUT_BYTES = 256 * 1024;
-const MAX_OUTPUT_LINES = 2000;
-
-const schema = Type.Object({
-	command: Type.String({ description: "Bash command to execute" }),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
-});
-
-export function createBashTool(cwd: string): AgentTool<typeof schema> {
-	return {
-		name: "bash",
-		label: "bash",
-		description: `Execute a bash command. Returns stdout and stderr. Output truncated to ${MAX_OUTPUT_LINES} lines or ${MAX_OUTPUT_BYTES / 1024}KB.`,
-		parameters: schema,
-		async execute(_toolCallId, { command, timeout }, signal, onUpdate) {
-			return new Promise((resolve, reject) => {
-				const shell = process.env.SHELL || "/bin/bash";
-				const child = spawn(shell, ["-c", command], {
-					cwd,
-					stdio: ["ignore", "pipe", "pipe"],
-					env: { ...process.env },
-				});
-
-				const chunks: Buffer[] = [];
-				let totalBytes = 0;
-				let timedOut = false;
-				let timeoutHandle: NodeJS.Timeout | undefined;
-
-				if (timeout !== undefined && timeout > 0) {
-					timeoutHandle = setTimeout(() => {
-						timedOut = true;
-						child.kill("SIGTERM");
-						setTimeout(() => child.kill("SIGKILL"), 2000);
-					}, timeout * 1000);
-				}
-
-				const handleData = (data: Buffer) => {
-					chunks.push(data);
-					totalBytes += data.length;
-
-					if (onUpdate) {
-						const text = Buffer.concat(chunks).toString("utf-8");
-						const truncated = truncateOutput(text);
-						onUpdate({
-							content: [{ type: "text", text: truncated }],
-							details: {},
-						});
-					}
-				};
-
-				child.stdout?.on("data", handleData);
-				child.stderr?.on("data", handleData);
-
-				const onAbort = () => {
-					child.kill("SIGTERM");
-					setTimeout(() => child.kill("SIGKILL"), 2000);
-				};
-
-				if (signal) {
-					if (signal.aborted) {
-						onAbort();
-					} else {
-						signal.addEventListener("abort", onAbort, { once: true });
-					}
-				}
-
-				child.on("close", (code) => {
-					if (timeoutHandle) clearTimeout(timeoutHandle);
-					if (signal) signal.removeEventListener("abort", onAbort);
-
-					const output = Buffer.concat(chunks).toString("utf-8");
-					const truncated = truncateOutput(output);
-
-					if (signal?.aborted) {
-						reject(new Error(truncated ? `${truncated}\n\nCommand aborted` : "Command aborted"));
-						return;
-					}
-
-					if (timedOut) {
-						reject(new Error(truncated ? `${truncated}\n\nCommand timed out after ${timeout}s` : `Command timed out after ${timeout}s`));
-						return;
-					}
-
-					if (code !== 0 && code !== null) {
-						reject(new Error(`${truncated || "(no output)"}\n\nExit code ${code}`));
-						return;
-					}
-
-					resolve({
-						content: [{ type: "text", text: truncated || "(no output)" }],
-						details: {},
-					});
-				});
-
-				child.on("error", (err) => {
-					if (timeoutHandle) clearTimeout(timeoutHandle);
-					if (signal) signal.removeEventListener("abort", onAbort);
-					reject(err);
-				});
-			});
-		},
-	};
-}
-
-function truncateOutput(text: string): string {
-	const lines = text.split("\n");
-
-	if (lines.length > MAX_OUTPUT_LINES) {
-		const kept = lines.slice(lines.length - MAX_OUTPUT_LINES);
-		const skipped = lines.length - MAX_OUTPUT_LINES;
-		return `[${skipped} lines truncated]\n${kept.join("\n")}`;
-	}
-
-	if (Buffer.byteLength(text, "utf-8") > MAX_OUTPUT_BYTES) {
-		const buf = Buffer.from(text, "utf-8");
-		return buf.subarray(buf.length - MAX_OUTPUT_BYTES).toString("utf-8");
-	}
-
-	return text;
-}