@empjs/skill 1.0.6 → 1.0.8

package/dist/index.cjs

@@ -34,14 +34,16 @@ var import_path = require("path");
 var import_url = require("url");
 
 // src/commands/agents.ts
-var import_node_fs = __toESM(require("fs"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 
 // src/config/agents.ts
+var import_node_fs = __toESM(require("fs"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var HOME = import_node_os.default.homedir();
+var CONFIG_HOME = process.env.XDG_CONFIG_HOME || import_node_path.default.join(HOME, ".config");
 function getAgentSkillsDirs(agent, cwd) {
   if (agent.skillsDirs) {
     if (typeof agent.skillsDirs === "function") {
@@ -56,21 +58,44 @@ function getAgentSkillsDirs(agent, cwd) {
 }
 var AGENTS = [
   {
-    name: "claude",
-    displayName: "Claude Code",
-    skillsDir: import_node_path.default.join(HOME, ".claude", "skills"),
+    name: "amp",
+    displayName: "AMP",
+    skillsDirs: (cwd) => {
+      const dirs = [import_node_path.default.join(CONFIG_HOME, "agents", "skills")];
+      if (cwd) dirs.push(import_node_path.default.join(cwd, ".agents", "skills"));
+      return dirs;
+    },
     enabled: true
   },
   {
-    name: "cursor",
-    displayName: "Cursor",
-    skillsDir: import_node_path.default.join(HOME, ".cursor", "skills"),
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDirs: (cwd) => {
+      const dirs = [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: "windsurf",
-    displayName: "Windsurf",
-    skillsDir: import_node_path.default.join(HOME, ".windsurf", "skills"),
+    name: "claude",
+    displayName: "Claude Code",
+    skillsDir: import_node_path.default.join(process.env.CLAUDE_CONFIG_DIR?.trim() || import_node_path.default.join(HOME, ".claude"), "skills"),
+    enabled: true
+  },
+  {
+    name: "clawdbot",
+    displayName: "ClawdBot",
+    skillsDirs: () => {
+      const openclaw = import_node_path.default.join(HOME, ".openclaw", "skills");
+      const clawdbot = import_node_path.default.join(HOME, ".clawdbot", "skills");
+      const moltbot = import_node_path.default.join(HOME, ".moltbot", "skills");
+      if (import_node_fs.default.existsSync(import_node_path.default.join(HOME, ".openclaw"))) return [openclaw];
+      if (import_node_fs.default.existsSync(import_node_path.default.join(HOME, ".clawdbot"))) return [clawdbot];
+      if (import_node_fs.default.existsSync(import_node_path.default.join(HOME, ".moltbot"))) return [moltbot];
+      return [openclaw];
+    },
     enabled: true
   },
   {
@@ -79,9 +104,29 @@ var AGENTS = [
     skillsDir: import_node_path.default.join(HOME, ".cline", "skills"),
     enabled: true
   },
+  {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: import_node_path.default.join(process.env.CODEX_HOME?.trim() || import_node_path.default.join(HOME, ".codex"), "skills"),
+    enabled: true
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: import_node_path.default.join(HOME, ".cursor", "skills"),
+    enabled: true,
+    /** Cursor does not follow symlinks to discover skills (known bug). Use copy instead. */
+    useCopyInsteadOfSymlink: true
+  },
+  {
+    name: "droid",
+    displayName: "Droid",
+    skillsDir: import_node_path.default.join(HOME, ".factory", "skills"),
+    enabled: true
+  },
   {
     name: "gemini",
-    displayName: "Gemini Code",
+    displayName: "Gemini",
     skillsDir: import_node_path.default.join(HOME, ".gemini", "skills"),
     enabled: true
   },
@@ -92,47 +137,31 @@ var AGENTS = [
     enabled: true
   },
   {
-    name: "opencode",
-    displayName: "OpenCode",
-    skillsDir: import_node_path.default.join(HOME, ".opencode", "skills"),
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: import_node_path.default.join(CONFIG_HOME, "goose", "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;
-    },
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: import_node_path.default.join(HOME, ".kilocode", "skills"),
     enabled: true
   },
   {
     name: "kiro",
-    displayName: "Kiro",
+    displayName: "Kiro CLI",
     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"),
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: import_node_path.default.join(CONFIG_HOME, "opencode", "skills"),
     enabled: true
   },
   {
-    name: "roocode",
+    name: "roo",
     displayName: "Roo Code",
     skillsDir: import_node_path.default.join(HOME, ".roo", "skills"),
     enabled: true
@@ -143,6 +172,24 @@ var AGENTS = [
     skillsDir: import_node_path.default.join(HOME, ".trae", "skills"),
     enabled: true
   },
+  {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDirs: () => {
+      const dirs = [];
+      dirs.push(import_node_path.default.join(HOME, ".windsurf", "skills"));
+      dirs.push(import_node_path.default.join(HOME, ".codeium", "windsurf", "skills"));
+      return dirs;
+    },
+    enabled: true
+  },
+  // Additional agents
+  {
+    name: "qoder",
+    displayName: "Qoder",
+    skillsDir: import_node_path.default.join(HOME, ".qoder", "skills"),
+    enabled: true
+  },
   {
     name: "continue",
     displayName: "Continue",
@@ -168,7 +215,7 @@ function agents() {
     } else {
       console.log(import_chalk.default.gray(`  Directories${dirsInfo}:`));
       for (const dir of skillsDirs) {
-        const exists = import_node_fs.default.existsSync(dir);
+        const exists = import_node_fs2.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)}`);
@@ -177,7 +224,7 @@ function agents() {
     console.log("");
   }
   console.log(import_chalk.default.bold("\u{1F4E6} Shared Skills Directory:"));
-  const sharedExists = import_node_fs.default.existsSync(SHARED_SKILLS_DIR);
+  const sharedExists = import_node_fs2.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)}`);
@@ -191,7 +238,7 @@ function agents() {
 
 // src/commands/install.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_fs6 = __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");
@@ -323,6 +370,10 @@ var Logger = class {
     if (this.spinner) this.spinner.stop();
     console.log(import_chalk2.default.red("\u2717"), message);
   }
+  dim(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(import_chalk2.default.dim("  " + message));
+  }
   start(message) {
     if (this.spinner) this.spinner.stop();
     this.spinner = (0, import_ora.default)(message).start();
@@ -359,7 +410,7 @@ var Logger = class {
 var logger = new Logger();
 
 // src/utils/paths.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_fs3 = __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);
@@ -373,8 +424,8 @@ function getAgentSkillPaths(agentName, skillName, cwd) {
   return skillsDirs.map((dir) => import_node_path2.default.join(dir, skillName));
 }
 function ensureSharedDir() {
-  if (!import_node_fs2.default.existsSync(SHARED_SKILLS_DIR)) {
-    import_node_fs2.default.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
+  if (!import_node_fs3.default.existsSync(SHARED_SKILLS_DIR)) {
+    import_node_fs3.default.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
   }
 }
 function detectInstalledAgents(cwd) {
@@ -382,7 +433,7 @@ function detectInstalledAgents(cwd) {
     try {
       const skillsDirs = getAgentSkillsDirs(agent, cwd);
       return skillsDirs.some((dir) => {
-        return import_node_fs2.default.existsSync(dir) || import_node_fs2.default.existsSync(import_node_path2.default.dirname(dir));
+        return import_node_fs3.default.existsSync(dir) || import_node_fs3.default.existsSync(import_node_path2.default.dirname(dir));
       });
     } catch {
       return false;
@@ -403,7 +454,7 @@ function extractSkillName(nameOrPath) {
 
 // src/utils/registry.ts
 var import_node_child_process = require("child_process");
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_fs4 = __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);
@@ -411,7 +462,7 @@ 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)) {
+    if (import_node_fs4.default.existsSync(npmrcPath)) {
       return npmrcPath;
     }
     currentDir = import_node_path3.default.dirname(currentDir);
@@ -420,7 +471,7 @@ function findNpmrc(startDir) {
 }
 function parseNpmrc(npmrcPath) {
   try {
-    const content = import_node_fs3.default.readFileSync(npmrcPath, "utf-8");
+    const content = import_node_fs4.default.readFileSync(npmrcPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -463,33 +514,50 @@ async function getRegistry(cwd = process.cwd()) {
 }
 
 // src/utils/symlink.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
+function copyDir(src, dest) {
+  import_node_fs5.default.mkdirSync(dest, { recursive: true });
+  const entries = import_node_fs5.default.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const srcPath = import_node_path4.default.join(src, entry.name);
+    const destPath = import_node_path4.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      import_node_fs5.default.copyFileSync(srcPath, destPath);
+    }
+  }
+}
 function createSymlink(skillName, agent, cwd) {
   const source = getSharedSkillPath(skillName);
-  if (!import_node_fs4.default.existsSync(source)) {
+  if (!import_node_fs5.default.existsSync(source)) {
     logger.error(`Skill not found: ${source}`);
     return false;
   }
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
+  const useCopy = agent.useCopyInsteadOfSymlink === true;
   let successCount = 0;
   for (const target of targets) {
     const targetDir = import_node_path4.default.dirname(target);
-    if (!import_node_fs4.default.existsSync(targetDir)) {
+    if (!import_node_fs5.default.existsSync(targetDir)) {
       try {
-        import_node_fs4.default.mkdirSync(targetDir, { recursive: true });
+        import_node_fs5.default.mkdirSync(targetDir, { recursive: true });
       } catch (error) {
         logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
         continue;
       }
     }
-    if (import_node_fs4.default.existsSync(target)) {
+    if (import_node_fs5.default.existsSync(target)) {
       try {
-        const stats = import_node_fs4.default.lstatSync(target);
+        const stats = import_node_fs5.default.lstatSync(target);
         if (stats.isSymbolicLink()) {
-          import_node_fs4.default.unlinkSync(target);
+          import_node_fs5.default.unlinkSync(target);
+        } else if (stats.isDirectory()) {
+          import_node_fs5.default.rmSync(target, { recursive: true, force: true });
         } else {
-          logger.warn(`Target exists but is not a symlink, skipping: ${target}`);
+          logger.warn(`Target exists but is not a symlink/dir, skipping: ${target}`);
           continue;
         }
       } catch (error) {
@@ -498,10 +566,14 @@ function createSymlink(skillName, agent, cwd) {
       }
     }
     try {
-      import_node_fs4.default.symlinkSync(source, target, "dir");
+      if (useCopy) {
+        copyDir(source, target);
+      } else {
+        import_node_fs5.default.symlinkSync(source, target, "dir");
+      }
       successCount++;
     } catch (error) {
-      logger.error(`Failed to create symlink at ${target}: ${error.message}`);
+      logger.error(`Failed to ${useCopy ? "copy" : "symlink"} at ${target}: ${error.message}`);
     }
   }
   if (successCount > 0) {
@@ -515,19 +587,22 @@ function removeSymlink(skillName, agent, cwd) {
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
   let removedCount = 0;
   for (const target of targets) {
-    if (!import_node_fs4.default.existsSync(target)) {
+    if (!import_node_fs5.default.existsSync(target)) {
       continue;
     }
     try {
-      const stats = import_node_fs4.default.lstatSync(target);
+      const stats = import_node_fs5.default.lstatSync(target);
       if (stats.isSymbolicLink()) {
-        import_node_fs4.default.unlinkSync(target);
+        import_node_fs5.default.unlinkSync(target);
+        removedCount++;
+      } else if (stats.isDirectory()) {
+        import_node_fs5.default.rmSync(target, { recursive: true, force: true });
         removedCount++;
       } else {
-        logger.warn(`Not a symlink: ${target}`);
+        logger.warn(`Not a symlink or directory: ${target}`);
       }
     } catch (error) {
-      logger.error(`Failed to remove symlink at ${target}: ${error.message}`);
+      logger.error(`Failed to remove at ${target}: ${error.message}`);
     }
   }
   if (removedCount > 0) {
@@ -539,7 +614,7 @@ function removeSymlink(skillName, agent, cwd) {
 }
 function isSymlink(filePath) {
   try {
-    const stats = import_node_fs4.default.lstatSync(filePath);
+    const stats = import_node_fs5.default.lstatSync(filePath);
     return stats.isSymbolicLink();
   } catch {
     return false;
@@ -547,7 +622,7 @@ function isSymlink(filePath) {
 }
 function readSymlink(filePath) {
   try {
-    return import_node_fs4.default.readlinkSync(filePath);
+    return import_node_fs5.default.readlinkSync(filePath);
   } catch {
     return null;
   }
@@ -577,11 +652,20 @@ async function execWithTimeout(command, timeout = 12e4, env) {
   }
 }
 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}`);
@@ -593,21 +677,17 @@ async function install(skillNameOrPath, options = {}) {
     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_fs5.default.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...`);
+      import_node_fs6.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`);
+        spinner.succeed(`Cloned successfully`);
       } catch (error) {
         spinner.fail("Clone failed");
         if (error.message.includes("timeout")) {
@@ -624,7 +704,7 @@ async function install(skillNameOrPath, options = {}) {
       }
       if (gitInfo.path) {
         skillPath = import_node_path5.default.join(cloneDir, gitInfo.path);
-        if (!import_node_fs5.default.existsSync(skillPath)) {
+        if (!import_node_fs6.default.existsSync(skillPath)) {
           logger.error(`Path not found in repository: ${gitInfo.path}`);
           logger.info(`Repository cloned to: ${cloneDir}`);
           process.exit(1);
@@ -633,7 +713,7 @@ async function install(skillNameOrPath, options = {}) {
         skillPath = cloneDir;
       }
       const skillMdPath = import_node_path5.default.join(skillPath, "SKILL.md");
-      if (!import_node_fs5.default.existsSync(skillMdPath)) {
+      if (!import_node_fs6.default.existsSync(skillMdPath)) {
         logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
         logger.info("The directory may not be a valid skill package");
       }
@@ -655,16 +735,16 @@ Tried to clone: ${gitInfo.gitUrl}`);
       }
       process.exit(1);
     }
-  } else if (options.link || import_node_fs5.default.existsSync(skillNameOrPath)) {
+  } else if (options.link || import_node_fs6.default.existsSync(skillNameOrPath)) {
     skillPath = import_node_path5.default.resolve(skillNameOrPath);
-    if (!import_node_fs5.default.existsSync(skillPath)) {
+    if (!import_node_fs6.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_fs5.default.existsSync(pkgPath)) {
+    if (import_node_fs6.default.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgPath, "utf-8"));
         skillName = extractSkillName(pkg.name);
       } catch {
         skillName = extractSkillName(import_node_path5.default.basename(skillPath));
@@ -681,12 +761,12 @@ Tried to clone: ${gitInfo.gitUrl}`);
       const spinner = logger.start(`Installing ${skillNameOrPath}...`);
       logger.infoWithoutStop(`Registry: ${registry}`);
       logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      import_node_fs5.default.mkdirSync(tempDir, { recursive: true });
+      import_node_fs6.default.mkdirSync(tempDir, { recursive: true });
       logger.updateSpinner(`Downloading ${skillNameOrPath} from ${registry}...`);
       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_fs5.default.mkdirSync(npmCacheDir, { recursive: true });
+      import_node_fs6.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,
@@ -767,7 +847,7 @@ Tried to clone: ${gitInfo.gitUrl}`);
         process.exit(1);
       }
       skillPath = import_node_path5.default.join(tempDir, "node_modules", skillNameOrPath);
-      if (!import_node_fs5.default.existsSync(skillPath)) {
+      if (!import_node_fs6.default.existsSync(skillPath)) {
         logger.error(`Failed to download package: ${skillNameOrPath}`);
         process.exit(1);
       }
@@ -777,21 +857,24 @@ Tried to clone: ${gitInfo.gitUrl}`);
     }
   }
   const targetPath = getSharedSkillPath(skillName);
-  if (import_node_fs5.default.existsSync(targetPath)) {
+  const sourceIsTarget = import_node_path5.default.resolve(skillPath) === import_node_path5.default.resolve(targetPath);
+  const alreadyExists = import_node_fs6.default.existsSync(targetPath) && !sourceIsTarget;
+  if (alreadyExists) {
     if (options.force) {
       logger.warn("Removing existing installation...");
-      import_node_fs5.default.rmSync(targetPath, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(targetPath, { recursive: true, force: true });
     } else {
-      logger.error(`Skill already exists: ${targetPath}`);
-      logger.info("Use --force to overwrite");
-      process.exit(1);
+      logger.info(`Skill already exists, updating agent links...`);
     }
   }
-  if (options.link) {
-    import_node_fs5.default.symlinkSync(skillPath, targetPath, "dir");
+  if (sourceIsTarget) {
+    logger.info(`Skill already in shared directory, updating agent links...`);
+  } else if (alreadyExists && !options.force) {
+  } else if (options.link) {
+    import_node_fs6.default.symlinkSync(skillPath, targetPath, "dir");
     logger.success(`Linked to shared directory (dev mode)`);
   } else {
-    copyDir(skillPath, targetPath);
+    copyDir2(skillPath, targetPath);
     logger.success(`Installed to shared directory`);
   }
   logger.info(`\u{1F4CD} Location: ${targetPath}`);
@@ -802,21 +885,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;
@@ -833,9 +920,9 @@ Linked to ${successCount}/${targetAgents.length} agents`);
     logger.info("\n\u{1F4A1} Dev mode: changes to source files will reflect immediately");
   }
 }
-function copyDir(src, dest) {
-  import_node_fs5.default.mkdirSync(dest, { recursive: true });
-  const entries = import_node_fs5.default.readdirSync(src, { withFileTypes: true });
+function copyDir2(src, dest) {
+  import_node_fs6.default.mkdirSync(dest, { recursive: true });
+  const entries = import_node_fs6.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);
@@ -843,25 +930,25 @@ function copyDir(src, dest) {
       continue;
     }
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
+      copyDir2(srcPath, destPath);
     } else {
-      import_node_fs5.default.copyFileSync(srcPath, destPath);
+      import_node_fs6.default.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/commands/list.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var import_chalk3 = __toESM(require("chalk"), 1);
 function list() {
-  if (!import_node_fs6.default.existsSync(SHARED_SKILLS_DIR)) {
+  if (!import_node_fs7.default.existsSync(SHARED_SKILLS_DIR)) {
     logger.info("No skills installed");
     logger.info(`
 To install a skill, run: ${import_chalk3.default.cyan("eskill install <skill-name>")}`);
     return;
   }
-  const skills = import_node_fs6.default.readdirSync(SHARED_SKILLS_DIR);
+  const skills = import_node_fs7.default.readdirSync(SHARED_SKILLS_DIR);
   if (skills.length === 0) {
     logger.info("No skills installed");
     logger.info(`
@@ -874,15 +961,15 @@ 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_fs6.default.lstatSync(skillPath);
+      const stats = import_node_fs7.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_fs6.default.existsSync(pkgPath)) {
+      if (import_node_fs7.default.existsSync(pkgPath)) {
         try {
-          const pkgContent = import_node_fs6.default.readFileSync(pkgPath, "utf-8");
+          const pkgContent = import_node_fs7.default.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgContent);
           if (pkg.version && typeof pkg.version === "string") {
             version2 = pkg.version;
@@ -892,9 +979,9 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       }
       if (version2 === "unknown") {
         const skillMdPath = import_node_path6.default.join(skillPath, "SKILL.md");
-        if (import_node_fs6.default.existsSync(skillMdPath)) {
+        if (import_node_fs7.default.existsSync(skillMdPath)) {
           try {
-            const skillMdContent = import_node_fs6.default.readFileSync(skillMdPath, "utf-8");
+            const skillMdContent = import_node_fs7.default.readFileSync(skillMdPath, "utf-8");
             const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
             if (frontmatterMatch) {
               const frontmatter = frontmatterMatch[1];
@@ -912,8 +999,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_fs6.default.existsSync(targetPkgPath)) {
-              const pkg = JSON.parse(import_node_fs6.default.readFileSync(targetPkgPath, "utf-8"));
+            if (import_node_fs7.default.existsSync(targetPkgPath)) {
+              const pkg = JSON.parse(import_node_fs7.default.readFileSync(targetPkgPath, "utf-8"));
               if (pkg.version && typeof pkg.version === "string") {
                 version2 = pkg.version;
               }
@@ -930,15 +1017,19 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       const linkedAgents = [];
       for (const agent of AGENTS) {
         const skillsDirs = getAgentSkillsDirs(agent, cwd);
-        const hasSymlink = skillsDirs.some((dir) => {
+        const hasRef = skillsDirs.some((dir) => {
           const agentSkillPath = import_node_path6.default.join(dir, skill);
-          if (import_node_fs6.default.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
+          if (!import_node_fs7.default.existsSync(agentSkillPath)) return false;
+          if (isSymlink(agentSkillPath)) {
             const target = readSymlink(agentSkillPath);
             return target === skillPath;
           }
+          if (agent.useCopyInsteadOfSymlink) {
+            return import_node_fs7.default.statSync(agentSkillPath).isDirectory();
+          }
           return false;
         });
-        if (hasSymlink) {
+        if (hasRef) {
           linkedAgents.push(agent.displayName);
         }
       }
@@ -960,11 +1051,11 @@ Installed skills in ${SHARED_SKILLS_DIR}:
 }
 
 // src/commands/remove.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 async function remove(skillName, options = {}) {
   const extractedName = extractSkillName(skillName);
   const sharedPath = getSharedSkillPath(extractedName);
-  const skillExists = import_node_fs7.default.existsSync(sharedPath);
+  const skillExists = import_node_fs8.default.existsSync(sharedPath);
   if (!skillExists) {
     logger.error(`Skill not found: ${extractedName}`);
     logger.info(`Location: ${sharedPath}`);
@@ -974,11 +1065,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];
@@ -1000,35 +1091,33 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
   logger.info("Removing skill from shared directory...");
   try {
-    const stats = import_node_fs7.default.lstatSync(sharedPath);
+    const stats = import_node_fs8.default.lstatSync(sharedPath);
     if (stats.isSymbolicLink()) {
-      import_node_fs7.default.unlinkSync(sharedPath);
+      import_node_fs8.default.unlinkSync(sharedPath);
       logger.success("Removed symlink from shared directory");
     } else {
-      import_node_fs7.default.rmSync(sharedPath, { recursive: true, force: true });
+      import_node_fs8.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 = [];
+  const remainingRefs = [];
   for (const agent of AGENTS) {
     const agentSkillPaths = getAgentSkillPaths(agent.name, extractedName, cwd);
-    const hasSymlink = agentSkillPaths.some((path7) => {
-      return import_node_fs7.default.existsSync(path7) && isSymlink(path7);
-    });
-    if (hasSymlink) {
-      remainingSymlinks.push(agent.displayName);
+    const hasRef = agentSkillPaths.some((p) => import_node_fs8.default.existsSync(p));
+    if (hasRef) {
+      remainingRefs.push(agent.displayName);
     }
   }
-  if (remainingSymlinks.length > 0) {
+  if (remainingRefs.length > 0) {
     logger.warn(`
-\u26A0\uFE0F  Warning: Found remaining symlinks in:`);
-    for (const agentName of remainingSymlinks) {
+\u26A0\uFE0F  Warning: Found remaining references in:`);
+    for (const agentName of remainingRefs) {
       logger.info(`  - ${agentName}`);
     }
-    logger.info("\nYou may need to manually remove these symlinks");
+    logger.info("\nYou may need to manually remove these");
   } else {
     logger.success(`\u2705 Skill "${extractedName}" removed successfully!`);
   }