reskill 0.1.0 → 0.11.0

package/dist/index.js

@@ -3,6 +3,9 @@ import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
 import * as __WEBPACK_EXTERNAL_MODULE_node_child_process__ from "node:child_process";
 import * as __WEBPACK_EXTERNAL_MODULE_node_util__ from "node:util";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
 import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
 var __webpack_modules__ = {
     "node:fs": function(module) {
@@ -441,6 +444,36 @@ function getGlobalSkillsDir() {
     const home = getHomeDir();
     return __WEBPACK_EXTERNAL_MODULE_node_path__.join(home, '.claude', 'skills');
 }
+const AGENTS_DIR = '.agents';
+const SKILLS_SUBDIR = 'skills';
+function getCanonicalSkillsDir(options = {}) {
+    const { global: isGlobal = false, cwd } = options;
+    const baseDir = isGlobal ? getHomeDir() : cwd || process.cwd();
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(baseDir, AGENTS_DIR, SKILLS_SUBDIR);
+}
+function getCanonicalSkillPath(skillName, options = {}) {
+    return __WEBPACK_EXTERNAL_MODULE_node_path__.join(getCanonicalSkillsDir(options), skillName);
+}
+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;
+}
+function 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 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;
+}
 class CacheManager {
     cacheDir;
     constructor(cacheDir){
@@ -452,6 +485,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);
@@ -614,7 +650,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) {
@@ -759,6 +797,341 @@ 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'))
+    }
+};
+function getAllAgentTypes() {
+    return Object.keys(agents);
+}
+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;
+}
+function getAgentSkillsDir(type, options = {}) {
+    const config = agents[type];
+    if (options.global) return config.globalSkillsDir;
+    const cwd = options.cwd || process.cwd();
+    return (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(cwd, config.skillsDir);
+}
+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);
+    }
+}
 const logger = {
     info (message) {
         console.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].blue('ℹ'), message);
@@ -1029,5 +1402,226 @@ 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;
+    }
+}
+class SkillValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'SkillValidationError';
+    }
+}
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) return {
+        data: {},
+        content
+    };
+    const yamlContent = match[1];
+    const markdownContent = match[2];
+    const data = {};
+    const lines = yamlContent.split('\n');
+    let currentKey = '';
+    let currentValue = '';
+    let inMultiline = false;
+    for (const line of lines){
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
+        const keyValueMatch = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+        if (keyValueMatch && !inMultiline) {
+            if (currentKey) data[currentKey] = parseYamlValue(currentValue.trim());
+            currentKey = keyValueMatch[1];
+            currentValue = keyValueMatch[2];
+            if ('|' === currentValue || '>' === currentValue) {
+                inMultiline = true;
+                currentValue = '';
+            }
+        } else if (inMultiline && line.startsWith('  ')) currentValue += (currentValue ? '\n' : '') + line.slice(2);
+        else if (inMultiline && !line.startsWith('  ')) {
+            inMultiline = false;
+            data[currentKey] = currentValue.trim();
+            const newKeyMatch = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+            if (newKeyMatch) {
+                currentKey = newKeyMatch[1];
+                currentValue = newKeyMatch[2];
+            }
+        }
+    }
+    if (currentKey) data[currentKey] = parseYamlValue(currentValue.trim());
+    return {
+        data,
+        content: markdownContent
+    };
+}
+function parseYamlValue(value) {
+    if (!value) return '';
+    if ('true' === value) return true;
+    if ('false' === value) return false;
+    if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+    return value;
+}
+function validateSkillName(name) {
+    if (!name) throw new SkillValidationError('Skill name is required', 'name');
+    if (name.length > 64) throw new SkillValidationError('Skill name must be at most 64 characters', 'name');
+    if (!/^[a-z0-9]/.test(name)) throw new SkillValidationError('Skill name must start with a lowercase letter or number', 'name');
+    if (!/[a-z0-9]$/.test(name)) throw new SkillValidationError('Skill name must end with a lowercase letter or number', 'name');
+    if (/--/.test(name)) throw new SkillValidationError('Skill name cannot contain consecutive hyphens', 'name');
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1) throw new SkillValidationError('Skill name can only contain lowercase letters, numbers, and hyphens', 'name');
+    if (1 === name.length && !/^[a-z0-9]$/.test(name)) throw new SkillValidationError('Single character skill name must be a lowercase letter or number', 'name');
+}
+function validateSkillDescription(description) {
+    if (!description) throw new SkillValidationError('Skill description is required', 'description');
+    if (description.length > 1024) throw new SkillValidationError('Skill description must be at most 1024 characters', 'description');
+    if (/<|>/.test(description)) throw new SkillValidationError('Skill description cannot contain angle brackets', 'description');
+}
+function parseSkillMd(content, options = {}) {
+    const { strict = false } = options;
+    try {
+        const { data, content: body } = parseFrontmatter(content);
+        if (!data.name || !data.description) {
+            if (strict) throw new SkillValidationError('SKILL.md must have name and description in frontmatter');
+            return null;
+        }
+        const name = String(data.name);
+        const description = String(data.description);
+        if (strict) {
+            validateSkillName(name);
+            validateSkillDescription(description);
+        }
+        let allowedTools;
+        if (data['allowed-tools']) {
+            const toolsStr = String(data['allowed-tools']);
+            allowedTools = toolsStr.split(/\s+/).filter(Boolean);
+        }
+        return {
+            name,
+            description,
+            license: data.license ? String(data.license) : void 0,
+            compatibility: data.compatibility ? String(data.compatibility) : void 0,
+            metadata: data.metadata,
+            allowedTools,
+            content: body,
+            rawContent: content
+        };
+    } catch (error) {
+        if (error instanceof SkillValidationError) throw error;
+        if (strict) throw new SkillValidationError(`Failed to parse SKILL.md: ${error}`);
+        return null;
+    }
+}
+function parseSkillMdFile(filePath, options = {}) {
+    if (!external_node_fs_.existsSync(filePath)) {
+        if (options.strict) throw new SkillValidationError(`SKILL.md not found: ${filePath}`);
+        return null;
+    }
+    const content = external_node_fs_.readFileSync(filePath, 'utf-8');
+    return parseSkillMd(content, options);
+}
+function parseSkillFromDir(dirPath, options = {}) {
+    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
+    return parseSkillMdFile(skillMdPath, options);
+}
+function hasValidSkillMd(dirPath) {
+    const skillMdPath = __WEBPACK_EXTERNAL_MODULE_node_path__.join(dirPath, 'SKILL.md');
+    if (!external_node_fs_.existsSync(skillMdPath)) return false;
+    try {
+        const skill = parseSkillMdFile(skillMdPath);
+        return null !== skill;
+    } catch  {
+        return false;
+    }
+}
+function generateSkillMd(skill) {
+    const frontmatter = [
+        '---'
+    ];
+    frontmatter.push(`name: ${skill.name}`);
+    frontmatter.push(`description: ${skill.description}`);
+    if (skill.license) frontmatter.push(`license: ${skill.license}`);
+    if (skill.compatibility) frontmatter.push(`compatibility: ${skill.compatibility}`);
+    if (skill.allowedTools && skill.allowedTools.length > 0) frontmatter.push(`allowed-tools: ${skill.allowedTools.join(' ')}`);
+    frontmatter.push('---');
+    frontmatter.push('');
+    return frontmatter.join('\n') + skill.content;
 }
