add-skill 1.0.21 → 1.0.23

package/dist/index.js

@@ -245,8 +245,9 @@ function getSkillDisplayName(skill) {
 }
 
 // src/installer.ts
-import { mkdir, cp, access, readdir as readdir2 } from "fs/promises";
-import { join as join4, basename as basename2, normalize as normalize2, resolve as resolve3, sep as sep2 } from "path";
+import { mkdir, cp, access, readdir as readdir2, symlink, lstat, rm as rm2, readlink } from "fs/promises";
+import { join as join4, basename as basename2, normalize as normalize2, resolve as resolve3, sep as sep2, relative } from "path";
+import { homedir as homedir2, platform } from "os";
 
 // src/agents.ts
 import { homedir } from "os";
@@ -410,6 +411,8 @@ async function detectInstalledAgents() {
 }
 
 // src/installer.ts
+var AGENTS_DIR = ".agents";
+var SKILLS_SUBDIR = "skills";
 function sanitizeName(name) {
   let sanitized = name.replace(/[\/\\:\0]/g, "");
   sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, "");
@@ -427,27 +430,107 @@ function isPathSafe(basePath, targetPath) {
   const normalizedTarget = normalize2(resolve3(targetPath));
   return normalizedTarget.startsWith(normalizedBase + sep2) || normalizedTarget === normalizedBase;
 }
