@oh-my-pi/pi-coding-agent 3.25.0 → 3.30.0

package/src/core/tools/web-fetch-handlers/brew.ts

@@ -0,0 +1,173 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface BrewFormula {
+	name: string;
+	full_name?: string;
+	desc?: string;
+	homepage?: string;
+	license?: string;
+	versions?: {
+		stable?: string;
+		head?: string;
+		bottle?: boolean;
+	};
+	dependencies?: string[];
+	build_dependencies?: string[];
+	optional_dependencies?: string[];
+	conflicts_with?: string[];
+	caveats?: string;
+	analytics?: {
+		install?: {
+			"30d"?: Record<string, number>;
+			"90d"?: Record<string, number>;
+			"365d"?: Record<string, number>;
+		};
+	};
+}
+
+interface BrewCask {
+	token: string;
+	name?: string[];
+	desc?: string;
+	homepage?: string;
+	version?: string;
+	sha256?: string;
+	caveats?: string;
+	depends_on?: {
+		macos?: Record<string, string[]>;
+	};
+	conflicts_with?: {
+		cask?: string[];
+	};
+	analytics?: {
+		install?: {
+			"30d"?: Record<string, number>;
+			"90d"?: Record<string, number>;
+			"365d"?: Record<string, number>;
+		};
+	};
+}
+
+function getInstallCount(analytics?: { install?: { "30d"?: Record<string, number> } }): number | null {
+	if (!analytics?.install?.["30d"]) return null;
+	const counts = Object.values(analytics.install["30d"]);
+	return counts.reduce((sum, n) => sum + n, 0);
+}
+
+/**
+ * Handle Homebrew formulae and cask URLs via API
+ */
+export const handleBrew: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "formulae.brew.sh") return null;
+
+		const formulaMatch = parsed.pathname.match(/^\/formula\/([^/]+)\/?$/);
+		const caskMatch = parsed.pathname.match(/^\/cask\/([^/]+)\/?$/);
+
+		if (!formulaMatch && !caskMatch) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const isFormula = Boolean(formulaMatch);
+		const name = decodeURIComponent(isFormula ? formulaMatch![1] : caskMatch![1]);
+
+		const apiUrl = isFormula
+			? `https://formulae.brew.sh/api/formula/${encodeURIComponent(name)}.json`
+			: `https://formulae.brew.sh/api/cask/${encodeURIComponent(name)}.json`;
+
+		const result = await loadPage(apiUrl, { timeout });
+		if (!result.ok) return null;
+
+		let md: string;
+
+		if (isFormula) {
+			const formula: BrewFormula = JSON.parse(result.content);
+
+			md = `# ${formula.full_name || formula.name}\n\n`;
+			if (formula.desc) md += `${formula.desc}\n\n`;
+
+			md += `**Version:** ${formula.versions?.stable || "unknown"}`;
+			if (formula.license) md += ` · **License:** ${formula.license}`;
+			md += "\n";
+
+			const installs = getInstallCount(formula.analytics);
+			if (installs !== null) {
+				md += `**Installs (30d):** ${formatCount(installs)}\n`;
+			}
+			md += "\n";
+
+			md += `\`\`\`bash\nbrew install ${formula.name}\n\`\`\`\n\n`;
+
+			if (formula.homepage) md += `**Homepage:** ${formula.homepage}\n`;
+
+			if (formula.dependencies?.length) {
+				md += `\n## Dependencies\n\n`;
+				for (const dep of formula.dependencies) {
+					md += `- ${dep}\n`;
+				}
+			}
+
+			if (formula.build_dependencies?.length) {
+				md += `\n## Build Dependencies\n\n`;
+				for (const dep of formula.build_dependencies) {
+					md += `- ${dep}\n`;
+				}
+			}
+
+			if (formula.conflicts_with?.length) {
+				md += `\n## Conflicts With\n\n`;
+				for (const conflict of formula.conflicts_with) {
+					md += `- ${conflict}\n`;
+				}
+			}
+
+			if (formula.caveats) {
+				md += `\n## Caveats\n\n${formula.caveats}\n`;
+			}
+		} else {
+			const cask: BrewCask = JSON.parse(result.content);
+
+			const displayName = cask.name?.[0] || cask.token;
+			md = `# ${displayName}\n\n`;
+			if (cask.desc) md += `${cask.desc}\n\n`;
+
+			md += `**Version:** ${cask.version || "unknown"}\n`;
+
+			const installs = getInstallCount(cask.analytics);
+			if (installs !== null) {
+				md += `**Installs (30d):** ${formatCount(installs)}\n`;
+			}
+			md += "\n";
+
+			md += `\`\`\`bash\nbrew install --cask ${cask.token}\n\`\`\`\n\n`;
+
+			if (cask.homepage) md += `**Homepage:** ${cask.homepage}\n`;
+
+			if (cask.conflicts_with?.cask?.length) {
+				md += `\n## Conflicts With\n\n`;
+				for (const conflict of cask.conflicts_with.cask) {
+					md += `- ${conflict}\n`;
+				}
+			}
+
+			if (cask.caveats) {
+				md += `\n## Caveats\n\n${cask.caveats}\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "brew",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: [`Fetched via Homebrew ${isFormula ? "formula" : "cask"} API`],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/web-fetch-handlers/business.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "bun:test";
+import { handleOpenCorporates } from "./opencorporates";
+import { handleSecEdgar } from "./sec-edgar";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleSecEdgar", () => {
+	it("returns null for non-matching URLs", async () => {
+		const result = await handleSecEdgar("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for SEC URLs without valid CIK", async () => {
+		const result = await handleSecEdgar("https://www.sec.gov/about.html", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Apple Inc filings by CIK query param", async () => {
+		const result = await handleSecEdgar(
+			"https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0000320193",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("sec-edgar");
+		expect(result?.content).toContain("APPLE INC");
+		expect(result?.content).toContain("0000320193");
+		expect(result?.content).toContain("10-K"); // Apple files 10-K annually
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches via data.sec.gov submissions URL", async () => {
+		const result = await handleSecEdgar("https://data.sec.gov/submissions/CIK0000320193.json", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("sec-edgar");
+		expect(result?.content).toContain("APPLE INC");
+	});
+
+	it("fetches via Archives path", async () => {
+		// Any filing URL with CIK in Archives path
+		const result = await handleSecEdgar(
+			"https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("sec-edgar");
+		expect(result?.content).toContain("APPLE INC");
+	});
+});
+
+describe.skipIf(SKIP)("handleOpenCorporates", () => {
+	it("returns null for non-matching URLs", async () => {
+		const result = await handleOpenCorporates("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for OpenCorporates URLs without company path", async () => {
+		const result = await handleOpenCorporates("https://opencorporates.com/about", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Apple Inc Delaware registration", async () => {
+		const result = await handleOpenCorporates("https://opencorporates.com/companies/us_de/2927442", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("opencorporates");
+		expect(result?.content).toContain("APPLE INC");
+		expect(result?.content).toContain("2927442");
+		expect(result?.content).toContain("US_DE");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches Microsoft Corporation", async () => {
+		// Microsoft is registered in Washington state
+		const result = await handleOpenCorporates("https://opencorporates.com/companies/us_wa/600413485", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("opencorporates");
+		expect(result?.content).toMatch(/microsoft/i);
+	});
+});

package/src/core/tools/web-fetch-handlers/cheatsh.ts

@@ -0,0 +1,73 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+/**
+ * Handle cheat.sh / cht.sh URLs for command cheatsheets
+ *
+ * API: Plain text at https://cheat.sh/{topic}?T (T flag removes ANSI colors)
+ * Supports: commands, language/topic queries (e.g., python/list, go/slice)
+ */
+export const handleCheatSh: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "cheat.sh" && parsed.hostname !== "cht.sh") return null;
+
+		// Extract topic from path (everything after /)
+		const topic = parsed.pathname.slice(1);
+		if (!topic || topic === "" || topic === "/") return null;
+
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from cheat.sh API with ?T to disable ANSI colors
+		const apiUrl = `https://cheat.sh/${encodeURIComponent(topic)}?T`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: {
+				Accept: "text/plain",
+			},
+		});
+
+		if (!result.ok || !result.content.trim()) return null;
+
+		// Format the cheatsheet as markdown
+		const decodedTopic = decodeURIComponent(topic);
+		let md = `# cheat.sh/${decodedTopic}\n\n`;
+
+		// The content is already plain text, wrap in code block for readability
+		// Detect if it looks like code/commands vs prose
+		const content = result.content.trim();
+		const lines = content.split("\n");
+		const hasCodeIndicators = lines.some(
+			(line) =>
+				line.startsWith("$") ||
+				line.startsWith("#") ||
+				line.includes("()") ||
+				line.includes("=>") ||
+				/^\s*(if|for|while|def|func|fn|let|const|var)\b/.test(line),
+		);
+
+		if (hasCodeIndicators || decodedTopic.includes("/")) {
+			// Likely code examples - use code block
+			// Try to detect language from topic
+			const lang = decodedTopic.split("/")[0] || "bash";
+			md += `\`\`\`${lang}\n${content}\n\`\`\`\n`;
+		} else {
+			// Command cheatsheet - format as-is (already has good structure)
+			md += `\`\`\`\n${content}\n\`\`\`\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "cheat.sh",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via cheat.sh"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/web-fetch-handlers/chocolatey.ts

@@ -0,0 +1,153 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface NuGetODataEntry {
+	Id: string;
+	Version: string;
+	Title?: string;
+	Description?: string;
+	Summary?: string;
+	Authors?: string;
+	ProjectUrl?: string;
+	PackageSourceUrl?: string;
+	Tags?: string;
+	DownloadCount?: number;
+	VersionDownloadCount?: number;
+	Published?: string;
+	LicenseUrl?: string;
+	ReleaseNotes?: string;
+	Dependencies?: string;
+}
+
+interface NuGetODataResponse {
+	d?: {
+		results?: NuGetODataEntry[];
+	};
+}
+
+/**
+ * Handle Chocolatey package URLs via NuGet v2 OData API
+ */
+export const handleChocolatey: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("chocolatey.org")) return null;
+
+		// Extract package name from /packages/{name} or /packages/{name}/{version}
+		const match = parsed.pathname.match(/^\/packages\/([^/]+)(?:\/([^/]+))?/);
+		if (!match) return null;
+
+		const packageName = decodeURIComponent(match[1]);
+		const specificVersion = match[2] ? decodeURIComponent(match[2]) : null;
+
+		const fetchedAt = new Date().toISOString();
+
+		// Build OData query - filter by Id and optionally version
+		let apiUrl = `https://community.chocolatey.org/api/v2/Packages()?$filter=Id%20eq%20'${encodeURIComponent(packageName)}'`;
+		if (specificVersion) {
+			apiUrl += `%20and%20Version%20eq%20'${encodeURIComponent(specificVersion)}'`;
+		} else {
+			// Get latest version by ordering and taking first
+			apiUrl += "&$orderby=Version%20desc&$top=1";
+		}
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: {
+				Accept: "application/json",
+			},
+		});
+
+		if (!result.ok) return null;
+
+		let data: NuGetODataResponse;
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const pkg = data.d?.results?.[0];
+		if (!pkg) return null;
+
+		// Build markdown output
+		let md = `# ${pkg.Title || pkg.Id}\n\n`;
+
+		if (pkg.Summary) {
+			md += `${pkg.Summary}\n\n`;
+		} else if (pkg.Description) {
+			// Use first paragraph of description as summary
+			const firstPara = pkg.Description.split(/\n\n/)[0];
+			md += `${firstPara}\n\n`;
+		}
+
+		md += `**Version:** ${pkg.Version}`;
+		if (pkg.Authors) md += ` · **Authors:** ${pkg.Authors}`;
+		md += "\n";
+
+		if (pkg.DownloadCount !== undefined) {
+			md += `**Total Downloads:** ${formatCount(pkg.DownloadCount)}`;
+			if (pkg.VersionDownloadCount !== undefined) {
+				md += ` · **Version Downloads:** ${formatCount(pkg.VersionDownloadCount)}`;
+			}
+			md += "\n";
+		}
+
+		if (pkg.Published) {
+			const date = new Date(pkg.Published);
+			md += `**Published:** ${date.toISOString().split("T")[0]}\n`;
+		}
+
+		md += "\n";
+
+		if (pkg.ProjectUrl) md += `**Project URL:** ${pkg.ProjectUrl}\n`;
+		if (pkg.PackageSourceUrl) md += `**Source:** ${pkg.PackageSourceUrl}\n`;
+		if (pkg.LicenseUrl) md += `**License:** ${pkg.LicenseUrl}\n`;
+
+		if (pkg.Tags) {
+			const tags = pkg.Tags.split(/\s+/).filter((t) => t.length > 0);
+			if (tags.length > 0) {
+				md += `**Tags:** ${tags.join(", ")}\n`;
+			}
+		}
+
+		// Full description if different from summary
+		if (pkg.Description && pkg.Description !== pkg.Summary) {
+			md += `\n## Description\n\n${pkg.Description}\n`;
+		}
+
+		if (pkg.ReleaseNotes) {
+			md += `\n## Release Notes\n\n${pkg.ReleaseNotes}\n`;
+		}
+
+		if (pkg.Dependencies) {
+			// Dependencies format: "id:version|id:version"
+			const deps = pkg.Dependencies.split("|").filter((d) => d.trim().length > 0);
+			if (deps.length > 0) {
+				md += `\n## Dependencies\n\n`;
+				for (const dep of deps) {
+					const [depId, depVersion] = dep.split(":");
+					if (depId) {
+						md += `- ${depId}${depVersion ? `: ${depVersion}` : ""}\n`;
+					}
+				}
+			}
+		}
+
+		md += `\n---\n**Install:** \`choco install ${packageName}\`\n`;
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "chocolatey",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Chocolatey NuGet API"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/web-fetch-handlers/coingecko.ts

