@skillkit/core 1.4.0 → 1.5.0

package/dist/index.js

@@ -59,7 +59,10 @@ var SkillkitConfig = z.object({
   skillsDir: z.string().optional(),
   enabledSkills: z.array(z.string()).optional(),
   disabledSkills: z.array(z.string()).optional(),
-  autoSync: z.boolean().default(true)
+  autoSync: z.boolean().default(true),
+  cacheDir: z.string().optional(),
+  marketplaceSources: z.array(z.string()).optional(),
+  defaultTimeout: z.number().optional()
 });
 
 // src/skills.ts
@@ -321,8 +324,8 @@ function validateSkill(skillPath) {
   return { valid: errors.length === 0, errors, warnings };
 }
 function isPathInside(child, parent) {
-  const relative = child.replace(parent, "");
-  return !relative.startsWith("..") && !relative.includes("/..");
+  const relative2 = child.replace(parent, "");
+  return !relative2.startsWith("..") && !relative2.includes("/..");
 }
 
 // src/config.ts
@@ -338,9 +341,27 @@ function getProjectConfigPath() {
 function getGlobalConfigPath() {
   return join2(homedir(), ".config", "skillkit", CONFIG_FILE);
 }
-function loadConfig() {
+function loadConfig(global = false) {
   const projectPath = getProjectConfigPath();
   const globalPath = getGlobalConfigPath();
+  if (global) {
+    if (existsSync2(globalPath)) {
+      try {
+        const content = readFileSync2(globalPath, "utf-8");
+        const data = parseYaml2(content);
+        const parsed = SkillkitConfig.safeParse(data);
+        if (parsed.success) {
+          return parsed.data;
+        }
+      } catch {
+      }
+    }
+    return {
+      version: 1,
+      agent: "universal",
+      autoSync: true
+    };
+  }
   if (existsSync2(projectPath)) {
     try {
       const content = readFileSync2(projectPath, "utf-8");
@@ -4893,7 +4914,7 @@ var SkillExecutionEngine = class {
     const startTime = /* @__PURE__ */ new Date();
     const taskId = task.id || randomUUID6();
     try {
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
       const endTime = /* @__PURE__ */ new Date();
       return {
         taskId,
@@ -5230,7 +5251,7 @@ async function executeWithAgent(agentType, prompt, options = {}) {
   });
 }
 async function executeCommand(command, args, options = {}) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const startTime = Date.now();
     let stdout = "";
     let stderr = "";
@@ -5253,7 +5274,7 @@ async function executeCommand(command, args, options = {}) {
     });
     child.on("error", (error) => {
       if (timeoutId) clearTimeout(timeoutId);
-      resolve2({
+      resolve3({
         success: false,
         output: stdout,
         error: error.message,
@@ -5263,7 +5284,7 @@ async function executeCommand(command, args, options = {}) {
     });
     child.on("close", (code) => {
       if (timeoutId) clearTimeout(timeoutId);
-      resolve2({
+      resolve3({
         success: code === 0 && !timedOut,
         output: stdout,
         error: timedOut ? "Execution timed out" : stderr || void 0,
@@ -5318,9 +5339,158 @@ To execute this skill manually:
 `;
 }
 
-// src/testing/runner.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
+// src/executor/skill-executor.ts
+import { existsSync as existsSync15 } from "fs";
 import { join as join14 } from "path";
+import { homedir as homedir4 } from "os";
+function getSearchDirs2(projectPath) {
+  const dirs = [];
+  for (const searchPath of SKILL_DISCOVERY_PATHS) {
+    const fullPath = join14(projectPath, searchPath);
+    if (existsSync15(fullPath)) {
+      dirs.push(fullPath);
+    }
+  }
+  const home = homedir4();
+  const globalPaths = [
+    join14(home, ".claude", "skills"),
+    join14(home, ".cursor", "skills"),
+    join14(home, ".codex", "skills"),
+    join14(home, ".skillkit", "skills")
+  ];
+  for (const globalPath of globalPaths) {
+    if (existsSync15(globalPath)) {
+      dirs.push(globalPath);
+    }
+  }
+  return dirs;
+}
+function createSkillExecutor(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    preferredAgent,
+    timeout = 3e5,
+    // 5 minutes
+    fallbackToAvailable = true,
+    onExecutionEvent
+  } = options;
+  return async (skillName, config) => {
+    const searchDirs = getSearchDirs2(projectPath);
+    const skill = findSkill(skillName, searchDirs);
+    if (!skill) {
+      onExecutionEvent?.({
+        type: "skill_not_found",
+        skillName,
+        message: `Skill "${skillName}" not found in any search directory`
+      });
+      return {
+        success: false,
+        error: `Skill "${skillName}" not found. Search paths: ${searchDirs.join(", ")}`
+      };
+    }
+    onExecutionEvent?.({
+      type: "skill_found",
+      skillName,
+      message: `Found skill at: ${skill.path}`
+    });
+    const content = readSkillContent(skill.path);
+    if (!content) {
+      return {
+        success: false,
+        error: `Could not read skill content from: ${skill.path}`
+      };
+    }
+    let agentToUse = preferredAgent;
+    if (!agentToUse || fallbackToAvailable) {
+      const availableAgents = await getAvailableCLIAgents();
+      if (preferredAgent && availableAgents.includes(preferredAgent)) {
+        agentToUse = preferredAgent;
+      } else if (availableAgents.length > 0) {
+        agentToUse = availableAgents.includes("claude-code") ? "claude-code" : availableAgents[0];
+      }
+    }
+    if (!agentToUse) {
+      const strategy = getExecutionStrategy(preferredAgent || "universal");
+      const instructions = getManualExecutionInstructions(preferredAgent || "universal", skill.path);
+      if (strategy === "ide" || strategy === "manual") {
+        onExecutionEvent?.({
+          type: "execution_complete",
+          skillName,
+          success: false,
+          message: "No CLI agent available",
+          error: `No CLI agent available for execution.
+${instructions}`
+        });
+        return {
+          success: false,
+          error: `No CLI agent available for automated execution. ${instructions}`
+        };
+      }
+      const errorMsg = preferredAgent ? `The preferred agent "${preferredAgent}" supports CLI execution but its CLI is not installed.` : "No CLI agent is available for execution.";
+      onExecutionEvent?.({
+        type: "execution_complete",
+        skillName,
+        success: false,
+        message: "CLI not installed",
+        error: `${errorMsg}
+${instructions}`
+      });
+      return {
+        success: false,
+        error: `${errorMsg} ${instructions}`
+      };
+    }
+    onExecutionEvent?.({
+      type: "agent_selected",
+      skillName,
+      agent: agentToUse,
+      message: `Using agent: ${agentToUse}`
+    });
+    let taskDescription;
+    if (config?.task) {
+      taskDescription = String(config.task);
+    }
+    const prompt = formatSkillAsPrompt(skillName, content, taskDescription);
+    onExecutionEvent?.({
+      type: "execution_start",
+      skillName,
+      agent: agentToUse,
+      message: `Starting execution with ${agentToUse}`
+    });
+    const result = await executeWithAgent(agentToUse, prompt, {
+      cwd: projectPath,
+      timeout
+    });
+    onExecutionEvent?.({
+      type: "execution_complete",
+      skillName,
+      agent: agentToUse,
+      success: result.success,
+      error: result.error,
+      message: result.success ? "Execution completed successfully" : `Execution failed: ${result.error}`
+    });
+    return {
+      success: result.success,
+      error: result.error
+    };
+  };
+}
+function createSimulatedSkillExecutor(options = {}) {
+  const { delay = 100, shouldFail, onExecute } = options;
+  return async (skillName, _config) => {
+    onExecute?.(skillName);
+    await new Promise((resolve3) => setTimeout(resolve3, delay));
+    const failed = shouldFail?.(skillName) ?? false;
+    return {
+      success: !failed,
+      error: failed ? `Simulated failure for skill: ${skillName}` : void 0
+    };
+  };
+}
+
+// src/testing/runner.ts
+import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
+import { join as join15 } from "path";
 import { exec } from "child_process";
 import { createServer } from "net";
 import { promisify } from "util";
@@ -5385,8 +5555,8 @@ async function runAssertion(assertion, cwd, timeout) {
   }
 }
 function assertFileExists(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  const exists = existsSync15(filePath);
+  const filePath = join15(cwd, assertion.target || "");
+  const exists = existsSync16(filePath);
   return {
     assertion,
     passed: exists,
@@ -5397,8 +5567,8 @@ function assertFileExists(assertion, cwd, startTime) {
   };
 }
 function assertFileNotExists(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  const exists = existsSync15(filePath);
+  const filePath = join15(cwd, assertion.target || "");
+  const exists = existsSync16(filePath);
   return {
     assertion,
     passed: !exists,
@@ -5409,8 +5579,8 @@ function assertFileNotExists(assertion, cwd, startTime) {
   };
 }
 function assertFileContains(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5431,8 +5601,8 @@ function assertFileContains(assertion, cwd, startTime) {
   };
 }
 function assertFileNotContains(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: true,
@@ -5453,8 +5623,8 @@ function assertFileNotContains(assertion, cwd, startTime) {
   };
 }
 function assertFileMatches(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5549,8 +5719,8 @@ async function assertCommandOutputContains(assertion, cwd, timeout, startTime) {
   }
 }
 function assertJsonValid(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5580,8 +5750,8 @@ function assertJsonValid(assertion, cwd, startTime) {
   }
 }
 function assertJsonHasKey(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5625,8 +5795,8 @@ function assertJsonHasKey(assertion, cwd, startTime) {
   }
 }
 function assertYamlValid(assertion, cwd, startTime) {
-  const filePath = join14(cwd, assertion.target || "");
-  if (!existsSync15(filePath)) {
+  const filePath = join15(cwd, assertion.target || "");
+  if (!existsSync16(filePath)) {
     return {
       assertion,
       passed: false,
@@ -5758,12 +5928,12 @@ function assertEnvVarSet(assertion, startTime) {
   };
 }
 async function checkPortAvailable(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const server = createServer();
-    server.once("error", () => resolve2(false));
+    server.once("error", () => resolve3(false));
     server.once("listening", () => {
       server.close();
-      resolve2(true);
+      resolve3(true);
     });
     server.listen(port, "127.0.0.1");
   });
@@ -6122,9 +6292,9 @@ var MARKETPLACE_CACHE_FILE = "marketplace-index.json";
 var DEFAULT_CACHE_TTL = 60 * 60 * 1e3;
 
 // src/marketplace/aggregator.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, unlinkSync as unlinkSync2 } from "fs";
-import { join as join15 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, unlinkSync as unlinkSync2 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir5 } from "os";
 var MarketplaceAggregator = class {
   config;
   cacheDir;
@@ -6132,9 +6302,9 @@ var MarketplaceAggregator = class {
   index = null;
   constructor(config = {}) {
     this.config = config;
-    this.cacheDir = config.cacheDir || join15(homedir4(), ".skillkit", "marketplace");
-    this.cachePath = join15(this.cacheDir, MARKETPLACE_CACHE_FILE);
-    if (!existsSync16(this.cacheDir)) {
+    this.cacheDir = config.cacheDir || join16(homedir5(), ".skillkit", "marketplace");
+    this.cachePath = join16(this.cacheDir, MARKETPLACE_CACHE_FILE);
+    if (!existsSync17(this.cacheDir)) {
       mkdirSync8(this.cacheDir, { recursive: true });
     }
   }
@@ -6148,7 +6318,7 @@ var MarketplaceAggregator = class {
    * Load cached index
    */
   loadCache() {
-    if (!existsSync16(this.cachePath)) {
+    if (!existsSync17(this.cachePath)) {
       return null;
     }
     try {
@@ -6285,9 +6455,9 @@ var MarketplaceAggregator = class {
       const context = readme.slice(contextStart, contextEnd);
       const descMatch = context.match(/[-*]\s*\[.*?\]\(.*?\)\s*[-:]\s*(.+?)(?:\n|$)/);
       const description = descMatch ? descMatch[1].trim() : "";
-      const isAbsolute = this.isAbsoluteUrl(path);
-      const normalizedPath = isAbsolute ? path : path.startsWith("/") ? path : `/${path}`;
-      const rawUrl = isAbsolute ? this.toRawUrl(path) : `https://raw.githubusercontent.com/${source.owner}/${source.repo}/${branch}/${path}`;
+      const isAbsolute2 = this.isAbsoluteUrl(path);
+      const normalizedPath = isAbsolute2 ? path : path.startsWith("/") ? path : `/${path}`;
+      const rawUrl = isAbsolute2 ? this.toRawUrl(path) : `https://raw.githubusercontent.com/${source.owner}/${source.repo}/${branch}/${path}`;
       skills.push({
         id: `${source.owner}/${source.repo}/${path}`,
         name,
@@ -6493,7 +6663,7 @@ var MarketplaceAggregator = class {
    * Clear cache
    */
   clearCache() {
-    if (existsSync16(this.cachePath)) {
+    if (existsSync17(this.cachePath)) {
       unlinkSync2(this.cachePath);
     }
     this.index = null;
@@ -6719,8 +6889,8 @@ var DEFAULT_MEMORY_CONFIG = {
 };
 
 // src/memory/observation-store.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname3, join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname3, join as join17 } from "path";
 import { parse as parseYaml7, stringify as stringifyYaml5 } from "yaml";
 import { randomUUID as randomUUID7 } from "crypto";
 var ObservationStore = class {
@@ -6728,18 +6898,18 @@ var ObservationStore = class {
   data = null;
   sessionId;
   constructor(projectPath, sessionId) {
-    this.filePath = join16(projectPath, ".skillkit", "memory", "observations.yaml");
+    this.filePath = join17(projectPath, ".skillkit", "memory", "observations.yaml");
     this.sessionId = sessionId || randomUUID7();
   }
   ensureDir() {
     const dir = dirname3(this.filePath);
-    if (!existsSync17(dir)) {
+    if (!existsSync18(dir)) {
       mkdirSync9(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync17(this.filePath)) {
+    if (existsSync18(this.filePath)) {
       try {
         const content = readFileSync12(this.filePath, "utf-8");
         this.data = parseYaml7(content);
@@ -6823,7 +6993,7 @@ var ObservationStore = class {
     }
   }
   exists() {
-    return existsSync17(this.filePath);
+    return existsSync18(this.filePath);
   }
   delete(id) {
     const data = this.load();
@@ -6846,9 +7016,9 @@ var ObservationStore = class {
 };
 
 // src/memory/learning-store.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname4, join as join17 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname4, join as join18 } from "path";
+import { homedir as homedir6 } from "os";
 import { parse as parseYaml8, stringify as stringifyYaml6 } from "yaml";
 import { randomUUID as randomUUID8 } from "crypto";
 var LearningStore = class {
@@ -6860,20 +7030,20 @@ var LearningStore = class {
     this.scope = scope;
     this.projectName = projectName;
     if (scope === "project" && projectPath) {
-      this.filePath = join17(projectPath, ".skillkit", "memory", "learnings.yaml");
+      this.filePath = join18(projectPath, ".skillkit", "memory", "learnings.yaml");
     } else {
-      this.filePath = join17(homedir5(), ".skillkit", "memory", "global.yaml");
+      this.filePath = join18(homedir6(), ".skillkit", "memory", "global.yaml");
     }
   }
   ensureDir() {
     const dir = dirname4(this.filePath);
-    if (!existsSync18(dir)) {
+    if (!existsSync19(dir)) {
       mkdirSync10(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync18(this.filePath)) {
+    if (existsSync19(this.filePath)) {
       try {
         const content = readFileSync13(this.filePath, "utf-8");
         this.data = parseYaml8(content);
@@ -7001,7 +7171,7 @@ var LearningStore = class {
     this.save();
   }
   exists() {
-    return existsSync18(this.filePath);
+    return existsSync19(this.filePath);
   }
   getScope() {
     return this.scope;
@@ -7009,24 +7179,24 @@ var LearningStore = class {
 };
 
 // src/memory/memory-index.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname5, join as join18 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname5, join as join19 } from "path";
 import { parse as parseYaml9, stringify as stringifyYaml7 } from "yaml";
 var MemoryIndexStore = class {
   filePath;
   data = null;
   constructor(basePath, _isGlobal = false) {
-    this.filePath = join18(basePath, ".skillkit", "memory", "index.yaml");
+    this.filePath = join19(basePath, ".skillkit", "memory", "index.yaml");
   }
   ensureDir() {
     const dir = dirname5(this.filePath);
-    if (!existsSync19(dir)) {
+    if (!existsSync20(dir)) {
       mkdirSync11(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync19(this.filePath)) {
+    if (existsSync20(this.filePath)) {
       try {
         const content = readFileSync14(this.filePath, "utf-8");
         this.data = parseYaml9(content);
@@ -7246,7 +7416,7 @@ var MemoryIndexStore = class {
     this.save();
   }
   exists() {
-    return existsSync19(this.filePath);
+    return existsSync20(this.filePath);
   }
   getStats() {
     const data = this.load();
@@ -7259,50 +7429,50 @@ var MemoryIndexStore = class {
 };
 
 // src/memory/initializer.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12 } from "fs";
-import { join as join19 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir7 } from "os";
 function getMemoryPaths(projectPath) {
-  const projectMemoryDir = join19(projectPath, ".skillkit", "memory");
-  const globalMemoryDir = join19(homedir6(), ".skillkit", "memory");
+  const projectMemoryDir = join20(projectPath, ".skillkit", "memory");
+  const globalMemoryDir = join20(homedir7(), ".skillkit", "memory");
   return {
     projectMemoryDir,
     globalMemoryDir,
-    observationsFile: join19(projectMemoryDir, "observations.yaml"),
-    learningsFile: join19(projectMemoryDir, "learnings.yaml"),
-    indexFile: join19(projectMemoryDir, "index.yaml"),
-    globalLearningsFile: join19(globalMemoryDir, "global.yaml"),
-    globalIndexFile: join19(globalMemoryDir, "index.yaml")
+    observationsFile: join20(projectMemoryDir, "observations.yaml"),
+    learningsFile: join20(projectMemoryDir, "learnings.yaml"),
+    indexFile: join20(projectMemoryDir, "index.yaml"),
+    globalLearningsFile: join20(globalMemoryDir, "global.yaml"),
+    globalIndexFile: join20(globalMemoryDir, "index.yaml")
   };
 }
 function initializeMemoryDirectory(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  if (!existsSync20(paths.projectMemoryDir)) {
+  if (!existsSync21(paths.projectMemoryDir)) {
     mkdirSync12(paths.projectMemoryDir, { recursive: true });
   }
-  if (!existsSync20(paths.globalMemoryDir)) {
+  if (!existsSync21(paths.globalMemoryDir)) {
     mkdirSync12(paths.globalMemoryDir, { recursive: true });
   }
   return paths;
 }
 function memoryDirectoryExists(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  return existsSync20(paths.projectMemoryDir);
+  return existsSync21(paths.projectMemoryDir);
 }
 function globalMemoryDirectoryExists() {
-  const globalMemoryDir = join19(homedir6(), ".skillkit", "memory");
-  return existsSync20(globalMemoryDir);
+  const globalMemoryDir = join20(homedir7(), ".skillkit", "memory");
+  return existsSync21(globalMemoryDir);
 }
 function getMemoryStatus(projectPath) {
   const paths = getMemoryPaths(projectPath);
   return {
-    projectMemoryExists: existsSync20(paths.projectMemoryDir),
-    globalMemoryExists: existsSync20(paths.globalMemoryDir),
-    hasObservations: existsSync20(paths.observationsFile),
-    hasLearnings: existsSync20(paths.learningsFile),
-    hasGlobalLearnings: existsSync20(paths.globalLearningsFile),
-    hasIndex: existsSync20(paths.indexFile),
-    hasGlobalIndex: existsSync20(paths.globalIndexFile)
+    projectMemoryExists: existsSync21(paths.projectMemoryDir),
+    globalMemoryExists: existsSync21(paths.globalMemoryDir),
+    hasObservations: existsSync21(paths.observationsFile),
+    hasLearnings: existsSync21(paths.learningsFile),
+    hasGlobalLearnings: existsSync21(paths.globalLearningsFile),
+    hasIndex: existsSync21(paths.indexFile),
+    hasGlobalIndex: existsSync21(paths.globalIndexFile)
   };
 }
 
@@ -7904,7 +8074,7 @@ function wrapProgressCallbackWithMemory(projectPath, existingCallback, memoryCon
 }
 
 // src/memory/compressor.ts
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 var DEFAULT_COMPRESSION_OPTIONS = {
   minObservations: 3,
   maxLearnings: 10,
@@ -8499,7 +8669,7 @@ var MemoryCompressor = class {
       projectPath,
       options?.projectName
     );
-    const indexBasePath = options?.scope === "global" ? homedir7() : projectPath;
+    const indexBasePath = options?.scope === "global" ? homedir8() : projectPath;
     this.indexStore = new MemoryIndexStore(indexBasePath, options?.scope === "global");
     this.projectName = options?.projectName;
   }
@@ -9180,6 +9350,1077 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
 function createMemoryInjector(projectPath, projectName, projectContext) {
   return new MemoryInjector(projectPath, projectName, projectContext);
 }
+
+// src/team/manager.ts
+import { existsSync as existsSync22, readFileSync as readFileSync15, writeFileSync as writeFileSync12, mkdirSync as mkdirSync13 } from "fs";
+import { join as join21, dirname as dirname6 } from "path";
+import { execSync as execSync6 } from "child_process";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+var TEAM_CONFIG_FILE = "team.yaml";
+var TEAM_DIR = ".skillkit/team";
+var TeamManager = class {
+  projectPath;
+  config = null;
+  registry = null;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Initialize team configuration
+   */
+  async init(config) {
+    const teamId = this.generateTeamId();
+    const fullConfig = {
+      ...config,
+      teamId
+    };
+    const teamDir = join21(this.projectPath, TEAM_DIR);
+    if (!existsSync22(teamDir)) {
+      mkdirSync13(teamDir, { recursive: true });
+    }
+    this.saveConfig(fullConfig);
+    this.config = fullConfig;
+    const registry = {
+      version: 1,
+      teamId,
+      teamName: config.teamName,
+      skills: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveRegistry(registry);
+    this.registry = registry;
+    return fullConfig;
+  }
+  /**
+   * Load existing team configuration
+   */
+  load() {
+    const configPath = join21(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    if (!existsSync22(configPath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync15(configPath, "utf-8");
+      this.config = this.parseYaml(content);
+      this.loadRegistry();
+      return this.config;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get current config
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Get current registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Share a skill to the team registry
+   */
+  async shareSkill(options) {
+    if (!this.config || !this.registry) {
+      throw new Error("Team not initialized. Run `skillkit team init` first.");
+    }
+    const skillPath = this.findLocalSkill(options.skillName);
+    if (!skillPath) {
+      throw new Error(`Skill "${options.skillName}" not found locally.`);
+    }
+    const skillMdPath = join21(skillPath, "SKILL.md");
+    const skillContent = existsSync22(skillMdPath) ? readFileSync15(skillMdPath, "utf-8") : "";
+    const metadata = this.extractFrontmatter(skillContent);
+    const shared = {
+      name: options.skillName,
+      version: metadata.version || "1.0.0",
+      description: options.description || metadata.description || "",
+      author: this.getAuthor(),
+      sharedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: `${this.config.registryUrl}#${options.skillName}`,
+      tags: options.tags || metadata.tags || [],
+      agents: options.agents || this.detectCompatibleAgents(skillPath),
+      downloads: 0
+    };
+    const existingIndex = this.registry.skills.findIndex(
+      (s) => s.name === options.skillName
+    );
+    if (existingIndex >= 0) {
+      shared.sharedAt = this.registry.skills[existingIndex].sharedAt;
+      shared.downloads = this.registry.skills[existingIndex].downloads;
+      this.registry.skills[existingIndex] = shared;
+    } else {
+      this.registry.skills.push(shared);
+    }
+    this.registry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.saveRegistry(this.registry);
+    return shared;
+  }
+  /**
+   * List all shared skills in the team registry
+   */
+  listSharedSkills() {
+    return this.registry?.skills || [];
+  }
+  /**
+   * Search shared skills
+   */
+  searchSkills(query) {
+    if (!this.registry) return [];
+    const lowerQuery = query.toLowerCase();
+    return this.registry.skills.filter(
+      (s) => s.name.toLowerCase().includes(lowerQuery) || s.description?.toLowerCase().includes(lowerQuery) || s.tags?.some((t) => t.toLowerCase().includes(lowerQuery))
+    );
+  }
+  /**
+   * Import a shared skill from the team registry
+   */
+  async importSkill(skillName, options = {}) {
+    if (!this.config || !this.registry) {
+      return { success: false, error: "Team not initialized" };
+    }
+    const sharedSkill = this.registry.skills.find((s) => s.name === skillName);
+    if (!sharedSkill) {
+      return { success: false, error: `Skill "${skillName}" not found in team registry` };
+    }
+    const localPath = this.findLocalSkill(skillName);
+    if (localPath && !options.overwrite) {
+      return {
+        success: false,
+        error: `Skill "${skillName}" already exists. Use --overwrite to replace.`
+      };
+    }
+    if (options.dryRun) {
+      return {
+        success: true,
+        path: join21(this.projectPath, ".skillkit", "skills", skillName)
+      };
+    }
+    try {
+      const provider = detectProvider(this.config.registryUrl);
+      if (!provider) {
+        return { success: false, error: "Cannot detect provider for registry URL" };
+      }
+      const cloneOptions = { depth: 1 };
+      if (this.config.auth?.type === "ssh") {
+        cloneOptions.ssh = true;
+      }
+      const result = await provider.clone(this.config.registryUrl, skillName, cloneOptions);
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+      sharedSkill.downloads = (sharedSkill.downloads || 0) + 1;
+      this.saveRegistry(this.registry);
+      return { success: true, path: result.path };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Sync with remote registry
+   */
+  async sync() {
+    if (!this.config) {
+      throw new Error("Team not initialized");
+    }
+    if (!this.registry) {
+      throw new Error("Team registry not loaded. Call load() first.");
+    }
+    const result = { added: [], updated: [], removed: [] };
+    try {
+      const provider = detectProvider(this.config.registryUrl);
+      if (!provider) {
+        throw new Error("Cannot detect provider for registry URL");
+      }
+      const cloneOptions = { depth: 1 };
+      if (this.config.auth?.type === "ssh") {
+        cloneOptions.ssh = true;
+      }
+      const fetchResult = await provider.clone(this.config.registryUrl, "", cloneOptions);
+      if (!fetchResult.success || !fetchResult.path) {
+        throw new Error(fetchResult.error || "Failed to fetch remote registry");
+      }
+      const remoteRegistryPath = join21(fetchResult.path, TEAM_DIR, "registry.yaml");
+      if (existsSync22(remoteRegistryPath)) {
+        const remoteContent = readFileSync15(remoteRegistryPath, "utf-8");
+        const remoteRegistry = this.parseYaml(remoteContent);
+        const localSkillNames = new Set(this.registry?.skills.map((s) => s.name) || []);
+        for (const skill of remoteRegistry.skills) {
+          if (!localSkillNames.has(skill.name)) {
+            result.added.push(skill.name);
+            this.registry?.skills.push(skill);
+          } else {
+            const local = this.registry?.skills.find((s) => s.name === skill.name);
+            if (local && new Date(skill.updatedAt) > new Date(local.updatedAt)) {
+              result.updated.push(skill.name);
+              Object.assign(local, skill);
+            }
+          }
+        }
+        if (this.registry) {
+          this.registry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.saveRegistry(this.registry);
+        }
+      }
+      if (fetchResult.tempRoot) {
+        const { rmSync: rmSync5 } = await import("fs");
+        rmSync5(fetchResult.tempRoot, { recursive: true, force: true });
+      }
+    } catch (err) {
+      throw new Error(`Sync failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+    return result;
+  }
+  /**
+   * Remove a skill from the team registry
+   */
+  removeSkill(skillName) {
+    if (!this.registry) return false;
+    const index = this.registry.skills.findIndex((s) => s.name === skillName);
+    if (index === -1) return false;
+    this.registry.skills.splice(index, 1);
+    this.registry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.saveRegistry(this.registry);
+    return true;
+  }
+  // Private helpers
+  generateTeamId() {
+    return `team-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  saveConfig(config) {
+    const configPath = join21(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    const dir = dirname6(configPath);
+    if (!existsSync22(dir)) {
+      mkdirSync13(dir, { recursive: true });
+    }
+    writeFileSync12(configPath, this.toYaml(config), "utf-8");
+  }
+  loadRegistry() {
+    const registryPath = join21(this.projectPath, TEAM_DIR, "registry.yaml");
+    if (existsSync22(registryPath)) {
+      const content = readFileSync15(registryPath, "utf-8");
+      this.registry = this.parseYaml(content);
+    }
+  }
+  saveRegistry(registry) {
+    const registryPath = join21(this.projectPath, TEAM_DIR, "registry.yaml");
+    writeFileSync12(registryPath, this.toYaml(registry), "utf-8");
+  }
+  findLocalSkill(skillName) {
+    const possiblePaths = [
+      join21(this.projectPath, ".skillkit", "skills", skillName),
+      join21(this.projectPath, "skills", skillName),
+      join21(this.projectPath, ".claude", "skills", skillName)
+    ];
+    for (const p of possiblePaths) {
+      if (existsSync22(p)) {
+        return p;
+      }
+    }
+    return null;
+  }
+  getAuthor() {
+    try {
+      const name = execSync6("git config user.name", { encoding: "utf-8" }).trim();
+      const email = execSync6("git config user.email", { encoding: "utf-8" }).trim();
+      return email ? `${name} <${email}>` : name;
+    } catch {
+      return "Unknown";
+    }
+  }
+  detectCompatibleAgents(skillPath) {
+    const agents = [];
+    if (existsSync22(join21(skillPath, "SKILL.md"))) {
+      agents.push("claude-code", "codex", "gemini-cli", "universal");
+    }
+    if (existsSync22(join21(skillPath, "skill.mdc"))) {
+      agents.push("cursor");
+    }
+    if (existsSync22(join21(skillPath, "rules.md"))) {
+      agents.push("windsurf");
+    }
+    return agents.length > 0 ? agents : ["universal"];
+  }
+  extractFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+    try {
+      return this.parseYaml(match[1]);
+    } catch {
+      return {};
+    }
+  }
+  parseYaml(content) {
+    return yamlParse(content);
+  }
+  toYaml(obj) {
+    return yamlStringify(obj, { indent: 2 });
+  }
+};
+function createTeamManager(projectPath) {
+  return new TeamManager(projectPath);
+}
+
+// src/team/bundle.ts
+import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { join as join22, basename as basename8, resolve as resolve2, relative, dirname as dirname7, sep } from "path";
+import { createHash } from "crypto";
+var BUNDLE_VERSION = 1;
+var SkillBundle = class {
+  manifest;
+  skills = /* @__PURE__ */ new Map();
+  // skillName -> content
+  constructor(name, author, description) {
+    this.manifest = {
+      version: BUNDLE_VERSION,
+      name,
+      description,
+      author,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      skills: [],
+      totalSize: 0
+    };
+  }
+  /**
+   * Add a skill to the bundle
+   */
+  addSkill(skillPath, agents) {
+    const skillName = basename8(skillPath);
+    if (this.skills.has(skillName)) {
+      throw new Error(`Skill "${skillName}" already exists in bundle`);
+    }
+    const content = this.readSkillContent(skillPath);
+    this.skills.set(skillName, content);
+    this.manifest.skills.push({
+      name: skillName,
+      path: skillName,
+      // Store only the skill name, not the full path
+      agents: agents || this.detectAgents(skillPath)
+    });
+    this.manifest.totalSize += Buffer.byteLength(content, "utf-8");
+  }
+  /**
+   * Remove a skill from the bundle
+   */
+  removeSkill(skillName) {
+    const skill = this.manifest.skills.find((s) => s.name === skillName);
+    if (!skill) return false;
+    const content = this.skills.get(skillName);
+    if (content) {
+      this.manifest.totalSize -= Buffer.byteLength(content, "utf-8");
+    }
+    this.skills.delete(skillName);
+    this.manifest.skills = this.manifest.skills.filter((s) => s.name !== skillName);
+    return true;
+  }
+  /**
+   * Get bundle manifest
+   */
+  getManifest() {
+    return { ...this.manifest };
+  }
+  /**
+   * Get all skill names in bundle
+   */
+  getSkillNames() {
+    return this.manifest.skills.map((s) => s.name);
+  }
+  /**
+   * Get skill content by name
+   */
+  getSkillContent(skillName) {
+    return this.skills.get(skillName);
+  }
+  /**
+   * Calculate bundle checksum
+   */
+  getChecksum() {
+    const contents = [];
+    for (const [name, content] of this.skills.entries()) {
+      contents.push(`${name}:${content}`);
+    }
+    contents.sort();
+    return createHash("sha256").update(contents.join("\n")).digest("hex").slice(0, 12);
+  }
+  readSkillContent(skillPath) {
+    const contents = [];
+    const readDir = (dir, prefix = "") => {
+      const entries = readdirSync5(dir);
+      for (const entry of entries) {
+        const fullPath = join22(dir, entry);
+        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+        const stat = statSync3(fullPath);
+        if (stat.isDirectory()) {
+          readDir(fullPath, relativePath);
+        } else if (stat.isFile()) {
+          const content = readFileSync16(fullPath, "utf-8");
+          contents.push(`--- ${relativePath} ---
+${content}`);
+        }
+      }
+    };
+    if (statSync3(skillPath).isDirectory()) {
+      readDir(skillPath);
+    } else {
+      contents.push(readFileSync16(skillPath, "utf-8"));
+    }
+    return contents.join("\n\n");
+  }
+  detectAgents(skillPath) {
+    const agents = [];
+    if (existsSync23(skillPath) && statSync3(skillPath).isFile()) {
+      const fileName = basename8(skillPath).toLowerCase();
+      if (fileName === "skill.md") {
+        return ["claude-code", "codex", "gemini-cli", "universal"];
+      }
+      if (fileName === "skill.mdc") {
+        return ["cursor"];
+      }
+      if (fileName === "rules.md") {
+        return ["windsurf"];
+      }
+      return ["universal"];
+    }
+    if (existsSync23(join22(skillPath, "SKILL.md"))) {
+      agents.push("claude-code", "codex", "gemini-cli", "universal");
+    }
+    if (existsSync23(join22(skillPath, "skill.mdc"))) {
+      agents.push("cursor");
+    }
+    if (existsSync23(join22(skillPath, "rules.md"))) {
+      agents.push("windsurf");
+    }
+    return agents.length > 0 ? agents : ["universal"];
+  }
+};
+function createSkillBundle(name, author, description) {
+  return new SkillBundle(name, author, description);
+}
+function exportBundle(bundle, outputPath) {
+  try {
+    const manifest = bundle.getManifest();
+    const exportData = {
+      manifest,
+      skills: {}
+    };
+    for (const skill of manifest.skills) {
+      const content = bundle.getSkillContent(skill.name);
+      if (content) {
+        exportData.skills[skill.name] = content;
+      }
+    }
+    const dir = dirname7(outputPath);
+    if (dir && !existsSync23(dir)) {
+      mkdirSync14(dir, { recursive: true });
+    }
+    writeFileSync13(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
+    return { success: true, path: outputPath };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function importBundle(bundlePath, targetDir, options = {}) {
+  const imported = [];
+  const errors = [];
+  try {
+    const content = readFileSync16(bundlePath, "utf-8");
+    const data = JSON.parse(content);
+    const absoluteTargetDir = resolve2(targetDir);
+    for (const skill of data.manifest.skills) {
+      if (!skill.name || skill.name.includes("/") || skill.name.includes("\\") || skill.name === ".." || skill.name === "." || skill.name.startsWith(".")) {
+        errors.push(`Skill has invalid name: ${skill.name}`);
+        continue;
+      }
+      const skillContent = data.skills[skill.name];
+      if (!skillContent) {
+        errors.push(`Skill "${skill.name}" has no content in bundle`);
+        continue;
+      }
+      const skillDir = join22(absoluteTargetDir, skill.name);
+      const resolvedSkillDir = resolve2(skillDir);
+      const relativeToTarget = relative(absoluteTargetDir, resolvedSkillDir);
+      if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep)) {
+        errors.push(`Skill "${skill.name}" would escape target directory`);
+        continue;
+      }
+      if (existsSync23(skillDir) && !options.overwrite) {
+        errors.push(`Skill "${skill.name}" already exists (use --overwrite)`);
+        continue;
+      }
+      if (!existsSync23(skillDir)) {
+        mkdirSync14(skillDir, { recursive: true });
+      }
+      const files = parseSkillContent2(skillContent);
+      for (const [filePath, fileContent] of Object.entries(files)) {
+        const fullPath = resolve2(skillDir, filePath);
+        const relativeToSkill = relative(skillDir, fullPath);
+        if (relativeToSkill.startsWith("..") || relativeToSkill.startsWith(sep)) {
+          errors.push(`Skill "${skill.name}" contains invalid file path: ${filePath}`);
+          continue;
+        }
+        const fileDir = dirname7(fullPath);
+        if (!existsSync23(fileDir)) {
+          mkdirSync14(fileDir, { recursive: true });
+        }
+        writeFileSync13(fullPath, fileContent, "utf-8");
+      }
+      imported.push(skill.name);
+    }
+    return { success: errors.length === 0, imported, errors };
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : "Unknown error");
+    return { success: false, imported, errors };
+  }
+}
+function parseSkillContent2(content) {
+  const files = {};
+  const sections = content.split(/(?:^|\n)--- ([^\n]+) ---\n/);
+  let i = 1;
+  while (i < sections.length) {
+    const filePath = sections[i];
+    const fileContent = sections[i + 1] || "";
+    if (filePath && !filePath.startsWith("---")) {
+      files[filePath.trim()] = fileContent;
+    }
+    i += 2;
+  }
+  if (Object.keys(files).length === 0 && content.trim()) {
+    files["SKILL.md"] = content;
+  }
+  return files;
+}
+
+// src/plugins/manager.ts
+import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
+import { join as join23 } from "path";
+var PLUGINS_DIR = ".skillkit/plugins";
+var PLUGINS_CONFIG_FILE = "plugins.json";
+var PluginManager = class {
+  projectPath;
+  plugins = /* @__PURE__ */ new Map();
+  translators = /* @__PURE__ */ new Map();
+  providers = /* @__PURE__ */ new Map();
+  commands = /* @__PURE__ */ new Map();
+  hooks = /* @__PURE__ */ new Map();
+  state;
+  context;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.state = this.loadState();
+    this.context = this.createContext();
+  }
+  /**
+   * Register a plugin
+   */
+  async register(plugin) {
+    const name = plugin.metadata.name;
+    if (this.plugins.has(name)) {
+      throw new Error(`Plugin "${name}" is already registered`);
+    }
+    if (plugin.metadata.dependencies) {
+      for (const dep of plugin.metadata.dependencies) {
+        if (!this.plugins.has(dep)) {
+          throw new Error(`Plugin "${name}" requires "${dep}" which is not loaded`);
+        }
+      }
+    }
+    if (plugin.init) {
+      await plugin.init(this.context);
+    }
+    if (plugin.translators) {
+      for (const t of plugin.translators) {
+        this.translators.set(t.agentType, t.translator);
+      }
+    }
+    if (plugin.providers) {
+      for (const p of plugin.providers) {
+        this.providers.set(p.providerName, p.provider);
+      }
+    }
+    if (plugin.commands) {
+      for (const c of plugin.commands) {
+        this.commands.set(c.name, c);
+        if (c.aliases) {
+          for (const alias of c.aliases) {
+            this.commands.set(alias, c);
+          }
+        }
+      }
+    }
+    if (plugin.hooks) {
+      this.hooks.set(name, plugin.hooks);
+      if (plugin.hooks.onLoad) {
+        await plugin.hooks.onLoad(this.context);
+      }
+    }
+    this.plugins.set(name, plugin);
+    this.state.plugins[name] = {
+      enabled: true,
+      config: {},
+      loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveState();
+  }
+  /**
+   * Unregister a plugin
+   */
+  async unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin "${name}" is not registered`);
+    }
+    const hooks = this.hooks.get(name);
+    if (hooks?.onUnload) {
+      await hooks.onUnload();
+    }
+    if (plugin.destroy) {
+      await plugin.destroy();
+    }
+    if (plugin.translators) {
+      for (const t of plugin.translators) {
+        this.translators.delete(t.agentType);
+      }
+    }
+    if (plugin.providers) {
+      for (const p of plugin.providers) {
+        this.providers.delete(p.providerName);
+      }
+    }
+    if (plugin.commands) {
+      for (const c of plugin.commands) {
+        this.commands.delete(c.name);
+        if (c.aliases) {
+          for (const alias of c.aliases) {
+            this.commands.delete(alias);
+          }
+        }
+      }
+    }
+    this.hooks.delete(name);
+    this.plugins.delete(name);
+    delete this.state.plugins[name];
+    this.saveState();
+  }
+  /**
+   * Get a registered plugin
+   */
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Get all registered plugins
+   */
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Get plugin metadata for all plugins
+   */
+  listPlugins() {
+    return this.getAllPlugins().map((p) => p.metadata);
+  }
+  /**
+   * Get a translator by agent type
+   */
+  getTranslator(agentType) {
+    return this.translators.get(agentType);
+  }
+  /**
+   * Get all registered translators
+   */
+  getAllTranslators() {
+    return new Map(this.translators);
+  }
+  /**
+   * Get a provider by name
+   */
+  getProvider(name) {
+    return this.providers.get(name);
+  }
+  /**
+   * Get all registered providers
+   */
+  getAllProviders() {
+    return new Map(this.providers);
+  }
+  /**
+   * Get a command by name
+   */
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  /**
+   * Get all registered commands
+   */
+  getAllCommands() {
+    return Array.from(new Set(this.commands.values()));
+  }
+  /**
+   * Execute hooks for an event
+   */
+  async executeHook(hookName, ...args) {
+    for (const [, hooks] of this.hooks) {
+      const hook = hooks[hookName];
+      if (hook) {
+        await hook(...args);
+      }
+    }
+  }
+  /**
+   * Execute beforeTranslate hooks (returns transformed skill)
+   */
+  async executeBeforeTranslate(skill, targetAgent) {
+    let result = skill;
+    for (const [, hooks] of this.hooks) {
+      if (hooks.beforeTranslate) {
+        result = await hooks.beforeTranslate(result, targetAgent);
+      }
+    }
+    return result;
+  }
+  /**
+   * Execute afterTranslate hooks (returns transformed content)
+   */
+  async executeAfterTranslate(content, targetAgent) {
+    let result = content;
+    for (const [, hooks] of this.hooks) {
+      if (hooks.afterTranslate) {
+        result = await hooks.afterTranslate(result, targetAgent);
+      }
+    }
+    return result;
+  }
+  /**
+   * Set plugin configuration
+   */
+  setPluginConfig(name, config) {
+    if (!this.state.plugins[name]) {
+      this.state.plugins[name] = { enabled: true, config };
+    } else {
+      this.state.plugins[name].config = config;
+    }
+    this.saveState();
+  }
+  /**
+   * Get plugin configuration
+   */
+  getPluginConfig(name) {
+    return this.state.plugins[name]?.config;
+  }
+  /**
+   * Enable a plugin
+   */
+  enablePlugin(name) {
+    if (this.state.plugins[name]) {
+      this.state.plugins[name].enabled = true;
+      this.saveState();
+    }
+  }
+  /**
+   * Disable a plugin
+   */
+  disablePlugin(name) {
+    if (this.state.plugins[name]) {
+      this.state.plugins[name].enabled = false;
+      this.saveState();
+    }
+  }
+  /**
+   * Check if plugin is enabled
+   */
+  isPluginEnabled(name) {
+    return this.state.plugins[name]?.enabled ?? true;
+  }
+  // Private helpers
+  loadState() {
+    const statePath = join23(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
+    if (existsSync24(statePath)) {
+      try {
+        return JSON.parse(readFileSync17(statePath, "utf-8"));
+      } catch {
+      }
+    }
+    return { version: 1, plugins: {} };
+  }
+  saveState() {
+    const pluginsDir = join23(this.projectPath, PLUGINS_DIR);
+    if (!existsSync24(pluginsDir)) {
+      mkdirSync15(pluginsDir, { recursive: true });
+    }
+    const statePath = join23(pluginsDir, PLUGINS_CONFIG_FILE);
+    writeFileSync14(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+  }
+  createContext() {
+    return {
+      projectPath: this.projectPath,
+      skillkitVersion: "1.4.0",
+      config: {},
+      log: {
+        info: (msg) => console.log(`[plugin] ${msg}`),
+        warn: (msg) => console.warn(`[plugin] ${msg}`),
+        error: (msg) => console.error(`[plugin] ${msg}`),
+        debug: (msg) => {
+          if (process.env.DEBUG) console.log(`[plugin:debug] ${msg}`);
+        }
+      },
+      getTranslator: (agentType) => this.translators.get(agentType),
+      getProvider: (name) => this.providers.get(name)
+    };
+  }
+};
+function createPluginManager(projectPath) {
+  return new PluginManager(projectPath);
+}
+
+// src/plugins/loader.ts
+import { existsSync as existsSync25, readFileSync as readFileSync18, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { join as join24, extname, basename as basename9, isAbsolute } from "path";
+import { pathToFileURL } from "url";
+var PluginLoader = class {
+  /**
+   * Load a plugin from a file path
+   */
+  async loadFromFile(filePath) {
+    if (!existsSync25(filePath)) {
+      throw new Error(`Plugin file not found: ${filePath}`);
+    }
+    const ext = extname(filePath);
+    if (ext !== ".js" && ext !== ".mjs") {
+      throw new Error(`Unsupported plugin file type: ${ext}. Only .js and .mjs files are supported.`);
+    }
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const plugin = module.default || module.plugin;
+      if (!plugin || !plugin.metadata) {
+        throw new Error("Invalid plugin: missing metadata");
+      }
+      return this.validatePlugin(plugin);
+    } catch (err) {
+      throw new Error(
+        `Failed to load plugin from ${filePath}: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Load a plugin from an npm package
+   */
+  async loadFromPackage(packageName) {
+    try {
+      const module = await import(packageName);
+      const plugin = module.default || module.plugin;
+      if (!plugin || !plugin.metadata) {
+        throw new Error("Invalid plugin: missing metadata");
+      }
+      return this.validatePlugin(plugin);
+    } catch (err) {
+      throw new Error(
+        `Failed to load plugin from package ${packageName}: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Load a plugin from a JSON definition (for simple plugins)
+   */
+  loadFromJson(jsonPath) {
+    if (!existsSync25(jsonPath)) {
+      throw new Error(`Plugin JSON not found: ${jsonPath}`);
+    }
+    try {
+      const content = readFileSync18(jsonPath, "utf-8");
+      const data = JSON.parse(content);
+      if (!data.metadata) {
+        throw new Error("Invalid plugin JSON: missing metadata");
+      }
+      const plugin = {
+        metadata: data.metadata
+      };
+      return this.validatePlugin(plugin);
+    } catch (err) {
+      throw new Error(
+        `Failed to load plugin from ${jsonPath}: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Scan a directory for plugins
+   */
+  async scanDirectory(dirPath) {
+    if (!existsSync25(dirPath)) {
+      return [];
+    }
+    const plugins = [];
+    const entries = readdirSync6(dirPath);
+    for (const entry of entries) {
+      const fullPath = join24(dirPath, entry);
+      let stat;
+      try {
+        stat = statSync4(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        const pkgPath = join24(fullPath, "package.json");
+        const pluginPath = join24(fullPath, "plugin.json");
+        if (existsSync25(pkgPath)) {
+          try {
+            const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+            if ((pkg.skillkitPlugin || pkg.keywords?.includes("skillkit-plugin")) && pkg.name && typeof pkg.name === "string" && pkg.version && typeof pkg.version === "string") {
+              plugins.push({
+                name: pkg.name,
+                version: pkg.version,
+                description: pkg.description,
+                author: pkg.author,
+                homepage: pkg.homepage
+              });
+            }
+          } catch {
+          }
+        } else if (existsSync25(pluginPath)) {
+          try {
+            const data = JSON.parse(readFileSync18(pluginPath, "utf-8"));
+            if (data.metadata && data.metadata.name && typeof data.metadata.name === "string" && data.metadata.version && typeof data.metadata.version === "string") {
+              plugins.push(data.metadata);
+            }
+          } catch {
+          }
+        }
+      } else if (stat.isFile()) {
+        const ext = extname(entry);
+        if (ext === ".js" || ext === ".mjs") {
+          const name = basename9(entry, ext);
+          if (name.includes("plugin") || name.startsWith("skillkit-")) {
+            plugins.push({
+              name,
+              version: "0.0.0",
+              // Unknown until loaded
+              description: `Plugin file: ${entry}`
+            });
+          }
+        }
+      }
+    }
+    return plugins;
+  }
+  /**
+   * Validate a plugin structure
+   */
+  validatePlugin(plugin) {
+    const { metadata } = plugin;
+    if (!metadata.name) {
+      throw new Error("Plugin metadata must include a name");
+    }
+    if (!metadata.version) {
+      throw new Error("Plugin metadata must include a version");
+    }
+    if (!/^(?:@[a-z0-9-]+\/)?[a-z0-9-]+$/.test(metadata.name)) {
+      throw new Error(
+        "Plugin name must be lowercase alphanumeric with hyphens only (scoped names like @scope/name are allowed)"
+      );
+    }
+    if (!/^\d+\.\d+\.\d+/.test(metadata.version)) {
+      throw new Error("Plugin version must be semver format (e.g., 1.0.0)");
+    }
+    if (plugin.translators) {
+      for (const t of plugin.translators) {
+        if (!t.agentType || !t.translator) {
+          throw new Error("Translator plugin must include agentType and translator");
+        }
+      }
+    }
+    if (plugin.providers) {
+      for (const p of plugin.providers) {
+        if (!p.providerName || !p.provider) {
+          throw new Error("Provider plugin must include providerName and provider");
+        }
+      }
+    }
+    if (plugin.commands) {
+      for (const c of plugin.commands) {
+        if (!c.name || !c.handler) {
+          throw new Error("Command plugin must include name and handler");
+        }
+      }
+    }
+    return plugin;
+  }
+};
+async function loadPlugin(source) {
+  const loader = new PluginLoader();
+  const isLocalPath2 = source.startsWith(".") || // ./, ../, .hidden
+  isAbsolute(source) || // /abs/path or C:\path
+  source.includes("/") && !source.startsWith("@") || // plugins/x.js (but not @scope/pkg)
+  source.includes("\\") || // Windows backslash
+  source.startsWith("~");
+  if (isLocalPath2) {
+    if (source.endsWith(".json")) {
+      return loader.loadFromJson(source);
+    }
+    return loader.loadFromFile(source);
+  } else if (source.startsWith("@") || /^[a-z0-9-]+$/.test(source)) {
+    return loader.loadFromPackage(source);
+  } else {
+    throw new Error(`Cannot determine plugin source type: ${source}`);
+  }
+}
+async function loadPluginsFromDirectory(dirPath) {
+  const loader = new PluginLoader();
+  const plugins = [];
+  if (!existsSync25(dirPath)) {
+    return plugins;
+  }
+  const entries = readdirSync6(dirPath);
+  for (const entry of entries) {
+    const fullPath = join24(dirPath, entry);
+    let stat;
+    try {
+      stat = statSync4(fullPath);
+    } catch {
+      continue;
+    }
+    try {
+      if (stat.isDirectory()) {
+        const indexMjsPath = join24(fullPath, "index.mjs");
+        const indexPath = join24(fullPath, "index.js");
+        const mainMjsPath = join24(fullPath, "plugin.mjs");
+        const mainPath = join24(fullPath, "plugin.js");
+        const jsonPath = join24(fullPath, "plugin.json");
+        if (existsSync25(indexMjsPath)) {
+          plugins.push(await loader.loadFromFile(indexMjsPath));
+        } else if (existsSync25(indexPath)) {
+          plugins.push(await loader.loadFromFile(indexPath));
+        } else if (existsSync25(mainMjsPath)) {
+          plugins.push(await loader.loadFromFile(mainMjsPath));
+        } else if (existsSync25(mainPath)) {
+          plugins.push(await loader.loadFromFile(mainPath));
+        } else if (existsSync25(jsonPath)) {
+          plugins.push(loader.loadFromJson(jsonPath));
+        }
+      } else if (stat.isFile()) {
+        const ext = extname(entry);
+        if (ext === ".js" || ext === ".mjs") {
+          plugins.push(await loader.loadFromFile(fullPath));
+        } else if (ext === ".json" && entry.includes("plugin")) {
+          plugins.push(loader.loadFromJson(fullPath));
+        }
+      }
+    } catch (err) {
+      console.warn(`Failed to load plugin from ${fullPath}: ${err}`);
+    }
+  }
+  return plugins;
+}
 export {
   AGENT_CLI_CONFIGS,
   AGENT_FORMAT_MAP,
@@ -9221,6 +10462,8 @@ export {
   PRE_COMMIT_CONFIG_TEMPLATE,
   PRE_COMMIT_HOOK_TEMPLATE,
   PROJECT_TYPE_HINTS,
+  PluginLoader,
+  PluginManager,
   ProjectDetector,
   RecommendationEngine,
   RuleBasedCompressor,
@@ -9228,6 +10471,7 @@ export {
   SKILL_DISCOVERY_PATHS,
   SessionManager,
   Skill,
+  SkillBundle,
   SkillExecutionEngine,
   SkillFrontmatter,
   SkillLocation,
@@ -9236,6 +10480,7 @@ export {
   SkillSummary,
   SkillkitConfig,
   TAG_TO_TECH,
+  TeamManager,
   TranslatorRegistry,
   WORKFLOWS_DIR,
   WORKFLOW_EXTENSION,
@@ -9255,9 +10500,14 @@ export {
   createMemoryEnabledEngine,
   createMemoryInjector,
   createMemoryObserver,
+  createPluginManager,
   createRecommendationEngine,
   createRuleBasedCompressor,
   createSessionManager,
+  createSimulatedSkillExecutor,
+  createSkillBundle,
+  createSkillExecutor,
+  createTeamManager,
   createTestSuiteFromFrontmatter,
   createWorkflowOrchestrator,
   createWorkflowTemplate,
@@ -9267,6 +10517,7 @@ export {
   discoverSkills,
   estimateTokens,
   executeWithAgent,
+  exportBundle,
   extractField,
   extractFrontmatter,
   fetchSkillsFromRepo,
@@ -9292,6 +10543,7 @@ export {
   getSupportedTranslationAgents,
   getTechTags,
   globalMemoryDirectoryExists,
+  importBundle,
   initContext,
   initProject,
   initializeMemoryDirectory,
@@ -9306,6 +10558,8 @@ export {
   loadContext,
   loadIndex,
   loadMetadata,
+  loadPlugin,
+  loadPluginsFromDirectory,
   loadSkillMetadata,
   loadWorkflow,
   loadWorkflowByName,