skillverse 0.1.0 → 0.1.2

package/dist/bin.js

@@ -0,0 +1,2421 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import { join, dirname } from "path";
+import { existsSync, mkdirSync } from "fs";
+import { fileURLToPath } from "url";
+import dotenv from "dotenv";
+function setupEnvironment() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const skillverseHome = process.env.SKILLVERSE_HOME || join(home, ".skillverse");
+  const dbUrl = process.env.DATABASE_URL;
+  if (!existsSync(skillverseHome)) {
+    try {
+      mkdirSync(skillverseHome, { recursive: true });
+    } catch (error) {
+      console.error("Failed to create .skillverse directory:", error);
+    }
+  }
+  if (!dbUrl) {
+    const dbPath = join(skillverseHome, "skillverse.db");
+    process.env.DATABASE_URL = `file:${dbPath}`;
+  }
+  return {
+    skillverseHome,
+    databaseUrl: process.env.DATABASE_URL
+  };
+}
+var __filename, __dirname, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    dotenv.config();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    config = setupEnvironment();
+  }
+});
+
+// src/lib/db.ts
+import { PrismaClient } from "@prisma/client";
+var globalForPrisma, prisma;
+var init_db = __esm({
+  "src/lib/db.ts"() {
+    "use strict";
+    init_config();
+    globalForPrisma = globalThis;
+    prisma = globalForPrisma.prisma ?? new PrismaClient({
+      log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"]
+    });
+    if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+  }
+});
+
+// ../shared/dist/index.js
+var WORKSPACE_SKILLS_PATHS, ErrorCode;
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    WORKSPACE_SKILLS_PATHS = {
+      vscode: {
+        project: ".github/skills",
+        global: "~/.copilot/skills"
+      },
+      cursor: {
+        project: ".cursor/skills",
+        global: "~/.cursor/skills"
+      },
+      "claude-desktop": {
+        project: ".claude/skills",
+        global: "~/.claude/skills"
+      },
+      codex: {
+        project: ".codex/skills",
+        global: "~/.codex/skills"
+      },
+      antigravity: {
+        project: ".agent/skills",
+        global: "~/.agent/skills"
+      },
+      custom: {
+        project: "skills",
+        global: ""
+      }
+    };
+    ErrorCode = {
+      VALIDATION_ERROR: "VALIDATION_ERROR",
+      NOT_FOUND: "NOT_FOUND",
+      ALREADY_EXISTS: "ALREADY_EXISTS",
+      INTERNAL_ERROR: "INTERNAL_ERROR",
+      GIT_ERROR: "GIT_ERROR",
+      FILE_SYSTEM_ERROR: "FILE_SYSTEM_ERROR",
+      PERMISSION_ERROR: "PERMISSION_ERROR",
+      SYMLINK_ERROR: "SYMLINK_ERROR"
+    };
+  }
+});
+
+// src/middleware/errorHandler.ts
+function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+  if (err instanceof AppError) {
+    return res.status(err.statusCode).json({
+      success: false,
+      error: err.message,
+      code: err.code,
+      details: err.details
+    });
+  }
+  return res.status(500).json({
+    success: false,
+    error: "Internal server error",
+    code: ErrorCode.INTERNAL_ERROR,
+    message: process.env.NODE_ENV === "development" ? err.message : void 0
+  });
+}
+var AppError;
+var init_errorHandler = __esm({
+  "src/middleware/errorHandler.ts"() {
+    "use strict";
+    init_dist();
+    AppError = class extends Error {
+      constructor(code, message, statusCode = 500, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "AppError";
+      }
+    };
+  }
+});
+
+// src/services/skillService.ts
+import { join as join3, basename } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, rm, cp, readFile, unlink } from "fs/promises";
+import matter from "gray-matter";
+import simpleGit from "simple-git";
+import AdmZip from "adm-zip";
+function parseGitUrl(url) {
+  if (!url.includes("/tree/")) {
+    const urlParts = url.split("/");
+    const repoName = urlParts[urlParts.length - 1].replace(".git", "");
+    return { repoUrl: url, skillName: repoName };
+  }
+  const parts = url.split("/tree/");
+  const repoUrl = parts[0] + (parts[0].endsWith(".git") ? "" : ".git");
+  const pathParts = parts[1].split("/");
+  const branch = pathParts[0];
+  const subdir = pathParts.slice(1).join("/");
+  const skillName = pathParts[pathParts.length - 1];
+  return { repoUrl, subdir, skillName };
+}
+var SKILLVERSE_HOME, SKILLS_DIR, TEMP_DIR, SkillService, skillService;
+var init_skillService = __esm({
+  "src/services/skillService.ts"() {
+    "use strict";
+    init_db();
+    init_errorHandler();
+    init_dist();
+    SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join3(process.env.HOME || "", ".skillverse");
+    SKILLS_DIR = process.env.SKILLS_DIR || join3(SKILLVERSE_HOME, "skills");
+    TEMP_DIR = process.env.TEMP_DIR || join3(SKILLVERSE_HOME, "temp");
+    SkillService = class {
+      async getAllSkills() {
+        const skills = await prisma.skill.findMany({
+          include: {
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
+          },
+          orderBy: {
+            installDate: "desc"
+          }
+        });
+        return skills;
+      }
+      async getSkillById(id) {
+        const skill = await prisma.skill.findUnique({
+          where: { id },
+          include: {
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
+          }
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+        }
+        return skill;
+      }
+      async getSkillByName(name) {
+        const skill = await prisma.skill.findUnique({
+          where: { name },
+          include: {
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
+          }
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, `Skill "${name}" not found`, 404);
+        }
+        return skill;
+      }
+      async parseSkillMetadata(skillPath) {
+        try {
+          const skillMdPath = join3(skillPath, "SKILL.md");
+          let description = "";
+          let metadata = {};
+          if (existsSync3(skillMdPath)) {
+            const fileContent = await readFile(skillMdPath, "utf-8");
+            const parsed = matter(fileContent);
+            description = parsed.data.description || "";
+            metadata = parsed.data;
+          }
+          if (!description) {
+            const packageJsonPath = join3(skillPath, "package.json");
+            const skillJsonPath = join3(skillPath, "skill.json");
+            if (existsSync3(skillJsonPath)) {
+              const content = await readFile(skillJsonPath, "utf-8");
+              const json = JSON.parse(content);
+              description = json.description || "";
+              metadata = { ...metadata, ...json };
+            } else if (existsSync3(packageJsonPath)) {
+              const content = await readFile(packageJsonPath, "utf-8");
+              const pkg = JSON.parse(content);
+              description = pkg.description || "";
+              metadata = { ...metadata, name: pkg.name, version: pkg.version };
+            }
+          }
+          return { description, metadata };
+        } catch (error) {
+          console.warn("Failed to parse skill metadata:", error);
+          return { description: "", metadata: {} };
+        }
+      }
+      async createSkillFromGit(gitUrl, description) {
+        let tempPath = null;
+        try {
+          const { repoUrl, subdir, skillName } = parseGitUrl(gitUrl);
+          const existingSkill = await prisma.skill.findUnique({
+            where: { name: skillName }
+          });
+          if (existingSkill) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+          }
+          const skillPath = join3(SKILLS_DIR, skillName);
+          if (existsSync3(skillPath)) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+          }
+          let commitHash = "";
+          if (subdir) {
+            tempPath = join3(TEMP_DIR, `git-clone-${Date.now()}`);
+            await mkdir(tempPath, { recursive: true });
+            console.log(`Cloning ${repoUrl} to temp path for extraction...`);
+            const git = simpleGit();
+            await git.clone(repoUrl, tempPath);
+            try {
+              commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
+              console.log(`Captured commit hash: ${commitHash}`);
+            } catch (e) {
+              console.warn("Failed to capture commit hash:", e);
+            }
+            const sourcePath = join3(tempPath, subdir);
+            if (!existsSync3(sourcePath)) {
+              throw new AppError(
+                ErrorCode.GIT_ERROR,
+                `Subdirectory "${subdir}" not found in repository`,
+                400
+              );
+            }
+            const hasSkillMd = existsSync3(join3(sourcePath, "SKILL.md"));
+            const hasSkillJson = existsSync3(join3(sourcePath, "skill.json"));
+            const hasPackageJson = existsSync3(join3(sourcePath, "package.json"));
+            if (!hasSkillMd && !hasSkillJson && !hasPackageJson) {
+              throw new AppError(
+                ErrorCode.VALIDATION_ERROR,
+                `Invalid skill structure: "${subdir}" does not contain SKILL.md, skill.json, or package.json`,
+                400
+              );
+            }
+            await mkdir(skillPath, { recursive: true });
+            await cp(sourcePath, skillPath, { recursive: true });
+          } else {
+            if (!existsSync3(skillPath)) {
+              await mkdir(skillPath, { recursive: true });
+            }
+            const git = simpleGit();
+            console.log(`Cloning ${gitUrl} to ${skillPath}...`);
+            await git.clone(gitUrl, skillPath);
+            try {
+              commitHash = await git.cwd(skillPath).revparse(["HEAD"]);
+              console.log(`Captured commit hash: ${commitHash}`);
+            } catch (e) {
+              console.warn("Failed to capture commit hash:", e);
+            }
+          }
+          const parsed = await this.parseSkillMetadata(skillPath);
+          const skill = await prisma.skill.create({
+            data: {
+              name: skillName,
+              source: "git",
+              sourceUrl: gitUrl,
+              repoUrl,
+              commitHash,
+              description: description || parsed.description || "",
+              storagePath: skillPath,
+              metadata: JSON.stringify(parsed.metadata)
+            }
+          });
+          return skill;
+        } catch (error) {
+          throw error;
+        } finally {
+          if (tempPath && existsSync3(tempPath)) {
+            await rm(tempPath, { recursive: true, force: true }).catch(console.error);
+          }
+        }
+      }
+      async createSkillFromDirectory(path, name, description) {
+        if (!existsSync3(path)) {
+          throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 400);
+        }
+        const skillName = name || basename(path);
+        const skillPath = join3(SKILLS_DIR, skillName);
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name: skillName }
+        });
+        if (existingSkill) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${skillName}" already exists`, 409);
+        }
+        if (existsSync3(skillPath)) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+        }
+        try {
+          await mkdir(skillPath, { recursive: true });
+          await cp(path, skillPath, { recursive: true });
+          const parsed = await this.parseSkillMetadata(skillPath);
+          const skill = await prisma.skill.create({
+            data: {
+              name: skillName,
+              source: "local",
+              description: description || parsed.description || "",
+              storagePath: skillPath,
+              metadata: JSON.stringify(parsed.metadata)
+            }
+          });
+          return skill;
+        } catch (error) {
+          if (existsSync3(skillPath)) {
+            await rm(skillPath, { recursive: true, force: true }).catch(() => {
+            });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Helper to handle cases where the archive contains a single top-level directory.
+       * Moves contents up one level if that's the case.
+       */
+      async stripTopLevelDirectory(targetPath) {
+        const { readdir: readdir2, rename, rmdir, stat: stat2 } = await import("fs/promises");
+        const items = await readdir2(targetPath);
+        const validItems = items.filter((i) => i !== ".DS_Store" && i !== "__MACOSX");
+        if (validItems.length === 1) {
+          const topLevelItem = validItems[0];
+          const topLevelPath = join3(targetPath, topLevelItem);
+          const stats = await stat2(topLevelPath);
+          if (stats.isDirectory()) {
+            console.log(`Striping top-level directory: ${topLevelItem}`);
+            const subItems = await readdir2(topLevelPath);
+            for (const item of subItems) {
+              await rename(join3(topLevelPath, item), join3(targetPath, item));
+            }
+            await rmdir(topLevelPath);
+          }
+        }
+      }
+      async createSkillFromLocal(name, zipPath, description) {
+        const skillPath = join3(SKILLS_DIR, name);
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name }
+        });
+        if (existingSkill) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${name}" already exists`, 409);
+        }
+        if (existsSync3(skillPath)) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+        }
+        const extractPath = join3(TEMP_DIR, `extract-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        await mkdir(extractPath, { recursive: true });
+        try {
+          const zip = new AdmZip(zipPath);
+          zip.extractAllTo(extractPath, true);
+          await this.stripTopLevelDirectory(extractPath);
+          const parsed = await this.parseSkillMetadata(extractPath);
+          if (existsSync3(skillPath)) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+          }
+          await import("fs/promises").then((fs) => fs.rename(extractPath, skillPath));
+          const skill = await prisma.skill.create({
+            data: {
+              name,
+              source: "local",
+              description: description || parsed.description || "",
+              storagePath: skillPath,
+              metadata: JSON.stringify(parsed.metadata)
+            }
+          });
+          return skill;
+        } catch (error) {
+          if (existsSync3(skillPath)) {
+            await rm(skillPath, { recursive: true, force: true }).catch(() => {
+            });
+          }
+          if (existsSync3(extractPath)) {
+            await rm(extractPath, { recursive: true, force: true }).catch(() => {
+            });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Create a skill from a tar.gz bundle (marketplace install)
+       * @param bundlePath - Path to the .tar.gz bundle
+       * @param originalName - Original skill name
+       * @param description - Optional skill description
+       */
+      async createSkillFromBundle(bundlePath, originalName, description) {
+        let name = originalName;
+        let counter = 1;
+        while (await prisma.skill.findUnique({ where: { name } })) {
+          name = `${originalName}-${counter}`;
+          counter++;
+        }
+        const skillPath = join3(SKILLS_DIR, name);
+        const extractPath = join3(TEMP_DIR, `extract-bundle-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        await mkdir(extractPath, { recursive: true });
+        try {
+          const { createReadStream: createReadStream2 } = await import("fs");
+          const { createGunzip: createGunzip2 } = await import("zlib");
+          const tar = await import("tar");
+          const { pipeline: pipeline2 } = await import("stream/promises");
+          await pipeline2(
+            createReadStream2(bundlePath),
+            createGunzip2(),
+            tar.extract({ cwd: extractPath })
+          );
+          await this.stripTopLevelDirectory(extractPath);
+          const parsed = await this.parseSkillMetadata(extractPath);
+          if (existsSync3(skillPath)) {
+            throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+          }
+          await import("fs/promises").then((fs) => fs.rename(extractPath, skillPath));
+          const skill = await prisma.skill.create({
+            data: {
+              name,
+              source: "local",
+              description: description || parsed.description || "",
+              storagePath: skillPath,
+              metadata: JSON.stringify(parsed.metadata)
+            }
+          });
+          console.log(`\u{1F4E6} Installed skill "${name}" from bundle`);
+          return skill;
+        } catch (error) {
+          if (existsSync3(skillPath)) {
+            await rm(skillPath, { recursive: true, force: true }).catch(() => {
+            });
+          }
+          if (existsSync3(extractPath)) {
+            await rm(extractPath, { recursive: true, force: true }).catch(() => {
+            });
+          }
+          throw error;
+        }
+      }
+      async updateSkill(id, data) {
+        const skill = await this.getSkillById(id);
+        const updatedSkill = await prisma.skill.update({
+          where: { id },
+          data: {
+            ...data.name && { name: data.name },
+            ...data.description !== void 0 && { description: data.description },
+            ...data.metadata && { metadata: JSON.stringify(data.metadata) }
+          }
+        });
+        return updatedSkill;
+      }
+      async deleteSkill(id, removeFiles = true) {
+        const skill = await this.getSkillById(id);
+        if (skill.linkedWorkspaces && skill.linkedWorkspaces.length > 0) {
+          for (const link of skill.linkedWorkspaces) {
+            try {
+              const workspacePath = link.workspace.path;
+              const symlinkPath = join3(workspacePath, skill.name);
+              if (existsSync3(symlinkPath)) {
+                const stats = await import("fs/promises").then((fs) => fs.lstat(symlinkPath));
+                if (stats.isSymbolicLink()) {
+                  await unlink(symlinkPath);
+                  console.log(`Removed symlink for ${skill.name} in workspace ${workspacePath}`);
+                }
+              }
+            } catch (error) {
+              console.warn(`Failed to remove symlink for ${skill.name} in workspace ${link.workspace.path}:`, error);
+            }
+          }
+        }
+        await prisma.skill.delete({
+          where: { id }
+        });
+        if (removeFiles && skill.storagePath) {
+          await rm(skill.storagePath, { recursive: true, force: true }).catch((err) => {
+            console.warn(`Failed to delete skill directory ${skill.storagePath}:`, err);
+          });
+        }
+        return { success: true, message: "Skill deleted successfully" };
+      }
+      // Check for updates
+      async checkForUpdate(id) {
+        const skill = await this.getSkillById(id);
+        if (skill.source !== "git" || !skill.repoUrl) {
+          return {
+            hasUpdate: false,
+            currentHash: skill.commitHash,
+            remoteHash: null,
+            message: "Not a git skill or missing repo URL"
+          };
+        }
+        const tempPath = join3(TEMP_DIR, `check-update-${Date.now()}`);
+        await mkdir(tempPath, { recursive: true });
+        try {
+          const git = simpleGit();
+          console.log(`Checking updates for ${skill.name} from ${skill.repoUrl}...`);
+          const remote = await git.listRemote([skill.repoUrl, "HEAD"]);
+          if (!remote) {
+            throw new Error("Failed to get remote HEAD");
+          }
+          const remoteHash = remote.split("	")[0];
+          const hasUpdate = remoteHash !== skill.commitHash;
+          await prisma.skill.update({
+            where: { id },
+            data: {
+              lastUpdateCheck: /* @__PURE__ */ new Date(),
+              updateAvailable: hasUpdate
+            }
+          });
+          return {
+            hasUpdate,
+            currentHash: skill.commitHash,
+            remoteHash
+          };
+        } catch (error) {
+          console.error("Update check error:", error);
+          throw new AppError(ErrorCode.GIT_ERROR, `Failed to check for updates: ${error.message}`, 500);
+        } finally {
+          await rm(tempPath, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+      async checkUpdates(ids) {
+        const whereClause = {
+          source: "git",
+          repoUrl: { not: null }
+        };
+        if (ids && ids.length > 0) {
+          whereClause.id = { in: ids };
+        }
+        const skills = await prisma.skill.findMany({ where: whereClause });
+        const results = {};
+        console.log(`Checking updates for ${skills.length} skills...`);
+        await Promise.all(skills.map(async (skill) => {
+          try {
+            const result = await this.checkForUpdate(skill.id);
+            results[skill.id] = result;
+          } catch (e) {
+            results[skill.id] = { error: e.message };
+          }
+        }));
+        return results;
+      }
+      async refreshMetadata(id) {
+        const skill = await this.getSkillById(id);
+        const parsed = await this.parseSkillMetadata(skill.storagePath);
+        const updated = await prisma.skill.update({
+          where: { id },
+          data: {
+            description: parsed.description,
+            metadata: JSON.stringify(parsed.metadata)
+          }
+        });
+        return updated;
+      }
+      async upgradeSkill(id) {
+        const skill = await this.getSkillById(id);
+        if (skill.source !== "git" || !skill.sourceUrl) {
+          throw new AppError(ErrorCode.VALIDATION_ERROR, "Cannot upgrade non-git skill", 400);
+        }
+        let tempPath = null;
+        let tempSkillPath = null;
+        try {
+          const { repoUrl, subdir } = parseGitUrl(skill.sourceUrl);
+          tempPath = join3(TEMP_DIR, `upgrade-${Date.now()}`);
+          await mkdir(tempPath, { recursive: true });
+          const git = simpleGit();
+          console.log(`Cloning ${repoUrl} to temp for upgrade...`);
+          await git.clone(repoUrl, tempPath);
+          let commitHash = "";
+          try {
+            commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
+          } catch (e) {
+            console.warn("Failed to capture commit hash during upgrade:", e);
+          }
+          let sourcePath = tempPath;
+          if (subdir) {
+            sourcePath = join3(tempPath, subdir);
+            if (!existsSync3(sourcePath)) {
+              throw new AppError(ErrorCode.GIT_ERROR, `Subdirectory "${subdir}" not found`, 400);
+            }
+          }
+          const hasSkillMd = existsSync3(join3(sourcePath, "SKILL.md"));
+          const hasSkillJson = existsSync3(join3(sourcePath, "skill.json"));
+          const hasPackageJson = existsSync3(join3(sourcePath, "package.json"));
+          if (!hasSkillMd && !hasSkillJson && !hasPackageJson) {
+            throw new AppError(ErrorCode.VALIDATION_ERROR, "Invalid skill structure in new version", 400);
+          }
+          const files = await import("fs/promises").then((fs) => fs.readdir(skill.storagePath));
+          for (const file of files) {
+            await rm(join3(skill.storagePath, file), { recursive: true, force: true });
+          }
+          await cp(sourcePath, skill.storagePath, { recursive: true });
+          const parsed = await this.parseSkillMetadata(skill.storagePath);
+          const updatedSkill = await prisma.skill.update({
+            where: { id },
+            data: {
+              commitHash,
+              updateAvailable: false,
+              lastUpdateCheck: /* @__PURE__ */ new Date(),
+              installDate: /* @__PURE__ */ new Date(),
+              // Considering upgrade as reinstall? Or user prefer generic updatedAt
+              // Keeping installDate as "last installed/upgraded"
+              description: parsed.description,
+              metadata: JSON.stringify(parsed.metadata)
+            }
+          });
+          return updatedSkill;
+        } catch (error) {
+          console.error("Upgrade error:", error);
+          throw new AppError(ErrorCode.GIT_ERROR, `Failed to upgrade skill: ${error.message}`, 500);
+        } finally {
+          if (tempPath) await rm(tempPath, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+    };
+    skillService = new SkillService();
+  }
+});
+
+// src/services/workspaceService.ts
+import { join as join4 } from "path";
+import { homedir } from "os";
+import { symlink, unlink as unlink2, rm as rm2, mkdir as mkdir2, appendFile, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync4, lstatSync } from "fs";
+function computeSkillsPath(projectPath, type, scope) {
+  const pathConfig = WORKSPACE_SKILLS_PATHS[type];
+  if (scope === "global") {
+    return pathConfig.global.replace("~", homedir());
+  }
+  return join4(projectPath, pathConfig.project);
+}
+var WorkspaceService, workspaceService;
+var init_workspaceService = __esm({
+  "src/services/workspaceService.ts"() {
+    "use strict";
+    init_db();
+    init_errorHandler();
+    init_dist();
+    WorkspaceService = class {
+      /**
+       * Helper to get expected skills path for a project
+       */
+      getSkillsPath(projectPath, type, scope) {
+        return computeSkillsPath(projectPath, type, scope);
+      }
+      /**
+       * Sync database links with filesystem state
+       * Removes links from DB if the symlink is missing from the workspace
+       */
+      async syncLinks(workspace) {
+        if (!workspace.linkedSkills || workspace.linkedSkills.length === 0) return;
+        for (const link of workspace.linkedSkills) {
+          if (!link.skill) continue;
+          const linkPath = join4(workspace.path, link.skill.name);
+          if (!existsSync4(linkPath)) {
+            console.log(`Link missing for skill "${link.skill.name}" in workspace "${workspace.name}". Removing from DB.`);
+            try {
+              await prisma.skillWorkspace.delete({
+                where: { id: link.id }
+              });
+              workspace.linkedSkills = workspace.linkedSkills.filter((l) => l.id !== link.id);
+            } catch (err) {
+              console.error(`Failed to sync link for ${link.skill.name}:`, err);
+            }
+          }
+        }
+      }
+      async findWorkspaceByPath(path) {
+        const workspace = await prisma.workspace.findUnique({
+          where: { path },
+          include: {
+            linkedSkills: {
+              include: {
+                skill: true
+              }
+            }
+          }
+        });
+        return workspace;
+      }
+      async getAllWorkspaces() {
+        const workspaces = await prisma.workspace.findMany({
+          include: {
+            linkedSkills: {
+              include: {
+                skill: true
+              }
+            }
+          },
+          orderBy: {
+            createdAt: "desc"
+          }
+        });
+        await Promise.all(workspaces.map((w) => this.syncLinks(w)));
+        return workspaces.map((workspace) => ({
+          ...workspace,
+          isPathValid: existsSync4(workspace.path)
+        }));
+      }
+      async getWorkspaceById(id) {
+        const workspace = await prisma.workspace.findUnique({
+          where: { id },
+          include: {
+            linkedSkills: {
+              include: {
+                skill: true
+              }
+            }
+          }
+        });
+        if (!workspace) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Workspace not found", 404);
+        }
+        await this.syncLinks(workspace);
+        return {
+          ...workspace,
+          isPathValid: existsSync4(workspace.path)
+        };
+      }
+      async createWorkspace(name, projectPath, type, scope) {
+        const skillsPath = computeSkillsPath(projectPath, type, scope);
+        if (scope === "project" && projectPath && !existsSync4(projectPath)) {
+          throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Project path does not exist: ${projectPath}`, 400);
+        }
+        if (!existsSync4(skillsPath)) {
+          try {
+            await mkdir2(skillsPath, { recursive: true });
+          } catch (err) {
+            throw new AppError(
+              ErrorCode.FILE_SYSTEM_ERROR,
+              `Failed to create skills directory: ${err.message}`,
+              500
+            );
+          }
+        }
+        const existingWorkspace = await prisma.workspace.findUnique({
+          where: { path: skillsPath }
+        });
+        if (existingWorkspace) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, "Workspace already exists at this path", 409);
+        }
+        const workspace = await prisma.workspace.create({
+          data: {
+            name,
+            path: skillsPath,
+            type,
+            scope
+          }
+        });
+        if (scope === "project" && projectPath && existsSync4(projectPath)) {
+          try {
+            const gitignorePath = join4(projectPath, ".gitignore");
+            const relativeSkillsPath = WORKSPACE_SKILLS_PATHS[type].project;
+            let shouldAppend = false;
+            if (existsSync4(gitignorePath)) {
+              const content = await readFile2(gitignorePath, "utf-8");
+              if (!content.includes(relativeSkillsPath)) {
+                shouldAppend = true;
+              }
+            } else {
+              shouldAppend = true;
+            }
+            if (shouldAppend) {
+              const ignoreEntry = `
+
+# SkillVerse
+${relativeSkillsPath}/
+`;
+              await appendFile(gitignorePath, ignoreEntry);
+              console.log(`Added ${relativeSkillsPath}/ to .gitignore in ${projectPath}`);
+            }
+          } catch (err) {
+            console.warn("Failed to update .gitignore:", err);
+          }
+        }
+        return {
+          ...workspace,
+          isPathValid: true
+        };
+      }
+      async updateWorkspace(id, data) {
+        await this.getWorkspaceById(id);
+        const workspace = await prisma.workspace.update({
+          where: { id },
+          data
+        });
+        return {
+          ...workspace,
+          isPathValid: existsSync4(workspace.path)
+        };
+      }
+      async deleteWorkspace(id) {
+        const workspace = await this.getWorkspaceById(id);
+        const links = await prisma.skillWorkspace.findMany({
+          where: { workspaceId: id },
+          include: { skill: true }
+        });
+        for (const link of links) {
+          try {
+            const linkPath = join4(workspace.path, link.skill.name);
+            if (existsSync4(linkPath)) {
+              await rm2(linkPath, { recursive: true, force: true });
+            }
+          } catch (error) {
+            console.error(`Failed to remove symlink for ${link.skill.name}:`, error);
+          }
+        }
+        await prisma.workspace.delete({ where: { id } });
+        return { success: true, message: "Workspace deleted successfully" };
+      }
+      async linkSkillToWorkspace(skillId, workspaceId) {
+        const skill = await prisma.skill.findUnique({ where: { id: skillId } });
+        const workspace = await prisma.workspace.findUnique({ where: { id: workspaceId } });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+        }
+        if (!workspace) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Workspace not found", 404);
+        }
+        if (!existsSync4(workspace.path)) {
+          throw new AppError(
+            ErrorCode.FILE_SYSTEM_ERROR,
+            `Workspace skills directory does not exist: ${workspace.path}. The folder may have been deleted. Please recreate it or remove this workspace.`,
+            400
+          );
+        }
+        const existingLink = await prisma.skillWorkspace.findFirst({
+          where: {
+            skillId,
+            workspaceId
+          }
+        });
+        if (existingLink) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, "Skill is already linked to this workspace", 409);
+        }
+        const targetPath = join4(workspace.path, skill.name);
+        try {
+          if (existsSync4(targetPath)) {
+            const stats = lstatSync(targetPath);
+            if (stats.isSymbolicLink()) {
+              await unlink2(targetPath);
+            } else {
+              throw new AppError(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                `A file or directory already exists at ${targetPath}`,
+                409
+              );
+            }
+          }
+          await symlink(skill.storagePath, targetPath, "dir");
+          const link = await prisma.skillWorkspace.create({
+            data: {
+              skillId,
+              workspaceId
+            },
+            include: {
+              skill: true,
+              workspace: true
+            }
+          });
+          return link;
+        } catch (error) {
+          if (error instanceof AppError) throw error;
+          console.error("Symlink creation error:", error);
+          throw new AppError(
+            ErrorCode.SYMLINK_ERROR,
+            `Failed to create symlink: ${error.message}`,
+            500,
+            error
+          );
+        }
+      }
+      async unlinkSkillFromWorkspace(skillId, workspaceId) {
+        const link = await prisma.skillWorkspace.findFirst({
+          where: {
+            skillId,
+            workspaceId
+          },
+          include: {
+            skill: true,
+            workspace: true
+          }
+        });
+        if (!link) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Link not found", 404);
+        }
+        const linkPath = join4(link.workspace.path, link.skill.name);
+        try {
+          if (existsSync4(linkPath)) {
+            await rm2(linkPath, { recursive: true, force: true });
+          }
+          await prisma.skillWorkspace.delete({
+            where: { id: link.id }
+          });
+          return { success: true, message: "Skill unlinked successfully" };
+        } catch (error) {
+          console.error("Unlink error:", error);
+          throw new AppError(
+            ErrorCode.FILE_SYSTEM_ERROR,
+            `Failed to unlink skill: ${error.message}`,
+            500,
+            error
+          );
+        }
+      }
+      /**
+       * Detect existing skills in a workspace skills directory
+       * Returns list of skill names that could be migrated
+       */
+      async detectExistingSkills(skillsPath) {
+        if (!existsSync4(skillsPath)) {
+          return [];
+        }
+        const { readdir: readdir2, stat: stat2, readFile: readFile3 } = await import("fs/promises");
+        const items = await readdir2(skillsPath);
+        const existingSkills = [];
+        for (const item of items) {
+          if (item.startsWith(".")) continue;
+          const itemPath = join4(skillsPath, item);
+          try {
+            const itemStat = await stat2(itemPath);
+            const lstats = lstatSync(itemPath);
+            if (lstats.isSymbolicLink()) continue;
+            if (itemStat.isDirectory()) {
+              const hasSkillMd = existsSync4(join4(itemPath, "SKILL.md"));
+              const hasSkillJson = existsSync4(join4(itemPath, "skill.json"));
+              const hasPackageJson = existsSync4(join4(itemPath, "package.json"));
+              if (hasSkillMd || hasSkillJson || hasPackageJson) {
+                existingSkills.push({
+                  name: item,
+                  hasSkillMd,
+                  path: itemPath
+                });
+              }
+            }
+          } catch (error) {
+            console.warn(`Failed to check ${itemPath}:`, error);
+          }
+        }
+        return existingSkills;
+      }
+      /**
+       * Migrate existing skills from workspace to unified storage
+       * 1. Move skills to ~/.skillverse/skills/
+       * 2. Register in database
+       * 3. Create symlinks back to workspace
+       */
+      async migrateExistingSkills(workspaceId, skillNames) {
+        const workspace = await this.getWorkspaceById(workspaceId);
+        const SKILLVERSE_HOME3 = process.env.SKILLVERSE_HOME || join4(homedir(), ".skillverse");
+        const SKILLS_DIR2 = process.env.SKILLS_DIR || join4(SKILLVERSE_HOME3, "skills");
+        if (!existsSync4(SKILLS_DIR2)) {
+          await mkdir2(SKILLS_DIR2, { recursive: true });
+        }
+        const { rename, readFile: readFile3, cp: cp2 } = await import("fs/promises");
+        const migrated = [];
+        const errors = [];
+        for (const skillName of skillNames) {
+          const sourcePath = join4(workspace.path, skillName);
+          const targetPath = join4(SKILLS_DIR2, skillName);
+          try {
+            if (!existsSync4(sourcePath)) {
+              errors.push(`${skillName}: Source path not found`);
+              continue;
+            }
+            const lstats = lstatSync(sourcePath);
+            if (lstats.isSymbolicLink()) {
+              errors.push(`${skillName}: Already a symlink, skipping`);
+              continue;
+            }
+            if (existsSync4(targetPath)) {
+              errors.push(`${skillName}: Already exists in unified storage`);
+              continue;
+            }
+            const existingSkill = await prisma.skill.findUnique({
+              where: { name: skillName }
+            });
+            if (existingSkill) {
+              errors.push(`${skillName}: Already registered in database`);
+              continue;
+            }
+            const skillMdPath = join4(sourcePath, "SKILL.md");
+            let description = "";
+            let metadata = {};
+            if (existsSync4(skillMdPath)) {
+              try {
+                const matter2 = await import("gray-matter");
+                const fileContent = await readFile3(skillMdPath, "utf-8");
+                const parsed = matter2.default(fileContent);
+                description = parsed.data.description || "";
+                metadata = parsed.data;
+              } catch (e) {
+                console.warn(`Failed to parse SKILL.md for ${skillName}:`, e);
+              }
+            }
+            await cp2(sourcePath, targetPath, { recursive: true });
+            await rm2(sourcePath, { recursive: true, force: true });
+            const skill = await prisma.skill.create({
+              data: {
+                name: skillName,
+                source: "local",
+                description,
+                storagePath: targetPath,
+                metadata: JSON.stringify(metadata)
+              }
+            });
+            await symlink(targetPath, sourcePath, "dir");
+            await prisma.skillWorkspace.create({
+              data: {
+                skillId: skill.id,
+                workspaceId: workspace.id
+              }
+            });
+            migrated.push(skillName);
+            console.log(`\u2705 Migrated skill "${skillName}" to unified storage`);
+          } catch (error) {
+            console.error(`Failed to migrate ${skillName}:`, error);
+            errors.push(`${skillName}: ${error.message}`);
+          }
+        }
+        return {
+          success: errors.length === 0,
+          migrated,
+          errors
+        };
+      }
+    };
+    workspaceService = new WorkspaceService();
+  }
+});
+
+// src/routes/skills.ts
+import { Router } from "express";
+import multer from "multer";
+import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
+var router, TEMP_DIR2, storage, upload, skills_default;
+var init_skills = __esm({
+  "src/routes/skills.ts"() {
+    "use strict";
+    init_skillService();
+    init_workspaceService();
+    router = Router();
+    TEMP_DIR2 = process.env.TEMP_DIR || join5(process.env.HOME || "", ".skillverse", "temp");
+    if (!existsSync5(TEMP_DIR2)) {
+      mkdir3(TEMP_DIR2, { recursive: true });
+    }
+    storage = multer.diskStorage({
+      destination: (req, file, cb) => {
+        cb(null, TEMP_DIR2);
+      },
+      filename: (req, file, cb) => {
+        const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
+        cb(null, uniqueSuffix + "-" + file.originalname);
+      }
+    });
+    upload = multer({
+      storage,
+      limits: {
+        fileSize: 100 * 1024 * 1024
+        // 100MB limit
+      },
+      fileFilter: (req, file, cb) => {
+        if (file.mimetype === "application/zip" || file.originalname.endsWith(".zip")) {
+          cb(null, true);
+        } else {
+          cb(new Error("Only ZIP files are allowed"));
+        }
+      }
+    });
+    router.get("/", async (req, res, next) => {
+      try {
+        const skills = await skillService.getAllSkills();
+        res.json({
+          success: true,
+          data: skills
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.get("/:id", async (req, res, next) => {
+      try {
+        const skill = await skillService.getSkillById(req.params.id);
+        res.json({
+          success: true,
+          data: skill
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post("/from-git", async (req, res, next) => {
+      try {
+        const { gitUrl, description } = req.body;
+        if (!gitUrl) {
+          return res.status(400).json({
+            success: false,
+            error: "gitUrl is required"
+          });
+        }
+        const skill = await skillService.createSkillFromGit(gitUrl, description);
+        res.status(201).json({
+          success: true,
+          data: skill,
+          message: "Skill created successfully from Git repository"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post(
+      "/from-local",
+      upload.single("file"),
+      async (req, res, next) => {
+        try {
+          const { name, description } = req.body;
+          const file = req.file;
+          if (!name) {
+            if (file) {
+              await rm3(file.path, { force: true });
+            }
+            return res.status(400).json({
+              success: false,
+              error: "name is required"
+            });
+          }
+          if (!file) {
+            return res.status(400).json({
+              success: false,
+              error: "ZIP file is required"
+            });
+          }
+          const skill = await skillService.createSkillFromLocal(name, file.path, description);
+          await rm3(file.path, { force: true });
+          res.status(201).json({
+            success: true,
+            data: skill,
+            message: "Skill created successfully from local file"
+          });
+        } catch (error) {
+          if (req.file) {
+            await rm3(req.file.path, { force: true }).catch(() => {
+            });
+          }
+          next(error);
+        }
+      }
+    );
+    router.put("/:id", async (req, res, next) => {
+      try {
+        const { name, description, metadata } = req.body;
+        const skill = await skillService.updateSkill(req.params.id, {
+          name,
+          description,
+          metadata
+        });
+        res.json({
+          success: true,
+          data: skill,
+          message: "Skill updated successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.delete("/:id", async (req, res, next) => {
+      try {
+        const removeFiles = req.query.removeFiles !== "false";
+        const result = await skillService.deleteSkill(req.params.id, removeFiles);
+        res.json(result);
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post("/:id/link", async (req, res, next) => {
+      try {
+        const { workspaceId } = req.body;
+        if (!workspaceId) {
+          return res.status(400).json({
+            success: false,
+            error: "workspaceId is required"
+          });
+        }
+        const link = await workspaceService.linkSkillToWorkspace(req.params.id, workspaceId);
+        res.status(201).json({
+          success: true,
+          data: link,
+          message: "Skill linked to workspace successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.delete(
+      "/:id/unlink/:workspaceId",
+      async (req, res, next) => {
+        try {
+          const result = await workspaceService.unlinkSkillFromWorkspace(
+            req.params.id,
+            req.params.workspaceId
+          );
+          res.json(result);
+        } catch (error) {
+          next(error);
+        }
+      }
+    );
+    router.get("/:id/check-update", async (req, res, next) => {
+      try {
+        const result = await skillService.checkForUpdate(req.params.id);
+        res.json({
+          success: true,
+          data: result
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post("/:id/upgrade", async (req, res, next) => {
+      try {
+        const skill = await skillService.upgradeSkill(req.params.id);
+        res.json({
+          success: true,
+          data: skill,
+          message: "Skill upgraded successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post("/check-updates", async (req, res, next) => {
+      try {
+        const { ids } = req.body;
+        const results = await skillService.checkUpdates(ids);
+        res.json({
+          success: true,
+          data: results
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.post("/:id/refresh-metadata", async (req, res, next) => {
+      try {
+        const skill = await skillService.refreshMetadata(req.params.id);
+        res.json({
+          success: true,
+          data: skill,
+          message: "Metadata refreshed successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router.get("/:id/skill-md", async (req, res, next) => {
+      try {
+        const { readFile: readFile3 } = await import("fs/promises");
+        const skill = await skillService.getSkillById(req.params.id);
+        const skillMdPath = join5(skill.storagePath, "SKILL.md");
+        if (!existsSync5(skillMdPath)) {
+          return res.json({
+            success: true,
+            data: {
+              exists: false,
+              content: null
+            }
+          });
+        }
+        const content = await readFile3(skillMdPath, "utf-8");
+        res.json({
+          success: true,
+          data: {
+            exists: true,
+            content
+          }
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    skills_default = router;
+  }
+});
+
+// src/routes/workspaces.ts
+import { Router as Router2 } from "express";
+var router2, workspaces_default;
+var init_workspaces = __esm({
+  "src/routes/workspaces.ts"() {
+    "use strict";
+    init_workspaceService();
+    router2 = Router2();
+    router2.get("/", async (req, res, next) => {
+      try {
+        const workspaces = await workspaceService.getAllWorkspaces();
+        res.json({
+          success: true,
+          data: workspaces
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.get("/:id", async (req, res, next) => {
+      try {
+        const workspace = await workspaceService.getWorkspaceById(req.params.id);
+        res.json({
+          success: true,
+          data: workspace
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.post("/", async (req, res, next) => {
+      try {
+        const { name, projectPath, type, scope } = req.body;
+        if (!name || !type || !scope) {
+          return res.status(400).json({
+            success: false,
+            error: "name, type, and scope are required"
+          });
+        }
+        if (scope === "project" && !projectPath) {
+          return res.status(400).json({
+            success: false,
+            error: "projectPath is required for project scope"
+          });
+        }
+        const validTypes = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+        if (!validTypes.includes(type)) {
+          return res.status(400).json({
+            success: false,
+            error: `type must be one of: ${validTypes.join(", ")}`
+          });
+        }
+        const validScopes = ["project", "global"];
+        if (!validScopes.includes(scope)) {
+          return res.status(400).json({
+            success: false,
+            error: `scope must be one of: ${validScopes.join(", ")}`
+          });
+        }
+        const workspace = await workspaceService.createWorkspace(name, projectPath || "", type, scope);
+        res.status(201).json({
+          success: true,
+          data: workspace,
+          message: "Workspace created successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.put("/:id", async (req, res, next) => {
+      try {
+        const { name, path, type, scope } = req.body;
+        if (type) {
+          const validTypes = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+          if (!validTypes.includes(type)) {
+            return res.status(400).json({
+              success: false,
+              error: `type must be one of: ${validTypes.join(", ")}`
+            });
+          }
+        }
+        if (scope) {
+          const validScopes = ["project", "global"];
+          if (!validScopes.includes(scope)) {
+            return res.status(400).json({
+              success: false,
+              error: `scope must be one of: ${validScopes.join(", ")}`
+            });
+          }
+        }
+        const workspace = await workspaceService.updateWorkspace(req.params.id, {
+          name,
+          path,
+          type,
+          scope
+        });
+        res.json({
+          success: true,
+          data: workspace,
+          message: "Workspace updated successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.delete("/:id", async (req, res, next) => {
+      try {
+        const result = await workspaceService.deleteWorkspace(req.params.id);
+        res.json(result);
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.post("/:id/detect-skills", async (req, res, next) => {
+      try {
+        const workspace = await workspaceService.getWorkspaceById(req.params.id);
+        const existingSkills = await workspaceService.detectExistingSkills(workspace.path);
+        res.json({
+          success: true,
+          data: existingSkills
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router2.post("/:id/migrate-skills", async (req, res, next) => {
+      try {
+        const { skillNames } = req.body;
+        if (!skillNames || !Array.isArray(skillNames) || skillNames.length === 0) {
+          return res.status(400).json({
+            success: false,
+            error: "skillNames array is required"
+          });
+        }
+        const result = await workspaceService.migrateExistingSkills(req.params.id, skillNames);
+        res.json({
+          success: true,
+          data: result
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    workspaces_default = router2;
+  }
+});
+
+// src/services/bundleService.ts
+var bundleService_exports = {};
+__export(bundleService_exports, {
+  bundleService: () => bundleService,
+  createBundle: () => createBundle,
+  deleteBundle: () => deleteBundle,
+  extractBundle: () => extractBundle,
+  getBundleSize: () => getBundleSize,
+  listBundles: () => listBundles
+});
+import { createWriteStream, existsSync as existsSync6, createReadStream } from "fs";
+import { mkdir as mkdir4, rm as rm4, readdir, stat } from "fs/promises";
+import { join as join6 } from "path";
+import { pipeline } from "stream/promises";
+import archiver from "archiver";
+import { createGunzip } from "zlib";
+import { extract } from "tar";
+async function ensureBundlesDir() {
+  if (!existsSync6(BUNDLES_DIR)) {
+    await mkdir4(BUNDLES_DIR, { recursive: true });
+  }
+}
+async function createBundle(skillPath, skillName) {
+  await ensureBundlesDir();
+  const bundleName = `${skillName}-${Date.now()}.tar.gz`;
+  const bundlePath = join6(BUNDLES_DIR, bundleName);
+  return new Promise((resolve, reject) => {
+    const output = createWriteStream(bundlePath);
+    const archive = archiver("tar", {
+      gzip: true,
+      gzipOptions: { level: 9 }
+    });
+    output.on("close", () => {
+      console.log(`\u{1F4E6} Bundle created: ${bundlePath} (${archive.pointer()} bytes)`);
+      resolve(bundlePath);
+    });
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    archive.pipe(output);
+    archive.directory(skillPath, false);
+    archive.finalize();
+  });
+}
+async function extractBundle(bundlePath, targetDir) {
+  if (!existsSync6(bundlePath)) {
+    throw new Error(`Bundle not found: ${bundlePath}`);
+  }
+  if (!existsSync6(targetDir)) {
+    await mkdir4(targetDir, { recursive: true });
+  }
+  await pipeline(
+    createReadStream(bundlePath),
+    createGunzip(),
+    extract({ cwd: targetDir })
+  );
+  console.log(`\u{1F4C2} Bundle extracted to: ${targetDir}`);
+}
+async function deleteBundle(bundlePath) {
+  if (existsSync6(bundlePath)) {
+    await rm4(bundlePath);
+    console.log(`\u{1F5D1}\uFE0F Bundle deleted: ${bundlePath}`);
+  }
+}
+async function getBundleSize(bundlePath) {
+  if (!existsSync6(bundlePath)) {
+    return 0;
+  }
+  const stats = await stat(bundlePath);
+  return stats.size;
+}
+async function listBundles() {
+  await ensureBundlesDir();
+  const files = await readdir(BUNDLES_DIR);
+  return files.filter((f) => f.endsWith(".tar.gz")).map((f) => join6(BUNDLES_DIR, f));
+}
+var BUNDLES_DIR, bundleService;
+var init_bundleService = __esm({
+  "src/services/bundleService.ts"() {
+    "use strict";
+    BUNDLES_DIR = join6(
+      process.env.SKILLVERSE_HOME || join6(process.env.HOME || "", ".skillverse"),
+      "bundles"
+    );
+    bundleService = {
+      createBundle,
+      extractBundle,
+      deleteBundle,
+      getBundleSize,
+      listBundles,
+      BUNDLES_DIR
+    };
+  }
+});
+
+// src/routes/marketplace.ts
+import { Router as Router3 } from "express";
+import { existsSync as existsSync7 } from "fs";
+var router3, marketplace_default;
+var init_marketplace = __esm({
+  "src/routes/marketplace.ts"() {
+    "use strict";
+    init_db();
+    init_skillService();
+    init_bundleService();
+    init_errorHandler();
+    init_dist();
+    router3 = Router3();
+    router3.get("/skills", async (req, res, next) => {
+      try {
+        const { search, page = "1", pageSize = "20" } = req.query;
+        const where = {};
+        if (search) {
+          where.skill = {
+            OR: [
+              { name: { contains: search } },
+              { description: { contains: search } }
+            ]
+          };
+        }
+        const [items, total] = await Promise.all([
+          prisma.marketplaceSkill.findMany({
+            where,
+            include: {
+              skill: true
+            },
+            orderBy: {
+              downloads: "desc"
+            },
+            skip: (parseInt(page) - 1) * parseInt(pageSize),
+            take: parseInt(pageSize)
+          }),
+          prisma.marketplaceSkill.count({ where })
+        ]);
+        res.json({
+          success: true,
+          data: {
+            items,
+            total,
+            page: parseInt(page),
+            pageSize: parseInt(pageSize)
+          }
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router3.get("/skills/:id", async (req, res, next) => {
+      try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+          where: { id: req.params.id },
+          include: {
+            skill: true
+          }
+        });
+        if (!marketplaceSkill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+        }
+        res.json({
+          success: true,
+          data: marketplaceSkill
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router3.get("/download/:id", async (req, res, next) => {
+      try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+          where: { id: req.params.id },
+          include: {
+            skill: true
+          }
+        });
+        if (!marketplaceSkill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+        }
+        if (marketplaceSkill.skill.source === "git" && marketplaceSkill.skill.sourceUrl) {
+          return res.json({
+            success: true,
+            data: {
+              type: "git",
+              sourceUrl: marketplaceSkill.skill.sourceUrl
+            }
+          });
+        }
+        if (marketplaceSkill.bundlePath && existsSync7(marketplaceSkill.bundlePath)) {
+          res.setHeader("Content-Type", "application/gzip");
+          res.setHeader(
+            "Content-Disposition",
+            `attachment; filename="${marketplaceSkill.skill.name}.tar.gz"`
+          );
+          return res.sendFile(marketplaceSkill.bundlePath);
+        }
+        throw new AppError(ErrorCode.NOT_FOUND, "Bundle not available for this skill", 404);
+      } catch (error) {
+        next(error);
+      }
+    });
+    router3.post("/publish", async (req, res, next) => {
+      try {
+        const { skillId, publisherName } = req.body;
+        if (!skillId) {
+          return res.status(400).json({
+            success: false,
+            error: "skillId is required"
+          });
+        }
+        const skill = await prisma.skill.findUnique({
+          where: { id: skillId }
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+        }
+        const existingEntry = await prisma.marketplaceSkill.findUnique({
+          where: { skillId }
+        });
+        if (existingEntry) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, "Skill is already published to marketplace", 409);
+        }
+        let bundlePath = null;
+        let bundleSize = null;
+        if (skill.source === "local" && existsSync7(skill.storagePath)) {
+          bundlePath = await bundleService.createBundle(skill.storagePath, skill.name);
+          bundleSize = await bundleService.getBundleSize(bundlePath);
+        }
+        const marketplaceSkill = await prisma.marketplaceSkill.create({
+          data: {
+            skillId,
+            publisherName: publisherName || "Anonymous",
+            bundlePath,
+            bundleSize
+          },
+          include: {
+            skill: true
+          }
+        });
+        res.status(201).json({
+          success: true,
+          data: marketplaceSkill,
+          message: "Skill published to marketplace successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router3.post("/install/:id", async (req, res, next) => {
+      try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+          where: { id: req.params.id },
+          include: {
+            skill: true
+          }
+        });
+        if (!marketplaceSkill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Marketplace skill not found", 404);
+        }
+        const sourceSkill = marketplaceSkill.skill;
+        if (sourceSkill.source === "git" && sourceSkill.sourceUrl) {
+          const newSkill = await skillService.createSkillFromGit(
+            sourceSkill.sourceUrl,
+            sourceSkill.description || void 0
+          );
+          await prisma.marketplaceSkill.update({
+            where: { id: req.params.id },
+            data: { downloads: { increment: 1 } }
+          });
+          return res.status(201).json({
+            success: true,
+            data: newSkill,
+            message: "Skill installed from marketplace successfully"
+          });
+        }
+        if (sourceSkill.source === "local" && marketplaceSkill.bundlePath && existsSync7(marketplaceSkill.bundlePath)) {
+          const newSkill = await skillService.createSkillFromBundle(
+            marketplaceSkill.bundlePath,
+            sourceSkill.name,
+            sourceSkill.description || void 0
+          );
+          await prisma.marketplaceSkill.update({
+            where: { id: req.params.id },
+            data: { downloads: { increment: 1 } }
+          });
+          return res.status(201).json({
+            success: true,
+            data: newSkill,
+            message: "Skill installed from marketplace successfully"
+          });
+        }
+        return res.status(400).json({
+          success: false,
+          error: "Cannot install this skill. Bundle not available."
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router3.delete("/unpublish/:skillId", async (req, res, next) => {
+      try {
+        const marketplaceSkill = await prisma.marketplaceSkill.findUnique({
+          where: { skillId: req.params.skillId }
+        });
+        if (!marketplaceSkill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill is not published to marketplace", 404);
+        }
+        await prisma.marketplaceSkill.delete({
+          where: { id: marketplaceSkill.id }
+        });
+        res.json({
+          success: true,
+          message: "Skill unpublished from marketplace successfully"
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    marketplace_default = router3;
+  }
+});
+
+// src/routes/dashboard.ts
+import { Router as Router4 } from "express";
+var router4, dashboard_default;
+var init_dashboard = __esm({
+  "src/routes/dashboard.ts"() {
+    "use strict";
+    init_db();
+    router4 = Router4();
+    router4.get("/stats", async (req, res, next) => {
+      try {
+        const [totalSkills, totalWorkspaces, totalLinks, marketplaceSkills, recentSkills] = await Promise.all([
+          prisma.skill.count(),
+          prisma.workspace.count(),
+          prisma.skillWorkspace.count(),
+          prisma.marketplaceSkill.count(),
+          prisma.skill.findMany({
+            orderBy: { installDate: "desc" },
+            take: 5,
+            include: {
+              linkedWorkspaces: {
+                include: {
+                  workspace: true
+                }
+              }
+            }
+          })
+        ]);
+        res.json({
+          success: true,
+          data: {
+            totalSkills,
+            totalWorkspaces,
+            totalLinks,
+            marketplaceSkills,
+            recentSkills
+          }
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    router4.get("/activity", async (req, res, next) => {
+      try {
+        const [recentSkills, recentLinks, recentPublished] = await Promise.all([
+          prisma.skill.findMany({
+            orderBy: { createdAt: "desc" },
+            take: 10,
+            select: {
+              id: true,
+              name: true,
+              source: true,
+              createdAt: true
+            }
+          }),
+          prisma.skillWorkspace.findMany({
+            orderBy: { linkedAt: "desc" },
+            take: 10,
+            include: {
+              skill: { select: { name: true } },
+              workspace: { select: { name: true } }
+            }
+          }),
+          prisma.marketplaceSkill.findMany({
+            orderBy: { publishDate: "desc" },
+            take: 10,
+            include: {
+              skill: { select: { name: true } }
+            }
+          })
+        ]);
+        const activities = [
+          ...recentSkills.map((s) => ({
+            type: "skill_added",
+            date: s.createdAt,
+            data: { skillName: s.name, source: s.source }
+          })),
+          ...recentLinks.map((l) => ({
+            type: "skill_linked",
+            date: l.linkedAt,
+            data: { skillName: l.skill.name, workspaceName: l.workspace.name }
+          })),
+          ...recentPublished.map((p) => ({
+            type: "skill_published",
+            date: p.publishDate,
+            data: { skillName: p.skill.name }
+          }))
+        ].sort((a, b) => b.date.getTime() - a.date.getTime());
+        res.json({
+          success: true,
+          data: activities.slice(0, 20)
+        });
+      } catch (error) {
+        next(error);
+      }
+    });
+    dashboard_default = router4;
+  }
+});
+
+// src/middleware/logger.ts
+function requestLogger(req, res, next) {
+  const start = Date.now();
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(`${req.method} ${req.path} - ${res.statusCode} - ${duration}ms`);
+  });
+  next();
+}
+var init_logger = __esm({
+  "src/middleware/logger.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  startServer: () => startServer
+});
+import express from "express";
+import cors from "cors";
+import dotenv2 from "dotenv";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, join as join7 } from "path";
+import { mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+async function initializeStorage() {
+  const skillverseHome = process.env.SKILLVERSE_HOME || join7(process.env.HOME || "", ".skillverse");
+  const skillsDir = process.env.SKILLS_DIR || join7(skillverseHome, "skills");
+  const marketplaceDir = process.env.MARKETPLACE_DIR || join7(skillverseHome, "marketplace");
+  const dirs = [skillverseHome, skillsDir, marketplaceDir];
+  for (const dir of dirs) {
+    if (!existsSync8(dir)) {
+      await mkdir5(dir, { recursive: true });
+      console.log(`Created directory: ${dir}`);
+    }
+  }
+}
+async function startServer(port = parseInt(process.env.PORT || "3001")) {
+  try {
+    await initializeStorage();
+    return new Promise((resolve) => {
+      app.listen(port, () => {
+        console.log(`\u{1F680} SkillVerse server running on http://localhost:${port}`);
+        console.log(`\u{1F4C1} Storage: ${process.env.SKILLVERSE_HOME || join7(process.env.HOME || "", ".skillverse")}`);
+        resolve();
+      });
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+var __filename3, __dirname3, app, PORT, possiblePublicDirs, publicDir;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_skills();
+    init_workspaces();
+    init_marketplace();
+    init_dashboard();
+    init_errorHandler();
+    init_logger();
+    dotenv2.config();
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = dirname3(__filename3);
+    app = express();
+    PORT = process.env.PORT || 3001;
+    app.use(cors());
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    app.use(requestLogger);
+    possiblePublicDirs = [
+      join7(__dirname3, "../public"),
+      // Production: dist/index.js -> public
+      join7(__dirname3, "../../public"),
+      // Dev tsx might resolve here 
+      join7(process.cwd(), "public"),
+      // Fallback: relative to cwd
+      join7(process.cwd(), "server/public")
+      // Fallback: from root
+    ];
+    publicDir = possiblePublicDirs.find((dir) => existsSync8(dir));
+    if (publicDir) {
+      app.use(express.static(publicDir));
+      console.log(`\u{1F4C2} Serving static files from: ${publicDir}`);
+    } else {
+      console.warn('\u26A0\uFE0F  No public directory found. Run "npm run build" in client first.');
+    }
+    app.use("/api/skills", skills_default);
+    app.use("/api/workspaces", workspaces_default);
+    app.use("/api/marketplace", marketplace_default);
+    app.use("/api/dashboard", dashboard_default);
+    app.get("/health", (req, res) => {
+      res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    });
+    if (publicDir && existsSync8(publicDir)) {
+      app.get("*", (req, res) => {
+        res.sendFile(join7(publicDir, "index.html"));
+      });
+    }
+    app.use(errorHandler);
+    if (process.argv[1] === fileURLToPath3(import.meta.url)) {
+      startServer();
+    }
+  }
+});
+
+// src/bin.ts
+init_config();
+import { program } from "commander";
+import open from "open";
+import { existsSync as existsSync9, readFileSync, writeFileSync } from "fs";
+import { join as join8 } from "path";
+import readline from "readline";
+
+// src/lib/initDb.ts
+init_db();
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { spawnSync } from "child_process";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+function getSchemaPath() {
+  const possiblePaths = [
+    join2(__dirname2, "../../prisma/schema.prisma"),
+    // From dist/lib or src/lib
+    join2(__dirname2, "../../../prisma/schema.prisma"),
+    join2(process.cwd(), "prisma/schema.prisma"),
+    // Fallback
+    join2(process.cwd(), "server/prisma/schema.prisma")
+  ];
+  return possiblePaths.find((p) => existsSync2(p)) || null;
+}
+async function ensureDatabaseInitialized() {
+  try {
+    try {
+      await prisma.skill.count();
+      return;
+    } catch (error) {
+      if (error.code === "P2021" || error.message.includes("table") || error.message.includes("does not exist")) {
+        console.log("\u{1F4E6} Initializing database...");
+        await initializeDatabase();
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    throw error;
+  }
+}
+async function initializeDatabase() {
+  const schemaPath = getSchemaPath();
+  if (!schemaPath) {
+    throw new Error("Could not find schema.prisma");
+  }
+  const possiblePrismaBins = [
+    join2(__dirname2, "../../node_modules/.bin/prisma"),
+    join2(__dirname2, "../../../node_modules/.bin/prisma"),
+    join2(process.cwd(), "node_modules/.bin/prisma")
+  ];
+  const prismaBin = possiblePrismaBins.find((p) => existsSync2(p)) || "prisma";
+  console.log(`   Using schema: ${schemaPath}`);
+  const result = spawnSync(prismaBin, ["db", "push", "--schema", schemaPath], {
+    stdio: "inherit",
+    env: { ...process.env }
+    // Ensure env vars (DATABASE_URL) are passed
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`Database initialization failed with status ${result.status}`);
+  }
+  console.log("\u2705 Database initialized successfully");
+}
+
+// src/bin.ts
+init_skillService();
+init_workspaceService();
+var { skillverseHome: SKILLVERSE_HOME2 } = config;
+var AUTH_FILE = join8(SKILLVERSE_HOME2, "auth.json");
+var CONFIG_FILE = join8(SKILLVERSE_HOME2, "config.json");
+program.hook("preAction", async (thisCommand, actionCommand) => {
+  if (["list", "start", "install", "add", "remove", "import", "search"].includes(actionCommand.name())) {
+    await ensureDatabaseInitialized();
+  }
+});
+function getRegistryUrl() {
+  if (existsSync9(CONFIG_FILE)) {
+    const config2 = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    return config2.registryUrl || "http://localhost:4000";
+  }
+  return process.env.SKILLVERSE_REGISTRY || "http://localhost:4000";
+}
+function getAuthToken() {
+  if (existsSync9(AUTH_FILE)) {
+    const auth = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    return auth.token || null;
+  }
+  return null;
+}
+function saveAuth(token, user) {
+  writeFileSync(AUTH_FILE, JSON.stringify({ token, user }, null, 2));
+}
+async function prompt(question, hidden = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    if (hidden) {
+      process.stdout.write(question);
+      let input = "";
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", (char) => {
+        const c = char.toString();
+        if (c === "\n" || c === "\r") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          console.log();
+          rl.close();
+          resolve(input);
+        } else if (c === "") {
+          process.exit();
+        } else if (c === "\x7F") {
+          input = input.slice(0, -1);
+        } else {
+          input += c;
+        }
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+program.name("skillverse").description("SkillVerse - Local-first skill management platform for AI coding assistants").version("0.1.0");
+program.command("start").description("Start the SkillVerse local server").option("-p, --port <number>", "Port to run server on", "3001").option("--no-open", "Do not open browser on start").action(async (options) => {
+  const port = parseInt(options.port, 10);
+  console.log("");
+  console.log("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("  \u2551         \u{1F680} SkillVerse CLI             \u2551");
+  console.log("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  console.log("");
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+  await startServer2(port);
+  if (options.open) {
+    const url = `http://localhost:${port}`;
+    console.log(`
+\u{1F310} Opening ${url} in your browser...`);
+    open(url).catch((err) => console.error("Failed to open browser:", err));
+  }
+  console.log("\n\u{1F4A1} Press Ctrl+C to stop the server\n");
+});
+program.command("login").description("Login to SkillVerse Registry").option("-r, --registry <url>", "Registry URL").action(async (options) => {
+  const registryUrl = options.registry || getRegistryUrl();
+  console.log(`
+\u{1F510} Logging in to ${registryUrl}...
+`);
+  const username = await prompt("Username: ");
+  const password = await prompt("Password: ", true);
+  try {
+    const response = await fetch(`${registryUrl}/api/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, password })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      console.error(`
+\u274C Login failed: ${data.error || "Unknown error"}`);
+      process.exit(1);
+    }
+    saveAuth(data.data.token, data.data.user);
+    console.log(`
+\u2705 Logged in as ${data.data.user.username}`);
+  } catch (error) {
+    console.error(`
+\u274C Failed to connect to registry: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("publish [path]").description("Publish a skill to the Registry").option("-n, --name <name>", "Skill name (defaults to directory name)").option("-d, --description <desc>", "Skill description").option("-r, --registry <url>", "Registry URL").action(async (skillPath, options) => {
+  const token = getAuthToken();
+  if (!token) {
+    console.error("\n\u274C Not logged in. Run `skillverse login` first.");
+    process.exit(1);
+  }
+  const targetPath = skillPath || process.cwd();
+  const registryUrl = options.registry || getRegistryUrl();
+  if (!existsSync9(targetPath)) {
+    console.error(`
+\u274C Path not found: ${targetPath}`);
+    process.exit(1);
+  }
+  const skillName = options.name || targetPath.split("/").pop();
+  console.log(`
+\u{1F4E6} Publishing skill "${skillName}" to ${registryUrl}...`);
+  try {
+    const { bundleService: bundleService2 } = await Promise.resolve().then(() => (init_bundleService(), bundleService_exports));
+    const bundlePath = await bundleService2.createBundle(targetPath, skillName);
+    const FormData = (await import("form-data")).default;
+    const form = new FormData();
+    form.append("name", skillName);
+    if (options.description) form.append("description", options.description);
+    form.append("bundle", readFileSync(bundlePath), {
+      filename: `${skillName}.tar.gz`,
+      contentType: "application/gzip"
+    });
+    const response = await fetch(`${registryUrl}/api/skills/publish`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        ...form.getHeaders()
+      },
+      body: form
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      console.error(`
+\u274C Publish failed: ${data.error || "Unknown error"}`);
+      process.exit(1);
+    }
+    console.log(`
+\u2705 Published ${skillName}@${data.data.version}`);
+    console.log(`   \u{1F4E5} Install: skillverse install ${skillName}`);
+  } catch (error) {
+    console.error(`
+\u274C Publish failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("search <query>").description("Search for skills in the Registry").option("-r, --registry <url>", "Registry URL").action(async (query, options) => {
+  const registryUrl = options.registry || getRegistryUrl();
+  console.log(`
+\u{1F50D} Searching for "${query}"...
+`);
+  try {
+    const response = await fetch(`${registryUrl}/api/skills?search=${encodeURIComponent(query)}`);
+    const data = await response.json();
+    if (!response.ok) {
+      console.error(`\u274C Search failed: ${data.error || "Unknown error"}`);
+      process.exit(1);
+    }
+    if (data.data.items.length === 0) {
+      console.log("No skills found.");
+      return;
+    }
+    console.log(`Found ${data.data.total} skill(s):
+`);
+    for (const skill of data.data.items) {
+      console.log(`  \u{1F4E6} ${skill.name}@${skill.version}`);
+      console.log(`     ${skill.description || "No description"}`);
+      console.log(`     by ${skill.publisher?.displayName || skill.publisher?.username}`);
+      console.log(`     \u{1F4E5} ${skill.downloads} downloads
+`);
+    }
+  } catch (error) {
+    console.error(`
+\u274C Failed to search: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("config").description("Configure SkillVerse settings").option("-r, --registry <url>", "Set default registry URL").action((options) => {
+  const config2 = existsSync9(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) : {};
+  if (options.registry) {
+    config2.registryUrl = options.registry;
+    writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+    console.log(`\u2705 Registry URL set to: ${options.registry}`);
+  } else {
+    console.log("\nCurrent Configuration:");
+    console.log(`  Registry: ${config2.registryUrl || getRegistryUrl()}`);
+  }
+});
+program.command("install [gitUrl]").description("Install a skill from Git URL").option("-a, --agent <agent>", "Link to agent workspace (vscode, cursor, etc.)").action(async (gitUrl, options) => {
+  if (!gitUrl) {
+    console.error("\u274C Git URL is required (Registry install not yet supported via CLI)");
+    process.exit(1);
+  }
+  try {
+    console.log(`
+\u2B07\uFE0F  Installing skill from ${gitUrl}...`);
+    const skill = await skillService.createSkillFromGit(gitUrl);
+    console.log(`\u2705 Installed skill "${skill.name}"`);
+    if (options.agent) {
+      const projectPath = process.cwd();
+      const type = options.agent;
+      const validAgents = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+      if (!validAgents.includes(type)) {
+        console.error(`\u274C Invalid agent type. Valid types: ${validAgents.join(", ")}`);
+        process.exit(1);
+      }
+      console.log(`
+\u{1F517} Linking to ${type} workspace...`);
+      const skillsPath = workspaceService.getSkillsPath(projectPath, type, "project");
+      const existingWorkspace = await workspaceService.findWorkspaceByPath(skillsPath);
+      let workspaceId = existingWorkspace?.id;
+      if (!workspaceId) {
+        console.log(`   Creating new workspace for ${type}...`);
+        const newWorkspace = await workspaceService.createWorkspace(
+          `${type}-workspace`,
+          projectPath,
+          type,
+          "project"
+        );
+        workspaceId = newWorkspace.id;
+      }
+      await workspaceService.linkSkillToWorkspace(skill.id, workspaceId);
+      console.log(`\u2705 Linked "${skill.name}" to ${type} workspace at ${skillsPath}`);
+    }
+  } catch (error) {
+    console.error(`
+\u274C Install failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("add").description("Add a local skill").requiredOption("-p, --path <path>", "Path to skill directory").option("-a, --agent <agent>", "Link to agent workspace").action(async (options) => {
+  const sourcePath = options.path.startsWith("/") ? options.path : join8(process.cwd(), options.path);
+  if (!existsSync9(sourcePath)) {
+    console.error(`\u274C Source path not found: ${sourcePath}`);
+    process.exit(1);
+  }
+  try {
+    console.log(`
+\u{1F4E6} Adding skill from ${sourcePath}...`);
+    const skill = await skillService.createSkillFromDirectory(sourcePath);
+    console.log(`\u2705 Added skill "${skill.name}"`);
+    if (options.agent) {
+      const projectPath = process.cwd();
+      const type = options.agent;
+      const validAgents = ["vscode", "cursor", "claude-desktop", "codex", "antigravity", "custom"];
+      if (!validAgents.includes(type)) {
+        console.error(`\u274C Invalid agent type. Valid types: ${validAgents.join(", ")}`);
+        process.exit(1);
+      }
+      console.log(`
+\u{1F517} Linking to ${type} workspace...`);
+      const skillsPath = workspaceService.getSkillsPath(projectPath, type, "project");
+      const existingWorkspace = await workspaceService.findWorkspaceByPath(skillsPath);
+      let workspaceId = existingWorkspace?.id;
+      if (!workspaceId) {
+        console.log(`   Creating new workspace for ${type}...`);
+        const newWorkspace = await workspaceService.createWorkspace(
+          `${type}-workspace`,
+          projectPath,
+          type,
+          "project"
+        );
+        workspaceId = newWorkspace.id;
+      }
+      await workspaceService.linkSkillToWorkspace(skill.id, workspaceId);
+      console.log(`\u2705 Linked "${skill.name}" to ${type} workspace at ${skillsPath}`);
+    }
+  } catch (error) {
+    console.error(`
+\u274C Add failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("list").description("List installed skills").action(async () => {
+  try {
+    const skills = await skillService.getAllSkills();
+    if (skills.length === 0) {
+      console.log("\nNo skills installed.");
+      return;
+    }
+    console.log(`
+\u{1F4E6} Installed Skills (${skills.length}):
+`);
+    console.log("Name".padEnd(50) + "Source".padEnd(10) + "Linked");
+    console.log("-".repeat(80));
+    for (const skill of skills) {
+      const source = skill.source;
+      const linkedCount = skill.linkedWorkspaces?.length || 0;
+      const updateStatus = skill.updateAvailable ? "*" : "";
+      console.log(
+        `${skill.name}${updateStatus}`.padEnd(50) + source.padEnd(10) + `${linkedCount} workspace(s)`
+      );
+    }
+    console.log("\n(* indicates update available)");
+  } catch (error) {
+    console.error(`
+\u274C List failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("remove <name>").description("Remove a skill").action(async (name) => {
+  try {
+    const skill = await skillService.getSkillByName(name);
+    console.log(`
+\u{1F5D1}\uFE0F  Removing skill "${name}"...`);
+    await skillService.deleteSkill(skill.id);
+    console.log(`\u2705 Skill "${name}" removed successfully`);
+  } catch (error) {
+    console.error(`
+\u274C Remove failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  program.parse(["node", "skillverse", "start"]);
+}
+//# sourceMappingURL=bin.js.map