+function getCanonicalSkillsDir(global, cwd) {
+  const baseDir = global ? homedir2() : cwd || process.cwd();
+  return join4(baseDir, AGENTS_DIR, SKILLS_SUBDIR);
+}
+async function createSymlink(target, linkPath) {
+  try {
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await readlink(linkPath);
+        if (resolve3(existingTarget) === resolve3(target)) {
+          return true;
+        }
+        await rm2(linkPath);
+      } else {
+        await rm2(linkPath, { recursive: true });
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") {
+        try {
+          await rm2(linkPath, { force: true });
+        } catch {
+        }
+      }
+    }
+    const linkDir = join4(linkPath, "..");
+    await mkdir(linkDir, { recursive: true });
+    const relativePath = relative(linkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : void 0;
+    await symlink(relativePath, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function installSkillForAgent(skill, agentType, options = {}) {
   const agent = agents[agentType];
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd || process.cwd();
   const rawSkillName = skill.name || basename2(skill.path);
   const skillName = sanitizeName(rawSkillName);
-  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
-  const targetDir = join4(targetBase, skillName);
-  if (!isPathSafe(targetBase, targetDir)) {
+  const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+  const canonicalDir = join4(canonicalBase, skillName);
+  const agentBase = isGlobal ? agent.globalSkillsDir : join4(cwd, agent.skillsDir);
+  const agentDir = join4(agentBase, skillName);
+  const installMode = options.mode ?? "symlink";
+  if (!isPathSafe(canonicalBase, canonicalDir)) {
     return {
       success: false,
-      path: targetDir,
+      path: agentDir,
+      mode: installMode,
+      error: "Invalid skill name: potential path traversal detected"
+    };
+  }
+  if (!isPathSafe(agentBase, agentDir)) {
+    return {
+      success: false,
+      path: agentDir,
+      mode: installMode,
       error: "Invalid skill name: potential path traversal detected"
     };
   }
   try {
-    await mkdir(targetDir, { recursive: true });
-    await copyDirectory(skill.path, targetDir);
-    return { success: true, path: targetDir };
+    if (installMode === "copy") {
+      await mkdir(agentDir, { recursive: true });
+      await copyDirectory(skill.path, agentDir);
+      return {
+        success: true,
+        path: agentDir,
+        mode: "copy"
+      };
+    }
+    await mkdir(canonicalDir, { recursive: true });
+    await copyDirectory(skill.path, canonicalDir);
+    const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+    if (!symlinkCreated) {
+      try {
+        await rm2(agentDir, { recursive: true, force: true });
+      } catch {
+      }
+      await mkdir(agentDir, { recursive: true });
+      await copyDirectory(skill.path, agentDir);
+      return {
+        success: true,
+        path: agentDir,
+        canonicalPath: canonicalDir,
+        mode: "symlink",
+        symlinkFailed: true
+      };
+    }
+    return {
+      success: true,
+      path: agentDir,
+      canonicalPath: canonicalDir,
+      mode: "symlink"
+    };
   } catch (error) {
     return {
       success: false,
-      path: targetDir,
+      path: agentDir,
+      mode: installMode,
       error: error instanceof Error ? error.message : "Unknown error"
     };
   }
@@ -492,17 +575,19 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
     return false;
   }
 }
-function getInstallPath(skillName, agentType, options = {}) {
-  const agent = agents[agentType];
+function getCanonicalPath(skillName, options = {}) {
   const sanitized = sanitizeName(skillName);
-  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
-  const installPath = join4(targetBase, sanitized);
-  if (!isPathSafe(targetBase, installPath)) {
+  const canonicalBase = getCanonicalSkillsDir(options.global ?? false, options.cwd);
+  const canonicalPath = join4(canonicalBase, sanitized);
+  if (!isPathSafe(canonicalBase, canonicalPath)) {
     throw new Error("Invalid skill name: potential path traversal detected");
   }
-  return installPath;
+  return canonicalPath;
 }
 
+// src/index.ts
+import { homedir as homedir3 } from "os";
+
 // src/telemetry.ts
 var TELEMETRY_URL = "https://add-skill.vercel.sh/t";
 var cliVersion = null;
@@ -539,7 +624,7 @@ function track(data) {
 // package.json
 var package_default = {
   name: "add-skill",
-  version: "1.0.21",
+  version: "1.0.23",
   description: "Install agent skills onto coding agents (OpenCode, Claude Code, Codex, Cursor)",
   type: "module",
   bin: {
@@ -605,6 +690,24 @@ var package_default = {
 };
 
 // src/index.ts
+function shortenPath(fullPath, cwd) {
+  const home2 = homedir3();
+  if (fullPath.startsWith(home2)) {
+    return fullPath.replace(home2, "~");
+  }
+  if (fullPath.startsWith(cwd)) {
+    return "." + fullPath.slice(cwd.length);
+  }
+  return fullPath;
+}
+function formatList(items, maxShow = 5) {
+  if (items.length <= maxShow) {
+    return items.join(", ");
+  }
+  const shown = items.slice(0, maxShow);
+  const remaining = items.length - maxShow;
+  return `${shown.join(", ")} +${remaining} more`;
+}
 var version = package_default.version;
 setVersion(version);
 program.name("add-skill").description("Install skills onto coding agents (OpenCode, Claude Code, Codex, Kiro CLI, Cursor, Antigravity, Github Copilot, Roo Code)").version(version).argument("<source>", "Git repo URL, GitHub shorthand (owner/repo), local path (./path), or direct path to skill").option("-g, --global", "Install skill globally (user-level) instead of project-level").option("-a, --agent <agents...>", "Specify agents to install to (opencode, claude-code, codex, kiro-cli, cursor, antigravity, github-copilot, roo)").option("-s, --skill <skills...>", "Specify skill names to install (skip selection prompt)").option("-l, --list", "List available skills in the repository without installing").option("-y, --yes", "Skip confirmation prompts").option("--all", "Install all skills to all agents without any prompts (implies -y -g)").configureOutput({
@@ -808,8 +911,24 @@ async function main(source, options) {
       }
       installGlobally = scope;
     }
+    let installMode = "symlink";
+    if (!options.yes) {
+      const modeChoice = await p.select({
+        message: "Installation method",
+        options: [
+          { value: "symlink", label: "Symlink (Recommended)", hint: "Single source of truth, easy updates" },
+          { value: "copy", label: "Copy to all agents", hint: "Independent copies for each agent" }
+        ]
+      });
+      if (p.isCancel(modeChoice)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      installMode = modeChoice;
+    }
+    const cwd = process.cwd();
     const summaryLines = [];
-    const maxAgentLen = Math.max(...targetAgents.map((a) => agents[a].displayName.length));
     const overwriteStatus = /* @__PURE__ */ new Map();
     for (const skill of selectedSkills) {
       const agentStatus = /* @__PURE__ */ new Map();
@@ -818,18 +937,25 @@ async function main(source, options) {
       }
       overwriteStatus.set(skill.name, agentStatus);
     }
+    const agentNames = targetAgents.map((a) => agents[a].displayName);
+    const hasOverwrites = Array.from(overwriteStatus.values()).some(
+      (agentMap) => Array.from(agentMap.values()).some((v) => v)
+    );
     for (const skill of selectedSkills) {
       if (summaryLines.length > 0) summaryLines.push("");
-      summaryLines.push(chalk.bold.cyan(getSkillDisplayName(skill)));
-      summaryLines.push("");
-      summaryLines.push(`  ${chalk.bold("Agent".padEnd(maxAgentLen + 2))}${chalk.bold("Directory")}`);
-      for (const agent of targetAgents) {
-        const fullPath = getInstallPath(skill.name, agent, { global: installGlobally });
-        const basePath = fullPath.replace(/\/[^/]+$/, "/");
-        const installed = overwriteStatus.get(skill.name)?.get(agent) ?? false;
-        const status = installed ? chalk.yellow(" (overwrite)") : "";
-        const agentName = agents[agent].displayName.padEnd(maxAgentLen + 2);
-        summaryLines.push(`  ${agentName}${chalk.dim(basePath)}${status}`);
+      if (installMode === "symlink") {
+        const canonicalPath = getCanonicalPath(skill.name, { global: installGlobally });
+        const shortCanonical = shortenPath(canonicalPath, cwd);
+        summaryLines.push(`${chalk.cyan(shortCanonical)}`);
+        summaryLines.push(`  ${chalk.dim("symlink \u2192")} ${formatList(agentNames)}`);
+      } else {
+        summaryLines.push(`${chalk.cyan(getSkillDisplayName(skill))}`);
+        summaryLines.push(`  ${chalk.dim("copy \u2192")} ${formatList(agentNames)}`);
+      }
+      const skillOverwrites = overwriteStatus.get(skill.name);
+      const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+      if (overwriteAgents.length > 0) {
+        summaryLines.push(`  ${chalk.yellow("overwrites:")} ${formatList(overwriteAgents)}`);
       }
     }
     console.log();
@@ -846,7 +972,7 @@ async function main(source, options) {
     const results = [];
     for (const skill of selectedSkills) {
       for (const agent of targetAgents) {
-        const result = await installSkillForAgent(skill, agent, { global: installGlobally });
+        const result = await installSkillForAgent(skill, agent, { global: installGlobally, mode: installMode });
         results.push({
           skill: getSkillDisplayName(skill),
           agent: agents[agent].displayName,
@@ -884,25 +1010,44 @@ async function main(source, options) {
     if (successful.length > 0) {
       const bySkill = /* @__PURE__ */ new Map();
       for (const r of successful) {
-        const skillAgents = bySkill.get(r.skill) || [];
-        skillAgents.push(r.agent);
-        bySkill.set(r.skill, skillAgents);
+        const skillResults = bySkill.get(r.skill) || [];
+        skillResults.push(r);
+        bySkill.set(r.skill, skillResults);
       }
       const skillCount = bySkill.size;
       const agentCount = new Set(successful.map((r) => r.agent)).size;
+      const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+      const copiedAgents = symlinkFailures.map((r) => r.agent);
       const resultLines = [];
-      for (const [skill, skillAgents] of bySkill) {
-        resultLines.push(`${chalk.green("\u2713")} ${chalk.bold(skill)}`);
-        for (const agent of skillAgents) {
-          resultLines.push(`  ${chalk.dim(agent)}`);
+      for (const [skillName, skillResults] of bySkill) {
+        const firstResult = skillResults[0];
+        if (firstResult.mode === "copy") {
+          resultLines.push(`${chalk.green("\u2713")} ${skillName} ${chalk.dim("(copied)")}`);
+          for (const r of skillResults) {
+            const shortPath = shortenPath(r.path, cwd);
+            resultLines.push(`  ${chalk.dim("\u2192")} ${shortPath}`);
+          }
+        } else {
+          if (firstResult.canonicalPath) {
+            const shortPath = shortenPath(firstResult.canonicalPath, cwd);
+            resultLines.push(`${chalk.green("\u2713")} ${shortPath}`);
+          }
+          const symlinked = skillResults.filter((r) => !r.symlinkFailed).map((r) => r.agent);
+          const copied = skillResults.filter((r) => r.symlinkFailed).map((r) => r.agent);
+          if (symlinked.length > 0) {
+            resultLines.push(`  ${chalk.dim("symlink \u2192")} ${formatList(symlinked)}`);
+          }
+          if (copied.length > 0) {
+            resultLines.push(`  ${chalk.yellow("copied \u2192")} ${formatList(copied)}`);
+          }
         }
-        resultLines.push("");
-      }
-      if (resultLines.length > 0 && resultLines[resultLines.length - 1] === "") {
-        resultLines.pop();
       }
       const title = chalk.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""} to ${agentCount} agent${agentCount !== 1 ? "s" : ""}`);
       p.note(resultLines.join("\n"), title);
+      if (symlinkFailures.length > 0) {
+        p.log.warn(chalk.yellow(`Symlinks failed for: ${formatList(copiedAgents)}`));
+        p.log.message(chalk.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+      }
     }
     if (failed.length > 0) {
       console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-skill",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Install agent skills onto coding agents (OpenCode, Claude Code, Codex, Cursor)",
   "type": "module",
   "bin": {