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

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

@@ -0,0 +1,136 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface BiorxivPaper {
+	biorxiv_doi?: string;
+	medrxiv_doi?: string;
+	title?: string;
+	authors?: string;
+	author_corresponding?: string;
+	author_corresponding_institution?: string;
+	abstract?: string;
+	date?: string;
+	category?: string;
+	version?: string;
+	type?: string;
+	license?: string;
+	jatsxml?: string;
+	published?: string; // Journal DOI if published
+	server?: string;
+}
+
+interface BiorxivResponse {
+	collection?: BiorxivPaper[];
+	messages?: { status: string; count: number }[];
+}
+
+/**
+ * Handle bioRxiv and medRxiv preprint URLs via their API
+ */
+export const handleBiorxiv: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.toLowerCase();
+
+		// Check if it's bioRxiv or medRxiv
+		const isBiorxiv = hostname === "www.biorxiv.org" || hostname === "biorxiv.org";
+		const isMedrxiv = hostname === "www.medrxiv.org" || hostname === "medrxiv.org";
+
+		if (!isBiorxiv && !isMedrxiv) return null;
+
+		// Extract DOI from URL path: /content/10.1101/2024.01.01.123456
+		const match = parsed.pathname.match(/\/content\/(10\.\d{4,}\/[^\s?#]+)/);
+		if (!match) return null;
+
+		let doi = match[1];
+		// Remove version suffix if present (e.g., v1, v2)
+		doi = doi.replace(/v\d+$/, "");
+		// Remove trailing .full or .full.pdf
+		doi = doi.replace(/\.full(\.pdf)?$/, "");
+
+		const server = isBiorxiv ? "biorxiv" : "medrxiv";
+		const apiUrl = `https://api.${server}.org/details/${server}/${doi}/na/json`;
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let data: BiorxivResponse;
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		if (!data.collection || data.collection.length === 0) return null;
+
+		// Get the latest version (last in array)
+		const paper = data.collection[data.collection.length - 1];
+		if (!paper) return null;
+
+		const serverName = isBiorxiv ? "bioRxiv" : "medRxiv";
+		const paperDoi = paper.biorxiv_doi || paper.medrxiv_doi || doi;
+
+		// Build markdown output
+		let md = `# ${paper.title || "Untitled Preprint"}\n\n`;
+
+		// Metadata section
+		if (paper.authors) {
+			md += `**Authors:** ${paper.authors}\n`;
+		}
+		if (paper.author_corresponding) {
+			let correspondingLine = `**Corresponding Author:** ${paper.author_corresponding}`;
+			if (paper.author_corresponding_institution) {
+				correspondingLine += ` (${paper.author_corresponding_institution})`;
+			}
+			md += `${correspondingLine}\n`;
+		}
+		if (paper.date) {
+			md += `**Posted:** ${paper.date}\n`;
+		}
+		if (paper.category) {
+			md += `**Category:** ${paper.category}\n`;
+		}
+		if (paper.version) {
+			md += `**Version:** ${paper.version}\n`;
+		}
+		if (paper.license) {
+			md += `**License:** ${paper.license}\n`;
+		}
+		md += `**DOI:** [${paperDoi}](https://doi.org/${paperDoi})\n`;
+		md += `**Server:** ${serverName}\n`;
+
+		// Published status
+		if (paper.published) {
+			md += `\n> **Published in journal:** [${paper.published}](https://doi.org/${paper.published})\n`;
+		}
+
+		// Abstract
+		md += `\n---\n\n## Abstract\n\n${paper.abstract || "No abstract available."}\n`;
+
+		// Links section
+		md += `\n---\n\n## Links\n\n`;
+		md += `- [View on ${serverName}](https://www.${server}.org/content/${paperDoi})\n`;
+		md += `- [PDF](https://www.${server}.org/content/${paperDoi}.full.pdf)\n`;
+		if (paper.jatsxml) {
+			md += `- [JATS XML](${paper.jatsxml})\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: server,
+			content: output.content,
+			fetchedAt: new Date().toISOString(),
+			truncated: output.truncated,
+			notes: [`Fetched via ${serverName} API`],
+		};
+	} catch {}
+
+	return null;
+};

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

@@ -0,0 +1,277 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+const API_BASE = "https://public.api.bsky.app/xrpc";
+
+interface BlueskyProfile {
+	did: string;
+	handle: string;
+	displayName?: string;
+	description?: string;
+	avatar?: string;
+	followersCount?: number;
+	followsCount?: number;
+	postsCount?: number;
+	createdAt?: string;
+}
+
+interface BlueskyPost {
+	uri: string;
+	cid: string;
+	author: BlueskyProfile;
+	record: {
+		text: string;
+		createdAt: string;
+		embed?: {
+			$type: string;
+			external?: { uri: string; title?: string; description?: string };
+			images?: Array<{ alt?: string; image: unknown }>;
+			record?: { uri: string };
+		};
+		facets?: Array<{
+			features: Array<{ $type: string; uri?: string; tag?: string; did?: string }>;
+			index: { byteStart: number; byteEnd: number };
+		}>;
+	};
+	likeCount?: number;
+	repostCount?: number;
+	replyCount?: number;
+	quoteCount?: number;
+	embed?: {
+		$type: string;
+		external?: { uri: string; title?: string; description?: string };
+		images?: Array<{ alt?: string; fullsize?: string; thumb?: string }>;
+		record?: { uri: string; value?: { text?: string }; author?: BlueskyProfile };
+	};
+}
+
+interface ThreadViewPost {
+	post: BlueskyPost;
+	parent?: ThreadViewPost | { $type: string };
+	replies?: Array<ThreadViewPost | { $type: string }>;
+}
+
+/**
+ * Resolve a handle to DID using the profile API
+ */
+async function resolveHandle(handle: string, timeout: number): Promise<string | null> {
+	const url = `${API_BASE}/app.bsky.actor.getProfile?actor=${encodeURIComponent(handle)}`;
+	const result = await loadPage(url, {
+		timeout,
+		headers: { Accept: "application/json" },
+	});
+
+	if (!result.ok) return null;
+
+	try {
+		const data = JSON.parse(result.content) as BlueskyProfile;
+		return data.did;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Format a post as markdown
+ */
+function formatPost(post: BlueskyPost, isQuote = false): string {
+	const author = post.author;
+	const name = author.displayName || author.handle;
+	const handle = `@${author.handle}`;
+	const date = new Date(post.record.createdAt).toLocaleString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+
+	let md = "";
+
+	if (isQuote) {
+		md += `> **${name}** (${handle}) - ${date}\n>\n`;
+		md += post.record.text
+			.split("\n")
+			.map((line) => `> ${line}`)
+			.join("\n");
+		md += "\n";
+	} else {
+		md += `**${name}** (${handle})\n`;
+		md += `*${date}*\n\n`;
+		md += `${post.record.text}\n`;
+	}
+
+	// Handle embeds
+	const embed = post.embed;
+	if (embed) {
+		if (embed.$type === "app.bsky.embed.external#view" && embed.external) {
+			const ext = embed.external;
+			md += `\n📎 [${ext.title || ext.uri}](${ext.uri})`;
+			if (ext.description) md += `\n*${ext.description}*`;
+			md += "\n";
+		} else if (embed.$type === "app.bsky.embed.images#view" && embed.images) {
+			md += `\n🖼️ ${embed.images.length} image(s)`;
+			for (const img of embed.images) {
+				if (img.alt) md += `\n- Alt: "${img.alt}"`;
+			}
+			md += "\n";
+		} else if (
+			(embed.$type === "app.bsky.embed.record#view" || embed.$type === "app.bsky.embed.recordWithMedia#view") &&
+			embed.record
+		) {
+			const rec = embed.record;
+			if (rec.value?.text && rec.author) {
+				md += "\n**Quoted post:**\n";
+				md += `> **${rec.author.displayName || rec.author.handle}** (@${rec.author.handle})\n`;
+				md += rec.value.text
+					.split("\n")
+					.map((line) => `> ${line}`)
+					.join("\n");
+				md += "\n";
+			}
+		}
+	}
+
+	// Stats
+	if (!isQuote) {
+		const stats: string[] = [];
+		if (post.likeCount) stats.push(`❤️ ${formatCount(post.likeCount)}`);
+		if (post.repostCount) stats.push(`🔁 ${formatCount(post.repostCount)}`);
+		if (post.replyCount) stats.push(`💬 ${formatCount(post.replyCount)}`);
+		if (post.quoteCount) stats.push(`📝 ${formatCount(post.quoteCount)}`);
+		if (stats.length) md += `\n${stats.join(" • ")}\n`;
+	}
+
+	return md;
+}
+
+/**
+ * Handle Bluesky post URLs
+ */
+export const handleBluesky: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!["bsky.app", "www.bsky.app"].includes(parsed.hostname)) {
+			return null;
+		}
+
+		const fetchedAt = new Date().toISOString();
+		const pathParts = parsed.pathname.split("/").filter(Boolean);
+
+		// /profile/{handle}
+		if (pathParts[0] === "profile" && pathParts[1]) {
+			const handle = pathParts[1];
+
+			// /profile/{handle}/post/{rkey}
+			if (pathParts[2] === "post" && pathParts[3]) {
+				const rkey = pathParts[3];
+
+				// First resolve handle to DID
+				const did = await resolveHandle(handle, timeout);
+				if (!did) return null;
+
+				// Construct AT URI and fetch thread
+				const atUri = `at://${did}/app.bsky.feed.post/${rkey}`;
+				const threadUrl = `${API_BASE}/app.bsky.feed.getPostThread?uri=${encodeURIComponent(atUri)}&depth=6&parentHeight=3`;
+
+				const result = await loadPage(threadUrl, {
+					timeout,
+					headers: { Accept: "application/json" },
+				});
+
+				if (!result.ok) return null;
+
+				const data = JSON.parse(result.content) as { thread: ThreadViewPost };
+				const thread = data.thread;
+
+				if (!thread.post) return null;
+
+				let md = `# Bluesky Post\n\n`;
+
+				// Show parent context if exists
+				if (thread.parent && "post" in thread.parent) {
+					md += "**Replying to:**\n";
+					md += formatPost(thread.parent.post, true);
+					md += "\n---\n\n";
+				}
+
+				// Main post
+				md += formatPost(thread.post);
+
+				// Show replies
+				if (thread.replies?.length) {
+					md += "\n---\n\n## Replies\n\n";
+					let replyCount = 0;
+					for (const reply of thread.replies) {
+						if (replyCount >= 10) break;
+						if ("post" in reply) {
+							md += formatPost(reply.post);
+							md += "\n---\n\n";
+							replyCount++;
+						}
+					}
+				}
+
+				const output = finalizeOutput(md);
+				return {
+					url,
+					finalUrl: url,
+					contentType: "text/markdown",
+					method: "bluesky-api",
+					content: output.content,
+					fetchedAt,
+					truncated: output.truncated,
+					notes: [`AT URI: ${atUri}`],
+				};
+			}
+
+			// Profile only
+			const profileUrl = `${API_BASE}/app.bsky.actor.getProfile?actor=${encodeURIComponent(handle)}`;
+			const result = await loadPage(profileUrl, {
+				timeout,
+				headers: { Accept: "application/json" },
+			});
+
+			if (!result.ok) return null;
+
+			const profile = JSON.parse(result.content) as BlueskyProfile;
+
+			let md = `# ${profile.displayName || profile.handle}\n\n`;
+			md += `**@${profile.handle}**\n\n`;
+
+			if (profile.description) {
+				md += `${profile.description}\n\n`;
+			}
+
+			md += "---\n\n";
+			md += `- **Followers:** ${formatCount(profile.followersCount || 0)}\n`;
+			md += `- **Following:** ${formatCount(profile.followsCount || 0)}\n`;
+			md += `- **Posts:** ${formatCount(profile.postsCount || 0)}\n`;
+
+			if (profile.createdAt) {
+				const joined = new Date(profile.createdAt).toLocaleDateString("en-US", {
+					year: "numeric",
+					month: "long",
+					day: "numeric",
+				});
+				md += `- **Joined:** ${joined}\n`;
+			}
+
+			md += `\n**DID:** \`${profile.did}\`\n`;
+
+			const output = finalizeOutput(md);
+			return {
+				url,
+				finalUrl: url,
+				contentType: "text/markdown",
+				method: "bluesky-api",
+				content: output.content,
+				fetchedAt,
+				truncated: output.truncated,
+				notes: ["Fetched via AT Protocol API"],
+			};
+		}
+	} catch {}
+
+	return null;
+};

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