skilld 0.0.1 → 0.1.2

package/dist/_chunks/releases.mjs

@@ -0,0 +1,986 @@
+import { a as getCacheDir } from "./config.mjs";
+import { join, resolve } from "node:path";
+import { createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, unlinkSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { globby } from "globby";
+import { Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
+let _ghAvailable;
+function isGhAvailable() {
+	if (_ghAvailable !== void 0) return _ghAvailable;
+	try {
+		execSync("gh auth status", { stdio: "ignore" });
+		return _ghAvailable = true;
+	} catch {
+		return _ghAvailable = false;
+	}
+}
+async function fetchGitHubIssues(owner, repo, limit = 20) {
+	if (!isGhAvailable()) return [];
+	try {
+		const result = execSync(`gh api "repos/${owner}/${repo}/issues?per_page=${Math.min(limit * 3, 100)}&state=all" -q '.[] | {number, title, state, labels: [.labels[].name], body, createdAt: .created_at, url: .html_url, isPr: (.pull_request != null), user: .user.login, userType: .user.type}'`, {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		const BOT_USERS = new Set([
+			"renovate[bot]",
+			"dependabot[bot]",
+			"renovate-bot",
+			"dependabot",
+			"github-actions[bot]"
+		]);
+		return result.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line)).filter((issue) => !issue.isPr && !BOT_USERS.has(issue.user) && issue.userType !== "Bot").slice(0, limit).map(({ isPr: _, user: __, userType: ___, ...issue }) => issue);
+	} catch {
+		return [];
+	}
+}
+function formatIssuesAsMarkdown(issues) {
+	if (issues.length === 0) return "";
+	const lines = ["# Recent Issues\n"];
+	for (const issue of issues) {
+		const labels = issue.labels.length > 0 ? ` [${issue.labels.join(", ")}]` : "";
+		lines.push(`## #${issue.number}: ${issue.title}${labels}`);
+		lines.push(`State: ${issue.state} | Created: ${issue.createdAt.split("T")[0]}`);
+		lines.push(`URL: ${issue.url}\n`);
+		if (issue.body) {
+			const body = issue.body.length > 500 ? `${issue.body.slice(0, 500)}...` : issue.body;
+			lines.push(body);
+		}
+		lines.push("\n---\n");
+	}
+	return lines.join("\n");
+}
+async function fetchGitHubDiscussions(owner, repo, limit = 20) {
+	if (!isGhAvailable()) return [];
+	try {
+		const result = execSync(`gh api graphql -f query='${`query { repository(owner: "${owner}", name: "${repo}") { discussions(first: ${Math.min(limit * 2, 50)}, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { number title body category { name } createdAt url upvoteCount comments { totalCount } author { login } } } } }`}'`, {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		const nodes = JSON.parse(result)?.data?.repository?.discussions?.nodes;
+		if (!Array.isArray(nodes)) return [];
+		const BOT_USERS = new Set([
+			"renovate[bot]",
+			"dependabot[bot]",
+			"renovate-bot",
+			"dependabot",
+			"github-actions[bot]"
+		]);
+		return nodes.filter((d) => d.author && !BOT_USERS.has(d.author.login)).slice(0, limit).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
+		}));
+	} catch {
+		return [];
+	}
+}
+function formatDiscussionsAsMarkdown(discussions) {
+	if (discussions.length === 0) return "";
+	const lines = ["# Recent Discussions\n"];
+	for (const d of discussions) {
+		const meta = [
+			d.category && `Category: ${d.category}`,
+			`Created: ${d.createdAt.split("T")[0]}`,
+			d.upvoteCount > 0 && `Upvotes: ${d.upvoteCount}`,
+			d.comments > 0 && `Comments: ${d.comments}`
+		].filter(Boolean).join(" | ");
+		lines.push(`## #${d.number}: ${d.title}`);
+		lines.push(meta);
+		lines.push(`URL: ${d.url}\n`);
+		if (d.body) {
+			const body = d.body.length > 500 ? `${d.body.slice(0, 500)}...` : d.body;
+			lines.push(body);
+		}
+		lines.push("\n---\n");
+	}
+	return lines.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;
+}
+const DOC_OVERRIDES = { vue: {
+	owner: "vuejs",
+	repo: "docs",
+	path: "src",
+	homepage: "https://vuejs.org"
+} };
+function getDocOverride(packageName) {
+	return DOC_OVERRIDES[packageName];
+}
+const USER_AGENT = "skilld/1.0";
+async function fetchText(url) {
+	const res = await fetch(url, { headers: { "User-Agent": USER_AGENT } }).catch(() => null);
+	if (!res?.ok) return null;
+	return res.text();
+}
+async function verifyUrl(url) {
+	const res = await fetch(url, {
+		method: "HEAD",
+		headers: { "User-Agent": USER_AGENT }
+	}).catch(() => null);
+	if (!res?.ok) return false;
+	return !(res.headers.get("content-type") || "").includes("text/html");
+}
+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\/([^/]+)\/([^/]+)/);
+	if (!match) return null;
+	return {
+		owner: match[1],
+		repo: match[2]
+	};
+}
+function normalizeRepoUrl(url) {
+	return url.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^git:\/\//, "https://").replace(/^ssh:\/\/git@github\.com/, "https://github.com");
+}
+async function listFilesAtRef(owner, repo, ref) {
+	const res = await fetch(`https://ungh.cc/repos/${owner}/${repo}/files/${ref}`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return [];
+	return (await res.json().catch(() => null))?.files?.map((f) => f.path) ?? [];
+}
+async function findGitTag(owner, repo, version, packageName) {
+	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
+			};
+		}
+	}
+	for (const branch of ["main", "master"]) {
+		const files = await listFilesAtRef(owner, repo, branch);
+		if (files.length > 0) return {
+			ref: branch,
+			files
+		};
+	}
+	return null;
+}
+async function findLatestReleaseTag(owner, repo, packageName) {
+	const res = await fetch(`https://ungh.cc/repos/${owner}/${repo}/releases`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	const data = await res.json().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) {
+	const override = packageName ? getDocOverride(packageName) : void 0;
+	if (override) {
+		const ref = override.ref || "main";
+		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
+		};
+	}
+	const tag = await findGitTag(owner, repo, version, packageName);
+	if (!tag) return null;
+	let docs = filterDocFiles(tag.files, "docs/");
+	let docsPrefix;
+	if (docs.length === 0) {
+		const discovered = discoverDocFiles(tag.files);
+		if (discovered) {
+			docs = discovered.files;
+			docsPrefix = discovered.prefix || void 0;
+		}
+	}
+	if (docs.length === 0) return null;
+	return {
+		baseUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${tag.ref}`,
+		ref: tag.ref,
+		files: docs,
+		docsPrefix
+	};
+}
+async function searchGitHubRepo(packageName) {
+	if (isGhAvailable()) try {
+		const json = execSync(`gh search repos "${packageName}" --json fullName --limit 5`, {
+			encoding: "utf-8",
+			timeout: 15e3
+		});
+		const repos = JSON.parse(json);
+		const match = repos.find((r) => r.fullName.toLowerCase().endsWith(`/${packageName.toLowerCase()}`) || r.fullName.toLowerCase().endsWith(`/${packageName.replace(/^@.*\//, "").toLowerCase()}`));
+		if (match) return `https://github.com/${match.fullName}`;
+		if (repos.length > 0) return `https://github.com/${repos[0].fullName}`;
+	} catch {}
+	const query = encodeURIComponent(`${packageName} in:name`);
+	const res = await fetch(`https://api.github.com/search/repositories?q=${query}&per_page=5`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	const data = await res.json().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(`/${packageName.replace(/^@.*\//, "").toLowerCase()}`));
+	return match ? `https://github.com/${match.full_name}` : `https://github.com/${data.items[0].full_name}`;
+}
+async function fetchGitHubRepoMeta(owner, repo, packageName) {
+	const override = packageName ? getDocOverride(packageName) : void 0;
+	if (override?.homepage) return { homepage: override.homepage };
+	if (isGhAvailable()) try {
+		const json = execSync(`gh api "repos/${owner}/${repo}" -q '{homepage}'`, {
+			encoding: "utf-8",
+			timeout: 1e4
+		});
+		const data = JSON.parse(json);
+		return data?.homepage ? { homepage: data.homepage } : null;
+	} catch {}
+	const res = await fetch(`https://api.github.com/repos/${owner}/${repo}`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	const data = await res.json().catch(() => null);
+	return data?.homepage ? { homepage: data.homepage } : null;
+}
+async function fetchReadme(owner, repo, subdir) {
+	const unghUrl = subdir ? `https://ungh.cc/repos/${owner}/${repo}/files/main/${subdir}/README.md` : `https://ungh.cc/repos/${owner}/${repo}/readme`;
+	if ((await fetch(unghUrl, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null))?.ok) return `ungh://${owner}/${repo}${subdir ? `/${subdir}` : ""}`;
+	const basePath = subdir ? `${subdir}/` : "";
+	for (const branch of ["main", "master"]) for (const filename of ["README.md", "readme.md"]) {
+		const readmeUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${basePath}${filename}`;
+		if (await verifyUrl(readmeUrl)) return readmeUrl;
+	}
+	return null;
+}
+async function fetchReadmeContent(url) {
+	if (url.startsWith("file://")) {
+		const { readFileSync, existsSync } = await import("node:fs");
+		const { fileURLToPath } = await import("node:url");
+		const filePath = fileURLToPath(url);
+		if (!existsSync(filePath)) return null;
+		return readFileSync(filePath, "utf-8");
+	}
+	if (url.startsWith("ungh://")) {
+		const parts = url.replace("ungh://", "").split("/");
+		const owner = parts[0];
+		const repo = parts[1];
+		const subdir = parts.slice(2).join("/");
+		const unghUrl = subdir ? `https://ungh.cc/repos/${owner}/${repo}/files/main/${subdir}/README.md` : `https://ungh.cc/repos/${owner}/${repo}/readme`;
+		const res = await fetch(unghUrl, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+		if (!res?.ok) return null;
+		const text = await res.text();
+		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 = `${docsUrl.replace(/\/$/, "")}/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;
+}
+async function downloadLlmsDocs(llmsContent, baseUrl, onProgress) {
+	const docs = [];
+	for (let i = 0; i < llmsContent.links.length; i++) {
+		const link = llmsContent.links[i];
+		onProgress?.(link.url, i, llmsContent.links.length);
+		const content = await fetchText(link.url.startsWith("http") ? link.url : `${baseUrl.replace(/\/$/, "")}${link.url.startsWith("/") ? "" : "/"}${link.url}`);
+		if (content && content.length > 100) docs.push({
+			url: link.url,
+			title: link.title,
+			content
+		});
+	}
+	return docs;
+}
+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 fetchNpmPackage(packageName) {
+	let res = await fetch(`https://unpkg.com/${packageName}/package.json`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	return res.json();
+}
+async function fetchNpmRegistryMeta(packageName, version) {
+	const res = await fetch(`https://registry.npmjs.org/${packageName}`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return {};
+	const data = await res.json();
+	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 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 subdir;
+	if (typeof pkg.repository === "object" && pkg.repository?.url) {
+		result.repoUrl = normalizeRepoUrl(pkg.repository.url);
+		subdir = pkg.repository.directory;
+	} else if (typeof pkg.repository === "string") {
+		const repo = pkg.repository.replace(/^github:/, "");
+		if (repo.includes("/") && !repo.includes(":")) result.repoUrl = `https://github.com/${repo}`;
+	}
+	if (result.repoUrl?.includes("github.com")) {
+		const gh = parseGitHubUrl(result.repoUrl);
+		if (gh) {
+			const targetVersion = options.version || pkg.version;
+			if (targetVersion) {
+				onProgress?.("github-docs");
+				const gitDocs = await fetchGitDocs(gh.owner, gh.repo, targetVersion, pkg.name);
+				if (gitDocs) {
+					result.gitDocsUrl = gitDocs.baseUrl;
+					result.gitRef = gitDocs.ref;
+					attempts.push({
+						source: "github-docs",
+						url: gitDocs.baseUrl,
+						status: "success",
+						message: `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) {
+					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, subdir);
+			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"
+			});
+		}
+	} 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) {
+				const targetVersion = options.version || pkg.version;
+				if (targetVersion) {
+					onProgress?.("github-docs");
+					const gitDocs = await fetchGitDocs(gh.owner, gh.repo, targetVersion, pkg.name);
+					if (gitDocs) {
+						result.gitDocsUrl = gitDocs.baseUrl;
+						result.gitRef = gitDocs.ref;
+						attempts.push({
+							source: "github-docs",
+							url: gitDocs.baseUrl,
+							status: "success",
+							message: `Found ${gitDocs.files.length} docs at ${gitDocs.ref}`
+						});
+					}
+				}
+				if (!result.docsUrl) {
+					onProgress?.("github-meta");
+					const repoMeta = await fetchGitHubRepoMeta(gh.owner, gh.repo, pkg.name);
+					if (repoMeta?.homepage) result.docsUrl = repoMeta.homepage;
+				}
+				onProgress?.("readme");
+				const readmeUrl = await fetchReadme(gh.owner, gh.repo);
+				if (readmeUrl) result.readmeUrl = readmeUrl;
+			}
+		} else attempts.push({
+			source: "github-search",
+			status: "not-found",
+			message: "No repository URL in package.json and GitHub search found no match"
+		});
+	}
+	if (pkg.homepage && !isGitHubRepoUrl(pkg.homepage)) result.docsUrl = pkg.homepage;
+	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: `${result.docsUrl}/llms.txt`,
+			status: "not-found",
+			message: "No llms.txt at docs URL"
+		});
+	}
+	if (!result.docsUrl && !result.llmsUrl && !result.readmeUrl && !result.gitDocsUrl && options.cwd) {
+		onProgress?.("local");
+		const pkgDir = join(options.cwd, "node_modules", packageName);
+		for (const filename of ["README.md", "readme.md"]) {
+			const readmePath = join(pkgDir, filename);
+			if (existsSync(readmePath)) {
+				result.readmeUrl = pathToFileURL(readmePath).href;
+				attempts.push({
+					source: "readme",
+					url: readmePath,
+					status: "success",
+					message: "Found local readme in node_modules"
+				});
+				break;
+			}
+		}
+	}
+	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("workspace:")) return {
+		name,
+		version: version.slice(10).replace(/^[\^~*]/, "") || "*"
+	};
+	if (version.startsWith("npm:")) {
+		const specifier = version.slice(4);
+		const atIndex = specifier.startsWith("@") ? specifier.indexOf("@", 1) : specifier.indexOf("@");
+		if (atIndex > 0) return {
+			name: specifier.slice(0, atIndex),
+			version: specifier.slice(atIndex + 1)
+		};
+		return {
+			name: specifier,
+			version: "*"
+		};
+	}
+	if (version.startsWith("file:") || version.startsWith("git:") || version.startsWith("git+")) return null;
+	return {
+		name,
+		version: version.replace(/^[\^~>=<]/, "")
+	};
+}
+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)) {
+		if (name.startsWith("@types/") || [
+			"typescript",
+			"eslint",
+			"prettier",
+			"vitest",
+			"jest"
+		].includes(name)) continue;
+		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;
+			}
+			const readmeUrl = await fetchReadme(gh.owner, gh.repo);
+			if (readmeUrl) result.readmeUrl = readmeUrl;
+		}
+	}
+	if (!result.readmeUrl && !result.gitDocsUrl) {
+		const localReadme = join(localPath, "README.md");
+		if (existsSync(localReadme)) result.readmeUrl = pathToFileURL(localReadme).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 res = await fetch(`https://registry.npmjs.org/${name}/${version}`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	const tarballUrl = (await res.json()).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();
+	});
+	try {
+		execSync(`tar xzf "${tmpTarball}" --strip-components=1 -C "${pkgDir}"`, { stdio: "ignore" });
+	} catch {
+		rmSync(pkgDir, {
+			recursive: true,
+			force: true
+		});
+		rmSync(tmpTarball, { force: true });
+		return null;
+	}
+	unlinkSync(tmpTarball);
+	return pkgDir;
+}
+async function fetchLatestVersion(packageName) {
+	const res = await fetch(`https://unpkg.com/${packageName}/package.json`, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+	if (!res?.ok) return null;
+	return (await res.json()).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;
+}
+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],
+		patch: +match[3],
+		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 json = execSync(`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"
+			]
+		});
+		return JSON.parse(json);
+	} catch {
+		return [];
+	}
+}
+async function fetchReleasesViaUngh(owner, repo) {
+	const res = await fetch(`https://ungh.cc/repos/${owner}/${repo}/releases`, {
+		headers: { "User-Agent": "skilld/1.0" },
+		signal: AbortSignal.timeout(15e3)
+	}).catch(() => null);
+	if (!res?.ok) return [];
+	return (await res.json().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) {
+	const hasMonorepoTags = packageName && releases.some((r) => tagMatchesPackage(r.tag, packageName));
+	return releases.filter((r) => {
+		if (r.prerelease) return false;
+		if (hasMonorepoTags && packageName) {
+			if (!tagMatchesPackage(r.tag, packageName)) return false;
+			const ver = extractVersion(r.tag, packageName);
+			return ver && parseSemver(ver);
+		}
+		return parseSemver(r.tag);
+	}).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) {
+	const date = (release.publishedAt || release.createdAt).split("T")[0];
+	return `# ${release.name || release.tag}\n\nTag: ${release.tag} | Published: ${date}\n\n${release.markdown}`;
+}
+async function fetchChangelog(owner, repo, ref) {
+	for (const filename of [
+		"CHANGELOG.md",
+		"changelog.md",
+		"CHANGES.md"
+	]) {
+		const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filename}`;
+		const res = await fetch(url, {
+			headers: { "User-Agent": "skilld/1.0" },
+			signal: AbortSignal.timeout(1e4)
+		}).catch(() => null);
+		if (res?.ok) return res.text();
+	}
+	return null;
+}
+async function fetchReleaseNotes(owner, repo, installedVersion, gitRef, packageName) {
+	const selected = selectReleases(await fetchAllReleases(owner, repo), packageName);
+	if (selected.length > 0) return selected.map((r) => {
+		return {
+			path: `releases/${r.tag.includes("@") || r.tag.startsWith("v") ? r.tag : `v${r.tag}`}.md`,
+			content: formatRelease(r)
+		};
+	});
+	const changelog = await fetchChangelog(owner, repo, gitRef || "main");
+	if (!changelog) return [];
+	return [{
+		path: "CHANGELOG.md",
+		content: changelog
+	}];
+}
+export { resolveEntryFiles as A, fetchText as C, verifyUrl as D, parseGitHubUrl as E, isGhAvailable as F, formatDiscussionsAsMarkdown as M, fetchGitHubIssues as N, DOC_OVERRIDES as O, formatIssuesAsMarkdown as P, fetchReadmeContent as S, normalizeRepoUrl as T, normalizeLlmsLinks as _, fetchPkgDist as a, fetchGitHubRepoMeta as b, readLocalDependencies as c, resolvePackageDocs as d, resolvePackageDocsWithAttempts as f, fetchLlmsUrl as g, fetchLlmsTxt as h, fetchNpmRegistryMeta as i, fetchGitHubDiscussions as j, getDocOverride as k, readLocalPackageInfo as l, extractSections as m, fetchLatestVersion as n, getInstalledSkillVersion as o, downloadLlmsDocs as p, fetchNpmPackage as r, parseVersionSpecifier as s, fetchReleaseNotes as t, resolveLocalPackageDocs as u, parseMarkdownLinks as v, isGitHubRepoUrl as w, fetchReadme as x, fetchGitDocs as y };
+
+//# sourceMappingURL=releases.mjs.map