reskill 0.14.0 → 0.16.0

package/dist/cli/index.js

@@ -4,10 +4,11 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_node_url__ from "node:url";
 import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
 import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
+import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
+import * as __WEBPACK_EXTERNAL_MODULE_tabtab__ from "tabtab";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os__ from "node:os";
 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_semver__ from "semver";
 import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts__ from "@clack/prompts";
 import * as __WEBPACK_EXTERNAL_MODULE_ora__ from "ora";
 var __webpack_modules__ = {
@@ -26,93 +27,7 @@ function __webpack_require__(moduleId) {
     return module.exports;
 }
 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');
-}
-function shortenPath(fullPath, cwd) {
-    const home = getHomeDir();
-    const currentDir = cwd || process.cwd();
-    if (fullPath.startsWith(home)) return fullPath.replace(home, '~');
-    if (fullPath.startsWith(currentDir)) return `.${fullPath.slice(currentDir.length)}`;
-    return fullPath;
-}
-const logger = {
+const logger_logger = {
     info (message) {
         console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].blue('ℹ'), message);
     },
@@ -153,6 +68,40 @@ const logger = {
         }
     }
 };
+async function checkForUpdate(packageName, currentVersion, options = {}) {
+    const timeout = options.timeout ?? 3000;
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), timeout);
+        const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) return null;
+        const data = await response.json();
+        const latest = data['dist-tags']?.latest;
+        if (!latest) return null;
+        const hasUpdate = __WEBPACK_EXTERNAL_MODULE_semver__["default"].gt(latest, currentVersion);
+        return {
+            current: currentVersion,
+            latest,
+            hasUpdate
+        };
+    } catch  {
+        return null;
+    }
+}
+function formatUpdateMessage(result) {
+    if (!result.hasUpdate) return '';
+    return `
+┌────────────────────────────────────────────────────┐
+│                                                    │
+│   Update available: ${result.current} → ${result.latest.padEnd(10)}          │
+│   Run: npm install -g reskill@latest               │
+│                                                    │
+└────────────────────────────────────────────────────┘
+`;
+}
 const agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
 const agents = {
     amp: {
@@ -286,7 +235,94 @@ function getAgentConfig(type) {
 function isValidAgentType(type) {
     return type in agents;
 }
-const execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
+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 || [];
+    const excludePrefix = options?.excludePrefix || '_';
+    ensureDir(dest);
+    const entries = external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        if (exclude.includes(entry.name) || entry.name.startsWith(excludePrefix)) 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');
+}
+function shortenPath(fullPath, cwd) {
+    const home = getHomeDir();
+    const currentDir = cwd || process.cwd();
+    if (fullPath.startsWith(home)) return fullPath.replace(home, '~');
+    if (fullPath.startsWith(currentDir)) return `.${fullPath.slice(currentDir.length)}`;
+    return fullPath;
+}
+const git_execAsync = (0, __WEBPACK_EXTERNAL_MODULE_node_util__.promisify)(__WEBPACK_EXTERNAL_MODULE_node_child_process__.exec);
 class GitCloneError extends Error {
     repoUrl;
     originalError;
@@ -334,7 +370,7 @@ class GitCloneError extends Error {
     }
 }
 async function git(args, cwd) {
-    const { stdout } = await execAsync(`git ${args.join(' ')}`, {
+    const { stdout } = await git_execAsync(`git ${args.join(' ')}`, {
         cwd,
         encoding: 'utf-8'
     });
@@ -468,40 +504,236 @@ function parseGitUrl(url) {
     }
     return null;
 }
-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);
-    }
-    getCachePath(parsed, version) {
-        return this.getSkillCachePath(parsed, version);
-    }
-    isCached(parsed, version) {
-        const cachePath = this.getSkillCachePath(parsed, version);
-        return exists(cachePath) && isDirectory(cachePath);
+const installer_AGENTS_DIR = '.agents';
+const installer_SKILLS_SUBDIR = 'skills';
+const DEFAULT_EXCLUDE_FILES = [
+    'README.md',
+    'metadata.json',
+    '.reskill-commit'
+];
+const EXCLUDE_PREFIX = '_';
+function installer_sanitizeName(name) {
+    let sanitized = name.replace(/[/\\:\0]/g, '');
+    sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, '');
+    sanitized = sanitized.replace(/^\.+/, '');
+    if (!sanitized || 0 === sanitized.length) sanitized = 'unnamed-skill';
+    if (sanitized.length > 255) sanitized = sanitized.substring(0, 255);
+    return sanitized;
+}
+function installer_isPathSafe(basePath, targetPath) {
+    const normalizedBase = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(basePath));
+    const normalizedTarget = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(targetPath));
+    return normalizedTarget.startsWith(normalizedBase + __WEBPACK_EXTERNAL_MODULE_node_path__.sep) || normalizedTarget === normalizedBase;
+}
+function installer_getCanonicalSkillsDir(isGlobal, cwd) {
+    const baseDir = isGlobal ? (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)() : cwd || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, installer_AGENTS_DIR, installer_SKILLS_SUBDIR);
+}
+function installer_ensureDir(dirPath) {
+    if (!external_node_fs_.existsSync(dirPath)) external_node_fs_.mkdirSync(dirPath, {
+        recursive: true
+    });
+}
+function installer_remove(targetPath) {
+    if (external_node_fs_.existsSync(targetPath)) external_node_fs_.rmSync(targetPath, {
+        recursive: true,
+        force: true
+    });
+}
+function copyDirectory(src, dest, options) {
+    const exclude = new Set(options?.exclude || DEFAULT_EXCLUDE_FILES);
+    installer_ensureDir(dest);
+    const entries = external_node_fs_.readdirSync(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        if (exclude.has(entry.name) || entry.name.startsWith(EXCLUDE_PREFIX)) 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()) copyDirectory(srcPath, destPath, options);
+        else external_node_fs_.copyFileSync(srcPath, destPath);
     }
