@empjs/skill 1.0.5 → 1.0.7

package/dist/index.js

@@ -3,80 +3,20 @@
 // src/index.ts
 import { Command } from "commander";
 import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 
-// src/commands/install.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import fs4 from "fs";
-import path5 from "path";
+// src/commands/agents.ts
+import fs2 from "fs";
 import os2 from "os";
-
-// src/utils/logger.ts
 import chalk from "chalk";
-import ora from "ora";
-var Logger = class {
-  spinner = null;
-  info(message) {
-    if (this.spinner) this.spinner.stop();
-    console.log(chalk.blue("\u2139"), message);
-  }
-  success(message) {
-    if (this.spinner) this.spinner.stop();
-    console.log(chalk.green("\u2713"), message);
-  }
-  warn(message) {
-    if (this.spinner) this.spinner.stop();
-    console.log(chalk.yellow("\u26A0"), message);
-  }
-  error(message) {
-    if (this.spinner) this.spinner.stop();
-    console.log(chalk.red("\u2717"), message);
-  }
-  start(message) {
-    if (this.spinner) this.spinner.stop();
-    this.spinner = ora(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(chalk.blue("\u2139"), message);
-      this.spinner.start(currentText);
-    } else {
-      console.log(chalk.blue("\u2139"), message);
-    }
-  }
-};
-var logger = new Logger();
-
-// src/utils/paths.ts
-import fs from "fs";
-import path2 from "path";
 
 // src/config/agents.ts
+import fs from "fs";
 import os from "os";
 import path from "path";
 var HOME = os.homedir();
