reskill 0.1.0 → 0.11.0

package/dist/cli/index.js

@@ -3,10 +3,14 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
 import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
-import * as __WEBPACK_EXTERNAL_MODULE_ora__ from "ora";
+import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts__ from "@clack/prompts";
 import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
 import * as __WEBPACK_EXTERNAL_MODULE_node_child_process__ from "node:child_process";
 import * as __WEBPACK_EXTERNAL_MODULE_node_util__ from "node:util";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_ora__ from "ora";
 var __webpack_modules__ = {
     "node:fs": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs__;
@@ -102,6 +106,13 @@ 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 DEFAULT_SKILLS_JSON = {
     skills: {},
     defaults: {
@@ -167,7 +178,9 @@ class ConfigLoader {
         const config = this.config || (this.exists() ? this.load() : DEFAULT_SKILLS_JSON);
         return {
             registry: config.defaults?.registry || DEFAULT_SKILLS_JSON.defaults.registry,
-            installDir: config.defaults?.installDir || DEFAULT_SKILLS_JSON.defaults.installDir
+            installDir: config.defaults?.installDir || DEFAULT_SKILLS_JSON.defaults.installDir,
+            targetAgents: config.defaults?.targetAgents || [],
+            installMode: config.defaults?.installMode || 'symlink'
         };
     }
     getRegistryUrl(registryName) {
@@ -630,6 +643,9 @@ class CacheManager {
     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);
@@ -827,6 +843,332 @@ class LockManager {
         this.lockData = null;
     }
 }
+const agent_registry_home = (0, __WEBPACK_EXTERNAL_MODULE_os__.homedir)();
+const agents = {
+    amp: {
+        name: 'amp',
+        displayName: 'Amp',
+        skillsDir: '.agents/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/agents/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/amp'))
+    },
+    antigravity: {
+        name: 'antigravity',
+        displayName: 'Antigravity',
+        skillsDir: '.agent/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/antigravity/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(process.cwd(), '.agent')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/antigravity'))
+    },
+    'claude-code': {
+        name: 'claude-code',
+        displayName: 'Claude Code',
+        skillsDir: '.claude/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude'))
+    },
+    clawdbot: {
+        name: 'clawdbot',
+        displayName: 'Clawdbot',
+        skillsDir: 'skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.clawdbot/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.clawdbot'))
+    },
+    codex: {
+        name: 'codex',
+        displayName: 'Codex',
+        skillsDir: '.codex/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codex/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codex'))
+    },
+    cursor: {
+        name: 'cursor',
+        displayName: 'Cursor',
+        skillsDir: '.cursor/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.cursor/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.cursor'))
+    },
+    droid: {
+        name: 'droid',
+        displayName: 'Droid',
+        skillsDir: '.factory/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.factory/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.factory/skills'))
+    },
+    'gemini-cli': {
+        name: 'gemini-cli',
+        displayName: 'Gemini CLI',
+        skillsDir: '.gemini/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.gemini'))
+    },
+    'github-copilot': {
+        name: 'github-copilot',
+        displayName: 'GitHub Copilot',
+        skillsDir: '.github/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.copilot/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(process.cwd(), '.github')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.copilot'))
+    },
+    goose: {
+        name: 'goose',
+        displayName: 'Goose',
+        skillsDir: '.goose/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/goose/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/goose'))
+    },
+    kilo: {
+        name: 'kilo',
+        displayName: 'Kilo Code',
+        skillsDir: '.kilocode/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kilocode/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kilocode'))
+    },
+    'kiro-cli': {
+        name: 'kiro-cli',
+        displayName: 'Kiro CLI',
+        skillsDir: '.kiro/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kiro/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.kiro'))
+    },
+    opencode: {
+        name: 'opencode',
+        displayName: 'OpenCode',
+        skillsDir: '.opencode/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/opencode/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.config/opencode')) || (0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.claude/skills'))
+    },
+    roo: {
+        name: 'roo',
+        displayName: 'Roo Code',
+        skillsDir: '.roo/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.roo/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.roo'))
+    },
+    trae: {
+        name: 'trae',
+        displayName: 'Trae',
+        skillsDir: '.trae/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.trae/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.trae'))
+    },
+    windsurf: {
+        name: 'windsurf',
+        displayName: 'Windsurf',
+        skillsDir: '.windsurf/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codeium/windsurf/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.codeium/windsurf'))
+    },
+    neovate: {
+        name: 'neovate',
+        displayName: 'Neovate',
+        skillsDir: '.neovate/skills',
+        globalSkillsDir: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.neovate/skills'),
+        detectInstalled: async ()=>(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(agent_registry_home, '.neovate'))
+    }
+};
+async function detectInstalledAgents() {
+    const installed = [];
+    for (const [type, config] of Object.entries(agents))if (await config.detectInstalled()) installed.push(type);
+    return installed;
+}
+function getAgentConfig(type) {
+    return agents[type];
+}
+function isValidAgentType(type) {
+    return type in agents;
+}
+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_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'
+    ]);
+    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_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 SkillManager {
     projectRoot;
     resolver;
@@ -1056,57 +1398,327 @@ class SkillManager {
         }
         return results;
     }
