itismyskillmarket 1.0.10

package/dist/index.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/constants.ts
+var MARKET_DIR = "skillmarket";
+var SUBDIRS = {
+  /** npm 包下载缓存目录，用于存储从 npm 下载的 skill 包 */
+  CACHE: "cache",
+  /** 已安装 skills 的主存储目录 */
+  SKILLS: "skills",
+  /** 各平台适配层软链接目录，用于跨平台共享 skills */
+  PLATFORM_LINKS: "platform-links"
+};
+var PLATFORMS = [
+  "cursor",
+  // Cursor IDE - AI 代码编辑器
+  "vscode",
+  // Visual Studio Code - 微软代码编辑器
+  "codex",
+  // OpenAI Codex - OpenAI 代码生成模型
+  "opencode",
+  // OpenCode - 开源 AI 编程工具
+  "claude",
+  // Claude Code - Anthropic CLI 工具
+  "antigravity"
+  // Antigravity - AI 编程助手
+];
+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);
+}
+function getCacheDir() {
+  return path.join(getMarketHome(), SUBDIRS.CACHE);
+}
+function getSkillsDir() {
+  return path.join(getMarketHome(), SUBDIRS.SKILLS);
+}
+function getPlatformLinksDir() {
+  return path.join(getMarketHome(), SUBDIRS.PLATFORM_LINKS);
+}
+function getRegistryPath() {
+  return path.join(getMarketHome(), REGISTRY_FILE);
+}
+async function ensureMarketDirs() {
+  await fs.ensureDir(getCacheDir());
+  await fs.ensureDir(getSkillsDir());
+  await fs.ensureDir(getPlatformLinksDir());
+}
+
+// src/commands/registry.ts
+var DEFAULT_REGISTRY = {
+  /** 空的 skills 字典，初始没有任何已安装的 skill */
+  skills: {},
+  /** 注册表创建时间 */
+  lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+};
+async function loadRegistry() {
+  const registryPath = getRegistryPath();
+  if (!await fs2.pathExists(registryPath)) {
+    return DEFAULT_REGISTRY;
+  }
+  try {
+    const data = await fs2.readJson(registryPath);
+    return data;
+  } catch {
+    return DEFAULT_REGISTRY;
+  }
+}
+async function saveRegistry(registry) {
+  await fs2.ensureDir(getMarketHome());
+  registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await fs2.writeJson(getRegistryPath(), registry, { spaces: 2 });
+}
+async function getInstalledSkills() {
+  const registry = await loadRegistry();
+  return Object.values(registry.skills);
+}
+async function isSkillInstalled(skillId) {
+  const registry = await loadRegistry();
+  return skillId in registry.skills;
+}
+
+// src/commands/npm.ts
+import https from "https";
+import { URL } from "url";
+async function fetchNpmPackage(packageName) {
+  return new Promise((resolve, reject) => {
+    const isScoped = packageName.startsWith("@");
+    let encodedName;
+    if (isScoped) {
+      const scopeAndName = packageName.substring(1);
+      const slashIndex = scopeAndName.indexOf("/");
+      if (slashIndex > 0) {
+        const scope = scopeAndName.substring(0, slashIndex);
+        const name = scopeAndName.substring(slashIndex + 1);
+        encodedName = `@${encodeURIComponent(scope)}%2F${encodeURIComponent(name)}`;
+      } else {
+        encodedName = packageName;
+      }
+    } else {
+      encodedName = encodeURIComponent(packageName);
+    }
+    const url = new URL(`https://registry.npmjs.org/${encodedName}`);
+    const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.error) {
+            resolve(null);
+            return;
+          }
+          resolve(parsed);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+  });
+}
+async function searchSkillmarketPackages() {
+  const packages = [];
+  return new Promise((resolve, reject) => {
+    const url = new URL("https://registry.npmjs.org/-/v1/search");
+    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) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const result = JSON.parse(data);
+          if (result.objects) {
+            for (const item of result.objects) {
+              if (item?.package?.name) {
+                packages.push(item.package.name);
+              }
+            }
+          }
+          resolve(packages);
+        } catch {
+          resolve([]);
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+  });
+}
+
+// src/commands/ls.ts
+async function listSkills(options) {
+  const { installed, updates } = options;
+  if (installed) {
+    const skills = await getInstalledSkills();
+    if (skills.length === 0) {
+      console.log('No skills installed yet. Run "skm --ls" to see available skills.');
+      return;
+    }
+    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();
+    }
+    return;
+  }
+  console.log("Searching npm registry...\n");
+  try {
+    const packages = await searchSkillmarketPackages();
+    if (packages.length === 0) {
+      console.log("No skills found. Check back later!");
+      return;
+    }
+    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 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();
+      }
+    }
+  } catch (error) {
+    console.log(`Error fetching skills: ${error}`);
+  }
+}
+
+// src/commands/info.ts
+async function showSkillInfo(skillId) {
+  const packageName = skillId.startsWith("@") ? skillId : `@itismyskillmarket/${skillId}`;
+  console.log(`Fetching info for: ${packageName}
+`);
+  try {
+    const info = await fetchNpmPackage(packageName);
+    if (!info) {
+      console.log(`Skill "${skillId}" not found in npm registry.`);
+      return;
+    }
+    const latestVersion = info["dist-tags"]?.latest;
+    const versions = info.versions || {};
+    const pkg = latestVersion ? versions[latestVersion] : void 0;
+    const installed = await isSkillInstalled(skillId);
+    const installedSkills = await getInstalledSkills();
+    const installedSkill = installedSkills.find((s) => s.id === skillId);
+    console.log(`=== ${info.name} ===`);
+    const versionDisplay = installedSkill ? `${latestVersion} (installed: ${installedSkill.version})` : latestVersion;
+    console.log(`Version: ${versionDisplay}`);
+    console.log(`Description: ${pkg?.description || "N/A"}
+`);
+    const skillmarketMeta = pkg?.skillmarket;
+    if (skillmarketMeta) {
+      console.log(`Platforms: ${skillmarketMeta.platforms?.join(", ") || "N/A"}`);
+      console.log(`Default Version: ${skillmarketMeta.defaultVersion || "N/A"}
+`);
+    }
+    const versionKeys = Object.keys(versions);
+    if (versionKeys.length > 0) {
+      const recentVersions = versionKeys.slice(-10);
+      console.log(`Recent versions: ${recentVersions.join(", ")}`);
+    }
+    if (installed) {
+      console.log(`
+Status: Installed (use skm update ${skillId} to update)`);
+    } else {
+      console.log(`
+Status: Not installed (use skm install ${skillId} to install)`);
+    }
+  } catch (error) {
+    console.log(`Error fetching skill info: ${error}`);
+  }
+}
+
+// src/commands/install.ts
+import fs3 from "fs-extra";
+import path2 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";
+}
+
+// src/commands/install.ts
+var execAsync = promisify(exec);
+async function installSkill(skillId, version) {
+  await ensureMarketDirs();
+  let packageName;
+  if (skillId.startsWith("@")) {
+    packageName = skillId;
+  } else {
+    packageName = `@itismyskillmarket/${skillId}`;
+  }
+  console.log(`Installing ${packageName}${version ? `@${version}` : ""}...`);
+  const pkgInfo = await fetchNpmPackage(packageName);
+  if (!pkgInfo) {
+    throw new Error(`Package ${packageName} not found`);
+  }
+  const targetVersion = version || pkgInfo["dist-tags"]?.latest;
+  if (!targetVersion) {
+    throw new Error(`No version found for ${packageName}`);
+  }
+  const cacheDir = getCacheDir();
+  const targetDir = path2.join(cacheDir, `${packageName}@${targetVersion}`);
+  if (!await fs3.pathExists(targetDir)) {
+    console.log("Downloading package...");
+    await fs3.ensureDir(cacheDir);
+    try {
+      await execAsync(`npm pack ${packageName}@${targetVersion} --pack-destination ${cacheDir}`);
+      const files = await fs3.readdir(cacheDir);
+      const tarball = files.find(
+        (f) => f.endsWith(".tgz") && f.includes(packageName.replace("/", "-"))
+      );
+      if (tarball) {
+        await execAsync(`tar -xzf "${path2.join(cacheDir, tarball)}" -C "${cacheDir}"`);
+        await fs3.remove(path2.join(cacheDir, tarball));
+        const extractedDir = path2.join(cacheDir, "package");
+        const finalDir = targetDir;
+        await fs3.move(extractedDir, finalDir, { overwrite: true });
+      }
+    } catch (err) {
+      throw new Error(`Failed to download package: ${err}`);
+    }
+  }
+  const skillsDir = getSkillsDir();
+  const skillVersionDir = path2.join(skillsDir, `${skillId}@${targetVersion}`);
+  console.log("Setting up skill...");
+  await fs3.ensureDir(skillVersionDir);
+  const pkgRoot = targetDir;
+  if (await fs3.pathExists(path2.join(pkgRoot, "SKILL.md"))) {
+    await fs3.copy(
+      path2.join(pkgRoot, "SKILL.md"),
+      path2.join(skillVersionDir, "SKILL.md")
+    );
+  }
+  if (await fs3.pathExists(path2.join(pkgRoot, "metadata.json"))) {
+    await fs3.copy(
+      path2.join(pkgRoot, "metadata.json"),
+      path2.join(skillVersionDir, "metadata.json")
+    );
+  }
+  const skillDir = path2.join(skillsDir, skillId);
+  await fs3.ensureDir(skillDir);
+  const latestLink = path2.join(skillDir, LATEST_LINK);
+  try {
+    await fs3.remove(latestLink);
+    await fs3.symlink(skillVersionDir, latestLink, "junction");
+  } catch {
+    await fs3.copy(skillVersionDir, path2.join(skillDir, LATEST_LINK), { overwrite: true });
+  }
+  const registry = await loadRegistry();
+  const currentPlatform = detectPlatform();
+  registry.skills[skillId] = {
+    id: skillId,
+    version: targetVersion,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    platforms: [currentPlatform]
+  };
+  await saveRegistry(registry);
+  console.log(`
+\u2705 ${skillId}@${targetVersion} installed successfully!`);
+  console.log(`   Use "skm info ${skillId}" for more details`);
+}
+
+// src/commands/sync.ts
+import fs4 from "fs-extra";
+import path3 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 = path3.join(platformLinksDir, platform, "skills");
+    await fs4.ensureDir(platformDir);
+    for (const [skillId, skillInfo] of Object.entries(registry.skills)) {
+      const skillLatestLink = path3.join(skillsDir, skillId, LATEST_LINK);
+      const targetPlatformDir = path3.join(skillLatestLink, platform);
+      const platformSkillDir = path3.join(platformDir, skillId);
+      if (await fs4.pathExists(skillLatestLink)) {
+        if (await fs4.pathExists(targetPlatformDir)) {
+          try {
+            await fs4.remove(platformSkillDir);
+            await fs4.symlink(targetPlatformDir, platformSkillDir, "junction");
+            console.log(`  Linked: ${platform}/${skillId}`);
+          } catch {
+            await fs4.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}`);
+    if (pkgInfo) {
+      const latestVersion = pkgInfo["dist-tags"]?.latest;
+      console.log(`Updating ${skillId} to ${latestVersion}...`);
+      await installSkill(skillId, latestVersion);
+    }
+    return;
+  }
+  const installed = await getInstalledSkills();
+  if (installed.length === 0) {
+    console.log("No skills installed to update.");
+    return;
+  }
+  console.log(`Checking updates for ${installed.length} skill(s)...
+`);
+  let hasUpdates = false;
+  for (const skill of installed) {
+    const pkgInfo = await fetchNpmPackage(`@wanxuchen/${skill.id}`);
+    if (pkgInfo) {
+      const latestVersion = pkgInfo["dist-tags"]?.latest;
+      if (latestVersion && latestVersion !== skill.version) {
+        console.log(`  ${skill.id}: ${skill.version} \u2192 ${latestVersion} [UPDATE]`);
+        hasUpdates = true;
+        try {
+          await installSkill(skill.id, latestVersion);
+        } catch (err) {
+          console.error(`  Failed to update ${skill.id}:`, err);
+        }
+      } else {
+        console.log(`  ${skill.id}: ${skill.version} (up to date)`);
+      }
+    }
+  }
+  if (!hasUpdates) {
+    console.log("\nAll skills are up to date!");
+  }
+}
+
+// src/commands/uninstall.ts
+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.`);
+    return;
+  }
+  const skillInfo = registry.skills[skillId];
+  console.log(`Uninstalling ${skillId}@${skillInfo.version}...`);
+  const skillsDir = getSkillsDir();
+  const skillDir = path4.join(skillsDir, skillId);
+  await fs5.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);
+    }
+  }
+  delete registry.skills[skillId];
+  await saveRegistry(registry);
+  console.log(`
+\u2705 ${skillId} uninstalled successfully!`);
+}
+
+// src/cli.ts
+var program = new Command();
+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:
+  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
+  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
+      `);
+    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);
+});
+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").action(async (skill, opts) => {
+  try {
+    await installSkill(skill);
+  } 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) => {
+  try {
+    await uninstallSkill(skill);
+  } catch (err) {
+    console.error("Uninstall failed:", err);
+    process.exit(1);
+  }
+});
+var updateCmd = program.command("update").description("Update installed skills");
+updateCmd.argument("[skill]", "Skill ID to update (optional, updates all if not specified)").option("--all", "Update all skills").action(async (skill, opts) => {
+  try {
+    if (opts.all || !skill) {
+      await updateSkill();
+    } else {
+      await updateSkill(skill);
+    }
+  } catch (err) {
+    console.error("Update failed:", err);
+    process.exit(1);
+  }
+});
+program.command("sync").description("Synchronize platform links").action(async () => {
+  try {
+    await syncPlatformLinks();
+  } catch (err) {
+    console.error("Sync failed:", err);
+    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);
+});
+program.parse();