-    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 = '';
+}
+async function installer_createSymlink(target, linkPath) {
+    try {
         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);
+            const stats = external_node_fs_.lstatSync(linkPath);
+            if (stats.isSymbolicLink()) {
+                const existingTarget = external_node_fs_.readlinkSync(linkPath);
+                if (__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(existingTarget) === __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(target)) return true;
+                external_node_fs_.rmSync(linkPath);
+            } else external_node_fs_.rmSync(linkPath, {
+                recursive: true
+            });
+        } catch (err) {
+            if (err && 'object' == typeof err && 'code' in err) {
+                if ('ELOOP' === err.code) try {
+                    external_node_fs_.rmSync(linkPath, {
+                        force: true
+                    });
+                } catch  {}
+            }
+        }
+        const linkDir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath);
+        installer_ensureDir(linkDir);
+        const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path__.relative(linkDir, target);
+        const symlinkType = 'win32' === (0, __WEBPACK_EXTERNAL_MODULE_node_os__.platform)() ? 'junction' : void 0;
+        external_node_fs_.symlinkSync(relativePath, linkPath, symlinkType);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+class Installer {
+    cwd;
+    isGlobal;
+    constructor(options = {}){
+        this.cwd = options.cwd || process.cwd();
+        this.isGlobal = options.global || false;
+    }
+    getCanonicalPath(skillName) {
+        const sanitized = installer_sanitizeName(skillName);
+        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
+    }
+    getAgentSkillPath(skillName, agentType) {
+        const agent = getAgentConfig(agentType);
+        const sanitized = installer_sanitizeName(skillName);
+        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
+    }
+    async installForAgent(sourcePath, skillName, agentType, options = {}) {
+        const agent = getAgentConfig(agentType);
+        const installMode = options.mode || 'symlink';
+        const sanitized = installer_sanitizeName(skillName);
+        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
+        const canonicalDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
+        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        const agentDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
+        if (!installer_isPathSafe(canonicalBase, canonicalDir)) return {
+            success: false,
+            path: agentDir,
+            mode: installMode,
+            error: 'Invalid skill name: potential path traversal detected'
+        };
+        if (!installer_isPathSafe(agentBase, agentDir)) return {
+            success: false,
+            path: agentDir,
+            mode: installMode,
+            error: 'Invalid skill name: potential path traversal detected'
+        };
+        try {
+            if ('copy' === installMode) {
+                installer_ensureDir(agentDir);
+                installer_remove(agentDir);
+                copyDirectory(sourcePath, agentDir);
+                return {
+                    success: true,
+                    path: agentDir,
+                    mode: 'copy'
+                };
+            }
+            installer_ensureDir(canonicalDir);
+            installer_remove(canonicalDir);
+            copyDirectory(sourcePath, canonicalDir);
+            const symlinkCreated = await installer_createSymlink(canonicalDir, agentDir);
+            if (!symlinkCreated) {
+                try {
+                    installer_remove(agentDir);
+                } catch  {}
+                installer_ensureDir(agentDir);
+                copyDirectory(sourcePath, agentDir);
+                return {
+                    success: true,
+                    path: agentDir,
+                    canonicalPath: canonicalDir,
+                    mode: 'symlink',
+                    symlinkFailed: true
+                };
+            }
+            return {
+                success: true,
+                path: agentDir,
+                canonicalPath: canonicalDir,
+                mode: 'symlink'
+            };
+        } catch (error) {
+            return {
+                success: false,
+                path: agentDir,
+                mode: installMode,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    async installToAgents(sourcePath, skillName, targetAgents, options = {}) {
+        const results = new Map();
+        for (const agent of targetAgents){
+            const result = await this.installForAgent(sourcePath, skillName, agent, options);
+            results.set(agent, result);
+        }
+        return results;
+    }
+    isInstalled(skillName, agentType) {
+        const skillPath = this.getAgentSkillPath(skillName, agentType);
+        return external_node_fs_.existsSync(skillPath);
+    }
+    uninstallFromAgent(skillName, agentType) {
+        const skillPath = this.getAgentSkillPath(skillName, agentType);
+        if (!external_node_fs_.existsSync(skillPath)) return false;
+        installer_remove(skillPath);
+        return true;
+    }
+    uninstallFromAgents(skillName, targetAgents) {
+        const results = new Map();
+        for (const agent of targetAgents)results.set(agent, this.uninstallFromAgent(skillName, agent));
+        const canonicalPath = this.getCanonicalPath(skillName);
+        if (external_node_fs_.existsSync(canonicalPath)) installer_remove(canonicalPath);
+        return results;
+    }
+    listInstalledSkills(agentType) {
+        const agent = getAgentConfig(agentType);
+        const skillsDir = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
+        if (!external_node_fs_.existsSync(skillsDir)) return [];
+        return external_node_fs_.readdirSync(skillsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() || entry.isSymbolicLink()).map((entry)=>entry.name);
+    }
+}
+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);
+    }
+    getCachePath(parsed, version) {
+        return this.getSkillCachePath(parsed, 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`;
@@ -540,9 +772,7 @@ class CacheManager {
         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'
-            ]
+            exclude: DEFAULT_EXCLUDE_FILES
         });
     }
     clearSkill(parsed, version) {
@@ -578,6 +808,31 @@ class CacheManager {
             registries
         };
     }
+    async getRemoteCommit(repoUrl, ref) {
+        const { exec } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execAsync = promisify(exec);
+        try {
+            const { stdout } = await execAsync(`git ls-remote ${repoUrl} ${ref}`, {
+                encoding: 'utf-8'
+            });
+            if (stdout.trim()) {
+                const [commit] = stdout.trim().split('\t');
+                return commit;
+            }
+            const { stdout: allRefs } = await execAsync(`git ls-remote ${repoUrl}`, {
+                encoding: 'utf-8'
+            });
+            const lines = allRefs.trim().split('\n');
+            for (const line of lines){
+                const [commit, refPath] = line.split('\t');
+                if (refPath === `refs/heads/${ref}` || refPath === `refs/tags/${ref}` || refPath === ref) return commit;
+            }
+            return '';
+        } catch  {
+            return '';
+        }
+    }
 }
 const DEFAULT_SKILLS_JSON = {
     skills: {},
@@ -795,287 +1050,93 @@ class GitResolver {
             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
-        };
-    }
-}
-const installer_AGENTS_DIR = '.agents';
-const installer_SKILLS_SUBDIR = 'skills';
-function installer_sanitizeName(name) {
-    let sanitized = name.replace(/[/\\:\0]/g, '');
-    sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, '');
-    sanitized = sanitized.replace(/^\.+/, '');
-    if (!sanitized || 0 === sanitized.length) sanitized = 'unnamed-skill';
-    if (sanitized.length > 255) sanitized = sanitized.substring(0, 255);
-    return sanitized;
-}
-function installer_isPathSafe(basePath, targetPath) {
-    const normalizedBase = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(basePath));
-    const normalizedTarget = __WEBPACK_EXTERNAL_MODULE_node_path__.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(targetPath));
-    return normalizedTarget.startsWith(normalizedBase + __WEBPACK_EXTERNAL_MODULE_node_path__.sep) || normalizedTarget === normalizedBase;
-}
-function installer_getCanonicalSkillsDir(isGlobal, cwd) {
-    const baseDir = isGlobal ? (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)() : cwd || process.cwd();
-    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, installer_AGENTS_DIR, installer_SKILLS_SUBDIR);
-}
-function installer_ensureDir(dirPath) {
-    if (!external_node_fs_.existsSync(dirPath)) external_node_fs_.mkdirSync(dirPath, {
-        recursive: true
-    });
-}
-function installer_remove(targetPath) {
-    if (external_node_fs_.existsSync(targetPath)) external_node_fs_.rmSync(targetPath, {
-        recursive: true,
-        force: true
-    });
-}
-function copyDirectory(src, dest, options) {
-    const exclude = new Set(options?.exclude || [
-        'README.md',
-        'metadata.json',
-        '.reskill-commit'
-    ]);
-    installer_ensureDir(dest);
-    const entries = external_node_fs_.readdirSync(src, {
-        withFileTypes: true
-    });
-    for (const entry of entries){
-        if (exclude.has(entry.name) || entry.name.startsWith('_')) 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()) copyDirectory(srcPath, destPath, options);
-        else external_node_fs_.copyFileSync(srcPath, destPath);
-    }
-}
-async function installer_createSymlink(target, linkPath) {
-    try {
-        try {
-            const stats = external_node_fs_.lstatSync(linkPath);
-            if (stats.isSymbolicLink()) {
-                const existingTarget = external_node_fs_.readlinkSync(linkPath);
-                if (__WEBPACK_EXTERNAL_MODULE_node_path__.resolve(existingTarget) === __WEBPACK_EXTERNAL_MODULE_node_path__.resolve(target)) return true;
-                external_node_fs_.rmSync(linkPath);
-            } else external_node_fs_.rmSync(linkPath, {
-                recursive: true
-            });
-        } catch (err) {
-            if (err && 'object' == typeof err && 'code' in err) {
-                if ('ELOOP' === err.code) try {
-                    external_node_fs_.rmSync(linkPath, {
-                        force: true
-                    });
-                } catch  {}
-            }
-        }
-        const linkDir = __WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath);
-        installer_ensureDir(linkDir);
-        const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path__.relative(linkDir, target);
-        const symlinkType = 'win32' === (0, __WEBPACK_EXTERNAL_MODULE_node_os__.platform)() ? 'junction' : void 0;
-        external_node_fs_.symlinkSync(relativePath, linkPath, symlinkType);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-class Installer {
-    cwd;
-    isGlobal;
-    constructor(options = {}){
-        this.cwd = options.cwd || process.cwd();
-        this.isGlobal = options.global || false;
-    }
-    getCanonicalPath(skillName) {
-        const sanitized = installer_sanitizeName(skillName);
-        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
-        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
-    }
-    getAgentSkillPath(skillName, agentType) {
-        const agent = getAgentConfig(agentType);
-        const sanitized = installer_sanitizeName(skillName);
-        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
-        return __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
-    }
-    async installForAgent(sourcePath, skillName, agentType, options = {}) {
-        const agent = getAgentConfig(agentType);
-        const installMode = options.mode || 'symlink';
-        const sanitized = installer_sanitizeName(skillName);
-        const canonicalBase = installer_getCanonicalSkillsDir(this.isGlobal, this.cwd);
-        const canonicalDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(canonicalBase, sanitized);
-        const agentBase = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
-        const agentDir = __WEBPACK_EXTERNAL_MODULE_node_path__.join(agentBase, sanitized);
-        if (!installer_isPathSafe(canonicalBase, canonicalDir)) return {
-            success: false,
-            path: agentDir,
-            mode: installMode,
-            error: 'Invalid skill name: potential path traversal detected'
-        };
-        if (!installer_isPathSafe(agentBase, agentDir)) return {
-            success: false,
-            path: agentDir,
-            mode: installMode,
-            error: 'Invalid skill name: potential path traversal detected'
+        if (versionSpec.startsWith('branch:')) return {
+            type: 'branch',
+            value: versionSpec.slice(7),
+            raw
         };
-        try {
-            if ('copy' === installMode) {
-                installer_ensureDir(agentDir);
-                installer_remove(agentDir);
-                copyDirectory(sourcePath, agentDir);
+        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 {
-                    success: true,
-                    path: agentDir,
-                    mode: 'copy'
+                    ref: versionSpec.value
                 };
-            }
-            installer_ensureDir(canonicalDir);
-            installer_remove(canonicalDir);
-            copyDirectory(sourcePath, canonicalDir);
-            const symlinkCreated = await installer_createSymlink(canonicalDir, agentDir);
-            if (!symlinkCreated) {
-                try {
-                    installer_remove(agentDir);
-                } catch  {}
-                installer_ensureDir(agentDir);
-                copyDirectory(sourcePath, agentDir);
+            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 {
-                    success: true,
-                    path: agentDir,
-                    canonicalPath: canonicalDir,
-                    mode: 'symlink',
-                    symlinkFailed: true
+                    ref: versionSpec.value
                 };
-            }
-            return {
-                success: true,
-                path: agentDir,
-                canonicalPath: canonicalDir,
-                mode: 'symlink'
-            };
-        } catch (error) {
-            return {
-                success: false,
-                path: agentDir,
-                mode: installMode,
-                error: error instanceof Error ? error.message : 'Unknown error'
-            };
-        }
-    }
-    async installToAgents(sourcePath, skillName, targetAgents, options = {}) {
-        const results = new Map();
-        for (const agent of targetAgents){
-            const result = await this.installForAgent(sourcePath, skillName, agent, options);
-            results.set(agent, result);
+            case 'commit':
+                return {
+                    ref: versionSpec.value,
+                    commit: versionSpec.value
+                };
+            default:
+                throw new Error(`Unknown version type: ${versionSpec.type}`);
         }
-        return results;
-    }
-    isInstalled(skillName, agentType) {
-        const skillPath = this.getAgentSkillPath(skillName, agentType);
-        return external_node_fs_.existsSync(skillPath);
-    }
-    uninstallFromAgent(skillName, agentType) {
-        const skillPath = this.getAgentSkillPath(skillName, agentType);
-        if (!external_node_fs_.existsSync(skillPath)) return false;
-        installer_remove(skillPath);
-        return true;
-    }
-    uninstallFromAgents(skillName, targetAgents) {
-        const results = new Map();
-        for (const agent of targetAgents)results.set(agent, this.uninstallFromAgent(skillName, agent));
-        const canonicalPath = this.getCanonicalPath(skillName);
-        if (external_node_fs_.existsSync(canonicalPath)) installer_remove(canonicalPath);
-        return results;
     }
-    listInstalledSkills(agentType) {
-        const agent = getAgentConfig(agentType);
-        const skillsDir = this.isGlobal ? agent.globalSkillsDir : __WEBPACK_EXTERNAL_MODULE_node_path__.join(this.cwd, agent.skillsDir);
-        if (!external_node_fs_.existsSync(skillsDir)) return [];
-        return external_node_fs_.readdirSync(skillsDir, {
-            withFileTypes: true
-        }).filter((entry)=>entry.isDirectory() || entry.isSymbolicLink()).map((entry)=>entry.name);
+    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
+        };
     }
 }
 const LOCKFILE_VERSION = 1;
@@ -1141,6 +1202,7 @@ class LockManager {
         const lockedSkill = {
             source: options.source,
             version: options.version,
+            ref: options.ref,
             resolved: options.resolved,
             commit: options.commit,
             installedAt: new Date().toISOString()
@@ -1220,35 +1282,43 @@ class SkillManager {
         const { force = false, save = true } = options;
         const resolved = await this.resolver.resolve(ref);
         const { parsed, repoUrl } = resolved;
-        const version = resolved.ref;
+        const gitRef = 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`);
+            const lockedRef = locked?.ref || locked?.version;
+            if (locked && lockedRef === gitRef) {
+                logger_logger.info(`${skillName}@${gitRef} is already installed`);
                 const installed = this.getInstalledSkill(skillName);
                 if (installed) return installed;
             }
             if (!force) {
-                logger.warn(`${skillName} is already installed. Use --force to reinstall.`);
+                logger_logger.warn(`${skillName} is already installed. Use --force to reinstall.`);
                 const installed = this.getInstalledSkill(skillName);
                 if (installed) return installed;
             }
         }
-        logger["package"](`Installing ${skillName}@${version}...`);
-        let cacheResult = await this.cache.get(parsed, version);
-        if (cacheResult) logger.debug(`Using cached ${skillName}@${version}`);
+        logger_logger["package"](`Installing ${skillName}@${gitRef}...`);
+        let cacheResult = await this.cache.get(parsed, gitRef);
+        if (cacheResult) logger_logger.debug(`Using cached ${skillName}@${gitRef}`);
         else {
-            logger.debug(`Caching ${skillName}@${version} from ${repoUrl}`);
-            cacheResult = await this.cache.cache(repoUrl, parsed, version, version);
+            logger_logger.debug(`Caching ${skillName}@${gitRef} from ${repoUrl}`);
+            cacheResult = await this.cache.cache(repoUrl, parsed, gitRef, gitRef);
         }
         ensureDir(this.getInstallDir());
         if (exists(skillPath)) remove(skillPath);
-        await this.cache.copyTo(parsed, version, skillPath);
+        await this.cache.copyTo(parsed, gitRef, skillPath);
+        let semanticVersion = gitRef;
+        const skillJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(skillPath, 'skill.json');
+        if (exists(skillJsonPath)) try {
+            const skillJson = readJson(skillJsonPath);
+            if (skillJson.version) semanticVersion = skillJson.version;
+        } catch  {}
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
             source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`,
-            version,
+            version: semanticVersion,
+            ref: gitRef,
             resolved: repoUrl,
             commit: cacheResult.commit
         });
@@ -1256,8 +1326,9 @@ class SkillManager {
             this.config.ensureExists();
             this.config.addSkill(skillName, ref);
         }
+        const displayVersion = semanticVersion !== gitRef ? `${semanticVersion} (${gitRef})` : gitRef;
         const locationHint = this.isGlobal ? '(global)' : '';
-        logger.success(`Installed ${skillName}@${version} to ${skillPath} ${locationHint}`.trim());
+        logger_logger.success(`Installed ${skillName}@${displayVersion} to ${skillPath} ${locationHint}`.trim());
         const installed = this.getInstalledSkill(skillName);
         if (!installed) throw new Error(`Failed to get installed skill info for ${skillName}`);
         return installed;
@@ -1272,7 +1343,7 @@ class SkillManager {
             });
             installed.push(skill);
         } catch (error) {
-            logger.error(`Failed to install ${name}: ${error.message}`);
+            logger_logger.error(`Failed to install ${name}: ${error.message}`);
         }
         return installed;
     }
@@ -1280,22 +1351,33 @@ class SkillManager {
         const skillPath = this.getSkillPath(name);
         if (!exists(skillPath)) {
             const location = this.isGlobal ? '(global)' : '';
-            logger.warn(`Skill ${name} is not installed ${location}`.trim());
+            logger_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());
+        logger_logger.success(`Uninstalled ${name} ${locationHint}`.trim());
         return true;
     }
+    checkNeedsUpdate(name, remoteCommit) {
+        const locked = this.lockManager.get(name);
+        if (!locked?.commit) return true;
+        return locked.commit !== remoteCommit;
+    }
     async update(name) {
         const updated = [];
         if (name) {
             const ref = this.config.getSkillRef(name);
             if (!ref) {
-                logger.error(`Skill ${name} not found in skills.json`);
+                logger_logger.error(`Skill ${name} not found in skills.json`);
+                return [];
+            }
+            const resolved = await this.resolver.resolve(ref);
+            const remoteCommit = await this.cache.getRemoteCommit(resolved.repoUrl, resolved.ref);
+            if (!this.checkNeedsUpdate(name, remoteCommit)) {
+                logger_logger.info(`${name} is already up to date`);
                 return [];
             }
             const skill = await this.install(ref, {
@@ -1306,13 +1388,19 @@ class SkillManager {
         } else {
             const skills = this.config.getSkills();
             for (const [skillName, ref] of Object.entries(skills))try {
+                const resolved = await this.resolver.resolve(ref);
+                const remoteCommit = await this.cache.getRemoteCommit(resolved.repoUrl, resolved.ref);
+                if (!this.checkNeedsUpdate(skillName, remoteCommit)) {
+                    logger_logger.info(`${skillName} is already up to date`);
+                    continue;
+                }
                 const skill = await this.install(ref, {
                     force: true,
                     save: false
                 });
                 updated.push(skill);
             } catch (error) {
-                logger.error(`Failed to update ${skillName}: ${error.message}`);
+                logger_logger.error(`Failed to update ${skillName}: ${error.message}`);
             }
         }
         return updated;
@@ -1329,7 +1417,7 @@ class SkillManager {
         const linkPath = this.getSkillPath(skillName);
         ensureDir(__WEBPACK_EXTERNAL_MODULE_node_path__.dirname(linkPath));
         createSymlink(absolutePath, linkPath);
-        logger.success(`Linked ${skillName} → ${absolutePath}`);
+        logger_logger.success(`Linked ${skillName} → ${absolutePath}`);
         return {
             name: skillName,
             path: linkPath,
@@ -1341,15 +1429,15 @@ class SkillManager {
     unlink(name) {
         const skillPath = this.getSkillPath(name);
         if (!exists(skillPath)) {
-            logger.warn(`Skill ${name} is not installed`);
+            logger_logger.warn(`Skill ${name} is not installed`);
             return false;
         }
         if (!isSymlink(skillPath)) {
-            logger.warn(`Skill ${name} is not a linked skill`);
+            logger_logger.warn(`Skill ${name} is not a linked skill`);
             return false;
         }
         remove(skillPath);
-        logger.success(`Unlinked ${name}`);
+        logger_logger.success(`Unlinked ${name}`);
         return true;
     }
     list() {
@@ -1419,7 +1507,8 @@ class SkillManager {
         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 currentRef = locked?.ref || locked?.version || 'unknown';
+            const currentVersion = locked?.version || 'unknown';
             const parsed = this.resolver.parseRef(ref);
             const repoUrl = this.resolver.buildRepoUrl(parsed);
             const latestResolved = await this.resolver.resolveVersion(repoUrl, {
@@ -1428,15 +1517,15 @@ class SkillManager {
                 raw: 'latest'
             });
             const latest = latestResolved.ref;
-            const updateAvailable = current !== latest && 'unknown' !== current;
+            const updateAvailable = currentRef !== latest && 'unknown' !== currentRef;
             results.push({
                 name,
-                current,
+                current: currentVersion !== currentRef ? `${currentVersion} (${currentRef})` : currentRef,
                 latest,
                 updateAvailable
             });
         } catch (error) {
-            logger.debug(`Failed to check ${name}: ${error.message}`);
+            logger_logger.debug(`Failed to check ${name}: ${error.message}`);
             results.push({
                 name,
                 current: 'unknown',
@@ -1450,16 +1539,22 @@ class SkillManager {
         const { save = true, mode = 'symlink' } = options;
         const resolved = await this.resolver.resolve(ref);
         const { parsed, repoUrl } = resolved;
-        const version = resolved.ref;
+        const gitRef = resolved.ref;
         const skillName = parsed.subPath ? __WEBPACK_EXTERNAL_MODULE_node_path__.basename(parsed.subPath) : parsed.repo;
-        logger["package"](`Installing ${skillName}@${version} to ${targetAgents.length} agent(s)...`);
-        let cacheResult = await this.cache.get(parsed, version);
-        if (cacheResult) logger.debug(`Using cached ${skillName}@${version}`);
+        logger_logger["package"](`Installing ${skillName}@${gitRef} to ${targetAgents.length} agent(s)...`);
+        let cacheResult = await this.cache.get(parsed, gitRef);
+        if (cacheResult) logger_logger.debug(`Using cached ${skillName}@${gitRef}`);
         else {
-            logger.debug(`Caching ${skillName}@${version} from ${repoUrl}`);
-            cacheResult = await this.cache.cache(repoUrl, parsed, version, version);
+            logger_logger.debug(`Caching ${skillName}@${gitRef} from ${repoUrl}`);
+            cacheResult = await this.cache.cache(repoUrl, parsed, gitRef, gitRef);
         }
-        const sourcePath = this.cache.getCachePath(parsed, version);
+        const sourcePath = this.cache.getCachePath(parsed, gitRef);
+        let semanticVersion = gitRef;
+        const skillJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(sourcePath, 'skill.json');
+        if (exists(skillJsonPath)) try {
+            const skillJson = readJson(skillJsonPath);
+            if (skillJson.version) semanticVersion = skillJson.version;
+        } catch  {}
         const installer = new Installer({
             cwd: this.projectRoot,
             global: this.isGlobal
@@ -1469,7 +1564,8 @@ class SkillManager {
         });
         if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
             source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`,
-            version,
+            version: semanticVersion,
+            ref: gitRef,
             resolved: repoUrl,
             commit: cacheResult.commit
         });
