@tomsun28/pizza 0.0.1

package/src/system-prompt.ts

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,124 @@
+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;
+}

package/src/tools/edit.ts

@@ -0,0 +1,50 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve, isAbsolute } from "node:path";
+
+const schema = Type.Object({
+	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+	oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+	newText: Type.String({ description: "New text to replace the old text with" }),
+});
+
+export function createEditTool(cwd: string): AgentTool<typeof schema> {
+	return {
+		name: "edit",
+		label: "edit",
+		description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace).",
+		parameters: schema,
+		async execute(_toolCallId, { path, oldText, newText }, signal) {
+			const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+
+			if (signal?.aborted) throw new Error("aborted");
+
+			const content = await readFile(absolutePath, "utf-8");
+
+			const index = content.indexOf(oldText);
+			if (index === -1) {
+				throw new Error(
+					`Could not find the exact text in ${path}. The old text must match exactly including whitespace and newlines.`
+				);
+			}
+
+			// Check for multiple occurrences
+			const secondIndex = content.indexOf(oldText, index + 1);
+			if (secondIndex !== -1) {
+				throw new Error(
+					`Found multiple occurrences of the text in ${path}. Provide more context to make it unique.`
+				);
+			}
+
+			const newContent = content.substring(0, index) + newText + content.substring(index + oldText.length);
+
+			await writeFile(absolutePath, newContent, "utf-8");
+
+			return {
+				content: [{ type: "text", text: `Edited ${path}` }],
+				details: {},
+			};
+		},
+	};
+}

package/src/tools/grep.ts

@@ -0,0 +1,124 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { resolve, isAbsolute, join, relative } from "node:path";
+
+const MAX_RESULTS = 200;
+const MAX_FILE_SIZE = 1024 * 1024; // Skip files > 1MB
+
+const schema = Type.Object({
+	pattern: Type.String({ description: "Regex pattern to search for" }),
+	path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
+	include: Type.Optional(Type.String({ description: "Glob-like file extension filter, e.g. '*.ts'" })),
+});
+
+export function createGrepTool(cwd: string): AgentTool<typeof schema> {
+	return {
+		name: "grep",
+		label: "grep",
+		description: `Search file contents with regex. Returns matching lines with file paths and line numbers. Max ${MAX_RESULTS} results.`,
+		parameters: schema,
+		async execute(_toolCallId, { pattern, path, include }, signal) {
+			const searchDir = path ? (isAbsolute(path) ? path : resolve(cwd, path)) : cwd;
+
+			if (signal?.aborted) throw new Error("aborted");
+
+			let regex: RegExp;
+			try {
+				regex = new RegExp(pattern, "g");
+			} catch (e: any) {
+				throw new Error(`Invalid regex pattern: ${e.message}`);
+			}
+
+			const extFilter = include ? parseExtFilter(include) : null;
+			const results: string[] = [];
+
+			await searchDirectory(searchDir, regex, extFilter, results, cwd, signal);
+
+			if (results.length === 0) {
+				return { content: [{ type: "text", text: "No matches found." }], details: {} };
+			}
+
+			let output = results.join("\n");
+			if (results.length >= MAX_RESULTS) {
+				output += `\n\n[Truncated at ${MAX_RESULTS} results]`;
+			}
+
+			return {
+				content: [{ type: "text", text: output }],
+				details: {},
+			};
+		},
+	};
+}
+
+function parseExtFilter(include: string): string | null {
+	// Handle "*.ts" → ".ts"
+	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 searchDirectory(
+	dir: string,
+	regex: RegExp,
+	extFilter: string | null,
+	results: string[],
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<void> {
+	if (results.length >= MAX_RESULTS) return;
+	if (signal?.aborted) return;
+
+	let entries: string[];
+	try {
+		entries = await readdir(dir);
+	} catch {
+		return;
+	}
+
+	for (const entry of entries) {
+		if (results.length >= MAX_RESULTS) return;
+		if (signal?.aborted) return;
+
+		const fullPath = join(dir, entry);
+
+		let s;
+		try {
+			s = await stat(fullPath);
+		} catch {
+			continue;
+		}
+
+		if (s.isDirectory()) {
+			if (!SKIP_DIRS.has(entry)) {
+				await searchDirectory(fullPath, regex, extFilter, results, cwd, signal);
+			}
+		} else if (s.isFile()) {
+			if (s.size > MAX_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_RESULTS) return;
+					}
+				}
+			} catch {
+				// Skip binary/unreadable files
+			}
+		}
+	}
+}

package/src/tools/index.ts

