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

package/src/core/tools/{web-fetch-handlers → web-scrapers}/mastodon.ts

@@ -51,11 +51,12 @@ interface MastodonStatus {
 /**
  * Check if a domain is a Mastodon instance by probing the API
  */
-async function isMastodonInstance(hostname: string, timeout: number): Promise<boolean> {
+async function isMastodonInstance(hostname: string, timeout: number, signal?: AbortSignal): Promise<boolean> {
 	try {
 		const result = await loadPage(`https://${hostname}/api/v1/instance`, {
 			timeout: Math.min(timeout, 5),
 			headers: { Accept: "application/json" },
+			signal,
 		});
 		if (!result.ok) return false;
 		const data = JSON.parse(result.content);
@@ -188,7 +189,11 @@ function formatAccount(account: MastodonAccount): string {
 /**
  * Handle Mastodon/Fediverse URLs
  */
-export const handleMastodon: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleMastodon: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 
@@ -199,7 +204,7 @@ export const handleMastodon: SpecialHandler = async (url: string, timeout: numbe
 		if (!postMatch && !profileMatch) return null;
 
 		// Verify this is a Mastodon instance
-		if (!(await isMastodonInstance(parsed.hostname, timeout))) {
+		if (!(await isMastodonInstance(parsed.hostname, timeout, signal))) {
 			return null;
 		}
 
@@ -214,6 +219,7 @@ export const handleMastodon: SpecialHandler = async (url: string, timeout: numbe
 			const result = await loadPage(apiUrl, {
 				timeout,
 				headers: { Accept: "application/json" },
+				signal,
 			});
 
 			if (!result.ok) return null;
@@ -248,6 +254,7 @@ export const handleMastodon: SpecialHandler = async (url: string, timeout: numbe
 			const result = await loadPage(lookupUrl, {
 				timeout,
 				headers: { Accept: "application/json" },
+				signal,
 			});
 
 			if (!result.ok) return null;
@@ -264,6 +271,7 @@ export const handleMastodon: SpecialHandler = async (url: string, timeout: numbe
 			const statusesResult = await loadPage(statusesUrl, {
 				timeout,
 				headers: { Accept: "application/json" },
+				signal,
 			});
 
 			let md = formatAccount(account);

package/src/core/tools/{web-fetch-handlers → web-scrapers}/maven.ts

@@ -25,7 +25,11 @@ interface MavenResponse {
  * Handle Maven Central URLs via Solr API
  * Supports: search.maven.org/artifact/... and mvnrepository.com/artifact/...
  */
-export const handleMaven: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleMaven: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		const hostname = parsed.hostname;
@@ -65,6 +69,7 @@ export const handleMaven: SpecialHandler = async (url: string, timeout: number):
 		const result = await loadPage(apiUrl, {
 			timeout,
 			headers: { Accept: "application/json" },
+			signal,
 		});
 
 		if (!result.ok) return null;

package/src/core/tools/{web-fetch-handlers → web-scrapers}/mdn.ts

@@ -105,7 +105,7 @@ function convertMDNBody(sections: MDNSection[]): string {
 	return parts.join("\n\n");
 }
 
-export const handleMDN: SpecialHandler = async (url: string, timeout: number) => {
+export const handleMDN: SpecialHandler = async (url: string, timeout: number, signal?: AbortSignal) => {
 	const urlObj = new URL(url);
 
 	// Only handle developer.mozilla.org
@@ -124,7 +124,7 @@ export const handleMDN: SpecialHandler = async (url: string, timeout: number) =>
 	const jsonUrl = url.replace(/\/?$/, "/index.json");
 
 	try {
-		const result = await loadPage(jsonUrl, { timeout, headers: { Accept: "application/json" } });
+		const result = await loadPage(jsonUrl, { timeout, signal, headers: { Accept: "application/json" } });
 
 		if (!result.ok) {
 			notes.push(`Failed to fetch MDN JSON API (status ${result.status || "unknown"})`);

package/src/core/tools/{web-fetch-handlers → web-scrapers}/metacpan.ts

@@ -39,7 +39,11 @@ interface ReleaseResponse {
 /**
  * Handle MetaCPAN URLs via fastapi.metacpan.org
  */
-export const handleMetaCPAN: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleMetaCPAN: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "metacpan.org" && parsed.hostname !== "www.metacpan.org") return null;
@@ -50,21 +54,21 @@ export const handleMetaCPAN: SpecialHandler = async (url: string, timeout: numbe
 		const podMatch = parsed.pathname.match(/^\/pod\/(.+?)(?:\/|$)/);
 		if (podMatch) {
 			const moduleName = decodeURIComponent(podMatch[1]);
-			return await fetchModule(url, moduleName, timeout, fetchedAt);
+			return await fetchModule(url, moduleName, timeout, fetchedAt, signal);
 		}
 
 		// Match /release/AUTHOR/Distribution pattern
 		const releaseMatch = parsed.pathname.match(/^\/release\/([^/]+)\/([^/]+)/);
 		if (releaseMatch) {
 			const distribution = decodeURIComponent(releaseMatch[2]);
-			return await fetchRelease(url, distribution, timeout, fetchedAt);
+			return await fetchRelease(url, distribution, timeout, fetchedAt, signal);
 		}
 
 		// Match /release/Distribution pattern (without author)
 		const simpleReleaseMatch = parsed.pathname.match(/^\/release\/([^/]+)$/);
 		if (simpleReleaseMatch) {
 			const distribution = decodeURIComponent(simpleReleaseMatch[1]);
-			return await fetchRelease(url, distribution, timeout, fetchedAt);
+			return await fetchRelease(url, distribution, timeout, fetchedAt, signal);
 		}
 
 		return null;
@@ -78,9 +82,10 @@ async function fetchModule(
 	moduleName: string,
 	timeout: number,
 	fetchedAt: string,
+	signal?: AbortSignal,
 ): Promise<RenderResult | null> {
 	const apiUrl = `https://fastapi.metacpan.org/v1/module/${moduleName}`;
-	const result = await loadPage(apiUrl, { timeout });
+	const result = await loadPage(apiUrl, { timeout, signal });
 
 	if (!result.ok) return null;
 
@@ -93,7 +98,7 @@ async function fetchModule(
 
 	// Fetch additional release info for dependencies and metadata
 	const releaseUrl = `https://fastapi.metacpan.org/v1/release/${module.distribution}`;
-	const releaseResult = await loadPage(releaseUrl, { timeout: Math.min(timeout, 5) });
+	const releaseResult = await loadPage(releaseUrl, { timeout: Math.min(timeout, 5), signal });
 
 	let release: ReleaseResponse | null = null;
 	if (releaseResult.ok) {
@@ -122,9 +127,10 @@ async function fetchRelease(
 	distribution: string,
 	timeout: number,
 	fetchedAt: string,
+	signal?: AbortSignal,
 ): Promise<RenderResult | null> {
 	const apiUrl = `https://fastapi.metacpan.org/v1/release/${distribution}`;
-	const result = await loadPage(apiUrl, { timeout });
+	const result = await loadPage(apiUrl, { timeout, signal });
 
 	if (!result.ok) return null;
 

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

@@ -0,0 +1,273 @@
+/**
+ * MusicBrainz URL handler for artists, releases, and recordings
+ */
+
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+type MusicBrainzEntity = "artist" | "release" | "recording";
+
+interface MusicBrainzLifeSpan {
+	begin?: string;
+	end?: string;
+	ended?: boolean;
+}
+
+interface MusicBrainzArtist {
+	id: string;
+	name: string;
+	type?: string;
+	country?: string;
+	"life-span"?: MusicBrainzLifeSpan;
+}
+
+interface MusicBrainzArtistCredit {
+	name?: string;
+	artist?: {
+		id?: string;
+		name: string;
+	};
+}
+
+interface MusicBrainzRecording {
+	id: string;
+	title: string;
+	length?: number;
+	"artist-credit"?: MusicBrainzArtistCredit[];
+}
+
+interface MusicBrainzTrack {
+	id?: string;
+	title?: string;
+	number?: string;
+	position?: number;
+	length?: number;
+	recording?: {
+		title?: string;
+		length?: number;
+	};
+}
+
+interface MusicBrainzMedium {
+	position?: number;
+	format?: string;
+	"track-count"?: number;
+	tracks?: MusicBrainzTrack[];
+}
+
+interface MusicBrainzRelease {
+	id: string;
+	title: string;
+	"track-count"?: number;
+	media?: MusicBrainzMedium[];
+}
+
+const MUSICBRAINZ_HOSTS = new Set(["musicbrainz.org", "www.musicbrainz.org"]);
+const USER_AGENT = "omp-web-fetch/1.0 (https://github.com/anthropics)";
+const MAX_TRACKS = 50;
+
+function parseEntity(url: URL): { entity: MusicBrainzEntity; mbid: string } | null {
+	if (!MUSICBRAINZ_HOSTS.has(url.hostname)) return null;
+
+	const parts = url.pathname.split("/").filter(Boolean);
+	if (parts.length < 2) return null;
+
+	const entity = parts[0] as MusicBrainzEntity;
+	if (entity !== "artist" && entity !== "release" && entity !== "recording") return null;
+
+	const mbid = parts[1];
+	if (!/^[0-9a-fA-F-]{36}$/.test(mbid)) return null;
+
+	return { entity, mbid };
+}
+
+async function fetchJson<T>(apiUrl: string, timeout: number, signal?: AbortSignal): Promise<T | null> {
+	const result = await loadPage(apiUrl, {
+		timeout,
+		signal,
+		headers: {
+			"User-Agent": USER_AGENT,
+			Accept: "application/json",
+		},
+	});
+
+	if (!result.ok) return null;
+
+	try {
+		return JSON.parse(result.content) as T;
+	} catch {
+		return null;
+	}
+}
+
+function formatLifeSpan(life: MusicBrainzLifeSpan | undefined): string | null {
+	if (!life) return null;
+
+	const begin = life.begin?.trim();
+	const end = life.end?.trim();
+
+	if (begin && end) return `${begin} - ${end}`;
+	if (begin && !end) return `${begin} - ${life.ended ? "ended" : "present"}`;
+	if (!begin && end) return `? - ${end}`;
+	if (life.ended !== undefined) return life.ended ? "ended" : "present";
+
+	return null;
+}
+
+function formatDurationMs(lengthMs: number | undefined): string | null {
+	if (!lengthMs || lengthMs <= 0) return null;
+
+	const totalSeconds = Math.round(lengthMs / 1000);
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor((totalSeconds % 3600) / 60);
+	const seconds = totalSeconds % 60;
+
+	if (hours > 0) {
+		return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+	}
+
+	return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+}
+
+function formatArtistCredits(credits: MusicBrainzArtistCredit[] | undefined): string | null {
+	if (!credits?.length) return null;
+
+	const names = credits
+		.map((credit) => credit.name || credit.artist?.name)
+		.filter((name): name is string => Boolean(name));
+
+	if (!names.length) return null;
+	return names.join(", ");
+}
+
+function formatTrack(track: MusicBrainzTrack): string {
+	const title = track.title || track.recording?.title || "Untitled";
+	const duration = formatDurationMs(track.length ?? track.recording?.length);
+	const number = track.number || (track.position ? String(track.position) : null);
+
+	const prefix = number ? `${number}. ` : "- ";
+	let line = `${prefix}${title}`;
+	if (duration) line += ` (${duration})`;
+	return line;
+}
+
+function buildMediumLabel(medium: MusicBrainzMedium, includePosition: boolean): string | null {
+	const parts: string[] = [];
+	if (includePosition && medium.position) parts.push(`Disc ${medium.position}`);
+	if (medium.format) parts.push(medium.format);
+	return parts.length ? parts.join(" - ") : null;
+}
+
+function buildArtistMarkdown(artist: MusicBrainzArtist): string {
+	let md = `# ${artist.name}\n\n`;
+	const meta: string[] = [];
+
+	if (artist.type) meta.push(`**Type**: ${artist.type}`);
+	if (artist.country) meta.push(`**Country**: ${artist.country}`);
+
+	const lifeSpan = formatLifeSpan(artist["life-span"]);
+	if (lifeSpan) meta.push(`**Life Span**: ${lifeSpan}`);
+
+	if (meta.length) md += `${meta.join("\n")}\n`;
+
+	return md;
+}
+
+function buildReleaseMarkdown(release: MusicBrainzRelease): string {
+	let md = `# ${release.title}\n\n`;
+
+	const media = release.media ?? [];
+	const totalTracks =
+		release["track-count"] ??
+		media.reduce((sum, medium) => sum + (medium["track-count"] ?? medium.tracks?.length ?? 0), 0);
+
+	if (totalTracks) {
+		md += `**Tracks**: ${totalTracks}\n\n`;
+	}
+
+	if (media.length) {
+		md += "## Tracks\n\n";
+		const includePosition = media.length > 1;
+
+		for (const medium of media) {
+			const label = buildMediumLabel(medium, includePosition);
+			if (label) md += `### ${label}\n\n`;
+
+			const tracks = medium.tracks ?? [];
+			if (tracks.length) {
+				const lines = tracks.slice(0, MAX_TRACKS).map(formatTrack).join("\n");
+				md += `${lines}\n\n`;
+
+				if (tracks.length > MAX_TRACKS) {
+					md += `_Showing first ${MAX_TRACKS} of ${tracks.length} tracks._\n\n`;
+				}
+			} else if (medium["track-count"]) {
+				md += `- ${medium["track-count"]} tracks (details unavailable)\n\n`;
+			}
+		}
+	}
+
+	return md;
+}
+
+function buildRecordingMarkdown(recording: MusicBrainzRecording): string {
+	let md = `# ${recording.title}\n\n`;
+	const meta: string[] = [];
+
+	const artists = formatArtistCredits(recording["artist-credit"]);
+	if (artists) meta.push(`**Artists**: ${artists}`);
+
+	const length = formatDurationMs(recording.length);
+	if (length) meta.push(`**Length**: ${length}`);
+
+	if (meta.length) md += `${meta.join("\n")}\n`;
+
+	return md;
+}
+
+export const handleMusicBrainz: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		const parsedEntity = parseEntity(parsed);
+		if (!parsedEntity) return null;
+
+		const { entity, mbid } = parsedEntity;
+		const fetchedAt = new Date().toISOString();
+		let md = "";
+
+		if (entity === "artist") {
+			const apiUrl = `https://musicbrainz.org/ws/2/artist/${mbid}?fmt=json&inc=url-rels`;
+			const artist = await fetchJson<MusicBrainzArtist>(apiUrl, timeout, signal);
+			if (!artist) return null;
+			md = buildArtistMarkdown(artist);
+		} else if (entity === "release") {
+			const apiUrl = `https://musicbrainz.org/ws/2/release/${mbid}?fmt=json&inc=recordings`;
+			const release = await fetchJson<MusicBrainzRelease>(apiUrl, timeout, signal);
+			if (!release) return null;
+			md = buildReleaseMarkdown(release);
+		} else {
+			const apiUrl = `https://musicbrainz.org/ws/2/recording/${mbid}?fmt=json`;
+			const recording = await fetchJson<MusicBrainzRecording>(apiUrl, timeout, signal);
+			if (!recording) return null;
+			md = buildRecordingMarkdown(recording);
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "musicbrainz-api",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via MusicBrainz API"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/{web-fetch-handlers → web-scrapers}/npm.ts

@@ -4,7 +4,11 @@ import { finalizeOutput, formatCount, loadPage } from "./types";
 /**
  * Handle npm URLs via registry API
  */
-export const handleNpm: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleNpm: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "www.npmjs.com" && parsed.hostname !== "npmjs.com") return null;
@@ -28,8 +32,8 @@ export const handleNpm: SpecialHandler = async (url: string, timeout: number): P
 
 		// Fetch package info and download stats in parallel
 		const [result, downloadsResult] = await Promise.all([
-			loadPage(latestUrl, { timeout }),
-			loadPage(downloadsUrl, { timeout: Math.min(timeout, 5) }),
+			loadPage(latestUrl, { timeout, signal }),
+			loadPage(downloadsUrl, { timeout: Math.min(timeout, 5), signal }),
 		]);
 
 		if (!result.ok) return null;
@@ -47,7 +51,7 @@ export const handleNpm: SpecialHandler = async (url: string, timeout: number): P
 			name: string;
 			version: string;
 			description?: string;
-			license?: string;
+			license?: string | { type: string };
 			homepage?: string;
 			repository?: { url: string } | string;
 			keywords?: string[];
@@ -66,7 +70,10 @@ export const handleNpm: SpecialHandler = async (url: string, timeout: number): P
 		if (pkg.description) md += `${pkg.description}\n\n`;
 
 		md += `**Latest:** ${pkg.version || "unknown"}`;
-		if (pkg.license) md += ` · **License:** ${typeof pkg.license === "string" ? pkg.license : pkg.license}`;
+		if (pkg.license) {
+			const license = typeof pkg.license === "string" ? pkg.license : (pkg.license.type ?? String(pkg.license));
+			md += ` · **License:** ${license}`;
+		}
 		md += "\n";
 		if (weeklyDownloads !== null) {
 			md += `**Weekly Downloads:** ${formatCount(weeklyDownloads)}\n`;

package/src/core/tools/{web-fetch-handlers → web-scrapers}/nuget.ts

@@ -37,7 +37,11 @@ interface NuGetRegistrationIndex {
 /**
  * Handle NuGet URLs via API
  */
-export const handleNuGet: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleNuGet: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "www.nuget.org" && parsed.hostname !== "nuget.org") return null;
@@ -52,7 +56,7 @@ export const handleNuGet: SpecialHandler = async (url: string, timeout: number):
 
 		// 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 });
+		const result = await loadPage(apiUrl, { timeout, signal });
 
 		if (!result.ok) return null;
 
@@ -70,7 +74,7 @@ export const handleNuGet: SpecialHandler = async (url: string, timeout: number):
 
 		// If items are not inlined, fetch the page
 		if (!latestPage.items && latestPage["@id"]) {
-			const pageResult = await loadPage(latestPage["@id"], { timeout });
+			const pageResult = await loadPage(latestPage["@id"], { timeout, signal });
 			if (!pageResult.ok) return null;
 			try {
 				latestPage = JSON.parse(pageResult.content);
@@ -91,7 +95,7 @@ export const handleNuGet: SpecialHandler = async (url: string, timeout: number):
 
 				// Fetch page if items not inlined
 				if (!pageItems && page["@id"]) {
-					const pageResult = await loadPage(page["@id"], { timeout: Math.min(timeout, 5) });
+					const pageResult = await loadPage(page["@id"], { timeout: Math.min(timeout, 5), signal });
 					if (pageResult.ok) {
 						try {
 							const fetchedPage = JSON.parse(pageResult.content) as NuGetRegistrationPage;
@@ -121,7 +125,7 @@ export const handleNuGet: SpecialHandler = async (url: string, timeout: number):
 		// 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) });
+		const searchResult = await loadPage(searchUrl, { timeout: Math.min(timeout, 5), signal });
 
 		if (searchResult.ok) {
 			try {

package/src/core/tools/{web-fetch-handlers → web-scrapers}/nvd.ts

@@ -73,7 +73,11 @@ interface NvdResponse {
 /**
  * Handle NVD (National Vulnerability Database) CVE URLs
  */
-export const handleNvd: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleNvd: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (!parsed.hostname.includes("nvd.nist.gov")) return null;
@@ -90,6 +94,7 @@ export const handleNvd: SpecialHandler = async (url: string, timeout: number): P
 		const result = await loadPage(apiUrl, {
 			timeout,
 			headers: { Accept: "application/json" },
+			signal,
 		});
 
 		if (!result.ok) return null;