@gajae-code/coding-agent 0.1.1

package/src/web/scrapers/bluesky.ts

@@ -0,0 +1,262 @@
+import { tryParseJson } from "@gajae-code/utils";
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, formatNumber, loadPage } from "./types";
+
+const API_BASE = "https://public.api.bsky.app/xrpc";
+
+interface BlueskyProfile {
+	did: string;
+	handle: string;
+	displayName?: string;
+	description?: string;
+	avatar?: string;
+	followersCount?: number;
+	followsCount?: number;
+	postsCount?: number;
+	createdAt?: string;
+}
+
+interface BlueskyPost {
+	uri: string;
+	cid: string;
+	author: BlueskyProfile;
+	record: {
+		text: string;
+		createdAt: string;
+		embed?: {
+			$type: string;
+			external?: { uri: string; title?: string; description?: string };
+			images?: Array<{ alt?: string; image: unknown }>;
+			record?: { uri: string };
+		};
+		facets?: Array<{
+			features: Array<{ $type: string; uri?: string; tag?: string; did?: string }>;
+			index: { byteStart: number; byteEnd: number };
+		}>;
+	};
+	likeCount?: number;
+	repostCount?: number;
+	replyCount?: number;
+	quoteCount?: number;
+	embed?: {
+		$type: string;
+		external?: { uri: string; title?: string; description?: string };
+		images?: Array<{ alt?: string; fullsize?: string; thumb?: string }>;
+		record?: { uri: string; value?: { text?: string }; author?: BlueskyProfile };
+	};
+}
+
+interface ThreadViewPost {
+	post: BlueskyPost;
+	parent?: ThreadViewPost | { $type: string };
+	replies?: Array<ThreadViewPost | { $type: string }>;
+}
+
+/**
+ * Resolve a handle to DID using the profile API
+ */
+async function resolveHandle(handle: string, timeout: number, signal?: AbortSignal): Promise<string | null> {
+	const url = `${API_BASE}/app.bsky.actor.getProfile?actor=${encodeURIComponent(handle)}`;
+	const result = await loadPage(url, {
+		timeout,
+		headers: { Accept: "application/json" },
+		signal,
+	});
+
+	if (!result.ok) return null;
+
+	const data = tryParseJson<BlueskyProfile>(result.content);
+	if (!data) return null;
+	return data.did;
+}
+
+/**
+ * Format a post as markdown
+ */
+function formatPost(post: BlueskyPost, isQuote = false): string {
+	const author = post.author;
+	const name = author.displayName || author.handle;
+	const handle = `@${author.handle}`;
+	const date = new Date(post.record.createdAt).toLocaleString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+
+	let md = "";
+
+	if (isQuote) {
+		md += `> **${name}** (${handle}) - ${date}\n>\n`;
+		md += post.record.text
+			.split("\n")
+			.map(line => `> ${line}`)
+			.join("\n");
+		md += "\n";
+	} else {
+		md += `**${name}** (${handle})\n`;
+		md += `*${date}*\n\n`;
+		md += `${post.record.text}\n`;
+	}
+
+	// Handle embeds
+	const embed = post.embed;
+	if (embed) {
+		if (embed.$type === "app.bsky.embed.external#view" && embed.external) {
+			const ext = embed.external;
+			md += `\n📎 [${ext.title || ext.uri}](${ext.uri})`;
+			if (ext.description) md += `\n*${ext.description}*`;
+			md += "\n";
+		} else if (embed.$type === "app.bsky.embed.images#view" && embed.images) {
+			md += `\n🖼️ ${embed.images.length} image(s)`;
+			for (const img of embed.images) {
+				if (img.alt) md += `\n- Alt: "${img.alt}"`;
+			}
+			md += "\n";
+		} else if (
+			(embed.$type === "app.bsky.embed.record#view" || embed.$type === "app.bsky.embed.recordWithMedia#view") &&
+			embed.record
+		) {
+			const rec = embed.record;
+			if (rec.value?.text && rec.author) {
+				md += "\n**Quoted post:**\n";
+				md += `> **${rec.author.displayName || rec.author.handle}** (@${rec.author.handle})\n`;
+				md += rec.value.text
+					.split("\n")
+					.map(line => `> ${line}`)
+					.join("\n");
+				md += "\n";
+			}
+		}
+	}
+
+	// Stats
+	if (!isQuote) {
+		const stats: string[] = [];
+		if (post.likeCount) stats.push(`❤️ ${formatNumber(post.likeCount)}`);
+		if (post.repostCount) stats.push(`🔁 ${formatNumber(post.repostCount)}`);
+		if (post.replyCount) stats.push(`💬 ${formatNumber(post.replyCount)}`);
+		if (post.quoteCount) stats.push(`📝 ${formatNumber(post.quoteCount)}`);
+		if (stats.length) md += `\n${stats.join(" • ")}\n`;
+	}
+
+	return md;
+}
+
+/**
+ * Handle Bluesky post URLs
+ */
+export const handleBluesky: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!["bsky.app", "www.bsky.app"].includes(parsed.hostname)) {
+			return null;
+		}
+
+		const fetchedAt = new Date().toISOString();
+		const pathParts = parsed.pathname.split("/").filter(Boolean);
+
+		// /profile/{handle}
+		if (pathParts[0] === "profile" && pathParts[1]) {
+			const handle = pathParts[1];
+
+			// /profile/{handle}/post/{rkey}
+			if (pathParts[2] === "post" && pathParts[3]) {
+				const rkey = pathParts[3];
+
+				// First resolve handle to DID
+				const did = await resolveHandle(handle, timeout, signal);
+				if (!did) return null;
+
+				// Construct AT URI and fetch thread
+				const atUri = `at://${did}/app.bsky.feed.post/${rkey}`;
+				const threadUrl = `${API_BASE}/app.bsky.feed.getPostThread?uri=${encodeURIComponent(atUri)}&depth=6&parentHeight=3`;
+
+				const result = await loadPage(threadUrl, {
+					timeout,
+					headers: { Accept: "application/json" },
+					signal,
+				});
+
+				if (!result.ok) return null;
+
+				const data = JSON.parse(result.content) as { thread: ThreadViewPost };
+				const thread = data.thread;
+
+				if (!thread.post) return null;
+
+				let md = `# Bluesky Post\n\n`;
+
+				// Show parent context if exists
+				if (thread.parent && "post" in thread.parent) {
+					md += "**Replying to:**\n";
+					md += formatPost(thread.parent.post, true);
+					md += "\n---\n\n";
+				}
+
+				// Main post
+				md += formatPost(thread.post);
+
+				// Show replies
+				if (thread.replies?.length) {
+					md += "\n---\n\n## Replies\n\n";
+					let replyCount = 0;
+					for (const reply of thread.replies) {
+						if (replyCount >= 10) break;
+						if ("post" in reply) {
+							md += formatPost(reply.post);
+							md += "\n---\n\n";
+							replyCount++;
+						}
+					}
+				}
+
+				return buildResult(md, { url, method: "bluesky-api", fetchedAt, notes: [`AT URI: ${atUri}`] });
+			}
+
+			// Profile only
+			const profileUrl = `${API_BASE}/app.bsky.actor.getProfile?actor=${encodeURIComponent(handle)}`;
+			const result = await loadPage(profileUrl, {
+				timeout,
+				headers: { Accept: "application/json" },
+				signal,
+			});
+
+			if (!result.ok) return null;
+
+			const profile = JSON.parse(result.content) as BlueskyProfile;
+
+			let md = `# ${profile.displayName || profile.handle}\n\n`;
+			md += `**@${profile.handle}**\n\n`;
+
+			if (profile.description) {
+				md += `${profile.description}\n\n`;
+			}
+
+			md += "---\n\n";
+			md += `- **Followers:** ${formatNumber(profile.followersCount || 0)}\n`;
+			md += `- **Following:** ${formatNumber(profile.followsCount || 0)}\n`;
+			md += `- **Posts:** ${formatNumber(profile.postsCount || 0)}\n`;
+
+			if (profile.createdAt) {
+				const joined = new Date(profile.createdAt).toLocaleDateString("en-US", {
+					year: "numeric",
+					month: "long",
+					day: "numeric",
+				});
+				md += `- **Joined:** ${joined}\n`;
+			}
+
+			md += `\n**DID:** \`${profile.did}\`\n`;
+
+			return buildResult(md, { url, method: "bluesky-api", fetchedAt, notes: ["Fetched via AT Protocol API"] });
+		}
+	} catch {}
+
+	return null;
+};