+    async installToAgents(ref, targetAgents, options = {}) {
+        const { save = true, mode = 'symlink' } = options;
+        const resolved = await this.resolver.resolve(ref);
+        const { parsed, repoUrl } = resolved;
+        const version = resolved.ref;
+        const skillName = parsed.subPath ? __WEBPACK_EXTERNAL_MODULE_node_path__.basename(parsed.subPath) : parsed.repo;
+        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}`);
+        else {
+            logger.debug(`Caching ${skillName}@${version} from ${repoUrl}`);
+            cacheResult = await this.cache.cache(repoUrl, parsed, version, version);
+        }
+        const sourcePath = this.cache.getCachePath(parsed, version);
+        const installer = new Installer({
+            cwd: this.projectRoot,
+            global: this.isGlobal
+        });
+        const results = await installer.installToAgents(sourcePath, skillName, targetAgents, {
+            mode: mode
+        });
+        if (!this.isGlobal) this.lockManager.lockSkill(skillName, {
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`,
+            version,
+            resolved: repoUrl,
+            commit: cacheResult.commit
+        });
+        if (!this.isGlobal && save && this.config.exists()) this.config.addSkill(skillName, ref);
+        const 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 skill = {
+            name: skillName,
+            path: sourcePath,
+            version,
+            source: `${parsed.registry}:${parsed.owner}/${parsed.repo}${parsed.subPath ? '/' + parsed.subPath : ''}`
+        };
+        return {
+            skill,
+            results
+        };
+    }
+    async getDefaultTargetAgents() {
+        const defaults = this.config.getDefaults();
+        if (defaults.targetAgents && defaults.targetAgents.length > 0) return defaults.targetAgents.filter(isValidAgentType);
+        return detectInstalledAgents();
+    }
+    getDefaultInstallMode() {
+        const defaults = this.config.getDefaults();
+        if ('copy' === defaults.installMode || 'symlink' === defaults.installMode) return defaults.installMode;
+        return 'symlink';
+    }
+    validateAgentTypes(agentNames) {
+        const valid = [];
+        const invalid = [];
+        for (const name of agentNames)if (isValidAgentType(name)) valid.push(name);
+        else invalid.push(name);
+        return {
+            valid,
+            invalid
+        };
+    }
+    getAllAgentTypes() {
+        return Object.keys(agents);
+    }
+    uninstallFromAgents(name, targetAgents) {
+        const installer = new Installer({
+            cwd: this.projectRoot,
+            global: this.isGlobal
+        });
+        const results = installer.uninstallFromAgents(name, targetAgents);
+        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)`);
+        return results;
+    }
 }
-const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('install').alias('i').description('Install a skill or all skills from skills.json').argument('[skill]', 'Skill reference (e.g., github:user/skill@v1.0.0 or git@github.com:user/repo.git)').option('-f, --force', 'Force reinstall even if already installed').option('-g, --global', 'Install globally to ~/.claude/skills').option('--no-save', 'Do not save to skills.json').action(async (skill, options)=>{
-    const isGlobal = options.global || false;
+function formatAgentNames(agentTypes, maxShow = 5) {
+    const names = agentTypes.map((a)=>agents[a].displayName);
+    if (names.length <= maxShow) return names.join(', ');
+    const shown = names.slice(0, maxShow);
+    const remaining = names.length - maxShow;
+    return `${shown.join(', ')} +${remaining} more`;
+}
+const installCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('install').alias('i').description('Install a skill or all skills from skills.json').argument('[skill]', 'Skill reference (e.g., github:user/skill@v1.0.0 or git@github.com:user/repo.git)').option('-f, --force', 'Force reinstall even if already installed').option('-g, --global', 'Install globally to user home directory').option('--no-save', 'Do not save to skills.json').option('-a, --agent <agents...>', 'Specify target agents (e.g., cursor, claude-code)').option('--mode <mode>', 'Installation mode: symlink or copy').option('-y, --yes', 'Skip confirmation prompts').option('--all', 'Install to all agents (implies -y -g)').action(async (skill, options)=>{
+    if (options.all) {
+        options.yes = true;
+        options.global = true;
+    }
+    const skipConfirm = options.yes || false;
     const configLoader = new ConfigLoader();
-    const skillManager = new SkillManager(void 0, {
-        global: isGlobal
-    });
-    if (isGlobal) logger.info(`Installing to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(getGlobalSkillsDir())} ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(global)')}`);
-    if (skill) {
-        const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])(`Installing ${skill}...`).start();
-        try {
-            const installed = await skillManager.install(skill, {
-                force: options.force,
-                save: options.save && !isGlobal,
-                global: isGlobal
-            });
-            const location = isGlobal ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(' (global)') : '';
-            spinner.succeed(`Installed ${installed.name}@${installed.version}${location}`);
-        } catch (error) {
-            spinner.fail('Installation failed');
-            logger.error(error.message);
-            process.exit(1);
-        }
-    } else {
-        if (isGlobal) {
-            logger.error('Cannot install all skills globally. Please specify a skill to install.');
-            process.exit(1);
+    const allAgentTypes = Object.keys(agents);
+    console.log();
+    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.intro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgCyan.black(' reskill '));
+    try {
+        const spinner = __WEBPACK_EXTERNAL_MODULE__clack_prompts__.spinner();
+        let targetAgents;
+        if (options.all) {
+            targetAgents = allAgentTypes;
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to all ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(targetAgents.length)} agents`);
+        } else if (options.agent && options.agent.length > 0) {
+            const validAgents = Object.keys(agents);
+            const invalidAgents = options.agent.filter((a)=>!validAgents.includes(a));
+            if (invalidAgents.length > 0) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(`Invalid agents: ${invalidAgents.join(', ')}`);
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Valid agents: ${validAgents.join(', ')}`);
+                process.exit(1);
+            }
+            targetAgents = options.agent;
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${formatAgentNames(targetAgents)}`);
+        } else {
+            spinner.start('Detecting installed agents...');
+            const installedAgents = await detectInstalledAgents();
+            spinner.stop(`Detected ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(installedAgents.length)} agent${1 !== installedAgents.length ? 's' : ''}`);
+            if (0 === installedAgents.length) {
+                if (skipConfirm) {
+                    targetAgents = allAgentTypes;
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info('Installing to all agents (none detected)');
+                } else {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn('No coding agents detected. You can still install skills.');
+                    const allAgentChoices = Object.entries(agents).map(([key, config])=>({
+                            value: key,
+                            label: config.displayName
+                        }));
+                    const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
+                        message: 'Select agents to install skills to',
+                        options: allAgentChoices,
+                        required: true,
+                        initialValues: allAgentTypes
+                    });
+                    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(selected)) {
+                        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                        process.exit(0);
+                    }
+                    targetAgents = selected;
+                }
+            } else if (1 === installedAgents.length || skipConfirm) {
+                targetAgents = installedAgents;
+                if (1 === installedAgents.length) __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(agents[installedAgents[0]].displayName)}`);
+                else __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info(`Installing to: ${installedAgents.map((a)=>__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(agents[a].displayName)).join(', ')}`);
+            } else {
+                const agentChoices = installedAgents.map((a)=>({
+                        value: a,
+                        label: agents[a].displayName,
+                        hint: agents[a].skillsDir
+                    }));
+                const selected = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.multiselect({
+                    message: 'Select agents to install skills to',
+                    options: agentChoices,
+                    required: true,
+                    initialValues: installedAgents
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(selected)) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+                targetAgents = selected;
+            }
         }
