@vitos-pizza/vitos-pizza 0.1.0

package/packages/ui-enhancements/src/session.ts

@@ -0,0 +1,72 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	loadUiEnhancementsSettings,
+	type UiEnhancementsSettings,
+} from "./config.ts";
+
+export const UI_ENHANCEMENTS_STATUS_KEY = "ui-enhancements";
+
+export interface UiEnhancementsState {
+	settings: UiEnhancementsSettings;
+}
+
+export function registerUiEnhancementsSession(
+	pi: ExtensionAPI,
+	setState: (state: UiEnhancementsState) => void,
+): void {
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = loadUiEnhancementsSettings(ctx.cwd);
+		setState({ settings });
+
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+
+		if (settings.toolsCollapsedByDefault) {
+			ctx.ui.setToolsExpanded(false);
+		}
+
+		if (settings.showExpandHint && !settings.borderStatusBar) {
+			ctx.ui.setStatus(UI_ENHANCEMENTS_STATUS_KEY, "[ctrl+o: expand]");
+		}
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		ctx.ui.setStatus(UI_ENHANCEMENTS_STATUS_KEY, undefined);
+	});
+}
+
+export function formatUiEnhancementsStatus(
+	state: UiEnhancementsState | null,
+	ctx?: ExtensionContext,
+): string {
+	if (!state) {
+		return "UI enhancements: not initialized";
+	}
+
+	const lines = [
+		"**UI enhancements** (`@vitos-pizza/ui-enhancements`)",
+		"",
+		"| Setting | Value |",
+		"| --- | --- |",
+		`| toolsCollapsedByDefault | \`${state.settings.toolsCollapsedByDefault}\` |`,
+		`| showExpandHint | \`${state.settings.showExpandHint}\` |`,
+		`| welcomeHeader | \`${state.settings.welcomeHeader}\` |`,
+		`| borderStatusBar | \`${state.settings.borderStatusBar}\` |`,
+		"",
+		"**Compact built-in tools:** read, bash, write, edit, find, grep, ls",
+		"",
+		"- Read-only bash: collapsed by default with line count summary",
+		"- write / edit / dangerous bash: always full output",
+		"- Use `ctrl+o` (`app.tools.expand`) to toggle tool output expansion",
+		"",
+		"**Chrome UI:** Vito's welcome header + border status bar (model, thinking, context, cwd, git)",
+	];
+
+	if (ctx?.hasUI && ctx.mode === "tui") {
+		lines.push("", `Current tools expanded: \`${ctx.ui.getToolsExpanded()}\``);
+	}
+
+	return lines.join("\n");
+}

package/packages/ui-enhancements/src/tools/bash-write-edit.ts

