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

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

@@ -0,0 +1,313 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface OpenLibraryAuthor {
+	name?: string;
+	url?: string;
+}
+
+interface OpenLibrarySubject {
+	name: string;
+	url?: string;
+}
+
+interface OpenLibraryPublisher {
+	name: string;
+}
+
+interface OpenLibraryCover {
+	small?: string;
+	medium?: string;
+	large?: string;
+}
+
+interface OpenLibraryWork {
+	title: string;
+	authors?: Array<{ author: { key: string } }>;
+	description?: string | { value: string };
+	subjects?: string[];
+	subject_places?: string[];
+	subject_times?: string[];
+	covers?: number[];
+	first_publish_date?: string;
+}
+
+interface OpenLibraryEdition {
+	title: string;
+	authors?: Array<{ key: string }>;
+	publishers?: string[];
+	publish_date?: string;
+	number_of_pages?: number;
+	isbn_10?: string[];
+	isbn_13?: string[];
+	covers?: number[];
+	description?: string | { value: string };
+	subjects?: string[];
+	works?: Array<{ key: string }>;
+}
+
+interface OpenLibraryBooksApiResponse {
+	[key: string]: {
+		title: string;
+		authors?: OpenLibraryAuthor[];
+		publishers?: OpenLibraryPublisher[];
+		publish_date?: string;
+		number_of_pages?: number;
+		subjects?: OpenLibrarySubject[];
+		cover?: OpenLibraryCover;
+		url?: string;
+		identifiers?: {
+			isbn_10?: string[];
+			isbn_13?: string[];
+			openlibrary?: string[];
+		};
+	};
+}
+
+/**
+ * Handle Open Library URLs via their API
+ */
+export const handleOpenLibrary: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("openlibrary.org")) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const path = parsed.pathname;
+
+		// Match URL patterns
+		const workMatch = path.match(/^\/works\/(OL\d+W)/i);
+		const editionMatch = path.match(/^\/books\/(OL\d+M)/i);
+		const isbnMatch = path.match(/^\/isbn\/(\d{10}|\d{13})/i);
+
+		let md: string | null = null;
+
+		if (workMatch) {
+			md = await fetchWork(workMatch[1], timeout);
+		} else if (editionMatch) {
+			md = await fetchEdition(editionMatch[1], timeout);
+		} else if (isbnMatch) {
+			md = await fetchByIsbn(isbnMatch[1], timeout);
+		}
+
+		if (!md) return null;
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "openlibrary",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Open Library API"],
+		};
+	} catch {}
+
+	return null;
+};
+
+async function fetchWork(workId: string, timeout: number): Promise<string | null> {
+	const apiUrl = `https://openlibrary.org/works/${workId}.json`;
+	const result = await loadPage(apiUrl, { timeout });
+	if (!result.ok) return null;
+
+	let work: OpenLibraryWork;
+	try {
+		work = JSON.parse(result.content);
+	} catch {
+		return null;
+	}
+
+	let md = `# ${work.title}\n\n`;
+
+	// Fetch author names if we have author keys
+	if (work.authors?.length) {
+		const authorNames = await fetchAuthorNames(
+			work.authors.map((a) => a.author.key),
+			timeout,
+		);
+		if (authorNames.length) {
+			md += `**Authors:** ${authorNames.join(", ")}\n`;
+		}
+	}
+
+	if (work.first_publish_date) {
+		md += `**First Published:** ${work.first_publish_date}\n`;
+	}
+
+	if (work.covers?.length) {
+		const coverId = work.covers[0];
+		md += `**Cover:** https://covers.openlibrary.org/b/id/${coverId}-L.jpg\n`;
+	}
+
+	md += `**Open Library:** https://openlibrary.org/works/${workId}\n`;
+	md += "\n";
+
+	const description = extractDescription(work.description);
+	if (description) {
+		md += `## Description\n\n${description}\n\n`;
+	}
+
+	if (work.subjects?.length) {
+		md += `## Subjects\n\n${work.subjects.slice(0, 20).join(", ")}\n`;
+	}
+
+	return md;
+}
+
+async function fetchEdition(editionId: string, timeout: number): Promise<string | null> {
+	const apiUrl = `https://openlibrary.org/books/${editionId}.json`;
+	const result = await loadPage(apiUrl, { timeout });
+	if (!result.ok) return null;
+
+	let edition: OpenLibraryEdition;
+	try {
+		edition = JSON.parse(result.content);
+	} catch {
+		return null;
+	}
+
+	let md = `# ${edition.title}\n\n`;
+
+	// Fetch author names
+	if (edition.authors?.length) {
+		const authorNames = await fetchAuthorNames(
+			edition.authors.map((a) => a.key),
+			timeout,
+		);
+		if (authorNames.length) {
+			md += `**Authors:** ${authorNames.join(", ")}\n`;
+		}
+	}
+
+	if (edition.publishers?.length) {
+		md += `**Publishers:** ${edition.publishers.join(", ")}\n`;
+	}
+
+	if (edition.publish_date) {
+		md += `**Published:** ${edition.publish_date}\n`;
+	}
+
+	if (edition.number_of_pages) {
+		md += `**Pages:** ${edition.number_of_pages}\n`;
+	}
+
+	const isbns = [...(edition.isbn_13 || []), ...(edition.isbn_10 || [])];
+	if (isbns.length) {
+		md += `**ISBN:** ${isbns[0]}\n`;
+	}
+
+	if (edition.covers?.length) {
+		const coverId = edition.covers[0];
+		md += `**Cover:** https://covers.openlibrary.org/b/id/${coverId}-L.jpg\n`;
+	}
+
+	md += `**Open Library:** https://openlibrary.org/books/${editionId}\n`;
+
+	if (edition.works?.length) {
+		const workKey = edition.works[0].key.replace("/works/", "");
+		md += `**Work:** https://openlibrary.org/works/${workKey}\n`;
+	}
+
+	md += "\n";
+
+	const description = extractDescription(edition.description);
+	if (description) {
+		md += `## Description\n\n${description}\n\n`;
+	}
+
+	if (edition.subjects?.length) {
+		md += `## Subjects\n\n${edition.subjects.slice(0, 20).join(", ")}\n`;
+	}
+
+	return md;
+}
+
+async function fetchByIsbn(isbn: string, timeout: number): Promise<string | null> {
+	const apiUrl = `https://openlibrary.org/api/books?bibkeys=ISBN:${isbn}&format=json&jscmd=data`;
+	const result = await loadPage(apiUrl, { timeout });
+	if (!result.ok) return null;
+
+	let data: OpenLibraryBooksApiResponse;
+	try {
+		data = JSON.parse(result.content);
+	} catch {
+		return null;
+	}
+
+	const key = `ISBN:${isbn}`;
+	const book = data[key];
+	if (!book) return null;
+
+	let md = `# ${book.title}\n\n`;
+
+	if (book.authors?.length) {
+		md += `**Authors:** ${book.authors.map((a) => a.name).join(", ")}\n`;
+	}
+
+	if (book.publishers?.length) {
+		md += `**Publishers:** ${book.publishers.map((p) => p.name).join(", ")}\n`;
+	}
+
+	if (book.publish_date) {
+		md += `**Published:** ${book.publish_date}\n`;
+	}
+
+	if (book.number_of_pages) {
+		md += `**Pages:** ${book.number_of_pages}\n`;
+	}
+
+	md += `**ISBN:** ${isbn}\n`;
+
+	if (book.cover?.large || book.cover?.medium) {
+		md += `**Cover:** ${book.cover.large || book.cover.medium}\n`;
+	}
+
+	if (book.url) {
+		md += `**Open Library:** ${book.url}\n`;
+	}
+
+	md += "\n";
+
+	if (book.subjects?.length) {
+		md += `## Subjects\n\n${book.subjects
+			.slice(0, 20)
+			.map((s) => s.name)
+			.join(", ")}\n`;
+	}
+
+	return md;
+}
+
+async function fetchAuthorNames(authorKeys: string[], timeout: number): Promise<string[]> {
+	const names: string[] = [];
+
+	// Fetch authors in parallel (limit to first 5)
+	const promises = authorKeys.slice(0, 5).map(async (key) => {
+		const authorKey = key.startsWith("/authors/") ? key : `/authors/${key}`;
+		const apiUrl = `https://openlibrary.org${authorKey}.json`;
+		try {
+			const result = await loadPage(apiUrl, { timeout: Math.min(timeout, 5) });
+			if (result.ok) {
+				const author = JSON.parse(result.content) as { name?: string };
+				return author.name || null;
+			}
+		} catch {}
+		return null;
+	});
+
+	const results = await Promise.all(promises);
+	for (const name of results) {
+		if (name) names.push(name);
+	}
+
+	return names;
+}
+
+function extractDescription(desc: string | { value: string } | undefined): string | null {
+	if (!desc) return null;
+	if (typeof desc === "string") return desc;
+	return desc.value || null;
+}

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

