@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/ui-enhancements/tests/recent-sessions.test.ts

@@ -0,0 +1,72 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	utimesSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	formatTimeAgo,
+	getRecentSessions,
+} from "../src/chrome/recent-sessions.ts";
+
+describe("formatTimeAgo", () => {
+	it("formats recent times", () => {
+		expect(formatTimeAgo(30_000)).toBe("just now");
+		expect(formatTimeAgo(120_000)).toBe("2m ago");
+		expect(formatTimeAgo(3_600_000)).toBe("1h ago");
+		expect(formatTimeAgo(86_400_000)).toBe("1d ago");
+	});
+});
+
+describe("getRecentSessions", () => {
+	let tempHome: string;
+
+	beforeEach(() => {
+		tempHome = mkdtempSync(join(tmpdir(), "vitos-recent-sessions-"));
+		vi.stubEnv("HOME", tempHome);
+		vi.stubEnv("USERPROFILE", tempHome);
+	});
+
+	afterEach(() => {
+		vi.unstubAllEnvs();
+		rmSync(tempHome, { recursive: true, force: true });
+	});
+
+	it("returns empty list when sessions directory is missing", () => {
+		expect(getRecentSessions(5)).toEqual([]);
+	});
+
+	it("sorts, deduplicates, and formats recent sessions", () => {
+		const sessionsRoot = join(tempHome, ".pi", "agent", "sessions");
+		const projectA = join(sessionsRoot, "--users--project-a--");
+		const projectB = join(sessionsRoot, "--users--project-b--");
+		mkdirSync(projectA, { recursive: true });
+		mkdirSync(projectB, { recursive: true });
+
+		const older = join(projectA, "older.jsonl");
+		const newer = join(projectA, "newer.jsonl");
+		const other = join(projectB, "other.jsonl");
+
+		const header = (cwd: string) =>
+			`${JSON.stringify({ type: "session", version: 3, cwd })}\n`;
+
+		writeFileSync(older, header("C:\\Users\\me\\project-a"));
+		writeFileSync(newer, header("C:\\Users\\me\\project-a"));
+		writeFileSync(other, header("C:\\Users\\me\\subagent"));
+
+		const now = Date.now();
+		utimesSync(older, now / 1000 - 3600, now / 1000 - 3600);
+		utimesSync(newer, now / 1000 - 60, now / 1000 - 60);
+		utimesSync(other, now / 1000 - 10, now / 1000 - 10);
+
+		const recent = getRecentSessions(5);
+		expect(recent).toHaveLength(2);
+		expect(recent[0]?.name).toBe("subagent");
+		expect(recent[0]?.timeAgo).toBe("just now");
+		expect(recent[1]?.name).toBe("project-a");
+	});
+});

package/node_modules/@vitos-pizza/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/node_modules/@vitos-pizza/ui-enhancements/vitest.config.ts

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

package/node_modules/@vitos-pizza/websearch/extensions/index.ts