@@ -0,0 +1,148 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { isReadonlyBash } from "../bash-readonly.ts";
+import { shortenPath } from "../utils/shorten-path.ts";
+import {
+	countNonEmptyLines,
+	getTextContent,
+	renderBuiltInToolResult,
+} from "./text-content.ts";
+import { getBuiltInDefinitions, getBuiltInTools } from "./tool-cache.ts";
+
+export function registerBashTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).bash.parameters;
+
+	pi.registerTool({
+		name: "bash",
+		label: "bash",
+		description: getBuiltInTools(process.cwd()).bash.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.bash.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const command = (args.command as string | undefined) || "...";
+			const timeout = args.timeout as number | undefined;
+			const timeoutSuffix = timeout
+				? theme.fg("muted", ` (timeout ${timeout}s)`)
+				: "";
+
+			return new Text(
+				theme.fg("toolTitle", theme.bold(`$ ${command}`)) + timeoutSuffix,
+				0,
+				0,
+			);
+		},
+
+		renderResult(result, options, theme, context) {
+			if (options.isPartial) {
+				return new Text(theme.fg("warning", "Running..."), 0, 0);
+			}
+
+			const command = context.args.command as string | undefined;
+			const collapsed = command ? isReadonlyBash(command) : false;
+
+			if (collapsed && !options.expanded) {
+				const text = getTextContent(result);
+				if (text?.trim()) {
+					const count = countNonEmptyLines(text);
+					return new Text(theme.fg("muted", ` → ${count} lines`), 0, 0);
+				}
+				return new Text("", 0, 0);
+			}
+
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).bash,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}
+
+export function registerWriteTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).write.parameters;
+
+	pi.registerTool({
+		name: "write",
+		label: "write",
+		description: getBuiltInTools(process.cwd()).write.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.write.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const path = shortenPath((args.path as string | undefined) || "");
+			const pathDisplay = path
+				? theme.fg("accent", path)
+				: theme.fg("toolOutput", "...");
+			const content = args.content as string | undefined;
+			const lineCount = content ? content.split("\n").length : 0;
+			const lineInfo =
+				lineCount > 0 ? theme.fg("muted", ` (${lineCount} lines)`) : "";
+
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("write"))} ${pathDisplay}${lineInfo}`,
+				0,
+				0,
+			);
+		},
+
+		renderResult(result, options, theme, context) {
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).write,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}
+
+export function registerEditTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).edit.parameters;
+
+	pi.registerTool({
+		name: "edit",
+		label: "edit",
+		description: getBuiltInTools(process.cwd()).edit.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.edit.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const path = shortenPath((args.path as string | undefined) || "");
+			const pathDisplay = path
+				? theme.fg("accent", path)
+				: theme.fg("toolOutput", "...");
+
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`,
+				0,
+				0,
+			);
+		},
+
+		renderResult(result, options, theme, context) {
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).edit,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}

package/packages/ui-enhancements/src/tools/index.ts

@@ -0,0 +1,22 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	registerBashTool,
+	registerEditTool,
+	registerWriteTool,
+} from "./bash-write-edit.ts";
+import {
+	registerFindTool,
+	registerGrepTool,
+	registerLsTool,
+	registerReadTool,
+} from "./read-find-grep-ls.ts";
+
+export function registerCompactBuiltInTools(pi: ExtensionAPI): void {
+	registerReadTool(pi);
+	registerBashTool(pi);
+	registerWriteTool(pi);
+	registerEditTool(pi);
+	registerFindTool(pi);
+	registerGrepTool(pi);
+	registerLsTool(pi);
+}

package/packages/ui-enhancements/src/tools/read-find-grep-ls.ts

