@cantemizyurek/skillz 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -6823,7 +6823,7 @@ var require_semver2 = __commonJS({
 
 // src/index.ts
 var import_node_path5 = __toESM(require("path"), 1);
-var import_node_process = __toESM(require("process"), 1);
+var import_node_process2 = __toESM(require("process"), 1);
 var import_prompts2 = require("@inquirer/prompts");
 
 // ../shared/dist/index.js
@@ -11248,6 +11248,7 @@ var skillNameSchema = external_exports.string().min(1).max(64).regex(
   SKILL_NAME_REGEX,
   "Skill name must be lowercase alphanumeric with internal dashes"
 );
+var namespaceSchema = usernameSchema;
 var namespaceNameSchema = external_exports.string().regex(
   /^[a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])?\/[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/,
   "Expected namespace/name"
@@ -11318,6 +11319,16 @@ var RegistryClient = class {
       method: "GET"
     });
   }
+  async list(namespace) {
+    const params = new URLSearchParams();
+    params.set("sort", "downloads");
+    if (namespace) {
+      params.set("namespace", namespace);
+    }
+    return this.request(`/skills?${params.toString()}`, {
+      method: "GET"
+    });
+  }
   async skillInfo(namespace, name) {
     return this.request(`/skills/${namespace}/${name}`, {
       method: "GET"
@@ -11406,6 +11417,7 @@ async function readErrorMessage(response) {
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
+var import_node_process = __toESM(require("process"), 1);
 var import_prompts = require("@inquirer/prompts");
 
 // src/git.ts
@@ -11459,17 +11471,18 @@ function parseSkillRef(input) {
   }
   return { namespace, name };
 }
-async function chooseAgent(input) {
-  if (input === "codex" || input === "claude" || input === "cursor") {
-    return input;
+async function chooseAgents(input) {
+  if (input && input.length > 0) {
+    return dedupeAgents(input);
   }
-  return (0, import_prompts.select)({
-    message: "Choose an agent target",
+  return (0, import_prompts.checkbox)({
+    message: "Choose agent targets",
     choices: [
       { name: "Codex", value: "codex" },
       { name: "Claude Code", value: "claude" },
       { name: "Cursor", value: "cursor" }
-    ]
+    ],
+    validate: (value) => value.length > 0 || "Choose at least one agent"
   });
 }
 async function chooseScope(input) {
@@ -11506,6 +11519,18 @@ async function chooseVersion(availableVersions, preferredVersion) {
     }))
   });
 }
+async function chooseSymlinkMode(input) {
+  if (typeof input.provided === "boolean") {
+    return input.provided;
+  }
+  if (input.agents.length <= 1) {
+    return false;
+  }
+  return (0, import_prompts.confirm)({
+    message: "Install once in .agents/skills and symlink into other selected agent folders?",
+    default: true
+  });
+}
 async function resolveInstallTarget(input) {
   let repoRoot = input.cwd;
   let usedCwdFallback = false;
@@ -11567,6 +11592,42 @@ async function installArchiveBuffer(archiveBuffer, archiveFormat, destinationPat
     await import_promises2.default.rm(tempRoot, { recursive: true, force: true });
   }
 }
+async function createOrReplaceSkillSymlink(input) {
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(input.linkPath), { recursive: true });
+  await import_promises2.default.rm(input.linkPath, { recursive: true, force: true });
+  const linkTarget = import_node_process.default.platform === "win32" ? import_node_path2.default.resolve(input.targetPath) : import_node_path2.default.relative(import_node_path2.default.dirname(input.linkPath), input.targetPath);
+  await import_promises2.default.symlink(
+    linkTarget,
+    input.linkPath,
+    import_node_process.default.platform === "win32" ? "junction" : "dir"
+  );
+}
+async function resolveInstallWritePath(installPath) {
+  try {
+    const stats = await import_promises2.default.lstat(installPath);
+    if (stats.isSymbolicLink()) {
+      return await import_promises2.default.realpath(installPath);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return installPath;
+    }
+    throw error;
+  }
+  return installPath;
+}
+function dedupeAgents(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const agent of input) {
+    if (seen.has(agent)) {
+      continue;
+    }
+    seen.add(agent);
+    deduped.push(agent);
+  }
+  return deduped;
+}
 
 // src/publish.ts
 var import_promises3 = __toESM(require("fs/promises"), 1);
@@ -11749,6 +11810,26 @@ program.command("whoami").description("Show current authenticated user").action(
   const me = await client.whoami();
   console.log(`${me.user.username} (${me.user.role})`);
 });
