itismyskillmarket 1.2.9 → 1.3.0

package/dist/index.js

@@ -2,17 +2,6 @@
 
 // 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";
@@ -41,7 +30,13 @@ 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);
 }
@@ -100,7 +95,7 @@ async function isSkillInstalled(skillId) {
 import https from "https";
 import { URL } from "url";
 async function fetchNpmPackage(packageName) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const isScoped = packageName.startsWith("@");
     let encodedName;
     if (isScoped) {
@@ -126,12 +121,12 @@ async function fetchNpmPackage(packageName) {
         try {
           const parsed = JSON.parse(data);
           if (parsed.error) {
-            resolve2(null);
+            resolve(null);
             return;
           }
-          resolve2(parsed);
+          resolve(parsed);
         } catch {
-          resolve2(null);
+          resolve(null);
         }
       });
     });
@@ -142,50 +137,12 @@ 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(options = {}) {
-  const { from = 0, size = 100, keyword } = options;
+async function searchSkillmarketPackages() {
   const packages = [];
-  let total = 0;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const url = new URL("https://registry.npmjs.org/-/v1/search");
-    if (keyword) {
-      url.searchParams.set("text", `${keyword} keywords:skillmarket`);
-    } else {
-      url.searchParams.set("text", "keywords:skillmarket");
-    }
-    url.searchParams.set("size", String(size));
-    url.searchParams.set("from", String(from));
+    url.searchParams.set("text", "keywords:skillmarket");
+    url.searchParams.set("size", "100");
     const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
       let data = "";
       res.on("data", (chunk) => {
@@ -194,17 +151,14 @@ async function searchSkillmarketPackages(options = {}) {
       res.on("end", () => {
         try {
           const result = JSON.parse(data);
-          total = result.total || 0;
-          if (result.objects) {
-            for (const item of result.objects) {
-              if (item?.package?.name) {
-                packages.push(item.package.name);
-              }
+          for (const item of result.objects || []) {
+            if (item?.package?.name) {
+              packages.push(item.package.name);
             }
           }
-          resolve2({ packages, total });
+          resolve(packages);
         } catch {
-          resolve2({ packages: [], total: 0 });
+          resolve([]);
         }
       });
     });
@@ -217,145 +171,42 @@ async function searchSkillmarketPackages(options = {}) {
 }
 
 // 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 searchSkills(keyword, limit = 20) {
-  console.log(`Searching npm for "${keyword}"...
-`);
-  try {
-    const { packages, total } = await searchSkillmarketPackages({
-      from: 0,
-      size: limit,
-      keyword
-    });
-    if (packages.length === 0) {
-      console.log(`No skills found matching "${keyword}".`);
-      return;
-    }
-    console.log(`Found ${total} match(es) for "${keyword}":
-`);
-    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}`);
-        console.log(`   \u540D\u79F0: ${skillMeta?.displayName || info.name}`);
-        console.log(`   \u63CF\u8FF0: ${pkg?.description || "N/A"}`);
-        console.log(`   \u5E73\u53F0: ${(skillMeta?.platforms || []).join(", ") || "N/A"}`);
-        console.log();
-      } catch (e) {
-        console.log(`\u{1F4E6} ${pkgName} (\u83B7\u53D6\u5931\u8D25: ${e})`);
-        console.log();
-      }
-    }
-  } catch (error) {
-    console.log(`Error searching skills: ${error}`);
-  }
-}
 async function listSkills(options) {
-  const { installed, updates, page = 1, limit = 20, search } = options;
+  const { installed, updates } = options;
   if (installed) {
-    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);
+    const skills = await getInstalledSkills();
     if (skills.length === 0) {
-      if (search) {
-        console.log(`No skills found matching "${search}".`);
-      } else {
-        console.log('No skills installed yet. Run "skm ls" to see available skills.');
-      }
+      console.log('No skills installed yet. Run "skm --ls" to see available skills.');
       return;
     }
-    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("Installed Skills:\n");
+    for (const skill of skills) {
       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;
   }
-  if (search) {
-    console.log(`Searching npm for "${search}"...
-`);
-  } else {
-    console.log("Searching npm registry...\n");
-  }
+  console.log("Searching npm registry...\n");
   try {
-    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);
+    const packages = await searchSkillmarketPackages();
     if (packages.length === 0) {
-      if (search) {
-        console.log(`No skills found matching "${search}".`);
-      } else {
-        console.log("No skills found. Check back later!");
-      }
+      console.log("No skills found. Check back later!");
       return;
     }
-    if (search) {
-      console.log(`Found ${total} match(es) for "${search}":
-`);
-    } else {
-      console.log(`Found ${total} skill(s):
+    console.log(`Found ${packages.length} 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 info = await fetchNpmPackage(pkgName);
+      if (info && info["dist-tags"]?.latest) {
+        const latestVersion = info["dist-tags"].latest;
         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(`  ${info.name}@${latestVersion}`);
+        console.log(`    ${pkg?.description || "No description"}`);
         console.log();
       }
     }
-    console.log(`Page ${currentPage}/${totalPages} (${limit} per page) | Use --page N to navigate`);
   } catch (error) {
     console.log(`Error fetching skills: ${error}`);
   }
@@ -363,10 +214,11 @@ async function listSkills(options) {
 
 // src/commands/info.ts
 async function showSkillInfo(skillId) {
-  console.log(`Fetching info for: ${skillId}
+  const packageName = skillId.startsWith("@") ? skillId : `@skillmarket/${skillId}`;
+  console.log(`Fetching info for: ${packageName}
 `);
   try {
-    const info = await fetchSkillPackage(skillId);
+    const info = await fetchNpmPackage(packageName);
     if (!info) {
       console.log(`Skill "${skillId}" not found in npm registry.`);
       return;
@@ -406,344 +258,174 @@ Status: Not installed (use skm install ${skillId} to install)`);
 }
 
 // src/commands/install.ts
-import fs7 from "fs-extra";
-import path6 from "path";
+import fs4 from "fs-extra";
+import path3 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
-// src/adapters/base.ts
+// 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
 import fs3 from "fs-extra";
 import path2 from "path";
-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;
-    }
-  }
-  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 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];
     }
+  } else {
+    platformsToSync = PLATFORMS;
   }
-  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);
+  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}`);
+          }
         }
       }
     }
-    return skills;
   }
-};
-
-// 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]);
+  console.log("\n\u2705 Sync complete!");
 }
 
 // src/commands/install.ts
 var execAsync = promisify(exec);
