itismyskillmarket 1.3.6 → 1.3.7

package/README.md

@@ -56,6 +56,9 @@ skm platforms
 # Sync platform links
 skm sync
 
+# Sync skill to latest version (install to all platforms)
+skm sync brainstorming
+
 # Uninstall a skill (from all platforms)
 skm uninstall brainstorming
 
@@ -101,11 +104,11 @@ $ skm platforms
 
 📍 Available Platforms:
 
-OpenCode     ✅  Available (2 skills installed)
-Claude Code  ✅  Available (1 skills installed)
-VSCode       ✅  Available (0 skills installed)
-OpenClaw     ✅  Available
-Hermes Agent ✅  Available
+OpenCode        ✅  Available (2 skills installed)
+Claude Code     ✅  Available (1 skills installed)
+VSCode          ✅  Available (0 skills installed)
+OpenClaw        ✅  Available (0 skills installed)
+Hermes Agent    ✅  Available (0 skills installed)
 ```
 
 ## Development
@@ -152,6 +155,8 @@ Skills are installed to `~/.skillmarket/` with the following structure:
 - OpenCode
 - Claude Code
 - Antigravity
+- OpenClaw
+- Hermes Agent
 
 ## License
 

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, resolve } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname2, resolve } from "path";
 
 // src/commands/registry.ts
 import fs2 from "fs-extra";
@@ -102,7 +102,7 @@ async function isSkillInstalled(skillId) {
 
 // src/commands/npm.ts
 import https from "https";
-import { URL } from "url";
+import { URL as URL2 } from "url";
 async function fetchNpmPackage(packageName) {
   return new Promise((resolve2, reject) => {
     const isScoped = packageName.startsWith("@");
@@ -120,7 +120,7 @@ async function fetchNpmPackage(packageName) {
     } else {
       encodedName = encodeURIComponent(packageName);
     }
-    const url = new URL(`https://registry.npmjs.org/${encodedName}`);
+    const url = new URL2(`https://registry.npmjs.org/${encodedName}`);
     const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
       let data = "";
       res.on("data", (chunk) => {
@@ -182,7 +182,7 @@ async function searchSkillmarketPackages(options = {}) {
   const packages = [];
   let total = 0;
   return new Promise((resolve2, reject) => {
-    const url = new URL("https://registry.npmjs.org/-/v1/search");
+    const url = new URL2("https://registry.npmjs.org/-/v1/search");
     url.searchParams.set("text", "keywords:skillmarket");
     url.searchParams.set("size", String(Math.max(size, 100)));
     url.searchParams.set("from", String(from));
@@ -1131,13 +1131,13 @@ function parseGitHubUrl(input) {
       const repo = match[2].replace(/\.git$/, "");
       const branch = match[3] || "main";
       const commitOrPath = match[4] || match[3];
-      const path10 = match[5] || void 0;
+      const path11 = match[5] || void 0;
       return {
         owner,
         repo,
         branch: commitOrPath && !commitOrPath.includes("/") ? commitOrPath : branch,
         commit: commitOrPath?.match(/^[0-9a-f]{40}$/) ? commitOrPath : void 0,
-        path: path10
+        path: path11
       };
     }
   }
@@ -1378,10 +1378,419 @@ Installing to platforms: ${targetPlatforms.join(", ")}`);
   console.log(`   Source: ${source.owner}/${source.repo}`);
 }
 
+// src/commands/publish.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+async function publishSkill(skillName, options) {
+  const __dirname4 = fileURLToPath(new URL(".", import.meta.url));
+  const projectRoot = join3(__dirname4, "..", "..");
+  const skillDir = join3(projectRoot, "skills", skillName);
+  console.log(`Publishing ${skillName}...`);
+  if (!existsSync3(skillDir)) {
+    throw new Error(`Skill '${skillName}' not found in skills/ directory`);
+  }
+  if (!options?.skipInstall) {
+    console.log("Running npm install...");
+    try {
+      execSync("npm install", {
+        cwd: skillDir,
+        stdio: "inherit"
+      });
+    } catch (err) {
+      console.warn("Warning: npm install failed, continuing anyway...");
+    }
+  }
+  if (options?.version) {
+    console.log(`Updating version to ${options.version}...`);
+    try {
+      execSync(`npm version ${options.version} --no-git-tag-version`, {
+        cwd: skillDir,
+        stdio: "inherit"
+      });
+    } catch (err) {
+      throw new Error(`Failed to update version: ${err}`);
+    }
+  }
+  console.log("Publishing to npm...");
+  try {
+    execSync("npm publish --access=public", {
+      cwd: skillDir,
+      stdio: "inherit"
+    });
+  } catch (err) {
+    throw new Error(`Failed to publish: ${err}`);
+  }
+  console.log(`
+\u2705 ${skillName} published successfully!`);
+  console.log(`   View at: https://www.npmjs.com/package/@itismyskillmarket/${skillName}`);
+}
+
+// src/commands/verify.ts
+import fs11 from "fs-extra";
+import path10 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = path10.dirname(__filename);
+async function verifySkill(skillName) {
+  try {
+    console.log(`
+\u{1F50D} Verifying skill: ${skillName}
+`);
+    const skillDir = path10.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "skills", skillName);
+    if (!await fs11.pathExists(skillDir)) {
+      console.error(`\u274C Skill "${skillName}" not found locally.`);
+      console.log(`   Try: skm install ${skillName}`);
+      process.exit(1);
+    }
+    let passed = 0;
+    let failed = 0;
+    const skillMdPath = path10.join(skillDir, "SKILL.md");
+    if (await fs11.pathExists(skillMdPath)) {
+      console.log(`\u2705 SKILL.md exists`);
+      passed++;
+      const content = await fs11.readFile(skillMdPath, "utf-8");
+      if (content.trim().length > 0) {
+        console.log(`\u2705 SKILL.md is not empty (${content.length} chars)`);
+        passed++;
+      } else {
+        console.log(`\u26A0\uFE0F  SKILL.md is empty`);
+        failed++;
+      }
+    } else {
+      console.log(`\u274C SKILL.md not found`);
+      failed++;
+    }
+    const pkgPath = path10.join(skillDir, "package.json");
+    if (await fs11.pathExists(pkgPath)) {
+      console.log(`\u2705 package.json exists`);
+      passed++;
+      try {
+        const pkg = await fs11.readJson(pkgPath);
+        const requiredFields = ["name", "version", "description"];
+        for (const field of requiredFields) {
+          if (pkg[field]) {
+            console.log(`\u2705 package.json has "${field}"`);
+            passed++;
+          } else {
+            console.log(`\u26A0\uFE0F  package.json missing "${field}"`);
+            failed++;
+          }
+        }
+      } catch (err) {
+        console.log(`\u274C package.json is invalid JSON`);
+        failed++;
+      }
+    } else {
+      console.log(`\u26A0\uFE0F  package.json not found (optional for basic skills)`);
+    }
+    const registryPath = path10.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "registry.json");
+    if (await fs11.pathExists(registryPath)) {
+      try {
+        const registry = await fs11.readJson(registryPath);
+        if (registry[skillName]) {
+          console.log(`\u2705 Skill registered in registry (v${registry[skillName].version})`);
+          passed++;
+        } else {
+          console.log(`\u26A0\uFE0F  Skill not found in registry`);
+          failed++;
+        }
+      } catch {
+        console.log(`\u26A0\uFE0F  Registry is invalid JSON`);
+        failed++;
+      }
+    }
+    console.log(`
+\u{1F4CA} Verification Result:`);
+    console.log(`   \u2705 Passed: ${passed}`);
+    console.log(`   \u274C Failed: ${failed}`);
+    if (failed === 0) {
+      console.log(`
+\u2705 Skill "${skillName}" is valid!
+`);
+    } else {
+      console.log(`
+\u26A0\uFE0F  Skill "${skillName}" has issues. Consider reinstalling.
+`);
+    }
+  } catch (err) {
+    console.error("\u274C Verification failed:", err);
+    process.exit(1);
+  }
+}
+
+// src/commands/ui.ts
+import { createServer } from "http";
+import { readFileSync, existsSync as existsSync4 } from "fs";
+import { join as join4, extname, dirname } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename2 = fileURLToPath3(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var guiDir = join4(__dirname2, "..", "gui");
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function jsonResponse(res, status, data) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+  return new Promise((resolve2, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      if (!body) return resolve2({});
+      try {
+        resolve2(JSON.parse(body));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+var API_ROUTES = {
+  GET: {},
+  POST: {}
+};
+API_ROUTES.GET["/api/skills"] = async (_req, res, url) => {
+  try {
+    const page = Math.max(1, parseInt(url.searchParams.get("page") || "1"));
+    const limit = Math.min(100, Math.max(1, parseInt(url.searchParams.get("limit") || "20")));
+    const search = url.searchParams.get("search") || "";
+    const offset = (page - 1) * limit;
+    const { packages, total } = await searchSkillmarketPackages({
+      from: offset,
+      size: limit,
+      keyword: search || void 0
+    });
+    const skills = (await Promise.all(
+      packages.map(async (pkgName) => {
+        try {
+          const info = await fetchNpmPackage(pkgName);
+          if (!info) return null;
+          const latestVersion = info["dist-tags"]?.latest || "unknown";
+          const pkg = info.versions?.[latestVersion];
+          const meta = pkg?.skillmarket;
+          return {
+            id: meta?.id || info.name.replace(/^@[^/]+\//, ""),
+            name: info.name,
+            displayName: meta?.displayName || info.name,
+            version: latestVersion,
+            description: pkg?.description || "",
+            platforms: meta?.platforms || [],
+            author: info.author?.name || pkg?.author?.name || "",
+            homepage: pkg?.homepage || "",
+            repository: pkg?.repository?.url || ""
+          };
+        } catch {
+          return null;
+        }
+      })
+    )).filter(Boolean);
+    const totalPages = Math.ceil(total / limit) || 1;
+    jsonResponse(res, 200, { skills, page, totalPages, total });
+  } catch (err) {
+    jsonResponse(res, 500, {
+      error: String(err),
+      skills: [],
+      page: 1,
+      totalPages: 1,
+      total: 0
+    });
+  }
+};
+API_ROUTES.GET["/api/installed"] = async (_req, res, _url) => {
+  try {
+    const skills = await getInstalledSkills();
+    jsonResponse(res, 200, skills.map((s) => ({
+      id: s.id,
+      displayName: s.id,
+      version: s.version,
+      installedAt: s.installedAt,
+      platforms: s.platforms
+    })));
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/platforms"] = async (_req, res, _url) => {
+  try {
+    const available = await detectPlatforms();
+    const allAdapters = getAllAdapters();
+    const platforms = await Promise.all(
+      allAdapters.map(async (adapter) => {
+        const isAvailable = available.find((a) => a.id === adapter.id);
+        const installed = await adapter.listInstalled();
+        return {
+          id: adapter.id,
+          name: adapter.name,
+          available: !!isAvailable,
+          installedCount: Array.isArray(installed) ? installed.length : 0
+        };
+      })
+    );
+    jsonResponse(res, 200, platforms);
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/skill-info"] = async (_req, res, url) => {
+  try {
+    const skillName = url.searchParams.get("skill") || "";
+    if (!skillName) {
+      jsonResponse(res, 400, { error: 'Missing "skill" query parameter' });
+      return;
+    }
+    const info = await fetchNpmPackage(skillName);
+    if (!info) {
+      jsonResponse(res, 404, { error: `Skill "${skillName}" not found` });
+      return;
+    }
+    const latestVersion = info["dist-tags"]?.latest || "unknown";
+    const pkg = latestVersion ? info.versions?.[latestVersion] : void 0;
+    const meta = pkg?.skillmarket;
+    const versionKeys = Object.keys(info.versions || {});
+    const recentVersions = versionKeys.slice(-20);
+    jsonResponse(res, 200, {
+      id: meta?.id || info.name.replace(/^@[^/]+\//, ""),
+      name: info.name,
+      displayName: meta?.displayName || info.name,
+      description: pkg?.description || "",
+      version: latestVersion,
+      platforms: meta?.platforms || [],
+      versions: recentVersions,
+      author: info.author?.name || pkg?.author?.name || "",
+      license: info.license || "",
+      homepage: pkg?.homepage || "",
+      repository: pkg?.repository?.url || "",
+      readme: info.readme || ""
+    });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/install"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const version = body.version ? String(body.version) : void 0;
+    const platform = body.platform ? String(body.platform) : void 0;
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    await installSkill(skillId, version, {
+      platforms: platform ? [platform] : void 0,
+      force: true
+    });
+    jsonResponse(res, 200, { success: true, message: `${skillId} installed successfully` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/uninstall"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const platform = body.platform ? String(body.platform) : void 0;
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    await uninstallSkill(skillId, {
+      platforms: platform ? [platform] : void 0,
+      yes: true
+    });
+    jsonResponse(res, 200, { success: true, message: `${skillId} uninstalled successfully` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/update"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = body.skillId ? String(body.skillId) : void 0;
+    await updateSkill(skillId);
+    const msg = skillId ? `${skillId} updated successfully` : "All skills updated successfully";
+    jsonResponse(res, 200, { success: true, message: msg });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+function serveStaticFile(res, filePath) {
+  if (!existsSync4(filePath)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  const content = readFileSync(filePath);
+  const ext = extname(filePath);
+  const mime = MIME_TYPES[ext] || "application/octet-stream";
+  res.writeHead(200, { "Content-Type": mime });
+  res.end(content);
+}
+async function handleRequest(req, res) {
+  const method = req.method || "GET";
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  const pathname = url.pathname;
+  const routeHandler = API_ROUTES[method]?.[pathname];
+  if (routeHandler) {
+    try {
+      await routeHandler(req, res, url);
+    } catch (err) {
+      jsonResponse(res, 500, { error: String(err) });
+    }
+    return;
+  }
+  if (pathname.startsWith("/api/")) {
+    jsonResponse(res, 404, { error: `Unknown API endpoint: ${method} ${pathname}` });
+    return;
+  }
+  const filePath = join4(guiDir, pathname === "/" ? "index.html" : pathname);
+  if (filePath.startsWith(guiDir)) {
+    serveStaticFile(res, filePath);
+  } else {
+    res.writeHead(403);
+    res.end("Forbidden");
+  }
+}
+function startGuiServer(port = 18770) {
+  const server = createServer(handleRequest);
+  server.listen(port, () => {
+    console.log(`
+\u{1F680} SkillMarket GUI started!`);
+    console.log(`   Local: http://localhost:${port}`);
+    console.log(`
+Press Ctrl+C to stop
+`);
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`\u274C Port ${port} is already in use. Try: skm gui ${port + 1}`);
+    } else {
+      console.error("\u274C Failed to start GUI server:", err.message);
+    }
+    process.exit(1);
+  });
+}
+
 // 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 __filename3 = fileURLToPath4(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+var packageJson = JSON.parse(readFileSync2(resolve(__dirname3, "../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(VERSION);
@@ -1550,4 +1959,24 @@ platformsCmd.action(async () => {
     process.exit(1);
   }
 });
+program.command("gui [port]").description("Start SkillMarket GUI (web interface)").action(async (port) => {
+  const portNum = port ? parseInt(port) : 18770;
+  startGuiServer(portNum);
+});
+program.command("publish <skill>").description("Publish a skill to npm").option("-v, --version <version>", "Specify version (optional, auto-increment patch if not specified)").action(async (skill, options) => {
+  try {
+    await publishSkill(skill, options.version ? { version: options.version } : void 0);
+  } catch (err) {
+    console.error("Publish failed:", err);
+    process.exit(1);
+  }
+});
+program.command("verify <skill>").description("Verify skill integrity and format").action(async (skill) => {
+  try {
+    await verifySkill(skill);
+  } catch (err) {
+    console.error("Verify failed:", err);
+    process.exit(1);
+  }
+});
 program.parse();