@tomsun28/pizza 0.0.1

package/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Write",
+      "Bash(npm:*)",
+      "Bash(npx:*)",
+      "Bash(echo:*)",
+      "mcp__zread__get_repo_structure"
+    ]
+  },
+  "enabledPlugins": {
+    "skill-creator@claude-plugins-official": true
+  }
+}

package/dist/main.js

@@ -0,0 +1,91 @@
+#!/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) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+// Parse CLI args
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    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) {
+                console.error(`\n\x1b[31mError: ${err.message}\x1b[0m\n`);
+            }
+            prompt();
+        });
+    };
+    prompt();
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@tomsun28/pizza",
+	"version": "0.0.1",
+	"description": "Pizza - CLI is all you need",
+	"type": "module",
+	"bin": {
+		"pizza": "dist/main.js"
+	},
+	"main": "./dist/main.js",
+	"scripts": {
+		"dev": "tsx src/main.ts",
+		"build": "tsc",
+		"start": "node dist/main.js"
+	},
+	"dependencies": {
+		"@mariozechner/pi-agent-core": "^0.62.0",
+		"@mariozechner/pi-ai": "^0.62.0",
+		"@mariozechner/pi-tui": "^0.62.0",
+		"@sinclair/typebox": "^0.34.41"
+	},
+	"devDependencies": {
+		"@types/node": "^22.0.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.7.3"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"author": "tomsun28"
+}

package/src/agent.ts

@@ -0,0 +1,44 @@
+import { Agent, type AgentEvent } from "@mariozechner/pi-agent-core";
+import { getModel, type Model } from "@mariozechner/pi-ai";
+import { createAllTools } from "./tools/index.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { createCLIStreamFn } from "./cli-stream.js";
+import { convertToLlmWithCLI } from "./cli-convert.js";
+
+export interface PizzaOptions {
+	provider?: string;
+	model?: string;
+	cwd?: string;
+	apiKey?: string;
+}
+
+export interface PizzaAgent {
+	agent: Agent;
+	model: Model<any>;
+}
+
+export function createPizzaAgent(options: PizzaOptions = {}): PizzaAgent {
+	const cwd = options.cwd ?? process.cwd();
+	const provider = options.provider ?? "zai";
+	const modelId = options.model ?? "glm-4.7";
+
+	const model = getModel(provider as any, modelId as any);
+	const tools = createAllTools(cwd);
+	const systemPrompt = buildSystemPrompt(cwd);
+
+	const agent = new Agent({
+		initialState: {
+			systemPrompt,
+			model,
+			thinkingLevel: "off",
+			tools,
+		},
+		streamFn: createCLIStreamFn(),
+		convertToLlm: convertToLlmWithCLI,
+		getApiKey: async () => {
+			return options.apiKey ?? process.env.ZAI_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY;
+		},
+	});
+
+	return { agent, model };
+}

package/src/cli-convert.ts

@@ -0,0 +1,104 @@
+/**
+ * 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

@@ -0,0 +1,291 @@
+/**
+ * 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

@@ -0,0 +1,103 @@
+#!/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);
+});