@@ -1479,12 +1575,13 @@ class SkillManager {
         }
         const successCount = Array.from(results.values()).filter((r)=>r.success).length;
         const failCount = results.size - successCount;
-        if (0 === failCount) logger.success(`Installed ${skillName}@${version} to ${successCount} agent(s)`);
-        else logger.warn(`Installed ${skillName}@${version} to ${successCount} agent(s), ${failCount} failed`);
+        const displayVersion = semanticVersion !== gitRef ? `${semanticVersion} (${gitRef})` : gitRef;
+        if (0 === failCount) logger_logger.success(`Installed ${skillName}@${displayVersion} to ${successCount} agent(s)`);
+        else logger_logger.warn(`Installed ${skillName}@${displayVersion} to ${successCount} agent(s), ${failCount} failed`);
         const skill = {
             name: skillName,
             path: sourcePath,
-            version,
+            version: semanticVersion,
             source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? `/${parsed.subPath}` : ''}`
         };
         return {
@@ -1524,10 +1621,233 @@ class SkillManager {
         if (!this.isGlobal) this.lockManager.remove(name);
         if (!this.isGlobal && this.config.exists()) this.config.removeSkill(name);
         const successCount = Array.from(results.values()).filter((r)=>r).length;
-        logger.success(`Uninstalled ${name} from ${successCount} agent(s)`);
+        logger_logger.success(`Uninstalled ${name} from ${successCount} agent(s)`);
         return results;
     }
 }
+const SUBCOMMANDS = [
+    {
+        name: 'install',
+        description: 'Install a skill or all skills from skills.json'
+    },
+    {
+        name: 'uninstall',
+        description: 'Uninstall a skill'
+    },
+    {
+        name: 'update',
+        description: 'Update installed skills'
+    },
+    {
+        name: 'info',
+        description: 'Show skill details'
+    },
+    {
+        name: 'list',
+        description: 'List installed skills'
+    },
+    {
+        name: 'link',
+        description: 'Link a local skill for development'
+    },
+    {
+        name: 'unlink',
+        description: 'Unlink a linked skill'
+    },
+    {
+        name: 'init',
+        description: 'Initialize skills.json'
+    },
+    {
+        name: 'outdated',
+        description: 'Check for outdated skills'
+    },
+    {
+        name: 'completion',
+        description: 'Setup shell completion'
+    }
+];
+const SKILL_COMPLETION_COMMANDS = [
+    'info',
+    'uninstall',
+    'update'
+];
+const LINKED_SKILL_COMMANDS = [
+    'unlink'
+];
+function getAgentNames() {
+    return Object.keys(agents);
+}
+function getInstalledSkillNames() {
+    try {
+        const skillManager = new SkillManager();
+        const skills = skillManager.list();
+        return skills.map((s)=>s.name);
+    } catch  {
+        return [];
+    }
+}
+function getLinkedSkillNames() {
+    try {
+        const skillManager = new SkillManager();
+        const skills = skillManager.list();
+        return skills.filter((s)=>s.isLinked).map((s)=>s.name);
+    } catch  {
+        return [];
+    }
+}
+function handleCompletion() {
+    const env = __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].parseEnv(process.env);
+    if (!env.complete) return;
+    const { prev, line } = env;
+    const parts = line.trim().split(/\s+/);
+    const command = parts[1];
+    if (1 === parts.length || 2 === parts.length && !line.endsWith(' ')) {
+        const completions = SUBCOMMANDS.map((c)=>({
+                name: c.name,
+                description: c.description
+            }));
+        __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log(completions);
+        return;
+    }
+    if (SKILL_COMPLETION_COMMANDS.includes(command)) {
+        if (parts.length > 2 && line.endsWith(' ')) {
+            __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+            return;
+        }
+        if (parts.length > 3) {
+            __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+            return;
+        }
+        const skills = getInstalledSkillNames();
+        __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log(skills);
+        return;
+    }
+    if (LINKED_SKILL_COMMANDS.includes(command)) {
+        if (parts.length > 2 && line.endsWith(' ')) {
+            __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+            return;
+        }
+        if (parts.length > 3) {
+            __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+            return;
+        }
+        const skills = getLinkedSkillNames();
+        __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log(skills);
+        return;
+    }
+    if ('install' === command && ('-a' === prev || '--agent' === prev)) {
+        const agentNames = getAgentNames();
+        __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log(agentNames);
+        return;
+    }
+    if ('install' === command) {
+        const { last } = env;
+        if (last.startsWith('-')) {
+            const options = [
+                {
+                    name: '-f',
+                    description: 'Force reinstall'
+                },
+                {
+                    name: '--force',
+                    description: 'Force reinstall'
+                },
+                {
+                    name: '-g',
+                    description: 'Install globally'
+                },
+                {
+                    name: '--global',
+                    description: 'Install globally'
+                },
+                {
+                    name: '-a',
+                    description: 'Specify target agents'
+                },
+                {
+                    name: '--agent',
+                    description: 'Specify target agents'
+                },
+                {
+                    name: '-y',
+                    description: 'Skip confirmation'
+                },
+                {
+                    name: '--yes',
+                    description: 'Skip confirmation'
+                },
+                {
+                    name: '--all',
+                    description: 'Install to all agents'
+                }
+            ];
+            __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log(options);
+            return;
+        }
+        __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+        return;
+    }
+    __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].log([]);
+}
+const completionCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('completion').description('Setup shell completion for reskill').argument('[action]', 'Action: install, uninstall, or shell name (bash, zsh, fish)').action(async (action)=>{
+    const env = __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].parseEnv(process.env);
+    if (env.complete) {
+        handleCompletion();
+        return;
+    }
+    if (!action) {
+        logger_logger.log('Shell completion for reskill');
+        logger_logger.newline();
+        logger_logger.log('Usage:');
+        logger_logger.log('  reskill completion install     Install completion (interactive)');
+        logger_logger.log('  reskill completion uninstall   Remove completion');
+        logger_logger.newline();
+        logger_logger.log('Supported shells: bash, zsh, fish');
+        logger_logger.newline();
+        logger_logger.log('After installation, restart your shell or run:');
+        logger_logger.log('  source ~/.bashrc   # for bash');
+        logger_logger.log('  source ~/.zshrc    # for zsh');
+        return;
+    }
+    if ('install' === action) {
+        try {
+            await __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].install({
+                name: 'reskill',
+                completer: 'reskill'
+            });
+            logger_logger.success('Completion installed successfully!');
+            logger_logger.log('Restart your shell or source your shell config file.');
+        } catch (error) {
+            logger_logger.error(`Failed to install completion: ${error.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if ('uninstall' === action) {
+        try {
+            await __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].uninstall({
+                name: 'reskill'
+            });
+            logger_logger.success('Completion uninstalled successfully!');
+        } catch (error) {
+            logger_logger.error(`Failed to uninstall completion: ${error.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    logger_logger.error(`Unknown action: ${action}`);
+    logger_logger.log('Use "reskill completion install" or "reskill completion uninstall"');
+    process.exit(1);
+});
+function maybeHandleCompletion() {
+    const env = __WEBPACK_EXTERNAL_MODULE_tabtab__["default"].parseEnv(process.env);
+    if (env.complete) {
+        handleCompletion();
+        return true;
+    }
+    return false;
+}
 const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').description('Show skill details').argument('<skill>', 'Skill name').option('-j, --json', 'Output as JSON').action((skillName, options)=>{
     const skillManager = new SkillManager();
     const info = skillManager.getInfo(skillName);
@@ -1536,41 +1856,41 @@ const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').de
         return;
     }
     if (!info.installed && !info.config) {
-        logger.error(`Skill ${skillName} not found`);
+        logger_logger.error(`Skill ${skillName} not found`);
         process.exit(1);
     }
-    logger.log(`Skill: ${skillName}`);
-    logger.newline();
+    logger_logger.log(`Skill: ${skillName}`);
+    logger_logger.newline();
     if (info.config) {
-        logger.log("Configuration (skills.json):");
-        logger.log(`  Reference: ${info.config}`);
+        logger_logger.log("Configuration (skills.json):");
+        logger_logger.log(`  Reference: ${info.config}`);
     }
     if (info.locked) {
-        logger.log("Locked Version (skills.lock):");
-        logger.log(`  Version: ${info.locked.version}`);
-        logger.log(`  Source: ${info.locked.source}`);
-        logger.log(`  Commit: ${info.locked.commit}`);
-        logger.log(`  Installed: ${info.locked.installedAt}`);
+        logger_logger.log("Locked Version (skills.lock):");
+        logger_logger.log(`  Version: ${info.locked.version}`);
+        logger_logger.log(`  Source: ${info.locked.source}`);
+        logger_logger.log(`  Commit: ${info.locked.commit}`);
+        logger_logger.log(`  Installed: ${info.locked.installedAt}`);
     }
     if (info.installed) {
-        logger.log("Installed:");
-        logger.log(`  Path: ${info.installed.path}`);
-        logger.log(`  Version: ${info.installed.version}`);
-        logger.log(`  Linked: ${info.installed.isLinked ? 'Yes' : 'No'}`);
+        logger_logger.log("Installed:");
+        logger_logger.log(`  Path: ${info.installed.path}`);
+        logger_logger.log(`  Version: ${info.installed.version}`);
+        logger_logger.log(`  Linked: ${info.installed.isLinked ? 'Yes' : 'No'}`);
         if (info.installed.metadata) {
             const meta = info.installed.metadata;
-            logger.log("Metadata (skill.json):");
-            if (meta.description) logger.log(`  Description: ${meta.description}`);
-            if (meta.author) logger.log(`  Author: ${meta.author}`);
-            if (meta.license) logger.log(`  License: ${meta.license}`);
-            if (meta.keywords?.length) logger.log(`  Keywords: ${meta.keywords.join(', ')}`);
+            logger_logger.log("Metadata (skill.json):");
+            if (meta.description) logger_logger.log(`  Description: ${meta.description}`);
+            if (meta.author) logger_logger.log(`  Author: ${meta.author}`);
+            if (meta.license) logger_logger.log(`  License: ${meta.license}`);
+            if (meta.keywords?.length) logger_logger.log(`  Keywords: ${meta.keywords.join(', ')}`);
         }
-    } else logger.warn(`Skill ${skillName} is not installed`);
+    } else logger_logger.warn(`Skill ${skillName} is not installed`);
 });
 const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').description('Initialize a new skills.json configuration').option('-n, --name <name>', 'Project name').option('-r, --registry <registry>', 'Default registry', 'github').option('-d, --install-dir <dir>', 'Skills installation directory', '.skills').option('-y, --yes', 'Skip prompts and use defaults').action(async (options)=>{
     const configLoader = new ConfigLoader();
     if (configLoader.exists()) {
-        logger.warn('skills.json already exists');
+        logger_logger.warn('skills.json already exists');
         return;
     }
     const config = configLoader.create({
@@ -1580,16 +1900,16 @@ const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').de
             installDir: options.installDir
         }
     });
-    logger.success('Created skills.json');
-    logger.newline();
-    logger.log('Configuration:');
-    logger.log(`  Name: ${config.name || '(not set)'}`);
-    logger.log(`  Default registry: ${config.defaults?.registry}`);
-    logger.log(`  Install directory: ${config.defaults?.installDir}`);
-    logger.newline();
-    logger.log('Next steps:');
-    logger.log('  reskill install <skill>  Install a skill');
-    logger.log('  reskill list             List installed skills');
+    logger_logger.success('Created skills.json');
+    logger_logger.newline();
+    logger_logger.log('Configuration:');
+    logger_logger.log(`  Name: ${config.name || '(not set)'}`);
+    logger_logger.log(`  Default registry: ${config.defaults?.registry}`);
+    logger_logger.log(`  Install directory: ${config.defaults?.installDir}`);
+    logger_logger.newline();
+    logger_logger.log('Next steps:');
+    logger_logger.log('  reskill install <skill>  Install a skill');
+    logger_logger.log('  reskill list             List installed skills');
 });
 function formatAgentNames(agentTypes, maxShow = 5) {
     const names = agentTypes.map((a)=>agents[a].displayName);
@@ -1842,9 +2162,9 @@ const linkCmd = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('link').descri
     const skillManager = new SkillManager();
     try {
         const linked = skillManager.link(localPath, options.name);
-        logger.log(`Linked skill available at: ${linked.path}`);
+        logger_logger.log(`Linked skill available at: ${linked.path}`);
     } catch (error) {
-        logger.error(error.message);
+        logger_logger.error(error.message);
         process.exit(1);
     }
 });
@@ -1863,7 +2183,7 @@ const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').al
     const skills = skillManager.list();
     if (0 === skills.length) {
         const location = isGlobal ? 'globally' : 'in this project';
-        logger.info(`No skills installed ${location}`);
+        logger_logger.info(`No skills installed ${location}`);
         return;
     }
     if (options.json) {
@@ -1871,8 +2191,8 @@ const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').al
         return;
     }
     const locationLabel = isGlobal ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(' (global)') : '';
-    logger.log(`Installed Skills (${skillManager.getInstallDir()})${locationLabel}:`);
-    logger.newline();
+    logger_logger.log(`Installed Skills (${skillManager.getInstallDir()})${locationLabel}:`);
+    logger_logger.newline();
     const headers = [
         'Name',
         'Version',
@@ -1883,19 +2203,19 @@ const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').al
             skill.isLinked ? `${skill.version} (linked)` : skill.version,
             skill.source || '-'
         ]);
-    logger.table(headers, rows);
-    logger.newline();
-    logger.log(`Total: ${skills.length} skill(s)`);
+    logger_logger.table(headers, rows);
+    logger_logger.newline();
+    logger_logger.log(`Total: ${skills.length} skill(s)`);
 });
 const outdatedCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('outdated').description('Check for outdated skills').option('-j, --json', 'Output as JSON').action(async (options)=>{
     const configLoader = new ConfigLoader();
     if (!configLoader.exists()) {
-        logger.error("skills.json not found. Run 'reskill init' first.");
+        logger_logger.error("skills.json not found. Run 'reskill init' first.");
         process.exit(1);
     }
     const skills = configLoader.getSkills();
     if (0 === Object.keys(skills).length) {
-        logger.info('No skills defined in skills.json');
+        logger_logger.info('No skills defined in skills.json');
         return;
     }
     const skillManager = new SkillManager();
@@ -1909,11 +2229,11 @@ const outdatedCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('outda
         }
         const outdated = results.filter((r)=>r.updateAvailable);
         if (0 === outdated.length) {
-            logger.success('All skills are up to date!');
+            logger_logger.success('All skills are up to date!');
             return;
         }
-        logger["package"]('Checking for updates...');
-        logger.newline();
+        logger_logger["package"]('Checking for updates...');
+        logger_logger.newline();
         const headers = [
             'Skill',
             'Current',
@@ -1926,30 +2246,66 @@ const outdatedCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('outda
                 r.latest,
                 r.updateAvailable ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow('⬆️ Update available') : __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✅ Up to date')
             ]);
-        logger.table(headers, rows);
-        logger.newline();
+        logger_logger.table(headers, rows);
+        logger_logger.newline();
         if (outdated.length > 0) {
-            logger.log(`Run ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('reskill update')} to update all skills`);
-            logger.log(`Or ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('reskill update <skill>')} to update a specific skill`);
+            logger_logger.log(`Run ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('reskill update')} to update all skills`);
+            logger_logger.log(`Or ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('reskill update <skill>')} to update a specific skill`);
         }
     } catch (error) {
         spinner.fail('Check failed');
-        logger.error(error.message);
+        logger_logger.error(error.message);
         process.exit(1);
     }
 });
-const uninstallCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('uninstall').alias('un').alias('remove').alias('rm').description('Uninstall a skill').argument('<skill>', 'Skill name to uninstall').option('-g, --global', 'Uninstall from global installation (~/.claude/skills)').action((skillName, options)=>{
+const uninstallCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('uninstall').alias('un').alias('remove').alias('rm').description('Uninstall a skill').argument('<skill>', 'Skill name to uninstall').option('-g, --global', 'Uninstall from global installation (~/.claude/skills)').option('-y, --yes', 'Skip confirmation prompts').action(async (skillName, options)=>{
     const isGlobal = options.global || false;
+    const skipConfirm = options.yes || false;
     const skillManager = new SkillManager(void 0, {
         global: isGlobal
     });
-    const result = skillManager.uninstall(skillName);
-    if (!result) process.exit(1);
+    console.log();
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.intro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgCyan.black(' reskill '));
+    const installer = new Installer({
+        cwd: process.cwd(),
+        global: isGlobal
+    });
+    const allAgentTypes = Object.keys(agents);
+    const installedAgents = allAgentTypes.filter((agent)=>installer.isInstalled(skillName, agent));
+    if (0 === installedAgents.length) {
+        const location = isGlobal ? '(global)' : '';
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn(`Skill ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skillName)} is not installed ${location}`.trim());
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro('Done');
+        process.exit(0);
+    }
+    const summaryLines = [];
+    summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skillName)}`);
+    summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${installedAgents.map((a)=>agents[a].displayName).join(', ')}`);
+    summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('Scope:')} ${isGlobal ? 'Global' : 'Project'}`);
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(summaryLines.join('\n'), 'Uninstallation Summary');
+    if (!skipConfirm) {
+        const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.confirm({
+            message: 'Proceed with uninstallation?'
+        });
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(confirmed) || !confirmed) {
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Uninstallation cancelled');
+            process.exit(0);
+        }
+    }
+    const results = skillManager.uninstallFromAgents(skillName, installedAgents);
+    const successCount = Array.from(results.values()).filter((r)=>r).length;
+    if (successCount > 0) __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.success(`Uninstalled ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skillName)} from ${successCount} agent(s)`);
+    else {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(`Failed to uninstall ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skillName)}`);
+        process.exit(1);
+    }
+    console.log();
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('Done!'));
 });
 const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update').alias('up').description('Update installed skills').argument('[skill]', 'Skill name to update (updates all if not specified)').action(async (skill)=>{
     const configLoader = new ConfigLoader();
     if (!configLoader.exists()) {
-        logger.error("skills.json not found. Run 'reskill init' first.");
+        logger_logger.error("skills.json not found. Run 'reskill init' first.");
         process.exit(1);
     }
     const skillManager = new SkillManager();
