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

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

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

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

@@ -0,0 +1,78 @@
+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,
+	signal?: AbortSignal,
+): 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,
+			signal,
+			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-scrapers/chocolatey.ts

@@ -0,0 +1,158 @@
+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,
+	signal?: AbortSignal,
+): 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,
+			signal,
+			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-scrapers/choosealicense.ts

@@ -0,0 +1,110 @@
+import { parseFrontmatter } from "../../../discovery/helpers";
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+const ALLOWED_HOSTS = new Set(["choosealicense.com", "www.choosealicense.com"]);
+const LICENSE_PATH = /^\/licenses\/([^/]+)\/?$/i;
+const APPENDIX_PATH = /^\/appendix\/?$/i;
+
+function asString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function normalizeList(value: unknown): string[] {
+	if (Array.isArray(value)) {
+		return value
+			.filter((item): item is string => typeof item === "string")
+			.map((item) => item.trim())
+			.filter((item) => item.length > 0);
+	}
+	if (typeof value === "string") {
+		return value
+			.split(",")
+			.map((item) => item.trim())
+			.filter((item) => item.length > 0);
+	}
+	return [];
+}
+
+function formatLabel(value: string): string {
+	const cleaned = value.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim();
+	if (!cleaned) return value;
+	return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+
+function formatSection(title: string, items: string[]): string {
+	let md = `## ${title}\n\n`;
+	if (items.length === 0) {
+		md += "- None listed\n\n";
+		return md;
+	}
+	for (const item of items) {
+		md += `- ${formatLabel(item)}\n`;
+	}
+	md += "\n";
+	return md;
+}
+
+export const handleChooseALicense: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!ALLOWED_HOSTS.has(parsed.hostname)) return null;
+
+		const licenseMatch = parsed.pathname.match(LICENSE_PATH);
+		const isAppendix = APPENDIX_PATH.test(parsed.pathname);
+		if (!licenseMatch && !isAppendix) return null;
+
+		const licenseSlug = licenseMatch ? decodeURIComponent(licenseMatch[1]).toLowerCase() : "appendix";
+		const rawUrl = licenseMatch
+			? `https://raw.githubusercontent.com/github/choosealicense.com/gh-pages/_licenses/${licenseSlug}.txt`
+			: "https://raw.githubusercontent.com/github/choosealicense.com/gh-pages/_pages/appendix.md";
+
+		const fetchedAt = new Date().toISOString();
+		const result = await loadPage(rawUrl, { timeout, headers: { Accept: "text/plain" }, signal });
+		if (!result.ok) return null;
+
+		const { frontmatter, body } = parseFrontmatter(result.content);
+
+		const title = asString(frontmatter.title) ?? formatLabel(licenseSlug);
+		const spdxId = asString(frontmatter["spdx-id"]) ?? "Unknown";
+		const description = asString(frontmatter.description);
+		const permissions = normalizeList(frontmatter.permissions);
+		const conditions = normalizeList(frontmatter.conditions);
+		const limitations = normalizeList(frontmatter.limitations);
+
+		let md = `# ${title}\n\n`;
+		if (description) md += `${description}\n\n`;
+
+		md += `**SPDX ID:** ${spdxId}\n`;
+		md += `**Source:** https://choosealicense.com${isAppendix ? "/appendix" : `/licenses/${licenseSlug}/`}\n\n`;
+
+		md += formatSection("Permissions", permissions);
+		md += formatSection("Conditions", conditions);
+		md += formatSection("Limitations", limitations);
+
+		const licenseText = body.trim();
+		if (licenseText.length > 0) {
+			md += `---\n\n## License Text\n\n${licenseText}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "choosealicense",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Choose a License"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/web-scrapers/cisa-kev.ts

@@ -0,0 +1,100 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface KevEntry {
+	cveID: string;
+	vendorProject?: string;
+	product?: string;
+	vulnerabilityName?: string;
+	shortDescription?: string;
+	requiredAction?: string;
+	dateAdded?: string;
+	dueDate?: string;
+}
+
+interface KevCatalog {
+	title?: string;
+	catalogVersion?: string;
+	dateReleased?: string;
+	count?: number;
+	vulnerabilities?: KevEntry[];
+}
+
+const CVE_PATTERN = /CVE-\d{4}-\d{4,7}/i;
+const KEV_FEED_URL = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json";
+
+/**
+ * Handle CISA Known Exploited Vulnerabilities (KEV) URLs
+ */
+export const handleCisaKev: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.toLowerCase();
+		if (!hostname.endsWith("cisa.gov")) return null;
+
+		const path = parsed.pathname.toLowerCase();
+		if (!path.includes("known-exploited-vulnerabilities")) return null;
+
+		const cveMatch = parsed.pathname.match(CVE_PATTERN) ?? parsed.search.match(CVE_PATTERN);
+		if (!cveMatch) return null;
+
+		const cveId = cveMatch[0].toUpperCase();
+		const fetchedAt = new Date().toISOString();
+
+		const result = await loadPage(KEV_FEED_URL, {
+			timeout,
+			headers: { Accept: "application/json" },
+			signal,
+		});
+
+		if (!result.ok) return null;
+
+		let data: KevCatalog;
+		try {
+			data = JSON.parse(result.content) as KevCatalog;
+		} catch {
+			return null;
+		}
+
+		const entry = data.vulnerabilities?.find((item) => item.cveID?.toUpperCase() === cveId);
+		if (!entry) return null;
+
+		let md = `# ${entry.cveID}\n\n`;
+		if (entry.vulnerabilityName) {
+			md += `${entry.vulnerabilityName}\n\n`;
+		}
+
+		md += "## Metadata\n\n";
+		if (entry.vendorProject) md += `**Vendor:** ${entry.vendorProject}\n`;
+		if (entry.product) md += `**Product:** ${entry.product}\n`;
+		if (entry.dateAdded) md += `**Date Added:** ${entry.dateAdded}\n`;
+		if (entry.dueDate) md += `**Due Date:** ${entry.dueDate}\n`;
+		md += "\n";
+
+		if (entry.shortDescription) {
+			md += `## Description\n\n${entry.shortDescription}\n\n`;
+		}
+
+		if (entry.requiredAction) {
+			md += `## Required Action\n\n${entry.requiredAction}\n\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "cisa-kev",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via CISA KEV feed"],
+		};
+	} catch {}
+
+	return null;
+};