itismyskillmarket 1.3.0 → 1.3.2

package/dist/index.js

@@ -2,6 +2,17 @@
 
 // src/cli.ts
 import { Command } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+
+// src/commands/registry.ts
+import fs2 from "fs-extra";
+
+// src/utils/dirs.ts
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
 
 // src/constants.ts
 var MARKET_DIR = "skillmarket";
@@ -30,13 +41,7 @@ var PLATFORMS = [
 var REGISTRY_FILE = "registry.json";
 var LATEST_LINK = "latest";
 
-// src/commands/registry.ts
-import fs2 from "fs-extra";
-
 // src/utils/dirs.ts
-import os from "os";
-import path from "path";
-import fs from "fs-extra";
 function getMarketHome() {
   return path.join(os.homedir(), MARKET_DIR);
 }
@@ -95,7 +100,7 @@ async function isSkillInstalled(skillId) {
 import https from "https";
 import { URL } from "url";
 async function fetchNpmPackage(packageName) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const isScoped = packageName.startsWith("@");
     let encodedName;
     if (isScoped) {
@@ -121,12 +126,12 @@ async function fetchNpmPackage(packageName) {
         try {
           const parsed = JSON.parse(data);
           if (parsed.error) {
-            resolve(null);
+            resolve2(null);
             return;
           }
-          resolve(parsed);
+          resolve2(parsed);
         } catch {
-          resolve(null);
+          resolve2(null);
         }
       });
     });
@@ -137,12 +142,46 @@ async function fetchNpmPackage(packageName) {
     });
   });
 }
