itismyskillmarket 1.2.1 → 1.2.3

package/dist/index.js

@@ -3,6 +3,14 @@
 // src/cli.ts
 import { Command } from "commander";
 
+// 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";
 var SUBDIRS = {
@@ -30,13 +38,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);
 }
@@ -137,6 +139,37 @@ async function fetchNpmPackage(packageName) {
     });
   });
 }
+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() {
   const packages = [];
   return new Promise((resolve, reject) => {
@@ -151,9 +184,11 @@ 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);
+          if (result.objects) {
+            for (const item of result.objects) {
+              if (item?.package?.name) {
+                packages.push(item.package.name);
+              }
             }
           }
           resolve(packages);
@@ -198,12 +233,27 @@ async function listSkills(options) {
     console.log(`Found ${packages.length} skill(s):
 `);
     for (const pkgName of packages) {
-      const info = await fetchNpmPackage(pkgName);
-      if (info && info["dist-tags"]?.latest) {
-        const latestVersion = info["dist-tags"].latest;
+      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];
-        console.log(`  ${info.name}@${latestVersion}`);
-        console.log(`    ${pkg?.description || "No description"}`);
+        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();
       }
     }
@@ -214,11 +264,10 @@ async function listSkills(options) {
 
 // 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,172 +307,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 packageName = skillId.startsWith("@") ? skillId : `@skillmarket/${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("/", "-"))
       );
       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}...`);
@@ -440,7 +661,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) {
@@ -462,9 +683,9 @@ 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";
+async function uninstallSkill(skillId, options) {
   const registry = await loadRegistry();
   if (!(skillId in registry.skills)) {
     console.log(`Skill "${skillId}" is not installed.`);
@@ -472,14 +693,37 @@ async function uninstallSkill(skillId) {
   }
   const skillInfo = registry.skills[skillId];
   console.log(`Uninstalling ${skillId}@${skillInfo.version}...`);
+  let targetAdapters = [];
+  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) {
+        console.log(`${adapter.name.padEnd(12)} \u274C  Failed: ${error}`);
+      }
+    }
+  }
   const skillsDir = getSkillsDir();
-  const skillDir = path4.join(skillsDir, skillId);
-  await fs5.remove(skillDir);
+  const skillDir = path8.join(skillsDir, skillId);
+  await fs9.remove(skillDir);
   const platformLinksDir = getPlatformLinksDir();
   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);
     }
   }
   delete registry.skills[skillId];
@@ -490,38 +734,42 @@ async function uninstallSkill(skillId) {
 
 // src/cli.ts
 var program = new Command();
-program.name("skm").description("SkillMarket - Cross-platform skill manager for AI coding tools").version("1.2.0");
-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("1.0.0");
+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
+  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
+  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
+  skm ls --installed         Show installed skills only
+  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 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) => {
@@ -531,19 +779,24 @@ 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").option("-p, --platform <platforms>", "Target platforms (comma-separated)").action(async (skill, opts) => {
   try {
-    await uninstallSkill(skill);
+    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
+    await uninstallSkill(skill, { platforms });
   } catch (err) {
     console.error("Uninstall failed:", err);
     process.exit(1);
@@ -570,8 +823,29 @@ 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 platformsCmd = program.command("platforms").description("Show available platforms");
+platformsCmd.action(async () => {
+  try {
+    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("Failed to list platforms:", err);
+    process.exit(1);
+  }
 });
 program.parse();