unagent 0.0.1

package/dist/index-DmiDvQ8Q.d.ts

@@ -0,0 +1,37 @@
+//#region src/source/providers.d.ts
+type SourceProvider = "github" | "gitlab" | "bitbucket" | "local" | "url";
+interface ProviderInfo {
+  provider: SourceProvider;
+  owner?: string;
+  repo?: string;
+  path?: string;
+  ref?: string;
+  url?: string;
+}
+declare function getProviderFromUrl(url: string): SourceProvider;
+declare function parseGitHubUrl(url: string): ProviderInfo | undefined;
+declare function parseGitLabUrl(url: string): ProviderInfo | undefined;
+declare function buildGitHubCloneUrl(owner: string, repo: string): string;
+declare function buildGitLabCloneUrl(owner: string, repo: string): string;
+//#endregion
+//#region src/source/parse.d.ts
+interface ParsedSource {
+  type: SourceProvider;
+  raw: string;
+  owner?: string;
+  repo?: string;
+  path?: string;
+  ref?: string;
+  url?: string;
+  isLocal: boolean;
+}
+declare function isLocalPath(source: string): boolean;
+declare function isUrl(source: string): boolean;
+declare function parseSource(source: string): ParsedSource;
+declare function getOwnerRepo(parsed: ParsedSource): string | undefined;
+declare function parseOwnerRepo(ownerRepo: string): {
+  owner: string;
+  repo: string;
+} | undefined;
+//#endregion
+export { parseOwnerRepo as a, SourceProvider as c, getProviderFromUrl as d, parseGitHubUrl as f, isUrl as i, buildGitHubCloneUrl as l, getOwnerRepo as n, parseSource as o, parseGitLabUrl as p, isLocalPath as r, ProviderInfo as s, ParsedSource as t, buildGitLabCloneUrl as u };

package/dist/index-DwU61LUW.d.ts

@@ -0,0 +1,43 @@
+//#region src/git/clone.d.ts
+declare class GitCloneError extends Error {
+  readonly url: string;
+  readonly cause: Error | undefined;
+  constructor(message: string, url: string, cause?: Error);
+}
+interface CloneOptions {
+  depth?: number;
+  branch?: string;
+  timeout?: number;
+  tempDir?: string;
+}
+interface CloneResult {
+  success: boolean;
+  path: string;
+  error?: string;
+}
+declare function cloneRepo(url: string, dest: string, options?: CloneOptions): Promise<CloneResult>;
+declare function cloneToTemp(url: string, options?: CloneOptions): Promise<CloneResult>;
+declare function cleanupTempDir(path: string): boolean;
+declare function isTempDir(path: string): boolean;
+//#endregion
+//#region src/git/operations.d.ts
+interface GitStatus {
+  isRepo: boolean;
+  branch: string;
+  ahead: number;
+  behind: number;
+  staged: string[];
+  modified: string[];
+  untracked: string[];
+  hasChanges: boolean;
+}
+declare function getGitStatus(dir: string): Promise<GitStatus | undefined>;
+declare function getCurrentBranch(dir: string): Promise<string | undefined>;
+declare function checkout(dir: string, ref: string): Promise<boolean>;
+declare function pull(dir: string): Promise<boolean>;
+declare function fetch(dir: string, remote?: string): Promise<boolean>;
+declare function getRemoteUrl(dir: string, remote?: string): Promise<string | undefined>;
+declare function getLatestCommitHash(dir: string): Promise<string | undefined>;
+declare function hasUncommittedChanges(dir: string): Promise<boolean>;
+//#endregion
+export { getGitStatus as a, hasUncommittedChanges as c, CloneResult as d, GitCloneError as f, isTempDir as g, cloneToTemp as h, getCurrentBranch as i, pull as l, cloneRepo as m, checkout as n, getLatestCommitHash as o, cleanupTempDir as p, fetch as r, getRemoteUrl as s, GitStatus as t, CloneOptions as u };

package/dist/index-LzafUiEo.d.ts

@@ -0,0 +1,29 @@
+//#region src/lock/hash.d.ts
+declare function computeContentHash(content: string): string;
+declare function computeFileHash(filePath: string): string | undefined;
+declare function computeDirectoryHash(dirPath: string, exclude?: string[]): string | undefined;
+//#endregion
+//#region src/lock/lock.d.ts
+interface SkillLockEntry {
+  name: string;
+  source: string;
+  version?: string;
+  hash: string;
+  installedAt: string;
+  updatedAt: string;
+}
+interface SkillLock {
+  version: number;
+  skills: Record<string, SkillLockEntry>;
+}
+declare function createEmptyLock(): SkillLock;
+declare function readSkillLock(dir: string, filename?: string): SkillLock;
+declare function writeSkillLock(dir: string, lock: SkillLock, filename?: string): boolean;
+declare function addSkillToLock(lock: SkillLock, id: string, entry: Omit<SkillLockEntry, "installedAt" | "updatedAt">): SkillLock;
+declare function removeSkillFromLock(lock: SkillLock, id: string): SkillLock;
+declare function getSkillFromLock(lock: SkillLock, id: string): SkillLockEntry | undefined;
+declare function hasSkillInLock(lock: SkillLock, id: string): boolean;
+declare function listSkillsInLock(lock: SkillLock): SkillLockEntry[];
+declare function isSkillOutdated(lock: SkillLock, id: string, currentHash: string): boolean;
+//#endregion
+export { getSkillFromLock as a, listSkillsInLock as c, writeSkillLock as d, computeContentHash as f, createEmptyLock as i, readSkillLock as l, computeFileHash as m, SkillLockEntry as n, hasSkillInLock as o, computeDirectoryHash as p, addSkillToLock as r, isSkillOutdated as s, SkillLock as t, removeSkillFromLock as u };

package/dist/index-y5JZ6STt.d.ts

@@ -0,0 +1,36 @@
+//#region src/skill/parse.d.ts
+interface SkillFrontmatter {
+  name?: string;
+  description?: string;
+  version?: string;
+  author?: string;
+  globs?: string | string[];
+  alwaysApply?: boolean;
+  tags?: string[];
+  [key: string]: unknown;
+}
+interface ParsedSkill {
+  frontmatter: SkillFrontmatter;
+  content: string;
+  raw: string;
+}
+declare function parseSkillMd(content: string): ParsedSkill;
+declare function extractSkillName(frontmatter: SkillFrontmatter, filename?: string): string;
+declare function validateSkillMd(parsed: ParsedSkill): string[];
+//#endregion
+//#region src/skill/discover.d.ts
+interface DiscoveredSkill {
+  path: string;
+  filename: string;
+  name: string;
+  parsed: ParsedSkill;
+}
+interface DiscoverOptions {
+  recursive?: boolean;
+  extensions?: string[];
+}
+declare function discoverSkills(dir: string, options?: DiscoverOptions): DiscoveredSkill[];
+declare function filterSkills(skills: DiscoveredSkill[], query: string): DiscoveredSkill[];
+declare function findSkillByName(skills: DiscoveredSkill[], name: string): DiscoveredSkill | undefined;
+//#endregion
+export { findSkillByName as a, extractSkillName as c, filterSkills as i, parseSkillMd as l, DiscoveredSkill as n, ParsedSkill as o, discoverSkills as r, SkillFrontmatter as s, DiscoverOptions as t, validateSkillMd as u };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { _ as getAgentConfig, a as getAgentSkillsDir, c as isCI, d as detectAgentByEnv, f as detectCurrentAgent, g as agents, h as AgentConfig, i as getAgentRulesPath, l as isTTY, m as isRunningInAgent, n as agentConfigExists, o as getXDGPaths, p as detectInstalledAgents, r as getAgentConfigDir, s as hasTTY, t as XDGPaths, u as DetectedAgent, v as getAgentIds, y as getAllAgents } from "./index-BW91Ai1Y.js";
+import { a as getGitStatus, c as hasUncommittedChanges, d as CloneResult, f as GitCloneError, g as isTempDir, h as cloneToTemp, i as getCurrentBranch, l as pull, m as cloneRepo, n as checkout, o as getLatestCommitHash, p as cleanupTempDir, r as fetch, s as getRemoteUrl, t as GitStatus, u as CloneOptions } from "./index-DwU61LUW.js";
+import { a as removeSymlink, c as validateSymlinkTarget, d as copyDirectory, f as copyFile, i as isSymlink, l as CopyOptions, n as SymlinkResult, o as isPathSafe, p as getDirectorySize, r as createSymlink, s as sanitizeName, t as SymlinkOptions, u as CopyResult } from "./index-CFwFmDD-.js";
+import { a as getSkillFromLock, c as listSkillsInLock, d as writeSkillLock, f as computeContentHash, i as createEmptyLock, l as readSkillLock, m as computeFileHash, n as SkillLockEntry, o as hasSkillInLock, p as computeDirectoryHash, r as addSkillToLock, s as isSkillOutdated, t as SkillLock, u as removeSkillFromLock } from "./index-LzafUiEo.js";
+import { a as findSkillByName, c as extractSkillName, i as filterSkills, l as parseSkillMd, n as DiscoveredSkill, o as ParsedSkill, r as discoverSkills, s as SkillFrontmatter, t as DiscoverOptions, u as validateSkillMd } from "./index-y5JZ6STt.js";
+import { a as parseOwnerRepo, c as SourceProvider, d as getProviderFromUrl, f as parseGitHubUrl, i as isUrl, l as buildGitHubCloneUrl, n as getOwnerRepo, o as parseSource, p as parseGitLabUrl, r as isLocalPath, s as ProviderInfo, t as ParsedSource, u as buildGitLabCloneUrl } from "./index-DmiDvQ8Q.js";
+import { a as truncate, c as bold, d as gray, f as green, h as yellow, i as pluralize, l as cyan, m as stripAnsi, n as shortenPath, o as ANSI, p as red, r as formatList, s as blue, t as expandPath, u as dim } from "./index-CirIJDiq.js";
+export { ANSI, AgentConfig, CloneOptions, CloneResult, CopyOptions, CopyResult, DetectedAgent, DiscoverOptions, DiscoveredSkill, GitCloneError, GitStatus, ParsedSkill, ParsedSource, ProviderInfo, SkillFrontmatter, SkillLock, SkillLockEntry, SourceProvider, SymlinkOptions, SymlinkResult, XDGPaths, addSkillToLock, agentConfigExists, agents, blue, bold, buildGitHubCloneUrl, buildGitLabCloneUrl, checkout, cleanupTempDir, cloneRepo, cloneToTemp, computeContentHash, computeDirectoryHash, computeFileHash, copyDirectory, copyFile, createEmptyLock, createSymlink, cyan, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, dim, discoverSkills, expandPath, extractSkillName, fetch, filterSkills, findSkillByName, formatList, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getCurrentBranch, getDirectorySize, getGitStatus, getLatestCommitHash, getOwnerRepo, getProviderFromUrl, getRemoteUrl, getSkillFromLock, getXDGPaths, gray, green, hasSkillInLock, hasTTY, hasUncommittedChanges, isCI, isLocalPath, isPathSafe, isRunningInAgent, isSkillOutdated, isSymlink, isTTY, isTempDir, isUrl, listSkillsInLock, parseGitHubUrl, parseGitLabUrl, parseOwnerRepo, parseSkillMd, parseSource, pluralize, pull, readSkillLock, red, removeSkillFromLock, removeSymlink, sanitizeName, shortenPath, stripAnsi, truncate, validateSkillMd, validateSymlinkTarget, writeSkillLock, yellow };

package/dist/index.js

