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

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

@@ -0,0 +1,192 @@
+import { describe, expect, it } from "bun:test";
+import { handleBluesky } from "./bluesky";
+import { handleMastodon } from "./mastodon";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleMastodon", () => {
+	it("returns null for non-Mastodon URLs", async () => {
+		const result = await handleMastodon("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for URLs without @user pattern", async () => {
+		const result = await handleMastodon("https://mastodon.social/about", 20);
+		expect(result).toBeNull();
+	});
+
+	it(
+		"fetches a Mastodon profile",
+		async () => {
+			// @Gargron is Eugen Rochko, creator of Mastodon - very stable
+			const result = await handleMastodon("https://mastodon.social/@Gargron", 20);
+			expect(result).not.toBeNull();
+			expect(result?.method).toBe("mastodon");
+			expect(result?.contentType).toBe("text/markdown");
+			expect(result?.content).toContain("Gargron");
+			expect(result?.content).toContain("@Gargron");
+			expect(result?.content).toContain("**Followers:**");
+			expect(result?.content).toContain("**Following:**");
+			expect(result?.content).toContain("**Posts:**");
+			expect(result?.fetchedAt).toBeTruthy();
+			expect(result?.truncated).toBeDefined();
+			expect(result?.notes?.[0]).toContain("Mastodon API");
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"fetches a Mastodon post",
+		async () => {
+			// Gargron's post ID 1 - the first ever Mastodon post
+			const result = await handleMastodon("https://mastodon.social/@Gargron/1", 20);
+			// Post 1 may not exist anymore; check gracefully
+			if (result !== null) {
+				expect(result.method).toBe("mastodon");
+				expect(result.contentType).toBe("text/markdown");
+				expect(result.content).toContain("Post by");
+				expect(result.content).toContain("@Gargron");
+				expect(result.fetchedAt).toBeTruthy();
+				expect(result.truncated).toBeDefined();
+				expect(result.notes?.[0]).toContain("Mastodon API");
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"handles a stable pinned post",
+		async () => {
+			// Use a well-known post from mastodon.social - Gargron's announcement post
+			const result = await handleMastodon("https://mastodon.social/@Gargron/109318821117356215", 20);
+			// May not exist, check gracefully
+			if (result !== null) {
+				expect(result.method).toBe("mastodon");
+				expect(result.contentType).toBe("text/markdown");
+				expect(result.content).toContain("@Gargron");
+				expect(result.content).toContain("replies");
+				expect(result.content).toContain("boosts");
+				expect(result.content).toContain("favorites");
+				expect(result.fetchedAt).toBeTruthy();
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"includes recent posts in profile",
+		async () => {
+			const result = await handleMastodon("https://mastodon.social/@Gargron", 20);
+			expect(result).not.toBeNull();
+			// May include recent posts section
+			if (result?.content?.includes("## Recent Posts")) {
+				expect(result.content).toMatch(/###\s+\w+/); // Date header
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it("returns null for non-Mastodon instance with @user pattern", async () => {
+		// A site that has @user pattern but isn't Mastodon
+		const result = await handleMastodon("https://twitter.com/@jack", 20);
+		expect(result).toBeNull();
+	});
+});
+
+describe.skipIf(SKIP)("handleBluesky", () => {
+	it("returns null for non-Bluesky URLs", async () => {
+		const result = await handleBluesky("https://example.com", 20);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for bsky.app URLs without profile path", async () => {
+		const result = await handleBluesky("https://bsky.app/about", 20);
+		expect(result).toBeNull();
+	});
+
+	it(
+		"fetches a Bluesky profile",
+		async () => {
+			// bsky.app official account - stable
+			const result = await handleBluesky("https://bsky.app/profile/bsky.app", 20);
+			expect(result).not.toBeNull();
+			expect(result?.method).toBe("bluesky-api");
+			expect(result?.contentType).toBe("text/markdown");
+			expect(result?.content).toContain("bsky.app");
+			expect(result?.content).toContain("@bsky.app");
+			expect(result?.content).toContain("**Followers:**");
+			expect(result?.content).toContain("**Following:**");
+			expect(result?.content).toContain("**Posts:**");
+			expect(result?.content).toContain("**DID:**");
+			expect(result?.fetchedAt).toBeTruthy();
+			expect(result?.truncated).toBeDefined();
+			expect(result?.notes).toContain("Fetched via AT Protocol API");
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"fetches Jay Graber's profile",
+		async () => {
+			// Jay Graber - CEO of Bluesky, very stable
+			const result = await handleBluesky("https://bsky.app/profile/jay.bsky.team", 20);
+			expect(result).not.toBeNull();
+			expect(result?.method).toBe("bluesky-api");
+			expect(result?.contentType).toBe("text/markdown");
+			expect(result?.content).toContain("@jay.bsky.team");
+			expect(result?.content).toContain("**Followers:**");
+			expect(result?.fetchedAt).toBeTruthy();
+			expect(result?.truncated).toBeDefined();
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"fetches a Bluesky post",
+		async () => {
+			// A post from bsky.app - use a well-known stable post
+			const result = await handleBluesky("https://bsky.app/profile/bsky.app/post/3juzlwllznd24", 20);
+			// Post may not exist, check gracefully
+			if (result !== null) {
+				expect(result.method).toBe("bluesky-api");
+				expect(result.contentType).toBe("text/markdown");
+				expect(result.content).toContain("# Bluesky Post");
+				expect(result.content).toContain("@bsky.app");
+				expect(result.fetchedAt).toBeTruthy();
+				expect(result.truncated).toBeDefined();
+				expect(result.notes?.[0]).toContain("AT URI");
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"includes post stats",
+		async () => {
+			const result = await handleBluesky("https://bsky.app/profile/bsky.app/post/3juzlwllznd24", 20);
+			// Stats include likes, reposts, replies
+			if (result?.content) {
+				// Should have some engagement markers
+				const hasStats =
+					result.content.includes("❤️") || result.content.includes("🔁") || result.content.includes("💬");
+				expect(hasStats || result.content.includes("# Bluesky Post")).toBe(true);
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"handles www.bsky.app URLs",
+		async () => {
+			const result = await handleBluesky("https://www.bsky.app/profile/bsky.app", 20);
+			expect(result).not.toBeNull();
+			expect(result?.method).toBe("bluesky-api");
+		},
+		{ timeout: 30000 },
+	);
+
+	it("returns null for invalid profile handle", async () => {
+		const result = await handleBluesky("https://bsky.app/profile/", 20);
+		expect(result).toBeNull();
+	});
+});

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

@@ -0,0 +1,259 @@
+import { describe, expect, it } from "bun:test";
+import { handleReddit } from "./reddit";
+import { handleStackOverflow } from "./stackoverflow";
+import { handleTwitter } from "./twitter";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleTwitter", () => {
+	it("returns null for non-Twitter URLs", async () => {
+		const result = await handleTwitter("https://example.com", 10);
+		expect(result).toBeNull();
+	});
+
+	it(
+		"handles twitter.com status URLs",
+		async () => {
+			const result = await handleTwitter("https://twitter.com/jack/status/20", 10000);
+			expect(result).not.toBeNull();
+			expect(result?.method).toMatch(/^twitter/);
+			expect(result?.contentType).toMatch(/^text\/(markdown|plain)$/);
+			// Either successful fetch or blocked/unavailable message
+			if (result?.method === "twitter-nitter") {
+				expect(result?.content).toContain("Tweet by");
+				expect(result?.notes?.[0]).toContain("Via Nitter");
+			} else if (result?.method === "twitter-blocked") {
+				expect(result?.content).toContain("blocks automated access");
+				expect(result?.notes?.[0]).toContain("Nitter instances unavailable");
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"handles x.com status URLs",
+		async () => {
+			const result = await handleTwitter("https://x.com/elonmusk/status/1", 10000);
+			expect(result).not.toBeNull();
+			expect(result?.method).toMatch(/^twitter/);
+			expect(result?.contentType).toMatch(/^text\/(markdown|plain)$/);
+			// Either successful fetch or blocked/unavailable message
+			if (result?.method === "twitter-nitter") {
+				expect(result?.finalUrl).toContain("nitter");
+			} else if (result?.method === "twitter-blocked") {
+				expect(result?.content).toContain("blocks automated access");
+			}
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"handles www.twitter.com URLs",
+		async () => {
+			const result = await handleTwitter("https://www.twitter.com/twitter/status/1", 10000);
+			expect(result).not.toBeNull();
+			expect(result?.method).toMatch(/^twitter/);
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"handles www.x.com URLs",
+		async () => {
+			const result = await handleTwitter("https://www.x.com/twitter/status/1", 10000);
+			expect(result).not.toBeNull();
+			expect(result?.method).toMatch(/^twitter/);
+		},
+		{ timeout: 30000 },
+	);
+
+	it(
+		"may fail due to Nitter availability",
+		async () => {
+			// Test that failure returns helpful message instead of null
+			const result = await handleTwitter("https://twitter.com/nonexistent/status/999999999999999999", 10000);
+			expect(result).not.toBeNull();
+			// Should return blocked message when Nitter fails
+			if (result?.method === "twitter-blocked") {
+				expect(result?.content).toContain("Nitter instances were unavailable");
+				expect(result?.content).toContain("Try:");
+			}
+		},
+		{ timeout: 30000 },
+	);
+});
+
+describe.skipIf(SKIP)("handleReddit", () => {
+	it("returns null for non-Reddit URLs", async () => {
+		const result = await handleReddit("https://example.com", 10);
+		expect(result).toBeNull();
+	});
+
+	it("fetches subreddit", async () => {
+		const result = await handleReddit("https://www.reddit.com/r/programming/", 20000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("reddit");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.content).toContain("# r/programming");
+		expect(result?.content).toMatch(/\*\*.*\*\*/); // Contains bold formatting
+		expect(result?.notes).toContain("Fetched via Reddit JSON API");
+	});
+
+	it("fetches individual post", async () => {
+		// Use a more reliable recent post URL
+		const result = await handleReddit("https://www.reddit.com/r/programming/", 20000);
+		// Individual post may fail if post doesn't exist, check if we get data
+		if (result !== null) {
+			expect(result.method).toBe("reddit");
+			expect(result.contentType).toBe("text/markdown");
+			expect(result.content).toContain("# r/");
+			expect(result.notes).toContain("Fetched via Reddit JSON API");
+		}
+	});
+
+	it("includes comments in post when available", async () => {
+		const result = await handleReddit("https://www.reddit.com/r/programming/", 20000);
+		// Comments test - just verify structure if post with comments is found
+		if (result?.content?.includes("## Top Comments")) {
+			expect(result.content).toContain("### u/");
+			expect(result.content).toContain("points");
+		}
+	});
+
+	it("handles old.reddit.com", async () => {
+		const result = await handleReddit("https://old.reddit.com/r/programming/", 20000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("reddit");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.content).toContain("# r/");
+		expect(result?.notes).toContain("Fetched via Reddit JSON API");
+	});
+
+	it("handles reddit.com without www", async () => {
+		const result = await handleReddit("https://reddit.com/r/programming/", 20000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("reddit");
+	});
+
+	it("handles URLs with query parameters", async () => {
+		const result = await handleReddit("https://www.reddit.com/r/programming/?sort=top", 20000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("reddit");
+		expect(result?.content).toContain("# r/");
+	});
+
+	it("returns null for malformed Reddit URLs", async () => {
+		const result = await handleReddit("https://www.reddit.com/invalid", 20000);
+		// May return null or empty result
+		if (result !== null) {
+			expect(result.content).toBeDefined();
+		}
+	});
+});
+
+describe.skipIf(SKIP)("handleStackOverflow", () => {
+	it("returns null for non-SO URLs", async () => {
+		const result = await handleStackOverflow("https://example.com", 10);
+		expect(result).toBeNull();
+	});
+
+	it("returns null for SO URLs without question ID", async () => {
+		const result = await handleStackOverflow("https://stackoverflow.com/", 10);
+		expect(result).toBeNull();
+	});
+
+	it("fetches a known question", async () => {
+		// Use a well-known question that definitely exists
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster",
+			20000,
+		);
+		// API may fail or rate limit, check gracefully
+		if (result !== null) {
+			expect(result.method).toBe("stackoverflow");
+			expect(result.contentType).toBe("text/markdown");
+			expect(result.content).toContain("# ");
+			expect(result.content).toContain("**Score:");
+			expect(result.content).toContain("**Tags:");
+			expect(result.content).toContain("## Question");
+			expect(result.notes).toContain("Fetched via Stack Exchange API");
+		}
+	});
+
+	it("includes answers", async () => {
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster",
+			20000,
+		);
+		if (result?.content?.includes("## Answers")) {
+			expect(result.content).toContain("### Score:");
+		}
+	});
+
+	it("shows accepted answer marker when present", async () => {
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster",
+			20000,
+		);
+		// Some questions may have accepted answers
+		if (result?.content?.includes("(Accepted)")) {
+			expect(result.content).toContain("## Answers");
+		}
+	});
+
+	it("handles stackoverflow.com", async () => {
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-processing-an-unsorted-array",
+			20000,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("stackoverflow");
+		expect(result?.content).toContain("# ");
+		expect(result?.content).toContain("## Question");
+	});
+
+	it("handles other StackExchange sites", async () => {
+		const result = await handleStackOverflow("https://math.stackexchange.com/questions/1000/", 20000);
+		// API may fail, check gracefully
+		if (result !== null) {
+			expect(result.method).toBe("stackoverflow");
+			expect(result.contentType).toBe("text/markdown");
+			expect(result.content).toContain("# ");
+			expect(result.notes).toContain("Fetched via Stack Exchange API");
+		}
+	});
+
+	it("extracts question ID from URL", async () => {
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/1234567/some-long-question-title",
+			20000,
+		);
+		// Should attempt to fetch, may or may not exist
+		// Either returns valid result or null
+		if (result !== null) {
+			expect(result.method).toBe("stackoverflow");
+		}
+	});
+
+	it("handles URLs without trailing slash", async () => {
+		const result = await handleStackOverflow("https://stackoverflow.com/questions/11227809", 20000);
+		// API may fail, check gracefully
+		if (result !== null) {
+			expect(result.method).toBe("stackoverflow");
+		}
+	});
+
+	it("includes question metadata", async () => {
+		const result = await handleStackOverflow(
+			"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster",
+			20000,
+		);
+		// API may fail, check gracefully
+		if (result !== null) {
+			expect(result.content).toContain("**Score:");
+			expect(result.content).toContain("**Answers:");
+			expect(result.content).toContain("**Tags:");
+			expect(result.content).toContain("**Asked by:");
+		}
+	});
+});

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

@@ -0,0 +1,218 @@
+/**
+ * Spotify URL handler for podcasts, tracks, albums, and playlists
+ *
+ * Uses oEmbed API and Open Graph metadata to extract information
+ * from Spotify URLs without requiring authentication.
+ */
+
+import type { SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+interface SpotifyOEmbedResponse {
+	title?: string;
+	thumbnail_url?: string;
+	provider_name?: string;
+	html?: string;
+	width?: number;
+	height?: number;
+}
+
+interface OpenGraphData {
+	title?: string;
+	description?: string;
+	audio?: string;
+	image?: string;
+	type?: string;
+	duration?: string;
+	album?: string;
+	musician?: string;
+	artist?: string;
+	releaseDate?: string;
+}
+
+/**
+ * Parse Open Graph meta tags from HTML
+ */
+function parseOpenGraph(html: string): OpenGraphData {
+	const og: OpenGraphData = {};
+
+	const metaPattern = /<meta\s+(?:property|name)="([^"]+)"\s+content="([^"]*)"[^>]*>/gi;
+	let match: RegExpExecArray | null = null;
+
+	while (true) {
+		match = metaPattern.exec(html);
+		if (match === null) break;
+		const [, property, content] = match;
+
+		if (property === "og:title") og.title = content;
+		else if (property === "og:description") og.description = content;
+		else if (property === "og:audio") og.audio = content;
+		else if (property === "og:image") og.image = content;
+		else if (property === "og:type") og.type = content;
+		else if (property === "music:duration") og.duration = content;
+		else if (property === "music:album") og.album = content;
+		else if (property === "music:musician") og.musician = content;
+		else if (property === "music:release_date") og.releaseDate = content;
+		else if (property === "twitter:audio:artist_name") og.artist = content;
+	}
+
+	return og;
+}
+
+/**
+ * Determine content type from URL path
+ */
+function getContentType(url: string): string | null {
+	if (url.includes("/episode/")) return "podcast-episode";
+	if (url.includes("/show/")) return "podcast-show";
+	if (url.includes("/track/")) return "track";
+	if (url.includes("/album/")) return "album";
+	if (url.includes("/playlist/")) return "playlist";
+	return null;
+}
+
+/**
+ * Format duration from seconds
+ */
+function formatDuration(seconds: string | undefined): string | null {
+	if (!seconds) return null;
+	const num = parseInt(seconds, 10);
+	if (Number.isNaN(num)) return null;
+
+	const hours = Math.floor(num / 3600);
+	const minutes = Math.floor((num % 3600) / 60);
+	const secs = num % 60;
+
+	if (hours > 0) {
+		return `${hours}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+	}
+	return `${minutes}:${secs.toString().padStart(2, "0")}`;
+}
+
+/**
+ * Format output based on content type and available metadata
+ */
+function formatOutput(contentType: string, oEmbed: SpotifyOEmbedResponse, og: OpenGraphData, url: string): string {
+	const sections: string[] = [];
+
+	// Title
+	const title = og.title || oEmbed.title || "Unknown";
+	sections.push(`# ${title}\n`);
+
+	// Type
+	sections.push(`**Type**: ${contentType}\n`);
+
+	// Description
+	if (og.description) {
+		sections.push(`**Description**: ${og.description}\n`);
+	}
+
+	// Content-specific metadata
+	if (contentType === "track" || contentType === "podcast-episode") {
+		if (og.artist || og.musician) {
+			sections.push(`**Artist**: ${og.artist || og.musician}\n`);
+		}
+		if (og.album) {
+			sections.push(`**Album**: ${og.album}\n`);
+		}
+		if (og.duration) {
+			const formatted = formatDuration(og.duration);
+			if (formatted) {
+				sections.push(`**Duration**: ${formatted}\n`);
+			}
+		}
+	}
+
+	if (contentType === "album" && og.releaseDate) {
+		sections.push(`**Release Date**: ${og.releaseDate}\n`);
+	}
+
+	// Note about limited information
+	sections.push("\n---\n");
+	if (contentType === "playlist") {
+		sections.push(
+			"**Note**: Playlist details (tracks, creator, follower count) require authentication. " +
+				"Only basic metadata is available without Spotify API credentials.\n",
+		);
+	} else if (contentType === "album") {
+		sections.push(
+			"**Note**: Track listing and detailed album information require authentication. " +
+				"Only basic metadata is available without Spotify API credentials.\n",
+		);
+	} else if (contentType === "podcast-show") {
+		sections.push(
+			"**Note**: Episode listing and detailed show information require authentication. " +
+				"Only basic metadata is available without Spotify API credentials.\n",
+		);
+	}
+
+	sections.push(`**URL**: ${url}\n`);
+
+	if (oEmbed.thumbnail_url) {
+		sections.push(`**Thumbnail**: ${oEmbed.thumbnail_url}\n`);
+	} else if (og.image) {
+		sections.push(`**Image**: ${og.image}\n`);
+	}
+
+	return sections.join("\n");
+}
+
+export const handleSpotify: SpecialHandler = async (url: string, timeout: number) => {
+	// Check if this is a Spotify URL
+	if (!url.includes("open.spotify.com/")) {
+		return null;
+	}
+
+	const contentType = getContentType(url);
+	if (!contentType) {
+		return null;
+	}
+
+	const notes: string[] = [];
+	let oEmbedData: SpotifyOEmbedResponse = {};
+	let ogData: OpenGraphData = {};
+
+	// Fetch oEmbed data
+	try {
+		const oEmbedUrl = `https://open.spotify.com/oembed?url=${encodeURIComponent(url)}`;
+		const response = await loadPage(oEmbedUrl, { timeout });
+
+		if (response.ok) {
+			oEmbedData = JSON.parse(response.content) as SpotifyOEmbedResponse;
+			notes.push("Retrieved metadata via Spotify oEmbed API");
+		} else {
+			notes.push(`oEmbed API returned status ${response.status || "error"}`);
+		}
+	} catch (err) {
+		notes.push(`Failed to fetch oEmbed data: ${err instanceof Error ? err.message : String(err)}`);
+	}
+
+	// Fetch page HTML for Open Graph metadata
+	try {
+		const pageResponse = await loadPage(url, { timeout });
+
+		if (pageResponse.ok) {
+			ogData = parseOpenGraph(pageResponse.content);
+			notes.push("Parsed Open Graph metadata from page HTML");
+		} else {
+			notes.push(`Page fetch returned status ${pageResponse.status || "error"}`);
+		}
+	} catch (err) {
+		notes.push(`Failed to fetch page HTML: ${err instanceof Error ? err.message : String(err)}`);
+	}
+
+	// Format output
+	const output = formatOutput(contentType, oEmbedData, ogData, url);
+	const { content, truncated } = finalizeOutput(output);
+
+	return {
+		url,
+		finalUrl: url,
+		contentType: "text/markdown",
+		method: "spotify",
+		content,
+		fetchedAt: new Date().toISOString(),
+		truncated,
+		notes,
+	};
+};