@empjs/skill 1.0.5 → 1.0.6

package/dist/index.cjs

@@ -23,82 +23,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/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");
+var import_url = require("url");
 
-// 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);
+// src/commands/agents.ts
+var import_node_fs = __toESM(require("fs"), 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);
@@ -216,7 +154,213 @@ var SHARED_SKILLS_DIR = import_node_path.default.join(HOME, ".emp-agent", "skill
 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/commands/agents.ts
+function agents() {
+  const cwd = process.cwd();
+  console.log(import_chalk.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_chalk.default.bold(agent.displayName));
+    console.log(import_chalk.default.gray(`  Name: ${agent.name}`));
+    if (skillsDirs.length === 0) {
+      console.log(import_chalk.default.yellow("  \u26A0\uFE0F  No directories configured"));
+    } else {
+      console.log(import_chalk.default.gray(`  Directories${dirsInfo}:`));
+      for (const dir of skillsDirs) {
+        const exists = import_node_fs.default.existsSync(dir);
+        const status = exists ? import_chalk.default.green("\u2713") : import_chalk.default.gray("\u25CB");
+        const pathColor = exists ? import_chalk.default.white : import_chalk.default.gray;
+        console.log(`    ${status} ${pathColor(dir)}`);
+      }
+    }
+    console.log("");
+  }
+  console.log(import_chalk.default.bold("\u{1F4E6} Shared Skills Directory:"));
+  const sharedExists = import_node_fs.default.existsSync(SHARED_SKILLS_DIR);
+  const sharedStatus = sharedExists ? import_chalk.default.green("\u2713") : import_chalk.default.gray("\u25CB");
+  const sharedPathColor = sharedExists ? import_chalk.default.white : import_chalk.default.gray;
+  console.log(`  ${sharedStatus} ${sharedPathColor(SHARED_SKILLS_DIR)}`);
+  console.log("");
+  const home = import_node_os2.default.homedir();
+  if (cwd !== home) {
+    console.log(import_chalk.default.gray(`Current working directory: ${cwd}`));
+    console.log(import_chalk.default.gray("(Project-level directories are shown above)\n"));
+  }
+}
+
+// src/commands/install.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_util2 = require("util");
+
+// 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://host/group/repo/-/tree/branch/path (self-hosted + gitlab.com)
+    /^https?:\/\/([^/]+)\/(.+)\/-\/tree\/([^/]+)(?:\/(.+))?$/,
+    // https://gitlab.com/owner/repo
+    /^https?:\/\/gitlab\.com\/([^/]+)\/([^/]+)(?:\/)?$/,
+    // git@gitlab.com:owner/repo.git or git@host:group/repo.git
+    /^git@([^:]+):(.+)(?:\.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) {
+      let owner;
+      let repo;
+      let branch;
+      let path7;
+      let gitUrl;
+      if (i === 0) {
+        const host = match[1];
+        const repoPath = match[2].replace(/\.git$/, "");
+        branch = match[3];
+        path7 = match[4];
+        const parts = repoPath.split("/");
+        repo = parts.pop() || repoPath;
+        owner = parts.join("/") || repo;
+        gitUrl = `https://${host}/${repoPath}.git`;
+      } else if (i === 1) {
+        owner = match[1];
+        repo = match[2].replace(/\.git$/, "");
+        branch = "main";
+        gitUrl = `https://gitlab.com/${owner}/${repo}.git`;
+      } else {
+        const host = match[1];
+        const repoPath = match[2].replace(/\.git$/, "");
+        branch = "main";
+        const parts = repoPath.split("/");
+        repo = parts.pop() || repoPath;
+        owner = parts.join("/") || repo;
+        gitUrl = `https://${host}/${repoPath}.git`;
+      }
+      return {
+        type: "gitlab",
+        owner,
+        repo,
+        branch,
+        path: path7,
+        gitUrl,
+        installUrl: gitUrl
+      };
+    }
+  }
+  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.includes("/-/tree/") || // GitLab web URL pattern (self-hosted)
+  str.startsWith("git@") || str.startsWith("git+") || str.startsWith("git://");
+}
+
+// src/utils/logger.ts
+var import_chalk2 = __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_chalk2.default.blue("\u2139"), message);
+  }
+  success(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk2.default.green("\u2713"), message);
+  }
+  warn(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk2.default.yellow("\u26A0"), message);
+  }
+  error(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk2.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_chalk2.default.blue("\u2139"), message);
+      this.spinner.start(currentText);
+    } else {
+      console.log(import_chalk2.default.blue("\u2139"), message);
+    }
+  }
+};
+var logger = new Logger();
+
 // src/utils/paths.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 function getSharedSkillPath(skillName) {
   return import_node_path2.default.join(SHARED_SKILLS_DIR, skillName);
 }