-async function searchSkillmarketPackages() {
+var SKILL_SCOPES = [
+  "@wanxuchen",
+  // 原作者 scope
+  "@itismyskillmarket",
+  // 当前包名 scope
+  "@thisisskillmarket",
+  // 曾用 scope
+  "@this-is-skillmarket",
+  // 曾用 scope (带横线)
+  "@skillmarket"
+  // 通用 scope
+];
+function getPossiblePackageNames(skillId) {
+  if (skillId.startsWith("@")) {
+    return [skillId];
+  }
+  return SKILL_SCOPES.map((scope) => `${scope}/${skillId}`);
+}
+async function fetchSkillPackage(skillId) {
+  const packageNames = getPossiblePackageNames(skillId);
+  for (const packageName of packageNames) {
+    try {
+      const info = await fetchNpmPackage(packageName);
+      if (info) {
+        return info;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function searchSkillmarketPackages(options = {}) {
+  const { from = 0, size = 100, keyword } = options;
   const packages = [];
-  return new Promise((resolve, reject) => {
+  let total = 0;
+  return new Promise((resolve2, reject) => {
     const url = new URL("https://registry.npmjs.org/-/v1/search");
     url.searchParams.set("text", "keywords:skillmarket");
-    url.searchParams.set("size", "100");
+    url.searchParams.set("size", String(Math.max(size, 100)));
+    url.searchParams.set("from", String(from));
     const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
       let data = "";
       res.on("data", (chunk) => {
@@ -151,14 +190,32 @@ async function searchSkillmarketPackages() {
       res.on("end", () => {
         try {
           const result = JSON.parse(data);
-          for (const item of result.objects || []) {
-            if (item?.package?.name) {
-              packages.push(item.package.name);
+          let filteredTotal = 0;
+          if (result.objects) {
+            for (const item of result.objects) {
+              if (item?.package?.name) {
+                const pkgName = item.package.name;
+                const pkgDesc = item.package.description || "";
+                if (keyword) {
+                  const lowerKeyword = keyword.toLowerCase();
+                  const shortName = pkgName.includes("/") ? pkgName.split("/")[1] : pkgName;
+                  const nameMatch = shortName.toLowerCase().includes(lowerKeyword) || pkgName.toLowerCase().includes(lowerKeyword);
+                  const descMatch = pkgDesc.toLowerCase().includes(lowerKeyword);
+                  if (nameMatch || descMatch) {
+                    packages.push(pkgName);
+                    filteredTotal++;
+                  }
+                } else {
+                  packages.push(pkgName);
+                  filteredTotal++;
+                }
+              }
             }
           }
-          resolve(packages);
+          total = filteredTotal;
+          resolve2({ packages, total });
         } catch {
-          resolve([]);
+          resolve2({ packages: [], total: 0 });
         }
       });
     });
@@ -171,33 +228,128 @@ async function searchSkillmarketPackages() {
 }
 
 // src/commands/ls.ts
+function filterInstalledSkills(skills, keyword) {
+  const lower = keyword.toLowerCase();
+  return skills.filter(
+    (s) => s.id.toLowerCase().includes(lower) || s.displayName && s.displayName.toLowerCase().includes(lower) || s.description && s.description.toLowerCase().includes(lower)
+  );
+}
 async function listSkills(options) {
-  const { installed, updates } = options;
+  const { installed, updates, page = 1, limit = 20, search } = options;
   if (installed) {
-    const skills = await getInstalledSkills();
+    let skills = await getInstalledSkills();
+    if (search) {
+      skills = filterInstalledSkills(skills, search);
+    }
+    const total = skills.length;
+    const totalPages = Math.ceil(total / limit) || 1;
+    const currentPage = Math.min(Math.max(1, page), totalPages);
     if (skills.length === 0) {
-      console.log('No skills installed yet. Run "skm --ls" to see available skills.');
+      if (search) {
+        console.log(`No skills found matching "${search}".`);
+      } else {
+        console.log('No skills installed yet. Run "skm ls" to see available skills.');
+      }
       return;
     }
-    console.log("Installed Skills:\n");
-    for (const skill of skills) {
+    if (search) {
+      console.log(`Found ${total} match(es) for "${search}":
+`);
+    } else {
+      console.log(`Installed Skills (${total}):
+`);
+    }
+    const start = (currentPage - 1) * limit;
+    const end = Math.min(start + limit, total);
+    const pageSkills = skills.slice(start, end);
+    for (const skill of pageSkills) {
       console.log(`  ${skill.id}@${skill.version}`);
       console.log(`    Platforms: ${skill.platforms.join(", ")}`);
       console.log(`    Installed: ${skill.installedAt}`);
       console.log();
     }
+    console.log(`Page ${currentPage}/${totalPages} (${limit} per page) | Use --page N to navigate`);
     return;
   }
-  console.log("Searching npm registry...\n");
+  if (search) {
+    console.log(`Searching npm for "${search}"...
+`);
+  } else {
+    console.log("Searching npm registry...\n");
+  }
   try {
-    const packages = await searchSkillmarketPackages();
+    const offset = (page - 1) * limit;
+    const { packages, total } = await searchSkillmarketPackages({
+      from: offset,
+      size: limit,
+      keyword: search
+    });
+    const totalPages = Math.ceil(total / limit) || 1;
+    const currentPage = Math.min(Math.max(1, page), totalPages);
     if (packages.length === 0) {
-      console.log("No skills found. Check back later!");
+      if (search) {
+        console.log(`No skills found matching "${search}".`);
+      } else {
+        console.log("No skills found. Check back later!");
+      }
       return;
     }
-    console.log(`Found ${packages.length} skill(s):
+    if (search) {
+      console.log(`Found ${total} match(es) for "${search}":
 `);
+    } else {
+      console.log(`Found ${total} skill(s):
+`);
+    }
     for (const pkgName of packages) {
+      try {
+        const info = await fetchNpmPackage(pkgName);
+        if (!info) {
+          console.log(`\u{1F4E6} ${pkgName} (\u4FE1\u606F\u83B7\u53D6\u5931\u8D25)`);
+          console.log();
+          continue;
+        }
+        const latestVersion = info["dist-tags"]?.latest || "unknown";
+        const pkg = info.versions?.[latestVersion];
+        const skillMeta = pkg?.skillmarket;
+        console.log(`\u{1F4E6} ${info.name}@${latestVersion}`);
+        const displayName = skillMeta?.displayName || info.name;
+        console.log(`   \u540D\u79F0: ${displayName}`);
+        console.log(`   \u63CF\u8FF0: ${pkg?.description || "N/A"}`);
+        const platforms = skillMeta?.platforms || [];
+        console.log(`   \u5E73\u53F0: ${platforms.length > 0 ? platforms.join(", ") : "N/A"}`);
+        const npmLink = pkg?.links?.npm || `https://www.npmjs.com/package/${info.name}`;
+        console.log(`   \u94FE\u63A5: ${npmLink}`);
+        console.log();
+      } catch (e) {
+        console.log(`\u{1F4E6} ${pkgName} (\u83B7\u53D6\u5931\u8D25: ${e})`);
+        console.log();
+      }
+    }
+    console.log(`Page ${currentPage}/${totalPages} (${limit} per page) | Use --page N to navigate`);
+  } catch (error) {
+    console.log(`Error fetching skills: ${error}`);
+  }
+}
+
+// src/commands/search.ts
+async function searchSkills(keyword, options = {}) {
+  const limit = options.limit ?? 20;
+  console.log(`Searching for "${keyword}"...
+`);
+  try {
+    const { packages } = await searchSkillmarketPackages({ keyword });
+    const filtered = packages.filter(
+      (pkg) => pkg.toLowerCase().includes(keyword.toLowerCase())
+    );
+    if (filtered.length === 0) {
+      console.log(`No skills found matching "${keyword}".`);
+      return;
+    }
+    const results = filtered.slice(0, limit);
+    console.log(`Found ${filtered.length} skill(s) (showing ${results.length}):
+`);
+    for (const pkgName of results) {
       const info = await fetchNpmPackage(pkgName);
       if (info && info["dist-tags"]?.latest) {
         const latestVersion = info["dist-tags"].latest;
@@ -208,17 +360,16 @@ async function listSkills(options) {
       }
     }
   } catch (error) {
-    console.log(`Error fetching skills: ${error}`);
+    console.log(`Error searching skills: ${error}`);
   }
 }
 
 // src/commands/info.ts
 async function showSkillInfo(skillId) {
-  const packageName = skillId.startsWith("@") ? skillId : `@skillmarket/${skillId}`;
-  console.log(`Fetching info for: ${packageName}
+  console.log(`Fetching info for: ${skillId}
 `);
   try {
-    const info = await fetchNpmPackage(packageName);
+    const info = await fetchSkillPackage(skillId);
     if (!info) {
       console.log(`Skill "${skillId}" not found in npm registry.`);
       return;
@@ -258,174 +409,344 @@ Status: Not installed (use skm install ${skillId} to install)`);
 }
 
 // src/commands/install.ts
-import fs4 from "fs-extra";
-import path3 from "path";
+import fs7 from "fs-extra";
+import path6 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
-// src/utils/platform.ts
-function detectPlatform() {
-  if (process.env.OPENCODE) return "opencode";
-  if (process.env.CURSOR) return "cursor";
-  if (process.env.VSCODE) return "vscode";
-  if (process.env.CLAUDE_CODE) return "claude";
-  if (process.env.ANTIGRAVITY) return "antigravity";
-  return "codex";
-}
-function isValidPlatform(name) {
-  return PLATFORMS.includes(name);
-}
-function getPlatformFromInput(name) {
-  const lowerName = name.toLowerCase();
-  if (isValidPlatform(lowerName)) {
-    return lowerName;
-  }
-  return null;
-}
-
-// src/commands/sync.ts
+// src/adapters/base.ts
 import fs3 from "fs-extra";
 import path2 from "path";
-async function syncPlatformLinks(targetPlatform) {
-  await ensureMarketDirs();
-  const skillsDir = getSkillsDir();
-  const platformLinksDir = getPlatformLinksDir();
-  const registry = await loadRegistry();
-  let platformsToSync;
-  if (targetPlatform) {
-    const parsed = getPlatformFromInput(targetPlatform);
-    if (!parsed) {
-      console.warn(`Invalid platform: ${targetPlatform}, syncing all platforms`);
-      platformsToSync = PLATFORMS;
-    } else {
-      platformsToSync = [parsed];
+var BaseAdapter = class {
+  /**
+   * Get the path where a specific skill should be installed
+   */
+  getSkillPath(skillId) {
+    return path2.join(this.skillDir, skillId);
+  }
+  /**
+   * Get the path to the SKILL.md file for a skill
+   */
+  getSkillFilePath(skillId) {
+    return path2.join(this.getSkillPath(skillId), "SKILL.md");
+  }
+  async isAvailable() {
+    try {
+      await fs3.ensureDir(this.skillDir);
+      return true;
+    } catch {
+      return false;
     }
-  } else {
-    platformsToSync = PLATFORMS;
   }
-  const targetDesc = targetPlatform ? targetPlatform : "all platforms";
-  console.log(`Syncing platform links to ${targetDesc}...
-`);
-  for (const platform of platformsToSync) {
-    const platformDir = path2.join(platformLinksDir, platform, "skills");
-    await fs3.ensureDir(platformDir);
-    for (const [skillId, skillInfo] of Object.entries(registry.skills)) {
-      const skillLatestLink = path2.join(skillsDir, skillId, LATEST_LINK);
-      const targetPlatformDir = path2.join(skillLatestLink, platform);
-      const platformSkillDir = path2.join(platformDir, skillId);
-      if (await fs3.pathExists(skillLatestLink)) {
-        if (await fs3.pathExists(targetPlatformDir)) {
-          try {
-            await fs3.remove(platformSkillDir);
-            await fs3.symlink(targetPlatformDir, platformSkillDir, "junction");
-            console.log(`  Linked: ${platform}/${skillId}`);
-          } catch {
-            await fs3.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
-            console.log(`  Copied: ${platform}/${skillId}`);
-          }
+  async isInstalled(skillId) {
+    const skillFile = this.getSkillFilePath(skillId);
+    return fs3.pathExists(skillFile);
+  }
+  async install(skillId, sourceDir) {
+    const targetDir = this.getSkillPath(skillId);
+    const targetFile = this.getSkillFilePath(skillId);
+    await fs3.ensureDir(targetDir);
+    const sourceFile = path2.join(sourceDir, "SKILL.md");
+    if (!await fs3.pathExists(sourceFile)) {
+      throw new Error(`SKILL.md not found in ${sourceDir}`);
+    }
+    await fs3.copy(sourceFile, targetFile, { overwrite: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = this.getSkillPath(skillId);
+    if (await fs3.pathExists(targetDir)) {
+      await fs3.remove(targetDir);
+    }
+  }
+  async listInstalled() {
+    if (!await fs3.pathExists(this.skillDir)) {
+      return [];
+    }
+    const entries = await fs3.readdir(this.skillDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillFile = path2.join(this.skillDir, entry.name, "SKILL.md");
+        if (await fs3.pathExists(skillFile)) {
+          skills.push(entry.name);
         }
       }
     }
+    return skills;
   }
-  console.log("\n\u2705 Sync complete!");
+};
+
+// src/adapters/opencode.ts
+import path3 from "path";
+import os2 from "os";
+import fs4 from "fs-extra";
+var OpenCodeAdapter = class extends BaseAdapter {
+  id = "opencode";
+  name = "OpenCode";
+  get skillDir() {
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os2.homedir(), ".config", "opencode");
+    return path3.join(configDir, "skills");
+  }
+  async isAvailable() {
+    if (process.env.OPENCODE) return true;
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os2.homedir(), ".config", "opencode");
+    try {
+      await fs4.ensureDir(path3.join(configDir, "skills"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapters/claude.ts
+import path4 from "path";
+import os3 from "os";
+import fs5 from "fs-extra";
+var ClaudeAdapter = class extends BaseAdapter {
+  id = "claude";
+  name = "Claude Code";
+  get skillDir() {
+    return path4.join(os3.homedir(), ".claude", "skills");
+  }
+  async isAvailable() {
+    if (process.env.CLAUDE_CODE) return true;
+    const claudeDir = path4.join(os3.homedir(), ".claude");
+    return fs5.pathExists(claudeDir);
+  }
+};
+
+// src/adapters/vscode.ts
+import path5 from "path";
+import os4 from "os";
+import fs6 from "fs-extra";
+var VSCodeAdapter = class extends BaseAdapter {
+  id = "vscode";
+  name = "VSCode";
+  get skillDir() {
+    return path5.join(os4.homedir(), ".copilot", "skills");
+  }
+  async isAvailable() {
+    const possibleDirs = [
+      path5.join(os4.homedir(), ".copilot", "skills"),
+      path5.join(os4.homedir(), ".claude", "skills")
+    ];
+    for (const dir of possibleDirs) {
+      try {
+        await fs6.ensureDir(dir);
+        return true;
+      } catch {
+        continue;
+      }
+    }
+    return false;
+  }
+  async install(skillId, sourceDir) {
+    await super.install(skillId, sourceDir);
+    const claudeSkillDir = path5.join(os4.homedir(), ".claude", "skills");
+    const targetPath = this.getSkillPath(skillId);
+    const claudeTargetPath = path5.join(claudeSkillDir, skillId);
+    try {
+      await fs6.ensureDir(claudeSkillDir);
+      await fs6.remove(claudeTargetPath);
+      await fs6.symlink(targetPath, claudeTargetPath, "junction");
+    } catch {
+    }
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = /* @__PURE__ */ new Map();
+function registerAdapters() {
+  const opencode = new OpenCodeAdapter();
+  const claude = new ClaudeAdapter();
+  const vscode = new VSCodeAdapter();
+  adapters.set(opencode.id, opencode);
+  adapters.set(claude.id, claude);
+  adapters.set(vscode.id, vscode);
+}
+registerAdapters();
+async function detectPlatforms() {
+  const available = [];
+  for (const adapter of adapters.values()) {
+    if (await adapter.isAvailable()) {
+      available.push(adapter);
+    }
+  }
+  return available;
+}
+function getAdapterByPlatform(platform) {
+  const idMap = {
+    opencode: "opencode",
+    claude: "claude",
+    vscode: "vscode",
+    cursor: "opencode",
+    // Cursor uses OpenCode-compatible structure
+    codex: "opencode",
+    // Codex uses OpenCode-compatible structure
+    antigravity: "opencode"
+    // Antigravity uses OpenCode-compatible structure
+  };
+  return adapters.get(idMap[platform]);
 }
 
 // src/commands/install.ts
 var execAsync = promisify(exec);
-async function installSkill(skillId, version, targetPlatform) {
+async function installSkill(skillId, version, options) {
   await ensureMarketDirs();
-  const isScoped = skillId.startsWith("@");
-  const packageName = isScoped ? skillId : `@skillmarket/${skillId}`;
-  const shortName = skillId;
-  console.log(`Installing ${packageName}${version ? `@${version}` : ""}...`);
-  const pkgInfo = await fetchNpmPackage(packageName);
+  console.log(`Installing ${skillId}${version ? `@${version}` : ""}...`);
+  const pkgInfo = await fetchSkillPackage(skillId);
   if (!pkgInfo) {
-    throw new Error(`Package ${packageName} not found`);
+    throw new Error(`Package ${skillId} not found`);
   }
+  const packageName = pkgInfo.name;
   const targetVersion = version || pkgInfo["dist-tags"]?.latest;
   if (!targetVersion) {
     throw new Error(`No version found for ${packageName}`);
   }
   const cacheDir = getCacheDir();
-  const targetDir = path3.join(cacheDir, `${packageName}@${targetVersion}`);
-  if (!await fs4.pathExists(targetDir)) {
+  const targetDir = path6.join(cacheDir, `${packageName}@${targetVersion}`);
+  if (!await fs7.pathExists(targetDir)) {
     console.log("Downloading package...");
-    await fs4.ensureDir(cacheDir);
+    await fs7.ensureDir(cacheDir);
     try {
       await execAsync(`npm pack ${packageName}@${targetVersion} --pack-destination ${cacheDir}`);
-      const files = await fs4.readdir(cacheDir);
+      const files = await fs7.readdir(cacheDir);
       const tarball = files.find(
-        (f) => f.endsWith(".tgz") && f.includes(packageName.replace("/", "-"))
+        (f) => f.endsWith(".tgz") && f.includes(packageName.replace(/^@/, "").replace("/", "-"))
       );
       if (tarball) {
-        await execAsync(`tar -xzf "${path3.join(cacheDir, tarball)}" -C "${cacheDir}"`);
-        await fs4.remove(path3.join(cacheDir, tarball));
-        const extractedDir = path3.join(cacheDir, "package");
+        await execAsync(`tar -xzf "${path6.join(cacheDir, tarball)}" -C "${cacheDir}"`);
+        await fs7.remove(path6.join(cacheDir, tarball));
+        const extractedDir = path6.join(cacheDir, "package");
         const finalDir = targetDir;
-        await fs4.move(extractedDir, finalDir, { overwrite: true });
+        await fs7.move(extractedDir, finalDir, { overwrite: true });
       }
     } catch (err) {
       throw new Error(`Failed to download package: ${err}`);
     }
   }
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path3.join(skillsDir, `${skillId}@${targetVersion}`);
+  const skillVersionDir = path6.join(skillsDir, `${skillId}@${targetVersion}`);
   console.log("Setting up skill...");
-  await fs4.ensureDir(skillVersionDir);
+  await fs7.ensureDir(skillVersionDir);
   const pkgRoot = targetDir;
-  if (await fs4.pathExists(path3.join(pkgRoot, "SKILL.md"))) {
-    await fs4.copy(
-      path3.join(pkgRoot, "SKILL.md"),
-      path3.join(skillVersionDir, "SKILL.md")
+  if (await fs7.pathExists(path6.join(pkgRoot, "SKILL.md"))) {
+    await fs7.copy(
+      path6.join(pkgRoot, "SKILL.md"),
+      path6.join(skillVersionDir, "SKILL.md")
     );
   }
-  if (await fs4.pathExists(path3.join(pkgRoot, "metadata.json"))) {
-    await fs4.copy(
-      path3.join(pkgRoot, "metadata.json"),
-      path3.join(skillVersionDir, "metadata.json")
+  if (await fs7.pathExists(path6.join(pkgRoot, "metadata.json"))) {
+    await fs7.copy(
+      path6.join(pkgRoot, "metadata.json"),
+      path6.join(skillVersionDir, "metadata.json")
     );
   }
-  const skillDir = path3.join(skillsDir, skillId);
-  await fs4.ensureDir(skillDir);
-  const latestLink = path3.join(skillDir, LATEST_LINK);
+  const skillDir = path6.join(skillsDir, skillId);
+  await fs7.ensureDir(skillDir);
+  const latestLink = path6.join(skillDir, LATEST_LINK);
   try {
-    await fs4.remove(latestLink);
-    await fs4.symlink(skillVersionDir, latestLink, "junction");
+    await fs7.remove(latestLink);
+    await fs7.symlink(skillVersionDir, latestLink, "junction");
   } catch {
-    await fs4.copy(skillVersionDir, path3.join(skillDir, LATEST_LINK), { overwrite: true });
+    await fs7.copy(skillVersionDir, path6.join(skillDir, LATEST_LINK), { overwrite: true });
   }
-  let finalPlatform;
-  if (targetPlatform) {
-    const parsed = getPlatformFromInput(targetPlatform);
-    if (!parsed) {
-      throw new Error(`Invalid platform: ${targetPlatform}. Valid platforms: ${PLATFORMS.join(", ")}`);
+  let targetAdapters = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    for (const platformStr of options.platforms) {
+      const platform = platformStr;
+      const adapter = getAdapterByPlatform(platform);
+      if (adapter) {
+        targetAdapters.push(adapter);
+      } else {
+        console.warn(`\u26A0\uFE0F  Unknown platform: ${platformStr}`);
+      }
     }
-    finalPlatform = parsed;
   } else {
-    finalPlatform = detectPlatform();
+    targetAdapters = await detectPlatforms();
+  }
+  if (targetAdapters.length === 0) {
+    console.log("No target platforms detected.");
+    console.log("Use --platform to specify platforms manually.");
+  } else {
+    console.log(`
+Installing to ${targetAdapters.length} platform(s)...
+`);
+    const results = [];
+    for (const adapter of targetAdapters) {
+      try {
+        const isInstalled = await adapter.isInstalled(skillId);
+        if (isInstalled && !options?.force) {
+          console.log(`${adapter.name.padEnd(12)} \u26A0\uFE0F  Already installed (use --force to overwrite)`);
+          results.push({ name: adapter.name, status: "skipped" });
+          continue;
+        }
+        await adapter.install(skillId, skillVersionDir);
+        console.log(`${adapter.name.padEnd(12)} \u2705  Installed successfully`);
+        results.push({ name: adapter.name, status: "installed" });
+      } catch (error) {
+        console.log(`${adapter.name.padEnd(12)} \u274C  Failed: ${error}`);
+        results.push({ name: adapter.name, status: "failed", error: String(error) });
+      }
+    }
+    const installed = results.filter((r) => r.status === "installed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    console.log(`
+\u{1F4CA} Summary: ${installed} installed, ${skipped} skipped, ${failed} failed`);
   }
-  console.log(`Target platform: ${finalPlatform}`);
   const registry = await loadRegistry();
-  const existingSkill = registry.skills[skillId];
-  const existingPlatforms = existingSkill?.platforms || [];
+  const installedPlatforms = targetAdapters.map((a) => a.id);
   registry.skills[skillId] = {
     id: skillId,
     version: targetVersion,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    platforms: existingPlatforms.includes(finalPlatform) ? existingPlatforms : [...existingPlatforms, finalPlatform]
+    platforms: installedPlatforms
   };
   await saveRegistry(registry);
-  console.log(`Syncing to ${finalPlatform}...`);
-  await syncPlatformLinks(finalPlatform);
   console.log(`
 \u2705 ${skillId}@${targetVersion} installed successfully!`);
   console.log(`   Use "skm info ${skillId}" for more details`);
 }
 
+// src/commands/sync.ts
+import fs8 from "fs-extra";
+import path7 from "path";
+async function syncPlatformLinks() {
+  await ensureMarketDirs();
+  const skillsDir = getSkillsDir();
+  const platformLinksDir = getPlatformLinksDir();
+  const registry = await loadRegistry();
+  console.log("Syncing platform links...\n");
+  for (const platform of PLATFORMS) {
+    const platformDir = path7.join(platformLinksDir, platform, "skills");
+    await fs8.ensureDir(platformDir);
+    for (const [skillId, skillInfo] of Object.entries(registry.skills)) {
+      const skillLatestLink = path7.join(skillsDir, skillId, LATEST_LINK);
+      const targetPlatformDir = path7.join(skillLatestLink, platform);
+      const platformSkillDir = path7.join(platformDir, skillId);
+      if (await fs8.pathExists(skillLatestLink)) {
+        if (await fs8.pathExists(targetPlatformDir)) {
+          try {
+            await fs8.remove(platformSkillDir);
+            await fs8.symlink(targetPlatformDir, platformSkillDir, "junction");
+            console.log(`  Linked: ${platform}/${skillId}`);
+          } catch {
+            await fs8.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
+            console.log(`  Copied: ${platform}/${skillId}`);
+          }
+        }
+      }
+    }
+  }
+  console.log("\n\u2705 Sync complete!");
+}
+
 // src/commands/update.ts
 async function updateSkill(skillId) {
   if (skillId) {
-    const pkgInfo = await fetchNpmPackage(`@skillmarket/${skillId}`);
+    const pkgInfo = await fetchNpmPackage(`@itismyskillmarket/${skillId}`);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
       console.log(`Updating ${skillId} to ${latestVersion}...`);
@@ -442,7 +763,7 @@ async function updateSkill(skillId) {
 `);
   let hasUpdates = false;
   for (const skill of installed) {
-    const pkgInfo = await fetchNpmPackage(`@skillmarket/${skill.id}`);
+    const pkgInfo = await fetchNpmPackage(`@wanxuchen/${skill.id}`);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
       if (latestVersion && latestVersion !== skill.version) {
@@ -464,118 +785,306 @@ async function updateSkill(skillId) {
 }
 
 // src/commands/uninstall.ts
-import fs5 from "fs-extra";
-import path4 from "path";
-async function uninstallSkill(skillId) {
+import fs9 from "fs-extra";
+import path8 from "path";
+import readline from "readline";
+async function askConfirmation(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function getUninstallPreview(skillId, options) {
+  const registry = await loadRegistry();
+  const skillInfo = registry.skills[skillId];
+  let platformNames = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    platformNames = options.platforms;
+  } else {
+    const adapters2 = await detectPlatforms();
+    platformNames = adapters2.map((a) => a.name);
+  }
+  const skillsDir = getSkillsDir();
+  const localPath = path8.join(skillsDir, skillId);
+  const platformLinksDir = getPlatformLinksDir();
+  const platformLinks = [];
+  for (const platform of PLATFORMS) {
+    const linkPath = path8.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs9.pathExists(linkPath)) {
+      platformLinks.push(linkPath);
+    }
+  }
+  return { skillInfo, platforms: platformNames, localPath, platformLinks };
+}
+async function uninstallSkill(skillId, options) {
   const registry = await loadRegistry();
   if (!(skillId in registry.skills)) {
-    console.log(`Skill "${skillId}" is not installed.`);
-    return;
+    console.log(`\u274C Skill "${skillId}" is not installed.`);
+    return false;
   }
   const skillInfo = registry.skills[skillId];
-  console.log(`Uninstalling ${skillId}@${skillInfo.version}...`);
+  if (options?.dryRun) {
+    const preview = await getUninstallPreview(skillId, options);
+    console.log(`
+\u{1F4CB} Uninstall Preview for "${skillId}":`);
+    console.log(`   Version: ${skillInfo.version}`);
+    console.log(`   Installed: ${skillInfo.installedAt}`);
+    console.log(`   Platforms (from registry): ${preview.platforms.join(", ") || "none"}`);
+    console.log(`
+   Local files to remove:`);
+    console.log(`   - ${preview.localPath}`);
+    if (preview.platformLinks.length > 0) {
+      console.log(`
+   Platform links to remove:`);
+      for (const link of preview.platformLinks) {
+        console.log(`   - ${link}`);
+      }
+    }
+    console.log(`
+\u26A0\uFE0F  This was a dry-run. No files were actually deleted.`);
+    return true;
+  }
+  if (!options?.yes) {
+    const confirmed = await askConfirmation(`Are you sure you want to uninstall "${skillId}"?`);
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return false;
+    }
+  }
+  console.log(`
+Uninstalling ${skillId}@${skillInfo.version}...`);
+  let targetAdapters = [];
+  let platformUninstallErrors = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    for (const platformStr of options.platforms) {
+      const platform = platformStr;
+      targetAdapters.push(getAdapterByPlatform(platform));
+    }
+  } else {
+    targetAdapters = await detectPlatforms();
+  }
+  const validAdapters = targetAdapters.filter((a) => a !== void 0);
+  if (validAdapters.length > 0) {
+    console.log(`
+Uninstalling from ${validAdapters.length} platform(s)...
+`);
+    for (const adapter of validAdapters) {
+      try {
+        await adapter.uninstall(skillId);
+        console.log(`${adapter.name.padEnd(12)} \u2705  Uninstalled`);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log(`${adapter.name.padEnd(12)} \u274C  Failed: ${errorMsg}`);
+        platformUninstallErrors.push({ name: adapter.name, error: errorMsg });
+      }
+    }
+  }
+  if (platformUninstallErrors.length > 0 && !options?.yes) {
+    const continueAnyway = await askConfirmation(
+      `\u26A0\uFE0F  ${platformUninstallErrors.length} platform(s) failed to uninstall. Continue with local cleanup?`
+    );
+    if (!continueAnyway) {
+      console.log("Uninstall aborted. Platform files may still exist.");
+      return false;
+    }
+  }
   const skillsDir = getSkillsDir();
-  const skillDir = path4.join(skillsDir, skillId);
-  await fs5.remove(skillDir);
+  const skillDir = path8.join(skillsDir, skillId);
+  if (await fs9.pathExists(skillDir)) {
+    await fs9.remove(skillDir);
+    console.log(`\u2705 Removed local files: ${skillDir}`);
+  }
   const platformLinksDir = getPlatformLinksDir();
+  let removedLinks = 0;
   for (const platform of PLATFORMS) {
-    const linkPath = path4.join(platformLinksDir, platform, "skills", skillId);
-    if (await fs5.pathExists(linkPath)) {
-      await fs5.remove(linkPath);
+    const linkPath = path8.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs9.pathExists(linkPath)) {
+      await fs9.remove(linkPath);
+      removedLinks++;
     }
   }
+  if (removedLinks > 0) {
+    console.log(`\u2705 Removed ${removedLinks} platform link(s)`);
+  }
   delete registry.skills[skillId];
   await saveRegistry(registry);
+  console.log(`\u2705 Registry updated`);
   console.log(`
 \u2705 ${skillId} uninstalled successfully!`);
+  return true;
 }
-
-// src/commands/search.ts
-async function searchSkills(keyword) {
-  console.log(`Searching for "${keyword}"...
-`);
-  try {
-    const packages = await searchSkillmarketPackages();
-    const filtered = packages.filter(
-      (pkg) => pkg.toLowerCase().includes(keyword.toLowerCase())
+async function uninstallAll(options) {
+  const registry = await loadRegistry();
+  const installedSkills = Object.keys(registry.skills);
+  if (installedSkills.length === 0) {
+    console.log("No skills installed.");
+    return { success: 0, failed: 0 };
+  }
+  console.log(`
+Found ${installedSkills.length} installed skill(s):`);
+  for (const skillId of installedSkills) {
+    const info = registry.skills[skillId];
+    console.log(`  - ${skillId}@${info.version}`);
+  }
+  if (options?.dryRun) {
+    console.log(`
+\u{1F4CB} Dry-run: Would uninstall ${installedSkills.length} skill(s).`);
+    console.log(`\u26A0\uFE0F  No files were actually deleted.`);
+    return { success: installedSkills.length, failed: 0 };
+  }
+  if (!options?.yes) {
+    const confirmed = await askConfirmation(
+      `
+\u26A0\uFE0F  Are you sure you want to uninstall ALL ${installedSkills.length} skill(s)? This action cannot be undone.`
     );
-    if (filtered.length === 0) {
-      console.log(`No skills found matching "${keyword}".`);
-      return;
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return { success: 0, failed: 0 };
     }
-    console.log(`Found ${filtered.length} skill(s):
+  }
+  console.log(`
+Uninstalling all skills...
 `);
-    for (const pkgName of filtered) {
-      const info = await fetchNpmPackage(pkgName);
-      if (info && info["dist-tags"]?.latest) {
-        const latestVersion = info["dist-tags"].latest;
-        const pkg = info.versions?.[latestVersion];
-        console.log(`  ${info.name}@${latestVersion}`);
-        console.log(`    ${pkg?.description || "No description"}`);
-        console.log();
+  let successCount = 0;
+  let failedCount = 0;
+  for (const skillId of installedSkills) {
+    try {
+      const success = await uninstallSkill(skillId, { ...options, yes: true });
+      if (success) {
+        successCount++;
+      } else {
+        failedCount++;
       }
+    } catch (error) {
+      console.log(`\u274C Failed to uninstall ${skillId}: ${error}`);
+      failedCount++;
     }
-  } catch (error) {
-    console.log(`Error searching skills: ${error}`);
   }
+  console.log(`
+\u{1F4CA} Summary:`);
+  console.log(`   \u2705 Success: ${successCount}`);
+  console.log(`   \u274C Failed: ${failedCount}`);
+  console.log(`   \u{1F4E6} Total: ${installedSkills.length}`);
+  return { success: successCount, failed: failedCount };
 }
 
 // src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJson = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
+var VERSION = packageJson.version || "1.3.1";
 var program = new Command();
-program.name("skm").description("SkillMarket - Cross-platform skill manager for AI coding tools").version("1.2.10");
-var helpCmd = program.command("help").description("Display help information");
-helpCmd.action(() => {
-  console.log(`
+program.name("skm").description("SkillMarket - Cross-platform skill manager for AI coding tools").version(VERSION);
+program.hook("preAction", (thisCommand) => {
+  if (thisCommand.opts().help) {
+    console.log(`
 SkillMarket CLI
 
 Usage: skm <command> [options]
 
 Commands:
-  --help, -h          Display this help message
-  --ls [options]      List available skills
-                        --installed    Show only installed skills
-                        --updates      Check for updates
-  --info <skill-id>   Display skill information
-  --install <skill>   Install a skill (e.g., skm --install brainstorming)
-                        @version      Install specific version
-                        --all         Install all available skills
-  --uninstall <skill> Remove an installed skill
-  --update [options]  Update skills
-                        --all          Update all skills
-  --sync              Synchronize platform links
-  --platform <name>   Set target platform (${PLATFORMS.join(", ")})
+  ls [options]         List available skills
+                          --installed    Show only installed skills
+                          --updates      Check for updates
+                          --page <n>     Page number (default: 1)
+                          --limit <n>    Items per page (default: 20)
+                          -s, --search   Search by keyword
+  info <skill-id>      Display skill information
+  install <skill>      Install a skill
+                          @version      Install specific version
+                          --platform    Target platforms (opencode,claude,vscode)
+                          --force       Overwrite if already installed
+  uninstall <skill>    Remove an installed skill
+                          --platform    Target platforms
+                          --all          Uninstall ALL installed skills
+                          --dry-run     Preview without deleting
+                          -y, --yes     Skip confirmation
+  update [options]     Update skills
+                          --all          Update all skills
+  sync                 Synchronize platform links
+  platforms            Show available platforms
 
 Examples:
-  skm --ls                    List all available skills
-  skm --ls --installed        Show installed skills only
-  skm --info brainstorming     View skill details
-  skm --install brainstorming Install a skill
-  skm --install brainstorming@1.0.0 Install specific version
-  skm --update --all           Update all installed skills
-  skm --sync                  Sync platform links
-    `);
+  skm ls                     List all available skills (page 1)
+  skm ls --page 2            Go to page 2
+  skm ls --limit 10          Show 10 items per page
+  skm ls --search brain      Search skills by keyword
+  skm ls -s brain           Search with short form
+  skm ls --installed         Show installed skills only
+  skm ls --installed --search test  Search installed skills
+  skm ls --installed --page 2
+  skm info brainstorming     View skill details
+  skm install brainstorming  Install to all platforms
+  skm install brainstorming --platform opencode  Install to OpenCode only
+  skm install brainstorming --platform claude,vscode  Install to multiple
+  skm uninstall brainstorming
+  skm uninstall --all        Uninstall all skills (with confirmation)
+  skm uninstall --all --yes  Force uninstall all without confirmation
+  skm uninstall brainstorming --dry-run  Preview uninstall
+  skm platforms              Show available platforms
+       `);
+    process.exit(0);
+  }
 });
 var lsCmd = program.command("ls").description("List available skills");
-lsCmd.option("--installed", "Show only installed skills").option("--updates", "Check for updates").action((opts) => {
-  listSkills(opts);
+lsCmd.option("--installed", "Show only installed skills").option("--updates", "Check for updates").option("-p, --page <number>", "Page number (default: 1)", parseInt).option("-l, --limit <number>", "Items per page (default: 20)", parseInt).option("-s, --search <keyword>", "Search by keyword (id, displayName, description)").action((opts) => {
+  const options = {
+    ...opts,
+    page: opts.page ?? 1,
+    limit: opts.limit ?? 20,
+    search: opts.search
+  };
+  listSkills(options);
+});
+var searchCmd = program.command("search").description("Search skills from npm registry");
+searchCmd.argument("<keyword>", "Keyword to search").option("-l, --limit <number>", "Max results to show (default: 20)", parseInt).action(async (keyword, opts) => {
+  const limit = opts.limit ?? 20;
+  await searchSkills(keyword, limit);
 });
 var infoCmd = program.command("info").description("Display skill information");
 infoCmd.argument("<skill-id>", "Skill ID to show info").action((skillId) => {
   showSkillInfo(skillId);
 });
-var installCmd = program.command("install").description("Install a skill");
-installCmd.argument("<skill>", "Skill ID to install (e.g., brainstorming or @scope/name)").option("--all", "Install all available skills").option("-p, --platform <platform>", `Target platform (${PLATFORMS.join(", ")})`).action(async (skill, opts) => {
+var installCmd = program.command("install").description("Install a skill to local and platform directories");
+installCmd.argument("<skill>", "Skill ID to install (e.g., brainstorming or @scope/name)").option("-p, --platform <platforms>", "Target platforms (comma-separated: opencode,claude,vscode)").option("-f, --force", "Overwrite if already installed").option("-v, --version <version>", "Specific version to install").action(async (skill, opts) => {
   try {
-    await installSkill(skill, void 0, opts.platform);
+    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
+    await installSkill(skill, opts.version, {
+      platforms,
+      force: opts.force
+    });
   } catch (err) {
     console.error("Installation failed:", err);
     process.exit(1);
   }
 });
-var uninstallCmd = program.command("uninstall").description("Remove an installed skill");
-uninstallCmd.argument("<skill>", "Skill ID to uninstall").action(async (skill) => {
+var uninstallCmd = program.command("uninstall").description("Remove an installed skill from local and platform directories");
+uninstallCmd.argument("[skill]", "Skill ID to uninstall (required unless using --all)").option("-p, --platform <platforms>", "Target platforms (comma-separated)").option("-a, --all", "Uninstall ALL installed skills (requires confirmation)").option("-d, --dry-run", "Preview what would be uninstalled without actually deleting").option("-y, --yes", "Skip confirmation prompts").action(async (skill, opts) => {
   try {
-    await uninstallSkill(skill);
+    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
+    if (opts.all) {
+      await uninstallAll({
+        platforms,
+        dryRun: opts.dryRun,
+        yes: opts.yes
+      });
+      return;
+    }
+    if (!skill) {
+      console.error("Error: Skill ID is required (or use --all to uninstall all)");
+      process.exit(1);
+    }
+    await uninstallSkill(skill, {
+      platforms,
+      dryRun: opts.dryRun,
+      yes: opts.yes
+    });
   } catch (err) {
     console.error("Uninstall failed:", err);
     process.exit(1);
@@ -602,16 +1111,28 @@ program.command("sync").description("Synchronize platform links").action(async (
     process.exit(1);
   }
 });
-var platformCmd = program.command("platform").description("Set target platform");
-platformCmd.argument("<name>", "Platform name").action((name) => {
-  console.log("Platform command - name:", name);
-});
-var searchCmd = program.command("search").description("Search skills from npm registry");
-searchCmd.argument("<keyword>", "Keyword to search").action(async (keyword) => {
+var platformsCmd = program.command("platforms").description("Show available platforms");
+platformsCmd.action(async () => {
   try {
-    await searchSkills(keyword);
+    const available = await detectPlatforms();
+    console.log("\n\u{1F4CD} Available Platforms:\n");
+    const allPlatforms = [
+      { name: "OpenCode", adapter: new OpenCodeAdapter() },
+      { name: "Claude Code", adapter: new ClaudeAdapter() },
+      { name: "VSCode", adapter: new VSCodeAdapter() }
+    ];
+    for (const { name, adapter } of allPlatforms) {
+      const isAvailable = available.find((a) => a.id === adapter.id);
+      const installed = await adapter.listInstalled();
+      if (isAvailable) {
+        console.log(`${name.padEnd(12)} \u2705  Available (${installed.length} skills installed)`);
+      } else {
+        console.log(`${name.padEnd(12)} \u274C  Not detected`);
+      }
+    }
+    console.log("");
   } catch (err) {
-    console.error("Search failed:", err);
+    console.error("Failed to list platforms:", err);
     process.exit(1);
   }
 });