bfi-cli 0.1.29 → 0.1.35

package/dist/_chunks/agents2.mjs

@@ -0,0 +1,66 @@
+import { agents } from "./agents.mjs";
+import { loadGlobalConfig } from "../cli.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const CACHE_FILE = path.join(os.homedir(), ".bfi", "agents-cache.json");
+const CACHE_TTL_MS = 1440 * 60 * 1e3;
+function loadCache() {
+	try {
+		if (fs.existsSync(CACHE_FILE)) {
+			const raw = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+			if (Date.now() - raw.timestamp < CACHE_TTL_MS) return raw;
+		}
+	} catch {}
+	return null;
+}
+function saveCache(agents) {
+	try {
+		const dir = path.dirname(CACHE_FILE);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(CACHE_FILE, JSON.stringify({
+			timestamp: Date.now(),
+			agents
+		}));
+	} catch {}
+}
+function mapToAgentConfig(a) {
+	return {
+		name: a.name,
+		displayName: a.displayName || a.name,
+		skillsDir: a.skillsDir,
+		globalSkillsDir: a.globalSkillsDir || void 0,
+		detectInstalled: async () => false
+	};
+}
+function mapCustomEntry(name, entry) {
+	return {
+		name,
+		displayName: entry.displayName || name,
+		skillsDir: entry.skillsDir,
+		globalSkillsDir: entry.globalSkillsDir,
+		detectInstalled: async () => false
+	};
+}
+async function resolveAgents(api) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [name, config] of Object.entries(agents)) merged.set(name, config);
+	if (api) {
+		let remoteAgents = null;
+		const cache = loadCache();
+		if (cache) remoteAgents = cache.agents;
+		else try {
+			const resp = await api.getAgents();
+			const list = resp.data || resp;
+			if (Array.isArray(list)) {
+				remoteAgents = list.map(mapToAgentConfig);
+				saveCache(remoteAgents);
+			}
+		} catch {}
+		if (remoteAgents) for (const agent of remoteAgents) merged.set(agent.name, agent);
+	}
+	const config = loadGlobalConfig();
+	if (config?.customAgents) for (const [name, entry] of Object.entries(config.customAgents)) merged.set(name, mapCustomEntry(name, entry));
+	return Object.fromEntries(merged);
+}
+export { resolveAgents };

package/dist/_chunks/libs/@clack/prompts.mjs

@@ -1,6 +1,49 @@
+import { __exportAll } from "../../rolldown-runtime.mjs";
 import { a, block, fastStringWidth, getColumns, getRows, n$1, r, require_src, settings, u$2, wrapAnsi, wrapTextWithPrefix } from "./core.mjs";
 import { styleText } from "node:util";
 import process$1 from "node:process";
