reskill 0.15.0 → 0.16.0

package/dist/cli/index.js

@@ -5,6 +5,7 @@ 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";
@@ -101,92 +102,6 @@ function formatUpdateMessage(result) {
 └────────────────────────────────────────────────────┘
 `;
 }
-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 agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
 const agents = {
     amp: {
@@ -320,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;
@@ -368,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'
     });
@@ -484,23 +486,219 @@ function parseGitUrl(url) {
             };
         }
     }
-    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'
-            };
+    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;
+}
+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 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'
+        };
+        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);
     }
-    return null;
 }
 class CacheManager {
     cacheDir;
@@ -574,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) {
@@ -612,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: {},
@@ -820,296 +1041,102 @@ class GitResolver {
     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
-        };
-    }
-}
-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'
+            value: 'main',
+            raw: ''
         };
-        if (!installer_isPathSafe(agentBase, agentDir)) return {
-            success: false,
-            path: agentDir,
-            mode: installMode,
-            error: 'Invalid skill name: potential path traversal detected'
+        const raw = versionSpec;
+        if ('latest' === versionSpec) return {
+            type: 'latest',
+            value: 'latest',
+            raw
         };
-        try {
-            if ('copy' === installMode) {
-                installer_ensureDir(agentDir);
-                installer_remove(agentDir);
-                copyDirectory(sourcePath, agentDir);
+        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 {
-                    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;
@@ -1334,6 +1361,11 @@ class SkillManager {
         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) {
@@ -1342,6 +1374,12 @@ class SkillManager {
                 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, {
                 force: true,
                 save: false
@@ -1350,6 +1388,12 @@ 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
@@ -1581,6 +1625,229 @@ class SkillManager {
         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);
@@ -1991,13 +2258,49 @@ const outdatedCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('outda
         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();
@@ -2022,6 +2325,7 @@ const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update'
         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();
@@ -2035,6 +2339,7 @@ program.addCommand(outdatedCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(linkCommand);
 program.addCommand(unlinkCommand);
+program.addCommand(completionCommand);
 const updateCheckPromise = checkForUpdate(packageJson.name, packageJson.version);
 program.parseAsync().then(async ()=>{
     const result = await updateCheckPromise;