-export { CacheManager, ConfigLoader, DEFAULT_REGISTRIES, GitResolver, LockManager, SkillManager, logger };
+export { CacheManager, ConfigLoader, DEFAULT_REGISTRIES, GitResolver, Installer, LockManager, SkillManager, SkillValidationError, agents, detectInstalledAgents, generateSkillMd, getAgentConfig, getAgentSkillsDir, getAllAgentTypes, getCanonicalSkillPath, getCanonicalSkillsDir, hasValidSkillMd, isPathSafe, isValidAgentType, logger, parseSkillFromDir, parseSkillMd, parseSkillMdFile, sanitizeName, shortenPath, validateSkillDescription, validateSkillName };

package/dist/types/index.d.ts

@@ -2,6 +2,18 @@
  * Skills Package Manager Type Definitions
  * Based on: docs/skills-management-design.md
  */
+/**
+ * 支持的 Agent 类型
+ */
+export type { AgentType, AgentConfig, } from '../core/agent-registry.js';
+/**
+ * 安装模式
+ */
+export type { InstallMode, InstallResult } from '../core/installer.js';
+/**
+ * SKILL.md 解析相关类型 (遵循 agentskills.io 规范)
+ */
+export type { SkillMdFrontmatter, ParsedSkill, } from '../core/skill-parser.js';
 /**
  * 版本规范格式
  * - 精确版本: @v1.0.0
@@ -32,6 +44,10 @@ export interface SkillsDefaults {
     registry?: string;
     /** 安装目录，默认 .skills */
     installDir?: string;
+    /** 目标 agents 列表 */
+    targetAgents?: string[];
+    /** 安装模式: symlink | copy */
+    installMode?: 'symlink' | 'copy';
 }
 /**
  * Skill 覆盖配置
@@ -193,8 +209,14 @@ export interface InstallOptions {
     force?: boolean;
     /** 保存到 skills.json */
     save?: boolean;
-    /** 全局安装到 ~/.claude/skills */
+    /** 全局安装 */
     global?: boolean;
+    /** 目标 agents 列表 */
+    agents?: string[];
+    /** 安装模式: symlink | copy */
+    mode?: 'symlink' | 'copy';
+    /** 跳过确认 */
+    yes?: boolean;
 }
 /**
  * 更新选项