skillverse 0.1.1 → 0.1.2

package/dist/bin.js

@@ -9,133 +9,11 @@ var __export = (target, 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");
@@ -156,64 +34,77 @@ function setupEnvironment() {
     databaseUrl: process.env.DATABASE_URL
   };
 }
-var config = setupEnvironment();
+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 = globalThis;
-var prisma = globalForPrisma.prisma ?? new PrismaClient({
-  log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"]
+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;
+  }
 });
-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 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"
+    };
   }
-};
-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) {
@@ -231,11 +122,30 @@ function errorHandler(err, req, res, next) {
     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
-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");
+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("/");
@@ -250,1601 +160,1754 @@ function parseGitUrl(url) {
   const skillName = pathParts[pathParts.length - 1];
   return { repoUrl, subdir, skillName };
 }
-var SkillService = class {
-  async getAllSkills() {
-    const skills = await prisma.skill.findMany({
-      include: {
-        linkedWorkspaces: {
+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: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
+          },
+          orderBy: {
+            installDate: "desc"
           }
-        },
-        marketplaceEntry: true
-      },
-      orderBy: {
-        installDate: "desc"
+        });
+        return skills;
       }
-    });
-    return skills;
-  }
-  async getSkillById(id) {
-    const skill = await prisma.skill.findUnique({
-      where: { id },
-      include: {
-        linkedWorkspaces: {
+      async getSkillById(id) {
+        const skill = await prisma.skill.findUnique({
+          where: { id },
           include: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: true
           }
-        },
-        marketplaceEntry: true
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, "Skill not found", 404);
+        }
+        return skill;
       }
-    });
-    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: {
+      async getSkillByName(name) {
+        const skill = await prisma.skill.findUnique({
+          where: { name },
           include: {
-            workspace: true
+            linkedWorkspaces: {
+              include: {
+                workspace: true
+              }
+            },
+            marketplaceEntry: 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);
+        });
+        if (!skill) {
+          throw new AppError(ErrorCode.NOT_FOUND, `Skill "${name}" not found`, 404);
+        }
+        return skill;
       }
-      const skillPath = join2(SKILLS_DIR, skillName);
-      if (existsSync2(skillPath)) {
-        throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
+      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: {} };
+        }
       }
-      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);
+      async createSkillFromGit(gitUrl, description) {
+        let tempPath = null;
         try {
-          commitHash = await simpleGit(tempPath).revparse(["HEAD"]);
-          console.log(`Captured commit hash: ${commitHash}`);
-        } catch (e) {
-          console.warn("Failed to capture commit hash:", e);
+          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);
+          }
         }
-        const sourcePath = join2(tempPath, subdir);
-        if (!existsSync2(sourcePath)) {
-          throw new AppError(
-            ErrorCode.GIT_ERROR,
-            `Subdirectory "${subdir}" not found in repository`,
-            400
-          );
+      }
+      async createSkillFromDirectory(path, name, description) {
+        if (!existsSync3(path)) {
+          throw new AppError(ErrorCode.FILE_SYSTEM_ERROR, `Source path not found: ${path}`, 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
-          );
+        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);
         }
-        await mkdir(skillPath, { recursive: true });
-        await cp(sourcePath, skillPath, { recursive: true });
-      } else {
-        if (!existsSync2(skillPath)) {
-          await mkdir(skillPath, { recursive: true });
+        if (existsSync3(skillPath)) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${skillName}" already exists`, 409);
         }
-        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);
+          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;
         }
       }
