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

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

@@ -1,120 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleStackOverflow } from "./stackoverflow";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleStackOverflow", () => {
-	it("returns null for non-SE URLs", async () => {
-		const result = await handleStackOverflow("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for SE site without question path", async () => {
-		const result = await handleStackOverflow("https://stackoverflow.com/tags", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for SE user profile URLs", async () => {
-		const result = await handleStackOverflow("https://stackoverflow.com/users/1", 20);
-		expect(result).toBeNull();
-	});
-
-	// stackoverflow.com - "What is a NullPointerException" (classic, highly voted)
-	it("fetches stackoverflow.com question", async () => {
-		const result = await handleStackOverflow(
-			"https://stackoverflow.com/questions/218384/what-is-a-nullpointerexception-and-how-do-i-fix-it",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-		expect(result?.content).toContain("NullPointerException");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-		expect(result?.notes?.[0]).toContain("site=stackoverflow");
-	});
-
-	// unix.stackexchange.com - "Why does my shell script choke on whitespace" (classic)
-	it("fetches unix.stackexchange.com question", async () => {
-		const result = await handleStackOverflow(
-			"https://unix.stackexchange.com/questions/131766/why-does-my-shell-script-choke-on-whitespace-or-other-special-characters",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-		expect(result?.content).toContain("whitespace");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.notes?.[0]).toContain("site=unix");
-	});
-
-	// superuser.com - "What are PATH and other environment variables" (stable)
-	it("fetches superuser.com question", async () => {
-		const result = await handleStackOverflow(
-			"https://superuser.com/questions/284342/what-are-path-and-other-environment-variables-and-how-can-i-set-or-use-them",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-		expect(result?.content).toContain("PATH");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.notes?.[0]).toContain("site=superuser");
-	});
-
-	// askubuntu.com - "What is the difference between apt and apt-get" (iconic)
-	it("fetches askubuntu.com question", async () => {
-		const result = await handleStackOverflow(
-			"https://askubuntu.com/questions/445384/what-is-the-difference-between-apt-and-apt-get",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-		expect(result?.content).toContain("apt");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.notes?.[0]).toContain("site=askubuntu");
-	});
-
-	// serverfault.com - "What is a reverse proxy" (stable sysadmin topic)
-	it("fetches serverfault.com question", async () => {
-		const result = await handleStackOverflow(
-			"https://serverfault.com/questions/127021/what-is-the-difference-between-a-proxy-and-a-reverse-proxy",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-		expect(result?.content).toMatch(/proxy/i);
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.notes?.[0]).toContain("site=serverfault");
-	});
-
-	// Test with www. prefix
-	it("handles www.stackoverflow.com URLs", async () => {
-		const result = await handleStackOverflow(
-			"https://www.stackoverflow.com/questions/218384/what-is-a-nullpointerexception",
-			20,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("stackexchange");
-	});
-
-	// Verify response structure
-	it("returns complete response structure", async () => {
-		const result = await handleStackOverflow("https://stackoverflow.com/questions/218384", 20);
-		expect(result).not.toBeNull();
-		expect(result).toHaveProperty("url");
-		expect(result).toHaveProperty("finalUrl");
-		expect(result).toHaveProperty("contentType", "text/markdown");
-		expect(result).toHaveProperty("method", "stackexchange");
-		expect(result).toHaveProperty("content");
-		expect(result).toHaveProperty("fetchedAt");
-		expect(result).toHaveProperty("truncated");
-		expect(result).toHaveProperty("notes");
-		// Content should have question structure
-		expect(result?.content).toContain("# ");
-		expect(result?.content).toContain("Score:");
-		expect(result?.content).toContain("Tags:");
-	});
-});

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

@@ -1,122 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleCheatSh } from "./cheatsh";
-import { handleRfc } from "./rfc";
-import { handleTldr } from "./tldr";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleRfc", () => {
-	it("returns null for non-RFC URLs", async () => {
-		const result = await handleRfc("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for non-matching RFC domains", async () => {
-		const result = await handleRfc("https://www.ietf.org/about/", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches RFC 2616 (HTTP/1.1)", async () => {
-		const result = await handleRfc("https://www.rfc-editor.org/rfc/rfc2616", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("rfc");
-		expect(result?.content).toContain("HTTP/1.1");
-		expect(result?.content).toContain("Hypertext Transfer Protocol");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches RFC 2616 via datatracker URL", async () => {
-		const result = await handleRfc("https://datatracker.ietf.org/doc/rfc2616/", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("rfc");
-		expect(result?.content).toContain("HTTP/1.1");
-	});
-
-	it("fetches RFC 2616 via tools.ietf.org URL", async () => {
-		const result = await handleRfc("https://tools.ietf.org/html/rfc2616", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("rfc");
-		expect(result?.content).toContain("HTTP/1.1");
-	});
-
-	it("fetches RFC 793 (TCP)", async () => {
-		const result = await handleRfc("https://www.rfc-editor.org/rfc/rfc793", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("rfc");
-		expect(result?.content).toContain("Transmission Control Protocol");
-	});
-});
-
-describe.skipIf(SKIP)("handleCheatSh", () => {
-	it("returns null for non-cheat.sh URLs", async () => {
-		const result = await handleCheatSh("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for empty topic", async () => {
-		const result = await handleCheatSh("https://cheat.sh/", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches curl cheatsheet", async () => {
-		const result = await handleCheatSh("https://cheat.sh/curl", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("cheat.sh");
-		expect(result?.content).toContain("curl");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches tar cheatsheet", async () => {
-		const result = await handleCheatSh("https://cheat.sh/tar", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("cheat.sh");
-		expect(result?.content).toContain("tar");
-	});
-
-	it("fetches cheatsheet via cht.sh alias", async () => {
-		const result = await handleCheatSh("https://cht.sh/curl", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("cheat.sh");
-		expect(result?.content).toContain("curl");
-	});
-});
-
-describe.skipIf(SKIP)("handleTldr", () => {
-	it("returns null for non-tldr URLs", async () => {
-		const result = await handleTldr("https://example.com", 20);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for nested paths", async () => {
-		const result = await handleTldr("https://tldr.sh/nested/path", 20);
-		expect(result).toBeNull();
-	});
-
-	it("fetches git tldr page", async () => {
-		const result = await handleTldr("https://tldr.sh/git", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("tldr");
-		expect(result?.content).toContain("git");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(result?.truncated).toBeDefined();
-	});
-
-	it("fetches curl tldr page", async () => {
-		const result = await handleTldr("https://tldr.sh/curl", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("tldr");
-		expect(result?.content).toContain("curl");
-	});
-
-	it("fetches via tldr.ostera.io alias", async () => {
-		const result = await handleTldr("https://tldr.ostera.io/git", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("tldr");
-		expect(result?.content).toContain("git");
-	});
-});

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

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleWikipedia } from "./wikipedia";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleWikipedia", () => {
-	it("returns null for non-Wikipedia URLs", async () => {
-		const result = await handleWikipedia("https://example.com", 10);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for Wikipedia URLs without /wiki/ path", async () => {
-		const result = await handleWikipedia("https://en.wikipedia.org/", 10);
-		expect(result).toBeNull();
-	});
-
-	it("fetches a known article with full metadata", async () => {
-		// "Computer" is a stable, well-established article
-		const result = await handleWikipedia("https://en.wikipedia.org/wiki/Computer", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikipedia");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.content).toContain("Computer");
-		expect(result?.url).toBe("https://en.wikipedia.org/wiki/Computer");
-		expect(result?.finalUrl).toBe("https://en.wikipedia.org/wiki/Computer");
-		expect(result?.truncated).toBe(false);
-		expect(result?.notes).toContain("Fetched via Wikipedia API");
-		expect(result?.fetchedAt).toBeDefined();
-		// Should be a valid ISO timestamp
-		expect(() => new Date(result?.fetchedAt ?? "")).not.toThrow();
-		// The handler should filter out References and External links sections
-		const content = result?.content ?? "";
-		const hasReferencesHeading = /^## References$/m.test(content);
-		const hasExternalLinksHeading = /^## External links$/m.test(content);
-		// At least one of these should be filtered out
-		expect(hasReferencesHeading || hasExternalLinksHeading).toBe(false);
-	});
-
-	it("handles different language wikis", async () => {
-		// German Wikipedia article for "Computer"
-		const result = await handleWikipedia("https://de.wikipedia.org/wiki/Computer", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikipedia");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.content).toContain("Computer");
-	});
-
-	it("handles article with special characters in title", async () => {
-		// Article with special characters: "C++"
-		const result = await handleWikipedia("https://en.wikipedia.org/wiki/C%2B%2B", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikipedia");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.content).toMatch(/C\+\+/);
-	});
-
-	it("handles article with spaces and parentheses in title", async () => {
-		// Artificial intelligence uses underscores for spaces
-		const result = await handleWikipedia("https://en.wikipedia.org/wiki/Artificial_intelligence", 20);
-		expect(result).not.toBeNull();
-		expect(result?.method).toBe("wikipedia");
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.content).toMatch(/[Aa]rtificial intelligence/);
-	});
-
-	it("handles non-existent articles gracefully", async () => {
-		const result = await handleWikipedia(
-			"https://en.wikipedia.org/wiki/ThisArticleDefinitelyDoesNotExist123456789",
-			20,
-		);
-		expect(result).toBeNull();
-	});
-});

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

@@ -1,198 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { handleYouTube } from "./youtube";
-
-const SKIP = !process.env.WEB_FETCH_INTEGRATION;
-
-describe.skipIf(SKIP)("handleYouTube", () => {
-	it("returns null for non-YouTube URLs", async () => {
-		const result = await handleYouTube("https://example.com", 10);
-		expect(result).toBeNull();
-	});
-
-	it("returns null for invalid YouTube URLs", async () => {
-		const result = await handleYouTube("https://youtube.com/invalid", 10);
-		expect(result).toBeNull();
-	});
-
-	it("handles youtube.com/watch?v= format", async () => {
-		// Use Rick Astley's "Never Gonna Give You Up" - a stable, well-known video
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.contentType).toBe("text/markdown");
-		expect(result?.content).toContain("Video ID");
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("handles youtu.be/ short format", async () => {
-		const result = await handleYouTube("https://youtu.be/dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("handles youtube.com/shorts/ format", async () => {
-		// Use a stable YouTube Shorts video
-		const result = await handleYouTube("https://www.youtube.com/shorts/jNQXAC9IVRw", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.content).toContain("jNQXAC9IVRw");
-	}, 30000);
-
-	it("handles youtube.com/embed/ format", async () => {
-		const result = await handleYouTube("https://www.youtube.com/embed/dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("handles youtube.com/v/ format", async () => {
-		const result = await handleYouTube("https://www.youtube.com/v/dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("handles m.youtube.com mobile URLs", async () => {
-		const result = await handleYouTube("https://m.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.method).toMatch(/^youtube/);
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("extracts video metadata when yt-dlp is available", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-
-		// If yt-dlp is available, should have metadata
-		if (result?.method === "youtube") {
-			expect(result.content).toContain("Video ID");
-			expect(result.content).toContain("Channel");
-			// May have duration, views, upload date, etc.
-		}
-
-		// If yt-dlp is not available, should indicate that
-		if (result?.method === "youtube-no-ytdlp") {
-			expect(result.content).toContain("yt-dlp could not be installed");
-			expect(result.notes).toContain("yt-dlp installation failed");
-		}
-	}, 30000);
-
-	it("handles videos with transcripts gracefully", async () => {
-		// This video should have captions
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-
-		if (result?.method === "youtube") {
-			// Either has transcript or explicitly notes it's not available
-			const hasTranscript = result.content.includes("Transcript");
-			const noTranscriptNote = result.content.includes("No transcript available");
-			expect(hasTranscript || noTranscriptNote).toBe(true);
-		}
-	}, 30000);
-
-	it("handles videos without transcripts gracefully", async () => {
-		// Many music videos lack captions, but this is not guaranteed
-		// Just verify the handler doesn't crash and provides some info
-		const result = await handleYouTube("https://www.youtube.com/watch?v=kJQP7kiw5Fk", 30);
-		expect(result).not.toBeNull();
-
-		if (result?.method === "youtube") {
-			// Should still have basic metadata
-			expect(result.content).toContain("Video ID");
-		}
-	}, 30000);
-
-	it("returns appropriate response when yt-dlp is not available", async () => {
-		// We can't force yt-dlp to be unavailable in tests, but we can verify
-		// the return structure matches expectations for both cases
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-
-		// Should have one of these two methods
-		expect(["youtube", "youtube-no-ytdlp"]).toContain(result!.method);
-
-		// Both should have required fields
-		expect(result?.url).toBe("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
-		expect(result?.finalUrl).toContain("youtube.com");
-		expect(result?.fetchedAt).toBeTruthy();
-		expect(typeof result?.truncated).toBe("boolean");
-		expect(Array.isArray(result?.notes)).toBe(true);
-	}, 30000);
-
-	it("normalizes video URLs to canonical format", async () => {
-		// Different input formats should normalize to same canonical URL
-		const result = await handleYouTube("https://youtu.be/dQw4w9WgXcQ", 30);
-		expect(result).not.toBeNull();
-		expect(result?.finalUrl).toBe("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
-	}, 30000);
-
-	it("handles playlist URLs by extracting video ID", async () => {
-		const result = await handleYouTube(
-			"https://www.youtube.com/watch?v=dQw4w9WgXcQ&list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf",
-			30,
-		);
-		expect(result).not.toBeNull();
-		expect(result?.content).toContain("dQw4w9WgXcQ");
-	}, 30000);
-
-	it("includes subtitle source information when available", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		if (result?.method === "youtube") {
-			// If transcript is present, should note the source
-			const hasManualNote = result.notes.includes("Using manual subtitles");
-			const hasAutoNote = result.notes.includes("Using auto-generated captions");
-			const hasNoSubsNote = result.notes.includes("No subtitles/captions available");
-
-			// Should have exactly one of these
-			const noteCount = [hasManualNote, hasAutoNote, hasNoSubsNote].filter(Boolean).length;
-			expect(noteCount).toBeGreaterThanOrEqual(1);
-		}
-	}, 30000);
-
-	it("formats duration in human readable format", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		if (result?.method === "youtube" && result.content.includes("Duration")) {
-			// Should have duration in M:SS or H:MM:SS format
-			expect(result.content).toMatch(/Duration.*\d+:\d{2}/);
-		}
-	}, 30000);
-
-	it("formats view count in readable format", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		if (result?.method === "youtube" && result.content.includes("Views")) {
-			// Should have views formatted (e.g., 1.5B, 100M, 10.5K)
-			expect(result.content).toMatch(/Views.*\d+(\.\d+)?[KM]?/);
-		}
-	}, 30000);
-
-	it("includes upload date when available", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		if (result?.method === "youtube" && result.content.includes("Uploaded")) {
-			// Should have date in YYYY-MM-DD format
-			expect(result.content).toMatch(/Uploaded.*\d{4}-\d{2}-\d{2}/);
-		}
-	}, 30000);
-
-	it("truncates long descriptions", async () => {
-		const result = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		if (result?.method === "youtube" && result.content.includes("Description")) {
-			// Description section should exist
-			expect(result.content).toContain("## Description");
-		}
-	}, 30000);
-
-	it("handles www prefix variations", async () => {
-		const withWww = await handleYouTube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 30);
-		const withoutWww = await handleYouTube("https://youtube.com/watch?v=dQw4w9WgXcQ", 30);
-
-		expect(withWww).not.toBeNull();
-		expect(withoutWww).not.toBeNull();
-		expect(withWww?.finalUrl).toBe(withoutWww?.finalUrl);
-	}, 30000);
-});

package/src/discovery/helpers.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseFrontmatter } from "../core/frontmatter";
-
-describe("parseFrontmatter", () => {
-	const parse = (content: string) => parseFrontmatter(content, { source: "tests:frontmatter", level: "off" });
-
-	test("parses simple key-value pairs", () => {
-		const content = `---
-name: test
-enabled: true
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({ name: "test", enabled: true });
-		expect(result.body).toBe("Body content");
-	});
-
-	test("parses YAML list syntax", () => {
-		const content = `---
-tags:
-  - javascript
-  - typescript
-  - react
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({
-			tags: ["javascript", "typescript", "react"],
-		});
-		expect(result.body).toBe("Body content");
-	});
-
-	test("parses multi-line string values", () => {
-		const content = `---
-description: |
-  This is a multi-line
-  description block
-  with several lines
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({
-			description: "This is a multi-line\ndescription block\nwith several lines\n",
-		});
-		expect(result.body).toBe("Body content");
-	});
-
-	test("parses nested objects", () => {
-		const content = `---
-config:
-  server:
-    port: 3000
-    host: localhost
-  database:
-    name: mydb
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({
-			config: {
-				server: { port: 3000, host: "localhost" },
-				database: { name: "mydb" },
-			},
-		});
-		expect(result.body).toBe("Body content");
-	});
-
-	test("parses mixed complex YAML", () => {
-		const content = `---
-name: complex-test
-version: 1.0.0
-tags:
-  - prod
-  - critical
-metadata:
-  author: tester
-  created: 2024-01-01
-description: |
-  Multi-line description
-  with formatting
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({
-			name: "complex-test",
-			version: "1.0.0",
-			tags: ["prod", "critical"],
-			metadata: {
-				author: "tester",
-				created: "2024-01-01",
-			},
-			description: "Multi-line description\nwith formatting\n",
-		});
-		expect(result.body).toBe("Body content");
-	});
-
-	test("handles missing frontmatter", () => {
-		const content = "Just body content";
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({});
-		expect(result.body).toBe("Just body content");
-	});
-
-	test("handles invalid YAML in frontmatter", () => {
-		const content = `---
-invalid: [unclosed array
----
-Body content`;
-
-		const result = parse(content);
-		// Simple fallback parser extracts key:value pairs it can parse
-		expect(result.frontmatter).toEqual({ invalid: "[unclosed array" });
-		// Body is still extracted even with invalid YAML
-		expect(result.body).toBe("Body content");
-	});
-
-	test("handles empty frontmatter", () => {
-		const content = `---
----
-Body content`;
-
-		const result = parse(content);
-		expect(result.frontmatter).toEqual({});
-		expect(result.body).toBe("Body content");
-	});
-});