skilld 0.0.1 → 0.1.1

package/dist/_chunks/llm.mjs

@@ -0,0 +1,877 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import { exec, execSync, spawn } from "node:child_process";
+import { globby } from "globby";
+import { readFile } from "node:fs/promises";
+import { findDynamicImports, findStaticImports } from "mlly";
+import { createHash } from "node:crypto";
+const home = homedir();
+const configHome = process.env.XDG_CONFIG_HOME || join(home, ".config");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+const codexHome = process.env.CODEX_HOME || join(home, ".codex");
+const agents = {
+	"claude-code": {
+		name: "claude-code",
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		globalSkillsDir: join(claudeHome, "skills"),
+		detectInstalled: () => existsSync(claudeHome),
+		cli: "claude"
+	},
+	"cursor": {
+		name: "cursor",
+		displayName: "Cursor",
+		skillsDir: ".cursor/skills",
+		globalSkillsDir: join(home, ".cursor/skills"),
+		detectInstalled: () => existsSync(join(home, ".cursor"))
+	},
+	"windsurf": {
+		name: "windsurf",
+		displayName: "Windsurf",
+		skillsDir: ".windsurf/skills",
+		globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+		detectInstalled: () => existsSync(join(home, ".codeium/windsurf"))
+	},
+	"cline": {
+		name: "cline",
+		displayName: "Cline",
+		skillsDir: ".cline/skills",
+		globalSkillsDir: join(home, ".cline/skills"),
+		detectInstalled: () => existsSync(join(home, ".cline"))
+	},
+	"codex": {
+		name: "codex",
+		displayName: "Codex",
+		skillsDir: ".codex/skills",
+		globalSkillsDir: join(codexHome, "skills"),
+		detectInstalled: () => existsSync(codexHome),
+		cli: "codex"
+	},
+	"github-copilot": {
+		name: "github-copilot",
+		displayName: "GitHub Copilot",
+		skillsDir: ".github/skills",
+		globalSkillsDir: join(home, ".copilot/skills"),
+		detectInstalled: () => existsSync(join(home, ".copilot"))
+	},
+	"gemini-cli": {
+		name: "gemini-cli",
+		displayName: "Gemini CLI",
+		skillsDir: ".gemini/skills",
+		globalSkillsDir: join(home, ".gemini/skills"),
+		detectInstalled: () => existsSync(join(home, ".gemini")),
+		cli: "gemini"
+	},
+	"goose": {
+		name: "goose",
+		displayName: "Goose",
+		skillsDir: ".goose/skills",
+		globalSkillsDir: join(configHome, "goose/skills"),
+		detectInstalled: () => existsSync(join(configHome, "goose")),
+		cli: "goose"
+	},
+	"amp": {
+		name: "amp",
+		displayName: "Amp",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "agents/skills"),
+		detectInstalled: () => existsSync(join(configHome, "amp"))
+	},
+	"opencode": {
+		name: "opencode",
+		displayName: "OpenCode",
+		skillsDir: ".opencode/skills",
+		globalSkillsDir: join(configHome, "opencode/skills"),
+		detectInstalled: () => existsSync(join(configHome, "opencode"))
+	},
+	"roo": {
+		name: "roo",
+		displayName: "Roo Code",
+		skillsDir: ".roo/skills",
+		globalSkillsDir: join(home, ".roo/skills"),
+		detectInstalled: () => existsSync(join(home, ".roo"))
+	}
+};
+function detectInstalledAgents() {
+	return Object.entries(agents).filter(([_, config]) => config.detectInstalled()).map(([type]) => type);
+}
+function detectTargetAgent() {
+	if (process.env.CLAUDE_CODE || process.env.CLAUDE_CONFIG_DIR) return "claude-code";
+	if (process.env.CURSOR_SESSION || process.env.CURSOR_TRACE_ID) return "cursor";
+	if (process.env.WINDSURF_SESSION) return "windsurf";
+	if (process.env.CLINE_TASK_ID) return "cline";
+	if (process.env.CODEX_HOME || process.env.CODEX_SESSION) return "codex";
+	if (process.env.GITHUB_COPILOT_SESSION) return "github-copilot";
+	if (process.env.GEMINI_API_KEY && process.env.GEMINI_SESSION) return "gemini-cli";
+	if (process.env.GOOSE_SESSION) return "goose";
+	if (process.env.AMP_SESSION) return "amp";
+	if (process.env.OPENCODE_SESSION) return "opencode";
+	if (process.env.ROO_SESSION) return "roo";
+	const cwd = process.cwd();
+	if (existsSync(join(cwd, ".claude")) || existsSync(join(cwd, "CLAUDE.md"))) return "claude-code";
+	if (existsSync(join(cwd, ".cursor")) || existsSync(join(cwd, ".cursorrules"))) return "cursor";
+	if (existsSync(join(cwd, ".windsurf")) || existsSync(join(cwd, ".windsurfrules"))) return "windsurf";
+	if (existsSync(join(cwd, ".cline"))) return "cline";
+	if (existsSync(join(cwd, ".codex"))) return "codex";
+	if (existsSync(join(cwd, ".github", "copilot-instructions.md"))) return "github-copilot";
+	if (existsSync(join(cwd, ".gemini")) || existsSync(join(cwd, "AGENTS.md"))) return "gemini-cli";
+	if (existsSync(join(cwd, ".goose"))) return "goose";
+	if (existsSync(join(cwd, ".roo"))) return "roo";
+	return null;
+}
+function getAgentVersion(agentType) {
+	const agent = agents[agentType];
+	if (!agent.cli) return null;
+	try {
+		const output = execSync(`${agent.cli} --version`, {
+			encoding: "utf-8",
+			timeout: 3e3,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+		const match = output.match(/v?(\d+\.\d+\.\d+(?:-[a-z0-9.]+)?)/);
+		return match ? match[1] : output.split("\n")[0];
+	} catch {
+		return null;
+	}
+}
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+const NUXT_ECOSYSTEM = [
+	"vue",
+	"nitro",
+	"h3"
+];
+async function findNuxtConfig(cwd) {
+	for (const name of NUXT_CONFIG_FILES) {
+		const path = join(cwd, name);
+		const content = await readFile(path, "utf8").catch(() => null);
+		if (content) return {
+			path,
+			content
+		};
+	}
+	return null;
+}
+function extractModuleStrings(node) {
+	if (!node || typeof node !== "object") return [];
+	if (node.type === "Property" && !node.computed && node.key?.type === "Identifier" && node.key.name === "modules" && node.value?.type === "ArrayExpression") return node.value.elements.filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+	const results = [];
+	if (Array.isArray(node)) for (const child of node) results.push(...extractModuleStrings(child));
+	else for (const key of Object.keys(node)) {
+		if (key === "start" || key === "end" || key === "type") continue;
+		const val = node[key];
+		if (val && typeof val === "object") results.push(...extractModuleStrings(val));
+	}
+	return results;
+}
+async function detectNuxtModules(cwd) {
+	const config = await findNuxtConfig(cwd);
+	if (!config) return [];
+	const { parseSync } = await import("oxc-parser");
+	const modules = extractModuleStrings(parseSync(config.path, config.content).program);
+	const seen = /* @__PURE__ */ new Set();
+	const packages = [];
+	for (const mod of modules) if (!seen.has(mod)) {
+		seen.add(mod);
+		packages.push({
+			name: mod,
+			count: 0,
+			source: "preset"
+		});
+	}
+	for (const pkg of NUXT_ECOSYSTEM) if (!seen.has(pkg)) {
+		seen.add(pkg);
+		packages.push({
+			name: pkg,
+			count: 0,
+			source: "preset"
+		});
+	}
+	return packages;
+}
+async function detectPresetPackages(cwd) {
+	return detectNuxtModules(cwd);
+}
+const PATTERNS = ["**/*.{ts,js,vue,mjs,cjs,tsx,jsx,mts,cts}"];
+const IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/coverage/**"
+];
+function addPackage(counts, specifier) {
+	if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) return;
+	const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+	if (!isNodeBuiltin(name)) counts.set(name, (counts.get(name) || 0) + 1);
+}
+async function detectImportedPackages(cwd = process.cwd()) {
+	try {
+		const counts = /* @__PURE__ */ new Map();
+		const files = await globby(PATTERNS, {
+			cwd,
+			ignore: IGNORE,
+			gitignore: true,
+			absolute: true
+		});
+		await Promise.all(files.map(async (file) => {
+			const content = await readFile(file, "utf8");
+			for (const imp of findStaticImports(content)) addPackage(counts, imp.specifier);
+			for (const imp of findDynamicImports(content)) {
+				const match = imp.expression.match(/^['"]([^'"]+)['"]$/);
+				if (match) addPackage(counts, match[1]);
+			}
+		}));
+		const packages = [...counts.entries()].map(([name, count]) => ({
+			name,
+			count,
+			source: "import"
+		})).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+		const presets = await detectPresetPackages(cwd);
+		const importNames = new Set(packages.map((p) => p.name));
+		for (const preset of presets) if (!importNames.has(preset.name)) packages.push(preset);
+		return { packages };
+	} catch (err) {
+		return {
+			packages: [],
+			error: String(err)
+		};
+	}
+}
+const NODE_BUILTINS = new Set([
+	"assert",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"https",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"sys",
+	"timers",
+	"tls",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+]);
+function isNodeBuiltin(pkg) {
+	const base = pkg.startsWith("node:") ? pkg.slice(5) : pkg;
+	return NODE_BUILTINS.has(base.split("/")[0]);
+}
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").slice(0, 255) || "unnamed-skill";
+}
+function installSkillForAgents(skillName, skillContent, options = {}) {
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const sanitized = sanitizeName(skillName);
+	const targetAgents = options.agents || detectInstalledAgents();
+	const installed = [];
+	const paths = [];
+	for (const agentType of targetAgents) {
+		const agent = agents[agentType];
+		if (isGlobal && !agent.globalSkillsDir) continue;
+		const skillDir = join(isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir), sanitized);
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(join(skillDir, "_SKILL.md"), skillContent);
+		if (options.files) for (const [filename, content] of Object.entries(options.files)) writeFileSync(join(skillDir, filename), content);
+		installed.push(agentType);
+		paths.push(skillDir);
+	}
+	return {
+		installed,
+		paths
+	};
+}
+function formatDocTree(files) {
+	const dirs = /* @__PURE__ */ new Map();
+	for (const f of files) {
+		const dir = dirname(f);
+		dirs.set(dir, (dirs.get(dir) || 0) + 1);
+	}
+	return [...dirs.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([dir, count]) => `- \`${dir}/\` (${count} .md files)`).join("\n");
+}
+function generateImportantBlock({ packageName, hasGithub, hasReleases, hasChangelog, docsType, hasShippedDocs, skillDir }) {
+	const searchDesc = hasGithub ? "Docs + GitHub" : "Docs";
+	const searchCmd = `\`Bash 'npx skilld ${packageName} -q "<query>"'\``;
+	const docsPath = hasShippedDocs ? `\`${skillDir}/.skilld/pkg/docs/\` or \`${skillDir}/.skilld/pkg/README.md\`` : docsType === "llms.txt" ? `\`${skillDir}/.skilld/docs/llms.txt\`` : docsType === "readme" ? `\`${skillDir}/.skilld/pkg/README.md\`` : `\`${skillDir}/.skilld/docs/\``;
+	const rows = [
+		[searchDesc, searchCmd],
+		["Docs", docsPath],
+		["Package", `\`${skillDir}/.skilld/pkg/\``]
+	];
+	if (hasGithub) rows.push(["GitHub", `\`${skillDir}/.skilld/github/\``]);
+	if (hasChangelog) rows.push(["Changelog", `\`${skillDir}/.skilld/pkg/${hasChangelog}\``]);
+	if (hasReleases) rows.push(["Releases", `\`${skillDir}/.skilld/releases/\``]);
+	return `**IMPORTANT:** Use these references\n\n${[
+		"| Resource | Command |",
+		"|----------|---------|",
+		...rows.map(([desc, cmd]) => `| ${desc} | ${cmd} |`)
+	].join("\n")}`;
+}
+function buildSkillPrompt(opts) {
+	const { packageName, skillDir, version, hasGithub, hasReleases, hasChangelog, docFiles, docsType = "docs", hasShippedDocs = false, sections, customPrompt } = opts;
+	const hasBestPractices = !sections || sections.includes("best-practices");
+	const hasApi = !sections || sections.includes("api");
+	const hasCustom = sections?.includes("custom") && customPrompt;
+	const versionContext = version ? ` v${version}` : "";
+	const docsSection = docFiles?.length ? `**Documentation** (use Read tool to explore):\n${formatDocTree(docFiles)}` : "";
+	const importantBlock = generateImportantBlock({
+		packageName,
+		hasGithub,
+		hasReleases,
+		hasChangelog,
+		docsType,
+		hasShippedDocs,
+		skillDir
+	});
+	const taskParts = [];
+	if (hasBestPractices) taskParts.push(`Find novel best practices from the references. Every item must link to its source.
+
+Look for: tip, warning, best practice, avoid, pitfall, note, important.`);
+	if (hasApi) taskParts.push(`**Generate an API reference section.** List the package's exported functions/composables grouped by documentation page or category. Each function gets a one-liner description. Link group headings to the source doc URL when available.`);
+	if (hasCustom) taskParts.push(`**Custom instructions from the user:**\n${customPrompt}`);
+	const formatParts = [];
+	if (hasBestPractices) formatParts.push(`\`\`\`
+[✅ descriptive title](./.skilld/path/to/source.md)
+\`\`\`ts
+code example (1-3 lines)
+\`\`\`
+
+[❌ pitfall title](./.skilld/path/to/source.md#section)
+\`\`\`ts
+wrong // correct way
+\`\`\`
+\`\`\``);
+	if (hasApi) formatParts.push(`API reference format${hasBestPractices ? " (place at end, after best practices)" : ""}:
+\`\`\`
+## API
+
+### [Category Name](./.skilld/docs/category.md)
+- functionName — one-line description
+- anotherFn — one-line description
+\`\`\`
+
+Link group headings to the local \`./.skilld/\` source file.
+
+For single-page-docs packages, use a flat list without grouping. Skip the API section entirely for packages with fewer than 3 exports.`);
+	const rules = [];
+	if (hasBestPractices) rules.push("- **5-10 best practice items**, MAX 150 lines for best practices");
+	if (hasApi) rules.push("- **API section:** list all public exports, grouped by doc page, MAX 80 lines");
+	rules.push("- Link to exact source file where you found info", "- TypeScript only, Vue uses `<script setup lang=\"ts\">`", "- Imperative voice (\"Use X\" not \"You should use X\")", "- **NEVER fetch external URLs.** All information is in the local `./.skilld/` directory. Use Read/Glob only.");
+	return `Generate SKILL.md body for "${packageName}"${versionContext}.
+
+${importantBlock}
+${docsSection ? `${docsSection}\n` : ""}
+
+## Skill Quality Principles
+
+The context window is a shared resource. Skills share it with system prompt, conversation history, other skills, and the user request.
+
+- **Only add what Claude doesn't know.** Claude already knows general programming, popular APIs, common patterns. Challenge every line: "Does this justify its token cost?"
+- **Prefer concise examples over verbose explanations.** A 2-line code example beats a paragraph.
+- **Skip:** API signatures, installation steps, tutorials, marketing, general programming knowledge, anything in the package README that's obvious
+- **Include:** Non-obvious gotchas, surprising defaults, version-specific breaking changes, pitfalls from issues, patterns that differ from what Claude would assume
+
+## Task
+
+${taskParts.join("\n\n")}
+
+## Format
+
+${formatParts.join("\n\n")}
+
+## Rules
+
+${rules.join("\n")}
+
+## Output
+
+Write the body content to \`${skillDir}/_SKILL.md\` using the Write tool.
+Do NOT output the content to stdout. Write it to the file only.
+`;
+}
+const FILE_PATTERN_MAP = {
+	"vue": ["*.vue"],
+	"svelte": ["*.svelte"],
+	"astro": ["*.astro"],
+	"solid-js": ["*.jsx", "*.tsx"],
+	"qwik": ["*.tsx"],
+	"marko": ["*.marko"],
+	"riot": ["*.riot"],
+	"typescript": [
+		"*.ts",
+		"*.tsx",
+		"*.mts",
+		"*.cts"
+	],
+	"coffeescript": ["*.coffee"],
+	"livescript": ["*.ls"],
+	"elm": ["*.elm"],
+	"sass": ["*.scss", "*.sass"],
+	"less": ["*.less"],
+	"stylus": ["*.styl"],
+	"postcss": ["*.css", "*.pcss"],
+	"pug": ["*.pug"],
+	"ejs": ["*.ejs"],
+	"handlebars": ["*.hbs", "*.handlebars"],
+	"mustache": ["*.mustache"],
+	"nunjucks": ["*.njk"],
+	"liquid": ["*.liquid"],
+	"yaml": ["*.yaml", "*.yml"],
+	"js-yaml": ["*.yaml", "*.yml"],
+	"toml": ["*.toml"],
+	"@iarna/toml": ["*.toml"],
+	"json5": ["*.json5"],
+	"jsonc-parser": ["*.jsonc"],
+	"markdown-it": ["*.md"],
+	"marked": ["*.md"],
+	"remark": ["*.md", "*.mdx"],
+	"@mdx-js/mdx": ["*.mdx"],
+	"graphql": ["*.graphql", "*.gql"],
+	"graphql-tag": ["*.graphql", "*.gql"],
+	"@graphql-codegen/cli": ["*.graphql", "*.gql"],
+	"prisma": ["*.prisma"],
+	"@prisma/client": ["*.prisma"],
+	"wasm-pack": ["*.wasm"]
+};
+function generateSkillMd(opts) {
+	const header = generatePackageHeader(opts);
+	const refs = generateReferencesBlock(opts);
+	const content = opts.body ? `${header}\n\n${refs}${opts.body}` : `${header}\n\n${refs}`;
+	return `${generateFrontmatter(opts)}${content}
+${generateFooter(opts.relatedSkills)}`;
+}
+function formatRelativeDate(isoDate) {
+	const date = new Date(isoDate);
+	const diffMs = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+	const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+	if (diffDays === 0) return "today";
+	if (diffDays === 1) return "yesterday";
+	if (diffDays < 7) return `${diffDays} days ago`;
+	if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
+	if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
+	return `${Math.floor(diffDays / 365)} years ago`;
+}
+function generatePackageHeader({ name, description, version, releasedAt, dependencies, distTags, hasGithub }) {
+	const lines = [`# ${name}`];
+	if (description) lines.push("", `> ${description}`);
+	if (version) {
+		const relativeDate = releasedAt ? formatRelativeDate(releasedAt) : "";
+		const versionStr = relativeDate ? `${version} (${relativeDate})` : version;
+		lines.push("", `**Version:** ${versionStr}`);
+	}
+	if (dependencies && Object.keys(dependencies).length > 0) {
+		const deps = Object.entries(dependencies).map(([n, v]) => `${n}@${v}`).join(", ");
+		lines.push(`**Deps:** ${deps}`);
+	}
+	if (distTags && Object.keys(distTags).length > 0) {
+		const tags = Object.entries(distTags).map(([tag, info]) => {
+			const relDate = info.releasedAt ? ` (${formatRelativeDate(info.releasedAt)})` : "";
+			return `${tag}: ${info.version}${relDate}`;
+		}).join(", ");
+		lines.push(`**Tags:** ${tags}`);
+	}
+	if (hasGithub) lines.push(`**GitHub:** \`./.skilld/github/\``);
+	return lines.join("\n");
+}
+function generateFrontmatter({ name, version, globs }) {
+	const patterns = globs ?? FILE_PATTERN_MAP[name];
+	const description = patterns?.length ? `Load skill when working with ${patterns.join(", ")} files or importing from "${name}".` : `Load skill when using anything from the package "${name}".`;
+	const lines = [
+		"---",
+		`name: ${sanitizeName(name)}-skilld`,
+		`description: ${description}`
+	];
+	if (patterns?.length) lines.push(`globs: ${JSON.stringify(patterns)}`);
+	if (version) lines.push(`version: "${version}"`);
+	lines.push("---", "", "");
+	return lines.join("\n");
+}
+function generateReferencesBlock({ name, hasGithub, hasReleases, docsType = "docs", hasShippedDocs = false, pkgFiles = [] }) {
+	const lines = [
+		"## References",
+		"",
+		`IMPORTANT: Search all references (semantic and keyword) using \`skilld ${name} -q "<query>"\`.`,
+		""
+	];
+	const fileList = pkgFiles.length ? ` — ${pkgFiles.map((f) => `\`${f}\``).join(", ")}` : "";
+	lines.push(`**Package:** \`./.skilld/pkg/\`${fileList}`);
+	if (hasShippedDocs) lines.push(`**Docs:** \`./.skilld/pkg/docs/\``);
+	else if (docsType === "llms.txt") lines.push(`**Docs:** \`./.skilld/docs/llms.txt\``);
+	else if (docsType === "docs") lines.push(`**Docs:** \`./.skilld/docs/\``);
+	if (hasGithub) lines.push(`**GitHub:** \`./.skilld/github/\``);
+	if (hasReleases) lines.push(`**Releases:** \`./.skilld/releases/\``);
+	lines.push("");
+	return lines.join("\n");
+}
+function generateFooter(relatedSkills) {
+	if (relatedSkills.length === 0) return "";
+	return `\nRelated: ${relatedSkills.join(", ")}\n`;
+}
+const CACHE_DIR = join(homedir(), ".skilld", "llm-cache");
+const CLI_MODELS = {
+	"opus": {
+		cli: "claude",
+		model: "opus",
+		name: "Opus 4.5",
+		hint: "Most capable",
+		agentId: "claude-code"
+	},
+	"sonnet": {
+		cli: "claude",
+		model: "sonnet",
+		name: "Sonnet 4.5",
+		hint: "Balanced",
+		recommended: true,
+		agentId: "claude-code"
+	},
+	"haiku": {
+		cli: "claude",
+		model: "haiku",
+		name: "Haiku 4.5",
+		hint: "Fastest",
+		agentId: "claude-code"
+	},
+	"gemini-2.5-pro": {
+		cli: "gemini",
+		model: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		hint: "Most capable",
+		agentId: "gemini-cli"
+	},
+	"gemini-2.5-flash": {
+		cli: "gemini",
+		model: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash",
+		hint: "Balanced",
+		agentId: "gemini-cli"
+	},
+	"gemini-2.5-flash-lite": {
+		cli: "gemini",
+		model: "gemini-2.5-flash-lite",
+		name: "Gemini 2.5 Flash Lite",
+		hint: "Fastest",
+		agentId: "gemini-cli"
+	},
+	"gemini-3-pro": {
+		cli: "gemini",
+		model: "gemini-3-pro-preview",
+		name: "Gemini 3 Pro",
+		hint: "Most capable",
+		agentId: "gemini-cli"
+	},
+	"gemini-3-flash": {
+		cli: "gemini",
+		model: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash",
+		hint: "Balanced",
+		agentId: "gemini-cli"
+	}
+};
+function getModelName(id) {
+	return CLI_MODELS[id]?.name ?? id;
+}
+async function getAvailableModels() {
+	const { promisify } = await import("node:util");
+	const execAsync = promisify(exec);
+	const agentsWithCli = detectInstalledAgents().filter((id) => agents[id].cli);
+	const cliChecks = await Promise.all(agentsWithCli.map(async (agentId) => {
+		const cli = agents[agentId].cli;
+		try {
+			await execAsync(`which ${cli}`);
+			return agentId;
+		} catch {
+			return null;
+		}
+	}));
+	const availableAgentIds = new Set(cliChecks.filter((id) => id != null));
+	return Object.entries(CLI_MODELS).filter(([_, config]) => availableAgentIds.has(config.agentId)).map(([id, config]) => ({
+		id,
+		name: config.name,
+		hint: config.hint,
+		recommended: config.recommended,
+		agentId: config.agentId,
+		agentName: agents[config.agentId]?.displayName ?? config.agentId
+	}));
+}
+function resolveReferenceDirs(skillDir) {
+	const refsDir = join(skillDir, ".skilld");
+	if (!existsSync(refsDir)) return [];
+	return readdirSync(refsDir).map((entry) => join(refsDir, entry)).filter((p) => lstatSync(p).isSymbolicLink()).map((p) => realpathSync(p));
+}
+function buildCliArgs(cli, model, skillDir) {
+	const symlinkDirs = resolveReferenceDirs(skillDir);
+	if (cli === "claude") return [
+		"-p",
+		"--model",
+		model,
+		"--output-format",
+		"stream-json",
+		"--verbose",
+		"--include-partial-messages",
+		"--allowedTools",
+		"Read Glob Grep Write",
+		"--add-dir",
+		skillDir,
+		...symlinkDirs.flatMap((d) => ["--add-dir", d]),
+		"--dangerously-skip-permissions",
+		"--no-session-persistence"
+	];
+	return [
+		"-o",
+		"stream-json",
+		"-m",
+		model,
+		"-y",
+		"--include-directories",
+		skillDir,
+		...symlinkDirs.flatMap((d) => ["--include-directories", d])
+	];
+}
+function hashPrompt(prompt, model) {
+	return createHash("sha256").update(`exec:${model}:${prompt}`).digest("hex").slice(0, 16);
+}
+function getCached(prompt, model, maxAge = 10080 * 60 * 1e3) {
+	const path = join(CACHE_DIR, `${hashPrompt(prompt, model)}.json`);
+	if (!existsSync(path)) return null;
+	try {
+		const { text, timestamp } = JSON.parse(readFileSync(path, "utf-8"));
+		return Date.now() - timestamp > maxAge ? null : text;
+	} catch {
+		return null;
+	}
+}
+function setCache(prompt, model, text) {
+	mkdirSync(CACHE_DIR, { recursive: true });
+	writeFileSync(join(CACHE_DIR, `${hashPrompt(prompt, model)}.json`), JSON.stringify({
+		text,
+		model,
+		timestamp: Date.now()
+	}));
+}
+function parseClaudeLine(line) {
+	try {
+		const obj = JSON.parse(line);
+		if (obj.type === "stream_event") {
+			const evt = obj.event;
+			if (!evt) return {};
+			if (evt.type === "content_block_delta" && evt.delta?.type === "text_delta") return { textDelta: evt.delta.text };
+			if (evt.type === "content_block_start" && evt.content_block?.type === "tool_use") return { toolName: evt.content_block.name };
+			return {};
+		}
+		if (obj.type === "assistant" && obj.message?.content) {
+			const content = obj.message.content;
+			const tools = content.filter((c) => c.type === "tool_use");
+			if (tools.length) {
+				const names = tools.map((t) => t.name);
+				const hint = tools.map((t) => {
+					const input = t.input || {};
+					return input.file_path || input.path || input.pattern || input.query || input.command || "";
+				}).filter(Boolean).join(", ");
+				return {
+					toolName: names.join(", "),
+					toolHint: hint || void 0
+				};
+			}
+			const text = content.filter((c) => c.type === "text").map((c) => c.text).join("");
+			if (text) return { fullText: text };
+		}
+		if (obj.type === "result") {
+			const u = obj.usage;
+			return {
+				done: true,
+				usage: u ? {
+					input: u.input_tokens ?? u.inputTokens ?? 0,
+					output: u.output_tokens ?? u.outputTokens ?? 0
+				} : void 0,
+				cost: obj.total_cost_usd,
+				turns: obj.num_turns
+			};
+		}
+	} catch {}
+	return {};
+}
+function parseGeminiLine(line) {
+	try {
+		const obj = JSON.parse(line);
+		if (obj.type === "message" && obj.role === "assistant" && obj.content) return obj.delta ? { textDelta: obj.content } : { fullText: obj.content };
+		if (obj.type === "tool_use" || obj.type === "tool_call") return { toolName: obj.name || obj.tool || "tool" };
+		if (obj.type === "result") {
+			const s = obj.stats;
+			return {
+				done: true,
+				usage: s ? {
+					input: s.input_tokens ?? s.input ?? 0,
+					output: s.output_tokens ?? s.output ?? 0
+				} : void 0,
+				turns: s?.tool_calls
+			};
+		}
+	} catch {}
+	return {};
+}
+async function optimizeDocs(opts) {
+	const { packageName, skillDir, model = "sonnet", version, hasGithub, docFiles, onProgress, timeout = 18e4, noCache, sections, customPrompt } = opts;
+	const prompt = buildSkillPrompt({
+		packageName,
+		skillDir,
+		version,
+		hasGithub,
+		docFiles,
+		sections,
+		customPrompt
+	});
+	if (!noCache) {
+		const cached = getCached(prompt, model);
+		if (cached) {
+			onProgress?.({
+				chunk: "[cached]",
+				type: "text",
+				text: cached,
+				reasoning: ""
+			});
+			return {
+				optimized: cached,
+				wasOptimized: true,
+				finishReason: "cached"
+			};
+		}
+	}
+	const cliConfig = CLI_MODELS[model];
+	if (!cliConfig) return {
+		optimized: "",
+		wasOptimized: false,
+		error: `No CLI mapping for model: ${model}`
+	};
+	const { cli, model: cliModel } = cliConfig;
+	const args = buildCliArgs(cli, cliModel, skillDir);
+	const parseLine = cli === "claude" ? parseClaudeLine : parseGeminiLine;
+	writeFileSync(join(skillDir, "PROMPT.md"), prompt);
+	const outputPath = join(skillDir, "__SKILL.md");
+	return new Promise((resolve) => {
+		const proc = spawn(cli, args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout,
+			env: {
+				...process.env,
+				NO_COLOR: "1"
+			}
+		});
+		let buffer = "";
+		let usage;
+		let cost;
+		onProgress?.({
+			chunk: "[starting...]",
+			type: "reasoning",
+			text: "",
+			reasoning: ""
+		});
+		proc.stdin.write(prompt);
+		proc.stdin.end();
+		proc.stdout.on("data", (chunk) => {
+			buffer += chunk.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				const evt = parseLine(line);
+				if (evt.toolName) {
+					const hint = evt.toolHint ? `[${evt.toolName}: ${shortenPath(evt.toolHint)}]` : `[${evt.toolName}]`;
+					onProgress?.({
+						chunk: hint,
+						type: "reasoning",
+						text: "",
+						reasoning: hint
+					});
+				}
+				if (evt.usage) usage = evt.usage;
+				if (evt.cost != null) cost = evt.cost;
+			}
+		});
+		let stderr = "";
+		proc.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		proc.on("close", (code) => {
+			if (buffer.trim()) {
+				const evt = parseLine(buffer);
+				if (evt.usage) usage = evt.usage;
+				if (evt.cost != null) cost = evt.cost;
+			}
+			const optimized = existsSync(outputPath) ? readFileSync(outputPath, "utf-8").trim() : "";
+			if (!optimized && code !== 0) {
+				resolve({
+					optimized: "",
+					wasOptimized: false,
+					error: stderr.trim() || `CLI exited with code ${code}`
+				});
+				return;
+			}
+			if (!noCache && optimized) setCache(prompt, model, optimized);
+			const usageResult = usage ? {
+				inputTokens: usage.input,
+				outputTokens: usage.output,
+				totalTokens: usage.input + usage.output
+			} : void 0;
+			resolve({
+				optimized,
+				wasOptimized: !!optimized,
+				finishReason: code === 0 ? "stop" : "error",
+				usage: usageResult,
+				cost
+			});
+		});
+		proc.on("error", (err) => {
+			resolve({
+				optimized: "",
+				wasOptimized: false,
+				error: err.message
+			});
+		});
+	});
+}
+function shortenPath(p) {
+	const refIdx = p.indexOf(".skilld/");
+	if (refIdx !== -1) return p.slice(refIdx + 8);
+	const parts = p.split("/");
+	return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : p;
+}
+export { FILE_PATTERN_MAP as a, sanitizeName as c, detectTargetAgent as d, getAgentVersion as f, generateSkillMd as i, detectImportedPackages as l, getModelName as n, buildSkillPrompt as o, agents as p, optimizeDocs as r, installSkillForAgents as s, getAvailableModels as t, detectInstalledAgents as u };
+
+//# sourceMappingURL=llm.mjs.map