reskill 0.1.0

package/dist/index.js

@@ -0,0 +1,1033 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
+import * as __WEBPACK_EXTERNAL_MODULE_node_child_process__ from "node:child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_node_util__ from "node:util";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
+var __webpack_modules__ = {
+    "node:fs": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
+class GitCloneError extends Error {
+    repoUrl;
+    originalError;
+    isAuthError;
+    constructor(repoUrl, originalError){
+        const isAuthError = GitCloneError.isAuthenticationError(originalError.message);
+        let message = `Failed to clone repository: ${repoUrl}`;
+        if (isAuthError) {
+            message += '\n\nTip: For private repos, ensure git SSH keys or credentials are configured:';
+            message += '\n  - SSH: Check ~/.ssh/id_rsa or ~/.ssh/id_ed25519';
+            message += '\n  - HTTPS: Run \'git config --global credential.helper store\'';
+            message += '\n  - Or use a personal access token in the URL';
+        }
+        super(message);
+        this.name = 'GitCloneError';
+        this.repoUrl = repoUrl;
+        this.originalError = originalError;
+        this.isAuthError = isAuthError;
+    }
+    static isAuthenticationError(message) {
+        const authPatterns = [
+            /permission denied/i,
+            /could not read from remote/i,
+            /authentication failed/i,
+            /fatal: repository.*not found/i,
+            /host key verification failed/i,
+            /access denied/i,
+            /unauthorized/i,
+            /403/,
+            /401/
+        ];
+        return authPatterns.some((pattern)=>pattern.test(message));
+    }
+}
+async function git(args, cwd) {
+    const { stdout } = await execAsync(`git ${args.join(' ')}`, {
+        cwd,
+        encoding: 'utf-8'
+    });
+    return stdout.trim();
+}
+async function getRemoteTags(repoUrl) {
+    try {
+        const output = await git([
+            'ls-remote',
+            '--tags',
+            '--refs',
+            repoUrl
+        ]);
+        if (!output) return [];
+        const tags = [];
+        const lines = output.split('\n');
+        for (const line of lines){
+            const [commit, ref] = line.split('\t');
+            if (commit && ref) {
+                const tagName = ref.replace('refs/tags/', '');
+                tags.push({
+                    name: tagName,
+                    commit
+                });
+            }
+        }
+        return tags;
+    } catch  {
+        return [];
+    }
+}
+async function getLatestTag(repoUrl) {
+    const tags = await getRemoteTags(repoUrl);
+    if (0 === tags.length) return null;
+    const sortedTags = tags.sort((a, b)=>{
+        const aVer = a.name.replace(/^v/, '');
+        const bVer = b.name.replace(/^v/, '');
+        return compareVersions(bVer, aVer);
+    });
+    return sortedTags[0];
+}
+async function clone(repoUrl, destPath, options) {
+    const args = [
+        'clone'
+    ];
+    if (options?.depth) args.push('--depth', options.depth.toString());
+    if (options?.branch) args.push('--branch', options.branch);
+    args.push(repoUrl, destPath);
+    try {
+        await git(args);
+    } catch (error) {
+        throw new GitCloneError(repoUrl, error);
+    }
+}
+async function getCurrentCommit(cwd) {
+    return git([
+        'rev-parse',
+        'HEAD'
+    ], cwd);
+}
+async function getDefaultBranch(repoUrl) {
+    try {
+        const output = await git([
+            'ls-remote',
+            '--symref',
+            repoUrl,
+            'HEAD'
+        ]);
+        const match = output.match(/ref: refs\/heads\/(\S+)/);
+        return match ? match[1] : 'main';
+    } catch  {
+        return 'main';
+    }
+}
+function compareVersions(a, b) {
+    const aParts = a.split('.').map((p)=>parseInt(p, 10) || 0);
+    const bParts = b.split('.').map((p)=>parseInt(p, 10) || 0);
+    const maxLength = Math.max(aParts.length, bParts.length);
+    for(let i = 0; i < maxLength; i++){
+        const aPart = aParts[i] || 0;
+        const bPart = bParts[i] || 0;
+        if (aPart > bPart) return 1;
+        if (aPart < bPart) return -1;
+    }
+    return 0;
+}
+function buildRepoUrl(registry, ownerRepo) {
+    const registryUrls = {
+        github: 'https://github.com',
+        gitlab: 'https://gitlab.com'
+    };
+    const baseUrl = registryUrls[registry] || `https://${registry}`;
+    return `${baseUrl}/${ownerRepo}`;
+}
+function isGitUrl(source) {
+    return source.startsWith('git@') || source.startsWith('git://') || source.startsWith('http://') || source.startsWith('https://') || source.endsWith('.git');
+}
+function parseGitUrl(url) {
+    const cleanUrl = url.replace(/\.git$/, '');
+    const sshMatch = cleanUrl.match(/^git@([^:]+):(.+)$/);
+    if (sshMatch) {
+        const [, host, path] = sshMatch;
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            return {
+                host,
+                owner,
+                repo,
+                url,
+                type: 'ssh'
+            };
+        }
+    }
+    const httpMatch = cleanUrl.match(/^(https?|git):\/\/([^/]+)\/(.+)$/);
+    if (httpMatch) {
+        const [, protocol, host, path] = httpMatch;
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            return {
+                host,
+                owner,
+                repo,
+                url,
+                type: 'git' === protocol ? 'git' : 'https'
+            };
+        }
+    }
+    return null;
+}
+class GitResolver {
+    defaultRegistry;
+    constructor(defaultRegistry = 'github'){
+        this.defaultRegistry = defaultRegistry;
+    }
+    parseRef(ref) {
+        const raw = ref;
+        if (isGitUrl(ref)) return this.parseGitUrlRef(ref);
+        let remaining = ref;
+        let registry = this.defaultRegistry;
+        let version;
+        const registryMatch = remaining.match(/^([a-zA-Z0-9.-]+):(.+)$/);
+        if (registryMatch) {
+            registry = registryMatch[1];
+            remaining = registryMatch[2];
+        }
+        const atIndex = remaining.lastIndexOf('@');
+        if (atIndex > 0) {
+            version = remaining.slice(atIndex + 1);
+            remaining = remaining.slice(0, atIndex);
+        }
+        const parts = remaining.split('/');
+        if (parts.length < 2) throw new Error(`Invalid skill reference: ${ref}. Expected format: owner/repo[@version]`);
+        const owner = parts[0];
+        const repo = parts[1];
+        const subPath = parts.length > 2 ? parts.slice(2).join('/') : void 0;
+        return {
+            registry,
+            owner,
+            repo,
+            subPath,
+            version,
+            raw
+        };
+    }
+    parseGitUrlRef(ref) {
+        const raw = ref;
+        let gitUrl = ref;
+        let version;
+        let subPath;
+        const gitSuffixIndex = ref.indexOf('.git');
+        if (-1 !== gitSuffixIndex) {
+            const afterGit = ref.slice(gitSuffixIndex + 4);
+            if (afterGit) {
+                const atIndex = afterGit.lastIndexOf('@');
+                if (-1 !== atIndex) {
+                    version = afterGit.slice(atIndex + 1);
+                    const pathPart = afterGit.slice(0, atIndex);
+                    if (pathPart.startsWith('/')) subPath = pathPart.slice(1);
+                } else if (afterGit.startsWith('/')) subPath = afterGit.slice(1);
+                gitUrl = ref.slice(0, gitSuffixIndex + 4);
+            }
+        } else {
+            const atIndex = ref.lastIndexOf('@');
+            if (atIndex > 4) {
+                version = ref.slice(atIndex + 1);
+                gitUrl = ref.slice(0, atIndex);
+            }
+        }
+        const parsed = parseGitUrl(gitUrl);
+        if (!parsed) throw new Error(`Invalid Git URL: ${ref}. Expected format: git@host:owner/repo.git or https://host/owner/repo.git`);
+        return {
+            registry: parsed.host,
+            owner: parsed.owner,
+            repo: parsed.repo,
+            subPath,
+            version,
+            raw,
+            gitUrl
+        };
+    }
+    parseVersion(versionSpec) {
+        if (!versionSpec) return {
+            type: 'branch',
+            value: 'main',
+            raw: ''
+        };
+        const raw = versionSpec;
+        if ('latest' === versionSpec) return {
+            type: 'latest',
+            value: 'latest',
+            raw
+        };
+        if (versionSpec.startsWith('branch:')) return {
+            type: 'branch',
+            value: versionSpec.slice(7),
+            raw
+        };
+        if (versionSpec.startsWith('commit:')) return {
+            type: 'commit',
+            value: versionSpec.slice(7),
+            raw
+        };
+        if (/^[\^~><]/.test(versionSpec)) return {
+            type: 'range',
+            value: versionSpec,
+            raw
+        };
+        return {
+            type: 'exact',
+            value: versionSpec,
+            raw
+        };
+    }
+    buildRepoUrl(parsed) {
+        if (parsed.gitUrl) return parsed.gitUrl;
+        return buildRepoUrl(parsed.registry, `${parsed.owner}/${parsed.repo}`);
+    }
+    async resolveVersion(repoUrl, versionSpec) {
+        switch(versionSpec.type){
+            case 'exact':
+                return {
+                    ref: versionSpec.value
+                };
+            case 'latest':
+                {
+                    const latestTag = await getLatestTag(repoUrl);
+                    if (!latestTag) {
+                        const defaultBranch = await getDefaultBranch(repoUrl);
+                        return {
+                            ref: defaultBranch
+                        };
+                    }
+                    return {
+                        ref: latestTag.name,
+                        commit: latestTag.commit
+                    };
+                }
+            case 'range':
+                {
+                    const tags = await getRemoteTags(repoUrl);
+                    const matchingTags = tags.filter((tag)=>{
+                        const version = tag.name.replace(/^v/, '');
+                        return __WEBPACK_EXTERNAL_MODULE_semver__.satisfies(version, versionSpec.value);
+                    });
+                    if (0 === matchingTags.length) throw new Error(`No version found matching ${versionSpec.raw} for ${repoUrl}`);
+                    matchingTags.sort((a, b)=>{
+                        const aVer = a.name.replace(/^v/, '');
+                        const bVer = b.name.replace(/^v/, '');
+                        return __WEBPACK_EXTERNAL_MODULE_semver__.compare(bVer, aVer);
+                    });
+                    return {
+                        ref: matchingTags[0].name,
+                        commit: matchingTags[0].commit
+                    };
+                }
+            case 'branch':
+                return {
+                    ref: versionSpec.value
+                };
+            case 'commit':
+                return {
+                    ref: versionSpec.value,
+                    commit: versionSpec.value
+                };
+            default:
+                throw new Error(`Unknown version type: ${versionSpec.type}`);
+        }
+    }
+    async resolve(ref) {
+        const parsed = this.parseRef(ref);
+        const repoUrl = this.buildRepoUrl(parsed);
+        const versionSpec = this.parseVersion(parsed.version);
+        const resolved = await this.resolveVersion(repoUrl, versionSpec);
+        return {
+            parsed,
+            repoUrl,
+            ref: resolved.ref,
+            commit: resolved.commit
+        };
+    }
+}
+var external_node_fs_ = __webpack_require__("node:fs");
+function exists(filePath) {
+    return external_node_fs_.existsSync(filePath);
+}
+function readJson(filePath) {
+    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+function writeJson(filePath, data, indent = 2) {
+    const dir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(filePath);
+    if (!exists(dir)) external_node_fs_.mkdirSync(dir, {
+        recursive: true
+    });
+    external_node_fs_.writeFileSync(filePath, JSON.stringify(data, null, indent) + '\n', 'utf-8');
+}
+function ensureDir(dirPath) {
+    if (!exists(dirPath)) external_node_fs_.mkdirSync(dirPath, {
+        recursive: true
+    });
+}
+function remove(targetPath) {
+    if (exists(targetPath)) external_node_fs_.rmSync(targetPath, {
+        recursive: true,
+        force: true
+    });
+}
+function copyDir(src, dest, options) {
+    const exclude = options?.exclude || [];
+    ensureDir(dest);
+    const entries = external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        if (exclude.includes(entry.name)) continue;
+        const srcPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(src, entry.name);
+        const destPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dest, entry.name);
+        if (entry.isDirectory()) copyDir(srcPath, destPath, options);
+        else external_node_fs_.copyFileSync(srcPath, destPath);
+    }
+}
+function listDir(dirPath) {
+    if (!exists(dirPath)) return [];
+    return external_node_fs_.readdirSync(dirPath);
+}
+function isDirectory(targetPath) {
+    if (!exists(targetPath)) return false;
+    return external_node_fs_.statSync(targetPath).isDirectory();
+}
+function isSymlink(targetPath) {
+    if (!exists(targetPath)) return false;
+    return external_node_fs_.lstatSync(targetPath).isSymbolicLink();
+}
+function createSymlink(target, linkPath) {
+    const linkDir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath);
+    ensureDir(linkDir);
+    if (exists(linkPath)) remove(linkPath);
+    external_node_fs_.symlinkSync(target, linkPath, 'dir');
+}
+function getRealPath(linkPath) {
+    return external_node_fs_.realpathSync(linkPath);
+}
+function getSkillsJsonPath(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.json');
+}
+function getSkillsLockPath(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(root, 'skills.lock');
+}
+function getCacheDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return process.env.RESKILL_CACHE_DIR || __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.reskill-cache');
+}
+function getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '';
+}
+function getGlobalSkillsDir() {
+    const home = getHomeDir();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.claude', 'skills');
+}
+class CacheManager {
+    cacheDir;
+    constructor(cacheDir){
+        this.cacheDir = cacheDir || getCacheDir();
+    }
+    getCacheDir() {
+        return this.cacheDir;
+    }
+    getSkillCachePath(parsed, version) {
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo, version);
+    }
+    isCached(parsed, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        return exists(cachePath) && isDirectory(cachePath);
+    }
+    async get(parsed, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        if (!this.isCached(parsed, version)) return null;
+        const commitFile = __WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit');
+        let commit = '';
+        try {
+            const fs = await import("node:fs");
+            if (exists(commitFile)) commit = fs.readFileSync(commitFile, 'utf-8').trim();
+        } catch  {}
+        return {
+            path: cachePath,
+            commit
+        };
+    }
+    async cache(repoUrl, parsed, ref, version) {
+        const cachePath = this.getSkillCachePath(parsed, version);
+        if (exists(cachePath)) remove(cachePath);
+        ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(cachePath));
+        const tempPath = `${cachePath}.tmp`;
+        remove(tempPath);
+        await clone(repoUrl, tempPath, {
+            depth: 1,
+            branch: ref
+        });
+        const commit = await getCurrentCommit(tempPath);
+        if (parsed.subPath) {
+            const subDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(tempPath, parsed.subPath);
+            if (!exists(subDir)) {
+                remove(tempPath);
+                throw new Error(`Subpath ${parsed.subPath} not found in repository`);
+            }
+            copyDir(subDir, cachePath, {
+                exclude: [
+                    '.git'
+                ]
+            });
+        } else copyDir(tempPath, cachePath, {
+            exclude: [
+                '.git'
+            ]
+        });
+        const fs = await import("node:fs");
+        fs.writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__.join(cachePath, '.reskill-commit'), commit);
+        remove(tempPath);
+        return {
+            path: cachePath,
+            commit
+        };
+    }
+    async copyTo(parsed, version, destPath) {
+        const cached = await this.get(parsed, version);
+        if (!cached) throw new Error(`Skill ${parsed.raw} version ${version} not found in cache`);
+        if (exists(destPath)) remove(destPath);
+        copyDir(cached.path, destPath, {
+            exclude: [
+                '.reskill-commit'
+            ]
+        });
+    }
+    clearSkill(parsed, version) {
+        if (version) {
+            const cachePath = this.getSkillCachePath(parsed, version);
+            remove(cachePath);
+        } else {
+            const skillDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, parsed.registry, parsed.owner, parsed.repo);
+            remove(skillDir);
+        }
+    }
+    clearAll() {
+        remove(this.cacheDir);
+    }
+    getStats() {
+        if (!exists(this.cacheDir)) return {
+            totalSkills: 0,
+            registries: []
+        };
+        const registries = listDir(this.cacheDir).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, name)));
+        let totalSkills = 0;
+        for (const registry of registries){
+            const registryPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cacheDir, registry);
+            const owners = listDir(registryPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, name)));
+            for (const owner of owners){
+                const ownerPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(registryPath, owner);
+                const repos = listDir(ownerPath).filter((name)=>isDirectory(__WEBPACK_EXTERNAL_MODULE_node_path__.join(ownerPath, name)));
+                totalSkills += repos.length;
+            }
+        }
+        return {
+            totalSkills,
+            registries
+        };
+    }
+}
+const DEFAULT_SKILLS_JSON = {
+    skills: {},
+    defaults: {
+        registry: 'github',
+        installDir: '.skills'
+    }
+};
+const DEFAULT_REGISTRIES = {
+    github: 'https://github.com',
+    gitlab: 'https://gitlab.com'
+};
+class ConfigLoader {
+    projectRoot;
+    configPath;
+    config = null;
+    constructor(projectRoot){
+        this.projectRoot = projectRoot || process.cwd();
+        this.configPath = getSkillsJsonPath(this.projectRoot);
+    }
+    getProjectRoot() {
+        return this.projectRoot;
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+    exists() {
+        return exists(this.configPath);
+    }
+    load() {
+        if (this.config) return this.config;
+        if (!this.exists()) throw new Error(`skills.json not found in ${this.projectRoot}. Run 'reskill init' first.`);
+        try {
+            this.config = readJson(this.configPath);
+            return this.config;
+        } catch (error) {
+            throw new Error(`Failed to parse skills.json: ${error.message}`);
+        }
+    }
+    reload() {
+        this.config = null;
+        return this.load();
+    }
+    save(config) {
+        const toSave = config || this.config;
+        if (!toSave) throw new Error('No config to save');
+        writeJson(this.configPath, toSave);
+        this.config = toSave;
+    }
+    create(options) {
+        const config = {
+            ...DEFAULT_SKILLS_JSON,
+            ...options,
+            skills: options?.skills || {},
+            defaults: {
+                ...DEFAULT_SKILLS_JSON.defaults,
+                ...options?.defaults
+            }
+        };
+        this.save(config);
+        return config;
+    }
+    getDefaults() {
+        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
+        return {
+            registry: config.defaults?.registry || DEFAULT_SKILLS_JSON.defaults.registry,
+            installDir: config.defaults?.installDir || DEFAULT_SKILLS_JSON.defaults.installDir
+        };
+    }
+    getRegistryUrl(registryName) {
+        const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
+        if (config.registries?.[registryName]) return config.registries[registryName];
+        if (DEFAULT_REGISTRIES[registryName]) return DEFAULT_REGISTRIES[registryName];
+        return `https://${registryName}`;
+    }
+    getInstallDir() {
+        const defaults = this.getDefaults();
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.projectRoot, defaults.installDir);
+    }
+    addSkill(name, ref) {
+        if (!this.config) this.load();
+        this.config.skills[name] = ref;
+        this.save();
+    }
+    removeSkill(name) {
+        if (!this.config) this.load();
+        if (this.config.skills[name]) {
+            delete this.config.skills[name];
+            this.save();
+            return true;
+        }
+        return false;
+    }
+    getSkills() {
+        if (!this.config) {
+            if (!this.exists()) return {};
+            this.load();
+        }
+        return {
+            ...this.config.skills
+        };
+    }
+    hasSkill(name) {
+        const skills = this.getSkills();
+        return name in skills;
+    }
+    getSkillRef(name) {
+        const skills = this.getSkills();
+        return skills[name];
+    }
+}
+const LOCKFILE_VERSION = 1;
+class LockManager {
+    projectRoot;
+    lockPath;
+    lockData = null;
+    constructor(projectRoot){
+        this.projectRoot = projectRoot || process.cwd();
+        this.lockPath = getSkillsLockPath(this.projectRoot);
+    }
+    getLockPath() {
+        return this.lockPath;
+    }
+    exists() {
+        return exists(this.lockPath);
+    }
+    load() {
+        if (this.lockData) return this.lockData;
+        if (!this.exists()) {
+            this.lockData = {
+                lockfileVersion: LOCKFILE_VERSION,
+                skills: {}
+            };
+            return this.lockData;
+        }
+        try {
+            this.lockData = readJson(this.lockPath);
+            return this.lockData;
+        } catch (error) {
+            throw new Error(`Failed to parse skills.lock: ${error.message}`);
+        }
+    }
+    reload() {
+        this.lockData = null;
+        return this.load();
+    }
+    save(lockToSave) {
+        const toSave = lockToSave || this.lockData;
+        if (!toSave) throw new Error('No lock to save');
+        writeJson(this.lockPath, toSave);
+        this.lockData = toSave;
+    }
+    get(name) {
+        const lock = this.load();
+        return lock.skills[name];
+    }
+    set(name, skill) {
+        const lock = this.load();
+        lock.skills[name] = skill;
+        this.save();
+    }
+    remove(name) {
+        const lock = this.load();
+        if (lock.skills[name]) {
+            delete lock.skills[name];
+            this.save();
+            return true;
+        }
+        return false;
+    }
+    lockSkill(name, options) {
+        const lockedSkill = {
+            source: options.source,
+            version: options.version,
+            resolved: options.resolved,
+            commit: options.commit,
+            installedAt: new Date().toISOString()
+        };
+        this.set(name, lockedSkill);
+        return lockedSkill;
+    }
+    getAll() {
+        const lock = this.load();
+        return {
+            ...lock.skills
+        };
+    }
+    has(name) {
+        const lock = this.load();
+        return name in lock.skills;
+    }
+    isVersionMatch(name, version) {
+        const locked = this.get(name);
+        if (!locked) return false;
+        return locked.version === version;
+    }
+    clear() {
+        this.lockData = {
+            lockfileVersion: LOCKFILE_VERSION,
+            skills: {}
+        };
+        this.save();
+    }
+    delete() {
+        if (this.exists()) {
+            const fs = __webpack_require__("node:fs");
+            fs.unlinkSync(this.lockPath);
+        }
+        this.lockData = null;
+    }
+}
+const logger = {
+    info (message) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].blue('ℹ'), message);
+    },
+    success (message) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✅'), message);
+    },
+    warn (message) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow('⚠️'), message);
+    },
+    error (message) {
+        console.error(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('❌'), message);
+    },
+    debug (message) {
+        if (process.env.DEBUG || process.env.VERBOSE) console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].gray('🔍'), __WEBPACK_EXTERNAL_MODULE_chalk__["default"].gray(message));
+    },
+    package (message) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('📦'), message);
+    },
+    log (message) {
+        console.log(message);
+    },
+    newline () {
+        console.log();
+    },
+    table (headers, rows) {
+        const widths = headers.map((h, i)=>{
+            const colValues = [
+                h,
+                ...rows.map((r)=>r[i] || '')
+            ];
+            return Math.max(...colValues.map((v)=>v.length));
+        });
+        const headerRow = headers.map((h, i)=>h.padEnd(widths[i])).join('  ');
+        console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bold(headerRow));
+        for (const row of rows){
+            const rowStr = row.map((cell, i)=>(cell || '').padEnd(widths[i])).join('  ');
+            console.log(rowStr);
+        }
+    }
+};
+class SkillManager {
+    projectRoot;
+    resolver;
+    cache;
+    config;
+    lockManager;
+    isGlobal;
+    constructor(projectRoot, options){
+        this.projectRoot = projectRoot || process.cwd();
+        this.isGlobal = options?.global || false;
+        this.config = new ConfigLoader(this.projectRoot);
+        this.lockManager = new LockManager(this.projectRoot);
+        this.cache = new CacheManager();
+        const defaults = this.config.getDefaults();
+        this.resolver = new GitResolver(defaults.registry);
+    }
+    isGlobalMode() {
+        return this.isGlobal;
+    }
+    getProjectRoot() {
+        return this.projectRoot;
+    }
+    getInstallDir() {
+        if (this.isGlobal) return getGlobalSkillsDir();
+        return this.config.getInstallDir();
+    }
+    getSkillPath(name) {
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.getInstallDir(), name);
+    }
+    async install(ref, options = {}) {
+        const { force = false, save = true } = options;
+        const resolved = await this.resolver.resolve(ref);
+        const { parsed, repoUrl } = resolved;
+        const version = resolved.ref;
+        const skillName = parsed.subPath ? __WEBPACK_EXTERNAL_MODULE_node_path__.basename(parsed.subPath) : parsed.repo;
+        const skillPath = this.getSkillPath(skillName);
+        if (exists(skillPath) && !force) {
+            const locked = this.lockManager.get(skillName);
+            if (locked && locked.version === version) {
+                logger.info(`${skillName}@${version} is already installed`);
+                return this.getInstalledSkill(skillName);
+            }
+            if (!force) {
+                logger.warn(`${skillName} is already installed. Use --force to reinstall.`);
+                return this.getInstalledSkill(skillName);
+            }
+        }
+        logger["package"](`Installing ${skillName}@${version}...`);
+        let cacheResult = await this.cache.get(parsed, version);
+        if (cacheResult) logger.debug(`Using cached ${skillName}@${version}`);
+        else {
+            logger.debug(`Caching ${skillName}@${version} from ${repoUrl}`);
+            cacheResult = await this.cache.cache(repoUrl, parsed, version, version);
+        }
+        ensureDir(this.getInstallDir());
+        if (exists(skillPath)) remove(skillPath);
+        await this.cache.copyTo(parsed, version, skillPath);
+        if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`,
+            version,
+            resolved: repoUrl,
+            commit: cacheResult.commit
+        });
+        if (!this.isGlobal && save && this.config.exists()) this.config.addSkill(skillName, ref);
+        const locationHint = this.isGlobal ? '(global)' : '';
+        logger.success(`Installed ${skillName}@${version} to ${skillPath} ${locationHint}`.trim());
+        return this.getInstalledSkill(skillName);
+    }
+    async installAll(options = {}) {
+        const skills = this.config.getSkills();
+        const installed = [];
+        for (const [name, ref] of Object.entries(skills))try {
+            const skill = await this.install(ref, {
+                ...options,
+                save: false
+            });
+            installed.push(skill);
+        } catch (error) {
+            logger.error(`Failed to install ${name}: ${error.message}`);
+        }
+        return installed;
+    }
+    uninstall(name) {
+        const skillPath = this.getSkillPath(name);
+        if (!exists(skillPath)) {
+            const location = this.isGlobal ? '(global)' : '';
+            logger.warn(`Skill ${name} is not installed ${location}`.trim());
+            return false;
+        }
+        remove(skillPath);
+        if (!this.isGlobal) this.lockManager.remove(name);
+        if (!this.isGlobal && this.config.exists()) this.config.removeSkill(name);
+        const locationHint = this.isGlobal ? '(global)' : '';
+        logger.success(`Uninstalled ${name} ${locationHint}`.trim());
+        return true;
+    }
+    async update(name) {
+        const updated = [];
+        if (name) {
+            const ref = this.config.getSkillRef(name);
+            if (!ref) {
+                logger.error(`Skill ${name} not found in skills.json`);
+                return [];
+            }
+            const skill = await this.install(ref, {
+                force: true,
+                save: false
+            });
+            updated.push(skill);
+        } else {
+            const skills = this.config.getSkills();
+            for (const [skillName, ref] of Object.entries(skills))try {
+                const skill = await this.install(ref, {
+                    force: true,
+                    save: false
+                });
+                updated.push(skill);
+            } catch (error) {
+                logger.error(`Failed to update ${skillName}: ${error.message}`);
+            }
+        }
+        return updated;
+    }
+    link(localPath, name) {
+        const absolutePath = __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(localPath);
+        if (!exists(absolutePath)) throw new Error(`Path ${localPath} does not exist`);
+        const skillJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(absolutePath, 'skill.json');
+        let skillName = name || __WEBPACK_EXTERNAL_MODULE_node_path__.basename(absolutePath);
+        if (exists(skillJsonPath)) try {
+            const skillJson = readJson(skillJsonPath);
+            skillName = name || skillJson.name || skillName;
+        } catch  {}
+        const linkPath = this.getSkillPath(skillName);
+        ensureDir(this.getInstallDir());
+        createSymlink(absolutePath, linkPath);
+        logger.success(`Linked ${skillName} → ${absolutePath}`);
+        return {
+            name: skillName,
+            path: linkPath,
+            version: 'local',
+            source: absolutePath,
+            isLinked: true
+        };
+    }
+    unlink(name) {
+        const skillPath = this.getSkillPath(name);
+        if (!exists(skillPath)) {
+            logger.warn(`Skill ${name} is not installed`);
+            return false;
+        }
+        if (!isSymlink(skillPath)) {
+            logger.warn(`Skill ${name} is not a linked skill`);
+            return false;
+        }
+        remove(skillPath);
+        logger.success(`Unlinked ${name}`);
+        return true;
+    }
+    list() {
+        const installDir = this.getInstallDir();
+        if (!exists(installDir)) return [];
+        const skills = [];
+        const dirs = listDir(installDir);
+        for (const name of dirs){
+            const skillPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(installDir, name);
+            if (!isDirectory(skillPath)) continue;
+            const skill = this.getInstalledSkill(name);
+            if (skill) skills.push(skill);
+        }
+        return skills;
+    }
+    getInstalledSkill(name) {
+        const skillPath = this.getSkillPath(name);
+        if (!exists(skillPath)) return null;
+        const isLinked = isSymlink(skillPath);
+        const locked = this.lockManager.get(name);
+        let metadata;
+        const skillJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(skillPath, 'skill.json');
+        if (exists(skillJsonPath)) try {
+            metadata = readJson(skillJsonPath);
+        } catch  {}
+        return {
+            name,
+            path: skillPath,
+            version: isLinked ? 'local' : locked?.version || metadata?.version || 'unknown',
+            source: isLinked ? getRealPath(skillPath) : locked?.source || '',
+            metadata,
+            isLinked
+        };
+    }
+    getInfo(name) {
+        return {
+            installed: this.getInstalledSkill(name),
+            locked: this.lockManager.get(name),
+            config: this.config.getSkillRef(name)
+        };
+    }
+    async checkOutdated() {
+        const results = [];
+        const skills = this.config.getSkills();
+        for (const [name, ref] of Object.entries(skills))try {
+            const locked = this.lockManager.get(name);
+            const current = locked?.version || 'unknown';
+            const parsed = this.resolver.parseRef(ref);
+            const repoUrl = this.resolver.buildRepoUrl(parsed);
+            const latestResolved = await this.resolver.resolveVersion(repoUrl, {
+                type: 'latest',
+                value: 'latest',
+                raw: 'latest'
+            });
+            const latest = latestResolved.ref;
+            const updateAvailable = current !== latest && 'unknown' !== current;
+            results.push({
+                name,
+                current,
+                latest,
+                updateAvailable
+            });
+        } catch (error) {
+            logger.debug(`Failed to check ${name}: ${error.message}`);
+            results.push({
+                name,
+                current: 'unknown',
+                latest: 'unknown',
+                updateAvailable: false
+            });
+        }
+        return results;
+    }
+}
+export { CacheManager, ConfigLoader, DEFAULT_REGISTRIES, GitResolver, LockManager, SkillManager, logger };