@localskills/cli 0.3.0 → 0.7.0

package/dist/index.js

@@ -161,7 +161,7 @@ var require_src = __commonJS({
 });
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/auth.ts
 import { Command } from "commander";
@@ -1114,7 +1114,8 @@ var DEFAULT_CONFIG = {
   defaults: {
     scope: "project",
     method: "symlink"
-  }
+  },
+  anonymous_key: null
 };
 function loadConfig() {
   if (!existsSync(CONFIG_PATH)) {
@@ -1159,6 +1160,8 @@ function migrateV1toV2(v1) {
       name: skill.slug,
       hash: skill.hash,
       version: 0,
+      semver: null,
+      semverRange: null,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
       installations: [
         {
@@ -1187,6 +1190,14 @@ function clearToken() {
   config.token = null;
   saveConfig(config);
 }
+function getAnonymousKey() {
+  return loadConfig().anonymous_key ?? null;
+}
+function setAnonymousKey(key) {
+  const config = loadConfig();
+  config.anonymous_key = key;
+  saveConfig(config);
+}
 
 // src/lib/api-client.ts
 var ApiClient = class {
@@ -1229,25 +1240,16 @@ var ApiClient = class {
     });
     return this.handleResponse(res);
   }
-  async put(path, body) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      method: "PUT",
-      headers: this.headers(),
-      body: JSON.stringify(body)
-    });
-    return this.handleResponse(res);
-  }
-  async delete(path) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      method: "DELETE",
-      headers: this.headers()
-    });
-    return this.handleResponse(res);
-  }
-  async getRaw(path) {
-    return fetch(`${this.baseUrl}${path}`, {
-      headers: this.headers()
-    });
+  async fetchBinary(url) {
+    const headers = {};
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+      throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+    }
+    return Buffer.from(await res.arrayBuffer());
   }
   isAuthenticated() {
     return this.token !== null;
@@ -1285,9 +1287,29 @@ function openBrowser(url) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
-var loginCommand = new Command("login").description("Log in to localskills.sh").option("--token <token>", "Use an API token directly (headless mode)").action(async (opts) => {
+var loginCommand = new Command("login").description("Log in to localskills.sh").option("--token <token>", "Use an API token directly (headless mode)").option("--oidc-token <token>", "Exchange a CI/CD OIDC token for an API token").option("--team <slug>", "Team slug (required with --oidc-token)").action(async (opts) => {
+  if (opts.oidcToken) {
+    if (!opts.team) {
+      console.error("Error: --team is required with --oidc-token");
+      process.exit(1);
+    }
+    const client2 = new ApiClient();
+    const res = await client2.post(
+      "/api/oidc/token",
+      { token: opts.oidcToken, team: opts.team }
+    );
+    if (!res.success || !res.data) {
+      console.error(`OIDC login failed: ${res.error || "unknown error"}`);
+      process.exit(1);
+    }
+    setToken(res.data.token);
+    console.log(
+      `Authenticated via OIDC (expires ${new Date(res.data.expiresAt).toISOString()})`
+    );
+    return;
+  }
   if (opts.token) {
     setToken(opts.token);
     const client2 = new ApiClient();
@@ -1382,22 +1404,75 @@ var whoamiCommand = new Command("whoami").description("Show current user info").
 
 // src/commands/install.ts
 import { Command as Command2 } from "commander";
+import { mkdirSync as mkdirSync7 } from "fs";
+
+// ../../packages/shared/dist/utils/semver.js
+var SEMVER_RE = /^\d+\.\d+\.\d+$/;
+var RANGE_RE = /^(\^|~|>=)?\d+\.\d+\.\d+$|^\*$/;
+function parseSemVer(v) {
+  if (!SEMVER_RE.test(v))
+    return null;
+  const [major, minor, patch] = v.split(".").map(Number);
+  if (major > 999999 || minor > 999999 || patch > 999999)
+    return null;
+  return { major, minor, patch };
+}
+function isValidSemVer(v) {
+  return parseSemVer(v) !== null;
+}
+function isValidSemVerRange(range) {
+  return RANGE_RE.test(range);
+}
+
+// ../../packages/shared/dist/utils/index.js
+function titleFromSlug(slug) {
+  return slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// src/lib/cli-helpers.ts
+function requireAuth(client) {
+  if (!client.isAuthenticated()) {
+    console.error("Not authenticated. Run `localskills login` first.");
+    process.exit(1);
+  }
+}
+function buildVersionQuery(range) {
+  if (!range) return "";
+  if (isValidSemVer(range)) {
+    return `?semver=${encodeURIComponent(range)}`;
+  }
+  if (isValidSemVerRange(range)) {
+    return `?range=${encodeURIComponent(range)}`;
+  }
+  console.error(`Invalid version specifier: ${range}`);
+  process.exit(1);
+}
+function formatVersionLabel(semver, version) {
+  return semver ? `v${semver}` : `v${version}`;
+}
+function cancelGuard(value) {
+  if (Ct(value)) {
+    Ne("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
 
 // src/lib/cache.ts
 import {
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync10,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync4,
   readdirSync,
-  writeFileSync as writeFileSync9,
-  rmSync as rmSync4
+  writeFileSync as writeFileSync5,
+  rmSync as rmSync3
 } from "fs";
-import { join as join10, resolve as resolve2 } from "path";
-import { homedir as homedir7 } from "os";
+import { join as join12, resolve as resolve2 } from "path";
+import { homedir as homedir8 } from "os";
 
 // src/lib/installers/cursor.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/content-transform.ts
@@ -1437,10 +1512,13 @@ function stripFrontmatter(content) {
   return content;
 }
 
+// src/lib/installers/common.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join2 } from "path";
+
 // src/lib/symlink.ts
 import {
   symlinkSync,
-  readlinkSync,
   unlinkSync,
   lstatSync,
   existsSync as existsSync2,
@@ -1477,6 +1555,31 @@ function isSymlink(path) {
   }
 }
 
+// src/lib/installers/common.ts
+function safeSlugName(slug) {
+  return slug.replace(/\//g, "-");
+}
+var DEFAULT_METHOD = "symlink";
+function installFileOrSymlink(opts, targetPath) {
+  if (opts.method === "symlink") {
+    createSymlink(opts.cachePath, targetPath);
+  } else {
+    mkdirSync3(join2(targetPath, ".."), { recursive: true });
+    writeFileSync2(targetPath, opts.content);
+  }
+  return targetPath;
+}
+function uninstallFile(installation) {
+  if (installation.method === "symlink") {
+    removeSymlink(installation.path);
+  } else if (existsSync3(installation.path)) {
+    unlinkSync2(installation.path);
+  }
+}
+function defaultTransformContent(content) {
+  return toPlainMD(content);
+}
+
 // src/lib/installers/cursor.ts
 var descriptor = {
   id: "cursor",
@@ -1490,40 +1593,30 @@ function detect(projectDir) {
   const home = homedir2();
   const cwd = projectDir || process.cwd();
   return {
-    global: existsSync3(join2(home, ".cursor")),
-    project: existsSync3(join2(cwd, ".cursor"))
+    global: existsSync4(join3(home, ".cursor")),
+    project: existsSync4(join3(cwd, ".cursor"))
   };
 }
 function resolvePath(slug, scope, projectDir, _contentType) {
-  const safeName = slug.replace(/\//g, "-");
+  const safeName = safeSlugName(slug);
   if (scope === "global") {
-    return join2(homedir2(), ".cursor", "rules", `${safeName}.mdc`);
+    return join3(homedir2(), ".cursor", "rules", `${safeName}.mdc`);
   }
   const dir = projectDir || process.cwd();
-  return join2(dir, ".cursor", "rules", `${safeName}.mdc`);
+  return join3(dir, ".cursor", "rules", `${safeName}.mdc`);
 }
 function transformContent(content, skill) {
   return toCursorMDC(content, skill);
 }
 function install(opts) {
   const targetPath = resolvePath(opts.slug, opts.scope, opts.projectDir);
-  if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
-  } else {
-    mkdirSync3(join2(targetPath, ".."), { recursive: true });
-    writeFileSync2(targetPath, opts.content);
-  }
-  return targetPath;
+  return installFileOrSymlink(opts, targetPath);
 }
 function uninstall(installation, _slug) {
-  if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync3(installation.path)) {
-    unlinkSync2(installation.path);
-  }
+  uninstallFile(installation);
 }
 function defaultMethod() {
-  return "symlink";
+  return DEFAULT_METHOD;
 }
 var cursorAdapter = {
   descriptor,
@@ -1536,8 +1629,8 @@ var cursorAdapter = {
 };
 
 // src/lib/installers/claude.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, rmSync as rmSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
 var descriptor2 = {
   id: "claude",
@@ -1551,17 +1644,17 @@ function detect2(projectDir) {
   const home = homedir3();
   const cwd = projectDir || process.cwd();
   return {
-    global: existsSync4(join3(home, ".claude")),
-    project: existsSync4(join3(cwd, ".claude"))
+    global: existsSync5(join4(home, ".claude")),
+    project: existsSync5(join4(cwd, ".claude"))
   };
 }
 function resolvePath2(slug, scope, projectDir, contentType) {
-  const safeName = slug.replace(/\//g, "-");
-  const base = scope === "global" ? join3(homedir3(), ".claude") : join3(projectDir || process.cwd(), ".claude");
+  const safeName = safeSlugName(slug);
+  const base = scope === "global" ? join4(homedir3(), ".claude") : join4(projectDir || process.cwd(), ".claude");
   if (contentType === "rule") {
-    return join3(base, "rules", `${safeName}.md`);
+    return join4(base, "rules", `${safeName}.md`);
   }
-  return join3(base, "skills", safeName, "SKILL.md");
+  return join4(base, "skills", safeName, "SKILL.md");
 }
 function transformContent2(content, skill) {
   if (skill.type === "rule") {
@@ -1571,32 +1664,21 @@ function transformContent2(content, skill) {
 }
 function install2(opts) {
   const targetPath = resolvePath2(opts.slug, opts.scope, opts.projectDir, opts.contentType);
-  const targetDir = join3(targetPath, "..");
-  if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
-  } else {
-    mkdirSync4(targetDir, { recursive: true });
-    writeFileSync3(targetPath, opts.content);
-  }
-  return targetPath;
+  return installFileOrSymlink(opts, targetPath);
 }
 function uninstall2(installation, _slug) {
-  if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync4(installation.path)) {
-    unlinkSync3(installation.path);
-  }
-  const parentDir = join3(installation.path, "..");
+  uninstallFile(installation);
+  const parentDir = join4(installation.path, "..");
   try {
     const { readdirSync: readdirSync3 } = __require("fs");
-    if (existsSync4(parentDir) && readdirSync3(parentDir).length === 0) {
-      rmSync3(parentDir, { recursive: true });
+    if (existsSync5(parentDir) && readdirSync3(parentDir).length === 0) {
+      rmSync2(parentDir, { recursive: true });
     }
   } catch {
   }
 }
 function defaultMethod2() {
-  return "symlink";
+  return DEFAULT_METHOD;
 }
 var claudeAdapter = {
   descriptor: descriptor2,
@@ -1609,19 +1691,50 @@ var claudeAdapter = {
 };
 
 // src/lib/installers/codex.ts
-import { join as join4 } from "path";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+
+// src/lib/detect.ts
+import { existsSync as existsSync6 } from "fs";
+import { execFileSync } from "child_process";
 import { homedir as homedir4 } from "os";
-import { execSync } from "child_process";
+import { join as join5 } from "path";
+function commandExists(cmd) {
+  try {
+    execFileSync("which", [cmd], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectInstalledPlatforms(projectDir) {
+  const detected = [];
+  const home = homedir4();
+  const cwd = projectDir || process.cwd();
+  if (existsSync6(join5(home, ".cursor")) || existsSync6(join5(cwd, ".cursor")))
+    detected.push("cursor");
+  if (existsSync6(join5(home, ".claude")) || commandExists("claude"))
+    detected.push("claude");
+  if (commandExists("codex")) detected.push("codex");
+  if (existsSync6(join5(home, ".codeium")) || existsSync6(join5(cwd, ".windsurf")))
+    detected.push("windsurf");
+  if (existsSync6(join5(cwd, ".clinerules"))) detected.push("cline");
+  if (existsSync6(join5(cwd, ".github"))) detected.push("copilot");
+  if (commandExists("opencode") || existsSync6(join5(cwd, ".opencode")))
+    detected.push("opencode");
+  if (commandExists("aider")) detected.push("aider");
+  return detected;
+}
 
 // src/lib/marked-sections.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname2 } from "path";
 var START_MARKER = (slug) => `<!-- localskills:start:${slug} -->`;
 var END_MARKER = (slug) => `<!-- localskills:end:${slug} -->`;
 function upsertSection(filePath, slug, content) {
-  mkdirSync5(dirname2(filePath), { recursive: true });
+  mkdirSync4(dirname2(filePath), { recursive: true });
   let existing = "";
-  if (existsSync5(filePath)) {
+  if (existsSync7(filePath)) {
     existing = readFileSync2(filePath, "utf-8");
   }
   const start = START_MARKER(slug);
@@ -1638,10 +1751,10 @@ ${end}`;
     const separator = existing.length > 0 && !existing.endsWith("\n\n") ? "\n\n" : "";
     result = existing + separator + section + "\n";
   }
-  writeFileSync4(filePath, result);
+  writeFileSync3(filePath, result);
 }
 function removeSection(filePath, slug) {
-  if (!existsSync5(filePath)) return false;
+  if (!existsSync7(filePath)) return false;
   const existing = readFileSync2(filePath, "utf-8");
   const start = START_MARKER(slug);
   const end = END_MARKER(slug);
@@ -1653,11 +1766,11 @@ function removeSection(filePath, slug) {
   while (before.endsWith("\n\n")) before = before.slice(0, -1);
   while (after.startsWith("\n\n")) after = after.slice(1);
   const result = (before + after).trim();
-  writeFileSync4(filePath, result ? result + "\n" : "");
+  writeFileSync3(filePath, result ? result + "\n" : "");
   return true;
 }
 function listSections(filePath) {
-  if (!existsSync5(filePath)) return [];
+  if (!existsSync7(filePath)) return [];
   const content = readFileSync2(filePath, "utf-8");
   const regex = /<!-- localskills:start:(.+?) -->/g;
   const slugs = [];
@@ -1678,22 +1791,17 @@ var descriptor3 = {
   fileExtension: ".md"
 };
 function detect3() {
-  let hasCommand = false;
-  try {
-    execSync("which codex", { stdio: "ignore" });
-    hasCommand = true;
-  } catch {
-  }
+  const hasCommand = commandExists("codex");
   return { global: hasCommand, project: hasCommand };
 }
 function resolvePath3(slug, scope, projectDir, _contentType) {
   if (scope === "global") {
-    return join4(homedir4(), ".codex", "AGENTS.md");
+    return join6(homedir5(), ".codex", "AGENTS.md");
   }
-  return join4(projectDir || process.cwd(), "AGENTS.md");
+  return join6(projectDir || process.cwd(), "AGENTS.md");
 }
 function transformContent3(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function install3(opts) {
   const filePath = resolvePath3(opts.slug, opts.scope, opts.projectDir);
@@ -1719,9 +1827,9 @@ var codexAdapter = {
 };
 
 // src/lib/installers/windsurf.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
 var descriptor4 = {
   id: "windsurf",
   name: "Windsurf",
@@ -1732,22 +1840,22 @@ var descriptor4 = {
   fileExtension: ".md"
 };
 function detect4(projectDir) {
-  const home = homedir5();
+  const home = homedir6();
   const cwd = projectDir || process.cwd();
   return {
-    global: existsSync6(join5(home, ".codeium")),
-    project: existsSync6(join5(cwd, ".windsurf"))
+    global: existsSync8(join7(home, ".codeium")),
+    project: existsSync8(join7(cwd, ".windsurf"))
   };
 }
 function resolvePath4(slug, scope, projectDir, _contentType) {
-  const safeName = slug.replace(/\//g, "-");
+  const safeName = safeSlugName(slug);
   if (scope === "global") {
-    return join5(homedir5(), ".codeium", "windsurf", "memories", "global_rules.md");
+    return join7(homedir6(), ".codeium", "windsurf", "memories", "global_rules.md");
   }
-  return join5(projectDir || process.cwd(), ".windsurf", "rules", `${safeName}.md`);
+  return join7(projectDir || process.cwd(), ".windsurf", "rules", `${safeName}.md`);
 }
 function transformContent4(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function install4(opts) {
   const targetPath = resolvePath4(opts.slug, opts.scope, opts.projectDir);
@@ -1755,21 +1863,16 @@ function install4(opts) {
     upsertSection(targetPath, opts.slug, `## ${opts.slug}
 
 ${opts.content}`);
-  } else if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
   } else {
-    mkdirSync6(join5(targetPath, ".."), { recursive: true });
-    writeFileSync5(targetPath, opts.content);
+    installFileOrSymlink(opts, targetPath);
   }
   return targetPath;
 }
 function uninstall4(installation, slug) {
   if (installation.method === "section") {
     removeSection(installation.path, slug);
-  } else if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync6(installation.path)) {
-    unlinkSync4(installation.path);
+  } else {
+    uninstallFile(installation);
   }
 }
 function defaultMethod4(scope) {
@@ -1786,8 +1889,8 @@ var windsurfAdapter = {
 };
 
 // src/lib/installers/cline.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
 var descriptor5 = {
   id: "cline",
   name: "Cline",
@@ -1800,38 +1903,28 @@ function detect5(projectDir) {
   const cwd = projectDir || process.cwd();
   return {
     global: false,
-    project: existsSync7(join6(cwd, ".clinerules"))
+    project: existsSync9(join8(cwd, ".clinerules"))
   };
 }
 function resolvePath5(slug, scope, projectDir, _contentType) {
   if (scope === "global") {
     throw new Error("Cline does not support global installation");
   }
-  const safeName = slug.replace(/\//g, "-");
-  return join6(projectDir || process.cwd(), ".clinerules", `${safeName}.md`);
+  const safeName = safeSlugName(slug);
+  return join8(projectDir || process.cwd(), ".clinerules", `${safeName}.md`);
 }
 function transformContent5(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function install5(opts) {
   const targetPath = resolvePath5(opts.slug, opts.scope, opts.projectDir);
-  if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
-  } else {
-    mkdirSync7(join6(targetPath, ".."), { recursive: true });
-    writeFileSync6(targetPath, opts.content);
-  }
-  return targetPath;
+  return installFileOrSymlink(opts, targetPath);
 }
 function uninstall5(installation, _slug) {
-  if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync7(installation.path)) {
-    unlinkSync5(installation.path);
-  }
+  uninstallFile(installation);
 }
 function defaultMethod5() {
-  return "symlink";
+  return DEFAULT_METHOD;
 }
 var clineAdapter = {
   descriptor: descriptor5,
@@ -1844,8 +1937,8 @@ var clineAdapter = {
 };
 
 // src/lib/installers/copilot.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join9 } from "path";
 var descriptor6 = {
   id: "copilot",
   name: "GitHub Copilot",
@@ -1858,17 +1951,17 @@ function detect6(projectDir) {
   const cwd = projectDir || process.cwd();
   return {
     global: false,
-    project: existsSync8(join7(cwd, ".github"))
+    project: existsSync10(join9(cwd, ".github"))
   };
 }
 function resolvePath6(slug, scope, projectDir, _contentType) {
   if (scope === "global") {
     throw new Error("GitHub Copilot does not support global installation");
   }
-  return join7(projectDir || process.cwd(), ".github", "copilot-instructions.md");
+  return join9(projectDir || process.cwd(), ".github", "copilot-instructions.md");
 }
 function transformContent6(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function install6(opts) {
   const filePath = resolvePath6(opts.slug, opts.scope, opts.projectDir);
@@ -1894,10 +1987,9 @@ var copilotAdapter = {
 };
 
 // src/lib/installers/opencode.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync6 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir6 } from "os";
-import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir7 } from "os";
 var descriptor7 = {
   id: "opencode",
   name: "OpenCode",
@@ -1908,46 +2000,31 @@ var descriptor7 = {
 };
 function detect7(projectDir) {
   const cwd = projectDir || process.cwd();
-  let hasCommand = false;
-  try {
-    execSync2("which opencode", { stdio: "ignore" });
-    hasCommand = true;
-  } catch {
-  }
+  const hasCommand = commandExists("opencode");
   return {
     global: hasCommand,
-    project: hasCommand || existsSync9(join8(cwd, ".opencode"))
+    project: hasCommand || existsSync11(join10(cwd, ".opencode"))
   };
 }
 function resolvePath7(slug, scope, projectDir, _contentType) {
-  const safeName = slug.replace(/\//g, "-");
+  const safeName = safeSlugName(slug);
   if (scope === "global") {
-    return join8(homedir6(), ".config", "opencode", "rules", `${safeName}.md`);
+    return join10(homedir7(), ".config", "opencode", "rules", `${safeName}.md`);
   }
-  return join8(projectDir || process.cwd(), ".opencode", "rules", `${safeName}.md`);
+  return join10(projectDir || process.cwd(), ".opencode", "rules", `${safeName}.md`);
 }
 function transformContent7(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function install7(opts) {
   const targetPath = resolvePath7(opts.slug, opts.scope, opts.projectDir);
-  if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
-  } else {
-    mkdirSync8(join8(targetPath, ".."), { recursive: true });
-    writeFileSync7(targetPath, opts.content);
-  }
-  return targetPath;
+  return installFileOrSymlink(opts, targetPath);
 }
 function uninstall7(installation, _slug) {
-  if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync9(installation.path)) {
-    unlinkSync6(installation.path);
-  }
+  uninstallFile(installation);
 }
 function defaultMethod7() {
-  return "symlink";
+  return DEFAULT_METHOD;
 }
 var opencodeAdapter = {
   descriptor: descriptor7,
@@ -1960,9 +2037,8 @@ var opencodeAdapter = {
 };
 
 // src/lib/installers/aider.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, unlinkSync as unlinkSync7, readFileSync as readFileSync3 } from "fs";
-import { join as join9 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync12, writeFileSync as writeFileSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join11 } from "path";
 var descriptor8 = {
   id: "aider",
   name: "Aider",
@@ -1972,29 +2048,24 @@ var descriptor8 = {
   fileExtension: ".md"
 };
 function detect8() {
-  let hasCommand = false;
-  try {
-    execSync3("which aider", { stdio: "ignore" });
-    hasCommand = true;
-  } catch {
-  }
+  const hasCommand = commandExists("aider");
   return { global: false, project: hasCommand };
 }
 function resolvePath8(slug, scope, projectDir, contentType) {
   if (scope === "global") {
     throw new Error("Aider does not support global installation");
   }
-  const safeName = slug.replace(/\//g, "-");
+  const safeName = safeSlugName(slug);
   const subdir = contentType === "rule" ? "rules" : "skills";
-  return join9(projectDir || process.cwd(), ".aider", subdir, `${safeName}.md`);
+  return join11(projectDir || process.cwd(), ".aider", subdir, `${safeName}.md`);
 }
 function transformContent8(content) {
-  return toPlainMD(content);
+  return defaultTransformContent(content);
 }
 function addAiderRead(projectDir, relativePath) {
-  const configPath = join9(projectDir, ".aider.conf.yml");
+  const configPath = join11(projectDir, ".aider.conf.yml");
   let content = "";
-  if (existsSync10(configPath)) {
+  if (existsSync12(configPath)) {
     content = readFileSync3(configPath, "utf-8");
   }
   if (content.includes(relativePath)) return;
@@ -2004,44 +2075,35 @@ function addAiderRead(projectDir, relativePath) {
   } else {
     content = content.trimEnd() + (content ? "\n" : "") + readLine + "\n";
   }
-  writeFileSync8(configPath, content);
+  writeFileSync4(configPath, content);
 }
 function removeAiderRead(projectDir, relativePath) {
-  const configPath = join9(projectDir, ".aider.conf.yml");
-  if (!existsSync10(configPath)) return;
+  const configPath = join11(projectDir, ".aider.conf.yml");
+  if (!existsSync12(configPath)) return;
   let content = readFileSync3(configPath, "utf-8");
   const lines = content.split("\n");
   const filtered = lines.filter((line) => !line.includes(relativePath));
-  writeFileSync8(configPath, filtered.join("\n"));
+  writeFileSync4(configPath, filtered.join("\n"));
 }
 function install8(opts) {
   const targetPath = resolvePath8(opts.slug, opts.scope, opts.projectDir, opts.contentType);
   const projectDir = opts.projectDir || process.cwd();
-  if (opts.method === "symlink") {
-    createSymlink(opts.cachePath, targetPath);
-  } else {
-    mkdirSync9(join9(targetPath, ".."), { recursive: true });
-    writeFileSync8(targetPath, opts.content);
-  }
-  const safeName = opts.slug.replace(/\//g, "-");
+  installFileOrSymlink(opts, targetPath);
+  const safeName = safeSlugName(opts.slug);
   const subdir = opts.contentType === "rule" ? "rules" : "skills";
   const relativePath = `.aider/${subdir}/${safeName}.md`;
   addAiderRead(projectDir, relativePath);
   return targetPath;
 }
 function uninstall8(installation, slug) {
-  if (installation.method === "symlink") {
-    removeSymlink(installation.path);
-  } else if (existsSync10(installation.path)) {
-    unlinkSync7(installation.path);
-  }
+  uninstallFile(installation);
   const projectDir = installation.projectDir || process.cwd();
-  const safeName = slug.replace(/\//g, "-");
+  const safeName = safeSlugName(slug);
   removeAiderRead(projectDir, `.aider/skills/${safeName}.md`);
   removeAiderRead(projectDir, `.aider/rules/${safeName}.md`);
 }
 function defaultMethod8() {
-  return "symlink";
+  return DEFAULT_METHOD;
 }
 var aiderAdapter = {
   descriptor: descriptor8,
@@ -2074,7 +2136,7 @@ function getAllAdapters() {
 }
 
 // src/lib/cache.ts
-var CACHE_DIR = join10(homedir7(), ".localskills", "cache");
+var CACHE_DIR = join12(homedir8(), ".localskills", "cache");
 function slugToDir(slug) {
   if (slug.includes("..") || slug.includes("\0")) {
     throw new Error("Invalid slug: contains forbidden characters");
@@ -2082,7 +2144,7 @@ function slugToDir(slug) {
   return slug.replace(/\//g, "--");
 }
 function getCacheDir(slug) {
-  const dir = resolve2(join10(CACHE_DIR, slugToDir(slug)));
+  const dir = resolve2(join12(CACHE_DIR, slugToDir(slug)));
   if (!dir.startsWith(resolve2(CACHE_DIR) + "/") && dir !== resolve2(CACHE_DIR)) {
     throw new Error("Invalid slug: path traversal detected");
   }
@@ -2090,17 +2152,18 @@ function getCacheDir(slug) {
 }
 function store(slug, content, skill, version) {
   const dir = getCacheDir(slug);
-  mkdirSync10(dir, { recursive: true });
-  writeFileSync9(join10(dir, "raw.md"), content);
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(join12(dir, "raw.md"), content);
   const meta = {
     hash: skill.contentHash,
     version,
+    semver: skill.currentSemver ?? null,
     name: skill.name,
     description: skill.description,
     type: skill.type ?? "skill",
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync9(join10(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+  writeFileSync5(join12(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
   clearPlatformFiles(slug);
 }
 function getPlatformFile(slug, platform, skill) {
@@ -2111,98 +2174,103 @@ function getPlatformFile(slug, platform, skill) {
   const transformed = adapter.transformContent(raw, skill);
   if (platform === "claude") {
     if (skill.type === "rule") {
-      const claudeRuleDir = join10(dir, "claude-rule");
-      mkdirSync10(claudeRuleDir, { recursive: true });
-      const filePath3 = join10(claudeRuleDir, `${slug.replace(/\//g, "-")}.md`);
-      writeFileSync9(filePath3, transformed);
+      const claudeRuleDir = join12(dir, "claude-rule");
+      mkdirSync5(claudeRuleDir, { recursive: true });
+      const filePath3 = join12(claudeRuleDir, `${slug.replace(/\//g, "-")}.md`);
+      writeFileSync5(filePath3, transformed);
       return filePath3;
     }
-    const claudeDir = join10(dir, "claude");
-    mkdirSync10(claudeDir, { recursive: true });
-    const filePath2 = join10(claudeDir, "SKILL.md");
-    writeFileSync9(filePath2, transformed);
+    const claudeDir = join12(dir, "claude");
+    mkdirSync5(claudeDir, { recursive: true });
+    const filePath2 = join12(claudeDir, "SKILL.md");
+    writeFileSync5(filePath2, transformed);
     return filePath2;
   }
   const ext = adapter.descriptor.fileExtension;
-  const filePath = join10(dir, `${platform}${ext}`);
-  writeFileSync9(filePath, transformed);
+  const filePath = join12(dir, `${platform}${ext}`);
+  writeFileSync5(filePath, transformed);
   return filePath;
 }
 function getRawContent(slug) {
-  const filePath = join10(getCacheDir(slug), "raw.md");
-  if (!existsSync11(filePath)) return null;
+  const filePath = join12(getCacheDir(slug), "raw.md");
+  if (!existsSync13(filePath)) return null;
   return readFileSync4(filePath, "utf-8");
 }
 function purge(slug) {
   const dir = getCacheDir(slug);
-  if (existsSync11(dir)) {
-    rmSync4(dir, { recursive: true, force: true });
+  if (existsSync13(dir)) {
+    rmSync3(dir, { recursive: true, force: true });
   }
 }
+function storePackage(slug, zipBuffer, manifest, skill, version) {
+  const dir = getCacheDir(slug);
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(join12(dir, "package.zip"), zipBuffer);
+  writeFileSync5(join12(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  const meta = {
+    hash: skill.contentHash,
+    version,
+    semver: skill.currentSemver ?? null,
+    name: skill.name,
+    description: skill.description,
+    type: skill.type ?? "skill",
+    format: "package",
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync5(join12(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+}
 function clearPlatformFiles(slug) {
   const dir = getCacheDir(slug);
-  if (!existsSync11(dir)) return;
-  const keep = /* @__PURE__ */ new Set(["raw.md", "meta.json"]);
+  if (!existsSync13(dir)) return;
+  const keep = /* @__PURE__ */ new Set(["raw.md", "meta.json", "package.zip", "manifest.json"]);
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (!keep.has(entry.name)) {
-      rmSync4(join10(dir, entry.name), { recursive: true, force: true });
+      rmSync3(join12(dir, entry.name), { recursive: true, force: true });
     }
   }
 }
 
-// src/lib/detect.ts
-import { existsSync as existsSync12 } from "fs";
-import { execFileSync } from "child_process";
-import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
-function commandExists(cmd) {
-  try {
-    execFileSync("which", [cmd], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+// src/lib/extract.ts
+import { unzipSync } from "fflate";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13, dirname as dirname3, resolve as resolve3 } from "path";
+function extractPackage(zipBuffer, targetDir) {
+  const resolvedTarget = resolve3(targetDir);
+  const extracted = unzipSync(new Uint8Array(zipBuffer));
+  const writtenFiles = [];
+  for (const [path, data] of Object.entries(extracted)) {
+    if (path.endsWith("/")) continue;
+    if (path.includes("..") || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) {
+      continue;
+    }
+    const fullPath = resolve3(join13(targetDir, path));
+    if (!fullPath.startsWith(resolvedTarget + "/") && fullPath !== resolvedTarget) {
+      continue;
+    }
+    mkdirSync6(dirname3(fullPath), { recursive: true });
+    writeFileSync6(fullPath, Buffer.from(data));
+    writtenFiles.push(path);
   }
-}
-function detectInstalledPlatforms(projectDir) {
-  const detected = [];
-  const home = homedir8();
-  const cwd = projectDir || process.cwd();
-  if (existsSync12(join11(home, ".cursor")) || existsSync12(join11(cwd, ".cursor")))
-    detected.push("cursor");
-  if (existsSync12(join11(home, ".claude")) || commandExists("claude"))
-    detected.push("claude");
-  if (commandExists("codex")) detected.push("codex");
-  if (existsSync12(join11(home, ".codeium")) || existsSync12(join11(cwd, ".windsurf")))
-    detected.push("windsurf");
-  if (existsSync12(join11(cwd, ".clinerules"))) detected.push("cline");
-  if (existsSync12(join11(cwd, ".github"))) detected.push("copilot");
-  if (commandExists("opencode") || existsSync12(join11(cwd, ".opencode")))
-    detected.push("opencode");
-  if (commandExists("aider")) detected.push("aider");
-  return detected;
+  return writtenFiles;
 }
 
 // src/lib/interactive.ts
 async function interactiveInstall(availableSkills, detectedPlatforms) {
   We("localskills install");
-  const slug = await Je({
+  const slug = cancelGuard(await Je({
     message: "Which skill would you like to install?",
     options: availableSkills.map((s) => ({
       value: s.slug,
       label: s.name,
       hint: truncate(s.description, 60)
     }))
-  });
-  if (Ct(slug)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
+  }));
   const rest = await interactiveTargets(detectedPlatforms);
   return { slug, ...rest };
 }
 async function interactiveTargets(detectedPlatforms) {
   const allAdapters = getAllAdapters();
-  const platforms = await je({
+  const platforms = cancelGuard(await je({
     message: "Which platforms should receive this skill?",
     options: allAdapters.map((a) => ({
       value: a.descriptor.id,
@@ -2211,12 +2279,8 @@ async function interactiveTargets(detectedPlatforms) {
     })),
     initialValues: detectedPlatforms.length > 0 ? detectedPlatforms : void 0,
     required: true
-  });
-  if (Ct(platforms)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
-  const scope = await Je({
+  }));
+  const scope = cancelGuard(await Je({
     message: "Install scope?",
     options: [
       {
@@ -2231,12 +2295,8 @@ async function interactiveTargets(detectedPlatforms) {
       }
     ],
     initialValue: "project"
-  });
-  if (Ct(scope)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
-  const method = await Je({
+  }));
+  const method = cancelGuard(await Je({
     message: "Install method?",
     options: [
       {
@@ -2251,31 +2311,18 @@ async function interactiveTargets(detectedPlatforms) {
       }
     ],
     initialValue: "symlink"
-  });
-  if (Ct(method)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
-  return {
-    platforms,
-    scope,
-    method
-  };
+  }));
+  return { platforms, scope, method };
 }
 async function interactiveUninstall(installedSlugs) {
   We("localskills uninstall");
-  const slug = await Je({
+  return cancelGuard(await Je({
     message: "Which skill would you like to uninstall?",
     options: installedSlugs.map((s) => ({
       value: s,
       label: s
     }))
-  });
-  if (Ct(slug)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
-  return slug;
+  }));
 }
 function truncate(str, max) {
   if (str.length <= max) return str;
@@ -2311,6 +2358,19 @@ function parsePlatforms(raw) {
   }
   return platforms;
 }
+function buildSkillRecord(cacheKey, skill, version, resolvedSemver, requestedRange, existingInstallations, newInstallations) {
+  return {
+    slug: cacheKey,
+    name: skill.name,
+    type: skill.type ?? "skill",
+    hash: skill.contentHash,
+    version,
+    semver: resolvedSemver ?? null,
+    semverRange: requestedRange ?? null,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    installations: existingInstallations ? [...existingInstallations, ...newInstallations] : newInstallations
+  };
+}
 var installCommand = new Command2("install").description("Install a skill locally").argument("[slug]", "Skill slug (omit for interactive search)").option("-t, --target <targets...>", "Target platforms (cursor, claude, codex, ...)").option("-g, --global", "Install globally").option("-p, --project [dir]", "Install in project directory").option("--symlink", "Use symlink (default)").option("--copy", "Copy instead of symlink").action(
   async (slugArg, opts) => {
     const client = new ApiClient();
@@ -2363,10 +2423,17 @@ var installCommand = new Command2("install").description("Install a skill locall
         method = explicitMethod || answers.method;
       }
     }
+    let requestedRange = null;
+    if (slug.includes("@")) {
+      const atIdx = slug.lastIndexOf("@");
+      requestedRange = slug.substring(atIdx + 1);
+      slug = slug.substring(0, atIdx);
+    }
+    const versionQuery = buildVersionQuery(requestedRange);
     const spinner = bt2();
     spinner.start(`Fetching ${slug}...`);
     const res = await client.get(
-      `/api/skills/${encodeURIComponent(slug)}/content`
+      `/api/skills/${encodeURIComponent(slug)}/content${versionQuery}`
     );
     if (!res.success || !res.data) {
       spinner.stop("Failed.");
@@ -2378,9 +2445,62 @@ var installCommand = new Command2("install").description("Install a skill locall
       process.exit(1);
       return;
     }
-    const { skill, content, version } = res.data;
-    spinner.stop(`Fetched ${skill.name} v${version}`);
-    const cacheKey = skill.publicId || slug;
+    const resData = res.data;
+    const format = resData.format ?? "text";
+    const cacheKey = resData.skill.publicId || slug;
+    if (format === "package") {
+      const { skill: skill2, downloadUrl, manifest, version: version2, semver: resolvedSemver2 } = resData;
+      spinner.stop(`Fetched ${skill2.name} ${formatVersionLabel(resolvedSemver2, version2)} (package, ${manifest.files.length} files)`);
+      const dlSpinner = bt2();
+      dlSpinner.start("Downloading package...");
+      const zipBuffer = await client.fetchBinary(downloadUrl);
+      dlSpinner.stop(`Downloaded ${(zipBuffer.length / 1024).toFixed(1)} KB`);
+      storePackage(cacheKey, zipBuffer, manifest, skill2, version2);
+      const installations2 = [];
+      const results2 = [];
+      for (const platformId of platforms) {
+        const adapter = getAdapter(platformId);
+        const desc = adapter.descriptor;
+        if (scope === "global" && !desc.supportsGlobal) {
+          R2.warn(`${desc.name} does not support global \u2014 skipping.`);
+          continue;
+        }
+        if (scope === "project" && !desc.supportsProject) {
+          R2.warn(`${desc.name} does not support project \u2014 skipping.`);
+          continue;
+        }
+        const targetPath = adapter.resolvePath(cacheKey, scope, projectDir, skill2.type ?? "skill");
+        mkdirSync7(targetPath, { recursive: true });
+        const written = extractPackage(zipBuffer, targetPath);
+        const installation = {
+          platform: platformId,
+          scope,
+          method: "copy",
+          path: targetPath,
+          projectDir,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        installations2.push(installation);
+        results2.push(`${desc.name} \u2192 ${targetPath} (${written.length} files extracted)`);
+      }
+      config.installed_skills[cacheKey] = buildSkillRecord(
+        cacheKey,
+        skill2,
+        version2,
+        resolvedSemver2,
+        requestedRange,
+        config.installed_skills[cacheKey]?.installations,
+        installations2
+      );
+      saveConfig(config);
+      for (const r of results2) {
+        R2.success(r);
+      }
+      Le(`Done! Installed to ${installations2.length} target(s).`);
+      return;
+    }
+    const { skill, content, version, semver: resolvedSemver } = resData;
+    spinner.stop(`Fetched ${skill.name} ${formatVersionLabel(resolvedSemver, version)}`);
     store(cacheKey, content, skill, version);
     const contentType = skill.type ?? "skill";
     const installations = [];
@@ -2420,17 +2540,15 @@ var installCommand = new Command2("install").description("Install a skill locall
       const methodLabel = actualMethod === "symlink" ? "symlinked" : actualMethod === "section" ? "section" : "copied";
       results.push(`${desc.name} \u2192 ${installedPath} (${methodLabel})`);
     }
-    const existing = config.installed_skills[cacheKey];
-    const skillRecord = {
-      slug: cacheKey,
-      name: skill.name,
-      type: contentType,
-      hash: skill.contentHash,
+    config.installed_skills[cacheKey] = buildSkillRecord(
+      cacheKey,
+      skill,
       version,
-      cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      installations: existing ? [...existing.installations, ...installations] : installations
-    };
-    config.installed_skills[cacheKey] = skillRecord;
+      resolvedSemver,
+      requestedRange,
+      config.installed_skills[cacheKey]?.installations,
+      installations
+    );
     saveConfig(config);
     for (const r of results) {
       R2.success(r);
@@ -2489,33 +2607,62 @@ var uninstallCommand = new Command3("uninstall").description("Uninstall a skill"
 
 // src/commands/list.ts
 import { Command as Command4 } from "commander";
-var listCommand = new Command4("list").description("List available skills").option("--public", "Show public skills only").action(async (opts) => {
+var listCommand = new Command4("list").description("List available skills").option("--public", "Show public skills only").option("--tag <tag>", "Filter by tag (requires --public)").option("--search <query>", "Search skills (requires --public)").action(async (opts) => {
   const client = new ApiClient();
-  if (!client.isAuthenticated()) {
-    console.error("Not authenticated. Run `localskills login` first.");
+  if ((opts.tag || opts.search) && !opts.public) {
+    console.error("The --tag and --search flags require --public.");
     process.exit(1);
   }
-  const path = opts.public ? "/api/skills?visibility=public" : "/api/skills";
-  const res = await client.get(path);
-  if (!res.success || !res.data) {
-    console.error(`Error: ${res.error || "Failed to fetch skills"}`);
-    process.exit(1);
-    return;
-  }
-  if (res.data.length === 0) {
-    console.log("No skills found.");
-    return;
-  }
-  console.log("Available skills:\n");
-  for (const skill of res.data) {
-    const vis = skill.visibility === "public" ? "" : ` [${skill.visibility}]`;
-    console.log(`  ${skill.slug}${vis} \u2014 ${skill.description || skill.name}`);
-  }
-  console.log(`
+  if (opts.public) {
+    const params = new URLSearchParams();
+    if (opts.tag) params.set("tag", opts.tag);
+    if (opts.search) params.set("q", opts.search);
+    const qs = params.toString();
+    const path = qs ? `/api/explore?${qs}` : "/api/explore";
+    const res = await client.get(path);
+    if (!res.success || !res.data) {
+      console.error(`Error: ${res.error || "Failed to fetch skills"}`);
+      process.exit(1);
+      return;
+    }
+    if (res.data.length === 0) {
+      console.log("No skills found.");
+      return;
+    }
+    console.log("Public skills:\n");
+    for (const skill of res.data) {
+      const ver = formatVersionLabel(skill.currentSemver, skill.currentVersion);
+      const tags = skill.tags.length > 0 ? ` [${skill.tags.join(", ")}]` : "";
+      console.log(`  ${skill.slug} ${ver}${tags} \u2014 ${skill.description || skill.name}`);
+    }
+    console.log(`
+${res.data.length} skill(s) found.`);
+  } else {
+    requireAuth(client);
+    const res = await client.get("/api/skills");
+    if (!res.success || !res.data) {
+      console.error(`Error: ${res.error || "Failed to fetch skills"}`);
+      process.exit(1);
+      return;
+    }
+    if (res.data.length === 0) {
+      console.log("No skills found.");
+      return;
+    }
+    console.log("Available skills:\n");
+    for (const skill of res.data) {
+      const vis = skill.visibility === "public" ? "" : ` [${skill.visibility}]`;
+      const ver = formatVersionLabel(skill.currentSemver, skill.currentVersion);
+      const tags = skill.tags?.length > 0 ? ` [${skill.tags.join(", ")}]` : "";
+      console.log(`  ${skill.slug} ${ver}${vis}${tags} \u2014 ${skill.description || skill.name}`);
+    }
+    console.log(`
 ${res.data.length} skill(s) found.`);
+  }
 });
 
 // src/commands/pull.ts
+import { mkdirSync as mkdirSync8 } from "fs";
 import { Command as Command5 } from "commander";
 var pullCommand = new Command5("pull").description("Pull latest versions of all installed skills").argument("[slug]", "Pull a specific skill (omit for all)").action(async (slugArg) => {
   const config = loadConfig();
@@ -2535,53 +2682,70 @@ var pullCommand = new Command5("pull").description("Pull latest versions of all
       R2.warn(`${slug} \u2014 not found in config, skipping.`);
       continue;
     }
+    const versionQuery = buildVersionQuery(installed.semverRange);
     spinner.start(`Checking ${slug}...`);
     const res = await client.get(
-      `/api/skills/${encodeURIComponent(slug)}/content`
+      `/api/skills/${encodeURIComponent(slug)}/content${versionQuery}`
     );
     if (!res.success || !res.data) {
       spinner.stop(`${slug} \u2014 failed: ${res.error || "not found"}`);
       continue;
     }
-    const { skill, content, version } = res.data;
+    const resData = res.data;
+    const format = resData.format ?? "text";
+    const { skill, version } = resData;
     if (skill.contentHash === installed.hash) {
       spinner.stop(`${slug} \u2014 up to date`);
       skipped++;
       continue;
     }
-    store(slug, content, skill, version);
-    for (const installation of installed.installations) {
-      if (installation.method === "symlink") {
-        getPlatformFile(slug, installation.platform, skill);
-        continue;
+    if (format === "package") {
+      const { downloadUrl, manifest } = resData;
+      const zipBuffer = await client.fetchBinary(downloadUrl);
+      storePackage(slug, zipBuffer, manifest, skill, version);
+      for (const installation of installed.installations) {
+        const adapter = getAdapter(installation.platform);
+        const targetPath = adapter.resolvePath(slug, installation.scope, installation.projectDir, skill.type ?? "skill");
+        mkdirSync8(targetPath, { recursive: true });
+        extractPackage(zipBuffer, targetPath);
       }
-      const adapter = getAdapter(installation.platform);
-      const transformed = adapter.transformContent(content, skill);
-      if (installation.method === "section") {
-        upsertSection(
-          installation.path,
-          slug,
-          `## ${slug}
+    } else {
+      const { content } = resData;
+      store(slug, content, skill, version);
+      for (const installation of installed.installations) {
+        if (installation.method === "symlink") {
+          getPlatformFile(slug, installation.platform, skill);
+          continue;
+        }
+        const adapter = getAdapter(installation.platform);
+        const transformed = adapter.transformContent(content, skill);
+        if (installation.method === "section") {
+          upsertSection(
+            installation.path,
+            slug,
+            `## ${slug}
 
 ${transformed}`
-        );
-      } else {
-        const cachePath = getPlatformFile(slug, installation.platform, skill);
-        adapter.install({
-          slug,
-          content: transformed,
-          scope: installation.scope,
-          method: "copy",
-          cachePath,
-          projectDir: installation.projectDir
-        });
+          );
+        } else {
+          const cachePath = getPlatformFile(slug, installation.platform, skill);
+          adapter.install({
+            slug,
+            content: transformed,
+            scope: installation.scope,
+            method: "copy",
+            cachePath,
+            projectDir: installation.projectDir
+          });
+        }
       }
     }
     installed.hash = skill.contentHash;
     installed.version = version;
+    installed.semver = resData.semver ?? null;
     installed.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
     updated++;
-    spinner.stop(`${slug} \u2014 updated to v${version}`);
+    spinner.stop(`${slug} \u2014 updated to ${formatVersionLabel(res.data.semver, version)}`);
   }
   saveConfig(config);
   Le(`Pull complete. ${updated} updated, ${skipped} up to date.`);
@@ -2589,44 +2753,44 @@ ${transformed}`
 
 // src/commands/publish.ts
 import { Command as Command6 } from "commander";
-import { readFileSync as readFileSync6, existsSync as existsSync14 } from "fs";
-import { resolve as resolve3, basename as basename2, extname as extname2 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync15 } from "fs";
+import { resolve as resolve4, basename as basename2, extname as extname2 } from "path";
 import { homedir as homedir10 } from "os";
 
 // src/lib/scanner.ts
-import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { join as join12, basename, extname } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join14, basename, extname } from "path";
 import { homedir as homedir9 } from "os";
-import { readlinkSync as readlinkSync2, lstatSync as lstatSync2 } from "fs";
+import { readlinkSync, lstatSync as lstatSync2 } from "fs";
 function scanForSkills(projectDir) {
   const home = homedir9();
   const cwd = projectDir || process.cwd();
   const results = [];
-  scanDirectory(join12(home, ".cursor", "rules"), ".mdc", "cursor", "global", results);
-  scanDirectory(join12(cwd, ".cursor", "rules"), ".mdc", "cursor", "project", results);
-  scanClaudeSkills(join12(home, ".claude", "skills"), "global", results);
-  scanClaudeSkills(join12(cwd, ".claude", "skills"), "project", results);
-  scanDirectory(join12(home, ".claude", "rules"), ".md", "claude", "global", results, "rule");
-  scanDirectory(join12(cwd, ".claude", "rules"), ".md", "claude", "project", results, "rule");
-  scanSingleFile(join12(home, ".codex", "AGENTS.md"), "codex", "global", results);
-  scanSingleFile(join12(cwd, "AGENTS.md"), "codex", "project", results);
+  scanDirectory(join14(home, ".cursor", "rules"), ".mdc", "cursor", "global", results);
+  scanDirectory(join14(cwd, ".cursor", "rules"), ".mdc", "cursor", "project", results);
+  scanClaudeSkills(join14(home, ".claude", "skills"), "global", results);
+  scanClaudeSkills(join14(cwd, ".claude", "skills"), "project", results);
+  scanDirectory(join14(home, ".claude", "rules"), ".md", "claude", "global", results, "rule");
+  scanDirectory(join14(cwd, ".claude", "rules"), ".md", "claude", "project", results, "rule");
+  scanSingleFile(join14(home, ".codex", "AGENTS.md"), "codex", "global", results);
+  scanSingleFile(join14(cwd, "AGENTS.md"), "codex", "project", results);
   scanSingleFile(
-    join12(home, ".codeium", "windsurf", "memories", "global_rules.md"),
+    join14(home, ".codeium", "windsurf", "memories", "global_rules.md"),
     "windsurf",
     "global",
     results
   );
-  scanDirectory(join12(cwd, ".windsurf", "rules"), ".md", "windsurf", "project", results);
-  scanDirectory(join12(cwd, ".clinerules"), ".md", "cline", "project", results);
+  scanDirectory(join14(cwd, ".windsurf", "rules"), ".md", "windsurf", "project", results);
+  scanDirectory(join14(cwd, ".clinerules"), ".md", "cline", "project", results);
   scanSingleFile(
-    join12(cwd, ".github", "copilot-instructions.md"),
+    join14(cwd, ".github", "copilot-instructions.md"),
     "copilot",
     "project",
     results
   );
-  scanDirectory(join12(home, ".config", "opencode", "rules"), ".md", "opencode", "global", results);
-  scanDirectory(join12(cwd, ".opencode", "rules"), ".md", "opencode", "project", results);
-  scanDirectory(join12(cwd, ".aider", "skills"), ".md", "aider", "project", results);
+  scanDirectory(join14(home, ".config", "opencode", "rules"), ".md", "opencode", "global", results);
+  scanDirectory(join14(cwd, ".opencode", "rules"), ".md", "opencode", "project", results);
+  scanDirectory(join14(cwd, ".aider", "skills"), ".md", "aider", "project", results);
   return results;
 }
 function filterTracked(detected, config) {
@@ -2636,13 +2800,13 @@ function filterTracked(detected, config) {
       trackedPaths.add(inst.path);
     }
   }
-  const cacheDir = join12(homedir9(), ".localskills", "cache");
+  const cacheDir = join14(homedir9(), ".localskills", "cache");
   return detected.filter((skill) => {
     if (trackedPaths.has(skill.filePath)) return false;
     try {
       const stat = lstatSync2(skill.filePath);
       if (stat.isSymbolicLink()) {
-        const target = readlinkSync2(skill.filePath);
+        const target = readlinkSync(skill.filePath);
         if (target.startsWith(cacheDir)) return false;
       }
     } catch {
@@ -2653,11 +2817,9 @@ function filterTracked(detected, config) {
 function slugFromFilename(filename) {
   return basename(filename, extname(filename));
 }
-function nameFromSlug(slug) {
-  return slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
+var nameFromSlug = titleFromSlug;
 function scanDirectory(dir, ext, platform, scope, results, contentType = "skill") {
-  if (!existsSync13(dir)) return;
+  if (!existsSync14(dir)) return;
   let entries;
   try {
     entries = readdirSync2(dir);
@@ -2666,7 +2828,7 @@ function scanDirectory(dir, ext, platform, scope, results, contentType = "skill"
   }
   for (const entry of entries) {
     if (!entry.endsWith(ext)) continue;
-    const filePath = join12(dir, entry);
+    const filePath = join14(dir, entry);
     try {
       const raw = readFileSync5(filePath, "utf-8");
       const content = stripFrontmatter(raw).trim();
@@ -2686,7 +2848,7 @@ function scanDirectory(dir, ext, platform, scope, results, contentType = "skill"
   }
 }
 function scanClaudeSkills(skillsDir, scope, results) {
-  if (!existsSync13(skillsDir)) return;
+  if (!existsSync14(skillsDir)) return;
   let entries;
   try {
     entries = readdirSync2(skillsDir);
@@ -2694,8 +2856,8 @@ function scanClaudeSkills(skillsDir, scope, results) {
     return;
   }
   for (const entry of entries) {
-    const skillFile = join12(skillsDir, entry, "SKILL.md");
-    if (!existsSync13(skillFile)) continue;
+    const skillFile = join14(skillsDir, entry, "SKILL.md");
+    if (!existsSync14(skillFile)) continue;
     try {
       const raw = readFileSync5(skillFile, "utf-8");
       const content = stripFrontmatter(raw).trim();
@@ -2714,7 +2876,7 @@ function scanClaudeSkills(skillsDir, scope, results) {
   }
 }
 function scanSingleFile(filePath, platform, scope, results) {
-  if (!existsSync13(filePath)) return;
+  if (!existsSync14(filePath)) return;
   let raw;
   try {
     raw = readFileSync5(filePath, "utf-8");
@@ -2765,10 +2927,7 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
 ).option("--type <type>", "Content type: skill or rule", "skill").option("-m, --message <message>", "Version message").action(
   async (fileArg, opts) => {
     const client = new ApiClient();
-    if (!client.isAuthenticated()) {
-      console.error("Not authenticated. Run `localskills login` first.");
-      process.exit(1);
-    }
+    requireAuth(client);
     const teamsRes = await client.get("/api/tenants");
     if (!teamsRes.success || !teamsRes.data || teamsRes.data.length === 0) {
       console.error(
@@ -2779,8 +2938,8 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
     }
     const teams = teamsRes.data;
     if (fileArg) {
-      const filePath = resolve3(fileArg);
-      if (!existsSync14(filePath)) {
+      const filePath = resolve4(fileArg);
+      if (!existsSync15(filePath)) {
         console.error(`File not found: ${filePath}`);
         process.exit(1);
         return;
@@ -2793,7 +2952,7 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
         return;
       }
       const defaultSlug = basename2(filePath, extname2(filePath));
-      const defaultName = defaultSlug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      const defaultName = titleFromSlug(defaultSlug);
       const skillName = opts.name || defaultName;
       const contentType = validateContentType(opts.type || "skill");
       const visibility = validateVisibility(opts.visibility || "private");
@@ -2819,7 +2978,7 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
         Le("Nothing to publish.");
         return;
       }
-      const selected = await je({
+      const skills = cancelGuard(await je({
         message: "Select items to publish",
         options: detected.map((s) => ({
           value: s,
@@ -2827,28 +2986,19 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
           hint: `${s.platform}/${s.scope}/${s.contentType}  ${shortenPath(s.filePath)}`
         })),
         required: true
-      });
-      if (Ct(selected)) {
-        Ne("Cancelled.");
-        process.exit(0);
-      }
-      const skills = selected;
+      }));
       const tenantId = await resolveTeam(teams, opts.team);
       for (const skill of skills) {
         R2.step(`Publishing ${skill.suggestedName}...`);
-        const name = await Ze({
+        const name = cancelGuard(await Ze({
           message: "Skill name?",
           initialValue: skill.suggestedName,
           validate: (v) => {
             if (!v || v.length < 1) return "Name is required";
             if (v.length > 100) return "Name must be 100 characters or less";
           }
-        });
-        if (Ct(name)) {
-          Ne("Cancelled.");
-          process.exit(0);
-        }
-        const visibility = await Je({
+        }));
+        const visibility = cancelGuard(await Je({
           message: "Visibility?",
           options: [
             { value: "private", label: "Private", hint: "Only team members" },
@@ -2856,23 +3006,15 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
             { value: "unlisted", label: "Unlisted", hint: "Accessible via direct link" }
           ],
           initialValue: "private"
-        });
-        if (Ct(visibility)) {
-          Ne("Cancelled.");
-          process.exit(0);
-        }
-        const contentType = await Je({
+        }));
+        const contentType = cancelGuard(await Je({
           message: "Type?",
           options: [
             { value: "skill", label: "Skill", hint: "Reusable agent instructions" },
             { value: "rule", label: "Rule", hint: "Governance constraints" }
           ],
           initialValue: skill.contentType
-        });
-        if (Ct(contentType)) {
-          Ne("Cancelled.");
-          process.exit(0);
-        }
+        }));
         await uploadSkill(client, {
           name,
           content: skill.content,
@@ -2897,19 +3039,14 @@ async function resolveTeam(teams, teamFlag) {
   if (teams.length === 1) {
     return teams[0].id;
   }
-  const selected = await Je({
+  return cancelGuard(await Je({
     message: "Which team?",
     options: teams.map((t) => ({
       value: t.id,
       label: t.name,
       hint: t.slug
     }))
-  });
-  if (Ct(selected)) {
-    Ne("Cancelled.");
-    process.exit(0);
-  }
-  return selected;
+  }));
 }
 async function uploadSkill(client, params) {
   const spinner = bt2();
@@ -2954,8 +3091,200 @@ function shortenPath(filePath) {
   return filePath;
 }
 
+// src/commands/push.ts
+import { Command as Command7 } from "commander";
+import { readFileSync as readFileSync7, existsSync as existsSync16 } from "fs";
+import { resolve as resolve5 } from "path";
+var pushCommand = new Command7("push").description("Push a new version of an existing skill").argument("<file>", "Path to the skill file").requiredOption("-s, --skill <id>", "Skill ID or slug").option("--version <semver>", "Explicit semver (e.g., 1.1.0)").option("--patch", "Bump patch version").option("--minor", "Bump minor version").option("--major", "Bump major version").option("-m, --message <message>", "Version message").action(
+  async (fileArg, opts) => {
+    const client = new ApiClient();
+    requireAuth(client);
+    const filePath = resolve5(fileArg);
+    if (!existsSync16(filePath)) {
+      console.error(`File not found: ${filePath}`);
+      process.exit(1);
+      return;
+    }
+    const raw = readFileSync7(filePath, "utf-8");
+    const content = stripFrontmatter(raw).trim();
+    if (!content) {
+      console.error("File is empty after stripping frontmatter.");
+      process.exit(1);
+      return;
+    }
+    const bumpFlags = [opts.patch, opts.minor, opts.major].filter(Boolean);
+    if (opts.version && bumpFlags.length > 0) {
+      console.error("Cannot specify both --version and --patch/--minor/--major");
+      process.exit(1);
+      return;
+    }
+    let body = {
+      content,
+      message: opts.message
+    };
+    if (opts.version) {
+      if (!isValidSemVer(opts.version)) {
+        console.error(`Invalid semver format: ${opts.version}. Expected X.Y.Z`);
+        process.exit(1);
+        return;
+      }
+      body.semver = opts.version;
+    } else if (opts.major) {
+      body.bump = "major";
+    } else if (opts.minor) {
+      body.bump = "minor";
+    } else if (opts.patch) {
+      body.bump = "patch";
+    }
+    const spinner = bt2();
+    spinner.start("Pushing new version...");
+    const res = await client.post(
+      `/api/skills/${encodeURIComponent(opts.skill)}/versions`,
+      body
+    );
+    if (!res.success || !res.data) {
+      spinner.stop(`Failed: ${res.error || "Unknown error"}`);
+      process.exit(1);
+      return;
+    }
+    const v = res.data;
+    spinner.stop(`Pushed ${formatVersionLabel(v.semver, v.version)}`);
+    Le("Done!");
+  }
+);
+
+// src/commands/share.ts
+import { Command as Command8 } from "commander";
+import { readFileSync as readFileSync8, existsSync as existsSync17 } from "fs";
+import { resolve as resolve6, basename as basename3, extname as extname3 } from "path";
+import { generateKeyPairSync } from "crypto";
+var shareCommand = new Command8("share").description("Share a skill anonymously (no login required)").argument("[file]", "Path to a specific file to share").option("-n, --name <name>", "Skill name").option("--type <type>", "Content type: skill or rule", "skill").action(async (fileArg, opts) => {
+  We("localskills share");
+  await ensureAnonymousIdentity();
+  const client = new ApiClient();
+  if (fileArg) {
+    const filePath = resolve6(fileArg);
+    if (!existsSync17(filePath)) {
+      R2.error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+    const raw = readFileSync8(filePath, "utf-8");
+    const content = stripFrontmatter(raw).trim();
+    if (!content) {
+      R2.error("File is empty after stripping frontmatter.");
+      process.exit(1);
+    }
+    const defaultSlug = basename3(filePath, extname3(filePath));
+    const defaultName = titleFromSlug(defaultSlug);
+    const skillName = opts.name || defaultName;
+    const contentType = opts.type === "rule" ? "rule" : "skill";
+    await uploadAnonymousSkill(client, { name: skillName, content, type: contentType });
+  } else {
+    const spinner = bt2();
+    spinner.start("Scanning for skills...");
+    const config = loadConfig();
+    const allDetected = scanForSkills();
+    const detected = filterTracked(allDetected, config);
+    spinner.stop(
+      detected.length > 0 ? `Found ${detected.length} skill file${detected.length !== 1 ? "s" : ""}.` : "No skill files found."
+    );
+    if (detected.length === 0) {
+      Le("Nothing to share. Pass a file path: localskills share <file>");
+      return;
+    }
+    const selected = cancelGuard(
+      await Je({
+        message: "Select a skill to share",
+        options: detected.map((s) => ({
+          value: s,
+          label: s.suggestedName,
+          hint: `${s.platform} \xB7 ${s.contentType}`
+        }))
+      })
+    );
+    const name = cancelGuard(
+      await Ze({
+        message: "Skill name?",
+        initialValue: selected.suggestedName,
+        validate: (v) => {
+          if (!v || v.length < 1) return "Name is required";
+          if (v.length > 100) return "Name must be 100 characters or less";
+        }
+      })
+    );
+    await uploadAnonymousSkill(client, {
+      name,
+      content: selected.content,
+      type: selected.contentType
+    });
+  }
+  Le("Done!");
+});
+async function ensureAnonymousIdentity() {
+  const config = loadConfig();
+  if (config.token) {
+    const client = new ApiClient();
+    const res2 = await client.get("/api/cli/auth");
+    if (res2.success) return;
+  }
+  let keyPair = getAnonymousKey();
+  if (!keyPair) {
+    const s2 = bt2();
+    s2.start("Generating anonymous identity...");
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+      publicKeyEncoding: { type: "spki", format: "der" },
+      privateKeyEncoding: { type: "pkcs8", format: "der" }
+    });
+    const rawPubKey = publicKey.subarray(publicKey.length - 32);
+    const rawPrivKey = privateKey.subarray(privateKey.length - 32);
+    keyPair = {
+      publicKey: rawPubKey.toString("base64"),
+      privateKey: rawPrivKey.toString("base64")
+    };
+    setAnonymousKey(keyPair);
+    s2.stop("Identity created.");
+  }
+  const s = bt2();
+  s.start("Connecting to localskills.sh...");
+  const tempClient = new ApiClient();
+  const res = await tempClient.post("/api/cli/auth/anonymous", {
+    publicKey: keyPair.publicKey,
+    algorithm: "Ed25519"
+  });
+  if (!res.success || !res.data) {
+    s.stop(`Registration failed: ${res.error || "Unknown error"}`);
+    process.exit(1);
+  }
+  setToken(res.data.token);
+  s.stop(`Connected as ${res.data.username}`);
+}
+async function uploadAnonymousSkill(client, params) {
+  const s = bt2();
+  s.start(`Sharing "${params.name}"...`);
+  const teamsRes = await client.get("/api/tenants");
+  if (!teamsRes.success || !teamsRes.data || teamsRes.data.length === 0) {
+    s.stop("Failed to find your team. Try running `localskills share` again.");
+    process.exit(1);
+  }
+  const tenantId = teamsRes.data[0].id;
+  const res = await client.post("/api/skills", {
+    name: params.name,
+    content: params.content,
+    tenantId,
+    visibility: "unlisted",
+    type: params.type
+  });
+  if (!res.success || !res.data) {
+    s.stop(`Failed: ${res.error || "Unknown error"}`);
+    return;
+  }
+  s.stop("Shared!");
+  R2.success(`URL:     https://localskills.sh/s/${res.data.publicId}`);
+  R2.info(`Install: localskills install ${res.data.publicId}`);
+}
+
 // src/index.ts
-var program = new Command7();
+var program = new Command9();
 program.name("localskills").description("Install and manage agent skills from localskills.sh").version("0.1.0");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
@@ -2965,4 +3294,6 @@ program.addCommand(uninstallCommand);
 program.addCommand(listCommand);
 program.addCommand(pullCommand);
 program.addCommand(publishCommand);
+program.addCommand(pushCommand);
+program.addCommand(shareCommand);
 program.parse();