@@ -0,0 +1,10 @@
+import { a as agentConfigExists, c as getAgentSkillsDir, d as isCI, f as isTTY, g as getAllAgents, h as getAgentIds, i as isRunningInAgent, l as getXDGPaths, m as getAgentConfig, n as detectCurrentAgent, o as getAgentConfigDir, p as agents, r as detectInstalledAgents, s as getAgentRulesPath, t as detectAgentByEnv, u as hasTTY } from "./env-BUegcU7a.js";
+import { n as shortenPath, t as expandPath } from "./path-nPuHl-f5.js";
+import { a as getLatestCommitHash, c as pull, d as cloneRepo, f as cloneToTemp, i as getGitStatus, l as GitCloneError, n as fetch, o as getRemoteUrl, p as isTempDir, r as getCurrentBranch, s as hasUncommittedChanges, t as checkout, u as cleanupTempDir } from "./git-D4ZclaF6.js";
+import { a as sanitizeName, c as copyFile, i as isPathSafe, l as getDirectorySize, n as isSymlink, o as validateSymlinkTarget, r as removeSymlink, s as copyDirectory, t as createSymlink } from "./link-C4PSDr4v.js";
+import { a as isSkillOutdated, c as removeSkillFromLock, d as computeDirectoryHash, f as computeFileHash, i as hasSkillInLock, l as writeSkillLock, n as createEmptyLock, o as listSkillsInLock, r as getSkillFromLock, s as readSkillLock, t as addSkillToLock, u as computeContentHash } from "./lock-BeR43Izo.js";
+import { a as parseSkillMd, i as extractSkillName, n as filterSkills, o as validateSkillMd, r as findSkillByName, t as discoverSkills } from "./skill-BmLJYiQz.js";
+import { a as parseSource, c as getProviderFromUrl, i as parseOwnerRepo, l as parseGitHubUrl, n as isLocalPath, o as buildGitHubCloneUrl, r as isUrl, s as buildGitLabCloneUrl, t as getOwnerRepo, u as parseGitLabUrl } from "./source-IfQxnt_F.js";
+import { a as blue, c as dim, d as red, f as stripAnsi, i as ANSI, l as gray, n as pluralize, o as bold, p as yellow, r as truncate, s as cyan, t as formatList, u as green } from "./utils-CDyPZons.js";
+
+export { ANSI, GitCloneError, addSkillToLock, agentConfigExists, agents, blue, bold, buildGitHubCloneUrl, buildGitLabCloneUrl, checkout, cleanupTempDir, cloneRepo, cloneToTemp, computeContentHash, computeDirectoryHash, computeFileHash, copyDirectory, copyFile, createEmptyLock, createSymlink, cyan, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, dim, discoverSkills, expandPath, extractSkillName, fetch, filterSkills, findSkillByName, formatList, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getCurrentBranch, getDirectorySize, getGitStatus, getLatestCommitHash, getOwnerRepo, getProviderFromUrl, getRemoteUrl, getSkillFromLock, getXDGPaths, gray, green, hasSkillInLock, hasTTY, hasUncommittedChanges, isCI, isLocalPath, isPathSafe, isRunningInAgent, isSkillOutdated, isSymlink, isTTY, isTempDir, isUrl, listSkillsInLock, parseGitHubUrl, parseGitLabUrl, parseOwnerRepo, parseSkillMd, parseSource, pluralize, pull, readSkillLock, red, removeSkillFromLock, removeSymlink, sanitizeName, shortenPath, stripAnsi, truncate, validateSkillMd, validateSymlinkTarget, writeSkillLock, yellow };

package/dist/link/index.d.ts

@@ -0,0 +1,2 @@
+import { a as removeSymlink, c as validateSymlinkTarget, d as copyDirectory, f as copyFile, i as isSymlink, l as CopyOptions, n as SymlinkResult, o as isPathSafe, p as getDirectorySize, r as createSymlink, s as sanitizeName, t as SymlinkOptions, u as CopyResult } from "../index-CFwFmDD-.js";
+export { CopyOptions, CopyResult, SymlinkOptions, SymlinkResult, copyDirectory, copyFile, createSymlink, getDirectorySize, isPathSafe, isSymlink, removeSymlink, sanitizeName, validateSymlinkTarget };

package/dist/link/index.js

@@ -0,0 +1,3 @@
+import { a as sanitizeName, c as copyFile, i as isPathSafe, l as getDirectorySize, n as isSymlink, o as validateSymlinkTarget, r as removeSymlink, s as copyDirectory, t as createSymlink } from "../link-C4PSDr4v.js";
+
+export { copyDirectory, copyFile, createSymlink, getDirectorySize, isPathSafe, isSymlink, removeSymlink, sanitizeName, validateSymlinkTarget };

