@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

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

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

@@ -1,28 +0,0 @@
-{
-	"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

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

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

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

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

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

package/node_modules/@vitos-pizza/websearch/src/config.ts

@@ -1,124 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { BackendConfig, SearchConfig } from "./types.ts";
-import { getAgentDir } from "./utils.ts";
-
-export const DEFAULT_CONFIG: SearchConfig = {
-	defaultBackend: "auto",
-	reader: "jina",
-	backends: {
-		exa_mcp: { enabled: true },
-		firecrawl: { enabled: true },
-	},
-};
-
-export const FALLBACK_ENV_MAP: Record<string, string> = {
-	tavily: "SEARCH_TAVILY_API_KEY",
-	brave: "SEARCH_BRAVE_API_KEY",
-	firecrawl: "SEARCH_FIRECRAWL_API_KEY",
-};
-
-export let config: SearchConfig = structuredClone(DEFAULT_CONFIG);
-
-let activeBackendsList: string[] = [];
-let configCacheTime = 0;
-const CONFIG_TTL_MS = 10_000;
-
-function mergeBackends(
-	globalBackends: Record<string, BackendConfig>,
-	projectBackends: Record<string, BackendConfig>,
-): Record<string, BackendConfig> {
-	const merged = { ...globalBackends };
-	for (const [key, value] of Object.entries(projectBackends)) {
-		merged[key] = { ...merged[key], ...value };
-	}
-	return merged;
-}
-
-export function loadConfig(cwd: string): SearchConfig {
-	const globalPath = join(getAgentDir(), "extensions", "search.json");
-	const projectPath = join(cwd, ".pi", "search.json");
-
-	let loaded: SearchConfig = structuredClone(DEFAULT_CONFIG);
-
-	if (existsSync(globalPath)) {
-		try {
-			const global = JSON.parse(
-				readFileSync(globalPath, "utf8"),
-			) as SearchConfig;
-			loaded = {
-				...loaded,
-				...global,
-				backends: mergeBackends(loaded.backends ?? {}, global.backends ?? {}),
-			};
-		} catch {
-			// ignore invalid global config
-		}
-	}
-
-	const preProjectBackends = { ...(loaded.backends ?? {}) };
-
-	if (existsSync(projectPath)) {
-		try {
-			const project = JSON.parse(
-				readFileSync(projectPath, "utf8"),
-			) as SearchConfig;
-			loaded = {
-				...loaded,
-				...project,
-				backends: project.backends
-					? mergeBackends(preProjectBackends, project.backends)
-					: preProjectBackends,
-			};
-		} catch {
-			// ignore invalid project config
-		}
-	}
-
-	for (const [backend, envVar] of Object.entries(FALLBACK_ENV_MAP)) {
-		const envValue = process.env[envVar];
-		if (!envValue?.trim()) continue;
-		const existing = loaded.backends?.[backend];
-		if (existing?.enabled === false) continue;
-		loaded.backends ??= {};
-		loaded.backends[backend] = {
-			...existing,
-			enabled: existing?.enabled ?? true,
-		};
-	}
-
-	return loaded;
-}
-
-export function refreshConfig(cwd: string, force = false): string[] {
-	const now = Date.now();
-	if (!force && now - configCacheTime < CONFIG_TTL_MS) {
-		return activeBackendsList;
-	}
-
-	config = loadConfig(cwd);
-	configCacheTime = now;
-
-	activeBackendsList = Object.entries(config.backends ?? {})
-		.filter(([, backendConfig]) => backendConfig?.enabled)
-		.map(([name]) => name);
-
-	if (activeBackendsList.length === 0) {
-		activeBackendsList = ["exa_mcp", "firecrawl"];
-	}
-
-	if (config.defaultBackend && config.defaultBackend !== "auto") {
-		if (activeBackendsList.includes(config.defaultBackend)) {
-			activeBackendsList = [
-				config.defaultBackend,
-				...activeBackendsList.filter((name) => name !== config.defaultBackend),
-			];
-		}
-	}
-
-	return activeBackendsList;
-}
-
-export function getActiveBackends(): string[] {
-	return activeBackendsList;
-}