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

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

@@ -0,0 +1,303 @@
+/**
+ * Discogs URL handler for music releases and masters
+ *
+ * Uses the Discogs API to extract structured metadata about releases.
+ * API docs: https://www.discogs.com/developers
+ */
+
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface DiscogsArtist {
+	name: string;
+	anv?: string; // artist name variation
+	role?: string;
+	join?: string;
+}
+
+interface DiscogsTrack {
+	position: string;
+	title: string;
+	duration?: string;
+	artists?: DiscogsArtist[];
+	extraartists?: DiscogsArtist[];
+}
+
+interface DiscogsLabel {
+	name: string;
+	catno?: string; // catalog number
+}
+
+interface DiscogsFormat {
+	name: string;
+	qty?: string;
+	descriptions?: string[];
+}
+
+interface DiscogsRelease {
+	id: number;
+	title: string;
+	artists?: DiscogsArtist[];
+	year?: number;
+	released?: string;
+	country?: string;
+	genres?: string[];
+	styles?: string[];
+	labels?: DiscogsLabel[];
+	formats?: DiscogsFormat[];
+	tracklist?: DiscogsTrack[];
+	extraartists?: DiscogsArtist[];
+	notes?: string;
+	uri?: string;
+	master_id?: number;
+	master_url?: string;
+}
+
+interface DiscogsMaster {
+	id: number;
+	title: string;
+	artists?: DiscogsArtist[];
+	year?: number;
+	genres?: string[];
+	styles?: string[];
+	tracklist?: DiscogsTrack[];
+	notes?: string;
+	uri?: string;
+	main_release?: number;
+	main_release_url?: string;
+	versions_url?: string;
+	num_for_sale?: number;
+	lowest_price?: number;
+}
+
+/**
+ * Format artist names, handling name variations
+ */
+function formatArtists(artists: DiscogsArtist[] | undefined): string {
+	if (!artists?.length) return "Unknown Artist";
+	return artists
+		.map((a) => {
+			const name = a.anv || a.name;
+			const join = a.join || ", ";
+			return name + (a.join ? ` ${join} ` : "");
+		})
+		.join("")
+		.replace(/[,&]\s*$/, "")
+		.trim();
+}
+
+/**
+ * Format a single track
+ */
+function formatTrack(track: DiscogsTrack): string {
+	let line = track.position ? `${track.position}. ` : "- ";
+	line += track.title;
+	if (track.duration) line += ` (${track.duration})`;
+	if (track.artists?.length) {
+		line += ` - ${formatArtists(track.artists)}`;
+	}
+	return line;
+}
+
+/**
+ * Format credits/extraartists grouped by role
+ */
+function formatCredits(extraartists: DiscogsArtist[] | undefined): string {
+	if (!extraartists?.length) return "";
+
+	const byRole: Record<string, string[]> = {};
+	for (const artist of extraartists) {
+		const role = artist.role || "Other";
+		if (!byRole[role]) byRole[role] = [];
+		byRole[role].push(artist.anv || artist.name);
+	}
+
+	const lines: string[] = [];
+	for (const [role, names] of Object.entries(byRole)) {
+		lines.push(`- **${role}**: ${names.join(", ")}`);
+	}
+	return lines.join("\n");
+}
+
+/**
+ * Format formats (e.g., "2×LP, Album, Reissue")
+ */
+function formatFormats(formats: DiscogsFormat[] | undefined): string {
+	if (!formats?.length) return "";
+
+	return formats
+		.map((f) => {
+			const parts: string[] = [];
+			if (f.qty && parseInt(f.qty, 10) > 1) parts.push(`${f.qty}×`);
+			parts.push(f.name);
+			if (f.descriptions?.length) parts.push(f.descriptions.join(", "));
+			return parts.join(" ");
+		})
+		.join(" + ");
+}
+
+/**
+ * Format labels with catalog numbers
+ */
+function formatLabels(labels: DiscogsLabel[] | undefined): string {
+	if (!labels?.length) return "";
+	return labels
+		.map((l) => {
+			if (l.catno && l.catno !== "none") return `${l.name} (${l.catno})`;
+			return l.name;
+		})
+		.join(", ");
+}
+
+/**
+ * Build markdown for a release
+ */
+function buildReleaseMarkdown(release: DiscogsRelease): string {
+	const sections: string[] = [];
+
+	// Title with artist
+	const artist = formatArtists(release.artists);
+	sections.push(`# ${artist} - ${release.title}\n`);
+
+	// Metadata
+	const meta: string[] = [];
+	if (release.year) meta.push(`**Year**: ${release.year}`);
+	if (release.country) meta.push(`**Country**: ${release.country}`);
+
+	const format = formatFormats(release.formats);
+	if (format) meta.push(`**Format**: ${format}`);
+
+	const labels = formatLabels(release.labels);
+	if (labels) meta.push(`**Label**: ${labels}`);
+
+	if (release.genres?.length) meta.push(`**Genre**: ${release.genres.join(", ")}`);
+	if (release.styles?.length) meta.push(`**Style**: ${release.styles.join(", ")}`);
+
+	if (release.master_id) {
+		meta.push(`**Master Release**: [${release.master_id}](https://www.discogs.com/master/${release.master_id})`);
+	}
+
+	if (meta.length) sections.push(`${meta.join("\n")}\n`);
+
+	// Tracklist
+	if (release.tracklist?.length) {
+		sections.push("## Tracklist\n");
+		const tracks = release.tracklist.map(formatTrack);
+		sections.push(`${tracks.join("\n")}\n`);
+	}
+
+	// Credits
+	const credits = formatCredits(release.extraartists);
+	if (credits) {
+		sections.push("## Credits\n");
+		sections.push(`${credits}\n`);
+	}
+
+	// Notes
+	if (release.notes) {
+		sections.push("## Notes\n");
+		sections.push(`${release.notes}\n`);
+	}
+
+	return sections.join("\n");
+}
+
+/**
+ * Build markdown for a master release
+ */
+function buildMasterMarkdown(master: DiscogsMaster): string {
+	const sections: string[] = [];
+
+	// Title with artist
+	const artist = formatArtists(master.artists);
+	sections.push(`# ${artist} - ${master.title}\n`);
+	sections.push("*Master Release*\n");
+
+	// Metadata
+	const meta: string[] = [];
+	if (master.year) meta.push(`**Year**: ${master.year}`);
+	if (master.genres?.length) meta.push(`**Genre**: ${master.genres.join(", ")}`);
+	if (master.styles?.length) meta.push(`**Style**: ${master.styles.join(", ")}`);
+
+	if (master.main_release) {
+		meta.push(`**Main Release**: [${master.main_release}](https://www.discogs.com/release/${master.main_release})`);
+	}
+
+	if (master.num_for_sale !== undefined && master.num_for_sale > 0) {
+		meta.push(`**For Sale**: ${master.num_for_sale} copies`);
+		if (master.lowest_price !== undefined) {
+			meta.push(`**Lowest Price**: $${master.lowest_price.toFixed(2)}`);
+		}
+	}
+
+	if (meta.length) sections.push(`${meta.join("\n")}\n`);
+
+	// Tracklist
+	if (master.tracklist?.length) {
+		sections.push("## Tracklist\n");
+		const tracks = master.tracklist.map(formatTrack);
+		sections.push(`${tracks.join("\n")}\n`);
+	}
+
+	// Notes
+	if (master.notes) {
+		sections.push("## Notes\n");
+		sections.push(`${master.notes}\n`);
+	}
+
+	return sections.join("\n");
+}
+
+export const handleDiscogs: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("discogs.com")) return null;
+
+		// Match release or master URLs
+		// Patterns: /release/{id}, /master/{id}
+		// Also handles: /release/{id}-Artist-Title, /master/{id}-Artist-Title
+		const releaseMatch = parsed.pathname.match(/\/release\/(\d+)/);
+		const masterMatch = parsed.pathname.match(/\/master\/(\d+)/);
+
+		if (!releaseMatch && !masterMatch) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const isRelease = !!releaseMatch;
+		const id = isRelease ? releaseMatch[1] : masterMatch![1];
+
+		const apiUrl = isRelease ? `https://api.discogs.com/releases/${id}` : `https://api.discogs.com/masters/${id}`;
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: {
+				Accept: "application/json",
+				"User-Agent": "CodingAgent/1.0 +https://github.com/can1357/oh-my-pi",
+			},
+		});
+
+		if (!result.ok) return null;
+
+		let md: string;
+		if (isRelease) {
+			const release = JSON.parse(result.content) as DiscogsRelease;
+			md = buildReleaseMarkdown(release);
+		} else {
+			const master = JSON.parse(result.content) as DiscogsMaster;
+			md = buildMasterMarkdown(master);
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "discogs",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: [`Fetched via Discogs API (${isRelease ? "release" : "master"})`],
+		};
+	} catch {}
+
+	return null;
+};

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