@@ -0,0 +1,235 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { shortenPath } from "../utils/shorten-path.ts";
+import {
+	countNonEmptyLines,
+	getTextContent,
+	renderBuiltInToolResult,
+} from "./text-content.ts";
+import { getBuiltInDefinitions, getBuiltInTools } from "./tool-cache.ts";
+
+export function registerReadTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).read.parameters;
+
+	pi.registerTool({
+		name: "read",
+		label: "read",
+		description: getBuiltInTools(process.cwd()).read.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.read.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const path = shortenPath((args.path as string | undefined) || "");
+			let pathDisplay = path
+				? theme.fg("accent", path)
+				: theme.fg("toolOutput", "...");
+
+			if (args.offset !== undefined || args.limit !== undefined) {
+				const startLine = (args.offset as number | undefined) ?? 1;
+				const endLine =
+					args.limit !== undefined
+						? startLine + (args.limit as number) - 1
+						: "";
+				pathDisplay += theme.fg(
+					"warning",
+					`:${startLine}${endLine ? `-${endLine}` : ""}`,
+				);
+			}
+
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("read"))} ${pathDisplay}`,
+				0,
+				0,
+			);
+		},
+
+		renderResult(result, options, theme, context) {
+			if (options.isPartial) {
+				return new Text(theme.fg("warning", "Reading..."), 0, 0);
+			}
+
+			if (!options.expanded) {
+				return new Text("", 0, 0);
+			}
+
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).read,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}
+
+export function registerFindTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).find.parameters;
+
+	pi.registerTool({
+		name: "find",
+		label: "find",
+		description: getBuiltInTools(process.cwd()).find.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.find.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const pattern = (args.pattern as string | undefined) || "";
+			const path = shortenPath((args.path as string | undefined) || ".");
+			const limit = args.limit as number | undefined;
+
+			let text = `${theme.fg("toolTitle", theme.bold("find"))} ${theme.fg("accent", pattern)}`;
+			text += theme.fg("toolOutput", ` in ${path}`);
+			if (limit !== undefined) {
+				text += theme.fg("toolOutput", ` (limit ${limit})`);
+			}
+
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, options, theme, context) {
+			if (options.isPartial) {
+				return new Text(theme.fg("warning", "Searching..."), 0, 0);
+			}
+
+			if (!options.expanded) {
+				const text = getTextContent(result);
+				if (text) {
+					const count = countNonEmptyLines(text);
+					if (count > 0) {
+						return new Text(theme.fg("muted", ` → ${count} files`), 0, 0);
+					}
+				}
+				return new Text("", 0, 0);
+			}
+
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).find,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}
+
+export function registerGrepTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).grep.parameters;
+
+	pi.registerTool({
+		name: "grep",
+		label: "grep",
+		description: getBuiltInTools(process.cwd()).grep.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.grep.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const pattern = (args.pattern as string | undefined) || "";
+			const path = shortenPath((args.path as string | undefined) || ".");
+			const glob = args.glob as string | undefined;
+			const limit = args.limit as number | undefined;
+
+			let text = `${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", `/${pattern}/`)}`;
+			text += theme.fg("toolOutput", ` in ${path}`);
+			if (glob) {
+				text += theme.fg("toolOutput", ` (${glob})`);
+			}
+			if (limit !== undefined) {
+				text += theme.fg("toolOutput", ` limit ${limit}`);
+			}
+
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, options, theme, context) {
+			if (options.isPartial) {
+				return new Text(theme.fg("warning", "Searching..."), 0, 0);
+			}
+
+			if (!options.expanded) {
+				const text = getTextContent(result);
+				if (text) {
+					const count = countNonEmptyLines(text);
+					if (count > 0) {
+						return new Text(theme.fg("muted", ` → ${count} matches`), 0, 0);
+					}
+				}
+				return new Text("", 0, 0);
+			}
+
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).grep,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}
+
+export function registerLsTool(pi: ExtensionAPI): void {
+	const parameters = getBuiltInTools(process.cwd()).ls.parameters;
+
+	pi.registerTool({
+		name: "ls",
+		label: "ls",
+		description: getBuiltInTools(process.cwd()).ls.description,
+		parameters,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const tools = getBuiltInTools(ctx.cwd);
+			return tools.ls.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme) {
+			const path = shortenPath((args.path as string | undefined) || ".");
+			const limit = args.limit as number | undefined;
+
+			let text = `${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", path)}`;
+			if (limit !== undefined) {
+				text += theme.fg("toolOutput", ` (limit ${limit})`);
+			}
+
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, options, theme, context) {
+			if (options.isPartial) {
+				return new Text(theme.fg("warning", "Listing..."), 0, 0);
+			}
+
+			if (!options.expanded) {
+				const text = getTextContent(result);
+				if (text) {
+					const count = countNonEmptyLines(text);
+					if (count > 0) {
+						return new Text(theme.fg("muted", ` → ${count} entries`), 0, 0);
+					}
+				}
+				return new Text("", 0, 0);
+			}
+
+			return renderBuiltInToolResult(
+				getBuiltInDefinitions(context.cwd).ls,
+				result,
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+}

package/packages/ui-enhancements/src/tools/text-content.ts

@@ -0,0 +1,42 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type {
+	Theme,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
+
+type BuiltInRenderDefinition = {
+	renderResult?: (
+		result: AgentToolResult<unknown>,
+		options: ToolRenderResultOptions,
+		theme: Theme,
+		context: unknown,
+	) => Component;
+};
+
+export function getTextContent(
+	result: AgentToolResult<unknown>,
+): string | undefined {
+	const textContent = result.content.find((c) => c.type === "text");
+	if (textContent?.type !== "text") return undefined;
+	return textContent.text;
+}
+
+export function countNonEmptyLines(text: string): number {
+	return text.trim().split("\n").filter(Boolean).length;
+}
+
+export function renderBuiltInToolResult(
+	definition: object,
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: unknown,
+): Component {
+	const renderResult = (definition as BuiltInRenderDefinition).renderResult;
+	if (!renderResult) {
+		return new Text("", 0, 0);
+	}
+	return renderResult(result, options, theme, context);
+}

package/packages/ui-enhancements/src/tools/tool-cache.ts

@@ -0,0 +1,87 @@
+import {
+	createBashTool,
+	createBashToolDefinition,
+	createEditTool,
+	createEditToolDefinition,
+	createFindTool,
+	createFindToolDefinition,
+	createGrepTool,
+	createGrepToolDefinition,
+	createLsTool,
+	createLsToolDefinition,
+	createReadTool,
+	createReadToolDefinition,
+	createWriteTool,
+	createWriteToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+
+type BuiltInTools = {
+	read: ReturnType<typeof createReadTool>;
+	bash: ReturnType<typeof createBashTool>;
+	edit: ReturnType<typeof createEditTool>;
+	write: ReturnType<typeof createWriteTool>;
+	find: ReturnType<typeof createFindTool>;
+	grep: ReturnType<typeof createGrepTool>;
+	ls: ReturnType<typeof createLsTool>;
+};
+
+export type BuiltInDefinitions = {
+	read: ReturnType<typeof createReadToolDefinition>;
+	bash: ReturnType<typeof createBashToolDefinition>;
+	edit: ReturnType<typeof createEditToolDefinition>;
+	write: ReturnType<typeof createWriteToolDefinition>;
+	find: ReturnType<typeof createFindToolDefinition>;
+	grep: ReturnType<typeof createGrepToolDefinition>;
+	ls: ReturnType<typeof createLsToolDefinition>;
+};
+
+type BuiltInToolBundle = {
+	tools: BuiltInTools;
+	definitions: BuiltInDefinitions;
+};
+
+function createBuiltInBundle(cwd: string): BuiltInToolBundle {
+	return {
+		tools: {
+			read: createReadTool(cwd),
+			bash: createBashTool(cwd),
+			edit: createEditTool(cwd),
+			write: createWriteTool(cwd),
+			find: createFindTool(cwd),
+			grep: createGrepTool(cwd),
+			ls: createLsTool(cwd),
+		},
+		definitions: {
+			read: createReadToolDefinition(cwd),
+			bash: createBashToolDefinition(cwd),
+			edit: createEditToolDefinition(cwd),
+			write: createWriteToolDefinition(cwd),
+			find: createFindToolDefinition(cwd),
+			grep: createGrepToolDefinition(cwd),
+			ls: createLsToolDefinition(cwd),
+		},
+	};
+}
+
+const toolCache = new Map<string, BuiltInToolBundle>();
+
+function getBuiltInBundle(cwd: string): BuiltInToolBundle {
+	let bundle = toolCache.get(cwd);
+	if (!bundle) {
+		bundle = createBuiltInBundle(cwd);
+		toolCache.set(cwd, bundle);
+	}
+	return bundle;
+}
+
+export function getBuiltInTools(cwd: string): BuiltInTools {
+	return getBuiltInBundle(cwd).tools;
+}
+
+export function getBuiltInDefinitions(cwd: string): BuiltInDefinitions {
+	return getBuiltInBundle(cwd).definitions;
+}
+
+export function clearBuiltInToolCache(): void {
+	toolCache.clear();
+}

package/packages/ui-enhancements/src/utils/shorten-path.ts

@@ -0,0 +1,9 @@
+import { homedir } from "node:os";
+
+export function shortenPath(path: string): string {
+	const home = homedir();
+	if (path.startsWith(home)) {
+		return `~${path.slice(home.length)}`;
+	}
+	return path;
+}

package/packages/ui-enhancements/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": true
+	},
+	"include": [
+		"extensions/**/*.ts",
+		"src/**/*.ts",
+		"tests/**/*.ts",
+		"vitest.config.ts"
+	],
+	"exclude": ["node_modules"]
+}

package/packages/ui-enhancements/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["tests/**/*.test.ts"],
+	},
+});