@@ -0,0 +1,184 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface OsvSeverity {
+	type: string;
+	score: string;
+}
+
+interface OsvAffectedRange {
+	type: string;
+	events?: Array<{ introduced?: string; fixed?: string; last_affected?: string; limit?: string }>;
+}
+
+interface OsvAffected {
+	package?: {
+		ecosystem: string;
+		name: string;
+		purl?: string;
+	};
+	ranges?: OsvAffectedRange[];
+	versions?: string[];
+	severity?: OsvSeverity[];
+	database_specific?: Record<string, unknown>;
+	ecosystem_specific?: Record<string, unknown>;
+}
+
+interface OsvReference {
+	type: string;
+	url: string;
+}
+
+interface OsvVulnerability {
+	id: string;
+	summary?: string;
+	details?: string;
+	aliases?: string[];
+	modified?: string;
+	published?: string;
+	withdrawn?: string;
+	severity?: OsvSeverity[];
+	affected?: OsvAffected[];
+	references?: OsvReference[];
+	credits?: Array<{ name: string; contact?: string[]; type?: string }>;
+	database_specific?: Record<string, unknown>;
+}
+
+/**
+ * Handle OSV (Open Source Vulnerabilities) URLs
+ */
+export const handleOsv: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "osv.dev") return null;
+
+		// Extract vulnerability ID from /vulnerability/{id}
+		const match = parsed.pathname.match(/^\/vulnerability\/([A-Za-z0-9-]+)$/);
+		if (!match) return null;
+
+		const vulnId = match[1];
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from OSV API
+		const apiUrl = `https://api.osv.dev/v1/vulns/${vulnId}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let vuln: OsvVulnerability;
+		try {
+			vuln = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		let md = `# ${vuln.id}\n\n`;
+
+		// Summary
+		if (vuln.summary) {
+			md += `${vuln.summary}\n\n`;
+		}
+
+		// Metadata section
+		md += "## Metadata\n\n";
+		if (vuln.aliases?.length) {
+			md += `**Aliases:** ${vuln.aliases.join(", ")}\n`;
+		}
+		if (vuln.published) {
+			md += `**Published:** ${vuln.published.split("T")[0]}\n`;
+		}
+		if (vuln.modified) {
+			md += `**Modified:** ${vuln.modified.split("T")[0]}\n`;
+		}
+		if (vuln.withdrawn) {
+			md += `**Withdrawn:** ${vuln.withdrawn.split("T")[0]}\n`;
+		}
+
+		// Severity
+		const severities = vuln.severity || vuln.affected?.flatMap((a) => a.severity || []) || [];
+		if (severities.length) {
+			const formatted = severities.map((s) => `${s.type}: ${s.score}`).join(", ");
+			md += `**Severity:** ${formatted}\n`;
+		}
+		md += "\n";
+
+		// Details
+		if (vuln.details) {
+			md += `## Details\n\n${vuln.details}\n\n`;
+		}
+
+		// Affected packages
+		if (vuln.affected?.length) {
+			md += "## Affected Packages\n\n";
+			for (const affected of vuln.affected) {
+				const pkg = affected.package;
+				if (!pkg) continue;
+
+				md += `### ${pkg.ecosystem}: ${pkg.name}\n\n`;
+
+				// Version ranges
+				if (affected.ranges?.length) {
+					for (const range of affected.ranges) {
+						if (!range.events?.length) continue;
+						const parts: string[] = [];
+						for (const event of range.events) {
+							if (event.introduced) parts.push(`introduced: ${event.introduced}`);
+							if (event.fixed) parts.push(`fixed: ${event.fixed}`);
+							if (event.last_affected) parts.push(`last_affected: ${event.last_affected}`);
+							if (event.limit) parts.push(`limit: ${event.limit}`);
+						}
+						if (parts.length) {
+							md += `- **${range.type}:** ${parts.join(" → ")}\n`;
+						}
+					}
+				}
+
+				// Specific versions
+				if (affected.versions?.length) {
+					const versions =
+						affected.versions.length > 10
+							? `${affected.versions.slice(0, 10).join(", ")}... (${affected.versions.length} total)`
+							: affected.versions.join(", ");
+					md += `- **Versions:** ${versions}\n`;
+				}
+
+				md += "\n";
+			}
+		}
+
+		// References
+		if (vuln.references?.length) {
+			md += "## References\n\n";
+			for (const ref of vuln.references) {
+				md += `- [${ref.type}](${ref.url})\n`;
+			}
+			md += "\n";
+		}
+
+		// Credits
+		if (vuln.credits?.length) {
+			md += "## Credits\n\n";
+			for (const credit of vuln.credits) {
+				const type = credit.type ? ` (${credit.type})` : "";
+				md += `- ${credit.name}${type}\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "osv",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via OSV API"],
+		};
+	} catch {}
+
+	return null;
+};

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

@@ -0,0 +1,199 @@
+import { describe, expect, it } from "bun:test";
+import { handleChocolatey } from "./chocolatey";
+import { handleDockerHub } from "./dockerhub";
+import { handleHackage } from "./hackage";
+import { handleMetaCPAN } from "./metacpan";
+import { handleRepology } from "./repology";
+import { handleTerraform } from "./terraform";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleMetaCPAN", () => {
+	it("returns null for non-MetaCPAN URLs", async () => {
+		const result = await handleMetaCPAN("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-matching MetaCPAN paths", async () => {
+		const result = await handleMetaCPAN("https://metacpan.org/about", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Moose module", async () => {
+		const result = await handleMetaCPAN("https://metacpan.org/pod/Moose", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("metacpan");
+		expect(result?.content).toContain("Moose");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches release by distribution name", async () => {
+		const result = await handleMetaCPAN("https://metacpan.org/release/Moose", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("metacpan");
+		expect(result?.content).toContain("Moose");
+	});
+});
+
+describe.skipIf(SKIP)("handleHackage", () => {
+	it("returns null for non-Hackage URLs", async () => {
+		const result = await handleHackage("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-package Hackage paths", async () => {
+		const result = await handleHackage("https://hackage.haskell.org/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches aeson package", async () => {
+		const result = await handleHackage("https://hackage.haskell.org/package/aeson", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("hackage");
+		expect(result?.content).toContain("aeson");
+		expect(result?.content).toContain("JSON");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches text package", async () => {
+		const result = await handleHackage("https://hackage.haskell.org/package/text", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("hackage");
+		expect(result?.content).toContain("text");
+	});
+});
+
+describe.skipIf(SKIP)("handleDockerHub", () => {
+	it("returns null for non-DockerHub URLs", async () => {
+		const result = await handleDockerHub("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-matching DockerHub paths", async () => {
+		const result = await handleDockerHub("https://hub.docker.com/search", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches official nginx image", async () => {
+		const result = await handleDockerHub("https://hub.docker.com/_/nginx", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("dockerhub");
+		expect(result?.content).toContain("nginx");
+		expect(result?.content).toContain("docker pull");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches grafana/grafana image", async () => {
+		const result = await handleDockerHub("https://hub.docker.com/r/grafana/grafana", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("dockerhub");
+		expect(result?.content).toContain("grafana");
+		expect(result?.content).toContain("docker pull");
+	});
+});
+
+describe.skipIf(SKIP)("handleChocolatey", () => {
+	it("returns null for non-Chocolatey URLs", async () => {
+		const result = await handleChocolatey("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-package Chocolatey paths", async () => {
+		const result = await handleChocolatey("https://community.chocolatey.org/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches git package", async () => {
+		const result = await handleChocolatey("https://community.chocolatey.org/packages/git", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("chocolatey");
+		expect(result?.content).toContain("Git");
+		expect(result?.content).toContain("choco install");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches nodejs package", async () => {
+		const result = await handleChocolatey("https://community.chocolatey.org/packages/nodejs", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("chocolatey");
+		expect(result?.content).toContain("Node");
+	});
+});
+
+describe.skipIf(SKIP)("handleRepology", () => {
+	it("returns null for non-Repology URLs", async () => {
+		const result = await handleRepology("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-project Repology paths", async () => {
+		const result = await handleRepology("https://repology.org/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches firefox project", async () => {
+		const result = await handleRepology("https://repology.org/project/firefox", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("repology");
+		expect(result?.content).toContain("firefox");
+		expect(result?.content).toContain("Repositories");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches vim project", async () => {
+		const result = await handleRepology("https://repology.org/project/vim/versions", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("repology");
+		expect(result?.content).toContain("vim");
+	});
+});
+
+describe.skipIf(SKIP)("handleTerraform", () => {
+	it("returns null for non-Terraform URLs", async () => {
+		const result = await handleTerraform("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-matching Terraform paths", async () => {
+		const result = await handleTerraform("https://registry.terraform.io/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches hashicorp/aws provider", async () => {
+		const result = await handleTerraform("https://registry.terraform.io/providers/hashicorp/aws", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("terraform");
+		expect(result?.content).toContain("aws");
+		expect(result?.content).toContain("hashicorp");
+		expect(result?.content).toContain("required_providers");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches terraform-aws-modules/vpc/aws module", async () => {
+		const result = await handleTerraform("https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("terraform");
+		expect(result?.content).toContain("vpc");
+		expect(result?.content).toContain("terraform-aws-modules");
+		expect(result?.content).toContain("module");
+	});
+
+	it("fetches hashicorp/random provider", async () => {
+		const result = await handleTerraform("https://registry.terraform.io/providers/hashicorp/random", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("terraform");
+		expect(result?.content).toContain("random");
+	});
+});