-        if (!configLoader.exists()) {
-            logger.error("skills.json not found. Run 'reskill init' first.");
-            process.exit(1);
+        let installGlobally = options.global ?? false;
+        if (void 0 === options.global && !skipConfirm) {
+            const scope = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.select({
+                message: 'Installation scope',
+                options: [
+                    {
+                        value: false,
+                        label: 'Project',
+                        hint: 'Install in current directory (committed with your project)'
+                    },
+                    {
+                        value: true,
+                        label: 'Global',
+                        hint: 'Install in home directory (available across all projects)'
+                    }
+                ]
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(scope)) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                process.exit(0);
+            }
+            installGlobally = scope;
         }
-        const skills = configLoader.getSkills();
-        if (0 === Object.keys(skills).length) {
-            logger.info('No skills defined in skills.json');
-            return;
+        let installMode = options.mode || 'symlink';
+        if (!options.mode && !skipConfirm) {
+            const modeChoice = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.select({
+                message: 'Installation method',
+                options: [
+                    {
+                        value: 'symlink',
+                        label: 'Symlink (Recommended)',
+                        hint: 'Single source of truth, easy updates'
+                    },
+                    {
+                        value: 'copy',
+                        label: 'Copy to all agents',
+                        hint: 'Independent copies for each agent'
+                    }
+                ]
+            });
+            if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(modeChoice)) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                process.exit(0);
+            }
+            installMode = modeChoice;
         }
