@empjs/skill 1.0.5

package/dist/index.cjs

@@ -0,0 +1,1063 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var import_commander = require("commander");
+var import_fs = require("fs");
+var import_url = require("url");
+var import_path = require("path");
+
+// src/commands/install.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var Logger = class {
+  spinner = null;
+  info(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk.default.blue("\u2139"), message);
+  }
+  success(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk.default.green("\u2713"), message);
+  }
+  warn(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk.default.yellow("\u26A0"), message);
+  }
+  error(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk.default.red("\u2717"), message);
+  }
+  start(message) {
+    if (this.spinner) this.spinner.stop();
+    this.spinner = (0, import_ora.default)(message).start();
+    return this.spinner;
+  }
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Update spinner text without stopping it
+   */
+  updateSpinner(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  /**
+   * Log info without stopping spinner (for background info)
+   */
+  infoWithoutStop(message) {
+    if (this.spinner) {
+      const currentText = this.spinner.text;
+      this.spinner.stop();
+      console.log(import_chalk.default.blue("\u2139"), message);
+      this.spinner.start(currentText);
+    } else {
+      console.log(import_chalk.default.blue("\u2139"), message);
+    }
+  }
+};
+var logger = new Logger();
+
+// src/utils/paths.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/config/agents.ts
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var HOME = import_node_os.default.homedir();
+function getAgentSkillsDirs(agent, cwd) {
+  if (agent.skillsDirs) {
+    if (typeof agent.skillsDirs === "function") {
+      return agent.skillsDirs(cwd);
+    }
+    return agent.skillsDirs;
+  }
+  if (agent.skillsDir) {
+    return [agent.skillsDir];
+  }
+  return [];
+}
+var AGENTS = [
+  {
+    name: "claude",
+    displayName: "Claude Code",
+    skillsDir: import_node_path.default.join(HOME, ".claude", "skills"),
+    enabled: true
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: import_node_path.default.join(HOME, ".cursor", "skills"),
+    enabled: true
+  },
+  {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: import_node_path.default.join(HOME, ".windsurf", "skills"),
+    enabled: true
+  },
+  {
+    name: "cline",
+    displayName: "Cline",
+    skillsDir: import_node_path.default.join(HOME, ".cline", "skills"),
+    enabled: true
+  },
+  {
+    name: "gemini",
+    displayName: "Gemini Code",
+    skillsDir: import_node_path.default.join(HOME, ".gemini", "skills"),
+    enabled: true
+  },
+  {
+    name: "copilot",
+    displayName: "GitHub Copilot",
+    skillsDir: import_node_path.default.join(HOME, ".copilot", "skills"),
+    enabled: true
+  },
+  {
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: import_node_path.default.join(HOME, ".opencode", "skills"),
+    enabled: true
+  },
+  {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDirs: (cwd) => {
+      const dirs = [];
+      dirs.push(import_node_path.default.join(HOME, ".gemini", "antigravity", "skills"));
+      if (cwd) {
+        dirs.push(import_node_path.default.join(cwd, ".agent", "skills"));
+      }
+      if (cwd) {
+        dirs.push(import_node_path.default.join(cwd, ".shared", "skills"));
+      }
+      return dirs;
+    },
+    enabled: true
+  },
+  {
+    name: "kiro",
+    displayName: "Kiro",
+    skillsDir: import_node_path.default.join(HOME, ".kiro", "skills"),
+    enabled: true
+  },
+  {
+    name: "codex",
+    displayName: "Codex CLI",
+    skillsDir: import_node_path.default.join(HOME, ".codex", "skills"),
+    enabled: true
+  },
+  {
+    name: "qoder",
+    displayName: "Qoder",
+    skillsDir: import_node_path.default.join(HOME, ".qoder", "skills"),
+    enabled: true
+  },
+  {
+    name: "roocode",
+    displayName: "Roo Code",
+    skillsDir: import_node_path.default.join(HOME, ".roo", "skills"),
+    enabled: true
+  },
+  {
+    name: "trae",
+    displayName: "Trae",
+    skillsDir: import_node_path.default.join(HOME, ".trae", "skills"),
+    enabled: true
+  },
+  {
+    name: "continue",
+    displayName: "Continue",
+    skillsDir: import_node_path.default.join(HOME, ".continue", "skills"),
+    enabled: true
+  }
+];
+var SHARED_SKILLS_DIR = import_node_path.default.join(HOME, ".emp-agent", "skills");
+var CONFIG_FILE = import_node_path.default.join(HOME, ".emp-agent", "config.json");
+var CACHE_DIR = import_node_path.default.join(HOME, ".emp-agent", "cache");
+
+// src/utils/paths.ts
+function getSharedSkillPath(skillName) {
+  return import_node_path2.default.join(SHARED_SKILLS_DIR, skillName);
+}
+function getAgentSkillPaths(agentName, skillName, cwd) {
+  const agent = AGENTS.find((a) => a.name === agentName);
+  if (!agent) {
+    throw new Error(`Unknown agent: ${agentName}`);
+  }
+  const skillsDirs = getAgentSkillsDirs(agent, cwd);
+  return skillsDirs.map((dir) => import_node_path2.default.join(dir, skillName));
+}
+function ensureSharedDir() {
+  if (!import_node_fs.default.existsSync(SHARED_SKILLS_DIR)) {
+    import_node_fs.default.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
+  }
+}
+function detectInstalledAgents(cwd) {
+  return AGENTS.filter((agent) => {
+    try {
+      const skillsDirs = getAgentSkillsDirs(agent, cwd);
+      return skillsDirs.some((dir) => {
+        return import_node_fs.default.existsSync(dir) || import_node_fs.default.existsSync(import_node_path2.default.dirname(dir));
+      });
+    } catch {
+      return false;
+    }
+  });
+}
+function extractSkillName(nameOrPath) {
+  if (nameOrPath.startsWith("@")) {
+    const parts = nameOrPath.split("/");
+    if (parts.length === 2) {
+      const scope = parts[0].slice(1);
+      const name = parts[1].replace("-skill", "");
+      return `${scope}-${name}`;
+    }
+  }
+  return import_node_path2.default.basename(nameOrPath);
+}
+
+// src/utils/symlink.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+function createSymlink(skillName, agent, cwd) {
+  const source = getSharedSkillPath(skillName);
+  if (!import_node_fs2.default.existsSync(source)) {
+    logger.error(`Skill not found: ${source}`);
+    return false;
+  }
+  const targets = getAgentSkillPaths(agent.name, skillName, cwd);
+  let successCount = 0;
+  for (const target of targets) {
+    const targetDir = import_node_path3.default.dirname(target);
+    if (!import_node_fs2.default.existsSync(targetDir)) {
+      try {
+        import_node_fs2.default.mkdirSync(targetDir, { recursive: true });
+      } catch (error) {
+        logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
+        continue;
+      }
+    }
+    if (import_node_fs2.default.existsSync(target)) {
+      try {
+        const stats = import_node_fs2.default.lstatSync(target);
+        if (stats.isSymbolicLink()) {
+          import_node_fs2.default.unlinkSync(target);
+        } else {
+          logger.warn(`Target exists but is not a symlink, skipping: ${target}`);
+          continue;
+        }
+      } catch (error) {
+        logger.error(`Failed to remove existing target: ${error.message}`);
+        continue;
+      }
+    }
+    try {
+      import_node_fs2.default.symlinkSync(source, target, "dir");
+      successCount++;
+    } catch (error) {
+      logger.error(`Failed to create symlink at ${target}: ${error.message}`);
+    }
+  }
+  if (successCount > 0) {
+    const dirsInfo = targets.length > 1 ? ` (${successCount}/${targets.length} dirs)` : "";
+    logger.success(`\u2713 ${agent.displayName}${dirsInfo}`);
+    return true;
+  }
+  return false;
+}
+function removeSymlink(skillName, agent, cwd) {
+  const targets = getAgentSkillPaths(agent.name, skillName, cwd);
+  let removedCount = 0;
+  for (const target of targets) {
+    if (!import_node_fs2.default.existsSync(target)) {
+      continue;
+    }
+    try {
+      const stats = import_node_fs2.default.lstatSync(target);
+      if (stats.isSymbolicLink()) {
+        import_node_fs2.default.unlinkSync(target);
+        removedCount++;
+      } else {
+        logger.warn(`Not a symlink: ${target}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to remove symlink at ${target}: ${error.message}`);
+    }
+  }
+  if (removedCount > 0) {
+    const dirsInfo = targets.length > 1 ? ` (${removedCount}/${targets.length} dirs)` : "";
+    logger.success(`Unlinked from ${agent.displayName}${dirsInfo}`);
+    return true;
+  }
+  return false;
+}
+function isSymlink(filePath) {
+  try {
+    const stats = import_node_fs2.default.lstatSync(filePath);
+    return stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function readSymlink(filePath) {
+  try {
+    return import_node_fs2.default.readlinkSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/registry.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+function findNpmrc(startDir) {
+  let currentDir = import_node_path4.default.resolve(startDir);
+  while (currentDir !== import_node_path4.default.dirname(currentDir)) {
+    const npmrcPath = import_node_path4.default.join(currentDir, ".npmrc");
+    if (import_node_fs3.default.existsSync(npmrcPath)) {
+      return npmrcPath;
+    }
+    currentDir = import_node_path4.default.dirname(currentDir);
+  }
+  return null;
+}
+function parseNpmrc(npmrcPath) {
+  try {
+    const content = import_node_fs3.default.readFileSync(npmrcPath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const registryMatch = trimmed.match(/^(?:@[^:]+:)?registry\s*=\s*(.+)$/);
+      if (registryMatch) {
+        return registryMatch[1].trim();
+      }
+    }
+  } catch (error) {
+  }
+  return null;
+}
+async function getGlobalRegistry() {
+  try {
+    const { stdout } = await execAsync("npm config get registry");
+    const registry = stdout.trim();
+    if (registry && registry !== "undefined") {
+      return registry;
+    }
+  } catch (error) {
+  }
+  return null;
+}
+async function getRegistry(cwd = process.cwd()) {
+  const npmrcPath = findNpmrc(cwd);
+  if (npmrcPath) {
+    const registry = parseNpmrc(npmrcPath);
+    if (registry) {
+      return registry;
+    }
+  }
+  const globalRegistry = await getGlobalRegistry();
+  if (globalRegistry) {
+    return globalRegistry;
+  }
+  return "https://registry.npmjs.org/";
+}
+
+// src/utils/git.ts
+function parseGitUrl(url) {
+  const githubPatterns = [
+    // https://github.com/owner/repo/tree/branch/path/to/dir
+    /^https?:\/\/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)(?:\/(.+))?$/,
+    // https://github.com/owner/repo
+    /^https?:\/\/github\.com\/([^\/]+)\/([^\/]+)(?:\/)?$/,
+    // git@github.com:owner/repo.git
+    /^git@github\.com:([^\/]+)\/([^\/]+)(?:\.git)?$/
+  ];
+  const gitlabPatterns = [
+    // https://gitlab.com/owner/repo/-/tree/branch/path/to/dir
+    /^https?:\/\/gitlab\.com\/([^\/]+)\/([^\/]+)\/-\/tree\/([^\/]+)(?:\/(.+))?$/,
+    // https://gitlab.com/owner/repo
+    /^https?:\/\/gitlab\.com\/([^\/]+)\/([^\/]+)(?:\/)?$/,
+    // git@gitlab.com:owner/repo.git
+    /^git@gitlab\.com:([^\/]+)\/([^\/]+)(?:\.git)?$/
+  ];
+  for (let i = 0; i < githubPatterns.length; i++) {
+    const pattern = githubPatterns[i];
+    const match = url.match(pattern);
+    if (match) {
+      const owner = match[1];
+      const repo = match[2].replace(/\.git$/, "");
+      let branch;
+      let path7;
+      if (i === 0) {
+        branch = match[3];
+        path7 = match[4];
+      } else if (i === 1) {
+        branch = "main";
+      } else {
+        branch = "main";
+      }
+      const gitUrl = `https://github.com/${owner}/${repo}.git`;
+      return {
+        type: "github",
+        owner,
+        repo,
+        branch,
+        path: path7,
+        gitUrl,
+        installUrl: gitUrl
+        // Will be used for git clone
+      };
+    }
+  }
+  for (let i = 0; i < gitlabPatterns.length; i++) {
+    const pattern = gitlabPatterns[i];
+    const match = url.match(pattern);
+    if (match) {
+      const owner = match[1];
+      const repo = match[2].replace(/\.git$/, "");
+      let branch;
+      let path7;
+      if (i === 0) {
+        branch = match[3];
+        path7 = match[4];
+      } else if (i === 1) {
+        branch = "main";
+      } else {
+        branch = "main";
+      }
+      const gitUrl = `https://gitlab.com/${owner}/${repo}.git`;
+      return {
+        type: "gitlab",
+        owner,
+        repo,
+        branch,
+        path: path7,
+        gitUrl,
+        installUrl: gitUrl
+        // Will be used for git clone
+      };
+    }
+  }
+  if (url.startsWith("git+") || url.startsWith("git://")) {
+    return {
+      type: "other",
+      owner: "",
+      repo: "",
+      gitUrl: url.replace(/^git\+/, ""),
+      installUrl: url.startsWith("git+") ? url : `git+${url}`
+    };
+  }
+  return null;
+}
+function isGitUrl(str) {
+  return str.includes("github.com") || str.includes("gitlab.com") || str.startsWith("git@") || str.startsWith("git+") || str.startsWith("git://");
+}
+
+// src/commands/install.ts
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
+async function execWithTimeout(command, timeout = 12e4, env) {
+  let timeoutId = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`Command timeout after ${timeout / 1e3}s`));
+    }, timeout);
+  });
+  try {
+    const execOptions = env ? { env } : {};
+    const result = await Promise.race([
+      execAsync2(command, execOptions),
+      timeoutPromise
+    ]);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    return result;
+  } catch (error) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    throw error;
+  }
+}
+async function install(skillNameOrPath, options = {}) {
+  logger.info(`Installing skill: ${skillNameOrPath}`);
+  ensureSharedDir();
+  let skillPath;
+  let skillName;
+  if (isGitUrl(skillNameOrPath)) {
+    const gitInfo = parseGitUrl(skillNameOrPath);
+    if (!gitInfo) {
+      logger.error(`Invalid git URL: ${skillNameOrPath}`);
+      logger.info("Please ensure the URL is a valid GitHub or GitLab repository URL");
+      process.exit(1);
+    }
+    skillName = gitInfo.path ? extractSkillName(import_node_path5.default.basename(gitInfo.path)) : extractSkillName(gitInfo.repo);
+    const tempDir = import_node_path5.default.join("/tmp", `eskill-${Date.now()}`);
+    const cloneDir = import_node_path5.default.join(tempDir, "repo");
+    try {
+      const timeout = options.timeout || 12e4;
+      const spinner = logger.start(`Cloning ${gitInfo.gitUrl}...`);
+      logger.infoWithoutStop(`Repository: ${gitInfo.gitUrl}`);
+      if (gitInfo.branch) {
+        logger.infoWithoutStop(`Branch: ${gitInfo.branch}`);
+      }
+      if (gitInfo.path) {
+        logger.infoWithoutStop(`Path: ${gitInfo.path}`);
+      }
+      logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
+      import_node_fs4.default.mkdirSync(tempDir, { recursive: true });
+      const branchFlag = gitInfo.branch ? `-b ${gitInfo.branch}` : "";
+      const cloneCommand = branchFlag ? `git clone ${branchFlag} ${gitInfo.gitUrl} ${cloneDir} --depth 1 --quiet` : `git clone ${gitInfo.gitUrl} ${cloneDir} --depth 1 --quiet`;
+      try {
+        await execWithTimeout(cloneCommand, timeout);
+        spinner.succeed(`Repository cloned successfully`);
+      } catch (error) {
+        spinner.fail("Clone failed");
+        if (error.message.includes("timeout")) {
+          logger.error(`Clone timeout after ${timeout / 1e3} seconds`);
+          logger.info("");
+          logger.info("Possible reasons:");
+          logger.info("  - Slow network connection");
+          logger.info("  - Large repository size");
+          logger.info("  - Git server issues");
+          logger.info("");
+          logger.info(`Try again or increase timeout: eskill add ${skillNameOrPath} --timeout=300000`);
+        }
+        throw error;
+      }
+      if (gitInfo.path) {
+        skillPath = import_node_path5.default.join(cloneDir, gitInfo.path);
+        if (!import_node_fs4.default.existsSync(skillPath)) {
+          logger.error(`Path not found in repository: ${gitInfo.path}`);
+          logger.info(`Repository cloned to: ${cloneDir}`);
+          process.exit(1);
+        }
+      } else {
+        skillPath = cloneDir;
+      }
+      const skillMdPath = import_node_path5.default.join(skillPath, "SKILL.md");
+      if (!import_node_fs4.default.existsSync(skillMdPath)) {
+        logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
+        logger.info("The directory may not be a valid skill package");
+      }
+    } catch (error) {
+      logger.error(`Failed to clone repository: ${error.message}`);
+      if (error.message.includes("timeout")) {
+        logger.error(`Clone timeout after 2 minutes`);
+        logger.info("This might be due to:");
+        logger.info("  - Slow network connection");
+        logger.info("  - Large repository size");
+        logger.info("  - Git server issues");
+        logger.info(`
+Try again or check your network connection`);
+      }
+      logger.info(`
+Tried to clone: ${gitInfo.gitUrl}`);
+      if (gitInfo.branch) {
+        logger.info(`Branch: ${gitInfo.branch}`);
+      }
+      process.exit(1);
+    }
+  } else if (options.link || import_node_fs4.default.existsSync(skillNameOrPath)) {
+    skillPath = import_node_path5.default.resolve(skillNameOrPath);
+    if (!import_node_fs4.default.existsSync(skillPath)) {
+      logger.error(`Path not found: ${skillPath}`);
+      process.exit(1);
+    }
+    const pkgPath = import_node_path5.default.join(skillPath, "package.json");
+    if (import_node_fs4.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_node_fs4.default.readFileSync(pkgPath, "utf-8"));
+        skillName = extractSkillName(pkg.name);
+      } catch {
+        skillName = extractSkillName(import_node_path5.default.basename(skillPath));
+      }
+    } else {
+      skillName = extractSkillName(import_node_path5.default.basename(skillPath));
+    }
+  } else {
+    skillName = extractSkillName(skillNameOrPath);
+    const tempDir = import_node_path5.default.join("/tmp", `eskill-${Date.now()}`);
+    try {
+      const registry = options.registry || await getRegistry();
+      const timeout = options.timeout || 18e4;
+      const spinner = logger.start(`Installing ${skillNameOrPath}...`);
+      logger.infoWithoutStop(`Registry: ${registry}`);
+      logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
+      import_node_fs4.default.mkdirSync(tempDir, { recursive: true });
+      logger.updateSpinner(`Downloading ${skillNameOrPath} from ${registry}...`);
+      const homeDir = process.env.HOME || process.env.USERPROFILE || import_node_os2.default.homedir();
+      const npmCacheDir = import_node_path5.default.join(homeDir, ".npm");
+      const npmConfigPrefix = import_node_path5.default.join(homeDir, ".npm-global");
+      import_node_fs4.default.mkdirSync(npmCacheDir, { recursive: true });
+      const installCommand = `npm install ${skillNameOrPath} --prefix ${tempDir} --registry=${registry} --no-save --silent --no-bin-links --prefer-offline`;
+      const env = {
+        ...process.env,
+        npm_config_cache: npmCacheDir,
+        npm_config_prefix: npmConfigPrefix,
+        npm_config_global: "false"
+      };
+      try {
+        await execWithTimeout(installCommand, timeout, env);
+        spinner.succeed(`Package ${skillNameOrPath} downloaded successfully`);
+      } catch (error) {
+        spinner.fail("Download failed");
+        const errorMessage = error.message || error.stderr || "";
+        if (errorMessage.includes("timeout")) {
+          logger.error(`Download timeout after ${timeout / 1e3} seconds`);
+          logger.info("");
+          logger.info("Possible reasons:");
+          logger.info("  - Slow network connection");
+          logger.info("  - Registry server issues or unresponsive");
+          logger.info("  - Large package size");
+          logger.info("  - Network firewall blocking the connection");
+          logger.info("");
+          logger.info("Suggestions:");
+          logger.info(`  - Try again: eskill add ${skillNameOrPath}`);
+          logger.info(`  - Use a different registry: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`);
+          logger.info(`  - Increase timeout: eskill add ${skillNameOrPath} --timeout=300000`);
+        } else if (errorMessage.includes("EACCES") || errorMessage.includes("permission denied") || errorMessage.includes("Permission denied")) {
+          logger.error("Permission denied error detected");
+          logger.info("");
+          logger.info("This error occurs when npm tries to access system directories.");
+          logger.info("");
+          logger.info("\u{1F527} Quick Fix (Recommended):");
+          logger.info("");
+          logger.info("1. Configure npm to use user directory:");
+          logger.info(`   mkdir -p ${npmConfigPrefix}`);
+          logger.info(`   npm config set prefix '${npmConfigPrefix}'`);
+          logger.info("");
+          logger.info("2. Add to your ~/.zshrc (or ~/.bash_profile):");
+          logger.info(`   export PATH="${npmConfigPrefix}/bin:$PATH"`);
+          logger.info("");
+          logger.info("3. Reload shell configuration:");
+          logger.info("   source ~/.zshrc");
+          logger.info("");
+          logger.info("\u{1F4DA} Alternative Solutions:");
+          logger.info("");
+          logger.info("Option A: Use NVM (Node Version Manager)");
+          logger.info("   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash");
+          logger.info("   nvm install --lts");
+          logger.info("");
+          logger.info("Option B: Fix system directory permissions (requires sudo)");
+          logger.info("   sudo chown -R $(whoami) /usr/local/lib/node_modules");
+          logger.info("");
+          logger.info("Option C: Use sudo (not recommended for security reasons)");
+          logger.info(`   sudo npm install -g @empjs/skill --registry=${registry}`);
+          logger.info("");
+          logger.info("After fixing, try again:");
+          logger.info(`   eskill add ${skillNameOrPath}`);
+        } else if (errorMessage.includes("ENOTFOUND") || errorMessage.includes("ECONNREFUSED")) {
+          logger.error(`Network connection error: ${errorMessage}`);
+          logger.info("");
+          logger.info("Please check:");
+          logger.info("  - Your internet connection");
+          logger.info(`  - Registry accessibility: ${registry}`);
+          logger.info(`  - Try a different registry: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`);
+        } else {
+          logger.error(`Failed to download: ${errorMessage}`);
+          logger.info("");
+          logger.info("If this is a permission error, see the solutions above.");
+          logger.info("For other errors, please check:");
+          logger.info("  - Package name is correct");
+          logger.info("  - Registry is accessible");
+          logger.info(`  - Try: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`);
+        }
+        process.exit(1);
+      }
+      skillPath = import_node_path5.default.join(tempDir, "node_modules", skillNameOrPath);
+      if (!import_node_fs4.default.existsSync(skillPath)) {
+        logger.error(`Failed to download package: ${skillNameOrPath}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      logger.error(`Failed to download: ${error.message}`);
+      process.exit(1);
+    }
+  }
+  const targetPath = getSharedSkillPath(skillName);
+  if (import_node_fs4.default.existsSync(targetPath)) {
+    if (options.force) {
+      logger.warn("Removing existing installation...");
+      import_node_fs4.default.rmSync(targetPath, { recursive: true, force: true });
+    } else {
+      logger.error(`Skill already exists: ${targetPath}`);
+      logger.info("Use --force to overwrite");
+      process.exit(1);
+    }
+  }
+  if (options.link) {
+    import_node_fs4.default.symlinkSync(skillPath, targetPath, "dir");
+    logger.success(`Linked to shared directory (dev mode)`);
+  } else {
+    copyDir(skillPath, targetPath);
+    logger.success(`Installed to shared directory`);
+  }
+  logger.info(`\u{1F4CD} Location: ${targetPath}`);
+  const cwd = process.cwd();
+  const installedAgents = detectInstalledAgents(cwd);
+  if (installedAgents.length === 0) {
+    logger.warn("No AI agents detected");
+    logger.info("Skill installed to shared directory, but not linked to any agent");
+    logger.info("");
+    logger.info("Supported agents:");
+    logger.info("  - Claude Code (~/.claude/skills)");
+    logger.info("  - Cursor (~/.cursor/skills)");
+    logger.info("  - Windsurf (~/.windsurf/skills)");
+    return;
+  }
+  let targetAgents = installedAgents;
+  if (options.agent && options.agent !== "all") {
+    const agent = installedAgents.find((a) => a.name === options.agent);
+    if (!agent) {
+      logger.error(`Agent not installed: ${options.agent}`);
+      logger.info(`
+Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+      process.exit(1);
+    }
+    targetAgents = [agent];
+  }
+  logger.info("\nCreating symlinks...");
+  let successCount = 0;
+  for (const agent of targetAgents) {
+    if (createSymlink(skillName, agent, cwd)) {
+      successCount++;
+    }
+  }
+  logger.info("");
+  logger.success(`\u2705 Skill installed successfully!`);
+  logger.info(`
+Linked to ${successCount}/${targetAgents.length} agents`);
+  if (options.link) {
+    logger.info("\n\u{1F4A1} Dev mode: changes to source files will reflect immediately");
+  }
+}
+function copyDir(src, dest) {
+  import_node_fs4.default.mkdirSync(dest, { recursive: true });
+  const entries = import_node_fs4.default.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_node_path5.default.join(src, entry.name);
+    const destPath = import_node_path5.default.join(dest, entry.name);
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      import_node_fs4.default.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/list.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
+function list() {
+  if (!import_node_fs5.default.existsSync(SHARED_SKILLS_DIR)) {
+    logger.info("No skills installed");
+    logger.info(`
+To install a skill, run: ${import_chalk2.default.cyan("eskill install <skill-name>")}`);
+    return;
+  }
+  const skills = import_node_fs5.default.readdirSync(SHARED_SKILLS_DIR);
+  if (skills.length === 0) {
+    logger.info("No skills installed");
+    logger.info(`
+To install a skill, run: ${import_chalk2.default.cyan("eskill install <skill-name>")}`);
+    return;
+  }
+  console.log(import_chalk2.default.bold(`
+Installed skills in ${SHARED_SKILLS_DIR}:
+`));
+  for (const skill of skills) {
+    const skillPath = import_node_path6.default.join(SHARED_SKILLS_DIR, skill);
+    try {
+      const stats = import_node_fs5.default.lstatSync(skillPath);
+      if (!stats.isDirectory() && !stats.isSymbolicLink()) {
+        continue;
+      }
+      let version2 = "unknown";
+      const pkgPath = import_node_path6.default.join(skillPath, "package.json");
+      if (import_node_fs5.default.existsSync(pkgPath)) {
+        try {
+          const pkgContent = import_node_fs5.default.readFileSync(pkgPath, "utf-8");
+          const pkg = JSON.parse(pkgContent);
+          if (pkg.version && typeof pkg.version === "string") {
+            version2 = pkg.version;
+          }
+        } catch (error) {
+        }
+      }
+      if (version2 === "unknown") {
+        const skillMdPath = import_node_path6.default.join(skillPath, "SKILL.md");
+        if (import_node_fs5.default.existsSync(skillMdPath)) {
+          try {
+            const skillMdContent = import_node_fs5.default.readFileSync(skillMdPath, "utf-8");
+            const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
+            if (frontmatterMatch) {
+              const frontmatter = frontmatterMatch[1];
+              const versionMatch = frontmatter.match(/^version:\s*(.+)$/m);
+              if (versionMatch) {
+                version2 = versionMatch[1].trim().replace(/^["']|["']$/g, "");
+              }
+            }
+          } catch (error) {
+          }
+        }
+      }
+      if (version2 === "unknown" && isSymlink(skillPath)) {
+        try {
+          const targetPath = readSymlink(skillPath);
+          if (targetPath) {
+            const targetPkgPath = import_node_path6.default.join(targetPath, "package.json");
+            if (import_node_fs5.default.existsSync(targetPkgPath)) {
+              const pkg = JSON.parse(import_node_fs5.default.readFileSync(targetPkgPath, "utf-8"));
+              if (pkg.version && typeof pkg.version === "string") {
+                version2 = pkg.version;
+              }
+            }
+          }
+        } catch (error) {
+        }
+      }
+      const isDev = isSymlink(skillPath);
+      const devTag = isDev ? import_chalk2.default.yellow(" (dev)") : "";
+      const versionDisplay = version2 !== "unknown" ? import_chalk2.default.gray(`(v${version2})`) : "";
+      console.log(import_chalk2.default.green("\u{1F4E6}") + ` ${import_chalk2.default.bold(skill)}${versionDisplay ? " " + versionDisplay : ""}${devTag}`);
+      const cwd = process.cwd();
+      const linkedAgents = [];
+      for (const agent of AGENTS) {
+        const skillsDirs = getAgentSkillsDirs(agent, cwd);
+        const hasSymlink = skillsDirs.some((dir) => {
+          const agentSkillPath = import_node_path6.default.join(dir, skill);
+          if (import_node_fs5.default.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
+            const target = readSymlink(agentSkillPath);
+            return target === skillPath;
+          }
+          return false;
+        });
+        if (hasSymlink) {
+          linkedAgents.push(agent.displayName);
+        }
+      }
+      if (linkedAgents.length > 0) {
+        console.log(import_chalk2.default.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
+      } else {
+        console.log(import_chalk2.default.yellow(`   \u2192 Not linked to any agent`));
+      }
+      if (isDev) {
+        const target = readSymlink(skillPath);
+        if (target) {
+          console.log(import_chalk2.default.gray(`   \u2192 Source: ${target}`));
+        }
+      }
+      console.log("");
+    } catch (error) {
+      continue;
+    }
+  }
+}
+
+// src/commands/remove.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+async function remove(skillName, options = {}) {
+  const extractedName = extractSkillName(skillName);
+  const sharedPath = getSharedSkillPath(extractedName);
+  const skillExists = import_node_fs6.default.existsSync(sharedPath);
+  if (!skillExists) {
+    logger.error(`Skill not found: ${extractedName}`);
+    logger.info(`Location: ${sharedPath}`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const installedAgents = detectInstalledAgents(cwd);
+  let targetAgents = installedAgents;
+  if (options.agent && options.agent !== "all") {
+    const agent = installedAgents.find((a) => a.name === options.agent);
+    if (!agent) {
+      logger.error(`Agent not installed: ${options.agent}`);
+      logger.info(`
+Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+      process.exit(1);
+    }
+    targetAgents = [agent];
+  }
+  if (targetAgents.length > 0) {
+    logger.info("Removing symlinks from agents...");
+    let removedCount = 0;
+    for (const agent of targetAgents) {
+      if (removeSymlink(extractedName, agent, cwd)) {
+        removedCount++;
+      }
+    }
+    logger.info(`Removed ${removedCount}/${targetAgents.length} symlinks`);
+  }
+  if (options.agent && options.agent !== "all") {
+    logger.success(`\u2705 Removed symlinks for ${options.agent} only`);
+    logger.info(`Skill remains in shared directory: ${sharedPath}`);
+    return;
+  }
+  logger.info("Removing skill from shared directory...");
+  try {
+    const stats = import_node_fs6.default.lstatSync(sharedPath);
+    if (stats.isSymbolicLink()) {
+      import_node_fs6.default.unlinkSync(sharedPath);
+      logger.success("Removed symlink from shared directory");
+    } else {
+      import_node_fs6.default.rmSync(sharedPath, { recursive: true, force: true });
+      logger.success("Removed skill from shared directory");
+    }
+  } catch (error) {
+    logger.error(`Failed to remove skill: ${error.message}`);
+    process.exit(1);
+  }
+  const remainingSymlinks = [];
+  for (const agent of AGENTS) {
+    const agentSkillPaths = getAgentSkillPaths(agent.name, extractedName, cwd);
+    const hasSymlink = agentSkillPaths.some((path7) => {
+      return import_node_fs6.default.existsSync(path7) && isSymlink(path7);
+    });
+    if (hasSymlink) {
+      remainingSymlinks.push(agent.displayName);
+    }
+  }
+  if (remainingSymlinks.length > 0) {
+    logger.warn(`
+\u26A0\uFE0F  Warning: Found remaining symlinks in:`);
+    for (const agentName of remainingSymlinks) {
+      logger.info(`  - ${agentName}`);
+    }
+    logger.info("\nYou may need to manually remove these symlinks");
+  } else {
+    logger.success(`\u2705 Skill "${extractedName}" removed successfully!`);
+  }
+}
+
+// src/commands/agents.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+function agents() {
+  const cwd = process.cwd();
+  console.log(import_chalk3.default.bold("\n\u{1F4CB} Supported AI Agents:\n"));
+  for (const agent of AGENTS) {
+    const skillsDirs = getAgentSkillsDirs(agent, cwd);
+    const dirsInfo = skillsDirs.length > 1 ? ` (${skillsDirs.length} directories)` : "";
+    console.log(import_chalk3.default.bold(agent.displayName));
+    console.log(import_chalk3.default.gray(`  Name: ${agent.name}`));
+    if (skillsDirs.length === 0) {
+      console.log(import_chalk3.default.yellow("  \u26A0\uFE0F  No directories configured"));
+    } else {
+      console.log(import_chalk3.default.gray(`  Directories${dirsInfo}:`));
+      for (const dir of skillsDirs) {
+        const exists = import_node_fs7.default.existsSync(dir);
+        const status = exists ? import_chalk3.default.green("\u2713") : import_chalk3.default.gray("\u25CB");
+        const pathColor = exists ? import_chalk3.default.white : import_chalk3.default.gray;
+        console.log(`    ${status} ${pathColor(dir)}`);
+      }
+    }
+    console.log("");
+  }
+  console.log(import_chalk3.default.bold("\u{1F4E6} Shared Skills Directory:"));
+  const sharedExists = import_node_fs7.default.existsSync(SHARED_SKILLS_DIR);
+  const sharedStatus = sharedExists ? import_chalk3.default.green("\u2713") : import_chalk3.default.gray("\u25CB");
+  const sharedPathColor = sharedExists ? import_chalk3.default.white : import_chalk3.default.gray;
+  console.log(`  ${sharedStatus} ${sharedPathColor(SHARED_SKILLS_DIR)}`);
+  console.log("");
+  const home = import_node_os3.default.homedir();
+  if (cwd !== home) {
+    console.log(import_chalk3.default.gray(`Current working directory: ${cwd}`));
+    console.log(import_chalk3.default.gray("(Project-level directories are shown above)\n"));
+  }
+}
+
+// src/index.ts
+var __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
+var __dirname = (0, import_path.dirname)(__filename2);
+var packageJsonPath = (0, import_path.join)(__dirname, "..", "package.json");
+var packageJson = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+var version = packageJson.version;
+var program = new import_commander.Command();
+program.name("eskill").description("Unified CLI tool for managing AI agent skills").version(version);
+program.command("install <skill>").alias("add").description("Install a skill from NPM, Git URL, or local directory").option("-a, --agent <name>", "Install for specific agent (claude, cursor, windsurf, or all)").option("-l, --link", "Dev mode: symlink from local directory").option("-f, --force", "Force reinstall if already exists").option("-r, --registry <url>", "NPM registry URL (overrides .npmrc and global config)").option("-t, --timeout <ms>", "Timeout in milliseconds (default: 180000 for npm, 120000 for git)", (value) => parseInt(value, 10)).action(async (skill, options) => {
+  try {
+    await install(skill, options);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List installed skills").action(() => {
+  try {
+    list();
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.command("remove <skill>").alias("rm").alias("uninstall").description("Remove an installed skill").option("-a, --agent <name>", "Remove symlink for specific agent only (keeps skill in shared directory)").action(async (skill, options) => {
+  try {
+    await remove(skill, options);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.command("agents").alias("list-agents").description("List all supported AI agents and their skills directories").action(() => {
+  try {
+    agents();
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.cjs.map