+program.command("list").description("List skills by download count (descending)").argument("[namespace]", "optional namespace").action(async (namespaceInput, _options, command) => {
+  const { client } = await makeClient(command, true);
+  const namespace = namespaceInput ? namespaceSchema.parse(namespaceInput) : void 0;
+  const result = await client.list(namespace);
+  if (result.skills.length === 0) {
+    if (namespace) {
+      console.log(`No skills found for namespace ${namespace}.`);
+    } else {
+      console.log("No skills found.");
+    }
+    return;
+  }
+  for (const skill of result.skills) {
+    const latest = skill.latestVersion ?? "none";
+    console.log(
+      `${skill.namespace}/${skill.name}  downloads=${skill.downloadCount}  latest=${latest}`
+    );
+    console.log(`  ${skill.description}`);
+  }
+});
 program.command("search").description("Search skills").argument("<query>", "search query").action(async (query, _options, command) => {
   const { client } = await makeClient(command, true);
   const result = await client.search(query);
@@ -11776,51 +11857,108 @@ program.command("info").description("Show skill metadata and versions").argument
   console.log(`Downloads: ${info.skill.downloadCount}`);
   console.log(`Versions: ${versions.versions.map((version) => version.version).join(", ") || "none"}`);
 });
-program.command("install").description("Install a skill").argument("<namespace/skill>", "skill reference").option("--version <x.y.z>", "specific version").option("--agent <agent>", "codex | claude | cursor").option("--scope <scope>", "user | project").option("--dir <path>", "custom root directory").action(async (skillRefInput, options2, command) => {
+program.command("install").description("Install a skill").argument("<namespace/skill>", "skill reference").option("--version <x.y.z>", "specific version").option("--agent <agents>", "codex | claude | cursor (comma-separated)").option("--scope <scope>", "user | project").option("--dir <path>", "custom root directory").action(async (skillRefInput, options2, command) => {
   namespaceNameSchema.parse(skillRefInput);
   const skillRef = parseSkillRef(skillRefInput);
   const { client, registryBaseUrl } = await makeClient(command, true);
-  const agent = await chooseAgent(
-    options2.agent ? agentSchema.parse(options2.agent) : void 0
-  );
+  const requestedAgents = options2.agent ? parseAgentTargetsOption(options2.agent) : void 0;
+  const agents = await chooseAgents(requestedAgents);
   const scope = await chooseScope(
     options2.scope ? scopeSchema.parse(options2.scope) : void 0
   );
+  const symlinkMode = await chooseSymlinkMode({
+    agents
+  });
   const versionList = await client.skillVersions(skillRef.namespace, skillRef.name);
   const selectedVersion = await chooseVersion(
     versionList.versions.map((row) => row.version),
     options2.version ? semverSchema.parse(options2.version) : void 0
   );
-  const resolution = await resolveInstallTarget({
-    agent,
-    scope,
-    skillName: skillRef.name,
-    cwd: import_node_process.default.cwd(),
-    dirOverride: options2.dir
-  });
-  if (resolution.usedCwdFallback) {
+  const resolutions = await Promise.all(
+    agents.map(
+      (agent) => resolveInstallTarget({
+        agent,
+        scope,
+        skillName: skillRef.name,
+        cwd: import_node_process2.default.cwd(),
+        dirOverride: options2.dir
+      })
+    )
+  );
+  if (resolutions.some((resolution) => resolution.usedCwdFallback)) {
     console.log(
-      `No git repo detected. Using current directory as repo root: ${import_node_process.default.cwd()}`
+      `No git repo detected. Using current directory as repo root: ${import_node_process2.default.cwd()}`
     );
   }
-  await downloadAndInstallSkill(
-    client,
-    skillRef,
-    selectedVersion,
-    resolution.installPath
-  );
-  await upsertManifestEntry({
-    namespace: skillRef.namespace,
-    name: skillRef.name,
-    version: selectedVersion,
-    agent,
-    scope,
-    installPath: resolution.installPath,
-    registryBaseUrl,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (symlinkMode) {
+    const sharedResolution = resolutions.find((resolution) => resolution.agent === "codex") ?? await resolveInstallTarget({
+      agent: "codex",
+      scope,
+      skillName: skillRef.name,
+      cwd: import_node_process2.default.cwd(),
+      dirOverride: options2.dir
+    });
+    await downloadAndInstallSkill(
+      client,
+      skillRef,
+      selectedVersion,
+      sharedResolution.installPath
+    );
+    for (const resolution of resolutions) {
+      if (resolution.agent !== "codex") {
+        await createOrReplaceSkillSymlink({
+          linkPath: resolution.installPath,
+          targetPath: sharedResolution.installPath
+        });
+      }
+      await upsertManifestEntry({
+        namespace: skillRef.namespace,
+        name: skillRef.name,
+        version: selectedVersion,
+        agent: resolution.agent,
+        scope,
+        installPath: resolution.installPath,
+        sourceInstallPath: resolution.agent === "codex" ? void 0 : sharedResolution.installPath,
+        registryBaseUrl,
+        installedAt
+      });
+    }
+    console.log(`Installed ${skillRef.namespace}/${skillRef.name}@${selectedVersion}`);
+    console.log(`Shared path: ${sharedResolution.installPath}`);
+    for (const resolution of resolutions) {
+      if (resolution.agent === "codex") {
+        console.log(`Codex: ${resolution.installPath}`);
+        continue;
+      }
+      console.log(
+        `${resolution.agent}: ${resolution.installPath} -> ${sharedResolution.installPath}`
+      );
+    }
+    return;
+  }
+  for (const resolution of resolutions) {
+    await downloadAndInstallSkill(
+      client,
+      skillRef,
+      selectedVersion,
+      resolution.installPath
+    );
+    await upsertManifestEntry({
+      namespace: skillRef.namespace,
+      name: skillRef.name,
+      version: selectedVersion,
+      agent: resolution.agent,
+      scope,
+      installPath: resolution.installPath,
+      registryBaseUrl,
+      installedAt
+    });
+  }
   console.log(`Installed ${skillRef.namespace}/${skillRef.name}@${selectedVersion}`);
-  console.log(`Path: ${resolution.installPath}`);
+  for (const resolution of resolutions) {
+    console.log(`${resolution.agent}: ${resolution.installPath}`);
+  }
 });
 program.command("update").description("Update installed skills").argument("[namespace/skill]", "skill reference").option("--all", "update all installed skills").option("--agent <agent>", "codex | claude | cursor").option("--scope <scope>", "user | project").action(async (skillRefInput, options2, command) => {
   const updateAll = Boolean(options2.all);
@@ -11856,8 +11994,10 @@ program.command("update").description("Update installed skills").argument("[name
   if (!config.token) {
     throw new Error("Not logged in. Run skillz login.");
   }
+  const candidateGroups = groupManifestEntriesBySource(candidates);
   let updatedCount = 0;
-  for (const installed of candidates) {
+  for (const group of candidateGroups) {
+    const installed = group[0];
     if (installed.registryBaseUrl !== resolveRegistryBaseUrl(command, config)) {
       console.log(
         `Skipping ${installed.namespace}/${installed.name} because it belongs to ${installed.registryBaseUrl}`
@@ -11867,9 +12007,11 @@ program.command("update").description("Update installed skills").argument("[name
     const client = new RegistryClient(installed.registryBaseUrl, config.token);
     const versions = await client.skillVersions(installed.namespace, installed.name);
     const latestVersion = versions.versions[0]?.version;
-    if (!latestVersion || !isSemverGreater(latestVersion, installed.version)) {
+    if (!latestVersion || !group.some((entry) => isSemverGreater(latestVersion, entry.version))) {
       continue;
     }
+    const sourcePath = installed.sourceInstallPath ?? installed.installPath;
+    const writePath = await resolveInstallWritePath(sourcePath);
     await downloadAndInstallSkill(
       client,
       {
@@ -11877,13 +12019,16 @@ program.command("update").description("Update installed skills").argument("[name
         name: installed.name
       },
       latestVersion,
-      installed.installPath
+      writePath
     );
-    installed.version = latestVersion;
-    installed.installedAt = (/* @__PURE__ */ new Date()).toISOString();
-    updatedCount += 1;
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const entry of group) {
+      entry.version = latestVersion;
+      entry.installedAt = updatedAt;
+    }
+    updatedCount += group.length;
     console.log(
-      `Updated ${installed.namespace}/${installed.name} to ${latestVersion}`
+      `Updated ${installed.namespace}/${installed.name} to ${latestVersion} (${group.map((entry) => entry.agent).join(", ")})`
     );
   }
   if (updatedCount === 0) {
@@ -11912,10 +12057,10 @@ invitesCommand.command("create").description("Create a single-use invite code (a
   const invite = await client.createInvite();
   console.log(invite.inviteCode);
 });
-program.parseAsync(import_node_process.default.argv).catch((error) => {
+program.parseAsync(import_node_process2.default.argv).catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`Error: ${message}`);
-  import_node_process.default.exit(1);
+  import_node_process2.default.exit(1);
 });
 async function makeClient(command, requireAuth) {
   const commandContext = isCommand(command) ? command : program;
@@ -11934,7 +12079,7 @@ async function makeClient(command, requireAuth) {
 }
 function resolveRegistryBaseUrl(command, config) {
   const options2 = resolveGlobalOptions(command);
-  const resolved = options2.registry ?? import_node_process.default.env.SKILLS_REGISTRY_API_URL ?? config.apiBaseUrl ?? "https://skillz-api.vercel.app";
+  const resolved = options2.registry ?? import_node_process2.default.env.SKILLS_REGISTRY_API_URL ?? config.apiBaseUrl ?? "https://skillz-api.vercel.app";
   return resolved.replace(/\/$/, "");
 }
 function resolveGlobalOptions(command) {
@@ -11955,6 +12100,32 @@ function resolveGlobalOptions(command) {
 function isCommand(value) {
   return Boolean(value) && typeof value.opts === "function";
 }
+function parseAgentTargetsOption(input) {
+  const values = input.split(",").map((value) => value.trim()).filter((value) => value.length > 0).map((value) => agentSchema.parse(value));
+  if (values.length === 0) {
+    throw new Error("Provide at least one agent in --agent");
+  }
+  return Array.from(new Set(values));
+}
+function groupManifestEntriesBySource(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const sourcePath = entry.sourceInstallPath ?? entry.installPath;
+    const key = [
+      entry.registryBaseUrl,
+      entry.namespace,
+      entry.name,
+      sourcePath
+    ].join("::");
+    const group = grouped.get(key);
+    if (group) {
+      group.push(entry);
+    } else {
+      grouped.set(key, [entry]);
+    }
+  }
+  return Array.from(grouped.values());
+}
 /*! Bundled license information:
 
 is-extendable/index.js: