Agent package + coding agent WIP, refactored web-ui prompts

packages/coding-agent/src/tools/bash.ts

@@ -0,0 +1,37 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+const bashSchema = Type.Object({
+	command: Type.String({ description: "Bash command to execute" }),
+});
+
+export const bashTool: AgentTool<typeof bashSchema> = {
+	name: "bash",
+	label: "bash",
+	description:
+		"Execute a bash command in the current working directory. Returns stdout and stderr. Commands run with a 30 second timeout.",
+	parameters: bashSchema,
+	execute: async (_toolCallId: string, { command }: { command: string }) => {
+		try {
+			const { stdout, stderr } = await execAsync(command, {
+				timeout: 30000,
+				maxBuffer: 10 * 1024 * 1024, // 10MB
+			});
+
+			let output = "";
+			if (stdout) output += stdout;
+			if (stderr) output += stderr ? `\nSTDERR:\n${stderr}` : "";
+
+			return { output: output || "(no output)", details: undefined };
+		} catch (error: any) {
+			return {
+				output: `Error executing command: ${error.message}\nSTDOUT: ${error.stdout || ""}\nSTDERR: ${error.stderr || ""}`,
+				details: undefined,
+			};
+		}
+	},
+};

packages/coding-agent/src/tools/edit.ts

@@ -0,0 +1,61 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+const editSchema = 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 const editTool: AgentTool<typeof editSchema> = {
+	name: "edit",
+	label: "edit",
+	description:
+		"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+	parameters: editSchema,
+	execute: async (
+		_toolCallId: string,
+		{ path, oldText, newText }: { path: string; oldText: string; newText: string },
+	) => {
+		try {
+			const absolutePath = resolve(path);
+
+			if (!existsSync(absolutePath)) {
+				return { output: `Error: File not found: ${path}`, details: undefined };
+			}
+
+			const content = readFileSync(absolutePath, "utf-8");
+
+			// Check if old text exists
+			if (!content.includes(oldText)) {
+				return {
+					output: `Error: Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,
+					details: undefined,
+				};
+			}
+
+			// Count occurrences
+			const occurrences = content.split(oldText).length - 1;
+
+			if (occurrences > 1) {
+				return {
+					output: `Error: Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
+					details: undefined,
+				};
+			}
+
+			// Perform replacement
+			const newContent = content.replace(oldText, newText);
+			writeFileSync(absolutePath, newContent, "utf-8");
+
+			return {
+				output: `Successfully replaced text in ${path}. Changed ${oldText.length} characters to ${newText.length} characters.`,
+				details: undefined,
+			};
+		} catch (error: any) {
+			return { output: `Error editing file: ${error.message}`, details: undefined };
+		}
+	},
+};

packages/coding-agent/src/tools/index.ts

@@ -0,0 +1,11 @@
+export { bashTool } from "./bash.js";
+export { editTool } from "./edit.js";
+export { readTool } from "./read.js";
+export { writeTool } from "./write.js";
+
+import { bashTool } from "./bash.js";
+import { editTool } from "./edit.js";
+import { readTool } from "./read.js";
+import { writeTool } from "./write.js";
+
+export const codingTools = [readTool, bashTool, editTool, writeTool];

packages/coding-agent/src/tools/read.ts

@@ -0,0 +1,29 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+const readSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+});
+
+export const readTool: AgentTool<typeof readSchema> = {
+	name: "read",
+	label: "read",
+	description: "Read the contents of a file. Returns the full file content as text.",
+	parameters: readSchema,
+	execute: async (_toolCallId: string, { path }: { path: string }) => {
+		try {
+			const absolutePath = resolve(path);
+
+			if (!existsSync(absolutePath)) {
+				return { output: `Error: File not found: ${path}`, details: undefined };
+			}
+
+			const content = readFileSync(absolutePath, "utf-8");
+			return { output: content, details: undefined };
+		} catch (error: any) {
+			return { output: `Error reading file: ${error.message}`, details: undefined };
+		}
+	},
+};

packages/coding-agent/src/tools/write.ts

@@ -0,0 +1,31 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+
+const writeSchema = 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 const writeTool: AgentTool<typeof writeSchema> = {
+	name: "write",
+	label: "write",
+	description:
+		"Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+	parameters: writeSchema,
+	execute: async (_toolCallId: string, { path, content }: { path: string; content: string }) => {
+		try {
+			const absolutePath = resolve(path);
+			const dir = dirname(absolutePath);
+
+			// Create parent directories if needed
+			mkdirSync(dir, { recursive: true });
+
+			writeFileSync(absolutePath, content, "utf-8");
+			return { output: `Successfully wrote ${content.length} bytes to ${path}`, details: undefined };
+		} catch (error: any) {
+			return { output: `Error writing file: ${error.message}`, details: undefined };
+		}
+	},
+};