-        logger["package"]('Installing all skills from skills.json...');
-        const spinner = (0, __WEBPACK_EXTERNAL_MODULE_ora__["default"])('Installing...').start();
-        try {
-            const installed = await skillManager.installAll({
-                force: options.force
+        const skillManager = new SkillManager(void 0, {
+            global: installGlobally
+        });
+        const cwd = process.cwd();
+        if (skill) {
+            const summaryLines = [];
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(skill)}`);
+            summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${formatAgentNames(targetAgents)}`);
+            summaryLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('Scope:')} ${installGlobally ? 'Global' : 'Project'}${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(', Mode:')} ${installMode}`);
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(summaryLines.join('\n'), 'Installation Summary');
+            if (!skipConfirm) {
+                const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.confirm({
+                    message: 'Proceed with installation?'
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(confirmed) || !confirmed) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+            }
+            spinner.start(`Installing ${skill}...`);
+            const { skill: installed, results } = await skillManager.installToAgents(skill, targetAgents, {
+                force: options.force,
+                save: options.save && !installGlobally,
+                mode: installMode
             });
-            spinner.stop();
-            logger.newline();
-            logger.success(`Installed ${installed.length} skill(s)`);
-        } catch (error) {
-            spinner.fail('Installation failed');
-            logger.error(error.message);
-            process.exit(1);
+            spinner.stop('Installation complete');
+            const successful = Array.from(results.entries()).filter(([, r])=>r.success);
+            const failed = Array.from(results.entries()).filter(([, r])=>!r.success);
+            const symlinkFailed = successful.filter(([, r])=>'symlink' === r.mode && r.symlinkFailed);
+            if (successful.length > 0) {
+                const resultLines = [];
+                const firstResult = successful[0][1];
+                if ('copy' === firstResult.mode) {
+                    resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${installed.name}@${installed.version} ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('(copied)')}`);
+                    for (const [, result] of successful){
+                        const shortPath = shortenPath(result.path, cwd);
+                        resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${shortPath}`);
+                    }
+                } else {
+                    if (firstResult.canonicalPath) {
+                        const shortPath = shortenPath(firstResult.canonicalPath, cwd);
+                        resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${shortPath}`);
+                    } else resultLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓')} ${installed.name}@${installed.version}`);
+                    const symlinked = successful.filter(([, r])=>!r.symlinkFailed).map(([a])=>agents[a].displayName);
+                    const copied = successful.filter(([, r])=>r.symlinkFailed).map(([a])=>agents[a].displayName);
+                    if (symlinked.length > 0) resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('symlink →')} ${symlinked.join(', ')}`);
+                    if (copied.length > 0) resultLines.push(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow('copied →')} ${copied.join(', ')}`);
+                }
+                const title = __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Installed 1 skill to ${successful.length} agent${1 !== successful.length ? 's' : ''}`);
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(resultLines.join('\n'), title);
+                if (symlinkFailed.length > 0) {
+                    const copiedAgentNames = symlinkFailed.map(([a])=>agents[a].displayName);
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow(`Symlinks failed for: ${copiedAgentNames.join(', ')}`));
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.message(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('  Files were copied instead. On Windows, enable Developer Mode for symlink support.'));
+                }
+            }
+            if (failed.length > 0) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red(`Failed to install to ${failed.length} agent(s)`));
+                for (const [agent, result] of failed)__WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.message(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('✗')} ${agents[agent].displayName}: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(result.error)}`);
+            }
+        } else {
+            if (installGlobally) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error('Cannot install all skills globally. Please specify a skill to install.');
+                process.exit(1);
+            }
+            if (!configLoader.exists()) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error("skills.json not found. Run 'reskill init' first.");
+                process.exit(1);
+            }
+            const skills = configLoader.getSkills();
+            if (0 === Object.keys(skills).length) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.info('No skills defined in skills.json');
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro('Done');
+                return;
+            }
+            const summaryLines = [];
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(Object.keys(skills).length)} skill(s) → ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(targetAgents.length)} agent(s)`);
+            summaryLines.push(`${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('Scope:')} ${installGlobally ? 'Global (~/)' : 'Project (./)'}${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(', Mode:')} ${installMode}`);
+            __WEBPACK_EXTERNAL_MODULE__clack_prompts__.note(summaryLines.join('\n'), 'Installation Summary');
+            if (!skipConfirm) {
+                const confirmed = await __WEBPACK_EXTERNAL_MODULE__clack_prompts__.confirm({
+                    message: 'Proceed with installation?'
+                });
+                if (__WEBPACK_EXTERNAL_MODULE__clack_prompts__.isCancel(confirmed) || !confirmed) {
+                    __WEBPACK_EXTERNAL_MODULE__clack_prompts__.cancel('Installation cancelled');
+                    process.exit(0);
+                }
+            }
+            spinner.start('Installing skills...');
+            let totalInstalled = 0;
+            let totalFailed = 0;
+            for (const [name, ref] of Object.entries(skills))try {
+                const { results } = await skillManager.installToAgents(ref, targetAgents, {
+                    force: options.force,
+                    save: false,
+                    mode: installMode
+                });
+                const successCount = Array.from(results.values()).filter((r)=>r.success).length;
+                totalInstalled += successCount;
+                totalFailed += results.size - successCount;
+            } catch (error) {
+                __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(`Failed to install ${name}: ${error.message}`);
+                totalFailed += targetAgents.length;
+            }
+            spinner.stop('Installation complete');
+            if (0 === totalFailed) __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.success(`Installed ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(Object.keys(skills).length)} skill(s) to ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(targetAgents.length)} agent(s)`);
+            else __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.warn(`Installed ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(totalInstalled)} successfully, ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red(totalFailed)} failed`);
         }
+        console.log();
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('Done!'));
+    } catch (error) {
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.log.error(error.message);
+        __WEBPACK_EXTERNAL_MODULE__clack_prompts__.outro(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('Installation failed'));
+        process.exit(1);
     }
 });
 const listCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('list').alias('ls').description('List installed skills').option('-j, --json', 'Output as JSON').option('-g, --global', 'List globally installed skills').action((options)=>{