@@ -0,0 +1,25 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { createReadTool } from "./read.js";
+import { createWriteTool } from "./write.js";
+import { createEditTool } from "./edit.js";
+import { createLsTool } from "./ls.js";
+import { createGrepTool } from "./grep.js";
+import { createBashTool } from "./bash.js";
+
+export function createAllTools(cwd: string): AgentTool<any>[] {
+	return [
+		createReadTool(cwd),
+		createWriteTool(cwd),
+		createEditTool(cwd),
+		createLsTool(cwd),
+		createGrepTool(cwd),
+		createBashTool(cwd),
+	];
+}
+
+export { createReadTool } from "./read.js";
+export { createWriteTool } from "./write.js";
+export { createEditTool } from "./edit.js";
+export { createLsTool } from "./ls.js";
+export { createGrepTool } from "./grep.js";
+export { createBashTool } from "./bash.js";

package/src/tools/ls.ts

@@ -0,0 +1,52 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { readdir, stat } from "node:fs/promises";
+import { resolve, isAbsolute, join } from "node:path";
+
+const schema = Type.Object({
+	path: Type.Optional(Type.String({ description: "Directory path (default: current directory)" })),
+});
+
+export function createLsTool(cwd: string): AgentTool<typeof schema> {
+	return {
+		name: "ls",
+		label: "ls",
+		description: "List directory contents with file types and sizes.",
+		parameters: schema,
+		async execute(_toolCallId, { path }, signal) {
+			const dirPath = path ? (isAbsolute(path) ? path : resolve(cwd, path)) : cwd;
+
+			if (signal?.aborted) throw new Error("aborted");
+
+			const entries = await readdir(dirPath);
+			const lines: string[] = [];
+
+			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}`);
+				}
+			}
+
+			if (lines.length === 0) {
+				return { content: [{ type: "text", text: "(empty directory)" }], details: {} };
+			}
+
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: {},
+			};
+		},
+	};
+}
+
+function formatSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/src/tools/read.ts

@@ -0,0 +1,69 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { readFile } from "node:fs/promises";
+import { resolve, isAbsolute } from "node:path";
+
+const MAX_LINES = 2000;
+const MAX_BYTES = 256 * 1024;
+
+const schema = Type.Object({
+	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+
+export function createReadTool(cwd: string): AgentTool<typeof schema> {
+	return {
+		name: "read",
+		label: "read",
+		description: `Read file contents. Output truncated to ${MAX_LINES} lines or ${MAX_BYTES / 1024}KB. Use offset/limit for large files.`,
+		parameters: schema,
+		async execute(_toolCallId, { path, offset, limit }, signal) {
+			const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+
+			if (signal?.aborted) throw new Error("aborted");
+
+			const buffer = await readFile(absolutePath);
+			const text = buffer.toString("utf-8");
+			const allLines = text.split("\n");
+			const totalLines = allLines.length;
+
+			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 selectedLines: string[];
+			if (limit !== undefined) {
+				selectedLines = allLines.slice(startLine, startLine + limit);
+			} else {
+				selectedLines = allLines.slice(startLine);
+			}
+
+			// Truncate by lines
+			if (selectedLines.length > MAX_LINES) {
+				selectedLines = selectedLines.slice(0, MAX_LINES);
+			}
+
+			let output = selectedLines.join("\n");
+
+			// Truncate by bytes
+			if (Buffer.byteLength(output, "utf-8") > MAX_BYTES) {
+				const buf = Buffer.from(output, "utf-8");
+				output = buf.subarray(0, MAX_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 {
+				content: [{ type: "text", text: output }],
+				details: {},
+			};
+		},
+	};
+}

package/src/tools/write.ts

@@ -0,0 +1,31 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve, isAbsolute, dirname } from "node:path";
+
+const schema = Type.Object({
+	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+	content: Type.String({ description: "Content to write to the file" }),
+});
+
+export function createWriteTool(cwd: string): AgentTool<typeof schema> {
+	return {
+		name: "write",
+		label: "write",
+		description: "Write content to a file. Creates the file and parent directories if they don't exist, overwrites if they do.",
+		parameters: schema,
+		async execute(_toolCallId, { path, content }, signal) {
+			const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+
+			if (signal?.aborted) throw new Error("aborted");
+
+			await mkdir(dirname(absolutePath), { recursive: true });
+			await writeFile(absolutePath, content, "utf-8");
+
+			return {
+				content: [{ type: "text", text: `Wrote ${content.length} bytes to ${path}` }],
+				details: {},
+			};
+		},
+	};
+}