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

package/src/core/tools/web-scrapers/orcid.ts

@@ -0,0 +1,299 @@
+/**
+ * ORCID handler for web-fetch
+ */
+
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+const MAX_WORKS = 50;
+const ORCID_PATTERN = /\/(\d{4}-\d{4}-\d{4}-\d{3}[\dXx])(?:\/|$)/;
+
+interface OrcidName {
+	"given-names"?: { value?: string };
+	"family-name"?: { value?: string };
+	"credit-name"?: { value?: string };
+}
+
+interface OrcidBiography {
+	content?: string;
+}
+
+interface OrcidPerson {
+	name?: OrcidName;
+	biography?: OrcidBiography;
+}
+
+interface OrcidSummaryDate {
+	year?: { value?: string };
+	month?: { value?: string };
+	day?: { value?: string };
+}
+
+interface OrcidOrganizationAddress {
+	city?: string;
+	region?: string;
+	country?: string;
+}
+
+interface OrcidOrganization {
+	name?: string;
+	address?: OrcidOrganizationAddress;
+}
+
+interface OrcidAffiliationSummary {
+	organization?: OrcidOrganization;
+	"role-title"?: string;
+	"department-name"?: string;
+	"start-date"?: OrcidSummaryDate;
+	"end-date"?: OrcidSummaryDate;
+}
+
+interface OrcidAffiliationGroupSummary {
+	"employment-summary"?: OrcidAffiliationSummary;
+	"education-summary"?: OrcidAffiliationSummary;
+}
+
+interface OrcidAffiliationGroup {
+	summaries?: OrcidAffiliationGroupSummary[];
+}
+
+interface OrcidAffiliationsContainer {
+	"affiliation-group"?: OrcidAffiliationGroup[];
+	"employment-summary"?: OrcidAffiliationSummary[];
+	"education-summary"?: OrcidAffiliationSummary[];
+}
+
+interface OrcidWorkTitle {
+	title?: { value?: string };
+}
+
+interface OrcidWorkSummary {
+	title?: OrcidWorkTitle;
+}
+
+interface OrcidWorkGroup {
+	"work-summary"?: OrcidWorkSummary[];
+}
+
+interface OrcidWorksContainer {
+	group?: OrcidWorkGroup[];
+}
+
+interface OrcidActivitiesSummary {
+	employments?: OrcidAffiliationsContainer;
+	educations?: OrcidAffiliationsContainer;
+	works?: OrcidWorksContainer;
+}
+
+interface OrcidRecord {
+	"orcid-identifier"?: { path?: string; uri?: string };
+	person?: OrcidPerson;
+	"activities-summary"?: OrcidActivitiesSummary;
+}
+
+function isOrcidHost(hostname: string): boolean {
+	return hostname === "orcid.org" || hostname === "www.orcid.org";
+}
+
+function extractOrcidId(pathname: string): string | null {
+	const match = pathname.match(ORCID_PATTERN);
+	return match?.[1] ?? null;
+}
+
+function formatName(name?: OrcidName): string | null {
+	const credit = name?.["credit-name"]?.value?.trim();
+	if (credit) return credit;
+
+	const given = name?.["given-names"]?.value?.trim();
+	const family = name?.["family-name"]?.value?.trim();
+	if (given && family) return `${given} ${family}`;
+	return given || family || null;
+}
+
+function formatDate(date?: OrcidSummaryDate): string | null {
+	const year = date?.year?.value;
+	if (!year) return null;
+
+	const month = date?.month?.value;
+	const day = date?.day?.value;
+	if (month && day) {
+		return `${year}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+	}
+	if (month) return `${year}-${month.padStart(2, "0")}`;
+	return year;
+}
+
+function collectAffiliations(
+	container: OrcidAffiliationsContainer | undefined,
+	key: "employment-summary" | "education-summary",
+): OrcidAffiliationSummary[] {
+	const summaries: OrcidAffiliationSummary[] = [];
+
+	if (!container) return summaries;
+
+	const direct = container[key];
+	if (direct?.length) summaries.push(...direct);
+
+	const groups = container["affiliation-group"];
+	if (groups?.length) {
+		for (const group of groups) {
+			const groupSummaries = group.summaries || [];
+			for (const summary of groupSummaries) {
+				const entry = summary[key];
+				if (entry) summaries.push(entry);
+			}
+		}
+	}
+
+	return summaries;
+}
+
+function formatAffiliation(summary: OrcidAffiliationSummary): string | null {
+	const organization = summary.organization?.name?.trim();
+	const role = summary["role-title"]?.trim();
+	const department = summary["department-name"]?.trim();
+
+	const address = summary.organization?.address;
+	const locationParts = [address?.city, address?.region, address?.country].filter(Boolean) as string[];
+	const location = locationParts.length > 0 ? locationParts.join(", ") : null;
+
+	const start = formatDate(summary["start-date"]);
+	const end = formatDate(summary["end-date"]);
+	let dates: string | null = null;
+	if (start && end) {
+		dates = `${start} - ${end}`;
+	} else if (start) {
+		dates = `${start} - Present`;
+	} else if (end) {
+		dates = `Until ${end}`;
+	}
+
+	const label = organization || role || department;
+	if (!label) return null;
+
+	const details: string[] = [];
+	if (organization && role) details.push(role);
+	if (!organization && role && department) details.push(department);
+	if (organization && department) details.push(`Dept: ${department}`);
+	if (location) details.push(`Location: ${location}`);
+	if (dates) details.push(`Dates: ${dates}`);
+
+	if (details.length === 0) return label;
+	return `${label} (${details.join("; ")})`;
+}
+
+function collectWorkTitles(container: OrcidWorksContainer | undefined): string[] {
+	const titles: string[] = [];
+	const seen = new Set<string>();
+	const groups = container?.group || [];
+
+	for (const group of groups) {
+		const summaries = group["work-summary"] || [];
+		for (const summary of summaries) {
+			const title = summary.title?.title?.value?.trim();
+			if (!title || seen.has(title)) continue;
+			seen.add(title);
+			titles.push(title);
+			if (titles.length >= MAX_WORKS) return titles;
+		}
+	}
+
+	return titles;
+}
+
+export const handleOrcid: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!isOrcidHost(parsed.hostname)) return null;
+
+		const orcid = extractOrcidId(parsed.pathname);
+		if (!orcid) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const apiUrl = `https://pub.orcid.org/v3.0/${orcid}/record`;
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+			signal,
+		});
+
+		if (!result.ok || !result.content) return null;
+
+		let record: OrcidRecord;
+		try {
+			record = JSON.parse(result.content) as OrcidRecord;
+		} catch {
+			return null;
+		}
+
+		const personName = formatName(record.person?.name);
+		const biography = record.person?.biography?.content?.trim();
+
+		const activities = record["activities-summary"];
+		const employments = collectAffiliations(activities?.employments, "employment-summary");
+		const educations = collectAffiliations(activities?.educations, "education-summary");
+		const works = collectWorkTitles(activities?.works);
+
+		let md = `# ${personName || "ORCID Profile"}\n\n`;
+		md += `**ORCID:** ${orcid}\n`;
+		md += `**ORCID Profile:** https://orcid.org/${orcid}\n\n`;
+
+		md += "## Biography\n\n";
+		md += biography ? `${biography}\n\n` : "No biography available.\n\n";
+
+		md += "## Affiliations\n\n";
+		let hasAffiliations = false;
+
+		if (employments.length > 0) {
+			hasAffiliations = true;
+			md += "### Employment\n\n";
+			for (const summary of employments) {
+				const line = formatAffiliation(summary);
+				if (line) md += `- ${line}\n`;
+			}
+			md += "\n";
+		}
+
+		if (educations.length > 0) {
+			hasAffiliations = true;
+			md += "### Education\n\n";
+			for (const summary of educations) {
+				const line = formatAffiliation(summary);
+				if (line) md += `- ${line}\n`;
+			}
+			md += "\n";
+		}
+
+		if (!hasAffiliations) {
+			md += "No affiliations available.\n\n";
+		}
+
+		md += "## Works\n\n";
+		if (works.length > 0) {
+			for (const title of works) {
+				md += `- ${title}\n`;
+			}
+		} else {
+			md += "No works available.\n";
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "orcid-api",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via ORCID Public API"],
+		};
+	} catch {
+		return null;
+	}
+};

package/src/core/tools/web-scrapers/osv.ts

@@ -0,0 +1,189 @@
+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,
+	signal?: AbortSignal,
+): 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" },
+			signal,
+		});
+
+		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-scrapers/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");
+	});
+});