skilld 0.7.0 → 0.8.1

package/dist/_chunks/npm.mjs

@@ -1,1821 +0,0 @@
-import { i as getCacheDir } from "./config.mjs";
-import { a as getDocOverride, i as getBlogPreset, n as yamlParseKV } from "./yaml.mjs";
-import { basename, dirname, join, resolve } from "pathe";
-import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync } from "node:fs";
-import { htmlToMarkdown } from "mdream";
-import { spawnSync } from "node:child_process";
-import { ofetch } from "ofetch";
-import { globby } from "globby";
-import pLimit from "p-limit";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Writable } from "node:stream";
-import { resolvePathSync } from "mlly";
-const BOT_USERS = new Set([
-	"renovate[bot]",
-	"dependabot[bot]",
-	"renovate-bot",
-	"dependabot",
-	"github-actions[bot]"
-]);
-const isoDate = (iso) => iso.split("T")[0];
-function buildFrontmatter(fields) {
-	const lines = ["---"];
-	for (const [k, v] of Object.entries(fields)) if (v !== void 0) lines.push(`${k}: ${typeof v === "string" && /[:"[\]]/.test(v) ? `"${v.replace(/"/g, "\\\"")}"` : v}`);
-	lines.push("---");
-	return lines.join("\n");
-}
-let _ghAvailable;
-function isGhAvailable() {
-	if (_ghAvailable !== void 0) return _ghAvailable;
-	const { status } = spawnSync("gh", ["auth", "status"], { stdio: "ignore" });
-	return _ghAvailable = status === 0;
-}
-const NOISE_LABELS = new Set([
-	"duplicate",
-	"stale",
-	"invalid",
-	"wontfix",
-	"won't fix",
-	"spam",
-	"off-topic",
-	"needs triage",
-	"triage"
-]);
-const FEATURE_LABELS = new Set([
-	"enhancement",
-	"feature",
-	"feature request",
-	"feature-request",
-	"proposal",
-	"rfc",
-	"idea",
-	"suggestion"
-]);
-const BUG_LABELS = new Set([
-	"bug",
-	"defect",
-	"regression",
-	"error",
-	"crash",
-	"fix",
-	"confirmed",
-	"verified"
-]);
-const QUESTION_LABELS = new Set([
-	"question",
-	"help wanted",
-	"support",
-	"usage",
-	"how-to",
-	"help",
-	"assistance"
-]);
-const DOCS_LABELS = new Set([
-	"documentation",
-	"docs",
-	"doc",
-	"typo"
-]);
-function classifyIssue(labels) {
-	const lower = labels.map((l) => l.toLowerCase());
-	if (lower.some((l) => BUG_LABELS.has(l))) return "bug";
-	if (lower.some((l) => QUESTION_LABELS.has(l))) return "question";
-	if (lower.some((l) => DOCS_LABELS.has(l))) return "docs";
-	if (lower.some((l) => FEATURE_LABELS.has(l))) return "feature";
-	return "other";
-}
-function isNoiseIssue(issue) {
-	if (issue.labels.map((l) => l.toLowerCase()).some((l) => NOISE_LABELS.has(l))) return true;
-	if (issue.title.startsWith("☂️") || issue.title.startsWith("[META]") || issue.title.startsWith("[Tracking]")) return true;
-	return false;
-}
-function bodyLimit(reactions) {
-	if (reactions >= 10) return 2e3;
-	if (reactions >= 5) return 1500;
-	return 800;
-}
-function fetchIssuesByState(owner, repo, state, count, releasedAt) {
-	const fetchCount = Math.min(count * 3, 100);
-	let datePart = "";
-	if (state === "closed") if (releasedAt) {
-		const date = new Date(releasedAt);
-		date.setMonth(date.getMonth() + 6);
-		datePart = `+closed:<=${isoDate(date.toISOString())}`;
-	} else datePart = `+closed:>${oneYearAgo()}`;
-	else if (releasedAt) {
-		const date = new Date(releasedAt);
-		date.setMonth(date.getMonth() + 6);
-		datePart = `+created:<=${isoDate(date.toISOString())}`;
-	}
-	const { stdout: result } = spawnSync("gh", [
-		"api",
-		`search/issues?q=${`repo:${owner}/${repo}+is:issue+is:${state}${datePart}`}&sort=reactions&order=desc&per_page=${fetchCount}`,
-		"-q",
-		".items[] | {number, title, state, labels: [.labels[]?.name], body, createdAt: .created_at, url: .html_url, reactions: .reactions[\"+1\"], comments: .comments, user: .user.login, userType: .user.type}"
-	], {
-		encoding: "utf-8",
-		maxBuffer: 10 * 1024 * 1024
-	});
-	if (!result) return [];
-	return result.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line)).filter((issue) => !BOT_USERS.has(issue.user) && issue.userType !== "Bot").filter((issue) => !isNoiseIssue(issue)).map(({ user: _, userType: __, ...issue }) => ({
-		...issue,
-		type: classifyIssue(issue.labels),
-		topComments: []
-	})).sort((a, b) => (a.type === "feature" ? 1 : 0) - (b.type === "feature" ? 1 : 0)).slice(0, count);
-}
-function oneYearAgo() {
-	const d = /* @__PURE__ */ new Date();
-	d.setFullYear(d.getFullYear() - 1);
-	return isoDate(d.toISOString());
-}
-function enrichWithComments(owner, repo, issues, topN = 10) {
-	const worth = issues.filter((i) => i.comments > 0 && (i.type === "bug" || i.type === "question" || i.reactions >= 3)).sort((a, b) => b.reactions - a.reactions).slice(0, topN);
-	if (worth.length === 0) return;
-	const query = `query($owner: String!, $repo: String!) { repository(owner: $owner, name: $repo) { ${worth.map((issue, i) => `i${i}: issue(number: ${issue.number}) { comments(first: 3) { nodes { body author { login } reactions { totalCount } } } }`).join(" ")} } }`;
-	try {
-		const { stdout: result } = spawnSync("gh", [
-			"api",
-			"graphql",
-			"-f",
-			`query=${query}`,
-			"-f",
-			`owner=${owner}`,
-			"-f",
-			`repo=${repo}`
-		], {
-			encoding: "utf-8",
-			maxBuffer: 10 * 1024 * 1024
-		});
-		if (!result) return;
-		const repo_ = JSON.parse(result)?.data?.repository;
-		if (!repo_) return;
-		for (let i = 0; i < worth.length; i++) {
-			const nodes = repo_[`i${i}`]?.comments?.nodes;
-			if (!Array.isArray(nodes)) continue;
-			worth[i].topComments = nodes.filter((c) => c.author && !BOT_USERS.has(c.author.login)).map((c) => ({
-				body: c.body || "",
-				author: c.author.login,
-				reactions: c.reactions?.totalCount || 0
-			}));
-		}
-	} catch {}
-}
-async function fetchGitHubIssues(owner, repo, limit = 30, releasedAt) {
-	if (!isGhAvailable()) return [];
-	const openCount = Math.ceil(limit * .75);
-	const closedCount = limit - openCount;
-	try {
-		const open = fetchIssuesByState(owner, repo, "open", openCount, releasedAt);
-		const closed = fetchIssuesByState(owner, repo, "closed", closedCount, releasedAt);
-		const all = [...open, ...closed];
-		enrichWithComments(owner, repo, all);
-		return all;
-	} catch {
-		return [];
-	}
-}
-function formatIssueAsMarkdown(issue) {
-	const limit = bodyLimit(issue.reactions);
-	const fmFields = {
-		number: issue.number,
-		title: issue.title,
-		type: issue.type,
-		state: issue.state,
-		created: isoDate(issue.createdAt),
-		url: issue.url,
-		reactions: issue.reactions,
-		comments: issue.comments
-	};
-	if (issue.labels.length > 0) fmFields.labels = `[${issue.labels.join(", ")}]`;
-	const lines = [
-		buildFrontmatter(fmFields),
-		"",
-		`# ${issue.title}`
-	];
-	if (issue.body) {
-		const body = issue.body.length > limit ? `${issue.body.slice(0, limit)}...` : issue.body;
-		lines.push("", body);
-	}
-	if (issue.topComments.length > 0) {
-		lines.push("", "---", "", "## Top Comments");
-		for (const c of issue.topComments) {
-			const reactions = c.reactions > 0 ? ` (+${c.reactions})` : "";
-			const commentBody = c.body.length > 600 ? `${c.body.slice(0, 600)}...` : c.body;
-			lines.push("", `**@${c.author}**${reactions}:`, "", commentBody);
-		}
-	}
-	return lines.join("\n");
-}
-function generateIssueIndex(issues) {
-	const byType = /* @__PURE__ */ new Map();
-	for (const issue of issues) {
-		const list = byType.get(issue.type) || [];
-		list.push(issue);
-		byType.set(issue.type, list);
-	}
-	const typeLabels = {
-		bug: "Bugs & Regressions",
-		question: "Questions & Usage Help",
-		docs: "Documentation",
-		feature: "Feature Requests",
-		other: "Other"
-	};
-	const typeOrder = [
-		"bug",
-		"question",
-		"docs",
-		"other",
-		"feature"
-	];
-	const sections = [
-		[
-			"---",
-			`total: ${issues.length}`,
-			`open: ${issues.filter((i) => i.state === "open").length}`,
-			`closed: ${issues.filter((i) => i.state !== "open").length}`,
-			"---"
-		].join("\n"),
-		"",
-		"# Issues Index",
-		""
-	];
-	for (const type of typeOrder) {
-		const group = byType.get(type);
-		if (!group?.length) continue;
-		sections.push(`## ${typeLabels[type]} (${group.length})`, "");
-		for (const issue of group) {
-			const reactions = issue.reactions > 0 ? ` (+${issue.reactions})` : "";
-			const state = issue.state === "open" ? "" : " [closed]";
-			const date = isoDate(issue.createdAt);
-			sections.push(`- [#${issue.number}](./issue-${issue.number}.md): ${issue.title}${reactions}${state} (${date})`);
-		}
-		sections.push("");
-	}
-	return sections.join("\n");
-}
-const $fetch = ofetch.create({
-	retry: 3,
-	retryDelay: 500,
-	timeout: 15e3,
-	headers: { "User-Agent": "skilld/1.0" }
-});
-async function fetchText(url) {
-	return $fetch(url, { responseType: "text" }).catch(() => null);
-}
-async function verifyUrl(url) {
-	const res = await $fetch.raw(url, { method: "HEAD" }).catch(() => null);
-	if (!res) return false;
-	return !(res.headers.get("content-type") || "").includes("text/html");
-}
-const USELESS_HOSTS = new Set([
-	"twitter.com",
-	"x.com",
-	"facebook.com",
-	"linkedin.com",
-	"youtube.com",
-	"instagram.com",
-	"npmjs.com",
-	"www.npmjs.com",
-	"yarnpkg.com"
-]);
-function isUselessDocsUrl(url) {
-	try {
-		const { hostname } = new URL(url);
-		return USELESS_HOSTS.has(hostname);
-	} catch {
-		return false;
-	}
-}
-function isGitHubRepoUrl(url) {
-	try {
-		const parsed = new URL(url);
-		return parsed.hostname === "github.com" || parsed.hostname === "www.github.com";
-	} catch {
-		return false;
-	}
-}
-function parseGitHubUrl(url) {
-	const match = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:[/#]|$)/);
-	if (!match) return null;
-	return {
-		owner: match[1],
-		repo: match[2]
-	};
-}
-function normalizeRepoUrl(url) {
-	return url.replace(/^git\+/, "").replace(/#.*$/, "").replace(/\.git$/, "").replace(/^git:\/\//, "https://").replace(/^ssh:\/\/git@github\.com/, "https://github.com").replace(/^git@github\.com:/, "https://github.com/");
-}
-function extractBranchHint(url) {
-	const hash = url.indexOf("#");
-	if (hash === -1) return void 0;
-	const fragment = url.slice(hash + 1);
-	if (!fragment || fragment === "readme") return void 0;
-	return fragment;
-}
-function parseSemver(version) {
-	const clean = version.replace(/^v/, "");
-	const match = clean.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
-	if (!match) return null;
-	return {
-		major: +match[1],
-		minor: match[2] ? +match[2] : 0,
-		patch: match[3] ? +match[3] : 0,
-		raw: clean
-	};
-}
-function extractVersion(tag, packageName) {
-	if (packageName) {
-		const atMatch = tag.match(new RegExp(`^${escapeRegex(packageName)}@(.+)$`));
-		if (atMatch) return atMatch[1];
-		const dashMatch = tag.match(new RegExp(`^${escapeRegex(packageName)}-v?(.+)$`));
-		if (dashMatch) return dashMatch[1];
-	}
-	return tag.replace(/^v/, "");
-}
-function escapeRegex(str) {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function tagMatchesPackage(tag, packageName) {
-	return tag.startsWith(`${packageName}@`) || tag.startsWith(`${packageName}-v`) || tag.startsWith(`${packageName}-`);
-}
-function compareSemver(a, b) {
-	if (a.major !== b.major) return a.major - b.major;
-	if (a.minor !== b.minor) return a.minor - b.minor;
-	return a.patch - b.patch;
-}
-function fetchReleasesViaGh(owner, repo) {
-	try {
-		const { stdout: json } = spawnSync("gh", [
-			"api",
-			`repos/${owner}/${repo}/releases?per_page=100`,
-			"--jq",
-			"[.[] | {id: .id, tag: .tag_name, name: .name, prerelease: .prerelease, createdAt: .created_at, publishedAt: .published_at, markdown: .body}]"
-		], {
-			encoding: "utf-8",
-			timeout: 15e3,
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		});
-		if (!json) return [];
-		return JSON.parse(json);
-	} catch {
-		return [];
-	}
-}
-async function fetchReleasesViaUngh(owner, repo) {
-	return (await $fetch(`https://ungh.cc/repos/${owner}/${repo}/releases`, { signal: AbortSignal.timeout(15e3) }).catch(() => null))?.releases ?? [];
-}
-async function fetchAllReleases(owner, repo) {
-	if (isGhAvailable()) {
-		const releases = fetchReleasesViaGh(owner, repo);
-		if (releases.length > 0) return releases;
-	}
-	return fetchReleasesViaUngh(owner, repo);
-}
-function selectReleases(releases, packageName, installedVersion) {
-	const hasMonorepoTags = packageName && releases.some((r) => tagMatchesPackage(r.tag, packageName));
-	const installedSv = installedVersion ? parseSemver(installedVersion) : null;
-	return releases.filter((r) => {
-		if (r.prerelease) return false;
-		const ver = extractVersion(r.tag, hasMonorepoTags ? packageName : void 0);
-		if (!ver) return false;
-		const sv = parseSemver(ver);
-		if (!sv) return false;
-		if (hasMonorepoTags && packageName && !tagMatchesPackage(r.tag, packageName)) return false;
-		if (installedSv && compareSemver(sv, installedSv) > 0) return false;
-		return true;
-	}).sort((a, b) => {
-		const verA = extractVersion(a.tag, hasMonorepoTags ? packageName : void 0);
-		const verB = extractVersion(b.tag, hasMonorepoTags ? packageName : void 0);
-		if (!verA || !verB) return 0;
-		return compareSemver(parseSemver(verB), parseSemver(verA));
-	}).slice(0, 20);
-}
-function formatRelease(release, packageName) {
-	const date = isoDate(release.publishedAt || release.createdAt);
-	const version = extractVersion(release.tag, packageName) || release.tag;
-	const fm = [
-		"---",
-		`tag: ${release.tag}`,
-		`version: ${version}`,
-		`published: ${date}`
-	];
-	if (release.name && release.name !== release.tag) fm.push(`name: "${release.name.replace(/"/g, "\\\"")}"`);
-	fm.push("---");
-	return `${fm.join("\n")}\n\n# ${release.name || release.tag}\n\n${release.markdown}`;
-}
-function generateReleaseIndex(releasesOrOpts, packageName) {
-	const opts = Array.isArray(releasesOrOpts) ? {
-		releases: releasesOrOpts,
-		packageName
-	} : releasesOrOpts;
-	const { releases, blogReleases, hasChangelog } = opts;
-	const pkg = opts.packageName;
-	const lines = [
-		[
-			"---",
-			`total: ${releases.length + (blogReleases?.length ?? 0)}`,
-			`latest: ${releases[0]?.tag || "unknown"}`,
-			"---"
-		].join("\n"),
-		"",
-		"# Releases Index",
-		""
-	];
-	if (blogReleases && blogReleases.length > 0) {
-		lines.push("## Blog Releases", "");
-		for (const b of blogReleases) lines.push(`- [${b.version}](./blog-${b.version}.md): ${b.title} (${b.date})`);
-		lines.push("");
-	}
-	if (releases.length > 0) {
-		if (blogReleases && blogReleases.length > 0) lines.push("## Release Notes", "");
-		for (const r of releases) {
-			const date = isoDate(r.publishedAt || r.createdAt);
-			const filename = r.tag.includes("@") || r.tag.startsWith("v") ? r.tag : `v${r.tag}`;
-			const sv = parseSemver(extractVersion(r.tag, pkg) || r.tag);
-			const label = sv?.patch === 0 && sv.minor === 0 ? " **[MAJOR]**" : sv?.patch === 0 ? " **[MINOR]**" : "";
-			lines.push(`- [${r.tag}](./${filename}.md): ${r.name || r.tag} (${date})${label}`);
-		}
-		lines.push("");
-	}
-	if (hasChangelog) {
-		lines.push("## Changelog", "");
-		lines.push("- [CHANGELOG.md](./CHANGELOG.md)");
-		lines.push("");
-	}
-	return lines.join("\n");
-}
-function isChangelogRedirectPattern(releases) {
-	const sample = releases.slice(0, 3);
-	if (sample.length === 0) return false;
-	return sample.every((r) => {
-		const body = (r.markdown || "").trim();
-		return body.length < 500 && /changelog\.md/i.test(body);
-	});
-}
-async function fetchChangelog(owner, repo, ref) {
-	for (const filename of [
-		"CHANGELOG.md",
-		"changelog.md",
-		"CHANGES.md"
-	]) {
-		const content = await $fetch(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filename}`, {
-			responseType: "text",
-			signal: AbortSignal.timeout(1e4)
-		}).catch(() => null);
-		if (content) return content;
-	}
-	return null;
-}
-async function fetchReleaseNotes(owner, repo, installedVersion, gitRef, packageName) {
-	const selected = selectReleases(await fetchAllReleases(owner, repo), packageName, installedVersion);
-	if (selected.length > 0) {
-		if (isChangelogRedirectPattern(selected)) {
-			const changelog = await fetchChangelog(owner, repo, gitRef || selected[0].tag);
-			if (changelog) return [{
-				path: "releases/CHANGELOG.md",
-				content: changelog
-			}];
-		}
-		const docs = selected.map((r) => {
-			return {
-				path: `releases/${r.tag.includes("@") || r.tag.startsWith("v") ? r.tag : `v${r.tag}`}.md`,
-				content: formatRelease(r, packageName)
-			};
-		});
-		const changelog = await fetchChangelog(owner, repo, gitRef || selected[0].tag);
-		if (changelog && changelog.length < 5e5) docs.push({
-			path: "releases/CHANGELOG.md",
-			content: changelog
-		});
-		return docs;
-	}
-	const changelog = await fetchChangelog(owner, repo, gitRef || "main");
-	if (!changelog) return [];
-	return [{
-		path: "releases/CHANGELOG.md",
-		content: changelog
-	}];
-}
-function parseVersionFromUrl(url) {
-	const match = url.match(/\/posts\/\w+-(\d+)-(\d+)/);
-	if (match) return `${match[1]}.${match[2]}`;
-	return null;
-}
-function formatBlogRelease(release) {
-	return `${[
-		"---",
-		`version: ${release.version}`,
-		`title: "${release.title.replace(/"/g, "\\\"")}"`,
-		`date: ${release.date}`,
-		`url: ${release.url}`,
-		`source: blog-release`,
-		"---"
-	].join("\n")}\n\n# ${release.title}\n\n${release.markdown}`;
-}
-async function fetchBlogPost(url) {
-	try {
-		const html = await $fetch(url, {
-			responseType: "text",
-			signal: AbortSignal.timeout(1e4)
-		}).catch(() => null);
-		if (!html) return null;
-		const version = parseVersionFromUrl(url);
-		if (!version) return null;
-		let title = "";
-		const titleMatch = html.match(/<h1[^>]*>([^<]+)<\/h1>/);
-		if (titleMatch) title = titleMatch[1].trim();
-		if (!title) {
-			const metaTitleMatch = html.match(/<title>([^<]+)<\/title>/);
-			if (metaTitleMatch) title = metaTitleMatch[1].trim();
-		}
-		let date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-		const dateMatch = html.match(/(?:published|date|posted)["']?\s*:\s*["']?(\d{4}-\d{2}-\d{2})/);
-		if (dateMatch) date = dateMatch[1];
-		const markdown = htmlToMarkdown(html);
-		if (!markdown) return null;
-		return {
-			version,
-			title: title || `Release ${version}`,
-			date,
-			markdown,
-			url
-		};
-	} catch {
-		return null;
-	}
-}
-function filterBlogsByVersion(entries, installedVersion) {
-	const installedSv = parseSemver(installedVersion);
-	if (!installedSv) return entries;
-	return entries.filter((entry) => {
-		const entrySv = parseSemver(entry.version);
-		if (!entrySv) return false;
-		return compareSemver(entrySv, installedSv) <= 0;
-	});
-}
-async function fetchBlogReleases(packageName, installedVersion) {
-	const preset = getBlogPreset(packageName);
-	if (!preset) return [];
-	const filteredReleases = filterBlogsByVersion(preset.releases, installedVersion);
-	if (filteredReleases.length === 0) return [];
-	const releases = [];
-	const batchSize = 3;
-	for (let i = 0; i < filteredReleases.length; i += batchSize) {
-		const batch = filteredReleases.slice(i, i + batchSize);
-		const results = await Promise.all(batch.map((entry) => fetchBlogPost(entry.url)));
-		for (const result of results) if (result) releases.push(result);
-	}
-	if (releases.length === 0) return [];
-	releases.sort((a, b) => {
-		const aVer = a.version.split(".").map(Number);
-		const bVer = b.version.split(".").map(Number);
-		for (let i = 0; i < Math.max(aVer.length, bVer.length); i++) {
-			const diff = (bVer[i] ?? 0) - (aVer[i] ?? 0);
-			if (diff !== 0) return diff;
-		}
-		return 0;
-	});
-	return releases.map((r) => ({
-		path: `releases/blog-${r.version}.md`,
-		content: formatBlogRelease(r)
-	}));
-}
-const HIGH_VALUE_CATEGORIES = new Set([
-	"q&a",
-	"help",
-	"troubleshooting",
-	"support"
-]);
-const LOW_VALUE_CATEGORIES = new Set([
-	"show and tell",
-	"ideas",
-	"polls"
-]);
-async function fetchGitHubDiscussions(owner, repo, limit = 20, releasedAt) {
-	if (!isGhAvailable()) return [];
-	if (releasedAt) {
-		const cutoff = new Date(releasedAt);
-		cutoff.setMonth(cutoff.getMonth() + 6);
-		if (cutoff < /* @__PURE__ */ new Date()) return [];
-	}
-	try {
-		const { stdout: result } = spawnSync("gh", [
-			"api",
-			"graphql",
-			"-f",
-			`query=${`query($owner: String!, $repo: String!) { repository(owner: $owner, name: $repo) { discussions(first: ${Math.min(limit * 3, 80)}, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { number title body category { name } createdAt url upvoteCount comments(first: 3) { totalCount nodes { body author { login } } } answer { body } author { login } } } } }`}`,
-			"-f",
-			`owner=${owner}`,
-			"-f",
-			`repo=${repo}`
-		], {
-			encoding: "utf-8",
-			maxBuffer: 10 * 1024 * 1024
-		});
-		if (!result) return [];
-		const nodes = JSON.parse(result)?.data?.repository?.discussions?.nodes;
-		if (!Array.isArray(nodes)) return [];
-		return nodes.filter((d) => d.author && !BOT_USERS.has(d.author.login)).filter((d) => {
-			const cat = (d.category?.name || "").toLowerCase();
-			return !LOW_VALUE_CATEGORIES.has(cat);
-		}).map((d) => ({
-			number: d.number,
-			title: d.title,
-			body: d.body || "",
-			category: d.category?.name || "",
-			createdAt: d.createdAt,
-			url: d.url,
-			upvoteCount: d.upvoteCount || 0,
-			comments: d.comments?.totalCount || 0,
-			answer: d.answer?.body || void 0,
-			topComments: (d.comments?.nodes || []).filter((c) => c.author && !BOT_USERS.has(c.author.login)).map((c) => ({
-				body: c.body || "",
-				author: c.author.login
-			}))
-		})).sort((a, b) => {
-			const aHigh = HIGH_VALUE_CATEGORIES.has(a.category.toLowerCase()) ? 1 : 0;
-			const bHigh = HIGH_VALUE_CATEGORIES.has(b.category.toLowerCase()) ? 1 : 0;
-			if (aHigh !== bHigh) return bHigh - aHigh;
-			return b.upvoteCount + b.comments - (a.upvoteCount + a.comments);
-		}).slice(0, limit);
-	} catch {
-		return [];
-	}
-}
-function formatDiscussionAsMarkdown(d) {
-	const fm = buildFrontmatter({
-		number: d.number,
-		title: d.title,
-		category: d.category,
-		created: isoDate(d.createdAt),
-		url: d.url,
-		upvotes: d.upvoteCount,
-		comments: d.comments,
-		answered: !!d.answer
-	});
-	const bodyLimit = d.upvoteCount >= 5 ? 1500 : 800;
-	const lines = [
-		fm,
-		"",
-		`# ${d.title}`
-	];
-	if (d.body) {
-		const body = d.body.length > bodyLimit ? `${d.body.slice(0, bodyLimit)}...` : d.body;
-		lines.push("", body);
-	}
-	if (d.answer) {
-		const answerLimit = 1e3;
-		const answer = d.answer.length > answerLimit ? `${d.answer.slice(0, answerLimit)}...` : d.answer;
-		lines.push("", "---", "", "## Accepted Answer", "", answer);
-	} else if (d.topComments.length > 0) {
-		lines.push("", "---", "", "## Top Comments");
-		for (const c of d.topComments) {
-			const commentBody = c.body.length > 600 ? `${c.body.slice(0, 600)}...` : c.body;
-			lines.push("", `**@${c.author}:**`, "", commentBody);
-		}
-	}
-	return lines.join("\n");
-}
-function generateDiscussionIndex(discussions) {
-	const byCategory = /* @__PURE__ */ new Map();
-	for (const d of discussions) {
-		const cat = d.category || "Uncategorized";
-		const list = byCategory.get(cat) || [];
-		list.push(d);
-		byCategory.set(cat, list);
-	}
-	const answered = discussions.filter((d) => d.answer).length;
-	const sections = [
-		[
-			"---",
-			`total: ${discussions.length}`,
-			`answered: ${answered}`,
-			"---"
-		].join("\n"),
-		"",
-		"# Discussions Index",
-		""
-	];
-	const cats = [...byCategory.keys()].sort((a, b) => {
-		return (HIGH_VALUE_CATEGORIES.has(a.toLowerCase()) ? 0 : 1) - (HIGH_VALUE_CATEGORIES.has(b.toLowerCase()) ? 0 : 1) || a.localeCompare(b);
-	});
-	for (const cat of cats) {
-		const group = byCategory.get(cat);
-		sections.push(`## ${cat} (${group.length})`, "");
-		for (const d of group) {
-			const upvotes = d.upvoteCount > 0 ? ` (+${d.upvoteCount})` : "";
-			const answered = d.answer ? " [answered]" : "";
-			const date = isoDate(d.createdAt);
-			sections.push(`- [#${d.number}](./discussion-${d.number}.md): ${d.title}${upvotes}${answered} (${date})`);
-		}
-		sections.push("");
-	}
-	return sections.join("\n");
-}
-const SKIP_DIRS = [
-	"node_modules",
-	"_vendor",
-	"__tests__",
-	"__mocks__",
-	"__fixtures__",
-	"test",
-	"tests",
-	"fixture",
-	"fixtures",
-	"locales",
-	"locale",
-	"i18n",
-	".git"
-];
-const SKIP_PATTERNS = [
-	"*.min.*",
-	"*.prod.*",
-	"*.global.*",
-	"*.browser.*",
-	"*.map",
-	"*.map.js",
-	"CHANGELOG*",
-	"LICENSE*",
-	"README*"
-];
-const MAX_FILE_SIZE = 500 * 1024;
-async function resolveEntryFiles(packageDir) {
-	if (!existsSync(join(packageDir, "package.json"))) return [];
-	const files = await globby(["**/*.d.{ts,mts,cts}"], {
-		cwd: packageDir,
-		ignore: [...SKIP_DIRS.map((d) => `**/${d}/**`), ...SKIP_PATTERNS],
-		absolute: false
-	});
-	const entries = [];
-	for (const file of files) {
-		const absPath = join(packageDir, file);
-		let content;
-		try {
-			content = readFileSync(absPath, "utf-8");
-		} catch {
-			continue;
-		}
-		if (content.length > MAX_FILE_SIZE) continue;
-		entries.push({
-			path: file,
-			content,
-			type: "types"
-		});
-	}
-	return entries;
-}
-function parseGitSkillInput(input) {
-	const trimmed = input.trim();
-	if (trimmed.startsWith("@")) return null;
-	if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") || trimmed.startsWith("~")) return {
-		type: "local",
-		localPath: trimmed.startsWith("~") ? resolve(process.env.HOME || "", trimmed.slice(1)) : resolve(trimmed)
-	};
-	if (trimmed.startsWith("git@")) {
-		const gh = parseGitHubUrl(normalizeRepoUrl(trimmed));
-		if (gh) return {
-			type: "github",
-			owner: gh.owner,
-			repo: gh.repo
-		};
-		return null;
-	}
-	if (trimmed.startsWith("https://") || trimmed.startsWith("http://")) return parseGitUrl(trimmed);
-	if (/^[\w.-]+\/[\w.-]+$/.test(trimmed)) return {
-		type: "github",
-		owner: trimmed.split("/")[0],
-		repo: trimmed.split("/")[1]
-	};
-	return null;
-}
-function parseGitUrl(url) {
-	try {
-		const parsed = new URL(url);
-		if (parsed.hostname === "github.com" || parsed.hostname === "www.github.com") {
-			const parts = parsed.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
-			const owner = parts[0];
-			const repo = parts[1];
-			if (!owner || !repo) return null;
-			if (parts[2] === "tree" && parts.length >= 4) return {
-				type: "github",
-				owner,
-				repo,
-				ref: parts[3],
-				skillPath: parts.length > 4 ? parts.slice(4).join("/") : void 0
-			};
-			return {
-				type: "github",
-				owner,
-				repo
-			};
-		}
-		if (parsed.hostname === "gitlab.com") {
-			const parts = parsed.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
-			const owner = parts[0];
-			const repo = parts[1];
-			if (!owner || !repo) return null;
-			return {
-				type: "gitlab",
-				owner,
-				repo
-			};
-		}
-		return null;
-	} catch {
-		return null;
-	}
-}
-function parseSkillFrontmatterName(content) {
-	const match = content.match(/^---\n([\s\S]*?)\n---/);
-	if (!match) return {};
-	const result = {};
-	for (const line of match[1].split("\n")) {
-		const kv = yamlParseKV(line);
-		if (!kv) continue;
-		if (kv[0] === "name") result.name = kv[1];
-		if (kv[0] === "description") result.description = kv[1];
-	}
-	return result;
-}
-const SUPPORTING_DIRS = [
-	"scripts",
-	"references",
-	"assets"
-];
-async function fetchGitSkills(source, onProgress) {
-	if (source.type === "local") return fetchLocalSkills(source);
-	if (source.type === "github") return fetchGitHubSkills(source, onProgress);
-	if (source.type === "gitlab") return fetchGitLabSkills(source, onProgress);
-	return { skills: [] };
-}
-function fetchLocalSkills(source) {
-	const base = source.localPath;
-	if (!existsSync(base)) return { skills: [] };
-	const skills = [];
-	const skillsDir = resolve(base, "skills");
-	if (existsSync(skillsDir)) for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
-		if (!entry.isDirectory()) continue;
-		const skill = readLocalSkill(resolve(skillsDir, entry.name), `skills/${entry.name}`);
-		if (skill) skills.push(skill);
-	}
-	if (skills.length === 0) {
-		const skill = readLocalSkill(base, "");
-		if (skill) skills.push(skill);
-	}
-	return { skills };
-}
-function readLocalSkill(dir, repoPath) {
-	const skillMdPath = resolve(dir, "SKILL.md");
-	if (!existsSync(skillMdPath)) return null;
-	const content = readFileSync(skillMdPath, "utf-8");
-	const frontmatter = parseSkillFrontmatterName(content);
-	const dirName = dir.split("/").pop();
-	const name = frontmatter.name || dirName;
-	const files = [];
-	for (const subdir of SUPPORTING_DIRS) {
-		const subdirPath = resolve(dir, subdir);
-		if (!existsSync(subdirPath)) continue;
-		for (const file of readdirSync(subdirPath, { withFileTypes: true })) {
-			if (!file.isFile()) continue;
-			files.push({
-				path: `${subdir}/${file.name}`,
-				content: readFileSync(resolve(subdirPath, file.name), "utf-8")
-			});
-		}
-	}
-	return {
-		name,
-		description: frontmatter.description || "",
-		path: repoPath,
-		content,
-		files
-	};
-}
-async function fetchGitHubSkills(source, onProgress) {
-	const { owner, repo } = source;
-	if (!owner || !repo) return { skills: [] };
-	const ref = source.ref || "main";
-	onProgress?.(`Listing files at ${owner}/${repo}@${ref}`);
-	const data = await $fetch(`https://ungh.cc/repos/${owner}/${repo}/files/${ref}`).catch(() => null);
-	if (!data?.files?.length) {
-		if (ref === "main") {
-			const fallback = await $fetch(`https://ungh.cc/repos/${owner}/${repo}/files/master`).catch(() => null);
-			if (fallback?.files?.length) return extractGitHubSkills(owner, repo, "master", fallback, source.skillPath, onProgress);
-		}
-		return { skills: [] };
-	}
-	return extractGitHubSkills(owner, repo, ref, data, source.skillPath, onProgress);
-}
-async function extractGitHubSkills(owner, repo, ref, data, skillPath, onProgress) {
-	const allFiles = data.files.map((f) => f.path);
-	const commitSha = data.meta?.sha;
-	let skillMdPaths;
-	if (skillPath) {
-		const candidates = [`${skillPath}/SKILL.md`, skillPath.endsWith("/SKILL.md") ? skillPath : null].filter(Boolean);
-		skillMdPaths = allFiles.filter((f) => candidates.includes(f));
-	} else skillMdPaths = allFiles.filter((f) => f.match(/^skills\/[^/]+\/SKILL\.md$/) || f === "SKILL.md");
-	if (skillMdPaths.length === 0) return {
-		skills: [],
-		commitSha
-	};
-	const limit = pLimit(5);
-	const skills = [];
-	onProgress?.(`Found ${skillMdPaths.length} skill(s), downloading...`);
-	await Promise.all(skillMdPaths.map((mdPath) => limit(async () => {
-		const skillDir = mdPath === "SKILL.md" ? "" : mdPath.replace(/\/SKILL\.md$/, "");
-		const content = await fetchRawGitHub(owner, repo, ref, mdPath);
-		if (!content) return;
-		const frontmatter = parseSkillFrontmatterName(content);
-		const dirName = skillDir ? skillDir.split("/").pop() : repo;
-		const name = frontmatter.name || dirName;
-		const supportingFiles = [];
-		const prefix = skillDir ? `${skillDir}/` : "";
-		for (const subdir of SUPPORTING_DIRS) {
-			const subdirPrefix = `${prefix}${subdir}/`;
-			const matching = allFiles.filter((f) => f.startsWith(subdirPrefix));
-			for (const filePath of matching) {
-				const fileContent = await fetchRawGitHub(owner, repo, ref, filePath);
-				if (fileContent) {
-					const relativePath = filePath.slice(prefix.length);
-					supportingFiles.push({
-						path: relativePath,
-						content: fileContent
-					});
-				}
-			}
-		}
-		skills.push({
-			name,
-			description: frontmatter.description || "",
-			path: skillDir,
-			content,
-			files: supportingFiles
-		});
-	})));
-	return {
-		skills,
-		commitSha
-	};
-}
-async function fetchRawGitHub(owner, repo, ref, path) {
-	return $fetch(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`, { responseType: "text" }).catch(() => null);
-}
-async function fetchGitLabSkills(source, onProgress) {
-	const { owner, repo } = source;
-	if (!owner || !repo) return { skills: [] };
-	const ref = source.ref || "main";
-	const projectId = encodeURIComponent(`${owner}/${repo}`);
-	onProgress?.(`Listing files at ${owner}/${repo}@${ref}`);
-	const tree = await $fetch(`https://gitlab.com/api/v4/projects/${projectId}/repository/tree?ref=${ref}&recursive=true&per_page=100`).catch(() => null);
-	if (!tree?.length) return { skills: [] };
-	const allFiles = tree.filter((e) => e.type === "blob").map((e) => e.path);
-	const skillMdPaths = source.skillPath ? allFiles.filter((f) => f === `${source.skillPath}/SKILL.md`) : allFiles.filter((f) => f.match(/^skills\/[^/]+\/SKILL\.md$/) || f === "SKILL.md");
-	if (skillMdPaths.length === 0) return { skills: [] };
-	const limit = pLimit(5);
-	const skills = [];
-	onProgress?.(`Found ${skillMdPaths.length} skill(s), downloading...`);
-	await Promise.all(skillMdPaths.map((mdPath) => limit(async () => {
-		const skillDir = mdPath === "SKILL.md" ? "" : mdPath.replace(/\/SKILL\.md$/, "");
-		const content = await fetchRawGitLab(owner, repo, ref, mdPath);
-		if (!content) return;
-		const frontmatter = parseSkillFrontmatterName(content);
-		const dirName = skillDir ? skillDir.split("/").pop() : repo;
-		const name = frontmatter.name || dirName;
-		const supportingFiles = [];
-		const prefix = skillDir ? `${skillDir}/` : "";
-		for (const subdir of SUPPORTING_DIRS) {
-			const subdirPrefix = `${prefix}${subdir}/`;
-			const matching = allFiles.filter((f) => f.startsWith(subdirPrefix));
-			for (const filePath of matching) {
-				const fileContent = await fetchRawGitLab(owner, repo, ref, filePath);
-				if (fileContent) {
-					const relativePath = filePath.slice(prefix.length);
-					supportingFiles.push({
-						path: relativePath,
-						content: fileContent
-					});
-				}
-			}
-		}
-		skills.push({
-			name,
-			description: frontmatter.description || "",
-			path: skillDir,
-			content,
-			files: supportingFiles
-		});
-	})));
-	return { skills };
-}
-async function fetchRawGitLab(owner, repo, ref, path) {
-	return $fetch(`https://gitlab.com/${owner}/${repo}/-/raw/${ref}/${path}`, { responseType: "text" }).catch(() => null);
-}
-const MIN_GIT_DOCS = 5;
-const isShallowGitDocs = (n) => n > 0 && n < MIN_GIT_DOCS;
-async function listFilesAtRef(owner, repo, ref) {
-	return (await $fetch(`https://ungh.cc/repos/${owner}/${repo}/files/${ref}`).catch(() => null))?.files?.map((f) => f.path) ?? [];
-}
-async function findGitTag(owner, repo, version, packageName, branchHint) {
-	const candidates = [`v${version}`, version];
-	if (packageName) candidates.push(`${packageName}@${version}`);
-	for (const tag of candidates) {
-		const files = await listFilesAtRef(owner, repo, tag);
-		if (files.length > 0) return {
-			ref: tag,
-			files
-		};
-	}
-	if (packageName) {
-		const latestTag = await findLatestReleaseTag(owner, repo, packageName);
-		if (latestTag) {
-			const files = await listFilesAtRef(owner, repo, latestTag);
-			if (files.length > 0) return {
-				ref: latestTag,
-				files
-			};
-		}
-	}
-	const branches = branchHint ? [branchHint, ...["main", "master"].filter((b) => b !== branchHint)] : ["main", "master"];
-	for (const branch of branches) {
-		const files = await listFilesAtRef(owner, repo, branch);
-		if (files.length > 0) return {
-			ref: branch,
-			files,
-			fallback: true
-		};
-	}
-	return null;
-}
-async function findLatestReleaseTag(owner, repo, packageName) {
-	const data = await $fetch(`https://ungh.cc/repos/${owner}/${repo}/releases`).catch(() => null);
-	const prefix = `${packageName}@`;
-	return data?.releases?.find((r) => r.tag.startsWith(prefix))?.tag ?? null;
-}
-function filterDocFiles(files, pathPrefix) {
-	return files.filter((f) => f.startsWith(pathPrefix) && /\.(?:md|mdx)$/.test(f));
-}
-const NOISE_PATTERNS = [
-	/^\.changeset\//,
-	/CHANGELOG\.md$/i,
-	/CONTRIBUTING\.md$/i,
-	/^\.github\//
-];
-const EXCLUDE_DIRS = new Set([
-	"test",
-	"tests",
-	"__tests__",
-	"fixtures",
-	"fixture",
-	"examples",
-	"example",
-	"node_modules",
-	".git",
-	"dist",
-	"build",
-	"coverage",
-	"e2e",
-	"spec",
-	"mocks",
-	"__mocks__"
-]);
-const DOC_DIR_BONUS = new Set([
-	"docs",
-	"documentation",
-	"pages",
-	"content",
-	"website",
-	"guide",
-	"guides",
-	"wiki",
-	"manual",
-	"api"
-]);
-function hasExcludedDir(path) {
-	return path.split("/").some((p) => EXCLUDE_DIRS.has(p.toLowerCase()));
-}
-function getPathDepth(path) {
-	return path.split("/").filter(Boolean).length;
-}
-function hasDocDirBonus(path) {
-	return path.split("/").some((p) => DOC_DIR_BONUS.has(p.toLowerCase()));
-}
-function scoreDocDir(dir, fileCount) {
-	const depth = getPathDepth(dir) || 1;
-	return fileCount * (hasDocDirBonus(dir) ? 1.5 : 1) / depth;
-}
-function discoverDocFiles(allFiles) {
-	const mdFiles = allFiles.filter((f) => /\.(?:md|mdx)$/.test(f)).filter((f) => !NOISE_PATTERNS.some((p) => p.test(f))).filter((f) => f.includes("/"));
-	const docsGroups = /* @__PURE__ */ new Map();
-	for (const file of mdFiles) {
-		const docsIdx = file.lastIndexOf("/docs/");
-		if (docsIdx === -1) continue;
-		const prefix = file.slice(0, docsIdx + 6);
-		const group = docsGroups.get(prefix) || [];
-		group.push(file);
-		docsGroups.set(prefix, group);
-	}
-	if (docsGroups.size > 0) {
-		const largest = [...docsGroups.entries()].sort((a, b) => b[1].length - a[1].length)[0];
-		if (largest[1].length >= 3) {
-			const fullPrefix = largest[0];
-			const docsIdx = fullPrefix.lastIndexOf("docs/");
-			const stripPrefix = docsIdx > 0 ? fullPrefix.slice(0, docsIdx) : "";
-			return {
-				files: largest[1],
-				prefix: stripPrefix
-			};
-		}
-	}
-	const dirGroups = /* @__PURE__ */ new Map();
-	for (const file of mdFiles) {
-		if (hasExcludedDir(file)) continue;
-		const lastSlash = file.lastIndexOf("/");
-		if (lastSlash === -1) continue;
-		const dir = file.slice(0, lastSlash + 1);
-		const group = dirGroups.get(dir) || [];
-		group.push(file);
-		dirGroups.set(dir, group);
-	}
-	if (dirGroups.size === 0) return null;
-	const scored = [...dirGroups.entries()].map(([dir, files]) => ({
-		dir,
-		files,
-		score: scoreDocDir(dir, files.length)
-	})).filter((d) => d.files.length >= 5).sort((a, b) => b.score - a.score);
-	if (scored.length === 0) return null;
-	const best = scored[0];
-	return {
-		files: best.files,
-		prefix: best.dir
-	};
-}
-async function listDocsAtRef(owner, repo, ref, pathPrefix = "docs/") {
-	return filterDocFiles(await listFilesAtRef(owner, repo, ref), pathPrefix);
-}
-async function fetchGitDocs(owner, repo, version, packageName, repoUrl) {
-	const override = packageName ? getDocOverride(packageName) : void 0;
-	if (override) {
-		const ref = override.ref || "main";
-		const fallback = !override.ref;
-		const files = await listDocsAtRef(override.owner, override.repo, ref, `${override.path}/`);
-		if (files.length === 0) return null;
-		return {
-			baseUrl: `https://raw.githubusercontent.com/${override.owner}/${override.repo}/${ref}`,
-			ref,
-			files,
-			fallback
-		};
-	}
-	const tag = await findGitTag(owner, repo, version, packageName, repoUrl ? extractBranchHint(repoUrl) : void 0);
-	if (!tag) return null;
-	let docs = filterDocFiles(tag.files, "docs/");
-	let docsPrefix;
-	let allFiles;
-	if (docs.length === 0) {
-		const discovered = discoverDocFiles(tag.files);
-		if (discovered) {
-			docs = discovered.files;
-			docsPrefix = discovered.prefix || void 0;
-			allFiles = tag.files;
-		}
-	}
-	if (docs.length === 0) return null;
-	return {
-		baseUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${tag.ref}`,
-		ref: tag.ref,
-		files: docs,
-		docsPrefix,
-		allFiles,
-		fallback: tag.fallback
-	};
-}
-function normalizePath(p) {
-	return p.replace(/^\//, "").replace(/\.(?:md|mdx)$/, "");
-}
-function validateGitDocsWithLlms(llmsLinks, repoFiles) {
-	if (llmsLinks.length === 0) return {
-		isValid: true,
-		matchRatio: 1
-	};
-	const sample = llmsLinks.slice(0, 10);
-	const normalizedLinks = sample.map((link) => {
-		let path = link.url;
-		if (path.startsWith("http")) try {
-			path = new URL(path).pathname;
-		} catch {}
-		return normalizePath(path);
-	});
-	const repoNormalized = new Set(repoFiles.map(normalizePath));
-	let matches = 0;
-	for (const linkPath of normalizedLinks) for (const repoPath of repoNormalized) if (repoPath === linkPath || repoPath.endsWith(`/${linkPath}`)) {
-		matches++;
-		break;
-	}
-	const matchRatio = matches / sample.length;
-	return {
-		isValid: matchRatio >= .3,
-		matchRatio
-	};
-}
-async function verifyNpmRepo(owner, repo, packageName) {
-	const base = `https://raw.githubusercontent.com/${owner}/${repo}/HEAD`;
-	const paths = [
-		"package.json",
-		`packages/${packageName.replace(/^@.*\//, "")}/package.json`,
-		`packages/${packageName.replace(/^@/, "").replace("/", "-")}/package.json`
-	];
-	for (const path of paths) {
-		const text = await fetchText(`${base}/${path}`);
-		if (!text) continue;
-		try {
-			if (JSON.parse(text).name === packageName) return true;
-		} catch {}
-	}
-	return false;
-}
-async function searchGitHubRepo(packageName) {
-	const shortName = packageName.replace(/^@.*\//, "");
-	for (const candidate of [packageName.replace(/^@/, "").replace("/", "/"), shortName]) {
-		if (!candidate.includes("/")) {
-			if ((await $fetch.raw(`https://ungh.cc/repos/${shortName}/${shortName}`).catch(() => null))?.ok) return `https://github.com/${shortName}/${shortName}`;
-			continue;
-		}
-		if ((await $fetch.raw(`https://ungh.cc/repos/${candidate}`).catch(() => null))?.ok) return `https://github.com/${candidate}`;
-	}
-	const searchTerm = packageName.replace(/^@/, "");
-	if (isGhAvailable()) try {
-		const { stdout: json } = spawnSync("gh", [
-			"search",
-			"repos",
-			searchTerm,
-			"--json",
-			"fullName",
-			"--limit",
-			"5"
-		], {
-			encoding: "utf-8",
-			timeout: 15e3
-		});
-		if (!json) throw new Error("no output");
-		const repos = JSON.parse(json);
-		const match = repos.find((r) => r.fullName.toLowerCase().endsWith(`/${packageName.toLowerCase()}`) || r.fullName.toLowerCase().endsWith(`/${shortName.toLowerCase()}`));
-		if (match) return `https://github.com/${match.fullName}`;
-		for (const candidate of repos) {
-			const gh = parseGitHubUrl(`https://github.com/${candidate.fullName}`);
-			if (gh && await verifyNpmRepo(gh.owner, gh.repo, packageName)) return `https://github.com/${candidate.fullName}`;
-		}
-	} catch {}
-	const data = await $fetch(`https://api.github.com/search/repositories?q=${encodeURIComponent(`${searchTerm} in:name`)}&per_page=5`).catch(() => null);
-	if (!data?.items?.length) return null;
-	const match = data.items.find((r) => r.full_name.toLowerCase().endsWith(`/${packageName.toLowerCase()}`) || r.full_name.toLowerCase().endsWith(`/${shortName.toLowerCase()}`));
-	if (match) return `https://github.com/${match.full_name}`;
-	for (const candidate of data.items) {
-		const gh = parseGitHubUrl(`https://github.com/${candidate.full_name}`);
-		if (gh && await verifyNpmRepo(gh.owner, gh.repo, packageName)) return `https://github.com/${candidate.full_name}`;
-	}
-	return null;
-}
-async function fetchGitHubRepoMeta(owner, repo, packageName) {
-	const override = packageName ? getDocOverride(packageName) : void 0;
-	if (override?.homepage) return { homepage: override.homepage };
-	if (isGhAvailable()) try {
-		const { stdout: json } = spawnSync("gh", [
-			"api",
-			`repos/${owner}/${repo}`,
-			"-q",
-			"{homepage}"
-		], {
-			encoding: "utf-8",
-			timeout: 1e4
-		});
-		if (!json) throw new Error("no output");
-		const data = JSON.parse(json);
-		return data?.homepage ? { homepage: data.homepage } : null;
-	} catch {}
-	const data = await $fetch(`https://api.github.com/repos/${owner}/${repo}`).catch(() => null);
-	return data?.homepage ? { homepage: data.homepage } : null;
-}
-async function fetchReadme(owner, repo, subdir, ref) {
-	const unghUrl = subdir ? `https://ungh.cc/repos/${owner}/${repo}/files/${ref || "main"}/${subdir}/README.md` : `https://ungh.cc/repos/${owner}/${repo}/readme${ref ? `?ref=${ref}` : ""}`;
-	if ((await $fetch.raw(unghUrl).catch(() => null))?.ok) return `ungh://${owner}/${repo}${subdir ? `/${subdir}` : ""}${ref ? `@${ref}` : ""}`;
-	const basePath = subdir ? `${subdir}/` : "";
-	const branches = ref ? [ref] : ["main", "master"];
-	for (const b of branches) for (const filename of [
-		"README.md",
-		"Readme.md",
-		"readme.md"
-	]) {
-		const readmeUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${b}/${basePath}${filename}`;
-		if ((await $fetch.raw(readmeUrl).catch(() => null))?.ok) return readmeUrl;
-	}
-	return null;
-}
-async function fetchReadmeContent(url) {
-	if (url.startsWith("file://")) {
-		const filePath = fileURLToPath(url);
-		if (!existsSync(filePath)) return null;
-		return readFileSync(filePath, "utf-8");
-	}
-	if (url.startsWith("ungh://")) {
-		let path = url.replace("ungh://", "");
-		let ref = "main";
-		const atIdx = path.lastIndexOf("@");
-		if (atIdx !== -1) {
-			ref = path.slice(atIdx + 1);
-			path = path.slice(0, atIdx);
-		}
-		const parts = path.split("/");
-		const owner = parts[0];
-		const repo = parts[1];
-		const subdir = parts.slice(2).join("/");
-		const text = await $fetch(subdir ? `https://ungh.cc/repos/${owner}/${repo}/files/${ref}/${subdir}/README.md` : `https://ungh.cc/repos/${owner}/${repo}/readme?ref=${ref}`, { responseType: "text" }).catch(() => null);
-		if (!text) return null;
-		try {
-			const json = JSON.parse(text);
-			return json.markdown || json.file?.contents || null;
-		} catch {
-			return text;
-		}
-	}
-	return fetchText(url);
-}
-async function fetchLlmsUrl(docsUrl) {
-	const llmsUrl = `${new URL(docsUrl).origin}/llms.txt`;
-	if (await verifyUrl(llmsUrl)) return llmsUrl;
-	return null;
-}
-async function fetchLlmsTxt(url) {
-	const content = await fetchText(url);
-	if (!content || content.length < 50) return null;
-	return {
-		raw: content,
-		links: parseMarkdownLinks(content)
-	};
-}
-function parseMarkdownLinks(content) {
-	const links = [];
-	const seen = /* @__PURE__ */ new Set();
-	const linkRegex = /\[([^\]]+)\]\(([^)]+\.md)\)/g;
-	for (let match = linkRegex.exec(content); match !== null; match = linkRegex.exec(content)) {
-		const url = match[2];
-		if (!seen.has(url)) {
-			seen.add(url);
-			links.push({
-				title: match[1],
-				url
-			});
-		}
-	}
-	return links;
-}
-function isSafeUrl(url) {
-	try {
-		const parsed = new URL(url);
-		if (parsed.protocol !== "https:") return false;
-		const host = parsed.hostname;
-		if (host === "localhost" || host === "127.0.0.1" || host === "::1") return false;
-		if (host === "169.254.169.254") return false;
-		if (/^(?:10\.|172\.(?:1[6-9]|2\d|3[01])\.|192\.168\.)/.test(host)) return false;
-		if (host.startsWith("[")) return false;
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function downloadLlmsDocs(llmsContent, baseUrl, onProgress) {
-	const limit = pLimit(5);
-	let completed = 0;
-	return (await Promise.all(llmsContent.links.map((link) => limit(async () => {
-		const url = link.url.startsWith("http") ? link.url : `${baseUrl.replace(/\/$/, "")}${link.url.startsWith("/") ? "" : "/"}${link.url}`;
-		if (!isSafeUrl(url)) return null;
-		onProgress?.(link.url, completed++, llmsContent.links.length);
-		const content = await fetchText(url);
-		if (content && content.length > 100) return {
-			url: link.url,
-			title: link.title,
-			content
-		};
-		return null;
-	})))).filter((d) => d !== null);
-}
-function normalizeLlmsLinks(content, baseUrl) {
-	let normalized = content;
-	if (baseUrl) {
-		const escaped = baseUrl.replace(/\/$/, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		normalized = normalized.replace(new RegExp(`\\]\\(${escaped}(/[^)]+\\.md)\\)`, "g"), "](./docs$1)");
-	}
-	normalized = normalized.replace(/\]\(\/([^)]+\.md)\)/g, "](./docs/$1)");
-	return normalized;
-}
-function extractSections(content, patterns) {
-	const sections = [];
-	const parts = content.split(/\n---\n/);
-	for (const part of parts) {
-		const urlMatch = part.match(/^url: *(\S.*)$/m);
-		if (!urlMatch) continue;
-		const url = urlMatch[1];
-		if (patterns.some((p) => url.includes(p))) {
-			const contentStart = part.indexOf("\n", part.indexOf("url:"));
-			if (contentStart > -1) sections.push(part.slice(contentStart + 1));
-		}
-	}
-	if (sections.length === 0) return null;
-	return sections.join("\n\n---\n\n");
-}
-async function searchNpmPackages(query, size = 5) {
-	const data = await $fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=${size}`).catch(() => null);
-	if (!data?.objects?.length) return [];
-	return data.objects.map((o) => ({
-		name: o.package.name,
-		description: o.package.description,
-		version: o.package.version
-	}));
-}
-async function fetchNpmPackage(packageName) {
-	const data = await $fetch(`https://unpkg.com/${packageName}/package.json`).catch(() => null);
-	if (data) return data;
-	return $fetch(`https://registry.npmjs.org/${packageName}/latest`).catch(() => null);
-}
-async function fetchNpmRegistryMeta(packageName, version) {
-	const data = await $fetch(`https://registry.npmjs.org/${packageName}`).catch(() => null);
-	if (!data) return {};
-	const distTags = data["dist-tags"] ? Object.fromEntries(Object.entries(data["dist-tags"]).map(([tag, ver]) => [tag, {
-		version: ver,
-		releasedAt: data.time?.[ver]
-	}])) : void 0;
-	return {
-		releasedAt: data.time?.[version] || void 0,
-		distTags
-	};
-}
-async function resolveGitHub(gh, targetVersion, pkg, result, attempts, onProgress, opts) {
-	let allFiles;
-	if (targetVersion) {
-		onProgress?.("github-docs");
-		const gitDocs = await fetchGitDocs(gh.owner, gh.repo, targetVersion, pkg.name, opts?.rawRepoUrl);
-		if (gitDocs) {
-			result.gitDocsUrl = gitDocs.baseUrl;
-			result.gitRef = gitDocs.ref;
-			result.gitDocsFallback = gitDocs.fallback;
-			allFiles = gitDocs.allFiles;
-			attempts.push({
-				source: "github-docs",
-				url: gitDocs.baseUrl,
-				status: "success",
-				message: gitDocs.fallback ? `Found ${gitDocs.files.length} docs at ${gitDocs.ref} (no tag for v${targetVersion})` : `Found ${gitDocs.files.length} docs at ${gitDocs.ref}`
-			});
-		} else attempts.push({
-			source: "github-docs",
-			url: `${result.repoUrl}/tree/v${targetVersion}/docs`,
-			status: "not-found",
-			message: "No docs/ folder found at version tag"
-		});
-	}
-	if (!result.docsUrl) {
-		onProgress?.("github-meta");
-		const repoMeta = await fetchGitHubRepoMeta(gh.owner, gh.repo, pkg.name);
-		if (repoMeta?.homepage && !isUselessDocsUrl(repoMeta.homepage)) {
-			result.docsUrl = repoMeta.homepage;
-			attempts.push({
-				source: "github-meta",
-				url: result.repoUrl,
-				status: "success",
-				message: `Found homepage: ${repoMeta.homepage}`
-			});
-		} else attempts.push({
-			source: "github-meta",
-			url: result.repoUrl,
-			status: "not-found",
-			message: "No homepage in repo metadata"
-		});
-	}
-	onProgress?.("readme");
-	const readmeUrl = await fetchReadme(gh.owner, gh.repo, opts?.subdir, result.gitRef);
-	if (readmeUrl) {
-		result.readmeUrl = readmeUrl;
-		attempts.push({
-			source: "readme",
-			url: readmeUrl,
-			status: "success"
-		});
-	} else attempts.push({
-		source: "readme",
-		url: `${result.repoUrl}/README.md`,
-		status: "not-found",
-		message: "No README found"
-	});
-	return allFiles;
-}
-async function resolvePackageDocs(packageName, options = {}) {
-	return (await resolvePackageDocsWithAttempts(packageName, options)).package;
-}
-async function resolvePackageDocsWithAttempts(packageName, options = {}) {
-	const attempts = [];
-	const { onProgress } = options;
-	onProgress?.("npm");
-	const pkg = await fetchNpmPackage(packageName);
-	if (!pkg) {
-		attempts.push({
-			source: "npm",
-			url: `https://registry.npmjs.org/${packageName}/latest`,
-			status: "not-found",
-			message: "Package not found on npm registry"
-		});
-		return {
-			package: null,
-			attempts
-		};
-	}
-	attempts.push({
-		source: "npm",
-		url: `https://registry.npmjs.org/${packageName}/latest`,
-		status: "success",
-		message: `Found ${pkg.name}@${pkg.version}`
-	});
-	const registryMeta = pkg.version ? await fetchNpmRegistryMeta(packageName, pkg.version) : {};
-	const result = {
-		name: pkg.name,
-		version: pkg.version,
-		releasedAt: registryMeta.releasedAt,
-		description: pkg.description,
-		dependencies: pkg.dependencies,
-		distTags: registryMeta.distTags
-	};
-	let gitDocsAllFiles;
-	let subdir;
-	let rawRepoUrl;
-	if (typeof pkg.repository === "object" && pkg.repository?.url) {
-		rawRepoUrl = pkg.repository.url;
-		const normalized = normalizeRepoUrl(rawRepoUrl);
-		if (!normalized.includes("://") && normalized.includes("/") && !normalized.includes(":")) result.repoUrl = `https://github.com/${normalized}`;
-		else result.repoUrl = normalized;
-		subdir = pkg.repository.directory;
-	} else if (typeof pkg.repository === "string") if (pkg.repository.includes("://")) {
-		const gh = parseGitHubUrl(pkg.repository);
-		if (gh) result.repoUrl = `https://github.com/${gh.owner}/${gh.repo}`;
-	} else {
-		const repo = pkg.repository.replace(/^github:/, "");
-		if (repo.includes("/") && !repo.includes(":")) result.repoUrl = `https://github.com/${repo}`;
-	}
-	if (pkg.homepage && !isGitHubRepoUrl(pkg.homepage) && !isUselessDocsUrl(pkg.homepage)) result.docsUrl = pkg.homepage;
-	if (result.repoUrl?.includes("github.com")) {
-		const gh = parseGitHubUrl(result.repoUrl);
-		if (gh) gitDocsAllFiles = await resolveGitHub(gh, options.version || pkg.version, pkg, result, attempts, onProgress, {
-			rawRepoUrl,
-			subdir
-		});
-	} else if (!result.repoUrl) {
-		onProgress?.("github-search");
-		const searchedUrl = await searchGitHubRepo(pkg.name);
-		if (searchedUrl) {
-			result.repoUrl = searchedUrl;
-			attempts.push({
-				source: "github-search",
-				url: searchedUrl,
-				status: "success",
-				message: `Found via GitHub search: ${searchedUrl}`
-			});
-			const gh = parseGitHubUrl(searchedUrl);
-			if (gh) gitDocsAllFiles = await resolveGitHub(gh, options.version || pkg.version, pkg, result, attempts, onProgress);
-		} else attempts.push({
-			source: "github-search",
-			status: "not-found",
-			message: "No repository URL in package.json and GitHub search found no match"
-		});
-	}
-	if (result.docsUrl) {
-		onProgress?.("llms.txt");
-		const llmsUrl = await fetchLlmsUrl(result.docsUrl);
-		if (llmsUrl) {
-			result.llmsUrl = llmsUrl;
-			attempts.push({
-				source: "llms.txt",
-				url: llmsUrl,
-				status: "success"
-			});
-		} else attempts.push({
-			source: "llms.txt",
-			url: `${new URL(result.docsUrl).origin}/llms.txt`,
-			status: "not-found",
-			message: "No llms.txt at docs URL"
-		});
-	}
-	if (result.gitDocsUrl && result.llmsUrl && gitDocsAllFiles) {
-		const llmsContent = await fetchLlmsTxt(result.llmsUrl);
-		if (llmsContent && llmsContent.links.length > 0) {
-			const validation = validateGitDocsWithLlms(llmsContent.links, gitDocsAllFiles);
-			if (!validation.isValid) {
-				attempts.push({
-					source: "github-docs",
-					url: result.gitDocsUrl,
-					status: "not-found",
-					message: `Heuristic git docs don't match llms.txt links (${Math.round(validation.matchRatio * 100)}% match), preferring llms.txt`
-				});
-				result.gitDocsUrl = void 0;
-				result.gitRef = void 0;
-			}
-		}
-	}
-	if (!result.docsUrl && !result.llmsUrl && !result.readmeUrl && !result.gitDocsUrl && options.cwd) {
-		onProgress?.("local");
-		const pkgDir = join(options.cwd, "node_modules", packageName);
-		const readmeFile = existsSync(pkgDir) && readdirSync(pkgDir).find((f) => /^readme\.md$/i.test(f));
-		if (readmeFile) {
-			const readmePath = join(pkgDir, readmeFile);
-			result.readmeUrl = pathToFileURL(readmePath).href;
-			attempts.push({
-				source: "readme",
-				url: readmePath,
-				status: "success",
-				message: "Found local readme in node_modules"
-			});
-		}
-	}
-	if (!result.docsUrl && !result.llmsUrl && !result.readmeUrl && !result.gitDocsUrl) return {
-		package: null,
-		attempts
-	};
-	return {
-		package: result,
-		attempts
-	};
-}
-function parseVersionSpecifier(name, version, cwd) {
-	if (version.startsWith("link:")) {
-		const linkedPkgPath = join(resolve(cwd, version.slice(5)), "package.json");
-		if (existsSync(linkedPkgPath)) {
-			const linkedPkg = JSON.parse(readFileSync(linkedPkgPath, "utf-8"));
-			return {
-				name: linkedPkg.name || name,
-				version: linkedPkg.version || "0.0.0"
-			};
-		}
-		return null;
-	}
-	if (version.startsWith("npm:")) {
-		const specifier = version.slice(4);
-		const atIndex = specifier.startsWith("@") ? specifier.indexOf("@", 1) : specifier.indexOf("@");
-		const realName = atIndex > 0 ? specifier.slice(0, atIndex) : specifier;
-		return {
-			name: realName,
-			version: resolveInstalledVersion(realName, cwd) || "*"
-		};
-	}
-	if (version.startsWith("file:") || version.startsWith("git:") || version.startsWith("git+")) return null;
-	const installed = resolveInstalledVersion(name, cwd);
-	if (installed) return {
-		name,
-		version: installed
-	};
-	if (/^[\^~>=<\d]/.test(version)) return {
-		name,
-		version: version.replace(/^[\^~>=<]/, "")
-	};
-	if (version.startsWith("catalog:") || version.startsWith("workspace:")) return {
-		name,
-		version: "*"
-	};
-	return null;
-}
-function resolveInstalledVersion(name, cwd) {
-	try {
-		const resolved = resolvePathSync(`${name}/package.json`, { url: cwd });
-		return JSON.parse(readFileSync(resolved, "utf-8")).version || null;
-	} catch {
-		try {
-			let dir = dirname(resolvePathSync(name, { url: cwd }));
-			while (dir && basename(dir) !== "node_modules") {
-				const pkgPath = join(dir, "package.json");
-				if (existsSync(pkgPath)) return JSON.parse(readFileSync(pkgPath, "utf-8")).version || null;
-				dir = dirname(dir);
-			}
-		} catch {}
-		return null;
-	}
-}
-async function readLocalDependencies(cwd) {
-	const pkgPath = join(cwd, "package.json");
-	if (!existsSync(pkgPath)) throw new Error("No package.json found in current directory");
-	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-	const deps = {
-		...pkg.dependencies,
-		...pkg.devDependencies
-	};
-	const results = [];
-	for (const [name, version] of Object.entries(deps)) {
-		const parsed = parseVersionSpecifier(name, version, cwd);
-		if (parsed) results.push(parsed);
-	}
-	return results;
-}
-function readLocalPackageInfo(localPath) {
-	const pkgPath = join(localPath, "package.json");
-	if (!existsSync(pkgPath)) return null;
-	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-	let repoUrl;
-	if (pkg.repository?.url) repoUrl = normalizeRepoUrl(pkg.repository.url);
-	else if (typeof pkg.repository === "string") repoUrl = normalizeRepoUrl(pkg.repository);
-	return {
-		name: pkg.name,
-		version: pkg.version || "0.0.0",
-		description: pkg.description,
-		repoUrl,
-		localPath
-	};
-}
-async function resolveLocalPackageDocs(localPath) {
-	const info = readLocalPackageInfo(localPath);
-	if (!info) return null;
-	const result = {
-		name: info.name,
-		version: info.version,
-		description: info.description,
-		repoUrl: info.repoUrl
-	};
-	if (info.repoUrl?.includes("github.com")) {
-		const gh = parseGitHubUrl(info.repoUrl);
-		if (gh) {
-			const gitDocs = await fetchGitDocs(gh.owner, gh.repo, info.version, info.name);
-			if (gitDocs) {
-				result.gitDocsUrl = gitDocs.baseUrl;
-				result.gitRef = gitDocs.ref;
-				result.gitDocsFallback = gitDocs.fallback;
-			}
-			const readmeUrl = await fetchReadme(gh.owner, gh.repo, void 0, result.gitRef);
-			if (readmeUrl) result.readmeUrl = readmeUrl;
-		}
-	}
-	if (!result.readmeUrl && !result.gitDocsUrl) {
-		const readmeFile = readdirSync(localPath).find((f) => /^readme\.md$/i.test(f));
-		if (readmeFile) result.readmeUrl = pathToFileURL(join(localPath, readmeFile)).href;
-	}
-	if (!result.readmeUrl && !result.gitDocsUrl) return null;
-	return result;
-}
-async function fetchPkgDist(name, version) {
-	const cacheDir = getCacheDir(name, version);
-	const pkgDir = join(cacheDir, "pkg");
-	if (existsSync(join(pkgDir, "package.json"))) return pkgDir;
-	const data = await $fetch(`https://registry.npmjs.org/${name}/${version}`).catch(() => null);
-	if (!data) return null;
-	const tarballUrl = data.dist?.tarball;
-	if (!tarballUrl) return null;
-	const tarballRes = await fetch(tarballUrl, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
-	if (!tarballRes?.ok || !tarballRes.body) return null;
-	mkdirSync(pkgDir, { recursive: true });
-	const tmpTarball = join(cacheDir, "_pkg.tgz");
-	const fileStream = createWriteStream(tmpTarball);
-	const reader = tarballRes.body.getReader();
-	await new Promise((res, reject) => {
-		const writable = new Writable({ write(chunk, _encoding, callback) {
-			fileStream.write(chunk, callback);
-		} });
-		writable.on("finish", () => {
-			fileStream.end();
-			res();
-		});
-		writable.on("error", reject);
-		function pump() {
-			reader.read().then(({ done, value }) => {
-				if (done) {
-					writable.end();
-					return;
-				}
-				writable.write(value, () => pump());
-			}).catch(reject);
-		}
-		pump();
-	});
-	const { status } = spawnSync("tar", [
-		"xzf",
-		tmpTarball,
-		"--strip-components=1",
-		"-C",
-		pkgDir
-	], { stdio: "ignore" });
-	if (status !== 0) {
-		rmSync(pkgDir, {
-			recursive: true,
-			force: true
-		});
-		rmSync(tmpTarball, { force: true });
-		return null;
-	}
-	unlinkSync(tmpTarball);
-	return pkgDir;
-}
-async function fetchLatestVersion(packageName) {
-	return (await $fetch(`https://unpkg.com/${packageName}/package.json`).catch(() => null))?.version || null;
-}
-function getInstalledSkillVersion(skillDir) {
-	const skillPath = join(skillDir, "SKILL.md");
-	if (!existsSync(skillPath)) return null;
-	return readFileSync(skillPath, "utf-8").match(/^version:\s*"?([^"\n]+)"?/m)?.[1] || null;
-}
-export { resolveEntryFiles as A, extractBranchHint as B, fetchReadme as C, fetchGitSkills as D, validateGitDocsWithLlms as E, compareSemver as F, verifyUrl as G, isGitHubRepoUrl as H, fetchReleaseNotes as I, generateIssueIndex as J, fetchGitHubIssues as K, generateReleaseIndex as L, formatDiscussionAsMarkdown as M, generateDiscussionIndex as N, parseGitSkillInput as O, fetchBlogReleases as P, parseSemver as R, fetchGitHubRepoMeta as S, isShallowGitDocs as T, normalizeRepoUrl as U, fetchText as V, parseGitHubUrl as W, isGhAvailable as Y, fetchLlmsUrl as _, getInstalledSkillVersion as a, MIN_GIT_DOCS as b, readLocalPackageInfo as c, resolvePackageDocs as d, resolvePackageDocsWithAttempts as f, fetchLlmsTxt as g, extractSections as h, fetchPkgDist as i, fetchGitHubDiscussions as j, parseSkillFrontmatterName as k, resolveInstalledVersion as l, downloadLlmsDocs as m, fetchNpmPackage as n, parseVersionSpecifier as o, searchNpmPackages as p, formatIssueAsMarkdown as q, fetchNpmRegistryMeta as r, readLocalDependencies as s, fetchLatestVersion as t, resolveLocalPackageDocs as u, normalizeLlmsLinks as v, fetchReadmeContent as w, fetchGitDocs as x, parseMarkdownLinks as y, $fetch as z };
-
-//# sourceMappingURL=npm.mjs.map