+var dist_exports = /* @__PURE__ */ __exportAll({
+	MULTISELECT_INSTRUCTIONS: () => MULTISELECT_INSTRUCTIONS,
+	SELECT_INSTRUCTIONS: () => SELECT_INSTRUCTIONS,
+	S_BAR: () => S_BAR,
+	S_BAR_END: () => S_BAR_END,
+	S_BAR_H: () => S_BAR_H,
+	S_BAR_START: () => S_BAR_START,
+	S_CHECKBOX_ACTIVE: () => S_CHECKBOX_ACTIVE,
+	S_CHECKBOX_INACTIVE: () => S_CHECKBOX_INACTIVE,
+	S_CHECKBOX_SELECTED: () => S_CHECKBOX_SELECTED,
+	S_CONNECT_LEFT: () => S_CONNECT_LEFT,
+	S_CORNER_BOTTOM_LEFT: () => S_CORNER_BOTTOM_LEFT,
+	S_CORNER_BOTTOM_RIGHT: () => S_CORNER_BOTTOM_RIGHT,
+	S_CORNER_TOP_RIGHT: () => S_CORNER_TOP_RIGHT,
+	S_ERROR: () => S_ERROR,
+	S_INFO: () => S_INFO,
+	S_RADIO_ACTIVE: () => S_RADIO_ACTIVE,
+	S_RADIO_INACTIVE: () => S_RADIO_INACTIVE,
+	S_STEP_ACTIVE: () => S_STEP_ACTIVE,
+	S_STEP_CANCEL: () => S_STEP_CANCEL,
+	S_STEP_ERROR: () => S_STEP_ERROR,
+	S_STEP_SUBMIT: () => S_STEP_SUBMIT,
+	S_SUCCESS: () => S_SUCCESS,
+	S_WARN: () => S_WARN,
+	cancel: () => cancel,
+	confirm: () => confirm,
+	formatInstructionFooter: () => formatInstructionFooter,
+	groupMultiselect: () => groupMultiselect,
+	intro: () => intro,
+	isCI: () => isCI,
+	limitOptions: () => limitOptions,
+	log: () => log,
+	multiselect: () => multiselect,
+	note: () => note,
+	outro: () => outro,
+	select: () => select,
+	spinner: () => spinner,
+	symbol: () => symbol,
+	symbolBar: () => symbolBar,
+	unicode: () => unicode,
+	unicodeOr: () => unicodeOr
+});
 var import_src = require_src();
 function isUnicodeSupported() {
 	if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";
@@ -536,4 +579,4 @@ ${b}
 	}).prompt();
 };
 `${styleText("gray", S_BAR)}`;
-export { cancel, confirm, groupMultiselect, intro, log, multiselect, note, outro, select, spinner };
+export { cancel, confirm, dist_exports, groupMultiselect, intro, log, multiselect, note, outro, select, spinner };

package/dist/_chunks/skills.mjs