package/src/web/scrapers/brew.ts

@@ -0,0 +1,172 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, formatNumber, loadPage } from "./types";
+
+interface BrewFormula {
+	name: string;
+	full_name?: string;
+	desc?: string;
+	homepage?: string;
+	license?: string;
+	versions?: {
+		stable?: string;
+		head?: string;
+		bottle?: boolean;
+	};
+	dependencies?: string[];
+	build_dependencies?: string[];
+	optional_dependencies?: string[];
+	conflicts_with?: string[];
+	caveats?: string;
+	analytics?: {
+		install?: {
+			"30d"?: Record<string, number>;
+			"90d"?: Record<string, number>;
+			"365d"?: Record<string, number>;
+		};
+	};
+}
+
+interface BrewCask {
+	token: string;
+	name?: string[];
+	desc?: string;
+	homepage?: string;
+	version?: string;
+	sha256?: string;
+	caveats?: string;
+	depends_on?: {
+		macos?: Record<string, string[]>;
+	};
+	conflicts_with?: {
+		cask?: string[];
+	};
+	analytics?: {
+		install?: {
+			"30d"?: Record<string, number>;
+			"90d"?: Record<string, number>;
+			"365d"?: Record<string, number>;
+		};
+	};
+}
+
+function getInstallCount(analytics?: { install?: { "30d"?: Record<string, number> } }): number | null {
+	if (!analytics?.install?.["30d"]) return null;
+	const counts = Object.values(analytics.install["30d"]);
+	return counts.reduce((sum, n) => sum + n, 0);
+}
+
+/**
+ * Handle Homebrew formulae and cask URLs via API
+ */
+export const handleBrew: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "formulae.brew.sh") return null;
+
+		const formulaMatch = parsed.pathname.match(/^\/formula\/([^/]+)\/?$/);
+		const caskMatch = parsed.pathname.match(/^\/cask\/([^/]+)\/?$/);
+
+		if (!formulaMatch && !caskMatch) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const isFormula = Boolean(formulaMatch);
+		const name = decodeURIComponent(isFormula ? formulaMatch![1] : caskMatch![1]);
+
+		const apiUrl = isFormula
+			? `https://formulae.brew.sh/api/formula/${encodeURIComponent(name)}.json`
+			: `https://formulae.brew.sh/api/cask/${encodeURIComponent(name)}.json`;
+
+		const result = await loadPage(apiUrl, { timeout, signal });
+		if (!result.ok) return null;
+
+		let md: string;
+
+		if (isFormula) {
+			const formula: BrewFormula = JSON.parse(result.content);
+
+			md = `# ${formula.full_name || formula.name}\n\n`;
+			if (formula.desc) md += `${formula.desc}\n\n`;
+
+			md += `**Version:** ${formula.versions?.stable || "unknown"}`;
+			if (formula.license) md += ` · **License:** ${formula.license}`;
+			md += "\n";
+
+			const installs = getInstallCount(formula.analytics);
+			if (installs !== null) {
+				md += `**Installs (30d):** ${formatNumber(installs)}\n`;
+			}
+			md += "\n";
+
+			md += `\`\`\`bash\nbrew install ${formula.name}\n\`\`\`\n\n`;
+
+			if (formula.homepage) md += `**Homepage:** ${formula.homepage}\n`;
+
+			if (formula.dependencies?.length) {
+				md += `\n## Dependencies\n\n`;
+				for (const dep of formula.dependencies) {
+					md += `- ${dep}\n`;
+				}
+			}
+
+			if (formula.build_dependencies?.length) {
+				md += `\n## Build Dependencies\n\n`;
+				for (const dep of formula.build_dependencies) {
+					md += `- ${dep}\n`;
+				}
+			}
+
+			if (formula.conflicts_with?.length) {
+				md += `\n## Conflicts With\n\n`;
+				for (const conflict of formula.conflicts_with) {
+					md += `- ${conflict}\n`;
+				}
+			}
+
+			if (formula.caveats) {
+				md += `\n## Caveats\n\n${formula.caveats}\n`;
+			}
+		} else {
+			const cask: BrewCask = JSON.parse(result.content);
+
+			const displayName = cask.name?.[0] || cask.token;
+			md = `# ${displayName}\n\n`;
+			if (cask.desc) md += `${cask.desc}\n\n`;
+
+			md += `**Version:** ${cask.version || "unknown"}\n`;
+
+			const installs = getInstallCount(cask.analytics);
+			if (installs !== null) {
+				md += `**Installs (30d):** ${formatNumber(installs)}\n`;
+			}
+			md += "\n";
+
+			md += `\`\`\`bash\nbrew install --cask ${cask.token}\n\`\`\`\n\n`;
+
+			if (cask.homepage) md += `**Homepage:** ${cask.homepage}\n`;
+
+			if (cask.conflicts_with?.cask?.length) {
+				md += `\n## Conflicts With\n\n`;
+				for (const conflict of cask.conflicts_with.cask) {
+					md += `- ${conflict}\n`;
+				}
+			}
+
+			if (cask.caveats) {
+				md += `\n## Caveats\n\n${cask.caveats}\n`;
+			}
+		}
+
+		return buildResult(md, {
+			url,
+			method: "brew",
+			fetchedAt,
+			notes: [`Fetched via Homebrew ${isFormula ? "formula" : "cask"} API`],
+		});
+	} catch {}
+
+	return null;
+};