@@ -1958,17 +2314,18 @@ const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update'
         const updated = await skillManager.update(skill);
         spinner.stop();
         if (0 === updated.length) {
-            logger.info('No skills to update');
+            logger_logger.info('No skills to update');
             return;
         }
-        logger.success(`Updated ${updated.length} skill(s):`);
-        for (const s of updated)logger.log(`  - ${s.name}@${s.version}`);
+        logger_logger.success(`Updated ${updated.length} skill(s):`);
+        for (const s of updated)logger_logger.log(`  - ${s.name}@${s.version}`);
     } catch (error) {
         spinner.fail('Update failed');
-        logger.error(error.message);
+        logger_logger.error(error.message);
         process.exit(1);
     }
 });
+if (maybeHandleCompletion()) process.exit(0);
 const cli_rslib_entry_dirname = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)((0, __WEBPACK_EXTERNAL_MODULE_node_url__.fileURLToPath)(import.meta.url));
 const packageJson = JSON.parse((0, external_node_fs_.readFileSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cli_rslib_entry_dirname, '../../package.json'), 'utf-8'));
 const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
@@ -1982,4 +2339,9 @@ program.addCommand(outdatedCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(linkCommand);
 program.addCommand(unlinkCommand);
-program.parse();
+program.addCommand(completionCommand);
+const updateCheckPromise = checkForUpdate(packageJson.name, packageJson.version);
+program.parseAsync().then(async ()=>{
+    const result = await updateCheckPromise;
+    if (result?.hasUpdate) logger_logger.log(formatUpdateMessage(result));
+});