@@ -0,0 +1,130 @@
+/**
+ * @vitos-pizza/websearch — web search and URL reading for Vito's Pizzeria.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { config, refreshConfig } from "../src/config.ts";
+import { runSearchWithFallback } from "../src/dispatch.ts";
+import { formatReadResult, formatSearchResults } from "../src/formatters.ts";
+import {
+	type WebReadInput,
+	WebReadParams,
+	type WebSearchInput,
+	WebSearchParams,
+} from "../src/schema.ts";
+import {
+	buildSearchStatus,
+	normalizeUrl,
+	readUrlWithFallback,
+} from "../src/status.ts";
+import { validateUrl } from "../src/utils.ts";
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "web_search",
+		label: "Web Search",
+		description:
+			"Search the web using configured backends. Auto mode tries Exa MCP, Firecrawl, and optional keyed providers.",
+		promptSnippet: "Search the web for up-to-date information",
+		promptGuidelines: [
+			"Use web_search when you need current facts, documentation, or news from the web",
+			"Auto mode tries enabled backends in order; Exa MCP works without API keys",
+			"Configure Tavily or Brave in .pi/search.json for higher-quality results",
+		],
+		parameters: WebSearchParams,
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const input = params as WebSearchInput;
+			refreshConfig(ctx.cwd);
+			const numResults = Math.max(1, Math.min(input.numResults ?? 5, 20));
+			const backend = input.backend ?? "auto";
+
+			onUpdate?.({
+				content: [{ type: "text", text: `*Searching: ${input.query}*` }],
+				details: {},
+			});
+			ctx.ui.setStatus("search", `Searching: ${input.query}`);
+
+			try {
+				const result = await runSearchWithFallback(input.query, numResults, {
+					backend,
+					signal,
+				});
+				const text = formatSearchResults(
+					input.query,
+					result.results,
+					result.backend,
+				);
+				return {
+					content: [{ type: "text", text }],
+					details: {
+						backend: result.backend,
+						resultCount: result.results.length,
+						errors: result.errors,
+					},
+				};
+			} finally {
+				ctx.ui.setStatus("search", "");
+			}
+		},
+	});
+
+	pi.registerTool({
+		name: "web_read",
+		label: "Read Web Page",
+		description:
+			"Fetch a URL as markdown. Uses Jina Reader by default, then Firecrawl or Exa MCP as fallback.",
+		promptSnippet: "Read content from a specific URL",
+		promptGuidelines: [
+			"Use web_read when you already have a URL and need the page content",
+			"Prefer web_search first when you do not yet know which pages to open",
+		],
+		parameters: WebReadParams,
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const input = params as WebReadInput;
+			refreshConfig(ctx.cwd);
+			const url = normalizeUrl(input.url);
+			const ssrfError = validateUrl(url);
+			if (ssrfError) {
+				throw new Error(ssrfError);
+			}
+
+			onUpdate?.({
+				content: [{ type: "text", text: `*Reading: ${url}*` }],
+				details: {},
+			});
+			ctx.ui.setStatus("read", `Reading: ${url}`);
+
+			try {
+				const result = await readUrlWithFallback(url, config, signal);
+				const text = formatReadResult(
+					url,
+					result.content,
+					result.reader,
+					result.title,
+				);
+				return {
+					content: [{ type: "text", text }],
+					details: {
+						reader: result.reader,
+						url: result.url,
+						title: result.title,
+					},
+				};
+			} finally {
+				ctx.ui.setStatus("read", "");
+			}
+		},
+	});
+
+	pi.registerCommand("search-status", {
+		description: "Show active web search backends and key status",
+		handler: async (_args, ctx) => {
+			const activeBackends = refreshConfig(ctx.cwd, true);
+			ctx.ui.notify(buildSearchStatus(config, activeBackends), "info");
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		refreshConfig(ctx.cwd, true);
+	});
+}

package/node_modules/@vitos-pizza/websearch/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@vitos-pizza/websearch",
+	"version": "0.1.0",
+	"description": "Web search and URL reading for Vito's Pizzeria Pi distribution",
+	"type": "module",
+	"license": "MIT",
+	"private": true,
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-agent-core": "*",
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"typebox": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/node_modules/@vitos-pizza/websearch/src/backends/brave.ts

@@ -0,0 +1,35 @@
+import { parseBrave } from "../parsers.ts";
+import type { SearchResult } from "../types.ts";
+import { sanitizeError, timeoutSignal } from "../utils.ts";
+
+export async function searchBrave(
+	query: string,
+	numResults: number,
+	apiKey: string,
+	signal?: AbortSignal,
+): Promise<{ results: SearchResult[] }> {
+	const params = new URLSearchParams({
+		q: query,
+		count: String(Math.min(numResults, 20)),
+	});
+	const response = await fetch(
+		`https://api.search.brave.com/res/v1/web/search?${params}`,
+		{
+			method: "GET",
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "gzip",
+				"X-Subscription-Token": apiKey,
+			},
+			signal: timeoutSignal(signal),
+		},
+	);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Brave ${sanitizeError(response.status, text)}`);
+	}
+
+	const data = (await response.json()) as Record<string, unknown>;
+	return { results: parseBrave(data, numResults) };
+}

package/node_modules/@vitos-pizza/websearch/src/backends/exa-mcp.ts

@@ -0,0 +1,139 @@
+import { parseExaMcpItems } from "../parsers.ts";
+import type { SearchResult } from "../types.ts";
+import { sanitizeError, timeoutSignal } from "../utils.ts";
+
+const EXA_MCP_ENDPOINT = "https://mcp.exa.ai/mcp";
+
+interface MCPRequest {
+	jsonrpc: "2.0";
+	id: number;
+	method: string;
+	params?: {
+		name?: string;
+		arguments?: Record<string, unknown>;
+	};
+}
+
+interface MCPResponse {
+	jsonrpc: "2.0";
+	id: number;
+	result?: {
+		content?: Array<{ type: string; text?: string }>;
+	};
+	error?: {
+		code: number;
+		message: string;
+	};
+}
+
+let requestId = 0;
+
+function parseMcpText(text: string): SearchResult[] {
+	try {
+		const parsed = JSON.parse(text) as unknown;
+		if (Array.isArray(parsed)) {
+			return parseExaMcpItems(parsed as Array<Record<string, unknown>>);
+		}
+		if (
+			typeof parsed === "object" &&
+			parsed !== null &&
+			Array.isArray((parsed as Record<string, unknown>).results)
+		) {
+			return parseExaMcpItems(
+				(parsed as Record<string, unknown>).results as Array<
+					Record<string, unknown>
+				>,
+			);
+		}
+	} catch {
+		// fall through to line parsing
+	}
+
+	const results: SearchResult[] = [];
+	for (const line of text.split("\n")) {
+		const parts = line.split("\t");
+		if (parts.length >= 2) {
+			results.push({
+				title: parts[1] || "",
+				url: parts[0] || "",
+				snippet: parts[2] || "",
+			});
+		}
+	}
+	return results;
+}
+
+async function callMcp(
+	toolName: string,
+	arguments_: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<SearchResult[]> {
+	const id = ++requestId;
+	const request: MCPRequest = {
+		jsonrpc: "2.0",
+		id,
+		method: "tools/call",
+		params: {
+			name: toolName,
+			arguments: arguments_,
+		},
+	};
+
+	const response = await fetch(EXA_MCP_ENDPOINT, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(request),
+		signal: timeoutSignal(signal),
+	});
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Exa MCP ${sanitizeError(response.status, text)}`);
+	}
+
+	const data = (await response.json()) as MCPResponse;
+	if (data.error) {
+		throw new Error(`Exa MCP error: ${data.error.message}`);
+	}
+
+	const text = (data.result?.content ?? [])
+		.filter((entry) => entry.type === "text")
+		.map((entry) => entry.text ?? "")
+		.join("\n");
+
+	return parseMcpText(text);
+}
+
+export async function searchExaMCP(
+	query: string,
+	numResults: number,
+	signal?: AbortSignal,
+): Promise<{ results: SearchResult[] }> {
+	const results = await callMcp(
+		"web_search_exa",
+		{
+			query,
+			numResults: Math.min(numResults, 20),
+		},
+		signal,
+	);
+	return { results };
+}
+
+export async function fetchExaMCP(
+	url: string,
+	signal?: AbortSignal,
+): Promise<{ title: string; url: string; content: string }> {
+	const results = await callMcp("web_fetch_exa", { url }, signal);
+	const first = results[0];
+	if (!first) {
+		throw new Error(`Exa MCP fetch returned no content for ${url}`);
+	}
+	return {
+		title: first.title || "",
+		url: first.url || url,
+		content: first.content || first.snippet || "",
+	};
+}

package/node_modules/@vitos-pizza/websearch/src/backends/firecrawl.ts

@@ -0,0 +1,86 @@
+import { parseFirecrawl } from "../parsers.ts";
+import type { SearchResult } from "../types.ts";
+import { sanitizeError, timeoutSignal } from "../utils.ts";
+
+const FIRECRAWL_SEARCH_URL = "https://api.firecrawl.dev/v2/search";
+const FIRECRAWL_SCRAPE_URL = "https://api.firecrawl.dev/v2/scrape";
+
+function buildHeaders(apiKey?: string): Record<string, string> {
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+	};
+	if (apiKey) {
+		headers.Authorization = `Bearer ${apiKey}`;
+	}
+	return headers;
+}
+
+export async function searchFirecrawl(
+	query: string,
+	numResults: number,
+	apiKey: string | undefined,
+	signal?: AbortSignal,
+): Promise<{ results: SearchResult[] }> {
+	const response = await fetch(FIRECRAWL_SEARCH_URL, {
+		method: "POST",
+		headers: buildHeaders(apiKey),
+		body: JSON.stringify({
+			query,
+			limit: Math.min(numResults, 20),
+		}),
+		signal: timeoutSignal(signal),
+	});
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Firecrawl ${sanitizeError(response.status, text)}`);
+	}
+
+	const data = (await response.json()) as Record<string, unknown>;
+	return { results: parseFirecrawl(data, numResults) };
+}
+
+export async function fetchFirecrawl(
+	url: string,
+	apiKey: string | undefined,
+	signal?: AbortSignal,
+): Promise<{ title: string; url: string; content: string }> {
+	const response = await fetch(FIRECRAWL_SCRAPE_URL, {
+		method: "POST",
+		headers: buildHeaders(apiKey),
+		body: JSON.stringify({
+			url,
+			formats: ["markdown"],
+		}),
+		signal: timeoutSignal(signal),
+	});
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Firecrawl ${sanitizeError(response.status, text)}`);
+	}
+
+	const data = (await response.json()) as Record<string, unknown>;
+	const payload = data.data;
+	if (!payload || typeof payload !== "object") {
+		throw new Error(`Firecrawl scrape returned no content for ${url}`);
+	}
+	const record = payload as Record<string, unknown>;
+	const metadata =
+		(record.metadata as Record<string, unknown> | undefined) ?? {};
+	const content =
+		(record.markdown as string) ||
+		(record.content as string) ||
+		(record.text as string) ||
+		"";
+
+	if (!content.trim()) {
+		throw new Error(`Firecrawl scrape returned empty content for ${url}`);
+	}
+
+	return {
+		title: (metadata.title as string) || "",
+		url: (metadata.sourceURL as string) || url,
+		content,
+	};
+}

package/node_modules/@vitos-pizza/websearch/src/backends/registry.ts

@@ -0,0 +1,98 @@
+import { config } from "../config.ts";
+import { resolveBackendKey } from "../credentials.ts";
+import type { BackendRunner, SearchResult } from "../types.ts";
+import { MISSING_KEY_HELP } from "../utils.ts";
+import { searchBrave } from "./brave.ts";
+import { searchExaMCP } from "./exa-mcp.ts";
+import { searchFirecrawl } from "./firecrawl.ts";
+import { searchTavily } from "./tavily.ts";
+
+export const BACKEND_DEFS: Record<string, BackendRunner> = {
+	exa_mcp: {
+		needsKey: false,
+		optionalKey: false,
+		label: "Exa MCP",
+		search: async (query, numResults, { signal }) => {
+			const result = await searchExaMCP(query, numResults, signal);
+			return {
+				results: result.results.map((entry) => ({
+					...entry,
+					backend: "exa_mcp",
+				})),
+			};
+		},
+	},
+	firecrawl: {
+		needsKey: false,
+		optionalKey: true,
+		label: "Firecrawl",
+		search: async (query, numResults, { key, signal }) => {
+			const result = await searchFirecrawl(query, numResults, key, signal);
+			return {
+				results: result.results.map((entry) => ({
+					...entry,
+					backend: "firecrawl",
+				})),
+			};
+		},
+	},
+	tavily: {
+		needsKey: true,
+		optionalKey: false,
+		label: "Tavily",
+		search: async (query, numResults, { key, signal }) => {
+			if (!key) {
+				throw new Error(`Tavily backend not configured. ${MISSING_KEY_HELP}`);
+			}
+			const result = await searchTavily(query, numResults, key, signal);
+			return {
+				results: result.results.map((entry) => ({
+					...entry,
+					backend: "tavily",
+				})),
+			};
+		},
+	},
+	brave: {
+		needsKey: true,
+		optionalKey: false,
+		label: "Brave",
+		search: async (query, numResults, { key, signal }) => {
+			if (!key) {
+				throw new Error(`Brave backend not configured. ${MISSING_KEY_HELP}`);
+			}
+			const result = await searchBrave(query, numResults, key, signal);
+			return {
+				results: result.results.map((entry) => ({
+					...entry,
+					backend: "brave",
+				})),
+			};
+		},
+	},
+};
+
+export async function runBackend(
+	backend: string,
+	query: string,
+	numResults: number,
+	signal?: AbortSignal,
+): Promise<SearchResult[]> {
+	const def = BACKEND_DEFS[backend];
+	if (!def) {
+		throw new Error(`Unknown backend: ${backend}`);
+	}
+
+	let key: string | undefined;
+	if (def.needsKey || def.optionalKey) {
+		key = resolveBackendKey(backend, config);
+		if (def.needsKey && !key) {
+			throw new Error(
+				`${def.label} backend not configured. ${MISSING_KEY_HELP}`,
+			);
+		}
+	}
+
+	const result = await def.search(query, numResults, { key, signal });
+	return result.results;
+}

package/node_modules/@vitos-pizza/websearch/src/backends/tavily.ts

@@ -0,0 +1,32 @@
+import { parseTavily } from "../parsers.ts";
+import type { SearchResult } from "../types.ts";
+import { sanitizeError, timeoutSignal } from "../utils.ts";
+
+export async function searchTavily(
+	query: string,
+	numResults: number,
+	apiKey: string,
+	signal?: AbortSignal,
+): Promise<{ results: SearchResult[] }> {
+	const response = await fetch("https://api.tavily.com/search", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`,
+		},
+		body: JSON.stringify({
+			query,
+			max_results: Math.min(numResults, 20),
+			include_answer: false,
+		}),
+		signal: timeoutSignal(signal),
+	});
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Tavily ${sanitizeError(response.status, text)}`);
+	}
+
+	const data = (await response.json()) as Record<string, unknown>;
+	return { results: parseTavily(data, numResults) };
+}