@@ -0,0 +1,179 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface CoinGeckoResponse {
+	id: string;
+	symbol: string;
+	name: string;
+	description?: { en?: string };
+	links?: {
+		homepage?: string[];
+		blockchain_site?: string[];
+		repos_url?: { github?: string[] };
+	};
+	market_data?: {
+		current_price?: { usd?: number };
+		market_cap?: { usd?: number };
+		total_volume?: { usd?: number };
+		price_change_percentage_24h?: number;
+		ath?: { usd?: number };
+		ath_date?: { usd?: string };
+		circulating_supply?: number;
+		total_supply?: number;
+		max_supply?: number;
+	};
+	categories?: string[];
+	genesis_date?: string;
+}
+
+/**
+ * Handle CoinGecko cryptocurrency URLs via API
+ */
+export const handleCoinGecko: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("coingecko.com")) return null;
+
+		// Extract coin ID from /coins/{id} or /en/coins/{id}
+		const match = parsed.pathname.match(/^(?:\/[a-z]{2})?\/coins\/([^/?#]+)/);
+		if (!match) return null;
+
+		const coinId = decodeURIComponent(match[1]);
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from CoinGecko API
+		const apiUrl = `https://api.coingecko.com/api/v3/coins/${coinId}?localization=false&tickers=false&community_data=false&developer_data=false`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let coin: CoinGeckoResponse;
+		try {
+			coin = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const market = coin.market_data;
+
+		let md = `# ${coin.name} (${coin.symbol.toUpperCase()})\n\n`;
+
+		// Price and market data
+		if (market?.current_price?.usd !== undefined) {
+			md += `**Price:** $${formatPrice(market.current_price.usd)}`;
+			if (market.price_change_percentage_24h !== undefined) {
+				const change = market.price_change_percentage_24h;
+				const sign = change >= 0 ? "+" : "";
+				md += ` (${sign}${change.toFixed(2)}% 24h)`;
+			}
+			md += "\n";
+		}
+
+		if (market?.market_cap?.usd) {
+			md += `**Market Cap:** $${formatLargeNumber(market.market_cap.usd)}\n`;
+		}
+
+		if (market?.total_volume?.usd) {
+			md += `**24h Volume:** $${formatLargeNumber(market.total_volume.usd)}\n`;
+		}
+
+		if (market?.ath?.usd !== undefined) {
+			md += `**All-Time High:** $${formatPrice(market.ath.usd)}`;
+			if (market.ath_date?.usd) {
+				const athDate = new Date(market.ath_date.usd).toLocaleDateString("en-US", {
+					year: "numeric",
+					month: "short",
+					day: "numeric",
+				});
+				md += ` (${athDate})`;
+			}
+			md += "\n";
+		}
+
+		md += "\n";
+
+		// Supply info
+		if (market?.circulating_supply) {
+			md += `**Circulating Supply:** ${formatCount(Math.round(market.circulating_supply))}`;
+			if (market.max_supply) {
+				const percent = ((market.circulating_supply / market.max_supply) * 100).toFixed(1);
+				md += ` / ${formatCount(Math.round(market.max_supply))} (${percent}%)`;
+			} else if (market.total_supply) {
+				md += ` / ${formatCount(Math.round(market.total_supply))} total`;
+			}
+			md += "\n";
+		}
+
+		if (coin.genesis_date) {
+			md += `**Launch Date:** ${coin.genesis_date}\n`;
+		}
+
+		if (coin.categories?.length) {
+			md += `**Categories:** ${coin.categories.join(", ")}\n`;
+		}
+
+		// Links
+		const links: string[] = [];
+		if (coin.links?.homepage?.[0]) {
+			links.push(`[Website](${coin.links.homepage[0]})`);
+		}
+		if (coin.links?.blockchain_site?.[0]) {
+			links.push(`[Explorer](${coin.links.blockchain_site[0]})`);
+		}
+		if (coin.links?.repos_url?.github?.[0]) {
+			links.push(`[GitHub](${coin.links.repos_url.github[0]})`);
+		}
+		if (links.length) {
+			md += `**Links:** ${links.join(" · ")}\n`;
+		}
+
+		// Description
+		if (coin.description?.en) {
+			const desc = coin.description.en
+				.replace(/<[^>]+>/g, "") // Strip HTML
+				.replace(/\r\n/g, "\n")
+				.trim();
+			if (desc) {
+				md += `\n## About\n\n${desc}\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "coingecko",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via CoinGecko API"],
+		};
+	} catch {}
+
+	return null;
+};
+
+/**
+ * Format price with appropriate decimal places
+ */
+function formatPrice(price: number): string {
+	if (price >= 1000) return price.toLocaleString("en-US", { maximumFractionDigits: 2 });
+	if (price >= 1) return price.toFixed(2);
+	if (price >= 0.01) return price.toFixed(4);
+	if (price >= 0.0001) return price.toFixed(6);
+	return price.toFixed(8);
+}
+
+/**
+ * Format large numbers with B/M/K suffixes
+ */
+function formatLargeNumber(n: number): string {
+	if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(2)}B`;
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(2)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(2)}K`;
+	return n.toFixed(2);
+}