package/src/web/scrapers/cheatsh.ts

@@ -0,0 +1,68 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, loadPage } from "./types";
+
+/**
+ * Handle cheat.sh / cht.sh URLs for command cheatsheets
+ *
+ * API: Plain text at https://cheat.sh/{topic}?T (T flag removes ANSI colors)
+ * Supports: commands, language/topic queries (e.g., python/list, go/slice)
+ */
+export const handleCheatSh: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "cheat.sh" && parsed.hostname !== "cht.sh") return null;
+
+		// Extract topic from path (everything after /)
+		const topic = parsed.pathname.slice(1);
+		if (!topic || topic === "" || topic === "/") return null;
+
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from cheat.sh API with ?T to disable ANSI colors
+		const apiUrl = `https://cheat.sh/${encodeURIComponent(topic)}?T`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			signal,
+			headers: {
+				Accept: "text/plain",
+			},
+		});
+
+		if (!result.ok || !result.content.trim()) return null;
+
+		// Format the cheatsheet as markdown
+		const decodedTopic = decodeURIComponent(topic);
+		let md = `# cheat.sh/${decodedTopic}\n\n`;
+
+		// The content is already plain text, wrap in code block for readability
+		// Detect if it looks like code/commands vs prose
+		const content = result.content.trim();
+		const lines = content.split("\n");
+		const hasCodeIndicators = lines.some(
+			line =>
+				line.startsWith("$") ||
+				line.startsWith("#") ||
+				line.includes("()") ||
+				line.includes("=>") ||
+				/^\s*(if|for|while|def|func|fn|let|const|var)\b/.test(line),
+		);
+
+		if (hasCodeIndicators || decodedTopic.includes("/")) {
+			// Likely code examples - use code block
+			// Try to detect language from topic
+			const lang = decodedTopic.split("/")[0] || "bash";
+			md += `\`\`\`${lang}\n${content}\n\`\`\`\n`;
+		} else {
+			// Command cheatsheet - format as-is (already has good structure)
+			md += `\`\`\`\n${content}\n\`\`\`\n`;
+		}
+
+		return buildResult(md, { url, method: "cheat.sh", fetchedAt, notes: ["Fetched via cheat.sh"] });
+	} catch {}
+
+	return null;
+};