-async function installSkill(skillId, version, options) {
+async function installSkill(skillId, version, targetPlatform) {
   await ensureMarketDirs();
-  console.log(`Installing ${skillId}${version ? `@${version}` : ""}...`);
-  const pkgInfo = await fetchSkillPackage(skillId);
+  const isScoped = skillId.startsWith("@");
+  const packageName = isScoped ? skillId : `@skillmarket/${skillId}`;
+  const shortName = skillId;
+  console.log(`Installing ${packageName}${version ? `@${version}` : ""}...`);
+  const pkgInfo = await fetchNpmPackage(packageName);
   if (!pkgInfo) {
-    throw new Error(`Package ${skillId} not found`);
+    throw new Error(`Package ${packageName} 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 = path6.join(cacheDir, `${packageName}@${targetVersion}`);
-  if (!await fs7.pathExists(targetDir)) {
+  const targetDir = path3.join(cacheDir, `${packageName}@${targetVersion}`);
+  if (!await fs4.pathExists(targetDir)) {
     console.log("Downloading package...");
-    await fs7.ensureDir(cacheDir);
+    await fs4.ensureDir(cacheDir);
     try {
       await execAsync(`npm pack ${packageName}@${targetVersion} --pack-destination ${cacheDir}`);
-      const files = await fs7.readdir(cacheDir);
+      const files = await fs4.readdir(cacheDir);
       const tarball = files.find(
-        (f) => f.endsWith(".tgz") && f.includes(packageName.replace(/^@/, "").replace("/", "-"))
+        (f) => f.endsWith(".tgz") && f.includes(packageName.replace("/", "-"))
       );
       if (tarball) {
-        await execAsync(`tar -xzf "${path6.join(cacheDir, tarball)}" -C "${cacheDir}"`);
-        await fs7.remove(path6.join(cacheDir, tarball));
-        const extractedDir = path6.join(cacheDir, "package");
+        await execAsync(`tar -xzf "${path3.join(cacheDir, tarball)}" -C "${cacheDir}"`);
+        await fs4.remove(path3.join(cacheDir, tarball));
+        const extractedDir = path3.join(cacheDir, "package");
         const finalDir = targetDir;
-        await fs7.move(extractedDir, finalDir, { overwrite: true });
+        await fs4.move(extractedDir, finalDir, { overwrite: true });
       }
     } catch (err) {
       throw new Error(`Failed to download package: ${err}`);
     }
   }
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path6.join(skillsDir, `${skillId}@${targetVersion}`);
+  const skillVersionDir = path3.join(skillsDir, `${skillId}@${targetVersion}`);
   console.log("Setting up skill...");
-  await fs7.ensureDir(skillVersionDir);
+  await fs4.ensureDir(skillVersionDir);
   const pkgRoot = targetDir;
-  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, "SKILL.md"))) {
+    await fs4.copy(
+      path3.join(pkgRoot, "SKILL.md"),
+      path3.join(skillVersionDir, "SKILL.md")
     );
   }
-  if (await fs7.pathExists(path6.join(pkgRoot, "metadata.json"))) {
-    await fs7.copy(
-      path6.join(pkgRoot, "metadata.json"),
-      path6.join(skillVersionDir, "metadata.json")
+  if (await fs4.pathExists(path3.join(pkgRoot, "metadata.json"))) {
+    await fs4.copy(
+      path3.join(pkgRoot, "metadata.json"),
+      path3.join(skillVersionDir, "metadata.json")
     );
   }
-  const skillDir = path6.join(skillsDir, skillId);
-  await fs7.ensureDir(skillDir);
-  const latestLink = path6.join(skillDir, LATEST_LINK);
+  const skillDir = path3.join(skillsDir, skillId);
+  await fs4.ensureDir(skillDir);
+  const latestLink = path3.join(skillDir, LATEST_LINK);
   try {
-    await fs7.remove(latestLink);
-    await fs7.symlink(skillVersionDir, latestLink, "junction");
+    await fs4.remove(latestLink);
+    await fs4.symlink(skillVersionDir, latestLink, "junction");
   } catch {
-    await fs7.copy(skillVersionDir, path6.join(skillDir, LATEST_LINK), { overwrite: true });
+    await fs4.copy(skillVersionDir, path3.join(skillDir, LATEST_LINK), { overwrite: true });
   }
-  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}`);
-      }
+  let finalPlatform;
+  if (targetPlatform) {
+    const parsed = getPlatformFromInput(targetPlatform);
+    if (!parsed) {
+      throw new Error(`Invalid platform: ${targetPlatform}. Valid platforms: ${PLATFORMS.join(", ")}`);
     }
+    finalPlatform = parsed;
   } else {
-    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`);
+    finalPlatform = detectPlatform();
   }
+  console.log(`Target platform: ${finalPlatform}`);
   const registry = await loadRegistry();
-  const installedPlatforms = targetAdapters.map((a) => a.id);
+  const existingSkill = registry.skills[skillId];
+  const existingPlatforms = existingSkill?.platforms || [];
   registry.skills[skillId] = {
     id: skillId,
     version: targetVersion,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    platforms: installedPlatforms
+    platforms: existingPlatforms.includes(finalPlatform) ? existingPlatforms : [...existingPlatforms, finalPlatform]
   };
   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(`@itismyskillmarket/${skillId}`);
+    const pkgInfo = await fetchNpmPackage(`@skillmarket/${skillId}`);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
       console.log(`Updating ${skillId} to ${latestVersion}...`);
@@ -760,7 +442,7 @@ async function updateSkill(skillId) {
 `);
   let hasUpdates = false;
   for (const skill of installed) {
-    const pkgInfo = await fetchNpmPackage(`@wanxuchen/${skill.id}`);
+    const pkgInfo = await fetchNpmPackage(`@skillmarket/${skill.id}`);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
       if (latestVersion && latestVersion !== skill.version) {
@@ -782,9 +464,9 @@ async function updateSkill(skillId) {
 }
 
 // src/commands/uninstall.ts
-import fs9 from "fs-extra";
-import path8 from "path";
-async function uninstallSkill(skillId, options) {
+import fs5 from "fs-extra";
+import path4 from "path";
+async function uninstallSkill(skillId) {
   const registry = await loadRegistry();
   if (!(skillId in registry.skills)) {
     console.log(`Skill "${skillId}" is not installed.`);
@@ -792,37 +474,14 @@ async function uninstallSkill(skillId, options) {
   }
   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 = path8.join(skillsDir, skillId);
-  await fs9.remove(skillDir);
+  const skillDir = path4.join(skillsDir, skillId);
+  await fs5.remove(skillDir);
   const platformLinksDir = getPlatformLinksDir();
   for (const platform of PLATFORMS) {
-    const linkPath = path8.join(platformLinksDir, platform, "skills", skillId);
-    if (await fs9.pathExists(linkPath)) {
-      await fs9.remove(linkPath);
+    const linkPath = path4.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs5.pathExists(linkPath)) {
+      await fs5.remove(linkPath);
     }
   }
   delete registry.skills[skillId];
@@ -831,95 +490,92 @@ Uninstalling from ${validAdapters.length} platform(s)...
 \u2705 ${skillId} uninstalled successfully!`);
 }
 
+// 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())
+    );
+    if (filtered.length === 0) {
+      console.log(`No skills found matching "${keyword}".`);
+      return;
+    }
+    console.log(`Found ${filtered.length} skill(s):
+`);
+    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();
+      }
+    }
+  } catch (error) {
+    console.log(`Error searching skills: ${error}`);
+  }
+}
+
 // 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;
 var program = new Command();
-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(`
+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(`
 SkillMarket CLI
 
 Usage: skm <command> [options]
 
 Commands:
-  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
-  update [options]     Update skills
-                          --all          Update all skills
-  sync                 Synchronize platform links
-  platforms            Show available platforms
+  --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(", ")})
 
 Examples:
-  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 platforms              Show available platforms
-      `);
-    process.exit(0);
-  }
+  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
+    `);
 });
 var lsCmd = program.command("ls").description("List available skills");
-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);
+lsCmd.option("--installed", "Show only installed skills").option("--updates", "Check for updates").action((opts) => {
+  listSkills(opts);
 });
 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 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) => {
+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) => {
   try {
-    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
-    await installSkill(skill, opts.version, {
-      platforms,
-      force: opts.force
-    });
+    await installSkill(skill, void 0, opts.platform);
   } catch (err) {
     console.error("Installation failed:", err);
     process.exit(1);
   }
 });
-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) => {
+var uninstallCmd = program.command("uninstall").description("Remove an installed skill");
+uninstallCmd.argument("<skill>", "Skill ID to uninstall").action(async (skill) => {
   try {
-    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
-    await uninstallSkill(skill, { platforms });
+    await uninstallSkill(skill);
   } catch (err) {
     console.error("Uninstall failed:", err);
     process.exit(1);
@@ -946,28 +602,16 @@ program.command("sync").description("Synchronize platform links").action(async (
     process.exit(1);
   }
 });
-var platformsCmd = program.command("platforms").description("Show available platforms");
-platformsCmd.action(async () => {
+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) => {
   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("");
+    await searchSkills(keyword);
   } catch (err) {
-    console.error("Failed to list platforms:", err);
+    console.error("Search failed:", err);
     process.exit(1);
   }
 });