package/dist/link-C4PSDr4v.js

@@ -0,0 +1,199 @@
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
+
+//#region src/link/copy.ts
+const DEFAULT_EXCLUDE = [
+	".git",
+	"node_modules",
+	".DS_Store",
+	"Thumbs.db"
+];
+function copyDirectory(src, dest, options = {}) {
+	const { force = false, exclude = DEFAULT_EXCLUDE, preserveTimestamps = true } = options;
+	if (!existsSync(src)) return {
+		success: false,
+		src,
+		dest,
+		error: "Source does not exist"
+	};
+	if (!statSync(src).isDirectory()) return {
+		success: false,
+		src,
+		dest,
+		error: "Source is not a directory"
+	};
+	try {
+		if (existsSync(dest)) {
+			if (!force) return {
+				success: false,
+				src,
+				dest,
+				error: "Destination already exists"
+			};
+			rmSync(dest, {
+				recursive: true,
+				force: true
+			});
+		}
+		mkdirSync(dest, { recursive: true });
+		return {
+			success: true,
+			src,
+			dest,
+			filesCopied: copyRecursive(src, dest, exclude, preserveTimestamps)
+		};
+	} catch (error) {
+		return {
+			success: false,
+			src,
+			dest,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+function copyRecursive(src, dest, exclude, preserveTimestamps) {
+	let count = 0;
+	const entries = readdirSync(src);
+	for (const entry of entries) {
+		if (exclude.includes(entry)) continue;
+		const srcPath = join(src, entry);
+		const destPath = join(dest, entry);
+		if (statSync(srcPath).isDirectory()) {
+			mkdirSync(destPath, { recursive: true });
+			count += copyRecursive(srcPath, destPath, exclude, preserveTimestamps);
+		} else {
+			cpSync(srcPath, destPath, { preserveTimestamps });
+			count++;
+		}
+	}
+	return count;
+}
+function copyFile(src, dest, options = {}) {
+	const { force = false } = options;
+	if (!existsSync(src)) return false;
+	if (existsSync(dest) && !force) return false;
+	try {
+		const destDir = join(dest, "..");
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		cpSync(src, dest);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getDirectorySize(dir) {
+	if (!existsSync(dir)) return 0;
+	let size = 0;
+	const entries = readdirSync(dir);
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		if (stat.isDirectory()) size += getDirectorySize(fullPath);
+		else size += stat.size;
+	}
+	return size;
+}
+
+//#endregion
+//#region src/link/sanitize.ts
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+}
+function isPathSafe(targetPath, baseDir) {
+	const resolved = resolve(baseDir, targetPath);
+	const normalizedBase = normalize(baseDir);
+	if (!normalize(resolved).startsWith(normalizedBase)) return false;
+	const rel = relative(baseDir, resolved);
+	if (rel.startsWith("..") || isAbsolute(rel)) return false;
+	if ([
+		"..",
+		"~",
+		"$",
+		"`",
+		"|",
+		";",
+		"&",
+		">",
+		"<",
+		"\\"
+	].some((char) => targetPath.includes(char))) return false;
+	return true;
+}
+function validateSymlinkTarget(target) {
+	if (!target || typeof target !== "string") return false;
+	if (target.length > 4096) return false;
+	if (target.includes("\0")) return false;
+	return true;
+}
+
+//#endregion
+//#region src/link/symlink.ts
+function createSymlink(target, linkPath, options = {}) {
+	const { force = false, relative: useRelative = true } = options;
+	if (!validateSymlinkTarget(target)) return {
+		success: false,
+		path: linkPath,
+		target,
+		error: "Invalid symlink target"
+	};
+	if (!existsSync(target)) return {
+		success: false,
+		path: linkPath,
+		target,
+		error: "Target does not exist"
+	};
+	try {
+		const linkDir = dirname(linkPath);
+		if (!existsSync(linkDir)) mkdirSync(linkDir, { recursive: true });
+		if (existsSync(linkPath)) {
+			if (!force) return {
+				success: false,
+				path: linkPath,
+				target,
+				error: "Link already exists"
+			};
+			const stat = lstatSync(linkPath);
+			if (stat.isSymbolicLink() || stat.isFile()) unlinkSync(linkPath);
+			else return {
+				success: false,
+				path: linkPath,
+				target,
+				error: "Cannot overwrite directory"
+			};
+		}
+		const symlinkTarget = useRelative ? relative(linkDir, target) : target;
+		const targetStat = lstatSync(target);
+		symlinkSync(symlinkTarget, linkPath, process.platform === "win32" && targetStat.isDirectory() ? "junction" : void 0);
+		return {
+			success: true,
+			path: linkPath,
+			target
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: linkPath,
+			target,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+function isSymlink(path) {
+	try {
+		return lstatSync(path).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+function removeSymlink(linkPath) {
+	try {
+		if (!isSymlink(linkPath)) return false;
+		unlinkSync(linkPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { sanitizeName as a, copyFile as c, isPathSafe as i, getDirectorySize as l, isSymlink as n, validateSymlinkTarget as o, removeSymlink as r, copyDirectory as s, createSymlink as t };

package/dist/lock/index.d.ts

@@ -0,0 +1,2 @@
+import { a as getSkillFromLock, c as listSkillsInLock, d as writeSkillLock, f as computeContentHash, i as createEmptyLock, l as readSkillLock, m as computeFileHash, n as SkillLockEntry, o as hasSkillInLock, p as computeDirectoryHash, r as addSkillToLock, s as isSkillOutdated, t as SkillLock, u as removeSkillFromLock } from "../index-LzafUiEo.js";
+export { SkillLock, SkillLockEntry, addSkillToLock, computeContentHash, computeDirectoryHash, computeFileHash, createEmptyLock, getSkillFromLock, hasSkillInLock, isSkillOutdated, listSkillsInLock, readSkillLock, removeSkillFromLock, writeSkillLock };

package/dist/lock/index.js

@@ -0,0 +1,3 @@
+import { a as isSkillOutdated, c as removeSkillFromLock, d as computeDirectoryHash, f as computeFileHash, i as hasSkillInLock, l as writeSkillLock, n as createEmptyLock, o as listSkillsInLock, r as getSkillFromLock, s as readSkillLock, t as addSkillToLock, u as computeContentHash } from "../lock-BeR43Izo.js";
+
+export { addSkillToLock, computeContentHash, computeDirectoryHash, computeFileHash, createEmptyLock, getSkillFromLock, hasSkillInLock, isSkillOutdated, listSkillsInLock, readSkillLock, removeSkillFromLock, writeSkillLock };

package/dist/lock-BeR43Izo.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "pathe";
+import { createHash } from "node:crypto";
+
+//#region src/lock/hash.ts
+function computeContentHash(content) {
+	return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function computeFileHash(filePath) {
+	if (!existsSync(filePath)) return void 0;
+	return computeContentHash(readFileSync(filePath, "utf-8"));
+}
+function computeDirectoryHash(dirPath, exclude = []) {
+	if (!existsSync(dirPath)) return void 0;
+	const hash = createHash("sha256");
+	hashDirectory(dirPath, hash, exclude);
+	return hash.digest("hex").slice(0, 16);
+}
+function hashDirectory(dir, hash, exclude) {
+	const entries = readdirSync(dir).sort();
+	for (const entry of entries) {
+		if (exclude.includes(entry)) continue;
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		hash.update(entry);
+		if (stat.isDirectory()) {
+			hash.update("dir");
+			hashDirectory(fullPath, hash, exclude);
+		} else {
+			hash.update("file");
+			const content = readFileSync(fullPath);
+			hash.update(content);
+		}
+	}
+}
+
+//#endregion
+//#region src/lock/lock.ts
+const LOCK_VERSION = 1;
+const DEFAULT_LOCK_FILE = "skill.lock";
+function createEmptyLock() {
+	return {
+		version: LOCK_VERSION,
+		skills: {}
+	};
+}
+function readSkillLock(dir, filename = DEFAULT_LOCK_FILE) {
+	const lockPath = join(dir, filename);
+	if (!existsSync(lockPath)) return createEmptyLock();
+	try {
+		const content = readFileSync(lockPath, "utf-8");
+		const lock = JSON.parse(content);
+		if (lock.version !== LOCK_VERSION) return createEmptyLock();
+		return lock;
+	} catch {
+		return createEmptyLock();
+	}
+}
+function writeSkillLock(dir, lock, filename = DEFAULT_LOCK_FILE) {
+	const lockPath = join(dir, filename);
+	try {
+		const lockDir = dirname(lockPath);
+		if (!existsSync(lockDir)) mkdirSync(lockDir, { recursive: true });
+		writeFileSync(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function addSkillToLock(lock, id, entry) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const existing = lock.skills[id];
+	return {
+		...lock,
+		skills: {
+			...lock.skills,
+			[id]: {
+				...entry,
+				installedAt: existing?.installedAt || now,
+				updatedAt: now
+			}
+		}
+	};
+}
+function removeSkillFromLock(lock, id) {
+	const { [id]: _,...rest } = lock.skills;
+	return {
+		...lock,
+		skills: rest
+	};
+}
+function getSkillFromLock(lock, id) {
+	return lock.skills[id];
+}
+function hasSkillInLock(lock, id) {
+	return id in lock.skills;
+}
+function listSkillsInLock(lock) {
+	return Object.values(lock.skills);
+}
+function isSkillOutdated(lock, id, currentHash) {
+	const entry = lock.skills[id];
+	if (!entry) return true;
+	return entry.hash !== currentHash;
+}
+
+//#endregion
+export { isSkillOutdated as a, removeSkillFromLock as c, computeDirectoryHash as d, computeFileHash as f, hasSkillInLock as i, writeSkillLock as l, createEmptyLock as n, listSkillsInLock as o, getSkillFromLock as r, readSkillLock as s, addSkillToLock as t, computeContentHash as u };

package/dist/path-nPuHl-f5.js

@@ -0,0 +1,21 @@
+import { homedir } from "node:os";
+import { relative, resolve } from "pathe";
+
+//#region src/utils/path.ts
+function shortenPath(filepath, cwd) {
+	const home = homedir();
+	const resolved = resolve(filepath);
+	if (cwd) {
+		const rel = relative(cwd, resolved);
+		if (!rel.startsWith("..")) return rel.startsWith(".") ? rel : `./${rel}`;
+	}
+	if (resolved.startsWith(home)) return `~${resolved.slice(home.length)}`;
+	return resolved;
+}
+function expandPath(filepath) {
+	if (filepath.startsWith("~")) return `${homedir()}${filepath.slice(1)}`;
+	return resolve(filepath);
+}
+
+//#endregion
+export { shortenPath as n, expandPath as t };

package/dist/skill/index.d.ts

@@ -0,0 +1,2 @@
+import { a as findSkillByName, c as extractSkillName, i as filterSkills, l as parseSkillMd, n as DiscoveredSkill, o as ParsedSkill, r as discoverSkills, s as SkillFrontmatter, t as DiscoverOptions, u as validateSkillMd } from "../index-y5JZ6STt.js";
+export { DiscoverOptions, DiscoveredSkill, ParsedSkill, SkillFrontmatter, discoverSkills, extractSkillName, filterSkills, findSkillByName, parseSkillMd, validateSkillMd };

package/dist/skill/index.js

@@ -0,0 +1,3 @@
+import { a as parseSkillMd, i as extractSkillName, n as filterSkills, o as validateSkillMd, r as findSkillByName, t as discoverSkills } from "../skill-BmLJYiQz.js";
+
+export { discoverSkills, extractSkillName, filterSkills, findSkillByName, parseSkillMd, validateSkillMd };

package/dist/skill-BmLJYiQz.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, join } from "pathe";
+import matter from "gray-matter";
+
+//#region src/skill/parse.ts
+function parseSkillMd(content) {
+	const { data, content: body } = matter(content);
+	return {
+		frontmatter: data,
+		content: body.trim(),
+		raw: content
+	};
+}
+function extractSkillName(frontmatter, filename) {
+	if (frontmatter.name) return frontmatter.name;
+	if (filename) return filename.replace(/\.md$/i, "").replace(/^SKILL[._-]?/i, "").replace(/[._-]/g, " ").trim();
+	return "Unnamed Skill";
+}
+function validateSkillMd(parsed) {
+	const errors = [];
+	if (!parsed.content) errors.push("Skill content is empty");
+	if (parsed.frontmatter.globs) {
+		const globs = Array.isArray(parsed.frontmatter.globs) ? parsed.frontmatter.globs : [parsed.frontmatter.globs];
+		for (const glob of globs) if (typeof glob !== "string") errors.push(`Invalid glob pattern: ${glob}`);
+	}
+	return errors;
+}
+
+//#endregion
+//#region src/skill/discover.ts
+const DEFAULT_EXTENSIONS = [".md"];
+function discoverSkills(dir, options = {}) {
+	const { recursive = false, extensions = DEFAULT_EXTENSIONS } = options;
+	if (!existsSync(dir)) return [];
+	const skills = [];
+	const entries = readdirSync(dir);
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		if (stat.isDirectory() && recursive) skills.push(...discoverSkills(fullPath, options));
+		else if (stat.isFile() && extensions.includes(extname(entry).toLowerCase())) try {
+			const parsed = parseSkillMd(readFileSync(fullPath, "utf-8"));
+			const filename = basename(entry, extname(entry));
+			skills.push({
+				path: fullPath,
+				filename,
+				name: extractSkillName(parsed.frontmatter, filename),
+				parsed
+			});
+		} catch {}
+	}
+	return skills;
+}
+function filterSkills(skills, query) {
+	const lowerQuery = query.toLowerCase();
+	return skills.filter((skill) => {
+		const nameMatch = skill.name.toLowerCase().includes(lowerQuery);
+		const filenameMatch = skill.filename.toLowerCase().includes(lowerQuery);
+		const tagMatch = skill.parsed.frontmatter.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery));
+		return nameMatch || filenameMatch || tagMatch;
+	});
+}
+function findSkillByName(skills, name) {
+	const lowerName = name.toLowerCase();
+	return skills.find((skill) => skill.name.toLowerCase() === lowerName || skill.filename.toLowerCase() === lowerName);
+}
+
+//#endregion
+export { parseSkillMd as a, extractSkillName as i, filterSkills as n, validateSkillMd as o, findSkillByName as r, discoverSkills as t };

package/dist/source/index.d.ts

@@ -0,0 +1,2 @@
+import { a as parseOwnerRepo, c as SourceProvider, d as getProviderFromUrl, f as parseGitHubUrl, i as isUrl, l as buildGitHubCloneUrl, n as getOwnerRepo, o as parseSource, p as parseGitLabUrl, r as isLocalPath, s as ProviderInfo, t as ParsedSource, u as buildGitLabCloneUrl } from "../index-DmiDvQ8Q.js";
+export { ParsedSource, ProviderInfo, SourceProvider, buildGitHubCloneUrl, buildGitLabCloneUrl, getOwnerRepo, getProviderFromUrl, isLocalPath, isUrl, parseGitHubUrl, parseGitLabUrl, parseOwnerRepo, parseSource };

package/dist/source/index.js

@@ -0,0 +1,3 @@
+import { a as parseSource, c as getProviderFromUrl, i as parseOwnerRepo, l as parseGitHubUrl, n as isLocalPath, o as buildGitHubCloneUrl, r as isUrl, s as buildGitLabCloneUrl, t as getOwnerRepo, u as parseGitLabUrl } from "../source-IfQxnt_F.js";
+
+export { buildGitHubCloneUrl, buildGitLabCloneUrl, getOwnerRepo, getProviderFromUrl, isLocalPath, isUrl, parseGitHubUrl, parseGitLabUrl, parseOwnerRepo, parseSource };