@@ -0,0 +1,156 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface DockerHubRepo {
+	name: string;
+	namespace: string;
+	description?: string;
+	star_count?: number;
+	pull_count?: number;
+	last_updated?: string;
+	is_official?: boolean;
+	is_automated?: boolean;
+	user?: string;
+}
+
+interface DockerHubTag {
+	name: string;
+	last_updated?: string;
+	full_size?: number;
+	digest?: string;
+	images?: Array<{
+		architecture?: string;
+		os?: string;
+		size?: number;
+	}>;
+}
+
+interface DockerHubTagsResponse {
+	results?: DockerHubTag[];
+}
+
+function formatSize(bytes: number): string {
+	if (bytes >= 1_000_000_000) return `${(bytes / 1_000_000_000).toFixed(1)}GB`;
+	if (bytes >= 1_000_000) return `${(bytes / 1_000_000).toFixed(1)}MB`;
+	if (bytes >= 1_000) return `${(bytes / 1_000).toFixed(1)}KB`;
+	return `${bytes}B`;
+}
+
+/**
+ * Handle Docker Hub URLs via API
+ */
+export const handleDockerHub: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("hub.docker.com")) return null;
+
+		let namespace: string;
+		let repository: string;
+
+		// Official images: /_ /{image}
+		const officialMatch = parsed.pathname.match(/^\/_\/([^/]+)/);
+		if (officialMatch) {
+			namespace = "library";
+			repository = officialMatch[1];
+		} else {
+			// Regular images: /r/{namespace}/{repository}
+			const repoMatch = parsed.pathname.match(/^\/r\/([^/]+)\/([^/]+)/);
+			if (!repoMatch) return null;
+			namespace = repoMatch[1];
+			repository = repoMatch[2];
+		}
+
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch repository info and tags in parallel
+		const repoUrl = `https://hub.docker.com/v2/repositories/${namespace}/${repository}/`;
+		const tagsUrl = `https://hub.docker.com/v2/repositories/${namespace}/${repository}/tags/?page_size=10`;
+
+		const [repoResult, tagsResult] = await Promise.all([
+			loadPage(repoUrl, { timeout, headers: { Accept: "application/json" } }),
+			loadPage(tagsUrl, { timeout: Math.min(timeout, 10), headers: { Accept: "application/json" } }),
+		]);
+
+		if (!repoResult.ok) return null;
+
+		let repo: DockerHubRepo;
+		try {
+			repo = JSON.parse(repoResult.content);
+		} catch {
+			return null;
+		}
+
+		// Parse tags
+		let tags: DockerHubTag[] = [];
+		if (tagsResult.ok) {
+			try {
+				const tagsData = JSON.parse(tagsResult.content) as DockerHubTagsResponse;
+				tags = tagsData.results ?? [];
+			} catch {}
+		}
+
+		// Build markdown output
+		const fullName = namespace === "library" ? repo.name : `${namespace}/${repo.name}`;
+		let md = `# ${fullName}\n\n`;
+
+		if (repo.description) {
+			md += `${repo.description}\n\n`;
+		}
+
+		// Stats line
+		const stats: string[] = [];
+		if (repo.pull_count !== undefined) stats.push(`**Pulls:** ${formatCount(repo.pull_count)}`);
+		if (repo.star_count !== undefined) stats.push(`**Stars:** ${formatCount(repo.star_count)}`);
+		if (repo.is_official) stats.push("**Official Image**");
+		if (repo.is_automated) stats.push("**Automated Build**");
+		if (stats.length > 0) {
+			md += `${stats.join(" · ")}\n`;
+		}
+
+		if (repo.last_updated) {
+			const date = new Date(repo.last_updated);
+			md += `**Last Updated:** ${date.toISOString().split("T")[0]}\n`;
+		}
+
+		md += "\n";
+
+		// Docker pull command
+		md += "## Quick Start\n\n";
+		md += "```bash\n";
+		md += `docker pull ${fullName}\n`;
+		md += "```\n\n";
+
+		// Tags
+		if (tags.length > 0) {
+			md += "## Recent Tags\n\n";
+			md += "| Tag | Size | Architectures | Updated |\n";
+			md += "|-----|------|---------------|--------|\n";
+
+			for (const tag of tags) {
+				const size = tag.full_size ? formatSize(tag.full_size) : "-";
+				const archs =
+					tag.images
+						?.map((img) => img.architecture)
+						.filter(Boolean)
+						.join(", ") || "-";
+				const updated = tag.last_updated ? new Date(tag.last_updated).toISOString().split("T")[0] : "-";
+				md += `| \`${tag.name}\` | ${size} | ${archs} | ${updated} |\n`;
+			}
+			md += "\n";
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "dockerhub",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Docker Hub API"],
+		};
+	} catch {}
+
+	return null;
+};

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "bun:test";
+import { handleMDN } from "./mdn";
+import { handleReadTheDocs } from "./readthedocs";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleMDN", () => {
+	it("returns null for non-MDN URLs", async () => {
+		const result = await handleMDN("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for non-docs MDN URLs", async () => {
+		const result = await handleMDN("https://developer.mozilla.org/en-US/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for MDN blog URLs", async () => {
+		const result = await handleMDN("https://developer.mozilla.org/en-US/blog/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Array.map documentation", async () => {
+		const result = await handleMDN(
+			"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("mdn");
+		expect(result?.content).toContain("map");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+	});
+
+	it("fetches Promise documentation", async () => {
+		const result = await handleMDN(
+			"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("mdn");
+		expect(result?.content).toContain("Promise");
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches CSS documentation", async () => {
+		const result = await handleMDN("https://developer.mozilla.org/en-US/docs/Web/CSS/display", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("mdn");
+		expect(result?.content).toContain("display");
+	});
+});
+
+describe.skipIf(SKIP)("handleReadTheDocs", () => {
+	it("returns null for non-RTD URLs", async () => {
+		const result = await handleReadTheDocs("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for github.com URLs", async () => {
+		const result = await handleReadTheDocs("https://github.com/user/repo", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches requests docs", async () => {
+		const result = await handleReadTheDocs("https://requests.readthedocs.io/en/latest/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("readthedocs");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("returns null for non-readthedocs sites", async () => {
+		// These sites use Sphinx/RTD theme but aren't hosted on readthedocs.io
+		expect(await handleReadTheDocs("https://www.sphinx-doc.org/en/master/", 20)).toBeNull();
+		expect(await handleReadTheDocs("https://docs.pytest.org/en/stable/", 20)).toBeNull();
+		expect(await handleReadTheDocs("https://pip.pypa.io/en/stable/", 20)).toBeNull();
+	});
+
+	it("handles readthedocs.io subdomain", async () => {
+		const result = await handleReadTheDocs("https://flask.palletsprojects.readthedocs.io/en/latest/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("readthedocs");
+	});
+});

package/src/core/tools/web-fetch-handlers/finance-media.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from "bun:test";
+import { handleArtifactHub } from "./artifacthub";
+import { handleCoinGecko } from "./coingecko";
+import { handleDiscogs } from "./discogs";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleCoinGecko", () => {
+	it("returns null for non-CoinGecko URLs", async () => {
+		const result = await handleCoinGecko("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for CoinGecko homepage", async () => {
+		const result = await handleCoinGecko("https://www.coingecko.com/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for CoinGecko categories page", async () => {
+		const result = await handleCoinGecko("https://www.coingecko.com/en/categories", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Bitcoin data", async () => {
+		const result = await handleCoinGecko("https://www.coingecko.com/en/coins/bitcoin", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("coingecko");
+		expect(result?.content).toContain("Bitcoin");
+		expect(result?.content).toContain("BTC");
+		expect(result?.content).toContain("Price");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches Ethereum data", async () => {
+		const result = await handleCoinGecko("https://www.coingecko.com/en/coins/ethereum", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("coingecko");
+		expect(result?.content).toContain("Ethereum");
+		expect(result?.content).toContain("ETH");
+		expect(result?.content).toContain("Market Cap");
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("handles URL without locale prefix", async () => {
+		const result = await handleCoinGecko("https://www.coingecko.com/coins/bitcoin", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("coingecko");
+	});
+});
+
+describe.skipIf(SKIP)("handleDiscogs", () => {
+	it("returns null for non-Discogs URLs", async () => {
+		const result = await handleDiscogs("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for Discogs homepage", async () => {
+		const result = await handleDiscogs("https://www.discogs.com/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for Discogs search page", async () => {
+		const result = await handleDiscogs("https://www.discogs.com/search/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches Daft Punk Discovery release", async () => {
+		// Release 249504: Daft Punk - Discovery
+		const result = await handleDiscogs("https://www.discogs.com/release/249504-Daft-Punk-Discovery", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("discogs");
+		expect(result?.content).toContain("Daft Punk");
+		expect(result?.content).toContain("Discovery");
+		expect(result?.content).toContain("Tracklist");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches master release", async () => {
+		// Master 33395: Daft Punk - Discovery (master)
+		const result = await handleDiscogs("https://www.discogs.com/master/33395-Daft-Punk-Discovery", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("discogs");
+		expect(result?.content).toContain("Daft Punk");
+		expect(result?.content).toContain("Master Release");
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("handles release URL with just ID", async () => {
+		const result = await handleDiscogs("https://www.discogs.com/release/249504", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("discogs");
+	});
+});
+
+describe.skipIf(SKIP)("handleArtifactHub", () => {
+	it("returns null for non-ArtifactHub URLs", async () => {
+		const result = await handleArtifactHub("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for ArtifactHub homepage", async () => {
+		const result = await handleArtifactHub("https://artifacthub.io/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for ArtifactHub search page", async () => {
+		const result = await handleArtifactHub("https://artifacthub.io/packages/search", 20);
+		expect(result).toBeNull();
+	});
+
+	it("fetches bitnami/nginx helm chart", async () => {
+		const result = await handleArtifactHub("https://artifacthub.io/packages/helm/bitnami/nginx", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("artifacthub");
+		expect(result?.content).toContain("nginx");
+		expect(result?.content).toContain("Helm Chart");
+		expect(result?.content).toContain("Version");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.fetchedAt).toBeTruthy();
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("fetches prometheus-community/prometheus helm chart", async () => {
+		const result = await handleArtifactHub(
+			"https://artifacthub.io/packages/helm/prometheus-community/prometheus",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("artifacthub");
+		expect(result?.content).toContain("prometheus");
+		expect(result?.content).toContain("Repository");
+		expect(result?.truncated).toBeDefined();
+	});
+
+	it("handles www subdomain", async () => {
+		const result = await handleArtifactHub("https://www.artifacthub.io/packages/helm/bitnami/nginx", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("artifacthub");
+	});
+});