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

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);
+}

package/src/core/tools/web-fetch-handlers/crates-io.ts

@@ -0,0 +1,123 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+/**
+ * Check if content looks like HTML
+ */
+function looksLikeHtml(content: string): boolean {
+	const trimmed = content.trim().toLowerCase();
+	return (
+		trimmed.startsWith("<!doctype") ||
+		trimmed.startsWith("<html") ||
+		trimmed.startsWith("<head") ||
+		trimmed.startsWith("<body")
+	);
+}
+
+/**
+ * Handle crates.io URLs via API
+ */
+export const handleCratesIo: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "crates.io" && parsed.hostname !== "www.crates.io") return null;
+
+		// Extract crate name from /crates/name or /crates/name/version
+		const match = parsed.pathname.match(/^\/crates\/([^/]+)/);
+		if (!match) return null;
+
+		const crateName = decodeURIComponent(match[1]);
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from crates.io API
+		const apiUrl = `https://crates.io/api/v1/crates/${crateName}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { "User-Agent": "omp-web-fetch/1.0 (https://github.com/anthropics)" },
+		});
+
+		if (!result.ok) return null;
+
+		let data: {
+			crate: {
+				name: string;
+				description: string | null;
+				downloads: number;
+				recent_downloads: number;
+				max_version: string;
+				repository: string | null;
+				homepage: string | null;
+				documentation: string | null;
+				categories: string[];
+				keywords: string[];
+				created_at: string;
+				updated_at: string;
+			};
+			versions: Array<{
+				num: string;
+				downloads: number;
+				created_at: string;
+				license: string | null;
+				rust_version: string | null;
+			}>;
+		};
+
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const crate = data.crate;
+		const latestVersion = data.versions?.[0];
+
+		// Format download counts
+		const formatDownloads = (n: number): string =>
+			n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : n >= 1_000 ? `${(n / 1_000).toFixed(1)}K` : String(n);
+
+		let md = `# ${crate.name}\n\n`;
+		if (crate.description) md += `${crate.description}\n\n`;
+
+		md += `**Latest:** ${crate.max_version}`;
+		if (latestVersion?.license) md += ` · **License:** ${latestVersion.license}`;
+		if (latestVersion?.rust_version) md += ` · **MSRV:** ${latestVersion.rust_version}`;
+		md += "\n";
+		md += `**Downloads:** ${formatDownloads(crate.downloads)} total · ${formatDownloads(crate.recent_downloads)} recent\n\n`;
+
+		if (crate.repository) md += `**Repository:** ${crate.repository}\n`;
+		if (crate.homepage && crate.homepage !== crate.repository) md += `**Homepage:** ${crate.homepage}\n`;
+		if (crate.documentation) md += `**Docs:** ${crate.documentation}\n`;
+		if (crate.keywords?.length) md += `**Keywords:** ${crate.keywords.join(", ")}\n`;
+		if (crate.categories?.length) md += `**Categories:** ${crate.categories.join(", ")}\n`;
+
+		// Show recent versions
+		if (data.versions?.length > 0) {
+			md += `\n## Recent Versions\n\n`;
+			for (const ver of data.versions.slice(0, 5)) {
+				const date = ver.created_at.split("T")[0];
+				md += `- **${ver.num}** (${date}) - ${formatDownloads(ver.downloads)} downloads\n`;
+			}
+		}
+
+		// Try to fetch README from docs.rs or repository
+		const docsRsUrl = `https://docs.rs/crate/${crateName}/${crate.max_version}/source/README.md`;
+		const readmeResult = await loadPage(docsRsUrl, { timeout: Math.min(timeout, 5) });
+		if (readmeResult.ok && readmeResult.content.length > 100 && !looksLikeHtml(readmeResult.content)) {
+			md += `\n---\n\n## README\n\n${readmeResult.content}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "crates.io",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via crates.io API"],
+		};
+	} catch {}
+
+	return null;
+};