@oh-my-pi/pi-coding-agent 5.7.67 → 5.7.69

package/src/core/tools/web-scrapers/research.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleBiorxiv } from "./biorxiv";
-import { handleOpenLibrary } from "./openlibrary";
-import { handleWikidata } from "./wikidata";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleWikidata", () => {
-	it("returns null for non-matching URLs", async () => {
-		const result = await handleWikidata("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for non-wikidata URLs", async () => {
-		const result = await handleWikidata("https://wikipedia.org/wiki/Apple_Inc", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches Q312 - Apple Inc", async () => {
-		const result = await handleWikidata("https://www.wikidata.org/wiki/Q312", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikidata");
-		expect(result?.content).toContain("Apple");
-		expect(result?.content).toContain("Q312");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches Q5 - human (entity)", async () => {
-		const result = await handleWikidata("https://www.wikidata.org/entity/Q5", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikidata");
-		expect(result?.content).toContain("human");
-		expect(result?.content).toContain("Q5");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-});
-
-describe.skipIf(SKIP)("handleOpenLibrary", () => {
-	it("returns null for non-matching URLs", async () => {
-		const result = await handleOpenLibrary("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for non-openlibrary URLs", async () => {
-		const result = await handleOpenLibrary("https://amazon.com/books/123", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches by ISBN - Fantastic Mr Fox", async () => {
-		const result = await handleOpenLibrary("https://openlibrary.org/isbn/9780140328721", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("openlibrary");
-		expect(result?.content).toContain("Fantastic Mr");
-		expect(result?.content).toContain("Roald Dahl");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches work OL45804W - The Lord of the Rings", async () => {
-		const result = await handleOpenLibrary("https://openlibrary.org/works/OL45804W", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("openlibrary");
-		expect(result?.content).toContain("Lord of the Rings");
-		expect(result?.content).toContain("Tolkien");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-});
-
-describe.skipIf(SKIP)("handleBiorxiv", () => {
-	it("returns null for non-matching URLs", async () => {
-		const result = await handleBiorxiv("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for non-biorxiv URLs", async () => {
-		const result = await handleBiorxiv("https://nature.com/articles/123", 20);
-		expect(result).toBeNull();
-	});
-
-	// Using the AlphaFold Protein Structure Database paper - highly cited and stable
-	it("fetches bioRxiv preprint - AlphaFold database", async () => {
-		const result = await handleBiorxiv("https://www.biorxiv.org/content/10.1101/2021.10.04.463034", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("biorxiv");
-		expect(result?.content).toContain("AlphaFold");
-		expect(result?.content).toContain("Abstract");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	// Testing with version suffix handling
-	it("fetches bioRxiv preprint with version suffix", async () => {
-		const result = await handleBiorxiv("https://www.biorxiv.org/content/10.1101/2021.10.04.463034v1", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("biorxiv");
-		expect(result?.content).toContain("AlphaFold");
-		expect(result?.contentType).toBe("text/markdown");
-	});
-});

package/src/core/tools/web-scrapers/security.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleNvd } from "./nvd";
-import { handleOsv } from "./osv";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleNvd", () => {
-	it("returns null for non-NVD URLs", async () => {
-		const result = await handleNvd("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for NVD URLs without CVE detail path", async () => {
-		const result = await handleNvd("https://nvd.nist.gov/", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for NVD search URLs", async () => {
-		const result = await handleNvd("https://nvd.nist.gov/vuln/search/results?query=log4j", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches CVE-2021-44228 (Log4Shell)", async () => {
-		const result = await handleNvd("https://nvd.nist.gov/vuln/detail/CVE-2021-44228", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("nvd");
-		expect(result?.content).toContain("CVE-2021-44228");
-		expect(result?.content).toContain("Log4j");
-		expect(result?.content).toContain("CVSS");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches CVE-2014-0160 (Heartbleed)", async () => {
-		const result = await handleNvd("https://nvd.nist.gov/vuln/detail/CVE-2014-0160", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("nvd");
-		expect(result?.content).toContain("CVE-2014-0160");
-		expect(result?.content).toContain("OpenSSL");
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("handles lowercase CVE IDs", async () => {
-		const result = await handleNvd("https://nvd.nist.gov/vuln/detail/cve-2021-44228", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("nvd");
-		expect(result?.content).toContain("CVE-2021-44228");
-	});
-});
-
-describe.skipIf(SKIP)("handleOsv", () => {
-	it("returns null for non-OSV URLs", async () => {
-		const result = await handleOsv("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for OSV homepage", async () => {
-		const result = await handleOsv("https://osv.dev/", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for OSV list URLs", async () => {
-		const result = await handleOsv("https://osv.dev/list", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches GHSA-jfh8-c2jp-5v3q (log4j RCE)", async () => {
-		const result = await handleOsv("https://osv.dev/vulnerability/GHSA-jfh8-c2jp-5v3q", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("osv");
-		expect(result?.content).toContain("GHSA-jfh8-c2jp-5v3q");
-		expect(result?.content).toContain("log4j");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches CVE-2021-44228 via OSV", async () => {
-		const result = await handleOsv("https://osv.dev/vulnerability/CVE-2021-44228", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("osv");
-		expect(result?.content).toContain("CVE-2021-44228");
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches PYSEC vulnerability", async () => {
-		// PYSEC-2021-19 is a well-known pillow vulnerability
-		const result = await handleOsv("https://osv.dev/vulnerability/PYSEC-2021-19", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("osv");
-		expect(result?.content).toContain("PYSEC-2021-19");
-		expect(result?.content).toContain("Affected Packages");
-	});
-
-	it("fetches RUSTSEC vulnerability", async () => {
-		// RUSTSEC-2021-0119 is a well-known actix-web vulnerability
-		const result = await handleOsv("https://osv.dev/vulnerability/RUSTSEC-2021-0119", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("osv");
-		expect(result?.content).toContain("RUSTSEC-2021-0119");
-	});
-});

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

@@ -1,192 +0,0 @@
-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-scrapers/social.test.ts

@@ -1,259 +0,0 @@
-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:");
-		}
-	});
-});