+var CONFIG_HOME = process.env.XDG_CONFIG_HOME || path.join(HOME, ".config");
 function getAgentSkillsDirs(agent, cwd) {
   if (agent.skillsDirs) {
     if (typeof agent.skillsDirs === "function") {
@@ -91,21 +31,44 @@ function getAgentSkillsDirs(agent, cwd) {
 }
 var AGENTS = [
   {
-    name: "claude",
-    displayName: "Claude Code",
-    skillsDir: path.join(HOME, ".claude", "skills"),
+    name: "amp",
+    displayName: "AMP",
+    skillsDirs: (cwd) => {
+      const dirs = [path.join(CONFIG_HOME, "agents", "skills")];
+      if (cwd) dirs.push(path.join(cwd, ".agents", "skills"));
+      return dirs;
+    },
     enabled: true
   },
   {
-    name: "cursor",
-    displayName: "Cursor",
-    skillsDir: path.join(HOME, ".cursor", "skills"),
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDirs: (cwd) => {
+      const dirs = [path.join(HOME, ".gemini", "antigravity", "skills")];
+      if (cwd) dirs.push(path.join(cwd, ".agent", "skills"));
+      if (cwd) dirs.push(path.join(cwd, ".shared", "skills"));
+      return dirs;
+    },
     enabled: true
   },
   {
-    name: "windsurf",
-    displayName: "Windsurf",
-    skillsDir: path.join(HOME, ".windsurf", "skills"),
+    name: "claude",
+    displayName: "Claude Code",
+    skillsDir: path.join(process.env.CLAUDE_CONFIG_DIR?.trim() || path.join(HOME, ".claude"), "skills"),
+    enabled: true
+  },
+  {
+    name: "clawdbot",
+    displayName: "ClawdBot",
+    skillsDirs: () => {
+      const openclaw = path.join(HOME, ".openclaw", "skills");
+      const clawdbot = path.join(HOME, ".clawdbot", "skills");
+      const moltbot = path.join(HOME, ".moltbot", "skills");
+      if (fs.existsSync(path.join(HOME, ".openclaw"))) return [openclaw];
+      if (fs.existsSync(path.join(HOME, ".clawdbot"))) return [clawdbot];
+      if (fs.existsSync(path.join(HOME, ".moltbot"))) return [moltbot];
+      return [openclaw];
+    },
     enabled: true
   },
   {
@@ -114,9 +77,27 @@ var AGENTS = [
     skillsDir: path.join(HOME, ".cline", "skills"),
     enabled: true
   },
+  {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: path.join(process.env.CODEX_HOME?.trim() || path.join(HOME, ".codex"), "skills"),
+    enabled: true
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: path.join(HOME, ".cursor", "skills"),
+    enabled: true
+  },
+  {
+    name: "droid",
+    displayName: "Droid",
+    skillsDir: path.join(HOME, ".factory", "skills"),
+    enabled: true
+  },
   {
     name: "gemini",
-    displayName: "Gemini Code",
+    displayName: "Gemini",
     skillsDir: path.join(HOME, ".gemini", "skills"),
     enabled: true
   },
@@ -127,47 +108,31 @@ var AGENTS = [
     enabled: true
   },
   {
-    name: "opencode",
-    displayName: "OpenCode",
-    skillsDir: path.join(HOME, ".opencode", "skills"),
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: path.join(CONFIG_HOME, "goose", "skills"),
     enabled: true
   },
   {
-    name: "antigravity",
-    displayName: "Antigravity",
-    skillsDirs: (cwd) => {
-      const dirs = [];
-      dirs.push(path.join(HOME, ".gemini", "antigravity", "skills"));
-      if (cwd) {
-        dirs.push(path.join(cwd, ".agent", "skills"));
-      }
-      if (cwd) {
-        dirs.push(path.join(cwd, ".shared", "skills"));
-      }
-      return dirs;
-    },
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: path.join(HOME, ".kilocode", "skills"),
     enabled: true
   },
   {
     name: "kiro",
-    displayName: "Kiro",
+    displayName: "Kiro CLI",
     skillsDir: path.join(HOME, ".kiro", "skills"),
     enabled: true
   },
   {
-    name: "codex",
-    displayName: "Codex CLI",
-    skillsDir: path.join(HOME, ".codex", "skills"),
-    enabled: true
-  },
-  {
-    name: "qoder",
-    displayName: "Qoder",
-    skillsDir: path.join(HOME, ".qoder", "skills"),
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: path.join(CONFIG_HOME, "opencode", "skills"),
     enabled: true
   },
   {
-    name: "roocode",
+    name: "roo",
     displayName: "Roo Code",
     skillsDir: path.join(HOME, ".roo", "skills"),
     enabled: true
@@ -178,18 +143,246 @@ var AGENTS = [
     skillsDir: path.join(HOME, ".trae", "skills"),
     enabled: true
   },
+  {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDirs: () => {
+      const dirs = [];
+      dirs.push(path.join(HOME, ".windsurf", "skills"));
+      dirs.push(path.join(HOME, ".codeium", "windsurf", "skills"));
+      return dirs;
+    },
+    enabled: true
+  },
+  // Additional agents
+  {
+    name: "qoder",
+    displayName: "Qoder",
+    skillsDir: path.join(HOME, ".qoder", "skills"),
+    enabled: true
+  },
   {
     name: "continue",
     displayName: "Continue",
     skillsDir: path.join(HOME, ".continue", "skills"),
     enabled: true
   }
-];
-var SHARED_SKILLS_DIR = path.join(HOME, ".emp-agent", "skills");
-var CONFIG_FILE = path.join(HOME, ".emp-agent", "config.json");
-var CACHE_DIR = path.join(HOME, ".emp-agent", "cache");
+];
+var SHARED_SKILLS_DIR = path.join(HOME, ".emp-agent", "skills");
+var CONFIG_FILE = path.join(HOME, ".emp-agent", "config.json");
+var CACHE_DIR = path.join(HOME, ".emp-agent", "cache");
+
+// src/commands/agents.ts
+function agents() {
+  const cwd = process.cwd();
+  console.log(chalk.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(chalk.bold(agent.displayName));
+    console.log(chalk.gray(`  Name: ${agent.name}`));
+    if (skillsDirs.length === 0) {
+      console.log(chalk.yellow("  \u26A0\uFE0F  No directories configured"));
+    } else {
+      console.log(chalk.gray(`  Directories${dirsInfo}:`));
+      for (const dir of skillsDirs) {
+        const exists = fs2.existsSync(dir);
+        const status = exists ? chalk.green("\u2713") : chalk.gray("\u25CB");
+        const pathColor = exists ? chalk.white : chalk.gray;
+        console.log(`    ${status} ${pathColor(dir)}`);
+      }
+    }
+    console.log("");
+  }
+  console.log(chalk.bold("\u{1F4E6} Shared Skills Directory:"));
+  const sharedExists = fs2.existsSync(SHARED_SKILLS_DIR);
+  const sharedStatus = sharedExists ? chalk.green("\u2713") : chalk.gray("\u25CB");
+  const sharedPathColor = sharedExists ? chalk.white : chalk.gray;
+  console.log(`  ${sharedStatus} ${sharedPathColor(SHARED_SKILLS_DIR)}`);
+  console.log("");
+  const home = os2.homedir();
+  if (cwd !== home) {
+    console.log(chalk.gray(`Current working directory: ${cwd}`));
+    console.log(chalk.gray("(Project-level directories are shown above)\n"));
+  }
+}
+
+// src/commands/install.ts
+import { exec as exec2 } from "child_process";
+import fs6 from "fs";
+import os3 from "os";
+import path5 from "path";
+import { promisify as promisify2 } from "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
+import chalk2 from "chalk";
+import ora from "ora";
+var Logger = class {
+  spinner = null;
+  info(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.blue("\u2139"), message);
+  }
+  success(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.green("\u2713"), message);
+  }
+  warn(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.yellow("\u26A0"), message);
+  }
+  error(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.red("\u2717"), message);
+  }
+  dim(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.dim("  " + message));
+  }
+  start(message) {
+    if (this.spinner) this.spinner.stop();
+    this.spinner = ora(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(chalk2.blue("\u2139"), message);
+      this.spinner.start(currentText);
+    } else {
+      console.log(chalk2.blue("\u2139"), message);
+    }
+  }
+};
+var logger = new Logger();
 
 // src/utils/paths.ts
