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

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

@@ -0,0 +1,201 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface NuGetCatalogEntry {
+	id: string;
+	version: string;
+	description?: string;
+	authors?: string;
+	projectUrl?: string;
+	licenseUrl?: string;
+	licenseExpression?: string;
+	tags?: string[];
+	dependencyGroups?: Array<{
+		targetFramework?: string;
+		dependencies?: Array<{
+			id: string;
+			range: string;
+		}>;
+	}>;
+	published?: string;
+}
+
+interface NuGetRegistrationItem {
+	catalogEntry: NuGetCatalogEntry;
+	packageContent?: string;
+}
+
+interface NuGetRegistrationPage {
+	items?: NuGetRegistrationItem[];
+	"@id"?: string;
+}
+
+interface NuGetRegistrationIndex {
+	items: NuGetRegistrationPage[];
+}
+
+/**
+ * Handle NuGet URLs via API
+ */
+export const handleNuGet: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "www.nuget.org" && parsed.hostname !== "nuget.org") return null;
+
+		// Extract package name and optional version from /packages/name or /packages/name/version
+		const match = parsed.pathname.match(/^\/packages\/([^/]+)(?:\/([^/]+))?/i);
+		if (!match) return null;
+
+		const packageName = decodeURIComponent(match[1]);
+		const requestedVersion = match[2] ? decodeURIComponent(match[2]) : null;
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from NuGet registration API (package name must be lowercase)
+		const apiUrl = `https://api.nuget.org/v3/registration5-gz-semver2/${packageName.toLowerCase()}/index.json`;
+		const result = await loadPage(apiUrl, { timeout });
+
+		if (!result.ok) return null;
+
+		let index: NuGetRegistrationIndex;
+		try {
+			index = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		if (!index.items?.length) return null;
+
+		// Get the latest page (or fetch it if not inlined)
+		let latestPage = index.items[index.items.length - 1];
+
+		// If items are not inlined, fetch the page
+		if (!latestPage.items && latestPage["@id"]) {
+			const pageResult = await loadPage(latestPage["@id"], { timeout });
+			if (!pageResult.ok) return null;
+			try {
+				latestPage = JSON.parse(pageResult.content);
+			} catch {
+				return null;
+			}
+		}
+
+		if (!latestPage.items?.length) return null;
+
+		// Find the requested version or get the latest
+		let targetEntry: NuGetCatalogEntry | null = null;
+
+		if (requestedVersion) {
+			// Search all pages for the requested version
+			for (const page of index.items) {
+				let pageItems = page.items;
+
+				// Fetch page if items not inlined
+				if (!pageItems && page["@id"]) {
+					const pageResult = await loadPage(page["@id"], { timeout: Math.min(timeout, 5) });
+					if (pageResult.ok) {
+						try {
+							const fetchedPage = JSON.parse(pageResult.content) as NuGetRegistrationPage;
+							pageItems = fetchedPage.items;
+						} catch {}
+					}
+				}
+
+				if (pageItems) {
+					const found = pageItems.find(
+						(item) => item.catalogEntry.version.toLowerCase() === requestedVersion.toLowerCase(),
+					);
+					if (found) {
+						targetEntry = found.catalogEntry;
+						break;
+					}
+				}
+			}
+		}
+
+		// If no specific version requested or not found, use the latest
+		if (!targetEntry) {
+			const latestItem = latestPage.items[latestPage.items.length - 1];
+			targetEntry = latestItem.catalogEntry;
+		}
+
+		// Fetch download stats via search API
+		let totalDownloads: number | null = null;
+		const searchUrl = `https://api.nuget.org/v3/query?q=packageid:${encodeURIComponent(packageName)}&prerelease=true&take=1`;
+		const searchResult = await loadPage(searchUrl, { timeout: Math.min(timeout, 5) });
+
+		if (searchResult.ok) {
+			try {
+				const searchData = JSON.parse(searchResult.content) as {
+					data?: Array<{ totalDownloads?: number }>;
+				};
+				totalDownloads = searchData.data?.[0]?.totalDownloads ?? null;
+			} catch {}
+		}
+
+		// Format markdown output
+		let md = `# ${targetEntry.id}\n\n`;
+		if (targetEntry.description) md += `${targetEntry.description}\n\n`;
+
+		md += `**Version:** ${targetEntry.version}`;
+		if (targetEntry.licenseExpression) {
+			md += ` · **License:** ${targetEntry.licenseExpression}`;
+		} else if (targetEntry.licenseUrl) {
+			md += ` · **License:** [View](${targetEntry.licenseUrl})`;
+		}
+		md += "\n";
+
+		if (totalDownloads !== null) {
+			md += `**Total Downloads:** ${formatCount(totalDownloads)}\n`;
+		}
+
+		if (targetEntry.authors) md += `**Authors:** ${targetEntry.authors}\n`;
+		if (targetEntry.projectUrl) md += `**Project URL:** ${targetEntry.projectUrl}\n`;
+		if (targetEntry.tags?.length) md += `**Tags:** ${targetEntry.tags.join(", ")}\n`;
+		if (targetEntry.published) {
+			const pubDate = targetEntry.published.split("T")[0];
+			md += `**Published:** ${pubDate}\n`;
+		}
+
+		// Show dependencies by target framework
+		if (targetEntry.dependencyGroups?.length) {
+			const hasAnyDeps = targetEntry.dependencyGroups.some((g) => g.dependencies?.length);
+			if (hasAnyDeps) {
+				md += `\n## Dependencies\n\n`;
+				for (const group of targetEntry.dependencyGroups) {
+					if (!group.dependencies?.length) continue;
+					const framework = group.targetFramework || "All Frameworks";
+					md += `### ${framework}\n\n`;
+					for (const dep of group.dependencies) {
+						md += `- ${dep.id} (${dep.range})\n`;
+					}
+					md += "\n";
+				}
+			}
+		}
+
+		// Show recent versions from the latest page
+		if (latestPage.items && latestPage.items.length > 1) {
+			md += `## Recent Versions\n\n`;
+			const recentVersions = latestPage.items.slice(-5).reverse();
+			for (const item of recentVersions) {
+				const entry = item.catalogEntry;
+				const pubDate = entry.published?.split("T")[0] || "unknown";
+				md += `- **${entry.version}** (${pubDate})\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "nuget",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via NuGet API"],
+		};
+	} catch {}
+
+	return null;
+};

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

@@ -0,0 +1,238 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface CvssV31 {
+	baseScore: number;
+	baseSeverity: string;
+	vectorString: string;
+}
+
+interface CvssV2 {
+	baseScore: number;
+	severity?: string;
+	vectorString: string;
+}
+
+interface CvssMetric {
+	cvssData: CvssV31 | CvssV2;
+	exploitabilityScore?: number;
+	impactScore?: number;
+}
+
+interface CpeMatch {
+	criteria: string;
+	vulnerable: boolean;
+	versionStartIncluding?: string;
+	versionEndExcluding?: string;
+	versionEndIncluding?: string;
+}
+
+interface Configuration {
+	nodes?: Array<{
+		operator?: string;
+		cpeMatch?: CpeMatch[];
+	}>;
+}
+
+interface Reference {
+	url: string;
+	source?: string;
+	tags?: string[];
+}
+
+interface Description {
+	lang: string;
+	value: string;
+}
+
+interface Weakness {
+	description: Description[];
+}
+
+interface CveItem {
+	id: string;
+	sourceIdentifier?: string;
+	published: string;
+	lastModified: string;
+	vulnStatus?: string;
+	descriptions: Description[];
+	metrics?: {
+		cvssMetricV31?: CvssMetric[];
+		cvssMetricV30?: CvssMetric[];
+		cvssMetricV2?: CvssMetric[];
+	};
+	weaknesses?: Weakness[];
+	configurations?: Configuration[];
+	references?: Reference[];
+}
+
+interface NvdResponse {
+	vulnerabilities?: Array<{ cve: CveItem }>;
+}
+
+/**
+ * Handle NVD (National Vulnerability Database) CVE URLs
+ */
+export const handleNvd: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("nvd.nist.gov")) return null;
+
+		// Extract CVE ID from /vuln/detail/{CVE-ID}
+		const match = parsed.pathname.match(/\/vuln\/detail\/(CVE-\d{4}-\d+)/i);
+		if (!match) return null;
+
+		const cveId = match[1].toUpperCase();
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from NVD API
+		const apiUrl = `https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=${cveId}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let data: NvdResponse;
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const vuln = data.vulnerabilities?.[0]?.cve;
+		if (!vuln) return null;
+
+		let md = `# ${vuln.id}\n\n`;
+
+		// Status and dates
+		if (vuln.vulnStatus) {
+			md += `**Status:** ${vuln.vulnStatus}\n`;
+		}
+		md += `**Published:** ${formatDate(vuln.published)}`;
+		md += ` · **Modified:** ${formatDate(vuln.lastModified)}\n\n`;
+
+		// Description
+		const desc = vuln.descriptions.find((d) => d.lang === "en")?.value;
+		if (desc) {
+			md += `## Description\n\n${desc}\n\n`;
+		}
+
+		// CVSS Scores
+		const cvss31 = vuln.metrics?.cvssMetricV31?.[0];
+		const cvss30 = vuln.metrics?.cvssMetricV30?.[0];
+		const cvss2 = vuln.metrics?.cvssMetricV2?.[0];
+
+		if (cvss31 || cvss30 || cvss2) {
+			md += `## CVSS Scores\n\n`;
+
+			if (cvss31) {
+				const data = cvss31.cvssData as CvssV31;
+				md += `### CVSS 3.1\n\n`;
+				md += `- **Base Score:** ${data.baseScore} (${data.baseSeverity})\n`;
+				md += `- **Vector:** \`${data.vectorString}\`\n`;
+				if (cvss31.exploitabilityScore !== undefined) {
+					md += `- **Exploitability:** ${cvss31.exploitabilityScore}\n`;
+				}
+				if (cvss31.impactScore !== undefined) {
+					md += `- **Impact:** ${cvss31.impactScore}\n`;
+				}
+				md += "\n";
+			}
+
+			if (cvss30 && !cvss31) {
+				const data = cvss30.cvssData as CvssV31;
+				md += `### CVSS 3.0\n\n`;
+				md += `- **Base Score:** ${data.baseScore} (${data.baseSeverity})\n`;
+				md += `- **Vector:** \`${data.vectorString}\`\n`;
+				md += "\n";
+			}
+
+			if (cvss2) {
+				const data = cvss2.cvssData as CvssV2;
+				md += `### CVSS 2.0\n\n`;
+				md += `- **Base Score:** ${data.baseScore}`;
+				if (data.severity) md += ` (${data.severity})`;
+				md += `\n- **Vector:** \`${data.vectorString}\`\n\n`;
+			}
+		}
+
+		// Weaknesses (CWE)
+		const cwes = vuln.weaknesses
+			?.flatMap((w) => w.description)
+			.filter((d) => d.lang === "en" && d.value !== "NVD-CWE-Other" && d.value !== "NVD-CWE-noinfo");
+
+		if (cwes?.length) {
+			md += `## Weaknesses\n\n`;
+			for (const cwe of cwes) {
+				md += `- ${cwe.value}\n`;
+			}
+			md += "\n";
+		}
+
+		// Affected Products (CPE)
+		const cpes = extractCpes(vuln.configurations);
+		if (cpes.length > 0) {
+			md += `## Affected Products\n\n`;
+			const shown = cpes.slice(0, 20);
+			for (const cpe of shown) {
+				md += `- \`${cpe}\`\n`;
+			}
+			if (cpes.length > 20) {
+				md += `\n*...and ${cpes.length - 20} more*\n`;
+			}
+			md += "\n";
+		}
+
+		// References
+		if (vuln.references?.length) {
+			md += `## References\n\n`;
+			for (const ref of vuln.references.slice(0, 15)) {
+				const tags = ref.tags?.length ? ` (${ref.tags.join(", ")})` : "";
+				md += `- ${ref.url}${tags}\n`;
+			}
+			if (vuln.references.length > 15) {
+				md += `\n*...and ${vuln.references.length - 15} more references*\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "nvd",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via NVD API"],
+		};
+	} catch {}
+
+	return null;
+};
+
+function formatDate(iso: string): string {
+	try {
+		return new Date(iso).toISOString().split("T")[0];
+	} catch {
+		return iso;
+	}
+}
+
+function extractCpes(configurations?: Configuration[]): string[] {
+	if (!configurations) return [];
+
+	const cpes: string[] = [];
+	for (const config of configurations) {
+		for (const node of config.nodes ?? []) {
+			for (const match of node.cpeMatch ?? []) {
+				if (match.vulnerable && match.criteria) {
+					cpes.push(match.criteria);
+				}
+			}
+		}
+	}
+	return Array.from(new Set(cpes));
+}

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

@@ -0,0 +1,273 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface Officer {
+	id: number;
+	name: string;
+	position?: string;
+	start_date?: string;
+	end_date?: string;
+	occupation?: string;
+	nationality?: string;
+	inactive?: boolean;
+}
+
+interface Address {
+	street_address?: string;
+	locality?: string;
+	region?: string;
+	postal_code?: string;
+	country?: string;
+}
+
+interface CompanyData {
+	name: string;
+	company_number: string;
+	jurisdiction_code: string;
+	incorporation_date?: string;
+	dissolution_date?: string;
+	company_type?: string;
+	registry_url?: string;
+	branch?: string;
+	branch_status?: string;
+	inactive?: boolean;
+	current_status?: string;
+	created_at?: string;
+	updated_at?: string;
+	retrieved_at?: string;
+	opencorporates_url?: string;
+	source?: {
+		publisher?: string;
+		url?: string;
+		retrieved_at?: string;
+	};
+	registered_address?: Address;
+	registered_address_in_full?: string;
+	industry_codes?: Array<{
+		code: string;
+		description?: string;
+		code_scheme_name?: string;
+	}>;
+	identifiers?: Array<{
+		identifier_system_code: string;
+		identifier_system_name?: string;
+		identifier_uid: string;
+	}>;
+	previous_names?: Array<{
+		company_name: string;
+		con_date?: string;
+	}>;
+	alternative_names?: Array<{
+		company_name: string;
+		type?: string;
+	}>;
+	officers?: Array<{ officer: Officer }>;
+	agent_name?: string;
+	agent_address?: string;
+	number_of_employees?: string;
+	native_company_number?: string;
+}
+
+interface ApiResponse {
+	api_version: string;
+	results: {
+		company: CompanyData;
+	};
+}
+
+/**
+ * Handle OpenCorporates URLs via API
+ */
+export const handleOpenCorporates: SpecialHandler = async (
+	url: string,
+	timeout: number,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("opencorporates.com")) return null;
+
+		// Extract jurisdiction and company number from /companies/{jurisdiction}/{number}
+		const match = parsed.pathname.match(/^\/companies\/([^/]+)\/([^/]+)/);
+		if (!match) return null;
+
+		const jurisdiction = decodeURIComponent(match[1]);
+		const companyNumber = decodeURIComponent(match[2]);
+
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from OpenCorporates API
+		const apiUrl = `https://api.opencorporates.com/v0.4/companies/${jurisdiction}/${companyNumber}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let data: ApiResponse;
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const company = data.results?.company;
+		if (!company) return null;
+
+		let md = `# ${company.name}\n\n`;
+
+		// Basic info table
+		md += "| Field | Value |\n|-------|-------|\n";
+		md += `| **Company Number** | ${company.company_number} |\n`;
+		md += `| **Jurisdiction** | ${company.jurisdiction_code.toUpperCase()} |\n`;
+		if (company.current_status) {
+			md += `| **Status** | ${company.current_status} |\n`;
+		}
+		if (company.company_type) {
+			md += `| **Company Type** | ${company.company_type} |\n`;
+		}
+		if (company.incorporation_date) {
+			md += `| **Incorporated** | ${company.incorporation_date} |\n`;
+		}
+		if (company.dissolution_date) {
+			md += `| **Dissolved** | ${company.dissolution_date} |\n`;
+		}
+		if (company.branch) {
+			md += `| **Branch** | ${company.branch}${company.branch_status ? ` (${company.branch_status})` : ""} |\n`;
+		}
+		if (company.native_company_number && company.native_company_number !== company.company_number) {
+			md += `| **Native Number** | ${company.native_company_number} |\n`;
+		}
+		md += "\n";
+
+		// Registered address
+		if (company.registered_address_in_full) {
+			md += `## Registered Address\n\n${company.registered_address_in_full}\n\n`;
+		} else if (company.registered_address) {
+			const addr = company.registered_address;
+			const parts = [addr.street_address, addr.locality, addr.region, addr.postal_code, addr.country].filter(
+				Boolean,
+			);
+			if (parts.length > 0) {
+				md += `## Registered Address\n\n${parts.join(", ")}\n\n`;
+			}
+		}
+
+		// Agent info
+		if (company.agent_name) {
+			md += `## Registered Agent\n\n**${company.agent_name}**`;
+			if (company.agent_address) {
+				md += `\n${company.agent_address}`;
+			}
+			md += "\n\n";
+		}
+
+		// Officers/Directors
+		if (company.officers && company.officers.length > 0) {
+			const activeOfficers = company.officers.filter((o) => !o.officer.inactive && !o.officer.end_date);
+			const inactiveOfficers = company.officers.filter((o) => o.officer.inactive || o.officer.end_date);
+
+			if (activeOfficers.length > 0) {
+				md += `## Current Officers (${activeOfficers.length})\n\n`;
+				for (const { officer } of activeOfficers) {
+					md += `- **${officer.name}**`;
+					if (officer.position) md += ` - ${officer.position}`;
+					if (officer.start_date) md += ` (since ${officer.start_date})`;
+					if (officer.occupation) md += ` [${officer.occupation}]`;
+					if (officer.nationality) md += ` (${officer.nationality})`;
+					md += "\n";
+				}
+				md += "\n";
+			}
+
+			if (inactiveOfficers.length > 0) {
+				md += `## Former Officers (${inactiveOfficers.length})\n\n`;
+				for (const { officer } of inactiveOfficers.slice(0, 10)) {
+					md += `- **${officer.name}**`;
+					if (officer.position) md += ` - ${officer.position}`;
+					if (officer.start_date && officer.end_date) {
+						md += ` (${officer.start_date} to ${officer.end_date})`;
+					} else if (officer.end_date) {
+						md += ` (until ${officer.end_date})`;
+					}
+					md += "\n";
+				}
+				if (inactiveOfficers.length > 10) {
+					md += `\n*...and ${inactiveOfficers.length - 10} more former officers*\n`;
+				}
+				md += "\n";
+			}
+		}
+
+		// Industry codes
+		if (company.industry_codes && company.industry_codes.length > 0) {
+			md += `## Industry Codes\n\n`;
+			for (const ic of company.industry_codes) {
+				md += `- **${ic.code}**`;
+				if (ic.description) md += `: ${ic.description}`;
+				if (ic.code_scheme_name) md += ` (${ic.code_scheme_name})`;
+				md += "\n";
+			}
+			md += "\n";
+		}
+
+		// Identifiers
+		if (company.identifiers && company.identifiers.length > 0) {
+			md += `## Identifiers\n\n`;
+			for (const id of company.identifiers) {
+				md += `- **${id.identifier_system_name || id.identifier_system_code}**: ${id.identifier_uid}\n`;
+			}
+			md += "\n";
+		}
+
+		// Previous names
+		if (company.previous_names && company.previous_names.length > 0) {
+			md += `## Previous Names\n\n`;
+			for (const pn of company.previous_names) {
+				md += `- ${pn.company_name}`;
+				if (pn.con_date) md += ` (until ${pn.con_date})`;
+				md += "\n";
+			}
+			md += "\n";
+		}
+
+		// Alternative names
+		if (company.alternative_names && company.alternative_names.length > 0) {
+			md += `## Alternative Names\n\n`;
+			for (const an of company.alternative_names) {
+				md += `- ${an.company_name}`;
+				if (an.type) md += ` (${an.type})`;
+				md += "\n";
+			}
+			md += "\n";
+		}
+
+		// Source info
+		md += "---\n\n";
+		if (company.source?.publisher) {
+			md += `**Source:** ${company.source.publisher}`;
+			if (company.source.url) md += ` ([registry](${company.source.url}))`;
+			md += "\n";
+		}
+		if (company.registry_url) {
+			md += `**Official Registry:** ${company.registry_url}\n`;
+		}
+		if (company.retrieved_at) {
+			md += `**Data Retrieved:** ${company.retrieved_at}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: company.opencorporates_url || url,
+			contentType: "text/markdown",
+			method: "opencorporates",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via OpenCorporates API"],
+		};
+	} catch {}
+
+	return null;
+};