package/src/web/scrapers/chocolatey.ts

@@ -0,0 +1,196 @@
+import { tryParseJson } from "@gajae-code/utils";
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, formatIsoDate, formatNumber, loadPage } from "./types";
+
+interface NuGetODataEntry {
+	Id: string;
+	Version: string;
+	Title?: string;
+	Description?: string;
+	Summary?: string;
+	Authors?: string;
+	ProjectUrl?: string;
+	PackageSourceUrl?: string;
+	Tags?: string;
+	DownloadCount?: number;
+	VersionDownloadCount?: number;
+	Published?: string;
+	LicenseUrl?: string;
+	ReleaseNotes?: string;
+	Dependencies?: string;
+}
+
+interface NuGetODataResponse {
+	d?: {
+		results?: NuGetODataEntry[];
+	};
+}
+
+function extractXmlField(xml: string, fieldName: string): string | null {
+	const pattern = new RegExp(`<d:${fieldName}[^>]*>([\\s\\S]*?)</d:${fieldName}>`, "i");
+	const match = xml.match(pattern);
+	if (!match) return null;
+	return match[1].trim();
+}
+
+/**
+ * Handle Chocolatey package URLs via NuGet v2 OData API
+ */
+export const handleChocolatey: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.hostname.includes("chocolatey.org")) return null;
+
+		// Extract package name from /packages/{name} or /packages/{name}/{version}
+		const match = parsed.pathname.match(/^\/packages\/([^/]+)(?:\/([^/]+))?/);
+		if (!match) return null;
+
+		const packageName = decodeURIComponent(match[1]);
+		const specificVersion = match[2] ? decodeURIComponent(match[2]) : null;
+
+		const fetchedAt = new Date().toISOString();
+
+		// Build OData query - filter by Id and optionally version
+		let apiUrl = `https://community.chocolatey.org/api/v2/Packages()?$filter=Id%20eq%20'${encodeURIComponent(packageName)}'`;
+		if (specificVersion) {
+			apiUrl += `%20and%20Version%20eq%20'${encodeURIComponent(specificVersion)}'`;
+		} else {
+			// Get latest version by ordering and taking first
+			apiUrl += "&$orderby=Version%20desc&$top=1";
+		}
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			signal,
+			headers: {
+				Accept: "application/atom+xml, application/xml",
+			},
+		});
+
+		if (!result.ok) {
+			const fallback = `# ${packageName}\n\nChocolatey package metadata is currently unavailable.\n\n---\n**Install:** \`choco install ${packageName}\`\n`;
+			return buildResult(fallback, {
+				url,
+				method: "chocolatey",
+				fetchedAt,
+				notes: ["Chocolatey API request failed"],
+			});
+		}
+
+		let pkg = (() => {
+			const data = tryParseJson<NuGetODataResponse>(result.content);
+			return data?.d?.results?.[0] ?? null;
+		})();
+
+		if (!pkg) {
+			const xmlId = extractXmlField(result.content, "Id");
+			if (!xmlId) {
+				const fallback = `# ${packageName}\n\nChocolatey package metadata could not be parsed.\n\n---\n**Install:** \`choco install ${packageName}\`\n`;
+				return buildResult(fallback, {
+					url,
+					method: "chocolatey",
+					fetchedAt,
+					notes: ["Chocolatey API response parsing failed"],
+				});
+			}
+
+			pkg = {
+				Id: xmlId,
+				Version: extractXmlField(result.content, "Version") || "",
+				Title: extractXmlField(result.content, "Title") || undefined,
+				Description: extractXmlField(result.content, "Description") || undefined,
+				Summary: extractXmlField(result.content, "Summary") || undefined,
+				Authors: extractXmlField(result.content, "Authors") || undefined,
+				ProjectUrl: extractXmlField(result.content, "ProjectUrl") || undefined,
+				PackageSourceUrl: extractXmlField(result.content, "PackageSourceUrl") || undefined,
+				Tags: extractXmlField(result.content, "Tags") || undefined,
+				DownloadCount: (() => {
+					const value = extractXmlField(result.content, "DownloadCount");
+					return value ? Number.parseInt(value, 10) : undefined;
+				})(),
+				VersionDownloadCount: (() => {
+					const value = extractXmlField(result.content, "VersionDownloadCount");
+					return value ? Number.parseInt(value, 10) : undefined;
+				})(),
+				Published: extractXmlField(result.content, "Published") || undefined,
+				LicenseUrl: extractXmlField(result.content, "LicenseUrl") || undefined,
+				ReleaseNotes: extractXmlField(result.content, "ReleaseNotes") || undefined,
+				Dependencies: extractXmlField(result.content, "Dependencies") || undefined,
+			};
+		}
+
+		// Build markdown output
+		let md = `# ${pkg.Title || pkg.Id}\n\n`;
+
+		if (pkg.Summary) {
+			md += `${pkg.Summary}\n\n`;
+		} else if (pkg.Description) {
+			// Use first paragraph of description as summary
+			const firstPara = pkg.Description.split(/\n\n/)[0];
+			md += `${firstPara}\n\n`;
+		}
+
+		md += `**Version:** ${pkg.Version}`;
+		if (pkg.Authors) md += ` · **Authors:** ${pkg.Authors}`;
+		md += "\n";
+
+		if (pkg.DownloadCount !== undefined) {
+			md += `**Total Downloads:** ${formatNumber(pkg.DownloadCount)}`;
+			if (pkg.VersionDownloadCount !== undefined) {
+				md += ` · **Version Downloads:** ${formatNumber(pkg.VersionDownloadCount)}`;
+			}
+			md += "\n";
+		}
+
+		if (pkg.Published) {
+			const published = formatIsoDate(pkg.Published);
+			if (published) md += `**Published:** ${published}\n`;
+		}
+
+		md += "\n";
+
+		if (pkg.ProjectUrl) md += `**Project URL:** ${pkg.ProjectUrl}\n`;
+		if (pkg.PackageSourceUrl) md += `**Source:** ${pkg.PackageSourceUrl}\n`;
+		if (pkg.LicenseUrl) md += `**License:** ${pkg.LicenseUrl}\n`;
+
+		if (pkg.Tags) {
+			const tags = pkg.Tags.split(/\s+/).filter(t => t.length > 0);
+			if (tags.length > 0) {
+				md += `**Tags:** ${tags.join(", ")}\n`;
+			}
+		}
+
+		// Full description if different from summary
+		if (pkg.Description && pkg.Description !== pkg.Summary) {
+			md += `\n## Description\n\n${pkg.Description}\n`;
+		}
+
+		if (pkg.ReleaseNotes) {
+			md += `\n## Release Notes\n\n${pkg.ReleaseNotes}\n`;
+		}
+
+		if (pkg.Dependencies) {
+			// Dependencies format: "id:version|id:version"
+			const deps = pkg.Dependencies.split("|").filter(d => d.trim().length > 0);
+			if (deps.length > 0) {
+				md += `\n## Dependencies\n\n`;
+				for (const dep of deps) {
+					const [depId, depVersion] = dep.split(":");
+					if (depId) {
+						md += `- ${depId}${depVersion ? `: ${depVersion}` : ""}\n`;
+					}
+				}
+			}
+		}
+
+		md += `\n---\n**Install:** \`choco install ${packageName}\`\n`;
+
+		return buildResult(md, { url, method: "chocolatey", fetchedAt, notes: ["Fetched via Chocolatey NuGet API"] });
+	} catch {}
+
+	return null;
+};