+import fs3 from "fs";
+import path2 from "path";
 function getSharedSkillPath(skillName) {
   return path2.join(SHARED_SKILLS_DIR, skillName);
 }
@@ -202,8 +395,8 @@ function getAgentSkillPaths(agentName, skillName, cwd) {
   return skillsDirs.map((dir) => path2.join(dir, skillName));
 }
 function ensureSharedDir() {
-  if (!fs.existsSync(SHARED_SKILLS_DIR)) {
-    fs.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
+  if (!fs3.existsSync(SHARED_SKILLS_DIR)) {
+    fs3.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
   }
 }
 function detectInstalledAgents(cwd) {
@@ -211,7 +404,7 @@ function detectInstalledAgents(cwd) {
     try {
       const skillsDirs = getAgentSkillsDirs(agent, cwd);
       return skillsDirs.some((dir) => {
-        return fs.existsSync(dir) || fs.existsSync(path2.dirname(dir));
+        return fs3.existsSync(dir) || fs3.existsSync(path2.dirname(dir));
       });
     } catch {
       return false;
@@ -230,32 +423,93 @@ function extractSkillName(nameOrPath) {
   return path2.basename(nameOrPath);
 }
 
-// src/utils/symlink.ts
-import fs2 from "fs";
+// src/utils/registry.ts
+import { exec } from "child_process";
+import fs4 from "fs";
 import path3 from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function findNpmrc(startDir) {
+  let currentDir = path3.resolve(startDir);
+  while (currentDir !== path3.dirname(currentDir)) {
+    const npmrcPath = path3.join(currentDir, ".npmrc");
+    if (fs4.existsSync(npmrcPath)) {
+      return npmrcPath;
+    }
+    currentDir = path3.dirname(currentDir);
+  }
+  return null;
+}
+function parseNpmrc(npmrcPath) {
+  try {
+    const content = fs4.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
+import fs5 from "fs";
+import path4 from "path";
 function createSymlink(skillName, agent, cwd) {
   const source = getSharedSkillPath(skillName);
-  if (!fs2.existsSync(source)) {
+  if (!fs5.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 = path3.dirname(target);
-    if (!fs2.existsSync(targetDir)) {
+    const targetDir = path4.dirname(target);
+    if (!fs5.existsSync(targetDir)) {
       try {
-        fs2.mkdirSync(targetDir, { recursive: true });
+        fs5.mkdirSync(targetDir, { recursive: true });
       } catch (error) {
         logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
         continue;
       }
     }
-    if (fs2.existsSync(target)) {
+    if (fs5.existsSync(target)) {
       try {
-        const stats = fs2.lstatSync(target);
+        const stats = fs5.lstatSync(target);
         if (stats.isSymbolicLink()) {
-          fs2.unlinkSync(target);
+          fs5.unlinkSync(target);
         } else {
           logger.warn(`Target exists but is not a symlink, skipping: ${target}`);
           continue;
@@ -266,7 +520,7 @@ function createSymlink(skillName, agent, cwd) {
       }
     }
     try {
-      fs2.symlinkSync(source, target, "dir");
+      fs5.symlinkSync(source, target, "dir");
       successCount++;
     } catch (error) {
       logger.error(`Failed to create symlink at ${target}: ${error.message}`);
@@ -283,13 +537,13 @@ function removeSymlink(skillName, agent, cwd) {
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
   let removedCount = 0;
   for (const target of targets) {
-    if (!fs2.existsSync(target)) {
+    if (!fs5.existsSync(target)) {
       continue;
     }
     try {
-      const stats = fs2.lstatSync(target);
+      const stats = fs5.lstatSync(target);
       if (stats.isSymbolicLink()) {
-        fs2.unlinkSync(target);
+        fs5.unlinkSync(target);
         removedCount++;
       } else {
         logger.warn(`Not a symlink: ${target}`);
@@ -307,7 +561,7 @@ function removeSymlink(skillName, agent, cwd) {
 }
 function isSymlink(filePath) {
   try {
-    const stats = fs2.lstatSync(filePath);
+    const stats = fs5.lstatSync(filePath);
     return stats.isSymbolicLink();
   } catch {
     return false;
@@ -315,164 +569,12 @@ function isSymlink(filePath) {
 }
 function readSymlink(filePath) {
   try {
-    return fs2.readlinkSync(filePath);
+    return fs5.readlinkSync(filePath);
   } catch {
     return null;
   }
 }
 
-// src/utils/registry.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import fs3 from "fs";
-import path4 from "path";
-var execAsync = promisify(exec);
-function findNpmrc(startDir) {
-  let currentDir = path4.resolve(startDir);
-  while (currentDir !== path4.dirname(currentDir)) {
-    const npmrcPath = path4.join(currentDir, ".npmrc");
-    if (fs3.existsSync(npmrcPath)) {
-      return npmrcPath;
-    }
-    currentDir = path4.dirname(currentDir);
-  }
-  return null;
-}
-function parseNpmrc(npmrcPath) {
-  try {
-    const content = fs3.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 = promisify2(exec2);
 async function execWithTimeout(command, timeout = 12e4, env) {
@@ -484,10 +586,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);
     }
@@ -499,12 +598,25 @@ async function execWithTimeout(command, timeout = 12e4, env) {
     throw error;
   }
 }
+function shortenPath(p) {
+  const home = os3.homedir();
+  return p.startsWith(home) ? p.replace(home, "~") : p;
+}
 async function install(skillNameOrPath, options = {}) {
-  logger.info(`Installing skill: ${skillNameOrPath}`);
+  const isGit = isGitUrl(skillNameOrPath);
+  if (isGit) {
+    logger.info("Installing from Git URL");
+    logger.dim(skillNameOrPath);
+  } else {
+    logger.info(`Installing skill: ${skillNameOrPath}`);
+  }
   ensureSharedDir();
   let skillPath;
   let skillName;
-  if (isGitUrl(skillNameOrPath)) {
+  if (process.env.DEBUG_ESKILL) {
+    logger.dim(`[DEBUG] isGitUrl=${isGit}, parseGitUrl=${parseGitUrl(skillNameOrPath) ? "ok" : "null"}`);
+  }
+  if (isGit) {
     const gitInfo = parseGitUrl(skillNameOrPath);
     if (!gitInfo) {
       logger.error(`Invalid git URL: ${skillNameOrPath}`);
@@ -516,21 +628,17 @@ async function install(skillNameOrPath, options = {}) {
     const cloneDir = path5.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`);
-      fs4.mkdirSync(tempDir, { recursive: true });
+      const gitDetails = [`${gitInfo.gitUrl}`];
+      if (gitInfo.branch) gitDetails.push(`branch: ${gitInfo.branch}`);
+      if (gitInfo.path) gitDetails.push(`path: ${gitInfo.path}`);
+      logger.dim(gitDetails.join(" \xB7 "));
+      const spinner = logger.start(`Cloning...`);
+      fs6.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`);
+        spinner.succeed(`Cloned successfully`);
       } catch (error) {
         spinner.fail("Clone failed");
         if (error.message.includes("timeout")) {
@@ -547,7 +655,7 @@ async function install(skillNameOrPath, options = {}) {
       }
       if (gitInfo.path) {
         skillPath = path5.join(cloneDir, gitInfo.path);
-        if (!fs4.existsSync(skillPath)) {
+        if (!fs6.existsSync(skillPath)) {
           logger.error(`Path not found in repository: ${gitInfo.path}`);
           logger.info(`Repository cloned to: ${cloneDir}`);
           process.exit(1);
@@ -556,7 +664,7 @@ async function install(skillNameOrPath, options = {}) {
         skillPath = cloneDir;
       }
       const skillMdPath = path5.join(skillPath, "SKILL.md");
-      if (!fs4.existsSync(skillMdPath)) {
+      if (!fs6.existsSync(skillMdPath)) {
         logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
         logger.info("The directory may not be a valid skill package");
       }
@@ -578,16 +686,16 @@ Tried to clone: ${gitInfo.gitUrl}`);
       }
       process.exit(1);
     }
-  } else if (options.link || fs4.existsSync(skillNameOrPath)) {
+  } else if (options.link || fs6.existsSync(skillNameOrPath)) {
     skillPath = path5.resolve(skillNameOrPath);
-    if (!fs4.existsSync(skillPath)) {
+    if (!fs6.existsSync(skillPath)) {
       logger.error(`Path not found: ${skillPath}`);
       process.exit(1);
     }
     const pkgPath = path5.join(skillPath, "package.json");
-    if (fs4.existsSync(pkgPath)) {
+    if (fs6.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         skillName = extractSkillName(pkg.name);
       } catch {
         skillName = extractSkillName(path5.basename(skillPath));
@@ -604,12 +712,12 @@ Tried to clone: ${gitInfo.gitUrl}`);
       const spinner = logger.start(`Installing ${skillNameOrPath}...`);
       logger.infoWithoutStop(`Registry: ${registry}`);
       logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      fs4.mkdirSync(tempDir, { recursive: true });
+      fs6.mkdirSync(tempDir, { recursive: true });
       logger.updateSpinner(`Downloading ${skillNameOrPath} from ${registry}...`);
-      const homeDir = process.env.HOME || process.env.USERPROFILE || os2.homedir();
+      const homeDir = process.env.HOME || process.env.USERPROFILE || os3.homedir();
       const npmCacheDir = path5.join(homeDir, ".npm");
       const npmConfigPrefix = path5.join(homeDir, ".npm-global");
-      fs4.mkdirSync(npmCacheDir, { recursive: true });
+      fs6.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,
@@ -634,7 +742,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");
@@ -673,7 +783,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("");
@@ -686,7 +798,7 @@ Tried to clone: ${gitInfo.gitUrl}`);
         process.exit(1);
       }
       skillPath = path5.join(tempDir, "node_modules", skillNameOrPath);
-      if (!fs4.existsSync(skillPath)) {
+      if (!fs6.existsSync(skillPath)) {
         logger.error(`Failed to download package: ${skillNameOrPath}`);
         process.exit(1);
       }
@@ -696,18 +808,19 @@ Tried to clone: ${gitInfo.gitUrl}`);
     }
   }
   const targetPath = getSharedSkillPath(skillName);
-  if (fs4.existsSync(targetPath)) {
+  if (fs6.existsSync(targetPath)) {
     if (options.force) {
       logger.warn("Removing existing installation...");
-      fs4.rmSync(targetPath, { recursive: true, force: true });
+      fs6.rmSync(targetPath, { recursive: true, force: true });
     } else {
-      logger.error(`Skill already exists: ${targetPath}`);
-      logger.info("Use --force to overwrite");
+      logger.error(`Skill already exists`);
+      logger.dim(`Location: ${shortenPath(targetPath)}`);
+      logger.dim(`Tip: Add --force to overwrite`);
       process.exit(1);
     }
   }
   if (options.link) {
-    fs4.symlinkSync(skillPath, targetPath, "dir");
+    fs6.symlinkSync(skillPath, targetPath, "dir");
     logger.success(`Linked to shared directory (dev mode)`);
   } else {
     copyDir(skillPath, targetPath);
@@ -721,21 +834,25 @@ Tried to clone: ${gitInfo.gitUrl}`);
     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)");
+    logger.info("  AMP, Antigravity, Claude Code, ClawdBot, Cline, Codex, Cursor, Droid,");
+    logger.info("  Gemini, GitHub Copilot, Goose, Kilo, Kiro CLI, OpenCode, Roo, Trae, Windsurf");
+    logger.info("");
+    logger.info('Run "eskill agents" to see all agent directories');
     return;
   }
   let targetAgents = installedAgents;
   if (options.agent && options.agent !== "all") {
-    const agent = installedAgents.find((a) => a.name === options.agent);
+    const agent = AGENTS.find((a) => a.name === options.agent && a.enabled);
     if (!agent) {
-      logger.error(`Agent not installed: ${options.agent}`);
+      logger.error(`Unknown agent: ${options.agent}`);
       logger.info(`
-Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", ")}`);
       process.exit(1);
     }
     targetAgents = [agent];
+    if (!installedAgents.find((a) => a.name === options.agent)) {
+      logger.info(`Note: ${agent.displayName} directory will be created if not exists`);
+    }
   }
   logger.info("\nCreating symlinks...");
   let successCount = 0;
@@ -753,8 +870,8 @@ Linked to ${successCount}/${targetAgents.length} agents`);
   }
 }
 function copyDir(src, dest) {
-  fs4.mkdirSync(dest, { recursive: true });
-  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path5.join(src, entry.name);
     const destPath = path5.join(dest, entry.name);
@@ -764,44 +881,44 @@ function copyDir(src, dest) {
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs4.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/commands/list.ts
-import fs5 from "fs";
+import fs7 from "fs";
 import path6 from "path";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 function list() {
-  if (!fs5.existsSync(SHARED_SKILLS_DIR)) {
+  if (!fs7.existsSync(SHARED_SKILLS_DIR)) {
     logger.info("No skills installed");
     logger.info(`
-To install a skill, run: ${chalk2.cyan("eskill install <skill-name>")}`);
+To install a skill, run: ${chalk3.cyan("eskill install <skill-name>")}`);
     return;
   }
-  const skills = fs5.readdirSync(SHARED_SKILLS_DIR);
+  const skills = fs7.readdirSync(SHARED_SKILLS_DIR);
   if (skills.length === 0) {
     logger.info("No skills installed");
     logger.info(`
-To install a skill, run: ${chalk2.cyan("eskill install <skill-name>")}`);
+To install a skill, run: ${chalk3.cyan("eskill install <skill-name>")}`);
     return;
   }
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 Installed skills in ${SHARED_SKILLS_DIR}:
 `));
   for (const skill of skills) {
     const skillPath = path6.join(SHARED_SKILLS_DIR, skill);
     try {
-      const stats = fs5.lstatSync(skillPath);
+      const stats = fs7.lstatSync(skillPath);
       if (!stats.isDirectory() && !stats.isSymbolicLink()) {
         continue;
       }
       let version2 = "unknown";
       const pkgPath = path6.join(skillPath, "package.json");
-      if (fs5.existsSync(pkgPath)) {
+      if (fs7.existsSync(pkgPath)) {
         try {
-          const pkgContent = fs5.readFileSync(pkgPath, "utf-8");
+          const pkgContent = fs7.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgContent);
           if (pkg.version && typeof pkg.version === "string") {
             version2 = pkg.version;
@@ -811,9 +928,9 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       }
       if (version2 === "unknown") {
         const skillMdPath = path6.join(skillPath, "SKILL.md");
-        if (fs5.existsSync(skillMdPath)) {
+        if (fs7.existsSync(skillMdPath)) {
           try {
-            const skillMdContent = fs5.readFileSync(skillMdPath, "utf-8");
+            const skillMdContent = fs7.readFileSync(skillMdPath, "utf-8");
             const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
             if (frontmatterMatch) {
               const frontmatter = frontmatterMatch[1];
@@ -831,8 +948,8 @@ Installed skills in ${SHARED_SKILLS_DIR}:
           const targetPath = readSymlink(skillPath);
           if (targetPath) {
             const targetPkgPath = path6.join(targetPath, "package.json");
-            if (fs5.existsSync(targetPkgPath)) {
-              const pkg = JSON.parse(fs5.readFileSync(targetPkgPath, "utf-8"));
+            if (fs7.existsSync(targetPkgPath)) {
+              const pkg = JSON.parse(fs7.readFileSync(targetPkgPath, "utf-8"));
               if (pkg.version && typeof pkg.version === "string") {
                 version2 = pkg.version;
               }
@@ -842,16 +959,16 @@ Installed skills in ${SHARED_SKILLS_DIR}:
         }
       }
       const isDev = isSymlink(skillPath);
-      const devTag = isDev ? chalk2.yellow(" (dev)") : "";
-      const versionDisplay = version2 !== "unknown" ? chalk2.gray(`(v${version2})`) : "";
-      console.log(chalk2.green("\u{1F4E6}") + ` ${chalk2.bold(skill)}${versionDisplay ? " " + versionDisplay : ""}${devTag}`);
+      const devTag = isDev ? chalk3.yellow(" (dev)") : "";
+      const versionDisplay = version2 !== "unknown" ? chalk3.gray(`(v${version2})`) : "";
+      console.log(chalk3.green("\u{1F4E6}") + ` ${chalk3.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 = path6.join(dir, skill);
-          if (fs5.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
+          if (fs7.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
             const target = readSymlink(agentSkillPath);
             return target === skillPath;
           }
@@ -862,29 +979,28 @@ Installed skills in ${SHARED_SKILLS_DIR}:
         }
       }
       if (linkedAgents.length > 0) {
-        console.log(chalk2.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
+        console.log(chalk3.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
       } else {
-        console.log(chalk2.yellow(`   \u2192 Not linked to any agent`));
+        console.log(chalk3.yellow(`   \u2192 Not linked to any agent`));
       }
       if (isDev) {
         const target = readSymlink(skillPath);
         if (target) {
-          console.log(chalk2.gray(`   \u2192 Source: ${target}`));
+          console.log(chalk3.gray(`   \u2192 Source: ${target}`));
         }
       }
       console.log("");
     } catch (error) {
-      continue;
     }
   }
 }
 
 // src/commands/remove.ts
-import fs6 from "fs";
+import fs8 from "fs";
 async function remove(skillName, options = {}) {
   const extractedName = extractSkillName(skillName);
   const sharedPath = getSharedSkillPath(extractedName);
-  const skillExists = fs6.existsSync(sharedPath);
+  const skillExists = fs8.existsSync(sharedPath);
   if (!skillExists) {
     logger.error(`Skill not found: ${extractedName}`);
     logger.info(`Location: ${sharedPath}`);
@@ -894,11 +1010,11 @@ async function remove(skillName, options = {}) {
   const installedAgents = detectInstalledAgents(cwd);
   let targetAgents = installedAgents;
   if (options.agent && options.agent !== "all") {
-    const agent = installedAgents.find((a) => a.name === options.agent);
+    const agent = AGENTS.find((a) => a.name === options.agent && a.enabled);
     if (!agent) {
-      logger.error(`Agent not installed: ${options.agent}`);
+      logger.error(`Unknown agent: ${options.agent}`);
       logger.info(`
-Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", ")}`);
       process.exit(1);
     }
     targetAgents = [agent];
@@ -920,12 +1036,12 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
   logger.info("Removing skill from shared directory...");
   try {
-    const stats = fs6.lstatSync(sharedPath);
+    const stats = fs8.lstatSync(sharedPath);
     if (stats.isSymbolicLink()) {
-      fs6.unlinkSync(sharedPath);
+      fs8.unlinkSync(sharedPath);
       logger.success("Removed symlink from shared directory");
     } else {
-      fs6.rmSync(sharedPath, { recursive: true, force: true });
+      fs8.rmSync(sharedPath, { recursive: true, force: true });
       logger.success("Removed skill from shared directory");
     }
   } catch (error) {
@@ -936,7 +1052,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 fs6.existsSync(path7) && isSymlink(path7);
+      return fs8.existsSync(path7) && isSymlink(path7);
     });
     if (hasSymlink) {
       remainingSymlinks.push(agent.displayName);
@@ -954,44 +1070,6 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
 }
 
-// src/commands/agents.ts
-import chalk3 from "chalk";
-import fs7 from "fs";
-import os3 from "os";
-function agents() {
-  const cwd = process.cwd();
-  console.log(chalk3.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(chalk3.bold(agent.displayName));
-    console.log(chalk3.gray(`  Name: ${agent.name}`));
-    if (skillsDirs.length === 0) {
-      console.log(chalk3.yellow("  \u26A0\uFE0F  No directories configured"));
-    } else {
-      console.log(chalk3.gray(`  Directories${dirsInfo}:`));
-      for (const dir of skillsDirs) {
-        const exists = fs7.existsSync(dir);
-        const status = exists ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
-        const pathColor = exists ? chalk3.white : chalk3.gray;
-        console.log(`    ${status} ${pathColor(dir)}`);
-      }
-    }
-    console.log("");
-  }
-  console.log(chalk3.bold("\u{1F4E6} Shared Skills Directory:"));
-  const sharedExists = fs7.existsSync(SHARED_SKILLS_DIR);
-  const sharedStatus = sharedExists ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
-  const sharedPathColor = sharedExists ? chalk3.white : chalk3.gray;
-  console.log(`  ${sharedStatus} ${sharedPathColor(SHARED_SKILLS_DIR)}`);
-  console.log("");
-  const home = os3.homedir();
-  if (cwd !== home) {
-    console.log(chalk3.gray(`Current working directory: ${cwd}`));
-    console.log(chalk3.gray("(Project-level directories are shown above)\n"));
-  }
-}
-
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
@@ -1000,7 +1078,11 @@ var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 var version = packageJson.version;
 var program = new 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) {