@@ -229,8 +373,8 @@ function getAgentSkillPaths(agentName, skillName, 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 });
+  if (!import_node_fs2.default.existsSync(SHARED_SKILLS_DIR)) {
+    import_node_fs2.default.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
   }
 }
 function detectInstalledAgents(cwd) {
@@ -238,7 +382,7 @@ function detectInstalledAgents(cwd) {
     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));
+        return import_node_fs2.default.existsSync(dir) || import_node_fs2.default.existsSync(import_node_path2.default.dirname(dir));
       });
     } catch {
       return false;
@@ -257,32 +401,93 @@ function extractSkillName(nameOrPath) {
   return import_node_path2.default.basename(nameOrPath);
 }
 
-// src/utils/symlink.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
+// src/utils/registry.ts
+var import_node_child_process = require("child_process");
+var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+function findNpmrc(startDir) {
+  let currentDir = import_node_path3.default.resolve(startDir);
+  while (currentDir !== import_node_path3.default.dirname(currentDir)) {
+    const npmrcPath = import_node_path3.default.join(currentDir, ".npmrc");
+    if (import_node_fs3.default.existsSync(npmrcPath)) {
+      return npmrcPath;
+    }
+    currentDir = import_node_path3.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/symlink.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 function createSymlink(skillName, agent, cwd) {
   const source = getSharedSkillPath(skillName);
-  if (!import_node_fs2.default.existsSync(source)) {
+  if (!import_node_fs4.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)) {
+    const targetDir = import_node_path4.default.dirname(target);
+    if (!import_node_fs4.default.existsSync(targetDir)) {
       try {
-        import_node_fs2.default.mkdirSync(targetDir, { recursive: true });
+        import_node_fs4.default.mkdirSync(targetDir, { recursive: true });
       } catch (error) {
         logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
         continue;
       }
     }
-    if (import_node_fs2.default.existsSync(target)) {
+    if (import_node_fs4.default.existsSync(target)) {
       try {
-        const stats = import_node_fs2.default.lstatSync(target);
+        const stats = import_node_fs4.default.lstatSync(target);
         if (stats.isSymbolicLink()) {
-          import_node_fs2.default.unlinkSync(target);
+          import_node_fs4.default.unlinkSync(target);
         } else {
           logger.warn(`Target exists but is not a symlink, skipping: ${target}`);
           continue;
@@ -293,7 +498,7 @@ function createSymlink(skillName, agent, cwd) {
       }
     }
     try {
-      import_node_fs2.default.symlinkSync(source, target, "dir");
+      import_node_fs4.default.symlinkSync(source, target, "dir");
       successCount++;
     } catch (error) {
       logger.error(`Failed to create symlink at ${target}: ${error.message}`);
@@ -310,13 +515,13 @@ 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)) {
+    if (!import_node_fs4.default.existsSync(target)) {
       continue;
     }
     try {
-      const stats = import_node_fs2.default.lstatSync(target);
+      const stats = import_node_fs4.default.lstatSync(target);
       if (stats.isSymbolicLink()) {
-        import_node_fs2.default.unlinkSync(target);
+        import_node_fs4.default.unlinkSync(target);
         removedCount++;
       } else {
         logger.warn(`Not a symlink: ${target}`);
@@ -334,7 +539,7 @@ function removeSymlink(skillName, agent, cwd) {
 }
 function isSymlink(filePath) {
   try {
-    const stats = import_node_fs2.default.lstatSync(filePath);
+    const stats = import_node_fs4.default.lstatSync(filePath);
     return stats.isSymbolicLink();
   } catch {
     return false;
@@ -342,164 +547,12 @@ function isSymlink(filePath) {
 }
 function readSymlink(filePath) {
   try {
-    return import_node_fs2.default.readlinkSync(filePath);
+    return import_node_fs4.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) {
@@ -511,10 +564,7 @@ async function execWithTimeout(command, timeout = 12e4, env) {
   });
   try {
     const execOptions = env ? { env } : {};
-    const result = await Promise.race([
-      execAsync2(command, execOptions),
-      timeoutPromise
-    ]);
+    const result = await Promise.race([execAsync2(command, execOptions), timeoutPromise]);
     if (timeoutId) {
       clearTimeout(timeoutId);
     }
@@ -552,7 +602,7 @@ async function install(skillNameOrPath, options = {}) {
         logger.infoWithoutStop(`Path: ${gitInfo.path}`);
       }
       logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      import_node_fs4.default.mkdirSync(tempDir, { recursive: true });
+      import_node_fs5.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 {
@@ -574,7 +624,7 @@ async function install(skillNameOrPath, options = {}) {
       }
       if (gitInfo.path) {
         skillPath = import_node_path5.default.join(cloneDir, gitInfo.path);
-        if (!import_node_fs4.default.existsSync(skillPath)) {
+        if (!import_node_fs5.default.existsSync(skillPath)) {
           logger.error(`Path not found in repository: ${gitInfo.path}`);
           logger.info(`Repository cloned to: ${cloneDir}`);
           process.exit(1);
@@ -583,7 +633,7 @@ async function install(skillNameOrPath, options = {}) {
         skillPath = cloneDir;
       }
       const skillMdPath = import_node_path5.default.join(skillPath, "SKILL.md");
-      if (!import_node_fs4.default.existsSync(skillMdPath)) {
+      if (!import_node_fs5.default.existsSync(skillMdPath)) {
         logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
         logger.info("The directory may not be a valid skill package");
       }
@@ -605,16 +655,16 @@ Tried to clone: ${gitInfo.gitUrl}`);
       }
       process.exit(1);
     }
-  } else if (options.link || import_node_fs4.default.existsSync(skillNameOrPath)) {
+  } else if (options.link || import_node_fs5.default.existsSync(skillNameOrPath)) {
     skillPath = import_node_path5.default.resolve(skillNameOrPath);
-    if (!import_node_fs4.default.existsSync(skillPath)) {
+    if (!import_node_fs5.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)) {
+    if (import_node_fs5.default.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(import_node_fs4.default.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgPath, "utf-8"));
         skillName = extractSkillName(pkg.name);
       } catch {
         skillName = extractSkillName(import_node_path5.default.basename(skillPath));
@@ -631,12 +681,12 @@ Tried to clone: ${gitInfo.gitUrl}`);
       const spinner = logger.start(`Installing ${skillNameOrPath}...`);
       logger.infoWithoutStop(`Registry: ${registry}`);
       logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      import_node_fs4.default.mkdirSync(tempDir, { recursive: true });
+      import_node_fs5.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 homeDir = process.env.HOME || process.env.USERPROFILE || import_node_os3.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 });
+      import_node_fs5.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,
@@ -661,7 +711,9 @@ Tried to clone: ${gitInfo.gitUrl}`);
           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(
+            `  - 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");
@@ -700,7 +752,9 @@ Tried to clone: ${gitInfo.gitUrl}`);
           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/`);
+          logger.info(
+            `  - Try a different registry: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`
+          );
         } else {
           logger.error(`Failed to download: ${errorMessage}`);
           logger.info("");
@@ -713,7 +767,7 @@ Tried to clone: ${gitInfo.gitUrl}`);
         process.exit(1);
       }
       skillPath = import_node_path5.default.join(tempDir, "node_modules", skillNameOrPath);
-      if (!import_node_fs4.default.existsSync(skillPath)) {
+      if (!import_node_fs5.default.existsSync(skillPath)) {
         logger.error(`Failed to download package: ${skillNameOrPath}`);
         process.exit(1);
       }
@@ -723,10 +777,10 @@ Tried to clone: ${gitInfo.gitUrl}`);
     }
   }
   const targetPath = getSharedSkillPath(skillName);
-  if (import_node_fs4.default.existsSync(targetPath)) {
+  if (import_node_fs5.default.existsSync(targetPath)) {
     if (options.force) {
       logger.warn("Removing existing installation...");
-      import_node_fs4.default.rmSync(targetPath, { recursive: true, force: true });
+      import_node_fs5.default.rmSync(targetPath, { recursive: true, force: true });
     } else {
       logger.error(`Skill already exists: ${targetPath}`);
       logger.info("Use --force to overwrite");
@@ -734,7 +788,7 @@ Tried to clone: ${gitInfo.gitUrl}`);
     }
   }
   if (options.link) {
-    import_node_fs4.default.symlinkSync(skillPath, targetPath, "dir");
+    import_node_fs5.default.symlinkSync(skillPath, targetPath, "dir");
     logger.success(`Linked to shared directory (dev mode)`);
   } else {
     copyDir(skillPath, targetPath);
@@ -780,8 +834,8 @@ Linked to ${successCount}/${targetAgents.length} agents`);
   }
 }
 function copyDir(src, dest) {
-  import_node_fs4.default.mkdirSync(dest, { recursive: true });
-  const entries = import_node_fs4.default.readdirSync(src, { withFileTypes: true });
+  import_node_fs5.default.mkdirSync(dest, { recursive: true });
+  const entries = import_node_fs5.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);
@@ -791,44 +845,44 @@ function copyDir(src, dest) {
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      import_node_fs4.default.copyFileSync(srcPath, destPath);
+      import_node_fs5.default.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/commands/list.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 function list() {
-  if (!import_node_fs5.default.existsSync(SHARED_SKILLS_DIR)) {
+  if (!import_node_fs6.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>")}`);
+To install a skill, run: ${import_chalk3.default.cyan("eskill install <skill-name>")}`);
     return;
   }
-  const skills = import_node_fs5.default.readdirSync(SHARED_SKILLS_DIR);
+  const skills = import_node_fs6.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>")}`);
+To install a skill, run: ${import_chalk3.default.cyan("eskill install <skill-name>")}`);
     return;
   }
-  console.log(import_chalk2.default.bold(`
+  console.log(import_chalk3.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);
+      const stats = import_node_fs6.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)) {
+      if (import_node_fs6.default.existsSync(pkgPath)) {
         try {
-          const pkgContent = import_node_fs5.default.readFileSync(pkgPath, "utf-8");
+          const pkgContent = import_node_fs6.default.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgContent);
           if (pkg.version && typeof pkg.version === "string") {
             version2 = pkg.version;
@@ -838,9 +892,9 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       }
       if (version2 === "unknown") {
         const skillMdPath = import_node_path6.default.join(skillPath, "SKILL.md");
-        if (import_node_fs5.default.existsSync(skillMdPath)) {
+        if (import_node_fs6.default.existsSync(skillMdPath)) {
           try {
-            const skillMdContent = import_node_fs5.default.readFileSync(skillMdPath, "utf-8");
+            const skillMdContent = import_node_fs6.default.readFileSync(skillMdPath, "utf-8");
             const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
             if (frontmatterMatch) {
               const frontmatter = frontmatterMatch[1];
@@ -858,8 +912,8 @@ Installed skills in ${SHARED_SKILLS_DIR}:
           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 (import_node_fs6.default.existsSync(targetPkgPath)) {
+              const pkg = JSON.parse(import_node_fs6.default.readFileSync(targetPkgPath, "utf-8"));
               if (pkg.version && typeof pkg.version === "string") {
                 version2 = pkg.version;
               }
@@ -869,16 +923,16 @@ Installed skills in ${SHARED_SKILLS_DIR}:
         }
       }
       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 devTag = isDev ? import_chalk3.default.yellow(" (dev)") : "";
+      const versionDisplay = version2 !== "unknown" ? import_chalk3.default.gray(`(v${version2})`) : "";
+      console.log(import_chalk3.default.green("\u{1F4E6}") + ` ${import_chalk3.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)) {
+          if (import_node_fs6.default.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
             const target = readSymlink(agentSkillPath);
             return target === skillPath;
           }
@@ -889,29 +943,28 @@ Installed skills in ${SHARED_SKILLS_DIR}:
         }
       }
       if (linkedAgents.length > 0) {
-        console.log(import_chalk2.default.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
+        console.log(import_chalk3.default.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
       } else {
-        console.log(import_chalk2.default.yellow(`   \u2192 Not linked to any agent`));
+        console.log(import_chalk3.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(import_chalk3.default.gray(`   \u2192 Source: ${target}`));
         }
       }
       console.log("");
     } catch (error) {
-      continue;
     }
   }
 }
 
 // src/commands/remove.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs7 = __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);
+  const skillExists = import_node_fs7.default.existsSync(sharedPath);
   if (!skillExists) {
     logger.error(`Skill not found: ${extractedName}`);
     logger.info(`Location: ${sharedPath}`);
@@ -947,12 +1000,12 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
   logger.info("Removing skill from shared directory...");
   try {
-    const stats = import_node_fs6.default.lstatSync(sharedPath);
+    const stats = import_node_fs7.default.lstatSync(sharedPath);
     if (stats.isSymbolicLink()) {
-      import_node_fs6.default.unlinkSync(sharedPath);
+      import_node_fs7.default.unlinkSync(sharedPath);
       logger.success("Removed symlink from shared directory");
     } else {
-      import_node_fs6.default.rmSync(sharedPath, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(sharedPath, { recursive: true, force: true });
       logger.success("Removed skill from shared directory");
     }
   } catch (error) {
@@ -963,7 +1016,7 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   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);
+      return import_node_fs7.default.existsSync(path7) && isSymlink(path7);
     });
     if (hasSymlink) {
       remainingSymlinks.push(agent.displayName);
@@ -981,44 +1034,6 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
 }
 
-// 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);
@@ -1027,7 +1042,11 @@ 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) => {
+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) => Number.parseInt(value, 10)
+).action(async (skill, options) => {
   try {
     await install(skill, options);
   } catch (error) {