-      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)
+      /**
+       * 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);
+          }
         }
-      });
-      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(() => {
+      async createSkillFromLocal(name, zipPath, description) {
+        const skillPath = join3(SKILLS_DIR, name);
+        const existingSkill = await prisma.skill.findUnique({
+          where: { name }
         });
-      }
-      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)
+        if (existingSkill) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill "${name}" already exists`, 409);
         }
-      });
-      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)
+        if (existsSync3(skillPath)) {
+          throw new AppError(ErrorCode.ALREADY_EXISTS, `Skill directory "${name}" already exists`, 409);
         }
-      });
-      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) {
+        const extractPath = join3(TEMP_DIR, `extract-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        await mkdir(extractPath, { recursive: true });
         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}`);
-            }
+          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) {
-          console.warn(`Failed to remove symlink for ${skill.name} in workspace ${link.workspace.path}:`, 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;
         }
       }
-    }
-    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
+      /**
+       * 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;
         }
-      });
-      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)
+      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;
       }
-    });
-    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)
+      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);
+            }
+          }
         }
-      });
-      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(() => {
-      });
-    }
+        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();
   }
-};
-var skillService = new SkillService();
+});
 
 // src/services/workspaceService.ts
-import { join as join3 } from "path";
+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 existsSync3, lstatSync } from "fs";
+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 join3(projectPath, pathConfig.project);
+  return join4(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);
+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: {
+      async findWorkspaceByPath(path) {
+        const workspace = await prisma.workspace.findUnique({
+          where: { path },
           include: {
-            skill: true
+            linkedSkills: {
+              include: {
+                skill: true
+              }
+            }
           }
-        }
+        });
+        return workspace;
       }
-    });
-    return workspace;
-  }
-  async getAllWorkspaces() {
-    const workspaces = await prisma.workspace.findMany({
-      include: {
-        linkedSkills: {
+      async getAllWorkspaces() {
+        const workspaces = await prisma.workspace.findMany({
           include: {
-            skill: true
+            linkedSkills: {
+              include: {
+                skill: true
+              }
+            }
+          },
+          orderBy: {
+            createdAt: "desc"
           }
-        }
-      },
-      orderBy: {
-        createdAt: "desc"
+        });
+        await Promise.all(workspaces.map((w) => this.syncLinks(w)));
+        return workspaces.map((workspace) => ({
+          ...workspace,
+          isPathValid: existsSync4(workspace.path)
+        }));
       }
-    });
-    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: {
+      async getWorkspaceById(id) {
+        const workspace = await prisma.workspace.findUnique({
+          where: { id },
           include: {
-            skill: true
+            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)
+        };
       }
-    });
-    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;
+      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
+            );
           }
-        } else {
-          shouldAppend = true;
         }
-        if (shouldAppend) {
-          const ignoreEntry = `
+        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}`);
+              await appendFile(gitignorePath, ignoreEntry);
+              console.log(`Added ${relativeSkillsPath}/ to .gitignore in ${projectPath}`);
+            }
+          } catch (err) {
+            console.warn("Failed to update .gitignore:", err);
+          }
         }
-      } catch (err) {
-        console.warn("Failed to update .gitignore:", err);
+        return {
+          ...workspace,
+          isPathValid: true
+        };
       }
-    }
-    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);
+      async updateWorkspace(id, data) {
+        await this.getWorkspaceById(id);
+        const workspace = await prisma.workspace.update({
+          where: { id },
+          data
+        });
+        return {
+          ...workspace,
+          isPathValid: existsSync4(workspace.path)
+        };
       }
-    }
-    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
+      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" };
       }
-    });
-    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 {
+      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,
-            `A file or directory already exists at ${targetPath}`,
-            409
+            `Workspace skills directory does not exist: ${workspace.path}. The folder may have been deleted. Please recreate it or remove this workspace.`,
+            400
           );
         }
-      }
-      await symlink(skill.storagePath, targetPath, "dir");
-      const link = await prisma.skillWorkspace.create({
-        data: {
-          skillId,
-          workspaceId
-        },
-        include: {
-          skill: true,
-          workspace: true
+        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);
         }
-      });
-      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
-            });
+        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
+          );
         }
-      } 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;
+      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);
         }
-        if (existsSync3(targetPath)) {
-          errors.push(`${skillName}: Already exists in unified storage`);
-          continue;
+        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
+          );
         }
-        const existingSkill = await prisma.skill.findUnique({
-          where: { name: skillName }
-        });
-        if (existingSkill) {
-          errors.push(`${skillName}: Already registered in database`);
-          continue;
+      }
+      /**
+       * 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 skillMdPath = join3(sourcePath, "SKILL.md");
-        let description = "";
-        let metadata = {};
-        if (existsSync3(skillMdPath)) {
+        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 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);
+            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);
           }
         }
-        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
+        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}`);
           }
-        });
-        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
+        };
       }
-    }
-    return {
-      success: errors.length === 0,
-      migrated,
-      errors
     };
+    workspaceService = new WorkspaceService();
   }
-};
-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
+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);
+      }
     });
-  } 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
+    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"));
+        }
+      }
     });
-  } 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"
+    router.get("/", async (req, res, next) => {
+      try {
+        const skills = await skillService.getAllSkills();
+        res.json({
+          success: true,
+          data: skills
+        });
+      } catch (error) {
+        next(error);
+      }
     });
-  } 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"
+    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);
       }
-      if (!file) {
-        return res.status(400).json({
-          success: false,
-          error: "ZIP file is required"
+    });
+    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);
       }
-      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(() => {
+    });
+    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);
       }
-      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"
+    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);
+      }
     });
-  } 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"
+    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);
+      }
     });
-  } 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
+    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);
+      }
     });
-  } 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"
+    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);
+      }
     });
-  } 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
+    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);
+      }
     });
-  } 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"
+    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);
+      }
     });
-  } 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
+    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
+        const content = await readFile3(skillMdPath, "utf-8");
+        res.json({
+          success: true,
+          data: {
+            exists: true,
+            content
+          }
+        });
+      } catch (error) {
+        next(error);
       }
     });
-  } catch (error) {
-    next(error);
+    skills_default = router;
   }
 });
-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
+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);
+      }
     });
-  } 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
+    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);
+      }
     });
-  } 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"
+    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);
+      }
     });
-  } 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(", ")}`
+    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);
       }
-    }
-    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(", ")}`
+    });
+    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);
       }
-    }
-    const workspace = await workspaceService.updateWorkspace(req.params.id, {
-      name,
-      path,
-      type,
-      scope
     });
-    res.json({
-      success: true,
-      data: workspace,
-      message: "Workspace updated successfully"
+    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);
     });
-  } catch (error) {
-    next(error);
+    archive.pipe(output);
+    archive.directory(skillPath, false);
+    archive.finalize();
+  });
+}
+async function extractBundle(bundlePath, targetDir) {
+  if (!existsSync6(bundlePath)) {
+    throw new Error(`Bundle not found: ${bundlePath}`);
   }
-});
-router2.delete("/:id", async (req, res, next) => {
-  try {
-    const result = await workspaceService.deleteWorkspace(req.params.id);
-    res.json(result);
-  } catch (error) {
-    next(error);
+  if (!existsSync6(targetDir)) {
+    await mkdir4(targetDir, { recursive: true });
   }
-});
-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);
+  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}`);
   }
-});
-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);
+}
+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
+    };
   }
 });
-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)
+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);
       }
     });
-  } 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
+    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);
       }
     });
-    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
+    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);
       }
     });
-    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
+    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"
+          });
         }
-      });
-    }
-    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
+        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);
       }
     });
-    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
+    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);
       }
     });
-    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"
+    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);
+      }
     });
-  } catch (error) {
-    next(error);
+    marketplace_default = router3;
   }
 });
-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: {
+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: {
-              workspace: true
+              linkedWorkspaces: {
+                include: {
+                  workspace: true
+                }
+              }
             }
+          })
+        ]);
+        res.json({
+          success: true,
+          data: {
+            totalSkills,
+            totalWorkspaces,
+            totalLinks,
+            marketplaceSkills,
+            recentSkills
           }
-        }
-      })
-    ]);
-    res.json({
-      success: true,
-      data: {
-        totalSkills,
-        totalWorkspaces,
-        totalLinks,
-        marketplaceSkills,
-        recentSkills
+        });
+      } catch (error) {
+        next(error);
       }
     });
-  } 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)
+    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);
+      }
     });
-  } catch (error) {
-    next(error);
+    dashboard_default = router4;
   }
 });
-var dashboard_default = router4;
 
 // src/middleware/logger.ts
 function requestLogger(req, res, next) {
@@ -1855,54 +1918,31 @@ function requestLogger(req, res, next) {
   });
   next();
 }
+var init_logger = __esm({
+  "src/middleware/logger.ts"() {
+    "use strict";
+  }
+});
 
 // 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() });
+var index_exports = {};
+__export(index_exports, {
+  startServer: () => startServer
 });
-if (publicDir && existsSync7(publicDir)) {
-  app.get("*", (req, res) => {
-    res.sendFile(join6(publicDir, "index.html"));
-  });
-}
-app.use(errorHandler);
+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 || join6(process.env.HOME || "", ".skillverse");
-  const skillsDir = process.env.SKILLS_DIR || join6(skillverseHome, "skills");
-  const marketplaceDir = process.env.MARKETPLACE_DIR || join6(skillverseHome, "marketplace");
+  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 (!existsSync7(dir)) {
+    if (!existsSync8(dir)) {
       await mkdir5(dir, { recursive: true });
       console.log(`Created directory: ${dir}`);
     }
@@ -1914,7 +1954,7 @@ async function startServer(port = parseInt(process.env.PORT || "3001")) {
     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")}`);
+        console.log(`\u{1F4C1} Storage: ${process.env.SKILLVERSE_HOME || join7(process.env.HOME || "", ".skillverse")}`);
         resolve();
       });
     });
@@ -1923,28 +1963,151 @@ async function startServer(port = parseInt(process.env.PORT || "3001")) {
     process.exit(1);
   }
 }
-if (process.argv[1] === fileURLToPath2(import.meta.url)) {
-  startServer();
-}
+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 existsSync8, readFileSync, writeFileSync } from "fs";
-import { join as join7 } from "path";
+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 = join7(SKILLVERSE_HOME2, "auth.json");
-var CONFIG_FILE = join7(SKILLVERSE_HOME2, "config.json");
+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 (existsSync8(CONFIG_FILE)) {
+  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 (existsSync8(AUTH_FILE)) {
+  if (existsSync9(AUTH_FILE)) {
     const auth = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
     return auth.token || null;
   }
@@ -1996,7 +2159,8 @@ program.command("start").description("Start the SkillVerse local server").option
   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);
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+  await startServer2(port);
   if (options.open) {
     const url = `http://localhost:${port}`;
     console.log(`
@@ -2041,7 +2205,7 @@ program.command("publish [path]").description("Publish a skill to the Registry")
   }
   const targetPath = skillPath || process.cwd();
   const registryUrl = options.registry || getRegistryUrl();
-  if (!existsSync8(targetPath)) {
+  if (!existsSync9(targetPath)) {
     console.error(`
 \u274C Path not found: ${targetPath}`);
     process.exit(1);
@@ -2115,7 +2279,7 @@ program.command("search <query>").description("Search for skills in the Registry
   }
 });
 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")) : {};
+  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));
@@ -2168,8 +2332,8 @@ program.command("install [gitUrl]").description("Install a skill from Git URL").
   }
 });
 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)) {
+  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);
   }