@skillkit/core 1.10.0 → 1.12.0

package/dist/index.js

@@ -284,7 +284,7 @@ var init_local_models = __esm({
             if (done) break;
             const canContinue = fileStream.write(Buffer.from(value));
             if (!canContinue) {
-              await new Promise((resolve5) => fileStream.once("drain", resolve5));
+              await new Promise((resolve6) => fileStream.once("drain", resolve6));
             }
             downloaded += value.length;
             onProgress?.({
@@ -295,8 +295,8 @@ var init_local_models = __esm({
             });
           }
           fileStream.end();
-          await new Promise((resolve5, reject) => {
-            fileStream.on("finish", resolve5);
+          await new Promise((resolve6, reject) => {
+            fileStream.on("finish", resolve6);
             fileStream.on("error", reject);
           });
           await fs.promises.rename(tempPath, modelPath);
@@ -3658,7 +3658,7 @@ function getConfigFormat(agent) {
 
 // src/skills.ts
 import { existsSync, readdirSync, readFileSync } from "fs";
-import { join, basename } from "path";
+import { join, basename, resolve, sep } from "path";
 import { parse as parseYaml } from "yaml";
 var SKILL_DISCOVERY_PATHS = [
   "skills",
@@ -3971,8 +3971,9 @@ function validateSkill(skillPath) {
   return { valid: errors.length === 0, errors, warnings };
 }
 function isPathInside(child, parent) {
-  const relative5 = child.replace(parent, "");
-  return !relative5.startsWith("..") && !relative5.includes("/..");
+  const resolved = resolve(child);
+  const resolvedParent = resolve(parent);
+  return resolved === resolvedParent || resolved.startsWith(resolvedParent + sep);
 }
 
 // src/config.ts
@@ -4368,7 +4369,7 @@ var BitbucketProvider = class {
 
 // src/providers/local.ts
 import { existsSync as existsSync6, statSync, realpathSync } from "fs";
-import { join as join6, resolve, basename as basename5 } from "path";
+import { join as join6, resolve as resolve2, basename as basename5 } from "path";
 import { homedir as homedir2 } from "os";
 var LocalProvider = class {
   type = "local";
@@ -4382,7 +4383,7 @@ var LocalProvider = class {
     if (source.startsWith("~/")) {
       expandedPath = join6(homedir2(), source.slice(2));
     }
-    const absolutePath = resolve(expandedPath);
+    const absolutePath = resolve2(expandedPath);
     const dirName = basename5(absolutePath);
     return {
       owner: "local",
@@ -4438,7 +4439,7 @@ var LocalProvider = class {
 
 // src/providers/wellknown.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync as rmSync4 } from "fs";
-import { join as join7, basename as basename6, resolve as resolve2, sep } from "path";
+import { join as join7, basename as basename6, resolve as resolve3, sep as sep2 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 function sanitizeSkillName(name) {
@@ -4521,9 +4522,9 @@ var WellKnownProvider = class {
           continue;
         }
         const skillDir = join7(tempDir, safeName);
-        const resolvedSkillDir = resolve2(skillDir);
-        const resolvedTempDir = resolve2(tempDir);
-        if (!resolvedSkillDir.startsWith(resolvedTempDir + sep) && resolvedSkillDir !== resolvedTempDir) {
+        const resolvedSkillDir = resolve3(skillDir);
+        const resolvedTempDir = resolve3(tempDir);
+        if (!resolvedSkillDir.startsWith(resolvedTempDir + sep2) && resolvedSkillDir !== resolvedTempDir) {
           continue;
         }
         mkdirSync2(skillDir, { recursive: true });
@@ -4591,7 +4592,7 @@ function generateWellKnownIndex(skills) {
 }
 function generateWellKnownStructure(outputDir, skills) {
   const wellKnownDir = join7(outputDir, ".well-known", "skills");
-  const resolvedWellKnownDir = resolve2(wellKnownDir);
+  const resolvedWellKnownDir = resolve3(wellKnownDir);
   mkdirSync2(wellKnownDir, { recursive: true });
   const indexSkills = [];
   const skillPaths = [];
@@ -4601,8 +4602,8 @@ function generateWellKnownStructure(outputDir, skills) {
       continue;
     }
     const skillDir = join7(wellKnownDir, safeName);
-    const resolvedSkillDir = resolve2(skillDir);
-    if (!resolvedSkillDir.startsWith(resolvedWellKnownDir + sep) && resolvedSkillDir !== resolvedWellKnownDir) {
+    const resolvedSkillDir = resolve3(skillDir);
+    if (!resolvedSkillDir.startsWith(resolvedWellKnownDir + sep2) && resolvedSkillDir !== resolvedWellKnownDir) {
       continue;
     }
     mkdirSync2(skillDir, { recursive: true });
@@ -8402,7 +8403,7 @@ var SkillExecutionEngine = class {
     const startTime = /* @__PURE__ */ new Date();
     const taskId = task.id || randomUUID7();
     try {
-      await new Promise((resolve5) => setTimeout(resolve5, 100));
+      await new Promise((resolve6) => setTimeout(resolve6, 100));
       const endTime = /* @__PURE__ */ new Date();
       return {
         taskId,
@@ -8739,7 +8740,7 @@ async function executeWithAgent(agentType, prompt, options = {}) {
   });
 }
 async function executeCommand(command, args, options = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const startTime = Date.now();
     let stdout = "";
     let stderr = "";
@@ -8762,7 +8763,7 @@ async function executeCommand(command, args, options = {}) {
     });
     child.on("error", (error) => {
       if (timeoutId) clearTimeout(timeoutId);
-      resolve5({
+      resolve6({
         success: false,
         output: stdout,
         error: error.message,
@@ -8772,7 +8773,7 @@ async function executeCommand(command, args, options = {}) {
     });
     child.on("close", (code) => {
       if (timeoutId) clearTimeout(timeoutId);
-      resolve5({
+      resolve6({
         success: code === 0 && !timedOut,
         output: stdout,
         error: timedOut ? "Execution timed out" : stderr || void 0,
@@ -8967,7 +8968,7 @@ function createSimulatedSkillExecutor(options = {}) {
   const { delay = 100, shouldFail, onExecute } = options;
   return async (skillName, _config) => {
     onExecute?.(skillName);
-    await new Promise((resolve5) => setTimeout(resolve5, delay));
+    await new Promise((resolve6) => setTimeout(resolve6, delay));
     const failed = shouldFail?.(skillName) ?? false;
     return {
       success: !failed,
@@ -9416,12 +9417,12 @@ function assertEnvVarSet(assertion, startTime) {
   };
 }
 async function checkPortAvailable(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
-    server.once("error", () => resolve5(false));
+    server.once("error", () => resolve6(false));
     server.once("listening", () => {
       server.close();
-      resolve5(true);
+      resolve6(true);
     });
     server.listen(port, "127.0.0.1");
   });
@@ -13195,7 +13196,7 @@ function createTeamManager(projectPath) {
 
 // src/team/bundle.ts
 import { existsSync as existsSync27, readFileSync as readFileSync17, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { join as join26, basename as basename9, resolve as resolve3, relative, dirname as dirname8, sep as sep2 } from "path";
+import { join as join26, basename as basename9, resolve as resolve4, relative, dirname as dirname8, sep as sep3 } from "path";
 import { createHash } from "crypto";
 var BUNDLE_VERSION = 1;
 var SkillBundle = class {
@@ -13360,7 +13361,7 @@ function importBundle(bundlePath, targetDir, options = {}) {
   try {
     const content = readFileSync17(bundlePath, "utf-8");
     const data = JSON.parse(content);
-    const absoluteTargetDir = resolve3(targetDir);
+    const absoluteTargetDir = resolve4(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}`);
@@ -13372,9 +13373,9 @@ function importBundle(bundlePath, targetDir, options = {}) {
         continue;
       }
       const skillDir = join26(absoluteTargetDir, skill.name);
-      const resolvedSkillDir = resolve3(skillDir);
+      const resolvedSkillDir = resolve4(skillDir);
       const relativeToTarget = relative(absoluteTargetDir, resolvedSkillDir);
-      if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep2)) {
+      if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep3)) {
         errors.push(`Skill "${skill.name}" would escape target directory`);
         continue;
       }
@@ -13387,9 +13388,9 @@ function importBundle(bundlePath, targetDir, options = {}) {
       }
       const files = parseSkillContent2(skillContent);
       for (const [filePath, fileContent] of Object.entries(files)) {
-        const fullPath = resolve3(skillDir, filePath);
+        const fullPath = resolve4(skillDir, filePath);
         const relativeToSkill = relative(skillDir, fullPath);
-        if (relativeToSkill.startsWith("..") || relativeToSkill.startsWith(sep2)) {
+        if (relativeToSkill.startsWith("..") || relativeToSkill.startsWith(sep3)) {
           errors.push(`Skill "${skill.name}" contains invalid file path: ${filePath}`);
           continue;
         }
@@ -17856,8 +17857,8 @@ var PlanExecutor = class {
   pause() {
     if (!this.isPaused) {
       this.isPaused = true;
-      this.resumePromise = new Promise((resolve5) => {
-        this.resumeResolve = resolve5;
+      this.resumePromise = new Promise((resolve6) => {
+        this.resumeResolve = resolve6;
       });
       this.emit("plan:paused", {});
     }
@@ -20541,7 +20542,7 @@ function loadAndConvertSkill(skill, options) {
 
 // src/skill-translator.ts
 import { readFileSync as readFileSync25, existsSync as existsSync36, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
-import { join as join37, basename as basename12, dirname as dirname12, resolve as resolve4, relative as relative3, isAbsolute as isAbsolute2 } from "path";
+import { join as join37, basename as basename12, dirname as dirname12, resolve as resolve5, relative as relative3, isAbsolute as isAbsolute2 } from "path";
 import { parse as parseYaml11, stringify as stringifyYaml8 } from "yaml";
 var AGENT_SKILL_FORMATS = Object.fromEntries(
   Object.entries(AGENT_CONFIG).map(([agent, config]) => [
@@ -20780,8 +20781,8 @@ function writeTranslatedSkill(result, rootDir, options) {
     };
   }
   try {
-    const rootPath = resolve4(rootDir);
-    const filePath = resolve4(rootDir, result.targetDir, result.filename);
+    const rootPath = resolve5(rootDir);
+    const filePath = resolve5(rootDir, result.targetDir, result.filename);
     const targetPath = dirname12(filePath);
     const relPath = relative3(rootPath, filePath);
     if (relPath.startsWith("..") || isAbsolute2(relPath)) {
@@ -21930,7 +21931,7 @@ var AGENT_INSTRUCTION_TEMPLATES = {
 
 // src/primer/analyzer.ts
 import { existsSync as existsSync39, readFileSync as readFileSync28, readdirSync as readdirSync11 } from "fs";
-import { join as join40, basename as basename14, relative as relative4, sep as sep3 } from "path";
+import { join as join40, basename as basename14, relative as relative4, sep as sep4 } from "path";
 var PACKAGE_MANAGER_FILES = {
   "package-lock.json": "npm",
   "pnpm-lock.yaml": "pnpm",
@@ -22418,7 +22419,7 @@ var PrimerAnalyzer = class {
     let files = 0;
     let directories = 0;
     for (const file of this.files) {
-      if (file.includes(sep3)) {
+      if (file.includes(sep4)) {
         directories++;
       }
       files++;
@@ -25458,7 +25459,7 @@ var ExecutionManager = class {
     this.metrics.stepMetrics.set(stepName, existing);
   }
   delay(ms) {
-    return new Promise((resolve5) => setTimeout(resolve5, ms));
+    return new Promise((resolve6) => setTimeout(resolve6, ms));
   }
 };
 function createExecutionManager(config) {
@@ -25657,6 +25658,477 @@ init_vector_store();
 init_rrf();
 init_expansion();
 init_hybrid();
+
+// src/registry/community.ts
+import { readFileSync as readFileSync34, existsSync as existsSync48 } from "fs";
+import { join as join48, dirname as dirname19 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var CommunityRegistry = class {
+  constructor(skillsMdPath) {
+    this.skillsMdPath = skillsMdPath;
+  }
+  name = "community";
+  entries = [];
+  loaded = false;
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    const paths = this.skillsMdPath ? [this.skillsMdPath] : [
+      join48(process.cwd(), "registry", "SKILLS.md"),
+      join48(dirname19(fileURLToPath2(import.meta.url)), "..", "..", "..", "..", "registry", "SKILLS.md")
+    ];
+    for (const path4 of paths) {
+      if (!existsSync48(path4)) continue;
+      try {
+        const content = readFileSync34(path4, "utf-8");
+        this.entries = this.parse(content);
+        return;
+      } catch {
+        continue;
+      }
+    }
+  }
+  parse(content) {
+    const results = [];
+    let currentCategory = "";
+    for (const line of content.split("\n")) {
+      const headerMatch = line.match(/^##\s+(.+)/);
+      if (headerMatch) {
+        currentCategory = headerMatch[1].trim();
+        continue;
+      }
+      const entryMatch = line.match(/^-\s+\[([^\]]+)\]\(([^)]+)\)\s*-\s*(.+)/);
+      if (entryMatch) {
+        results.push({
+          name: entryMatch[1].trim(),
+          url: entryMatch[2].trim(),
+          description: entryMatch[3].trim(),
+          category: currentCategory
+        });
+      }
+    }
+    return results;
+  }
+  async search(query, options) {
+    this.load();
+    const limit = options?.limit ?? 20;
+    const q = query.toLowerCase();
+    const matched = this.entries.filter(
+      (e) => e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q) || e.category.toLowerCase().includes(q)
+    );
+    return matched.slice(0, limit).map((e) => ({
+      name: e.name,
+      description: e.description,
+      source: e.url,
+      registry: this.name
+    }));
+  }
+  getAll() {
+    this.load();
+    return [...this.entries];
+  }
+  getCategories() {
+    this.load();
+    return [...new Set(this.entries.map((e) => e.category))];
+  }
+};
+
+// src/registry/index.ts
+var RateLimitError = class extends Error {
+  constructor(registry) {
+    super(`Rate limited by ${registry} API. Authenticate with a token or wait before retrying.`);
+    this.name = "RateLimitError";
+  }
+};
+var GitHubSkillRegistry = class {
+  name = "github";
+  baseUrl = "https://api.github.com";
+  async search(query, options) {
+    const limit = options?.limit ?? 20;
+    const timeoutMs = options?.timeoutMs ?? 1e4;
+    const searchQuery = `SKILL.md ${query} in:path,file`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const headers = {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "skillkit-cli"
+      };
+      const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+      const response = await fetch(
+        `${this.baseUrl}/search/code?q=${encodeURIComponent(searchQuery)}&per_page=${limit}`,
+        {
+          headers,
+          signal: controller.signal
+        }
+      );
+      clearTimeout(timer);
+      if (!response.ok) {
+        if (response.status === 403) {
+          throw new RateLimitError(this.name);
+        }
+        return [];
+      }
+      const data = await response.json();
+      if (!data.items) return [];
+      const seen = /* @__PURE__ */ new Set();
+      const skills = [];
+      for (const item of data.items) {
+        const repo = item.repository.full_name;
+        if (seen.has(repo)) continue;
+        seen.add(repo);
+        const pathParts = item.path.split("/");
+        const skillName = pathParts.length > 1 ? pathParts[pathParts.length - 2] : repo.split("/").pop() || repo;
+        skills.push({
+          name: skillName,
+          description: item.repository.description || "",
+          source: item.repository.html_url,
+          registry: this.name,
+          path: item.path,
+          stars: item.repository.stargazers_count,
+          updatedAt: item.repository.updated_at
+        });
+      }
+      return skills;
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof RateLimitError) throw err;
+      return [];
+    }
+  }
+};
+var FederatedSearch = class {
+  registries = [];
+  addRegistry(registry) {
+    this.registries.push(registry);
+  }
+  async search(query, options) {
+    const limit = options?.limit ?? 20;
+    const results = await Promise.allSettled(
+      this.registries.map((r) => r.search(query, { limit }))
+    );
+    const allSkills = [];
+    const activeRegistries = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "fulfilled" && result.value.length > 0) {
+        allSkills.push(...result.value);
+        activeRegistries.push(this.registries[i].name);
+      } else if (result.status === "rejected" && result.reason instanceof RateLimitError) {
+        throw result.reason;
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduplicated = [];
+    for (const skill of allSkills) {
+      const key = `${skill.source}:${skill.name}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduplicated.push(skill);
+      }
+    }
+    deduplicated.sort((a, b) => (b.stars ?? 0) - (a.stars ?? 0));
+    return {
+      skills: deduplicated.slice(0, limit),
+      registries: activeRegistries,
+      total: deduplicated.length,
+      query
+    };
+  }
+};
+
+// src/cache/memory.ts
+var DEFAULT_MAX_SIZE = 1e3;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var MemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  maxSize;
+  ttlMs;
+  hitCount = 0;
+  missCount = 0;
+  constructor(options) {
+    this.maxSize = options?.maxSize ?? DEFAULT_MAX_SIZE;
+    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.missCount++;
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      this.missCount++;
+      return void 0;
+    }
+    entry.lastAccessed = Date.now();
+    this.hitCount++;
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.store.size >= this.maxSize && !this.store.has(key)) {
+      this.evictLRU();
+    }
+    const now = Date.now();
+    this.store.set(key, {
+      value,
+      expiresAt: now + this.ttlMs,
+      lastAccessed: now
+    });
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  clear() {
+    this.store.clear();
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+  stats() {
+    const total = this.hitCount + this.missCount;
+    return {
+      hits: this.hitCount,
+      misses: this.missCount,
+      size: this.store.size,
+      maxSize: this.maxSize,
+      hitRate: total > 0 ? this.hitCount / total : 0
+    };
+  }
+  evictLRU() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.store) {
+      if (entry.lastAccessed < oldestTime) {
+        oldestTime = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.store.delete(oldestKey);
+    }
+  }
+};
+
+// src/ranking/relevance.ts
+var WEIGHTS = {
+  contentAvailability: 40,
+  queryMatch: 30,
+  popularity: 15,
+  references: 15
+};
+var RelevanceRanker = class {
+  rank(skills, query) {
+    const results = skills.map((skill) => {
+      const breakdown = this.score(skill, query);
+      const score = breakdown.contentAvailability + breakdown.queryMatch + breakdown.popularity + breakdown.referenceScore;
+      return { skill, score, breakdown };
+    });
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+  score(skill, query) {
+    return {
+      contentAvailability: this.scoreContent(skill),
+      queryMatch: query ? this.scoreQuery(skill, query) : 0,
+      popularity: this.scorePopularity(skill),
+      referenceScore: this.scoreReferences(skill)
+    };
+  }
+  scoreContent(skill) {
+    let score = 0;
+    if (skill.description && skill.description.length > 0) score += 20;
+    if (skill.content && skill.content.length > 0) score += 20;
+    return score;
+  }
+  scoreQuery(skill, query) {
+    const q = query.toLowerCase();
+    const name = skill.name.toLowerCase();
+    if (name === q) return WEIGHTS.queryMatch;
+    if (name.includes(q) || q.includes(name)) {
+      return WEIGHTS.queryMatch * 0.7;
+    }
+    const desc = (skill.description || "").toLowerCase();
+    const content = (skill.content || "").toLowerCase();
+    const searchable = `${name} ${desc} ${content}`;
+    const words = q.split(/\s+/).filter(Boolean);
+    const matched = words.filter((w) => searchable.includes(w)).length;
+    if (words.length === 0) return 0;
+    return Math.round(WEIGHTS.queryMatch * (matched / words.length) * 0.6);
+  }
+  scorePopularity(skill) {
+    const count = (skill.stars ?? 0) + (skill.installs ?? 0);
+    if (count <= 0) return 0;
+    return Math.min(WEIGHTS.popularity, Math.round(Math.log10(count + 1) * 5));
+  }
+  scoreReferences(skill) {
+    if (!skill.references || skill.references.length === 0) return 0;
+    return Math.min(WEIGHTS.references, skill.references.length * 5);
+  }
+};
+
+// src/parser/references.ts
+import { readdirSync as readdirSync12, statSync as statSync9, existsSync as existsSync49 } from "fs";
+import { join as join49 } from "path";
+var REFERENCE_DIRS = ["references", "resources", "docs", "examples", "assets", "scripts"];
+var DIR_TYPE_MAP = {
+  references: "resource",
+  resources: "resource",
+  docs: "doc",
+  examples: "example",
+  assets: "asset",
+  scripts: "resource"
+};
+function discoverReferences(skillDir) {
+  const refs = [];
+  for (const dir of REFERENCE_DIRS) {
+    const fullPath = join49(skillDir, dir);
+    if (!existsSync49(fullPath)) continue;
+    try {
+      const stat = statSync9(fullPath);
+      if (!stat.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const type = DIR_TYPE_MAP[dir] || "resource";
+    try {
+      const entries = readdirSync12(fullPath);
+      for (const entry of entries) {
+        const entryPath = join49(fullPath, entry);
+        try {
+          const entryStat = statSync9(entryPath);
+          if (entryStat.isFile()) {
+            refs.push({
+              path: join49(dir, entry),
+              type,
+              name: entry
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return refs;
+}
+function stripFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    const emptyMatch = raw.match(/^---\r?\n---\r?\n?([\s\S]*)$/);
+    if (emptyMatch) {
+      return { frontmatter: {}, body: emptyMatch[1] };
+    }
+    return { frontmatter: {}, body: raw };
+  }
+  const fmBlock = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  for (const line of fmBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function parseSkillMd(raw, skillDir) {
+  const { frontmatter, body } = stripFrontmatter(raw);
+  const references = skillDir ? discoverReferences(skillDir) : [];
+  return {
+    frontmatter,
+    body,
+    references,
+    raw
+  };
+}
+
+// src/runtime/injector.ts
+function parseSource2(source) {
+  const parts = source.replace(/^https?:\/\/github\.com\//, "").split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid source format: "${source}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+var SkillInjector = class {
+  cache;
+  constructor(cacheTtlMs) {
+    this.cache = new MemoryCache({
+      maxSize: 200,
+      ttlMs: cacheTtlMs ?? 24 * 60 * 60 * 1e3
+    });
+  }
+  async fetch(source, skillId) {
+    const cacheKey = `${source}:${skillId}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    const { owner, repo } = parseSource2(source);
+    const raw = await this.fetchRawSkillMd(owner, repo, skillId);
+    const parsed = parseSkillMd(raw);
+    const result = {
+      source: { owner, repo },
+      skillId,
+      parsed,
+      fetchedAt: Date.now()
+    };
+    this.cache.set(cacheKey, result);
+    return result;
+  }
+  async inject(source, skillId) {
+    const fetched = await this.fetch(source, skillId);
+    return fetched.parsed.body;
+  }
+  async fetchRawSkillMd(owner, repo, skillId) {
+    const paths = [
+      `${skillId}/SKILL.md`,
+      `skills/${skillId}/SKILL.md`,
+      `SKILL.md`
+    ];
+    const headers = {
+      Accept: "application/vnd.github.v3.raw",
+      "User-Agent": "skillkit-runtime"
+    };
+    const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    for (const path4 of paths) {
+      const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path4}`;
+      try {
+        const response = await fetch(url, { headers });
+        if (response.ok) {
+          return await response.text();
+        }
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`SKILL.md not found in ${owner}/${repo} for skill "${skillId}"`);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  cacheStats() {
+    return this.cache.stats();
+  }
+};
 export {
   AGENT_CLI_CONFIGS,
   AGENT_CONFIG,
@@ -25687,6 +26159,7 @@ export {
   CUSTOM_AGENT_FORMAT_MAP,
   CommandGenerator,
   CommandRegistry,
+  CommunityRegistry,
   ConnectorCategorySchema,
   ConnectorConfigSchema,
   ConnectorMappingSchema,
@@ -25713,9 +26186,11 @@ export {
   ExecutionManager,
   ExecutionStepSchema,
   ExecutionStepStatusSchema,
+  FederatedSearch,
   GITHUB_ACTION_TEMPLATE,
   GITLAB_CI_TEMPLATE,
   GitHubProvider,
+  GitHubSkillRegistry,
   GitLabProvider,
   GitProvider,
   HookManager,
@@ -25731,6 +26206,7 @@ export {
   MARKETPLACE_CACHE_FILE,
   MODEL_REGISTRY,
   MarketplaceAggregator,
+  MemoryCache,
   MemoryCompressor,
   MemoryEnabledEngine,
   MemoryIndexStore,
@@ -25753,10 +26229,12 @@ export {
   PrimerGenerator,
   ProjectDetector,
   QueryExpander,
+  RateLimitError,
   ReasoningEngine,
   ReasoningProviderSchema,
   ReasoningRecommendationEngine,
   RecommendationEngine,
+  RelevanceRanker,
   RuleBasedCompressor,
   SEARCH_PLANNING_PROMPT,
   SESSION_FILE,
@@ -25769,6 +26247,7 @@ export {
   SkillChunkSchema,
   SkillExecutionEngine,
   SkillFrontmatter,
+  SkillInjector,
   SkillLocation,
   SkillMdTranslator,
   SkillMetadata,
@@ -25878,6 +26357,7 @@ export {
   discoverAgentsFromPath,
   discoverAgentsRecursive,
   discoverGlobalAgents,
+  discoverReferences,
   discoverSkills,
   dryRunExecutor,
   enableGuideline,
@@ -26044,6 +26524,7 @@ export {
   parseSkill,
   parseSkillContent,
   parseSkillContentToCanonical,
+  parseSkillMd,
   parseSkillToCanonical,
   parseSource,
   parseWorkflow,
@@ -26080,6 +26561,7 @@ export {
   shellExecutor,
   skillMdTranslator,
   skillToSubagent,
+  stripFrontmatter,
   suggestMappingsFromMcp,
   supportsAutoDiscovery,
   supportsSlashCommands,