skillverse 0.1.0 → 0.1.1

package/dist/bin.js

@@ -0,0 +1,2257 @@
+#!/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/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 existsSync5, createReadStream } from "fs";
+import { mkdir as mkdir4, rm as rm4, readdir, stat } from "fs/promises";
+import { join as join5 } from "path";
+import { pipeline } from "stream/promises";
+import archiver from "archiver";
+import { createGunzip } from "zlib";
+import { extract } from "tar";
+async function ensureBundlesDir() {
+  if (!existsSync5(BUNDLES_DIR)) {
+    await mkdir4(BUNDLES_DIR, { recursive: true });
+  }
+}
+async function createBundle(skillPath, skillName) {
+  await ensureBundlesDir();
+  const bundleName = `${skillName}-${Date.now()}.tar.gz`;
+  const bundlePath = join5(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 (!existsSync5(bundlePath)) {
+    throw new Error(`Bundle not found: ${bundlePath}`);
+  }
+  if (!existsSync5(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 (existsSync5(bundlePath)) {
+    await rm4(bundlePath);
+    console.log(`\u{1F5D1}\uFE0F Bundle deleted: ${bundlePath}`);
+  }
+}
+async function getBundleSize(bundlePath) {
+  if (!existsSync5(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) => join5(BUNDLES_DIR, f));
+}
+var BUNDLES_DIR, bundleService;
+var init_bundleService = __esm({
+  "src/services/bundleService.ts"() {
+    "use strict";
+    BUNDLES_DIR = join5(
+      process.env.SKILLVERSE_HOME || join5(process.env.HOME || "", ".skillverse"),
+      "bundles"
+    );
+    bundleService = {
+      createBundle,
+      extractBundle,
+      deleteBundle,
+      getBundleSize,
+      listBundles,
+      BUNDLES_DIR
+    };
+  }
+});
+
+// src/index.ts
+import express from "express";
+import cors from "cors";
+import dotenv2 from "dotenv";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join6 } from "path";
+import { mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+
+// src/routes/skills.ts
+import { Router } from "express";
+import multer from "multer";
+import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
+
+// src/services/skillService.ts
+import { join as join2, basename } from "path";
+import { existsSync as existsSync2 } 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";
+
+// src/config.ts
+import { join, dirname } from "path";
+import { existsSync, mkdirSync } from "fs";
+import { fileURLToPath } from "url";
+import dotenv from "dotenv";
+dotenv.config();
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+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 config = setupEnvironment();
+
+// src/lib/db.ts
+import { PrismaClient } from "@prisma/client";
+var globalForPrisma = globalThis;
+var 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 = {
+  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: ""
+  }
+};
+var 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
+var AppError = class extends Error {
+  constructor(code, message, statusCode = 500, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "AppError";
+  }
+};
+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
+  });
+}
+
+// src/services/skillService.ts
+var SKILLVERSE_HOME = process.env.SKILLVERSE_HOME || join2(process.env.HOME || "", ".skillverse");
+var SKILLS_DIR = process.env.SKILLS_DIR || join2(SKILLVERSE_HOME, "skills");
+var TEMP_DIR = process.env.TEMP_DIR || join2(SKILLVERSE_HOME, "temp");
+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 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 = join2(skillPath, "SKILL.md");
+      let description = "";
+      let metadata = {};
+      if (existsSync2(skillMdPath)) {
+        const fileContent = await readFile(skillMdPath, "utf-8");
+        const parsed = matter(fileContent);
+        description = parsed.data.description || "";
+        metadata = parsed.data;
+      }
+      if (!description) {
+        const packageJsonPath = join2(skillPath, "package.json");
+        const skillJsonPath = join2(skillPath, "skill.json");
+        if (existsSync2(skillJsonPath)) {
+          const content = await readFile(skillJsonPath, "utf-8");
+          const json = JSON.parse(content);
+          description = json.description || "";
+          metadata = { ...metadata, ...json };
+        } else if (existsSync2(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 = join2(SKILLS_DIR, skillName);
+      if (existsSync2(skillPath)) {
+        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+      }
+      let commitHash = "";
+      if (subdir) {
+        tempPath = join2(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 = join2(tempPath, subdir);
+        if (!existsSync2(sourcePath)) {
+          throw new AppError(
+            ErrorCode.GIT_ERROR,
+            `Subdirectory "${subdir}" not found in repository`,
+            400
+          );
+        }
+        const hasSkillMd = existsSync2(join2(sourcePath, "SKILL.md"));
+        const hasSkillJson = existsSync2(join2(sourcePath, "skill.json"));
+        const hasPackageJson = existsSync2(join2(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 (!existsSync2(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 && existsSync2(tempPath)) {
+        await rm(tempPath, { recursive: true, force: true }).catch(console.error);
+      }
+    }
+  }
+  async createSkillFromDirectory(path, name, description) {
+    if (!existsSync2(path)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 400);
+    }
+    const skillName = name || basename(path);
+    const skillPath = join2(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 (existsSync2(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 (existsSync2(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 = join2(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(join2(topLevelPath, item), join2(targetPath, item));
+        }
+        await rmdir(topLevelPath);
+      }
+    }
+  }
+  async createSkillFromLocal(name, zipPath, description) {
+    const skillPath = join2(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 (existsSync2(skillPath)) {
+      throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
+    }
+    const extractPath = join2(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 (existsSync2(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 (existsSync2(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (existsSync2(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 = join2(SKILLS_DIR, name);
+    const extractPath = join2(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 (existsSync2(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 (existsSync2(skillPath)) {
+        await rm(skillPath, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (existsSync2(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 = join2(workspacePath, skill.name);
+          if (existsSync2(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 = join2(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 = join2(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 = join2(tempPath, subdir);
+        if (!existsSync2(sourcePath)) {
+          throw new AppError(ErrorCode.GIT_ERROR, `Subdirectory "${subdir}" not found`, 400);
+        }
+      }
+      const hasSkillMd = existsSync2(join2(sourcePath, "SKILL.md"));
+      const hasSkillJson = existsSync2(join2(sourcePath, "skill.json"));
+      const hasPackageJson = existsSync2(join2(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(join2(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(() => {
+      });
+    }
+  }
+};
+var skillService = new SkillService();
+
+// src/services/workspaceService.ts
+import { join as join3 } 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 existsSync3, lstatSync } from "fs";
+function computeSkillsPath(projectPath, type, scope) {
+  const pathConfig = WORKSPACE_SKILLS_PATHS[type];
+  if (scope === "global") {
+    return pathConfig.global.replace("~", homedir());
+  }
+  return join3(projectPath, pathConfig.project);
+}
+var 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 = join3(workspace.path, link.skill.name);
+      if (!existsSync3(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: existsSync3(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: existsSync3(workspace.path)
+    };
+  }
+  async createWorkspace(name, projectPath, type, scope) {
+    const skillsPath = computeSkillsPath(projectPath, type, scope);
+    if (scope === "project" && projectPath && !existsSync3(projectPath)) {
+      throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Project path does not exist: ${projectPath}`, 400);
+    }
+    if (!existsSync3(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 && existsSync3(projectPath)) {
+      try {
+        const gitignorePath = join3(projectPath, ".gitignore");
+        const relativeSkillsPath = WORKSPACE_SKILLS_PATHS[type].project;
+        let shouldAppend = false;
+        if (existsSync3(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: existsSync3(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 = join3(workspace.path, link.skill.name);
+        if (existsSync3(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 (!existsSync3(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 = join3(workspace.path, skill.name);
+    try {
+      if (existsSync3(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 = join3(link.workspace.path, link.skill.name);
+    try {
+      if (existsSync3(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 (!existsSync3(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 = join3(skillsPath, item);
+      try {
+        const itemStat = await stat2(itemPath);
+        const lstats = lstatSync(itemPath);
+        if (lstats.isSymbolicLink()) continue;
+        if (itemStat.isDirectory()) {
+          const hasSkillMd = existsSync3(join3(itemPath, "SKILL.md"));
+          const hasSkillJson = existsSync3(join3(itemPath, "skill.json"));
+          const hasPackageJson = existsSync3(join3(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 || join3(homedir(), ".skillverse");
+    const SKILLS_DIR2 = process.env.SKILLS_DIR || join3(SKILLVERSE_HOME3, "skills");
+    if (!existsSync3(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 = join3(workspace.path, skillName);
+      const targetPath = join3(SKILLS_DIR2, skillName);
+      try {
+        if (!existsSync3(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 (existsSync3(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 = join3(sourcePath, "SKILL.md");
+        let description = "";
+        let metadata = {};
+        if (existsSync3(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
+    };
+  }
+};
+var workspaceService = new WorkspaceService();
+
+// src/routes/skills.ts
+var router = Router();
+var TEMP_DIR2 = process.env.TEMP_DIR || join4(process.env.HOME || "", ".skillverse", "temp");
+if (!existsSync4(TEMP_DIR2)) {
+  mkdir3(TEMP_DIR2, { recursive: true });
+}
+var 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);
+  }
+});
+var 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 = join4(skill.storagePath, "SKILL.md");
+    if (!existsSync4(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);
+  }
+});
+var skills_default = router;
+
+// src/routes/workspaces.ts
+import { Router as Router2 } from "express";
+var 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);
+  }
+});
+var workspaces_default = router2;
+
+// src/routes/marketplace.ts
+import { Router as Router3 } from "express";
+init_bundleService();
+import { existsSync as existsSync6 } from "fs";
+var 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 && existsSync6(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" && existsSync6(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 && existsSync6(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);
+  }
+});
+var marketplace_default = router3;
+
+// src/routes/dashboard.ts
+import { Router as Router4 } from "express";
+var 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);
+  }
+});
+var 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();
+}
+
+// src/index.ts
+dotenv2.config();
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var app = express();
+var PORT = process.env.PORT || 3001;
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(requestLogger);
+var possiblePublicDirs = [
+  join6(__dirname2, "../public"),
+  // Production: dist/index.js -> public
+  join6(__dirname2, "../../public"),
+  // Dev tsx might resolve here 
+  join6(process.cwd(), "public"),
+  // Fallback: relative to cwd
+  join6(process.cwd(), "server/public")
+  // Fallback: from root
+];
+var publicDir = possiblePublicDirs.find((dir) => existsSync7(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 && existsSync7(publicDir)) {
+  app.get("*", (req, res) => {
+    res.sendFile(join6(publicDir, "index.html"));
+  });
+}
+app.use(errorHandler);
+async function initializeStorage() {
+  const skillverseHome = process.env.SKILLVERSE_HOME || join6(process.env.HOME || "", ".skillverse");
+  const skillsDir = process.env.SKILLS_DIR || join6(skillverseHome, "skills");
+  const marketplaceDir = process.env.MARKETPLACE_DIR || join6(skillverseHome, "marketplace");
+  const dirs = [skillverseHome, skillsDir, marketplaceDir];
+  for (const dir of dirs) {
+    if (!existsSync7(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 || join6(process.env.HOME || "", ".skillverse")}`);
+        resolve();
+      });
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  startServer();
+}
+
+// src/bin.ts
+import { program } from "commander";
+import open from "open";
+import { existsSync as existsSync8, readFileSync, writeFileSync } from "fs";
+import { join as join7 } from "path";
+import readline from "readline";
+var { skillverseHome: SKILLVERSE_HOME2 } = config;
+var AUTH_FILE = join7(SKILLVERSE_HOME2, "auth.json");
+var CONFIG_FILE = join7(SKILLVERSE_HOME2, "config.json");
+function getRegistryUrl() {
+  if (existsSync8(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 (existsSync8(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("");
+  await startServer(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 (!existsSync8(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 = existsSync8(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 : join7(process.cwd(), options.path);
+  if (!existsSync8(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