@@ -0,0 +1,445 @@
+import { __exportAll, __toESM } from "./rolldown-runtime.mjs";
+import { require_picocolors } from "./libs/picocolors.mjs";
+import { basename, dirname, join, normalize, relative, resolve, sep } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { parse } from "yaml";
+import { createHash } from "crypto";
+const CSI_RE = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+const OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+const DCS_PM_APC_RE = /\x1b[P^_][\s\S]*?(?:\x1b\\)/g;
+const SIMPLE_ESC_RE = /\x1b[\x20-\x7e]/g;
+const C1_RE = /[\x80-\x9f]/g;
+const CONTROL_RE = /[\x00-\x06\x07\x08\x0b\x0c\x0d-\x1a\x1c-\x1f\x7f]/g;
+function stripTerminalEscapes(str) {
+	return str.replace(OSC_RE, "").replace(DCS_PM_APC_RE, "").replace(CSI_RE, "").replace(SIMPLE_ESC_RE, "").replace(C1_RE, "").replace(CONTROL_RE, "");
+}
+function sanitizeMetadata(str) {
+	return stripTerminalEscapes(str).replace(/[\r\n]+/g, " ").trim();
+}
+function parseFrontmatter(raw) {
+	const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!match) return {
+		data: {},
+		content: raw
+	};
+	return {
+		data: parse(match[1]) ?? {},
+		content: match[2] ?? ""
+	};
+}
+function isContainedIn(targetPath, basePath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function isValidRelativePath(path) {
+	return path.startsWith("./");
+}
+async function getPluginSkillPaths(basePath) {
+	const searchDirs = [];
+	const addPluginSkillPaths = (pluginBase, skills) => {
+		if (!isContainedIn(pluginBase, basePath)) return;
+		if (skills && skills.length > 0) for (const skillPath of skills) {
+			if (!isValidRelativePath(skillPath)) continue;
+			const skillDir = dirname(join(pluginBase, skillPath));
+			if (isContainedIn(skillDir, basePath)) searchDirs.push(skillDir);
+		}
+		searchDirs.push(join(pluginBase, "skills"));
+	};
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		const pluginRoot = manifest.metadata?.pluginRoot;
+		if (pluginRoot === void 0 || isValidRelativePath(pluginRoot)) for (const plugin of manifest.plugins ?? []) {
+			if (typeof plugin.source !== "string" && plugin.source !== void 0) continue;
+			if (plugin.source !== void 0 && !isValidRelativePath(plugin.source)) continue;
+			addPluginSkillPaths(join(basePath, pluginRoot ?? "", plugin.source ?? ""), plugin.skills);
+		}
+	} catch {}
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/plugin.json"), "utf-8");
+		addPluginSkillPaths(basePath, JSON.parse(content).skills);
+	} catch {}
+	return searchDirs;
+}
+async function getPluginGroupings(basePath) {
+	const groupings = /* @__PURE__ */ new Map();
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/marketplace.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		const pluginRoot = manifest.metadata?.pluginRoot;
+		if (pluginRoot === void 0 || isValidRelativePath(pluginRoot)) for (const plugin of manifest.plugins ?? []) {
+			if (!plugin.name) continue;
+			if (typeof plugin.source !== "string" && plugin.source !== void 0) continue;
+			if (plugin.source !== void 0 && !isValidRelativePath(plugin.source)) continue;
+			const pluginBase = join(basePath, pluginRoot ?? "", plugin.source ?? "");
+			if (!isContainedIn(pluginBase, basePath)) continue;
+			if (plugin.skills && plugin.skills.length > 0) for (const skillPath of plugin.skills) {
+				if (!isValidRelativePath(skillPath)) continue;
+				const skillDir = join(pluginBase, skillPath);
+				if (isContainedIn(skillDir, basePath)) groupings.set(resolve(skillDir), plugin.name);
+			}
+		}
+	} catch {}
+	try {
+		const content = await readFile(join(basePath, ".claude-plugin/plugin.json"), "utf-8");
+		const manifest = JSON.parse(content);
+		if (manifest.name && manifest.skills && manifest.skills.length > 0) for (const skillPath of manifest.skills) {
+			if (!isValidRelativePath(skillPath)) continue;
+			const skillDir = join(basePath, skillPath);
+			if (isContainedIn(skillDir, basePath)) groupings.set(resolve(skillDir), manifest.name);
+		}
+	} catch {}
+	return groupings;
+}
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const AGENTS_DIR = ".agents";
+const SKILL_LOCK_FILE = ".skill-lock.json";
+const SKILL_LOCK_CURRENT_VERSION = 3;
+const LOCAL_LOCK_FILE = "skills-lock.json";
+const LOCAL_LOCK_CURRENT_VERSION = 1;
+function getSkillLockPath() {
+	const xdgStateHome = process.env.XDG_STATE_HOME;
+	if (xdgStateHome) return join(xdgStateHome, "skills", SKILL_LOCK_FILE);
+	return join(homedir(), AGENTS_DIR, SKILL_LOCK_FILE);
+}
+function createEmptySkillLockFile() {
+	return {
+		version: SKILL_LOCK_CURRENT_VERSION,
+		skills: {},
+		dismissed: {}
+	};
+}
+async function readSkillLock() {
+	const lockPath = getSkillLockPath();
+	try {
+		const content = await readFile(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptySkillLockFile();
+		if (parsed.version < SKILL_LOCK_CURRENT_VERSION) return createEmptySkillLockFile();
+		return parsed;
+	} catch {
+		return createEmptySkillLockFile();
+	}
+}
+async function writeSkillLock(lock) {
+	const lockPath = getSkillLockPath();
+	await mkdir(dirname(lockPath), { recursive: true });
+	await writeFile(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+}
+let _ghWarningShown = false;
+function getGitHubToken() {
+	if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+	if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+	if (!_ghWarningShown) {
+		process.stderr.write(`${import_picocolors.default.yellow("│")}  ${import_picocolors.default.yellow("GitHub rate limit reached")} — using your ${import_picocolors.default.cyan("gh")} login to continue.\n${import_picocolors.default.yellow("│")}  ${import_picocolors.default.dim(`Tip: set ${import_picocolors.default.cyan("GITHUB_TOKEN")} to avoid this prompt, or use ${import_picocolors.default.cyan("--full-depth")} to clone instead.\n`)}`);
+		_ghWarningShown = true;
+	}
+	try {
+		const token = execSync("gh auth token", {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+		if (token) return token;
+	} catch {}
+	return null;
+}
+async function addSkillToLock(skillName, entry) {
+	const lock = await readSkillLock();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const existingEntry = lock.skills[skillName];
+	lock.skills[skillName] = {
+		...entry,
+		installedAt: existingEntry?.installedAt ?? now,
+		updatedAt: now
+	};
+	await writeSkillLock(lock);
+}
+async function removeSkillFromLock(skillName) {
+	const lock = await readSkillLock();
+	if (!(skillName in lock.skills)) return false;
+	delete lock.skills[skillName];
+	await writeSkillLock(lock);
+	return true;
+}
+async function getSkillFromLock(skillName) {
+	return (await readSkillLock()).skills[skillName] ?? null;
+}
+async function getAllLockedSkills() {
+	return (await readSkillLock()).skills;
+}
+async function isPromptDismissed(promptKey) {
+	return (await readSkillLock()).dismissed?.[promptKey] === true;
+}
+async function dismissPrompt(promptKey) {
+	const lock = await readSkillLock();
+	if (!lock.dismissed) lock.dismissed = {};
+	lock.dismissed[promptKey] = true;
+	await writeSkillLock(lock);
+}
+async function getLastSelectedAgents() {
+	return (await readSkillLock()).lastSelectedAgents;
+}
+async function saveSelectedAgents(agents) {
+	const lock = await readSkillLock();
+	lock.lastSelectedAgents = agents;
+	await writeSkillLock(lock);
+}
+function getLocalLockPath(cwd) {
+	return join(cwd || process.cwd(), LOCAL_LOCK_FILE);
+}
+function createEmptyLocalLock() {
+	return {
+		version: LOCAL_LOCK_CURRENT_VERSION,
+		skills: {}
+	};
+}
+async function readLocalLock(cwd) {
+	const lockPath = getLocalLockPath(cwd);
+	try {
+		const content = await readFile(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptyLocalLock();
+		if (parsed.version < LOCAL_LOCK_CURRENT_VERSION) return createEmptyLocalLock();
+		return parsed;
+	} catch {
+		return createEmptyLocalLock();
+	}
+}
+async function writeLocalLock(lock, cwd) {
+	const lockPath = getLocalLockPath(cwd);
+	const sortedSkills = {};
+	for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+	const sorted = {
+		version: lock.version,
+		skills: sortedSkills
+	};
+	await writeFile(lockPath, JSON.stringify(sorted, null, 2) + "\n", "utf-8");
+}
+async function computeSkillFolderHash(skillDir) {
+	const files = [];
+	await collectFiles(skillDir, skillDir, files);
+	files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+	const hash = createHash("sha256");
+	for (const file of files) {
+		hash.update(file.relativePath);
+		hash.update(file.content);
+	}
+	return hash.digest("hex");
+}
+async function collectFiles(baseDir, currentDir, results) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	await Promise.all(entries.map(async (entry) => {
+		const fullPath = join(currentDir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === ".git" || entry.name === "node_modules") return;
+			await collectFiles(baseDir, fullPath, results);
+		} else if (entry.isFile()) {
+			const content = await readFile(fullPath);
+			const relativePath = relative(baseDir, fullPath).split("\\").join("/");
+			results.push({
+				relativePath,
+				content
+			});
+		}
+	}));
+}
+async function addSkillToLocalLock(skillName, entry, cwd) {
+	const lock = await readLocalLock(cwd);
+	lock.skills[skillName] = entry;
+	await writeLocalLock(lock, cwd);
+}
+var skills_exports = /* @__PURE__ */ __exportAll({
+	discoverSkills: () => discoverSkills,
+	filterSkills: () => filterSkills,
+	getSkillDisplayName: () => getSkillDisplayName,
+	isSubpathSafe: () => isSubpathSafe,
+	parseSkillMd: () => parseSkillMd,
+	shouldInstallInternalSkills: () => shouldInstallInternalSkills
+});
+const SKIP_DIRS = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"__pycache__"
+];
+const AGENT_PROJECT_SKILL_DIRS = [
+	".agents/skills",
+	".claude/skills",
+	".cline/skills",
+	".codebuddy/skills",
+	".codex/skills",
+	".commandcode/skills",
+	".continue/skills",
+	".github/skills",
+	".goose/skills",
+	".iflow/skills",
+	".junie/skills",
+	".kilocode/skills",
+	".kiro/skills",
+	".mux/skills",
+	".neovate/skills",
+	".opencode/skills",
+	".openhands/skills",
+	".pi/skills",
+	".qoder/skills",
+	".roo/skills",
+	".trae/skills",
+	".windsurf/skills",
+	".zcode/skills",
+	".zencoder/skills"
+];
+function normalizeSkillName(name) {
+	return name.toLowerCase().replace(/[\s_]+/g, "-");
+}
+function normalizeRelativePath(path) {
+	return path.split(sep).join("/").replace(/\/+/g, "/");
+}
+function shouldInstallInternalSkills() {
+	const envValue = process.env.INSTALL_INTERNAL_SKILLS;
+	return envValue === "1" || envValue === "true";
+}
+async function hasSkillMd(dir) {
+	try {
+		return (await stat(join(dir, "SKILL.md"))).isFile();
+	} catch {
+		return false;
+	}
+}
+async function parseSkillMd(skillMdPath, options) {
+	try {
+		const content = await readFile(skillMdPath, "utf-8");
+		const { data } = parseFrontmatter(content);
+		if (!data.name || !data.description) return null;
+		if (typeof data.name !== "string" || typeof data.description !== "string") return null;
+		if (data.metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
+		return {
+			name: sanitizeMetadata(data.name),
+			description: sanitizeMetadata(data.description),
+			path: dirname(skillMdPath),
+			rawContent: content,
+			metadata: data.metadata
+		};
+	} catch {
+		return null;
+	}
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+	if (depth > maxDepth) return [];
+	try {
+		const [hasSkill, entries] = await Promise.all([hasSkillMd(dir), readdir(dir, { withFileTypes: true }).catch(() => [])]);
+		const currentDir = hasSkill ? [dir] : [];
+		const subDirResults = await Promise.all(entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.includes(entry.name)).map((entry) => findSkillDirs(join(dir, entry.name), depth + 1, maxDepth)));
+		return [...currentDir, ...subDirResults.flat()];
+	} catch {
+		return [];
+	}
+}
+function isSubpathSafe(basePath, subpath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(join(basePath, subpath)));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+async function discoverSkills(basePath, subpath, options) {
+	const skills = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	const localLock = await readLocalLock(basePath);
+	const lockedSkillNames = new Set(Object.keys(localLock.skills).map(normalizeSkillName));
+	if (subpath && !isSubpathSafe(basePath, subpath)) throw new Error(`Invalid subpath: "${subpath}" resolves outside the repository directory. Subpath must not contain ".." segments that escape the base path.`);
+	const searchPath = subpath ? join(basePath, subpath) : basePath;
+	const pluginGroupings = await getPluginGroupings(searchPath);
+	const enhanceSkill = (skill) => {
+		const resolvedPath = resolve(skill.path);
+		if (pluginGroupings.has(resolvedPath)) skill.pluginName = pluginGroupings.get(resolvedPath);
+		return skill;
+	};
+	const isInstalledProjectSkill = (skill) => {
+		if (lockedSkillNames.size === 0) return false;
+		const relativeDir = normalizeRelativePath(relative(basePath, skill.path));
+		if (!AGENT_PROJECT_SKILL_DIRS.some((dir) => relativeDir === dir || relativeDir.startsWith(`${dir}/`))) return false;
+		const skillName = normalizeSkillName(skill.name);
+		const directoryName = normalizeSkillName(basename(skill.path));
+		return lockedSkillNames.has(skillName) || lockedSkillNames.has(directoryName);
+	};
+	if (await hasSkillMd(searchPath)) {
+		let skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
+		if (skill) {
+			if (!isInstalledProjectSkill(skill)) {
+				skill = enhanceSkill(skill);
+				skills.push(skill);
+				seenNames.add(skill.name);
+				if (!options?.fullDepth) return skills;
+			}
+		}
+	}
+	const prioritySearchDirs = [
+		searchPath,
+		join(searchPath, "skills"),
+		join(searchPath, "skills/.curated"),
+		join(searchPath, "skills/.experimental"),
+		join(searchPath, "skills/.system"),
+		...AGENT_PROJECT_SKILL_DIRS.map((dir) => join(searchPath, dir))
+	];
+	const deepContainerDirs = new Set(prioritySearchDirs.slice(1));
+	prioritySearchDirs.push(...await getPluginSkillPaths(searchPath));
+	const tryAddSkillAt = async (skillDir) => {
+		if (!await hasSkillMd(skillDir)) return false;
+		let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+		if (!skill || seenNames.has(skill.name)) return true;
+		if (isInstalledProjectSkill(skill)) return true;
+		skill = enhanceSkill(skill);
+		skills.push(skill);
+		seenNames.add(skill.name);
+		return true;
+	};
+	for (const dir of prioritySearchDirs) {
+		const walkDeep = deepContainerDirs.has(dir);
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const childDir = join(dir, entry.name);
+				if (await tryAddSkillAt(childDir) || !walkDeep) continue;
+				if (SKIP_DIRS.includes(entry.name)) continue;
+				try {
+					const grandEntries = await readdir(childDir, { withFileTypes: true });
+					for (const grand of grandEntries) {
+						if (!grand.isDirectory() || SKIP_DIRS.includes(grand.name)) continue;
+						await tryAddSkillAt(join(childDir, grand.name));
+					}
+				} catch {}
+			}
+		} catch {}
+	}
+	if (skills.length === 0 || options?.fullDepth) {
+		const allSkillDirs = await findSkillDirs(searchPath);
+		for (const skillDir of allSkillDirs) {
+			let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+			if (skill && !seenNames.has(skill.name) && !isInstalledProjectSkill(skill)) {
+				skill = enhanceSkill(skill);
+				skills.push(skill);
+				seenNames.add(skill.name);
+			}
+		}
+	}
+	return skills;
+}
+function getSkillDisplayName(skill) {
+	return skill.name || basename(skill.path);
+}
+function filterSkills(skills, inputNames) {
+	const normalizedInputs = inputNames.map((n) => n.toLowerCase());
+	return skills.filter((skill) => {
+		const name = skill.name.toLowerCase();
+		const displayName = getSkillDisplayName(skill).toLowerCase();
+		return normalizedInputs.some((input) => input === name || input === displayName);
+	});
+}
+export { addSkillToLocalLock, addSkillToLock, computeSkillFolderHash, discoverSkills, dismissPrompt, filterSkills, getAllLockedSkills, getGitHubToken, getLastSelectedAgents, getSkillDisplayName, getSkillFromLock, isPromptDismissed, parseFrontmatter, parseSkillMd, readLocalLock, readSkillLock, removeSkillFromLock, sanitizeMetadata, saveSelectedAgents, skills_exports, stripTerminalEscapes };