@skillkit/core 1.7.5 → 1.7.7

package/dist/index.js

@@ -17,7 +17,22 @@ var AgentType = z.enum([
   "roo",
   "trae",
   "windsurf",
-  "universal"
+  "universal",
+  "cline",
+  "codebuddy",
+  "commandcode",
+  "continue",
+  "crush",
+  "factory",
+  "mcpjam",
+  "mux",
+  "neovate",
+  "openhands",
+  "pi",
+  "qoder",
+  "qwen",
+  "vercel",
+  "zencoder"
 ]);
 var GitProvider = z.enum(["github", "gitlab", "bitbucket", "local"]);
 var SkillFrontmatter = z.object({
@@ -233,6 +248,127 @@ var AGENT_CONFIG = {
     configFormat: "xml",
     usesFrontmatter: true,
     supportsAutoDiscovery: true
+  },
+  // Cline
+  cline: {
+    skillsDir: ".cline/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Codebuddy
+  codebuddy: {
+    skillsDir: ".codebuddy/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Commandcode
+  commandcode: {
+    skillsDir: ".commandcode/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Continue
+  continue: {
+    skillsDir: ".continue/skills",
+    configFile: "AGENTS.md",
+    globalSkillsDir: "~/.continue/skills",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Crush
+  crush: {
+    skillsDir: ".crush/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Factory
+  factory: {
+    skillsDir: ".factory/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // MCPJam
+  mcpjam: {
+    skillsDir: ".mcpjam/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Mux
+  mux: {
+    skillsDir: ".mux/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Neovate
+  neovate: {
+    skillsDir: ".neovate/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // OpenHands
+  openhands: {
+    skillsDir: ".openhands/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Pi
+  pi: {
+    skillsDir: ".pi/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Qoder
+  qoder: {
+    skillsDir: ".qoder/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Qwen
+  qwen: {
+    skillsDir: ".qwen/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Vercel
+  vercel: {
+    skillsDir: ".vercel/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
+  },
+  // Zencoder
+  zencoder: {
+    skillsDir: ".zencoder/skills",
+    configFile: "AGENTS.md",
+    configFormat: "xml",
+    usesFrontmatter: true,
+    supportsAutoDiscovery: true
   }
 };
 function getAgentDirectoryConfig(agent) {
@@ -271,10 +407,20 @@ var SKILL_DISCOVERY_PATHS = [
   "skills/.curated",
   "skills/.experimental",
   "skills/.system",
+  "agents",
   ".agents/skills",
   ".agent/skills",
+  ".amp/skills",
+  ".antigravity/skills",
   ".claude/skills",
+  ".cline/skills",
+  ".clawdbot/skills",
+  ".codebuddy/skills",
   ".codex/skills",
+  ".commandcode/skills",
+  ".continue/skills",
+  ".copilot/skills",
+  ".crush/skills",
   ".cursor/skills",
   ".factory/skills",
   ".gemini/skills",
@@ -282,13 +428,19 @@ var SKILL_DISCOVERY_PATHS = [
   ".goose/skills",
   ".kilocode/skills",
   ".kiro/skills",
+  ".mcpjam/skills",
+  ".mux/skills",
+  ".neovate/skills",
   ".opencode/skills",
+  ".openhands/skills",
+  ".pi/skills",
+  ".qoder/skills",
+  ".qwen/skills",
   ".roo/skills",
   ".trae/skills",
+  ".vercel/skills",
   ".windsurf/skills",
-  ".clawdbot/skills",
-  ".antigravity/skills",
-  ".copilot/skills"
+  ".zencoder/skills"
 ];
 function discoverSkillsInDir(dir) {
   const skills = [];
@@ -297,11 +449,17 @@ function discoverSkillsInDir(dir) {
   }
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillPath = join(dir, entry.name);
-    const skillMdPath = join(skillPath, "SKILL.md");
-    if (existsSync(skillMdPath)) {
-      const skill = parseSkill(skillPath);
+    if (entry.isDirectory()) {
+      const skillPath = join(dir, entry.name);
+      const skillMdPath = join(skillPath, "SKILL.md");
+      if (existsSync(skillMdPath)) {
+        const skill = parseSkill(skillPath);
+        if (skill) {
+          skills.push(skill);
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+      const skill = parseStandaloneSkill(join(dir, entry.name));
       if (skill) {
         skills.push(skill);
       }
@@ -309,6 +467,32 @@ function discoverSkillsInDir(dir) {
   }
   return skills;
 }
+function parseStandaloneSkill(filePath, location = "project") {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const frontmatter = extractFrontmatter(content);
+    if (!frontmatter) {
+      return null;
+    }
+    const name = frontmatter.name || basename(filePath, ".md");
+    const description = frontmatter.description || "No description available";
+    if (!name || name.length === 0) {
+      return null;
+    }
+    return {
+      name,
+      description,
+      path: filePath,
+      location,
+      enabled: true
+    };
+  } catch {
+    return null;
+  }
+}
 function discoverSkillsRecursive(dir, seen, maxDepth = 5, currentDepth = 0) {
   const skills = [];
   if (currentDepth >= maxDepth || !existsSync(dir)) {
@@ -320,18 +504,25 @@ function discoverSkillsRecursive(dir, seen, maxDepth = 5, currentDepth = 0) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
       }
-      if (!entry.isDirectory()) continue;
       const entryPath = join(dir, entry.name);
-      const skillMdPath = join(entryPath, "SKILL.md");
-      if (existsSync(skillMdPath)) {
-        const skill = parseSkill(entryPath);
+      if (entry.isDirectory()) {
+        const skillMdPath = join(entryPath, "SKILL.md");
+        if (existsSync(skillMdPath)) {
+          const skill = parseSkill(entryPath);
+          if (skill && !seen.has(skill.name)) {
+            seen.add(skill.name);
+            skills.push(skill);
+          }
+        } else {
+          const subSkills = discoverSkillsRecursive(entryPath, seen, maxDepth, currentDepth + 1);
+          skills.push(...subSkills);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        const skill = parseStandaloneSkill(entryPath);
         if (skill && !seen.has(skill.name)) {
           seen.add(skill.name);
           skills.push(skill);
         }
-      } else {
-        const subSkills = discoverSkillsRecursive(entryPath, seen, maxDepth, currentDepth + 1);
-        skills.push(...subSkills);
       }
     }
   } catch {
@@ -1033,7 +1224,22 @@ var AGENT_FORMAT_MAP = {
   "universal": "skill-md",
   "cursor": "cursor-mdc",
   "windsurf": "markdown-rules",
-  "github-copilot": "markdown-rules"
+  "github-copilot": "markdown-rules",
+  "cline": "skill-md",
+  "codebuddy": "skill-md",
+  "commandcode": "skill-md",
+  "continue": "skill-md",
+  "crush": "skill-md",
+  "factory": "skill-md",
+  "mcpjam": "skill-md",
+  "mux": "skill-md",
+  "neovate": "skill-md",
+  "openhands": "skill-md",
+  "pi": "skill-md",
+  "qoder": "skill-md",
+  "qwen": "skill-md",
+  "vercel": "skill-md",
+  "zencoder": "skill-md"
 };
 var TranslatableSkillFrontmatter = z2.object({
   name: z2.string(),
@@ -15094,6 +15300,111 @@ var AGENT_FORMATS = {
     directory: "commands",
     supportsSlashCommands: true,
     supportsCommandFiles: true
+  },
+  cline: {
+    agent: "cline",
+    extension: ".md",
+    directory: ".cline/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  codebuddy: {
+    agent: "codebuddy",
+    extension: ".md",
+    directory: ".codebuddy/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  commandcode: {
+    agent: "commandcode",
+    extension: ".md",
+    directory: ".commandcode/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  continue: {
+    agent: "continue",
+    extension: ".md",
+    directory: ".continue/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  crush: {
+    agent: "crush",
+    extension: ".md",
+    directory: ".crush/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  factory: {
+    agent: "factory",
+    extension: ".md",
+    directory: ".factory/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  mcpjam: {
+    agent: "mcpjam",
+    extension: ".md",
+    directory: ".mcpjam/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  mux: {
+    agent: "mux",
+    extension: ".md",
+    directory: ".mux/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  neovate: {
+    agent: "neovate",
+    extension: ".md",
+    directory: ".neovate/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  openhands: {
+    agent: "openhands",
+    extension: ".md",
+    directory: ".openhands/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  pi: {
+    agent: "pi",
+    extension: ".md",
+    directory: ".pi/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  qoder: {
+    agent: "qoder",
+    extension: ".md",
+    directory: ".qoder/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  qwen: {
+    agent: "qwen",
+    extension: ".md",
+    directory: ".qwen/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  vercel: {
+    agent: "vercel",
+    extension: ".md",
+    directory: ".vercel/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
+  },
+  zencoder: {
+    agent: "zencoder",
+    extension: ".md",
+    directory: ".zencoder/commands",
+    supportsSlashCommands: true,
+    supportsCommandFiles: true
   }
 };
 var CommandGenerator = class {
@@ -16094,22 +16405,40 @@ var AGENT_DISCOVERY_PATHS = {
   "roo": [".roo/agents", ".roo/modes"],
   "trae": [".trae/agents", ".trae/agent"],
   "windsurf": [".windsurf/agents", ".windsurf/workflows"],
-  "universal": ["agents", ".agents"]
+  "universal": ["agents", ".agents"],
+  "cline": [".cline/agents"],
+  "codebuddy": [".codebuddy/agents"],
+  "commandcode": [".commandcode/agents"],
+  "continue": [".continue/agents"],
+  "crush": [".crush/agents"],
+  "factory": [".factory/agents"],
+  "mcpjam": [".mcpjam/agents"],
+  "mux": [".mux/agents"],
+  "neovate": [".neovate/agents"],
+  "openhands": [".openhands/agents"],
+  "pi": [".pi/agents"],
+  "qoder": [".qoder/agents"],
+  "qwen": [".qwen/agents"],
+  "vercel": [".vercel/agents"],
+  "zencoder": [".zencoder/agents"]
 };
 var ALL_AGENT_DISCOVERY_PATHS = [
   "agents",
   ".agents",
+  ".amp/agents",
+  ".antigravity/agents",
   ".claude/agents",
+  ".cline/agents",
+  ".clawdbot/agents",
+  ".codebuddy/agents",
+  ".codex/agents",
+  ".commandcode/agents",
+  ".continue/agents",
+  ".crush/agents",
   ".cursor/agents",
   ".cursor/commands",
-  ".codex/agents",
-  ".gemini/agents",
-  ".opencode/agents",
-  ".opencode/agent",
-  ".antigravity/agents",
-  ".amp/agents",
-  ".clawdbot/agents",
   ".factory/agents",
+  ".gemini/agents",
   ".github/agents",
   ".github/instructions",
   ".github/custom-agents",
@@ -16117,12 +16446,23 @@ var ALL_AGENT_DISCOVERY_PATHS = [
   ".kilocode/agents",
   ".kilocode/modes",
   ".kiro/agents",
+  ".mcpjam/agents",
+  ".mux/agents",
+  ".neovate/agents",
+  ".opencode/agents",
+  ".opencode/agent",
+  ".openhands/agents",
+  ".pi/agents",
+  ".qoder/agents",
+  ".qwen/agents",
   ".roo/agents",
   ".roo/modes",
   ".trae/agents",
   ".trae/agent",
+  ".vercel/agents",
   ".windsurf/agents",
-  ".windsurf/workflows"
+  ".windsurf/workflows",
+  ".zencoder/agents"
 ];
 var CUSTOM_AGENT_FORMAT_MAP = {
   "claude-code": "claude-agent",
@@ -16141,7 +16481,22 @@ var CUSTOM_AGENT_FORMAT_MAP = {
   "roo": "claude-agent",
   "trae": "claude-agent",
   "windsurf": "universal",
-  "universal": "universal"
+  "universal": "universal",
+  "cline": "claude-agent",
+  "codebuddy": "claude-agent",
+  "commandcode": "claude-agent",
+  "continue": "claude-agent",
+  "crush": "claude-agent",
+  "factory": "claude-agent",
+  "mcpjam": "claude-agent",
+  "mux": "claude-agent",
+  "neovate": "claude-agent",
+  "openhands": "claude-agent",
+  "pi": "claude-agent",
+  "qoder": "claude-agent",
+  "qwen": "claude-agent",
+  "vercel": "claude-agent",
+  "zencoder": "claude-agent"
 };
 
 // src/agents/parser.ts
@@ -17367,6 +17722,798 @@ function escapeXml(text) {
 }
 var getAgentSkillsDir = getSkillsDir;
 var getAgentConfigFile = getConfigFile;
+
+// src/manifest/index.ts
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync18, existsSync as existsSync33 } from "fs";
+import { join as join34, dirname as dirname12 } from "path";
+import { parse as parseYaml12, stringify as stringifyYaml9 } from "yaml";
+var MANIFEST_FILENAMES = [".skills", ".skills.yaml", ".skills.yml", "skills.yaml"];
+function findManifestPath(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== dirname12(dir)) {
+    for (const filename of MANIFEST_FILENAMES) {
+      const manifestPath = join34(dir, filename);
+      if (existsSync33(manifestPath)) {
+        return manifestPath;
+      }
+    }
+    dir = dirname12(dir);
+  }
+  return null;
+}
+function loadManifest(manifestPath) {
+  const path2 = manifestPath || findManifestPath();
+  if (!path2 || !existsSync33(path2)) {
+    return null;
+  }
+  try {
+    const content = readFileSync25(path2, "utf-8");
+    const parsed = parseYaml12(content);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return {
+      version: parsed.version || 1,
+      skills: normalizeSkills(parsed.skills || []),
+      agents: parsed.agents,
+      installMethod: parsed.installMethod,
+      updatedAt: parsed.updatedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function normalizeSkills(skills) {
+  return skills.map((skill) => {
+    if (typeof skill === "string") {
+      const parts = skill.split("/");
+      if (parts.length >= 3) {
+        return {
+          source: `${parts[0]}/${parts[1]}`,
+          skills: [parts.slice(2).join("/")],
+          enabled: true
+        };
+      }
+      return { source: skill, enabled: true };
+    }
+    if (typeof skill === "object" && skill !== null) {
+      const entry = skill;
+      return {
+        source: String(entry.source || ""),
+        skills: entry.skills,
+        agents: entry.agents,
+        enabled: entry.enabled !== false
+      };
+    }
+    return { source: "", enabled: false };
+  }).filter((s) => s.source);
+}
+function saveManifest(manifest, manifestPath) {
+  const path2 = manifestPath || join34(process.cwd(), ".skills");
+  const content = stringifyYaml9({
+    version: manifest.version || 1,
+    skills: manifest.skills.map((s) => {
+      if (!s.skills && !s.agents && s.enabled !== false) {
+        return s.source;
+      }
+      return s;
+    }),
+    ...manifest.agents && { agents: manifest.agents },
+    ...manifest.installMethod && { installMethod: manifest.installMethod },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeFileSync18(path2, content, "utf-8");
+}
+function addToManifest(source, options, manifestPath) {
+  const existing = loadManifest(manifestPath) || {
+    version: 1,
+    skills: []
+  };
+  const existingIndex = existing.skills.findIndex((s) => s.source === source);
+  if (existingIndex >= 0) {
+    existing.skills[existingIndex] = {
+      ...existing.skills[existingIndex],
+      ...options,
+      enabled: true
+    };
+  } else {
+    existing.skills.push({
+      source,
+      ...options,
+      enabled: true
+    });
+  }
+  saveManifest(existing, manifestPath);
+  return existing;
+}
+function removeFromManifest(source, manifestPath) {
+  const existing = loadManifest(manifestPath);
+  if (!existing) {
+    return null;
+  }
+  existing.skills = existing.skills.filter((s) => s.source !== source);
+  saveManifest(existing, manifestPath);
+  return existing;
+}
+function initManifest(options, manifestPath) {
+  const manifest = {
+    version: 1,
+    skills: [],
+    ...options,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveManifest(manifest, manifestPath);
+  return manifest;
+}
+function generateManifestFromInstalled(installedSkills) {
+  const skillsBySource = /* @__PURE__ */ new Map();
+  for (const skill of installedSkills) {
+    if (!skill.source) continue;
+    const existing = skillsBySource.get(skill.source);
+    if (existing) {
+      existing.skills.push(skill.name);
+      if (skill.agents) {
+        skill.agents.forEach((a) => existing.agents.add(a));
+      }
+    } else {
+      skillsBySource.set(skill.source, {
+        skills: [skill.name],
+        agents: new Set(skill.agents || [])
+      });
+    }
+  }
+  const skills = [];
+  for (const [source, data] of skillsBySource) {
+    skills.push({
+      source,
+      skills: data.skills.length > 0 ? data.skills : void 0,
+      agents: data.agents.size > 0 ? Array.from(data.agents) : void 0,
+      enabled: true
+    });
+  }
+  return {
+    version: 1,
+    skills,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/quality/index.ts
+import { readFileSync as readFileSync26, existsSync as existsSync34 } from "fs";
+import { join as join35, basename as basename12 } from "path";
+
+// src/quality/benchmark.ts
+var CATEGORY_BENCHMARKS = {
+  react: {
+    category: "react",
+    avgScore: 78,
+    topScore: 95,
+    topSkills: ["react-patterns", "react-hooks-best-practices"],
+    count: 150,
+    distribution: { A: 15, B: 35, C: 30, D: 15, F: 5 }
+  },
+  typescript: {
+    category: "typescript",
+    avgScore: 75,
+    topScore: 92,
+    topSkills: ["typescript-strict", "type-safety-patterns"],
+    count: 120,
+    distribution: { A: 12, B: 30, C: 35, D: 18, F: 5 }
+  },
+  testing: {
+    category: "testing",
+    avgScore: 72,
+    topScore: 90,
+    topSkills: ["tdd-workflow", "testing-best-practices"],
+    count: 80,
+    distribution: { A: 10, B: 28, C: 38, D: 19, F: 5 }
+  },
+  git: {
+    category: "git",
+    avgScore: 80,
+    topScore: 94,
+    topSkills: ["git-workflow", "conventional-commits"],
+    count: 60,
+    distribution: { A: 18, B: 40, C: 28, D: 12, F: 2 }
+  },
+  security: {
+    category: "security",
+    avgScore: 76,
+    topScore: 93,
+    topSkills: ["security-review", "owasp-patterns"],
+    count: 45,
+    distribution: { A: 14, B: 32, C: 34, D: 16, F: 4 }
+  },
+  api: {
+    category: "api",
+    avgScore: 74,
+    topScore: 91,
+    topSkills: ["api-design", "rest-best-practices"],
+    count: 55,
+    distribution: { A: 11, B: 30, C: 36, D: 18, F: 5 }
+  },
+  general: {
+    category: "general",
+    avgScore: 70,
+    topScore: 88,
+    topSkills: ["code-review", "best-practices"],
+    count: 200,
+    distribution: { A: 8, B: 25, C: 40, D: 22, F: 5 }
+  }
+};
+function getGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function detectCategory(skillName, tags = []) {
+  const lowerName = skillName.toLowerCase();
+  const lowerTags = tags.map((t) => t.toLowerCase());
+  const searchTerms = [lowerName, ...lowerTags];
+  const categoryKeywords = {
+    react: ["react", "hooks", "jsx", "tsx", "component", "nextjs", "remix"],
+    typescript: ["typescript", "type", "types", "ts", "strict"],
+    testing: ["test", "testing", "tdd", "jest", "vitest", "playwright", "e2e"],
+    git: ["git", "commit", "branch", "merge", "workflow", "conventional"],
+    security: ["security", "auth", "owasp", "vulnerability", "safe"],
+    api: ["api", "rest", "graphql", "endpoint", "http"]
+  };
+  for (const [category, keywords] of Object.entries(categoryKeywords)) {
+    for (const term of searchTerms) {
+      if (keywords.some((kw) => term.includes(kw))) {
+        return category;
+      }
+    }
+  }
+  return "general";
+}
+function calculatePercentile(score, categoryStats) {
+  const { distribution } = categoryStats;
+  const totalSkills = distribution.A + distribution.B + distribution.C + distribution.D + distribution.F;
+  let percentBelow = 0;
+  if (score < 60) {
+    percentBelow = score / 60 * (distribution.F / totalSkills) * 100;
+  } else if (score < 70) {
+    percentBelow = distribution.F / totalSkills * 100;
+    percentBelow += (score - 60) / 10 * (distribution.D / totalSkills) * 100;
+  } else if (score < 80) {
+    percentBelow = (distribution.F + distribution.D) / totalSkills * 100;
+    percentBelow += (score - 70) / 10 * (distribution.C / totalSkills) * 100;
+  } else if (score < 90) {
+    percentBelow = (distribution.F + distribution.D + distribution.C) / totalSkills * 100;
+    percentBelow += (score - 80) / 10 * (distribution.B / totalSkills) * 100;
+  } else {
+    percentBelow = (distribution.F + distribution.D + distribution.C + distribution.B) / totalSkills * 100;
+    percentBelow += (score - 90) / 10 * (distribution.A / totalSkills) * 100;
+  }
+  return Math.round(Math.min(99, Math.max(1, percentBelow)));
+}
+function generateComparisonNotes(quality, categoryStats) {
+  const notes = [];
+  const topScore = categoryStats.topScore;
+  const avgScore = categoryStats.avgScore;
+  if (quality.overall >= topScore) {
+    notes.push("Your skill is among the top performers in this category");
+  } else if (quality.overall >= avgScore) {
+    notes.push(`Your skill is above the category average (${avgScore})`);
+  } else {
+    notes.push(`Your skill is ${avgScore - quality.overall} points below the category average`);
+  }
+  if (!quality.structure.hasExamples) {
+    notes.push("Missing code examples (present in 95% of top skills)");
+  }
+  if (!quality.structure.hasTriggers) {
+    notes.push("Missing trigger conditions (present in 80% of top skills)");
+  }
+  if (!quality.structure.hasBoundaries) {
+    notes.push('Missing "When Not to Use" section (present in 80% of top skills)');
+  }
+  if (quality.specificity.vagueTermCount > 3) {
+    notes.push("Trigger conditions are less specific than category average");
+  }
+  if (quality.clarity.lineCount > 300) {
+    notes.push("Skill is longer than recommended (top skills average 150-250 lines)");
+  }
+  if (quality.advanced.deprecatedPatterns.length > 0) {
+    notes.push("Contains deprecated patterns not found in top skills");
+  }
+  return notes;
+}
+function generateRecommendations(quality, categoryStats) {
+  const recommendations = [];
+  const gap = categoryStats.topScore - quality.overall;
+  if (gap > 20) {
+    recommendations.push("Consider studying top skills in this category for patterns");
+  }
+  if (!quality.structure.hasExamples) {
+    recommendations.push(`Add ${quality.specificity.hasCodeExamples ? "more" : ""} code examples showing input/output`);
+  }
+  if (!quality.structure.hasTriggers) {
+    recommendations.push('Add explicit trigger conditions with patterns like "Triggers when:"');
+  }
+  if (!quality.structure.hasBoundaries) {
+    recommendations.push('Add a "Boundaries" or "Limitations" section');
+  }
+  if (quality.clarity.lineCount > 400) {
+    recommendations.push("Split into multiple focused skills (top skills are 150-250 lines)");
+  }
+  if (quality.specificity.vagueTermCount > 0) {
+    recommendations.push(`Replace ${quality.specificity.vagueTermCount} vague term(s) with specific instructions`);
+  }
+  if (quality.advanced.completeness.hasTodos) {
+    recommendations.push("Complete TODO items before publishing");
+  }
+  return recommendations;
+}
+function benchmarkSkill(skillName, quality, tags = [], customCategoryStats) {
+  const category = detectCategory(skillName, tags);
+  const categoryStats = customCategoryStats || CATEGORY_BENCHMARKS[category] || CATEGORY_BENCHMARKS.general;
+  const percentile = calculatePercentile(quality.overall, categoryStats);
+  const comparisonNotes = generateComparisonNotes(quality, categoryStats);
+  const recommendations = generateRecommendations(quality, categoryStats);
+  return {
+    skill: skillName,
+    score: quality.overall,
+    grade: getGrade(quality.overall),
+    categoryAvg: categoryStats.avgScore,
+    topSkillScore: categoryStats.topScore,
+    percentile,
+    comparisonNotes,
+    recommendations
+  };
+}
+function getCategoryStats(category) {
+  return CATEGORY_BENCHMARKS[category] || null;
+}
+function getAllCategories() {
+  return Object.keys(CATEGORY_BENCHMARKS);
+}
+
+// src/quality/index.ts
+var VAGUE_TERMS = [
+  "be helpful",
+  "assist the user",
+  "help with",
+  "try to",
+  "attempt to",
+  "do your best",
+  "as needed",
+  "when appropriate",
+  "if necessary",
+  "general purpose",
+  "various tasks",
+  "many things",
+  "etc.",
+  "and so on",
+  "stuff like that"
+];
+var BOUNDARY_PATTERNS = [
+  /never\s+(?:do|use|commit|push|delete|remove)/i,
+  /always\s+(?:do|use|check|verify|ensure)/i,
+  /don'?t\s+(?:do|use|commit|push|delete)/i,
+  /avoid\s+(?:using|doing|committing)/i,
+  /must\s+(?:not|always|never)/i,
+  /forbidden/i,
+  /prohibited/i,
+  /required/i
+];
+var TRIGGER_PATTERNS = [
+  /when\s+to\s+use/i,
+  /use\s+this\s+(?:skill|when)/i,
+  /triggers?\s*(?:when|:)/i,
+  /activated?\s+(?:when|by)/i,
+  /applies?\s+(?:when|to)/i,
+  /invoke\s+(?:when|this)/i
+];
+var COMMAND_PATTERNS = [
+  /```(?:bash|sh|shell|zsh)[\s\S]*?```/g,
+  /`(?:npm|pnpm|yarn|bun|npx|git|docker|kubectl)\s+[^`]+`/g,
+  /\$\s*\w+/g
+];
+var CODE_EXAMPLE_PATTERNS = [
+  /```(?:typescript|javascript|tsx|jsx|python|go|rust|java)[\s\S]*?```/g,
+  /```[\s\S]{50,}?```/g
+];
+var FILE_PATTERN_PATTERNS = [
+  /\*\*\/\*\.\w+/,
+  /\.\w+$/m,
+  /glob[s]?\s*[:=]/i,
+  /include[s]?\s*[:=]/i,
+  /pattern[s]?\s*[:=]/i
+];
+var DEPRECATED_PATTERNS = [
+  { pattern: /require\s*\(['"][^'"]+['"]\)/g, message: "Uses CommonJS require() instead of ES modules" },
+  { pattern: /React\.Component/g, message: "Uses class components instead of functional" },
+  { pattern: /componentDidMount|componentWillUnmount|componentDidUpdate/g, message: "Uses lifecycle methods instead of hooks" },
+  { pattern: /\bvar\s+\w+\s*=/g, message: "Uses var instead of const/let" },
+  { pattern: /\.then\s*\([^)]*\)\.catch/g, message: "Uses .then().catch() instead of async/await" },
+  { pattern: /new\s+Promise\s*\(/g, message: "Consider using async/await instead of new Promise()" }
+];
+var SECURITY_PATTERNS = [
+  { pattern: /password\s*[:=]\s*['"][^'"]+['"]/gi, message: "Potential hardcoded password" },
+  { pattern: /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi, message: "Potential hardcoded API key" },
+  { pattern: /secret\s*[:=]\s*['"][^'"]+['"]/gi, message: "Potential hardcoded secret" },
+  { pattern: /token\s*[:=]\s*['"][A-Za-z0-9_-]{20,}['"]/gi, message: "Potential hardcoded token" },
+  { pattern: /\$\{[^}]*\}/g, message: "Template literal - ensure proper sanitization in shell commands" },
+  { pattern: /eval\s*\(/g, message: "Uses eval() - potential code injection risk" },
+  { pattern: /innerHTML\s*=/g, message: "Uses innerHTML - potential XSS risk" },
+  { pattern: /dangerouslySetInnerHTML/g, message: "Uses dangerouslySetInnerHTML - potential XSS risk" }
+];
+function extractFrontmatter4(content) {
+  const normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const match = normalizedContent.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const frontmatter = {};
+  const lines = match[1].split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return Object.keys(frontmatter).length > 0 ? frontmatter : null;
+}
+function countTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function countVagueTerms(content) {
+  const lowerContent = content.toLowerCase();
+  let count = 0;
+  for (const term of VAGUE_TERMS) {
+    const regex = new RegExp(term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+    const matches = lowerContent.match(regex);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function hasPattern(content, patterns) {
+  return patterns.some((p) => p.test(content));
+}
+function countMatches(content, patterns) {
+  let count = 0;
+  for (const pattern of patterns) {
+    const matches = content.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function calculateAvgSentenceLength(content) {
+  const contentWithoutCode = content.replace(/```[\s\S]*?```/g, "");
+  const sentences = contentWithoutCode.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  if (sentences.length === 0) return 0;
+  const totalWords = sentences.reduce((sum, s) => sum + s.trim().split(/\s+/).length, 0);
+  return Math.round(totalWords / sentences.length);
+}
+function evaluateStructure(content) {
+  const frontmatter = extractFrontmatter4(content);
+  const hasMetadata = frontmatter !== null && Object.keys(frontmatter).length > 0;
+  const hasDescription = !!frontmatter?.description || /^#+\s*description/im.test(content);
+  const hasTriggers = hasPattern(content, TRIGGER_PATTERNS);
+  const hasExamples = countMatches(content, CODE_EXAMPLE_PATTERNS) > 0;
+  const hasBoundaries = hasPattern(content, BOUNDARY_PATTERNS);
+  const hasWhenToUse = /when\s+to\s+use|use\s+case|scenario/i.test(content);
+  let score = 0;
+  if (hasMetadata) score += 15;
+  if (hasDescription) score += 10;
+  if (hasTriggers) score += 20;
+  if (hasExamples) score += 20;
+  if (hasBoundaries) score += 20;
+  if (hasWhenToUse) score += 15;
+  return {
+    score: Math.min(100, score),
+    hasMetadata,
+    hasDescription,
+    hasTriggers,
+    hasExamples,
+    hasBoundaries,
+    hasWhenToUse
+  };
+}
+function evaluateClarity(content) {
+  const lines = content.split("\n");
+  const lineCount = lines.length;
+  const tokenCount = countTokens(content);
+  const avgSentenceLength = calculateAvgSentenceLength(content);
+  const hasHeaders = /^#+\s+/m.test(content);
+  let score = 100;
+  if (lineCount > 500) score -= 30;
+  else if (lineCount > 300) score -= 15;
+  else if (lineCount > 150) score -= 5;
+  if (tokenCount > 4e3) score -= 30;
+  else if (tokenCount > 2e3) score -= 15;
+  else if (tokenCount > 1e3) score -= 5;
+  if (avgSentenceLength > 30) score -= 20;
+  else if (avgSentenceLength > 20) score -= 10;
+  if (!hasHeaders) score -= 15;
+  return {
+    score: Math.max(0, score),
+    lineCount,
+    tokenCount,
+    avgSentenceLength,
+    hasHeaders
+  };
+}
+function countCodeBlocks(content) {
+  const fencedBlocks = content.match(/```[\s\S]*?```/g) || [];
+  return fencedBlocks.length;
+}
+function detectDeprecatedPatterns(content) {
+  const codeBlocks = content.match(/```[\s\S]*?```/g) || [];
+  const codeContent = codeBlocks.join("\n");
+  const issues = [];
+  for (const { pattern, message } of DEPRECATED_PATTERNS) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    if (regex.test(codeContent)) {
+      issues.push(message);
+    }
+  }
+  return [...new Set(issues)];
+}
+function detectSecurityPatterns(content) {
+  const issues = [];
+  for (const { pattern, message } of SECURITY_PATTERNS) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    if (regex.test(content)) {
+      if (!message.includes("Template literal") || content.includes("bash") || content.includes("shell")) {
+        issues.push(message);
+      }
+    }
+  }
+  return [...new Set(issues)];
+}
+function detectConflictingInstructions(content) {
+  const issues = [];
+  const lowerContent = content.toLowerCase();
+  const alwaysMatches = lowerContent.match(/always\s+(?:use|do|include|add)\s+(\w+)/gi) || [];
+  const neverMatches = lowerContent.match(/never\s+(?:use|do|include|add)\s+(\w+)/gi) || [];
+  for (const always of alwaysMatches) {
+    const term = always.replace(/always\s+(?:use|do|include|add)\s+/i, "").toLowerCase();
+    for (const never of neverMatches) {
+      const neverTerm = never.replace(/never\s+(?:use|do|include|add)\s+/i, "").toLowerCase();
+      if (term === neverTerm) {
+        issues.push(`Conflicting instructions: "always" and "never" used with "${term}"`);
+      }
+    }
+  }
+  const mustMatches = lowerContent.match(/must\s+(\w+)/gi) || [];
+  const mustNotMatches = lowerContent.match(/must\s+not\s+(\w+)/gi) || [];
+  for (const must of mustMatches) {
+    const term = must.replace(/must\s+/i, "").toLowerCase();
+    for (const mustNot of mustNotMatches) {
+      const notTerm = mustNot.replace(/must\s+not\s+/i, "").toLowerCase();
+      if (term === notTerm) {
+        issues.push(`Conflicting instructions: "must" and "must not" used with "${term}"`);
+      }
+    }
+  }
+  return [...new Set(issues)];
+}
+function assessCompleteness(content) {
+  const todoMatches = content.match(/TODO|FIXME|XXX|HACK/gi) || [];
+  const todoCount = todoMatches.length;
+  const headerPositions = [];
+  const lines = content.split("\n");
+  let inFence = false;
+  let offset = 0;
+  for (const line of lines) {
+    if (/^```|^~~~/.test(line)) {
+      inFence = !inFence;
+    } else if (!inFence && /^#+\s+.+$/.test(line)) {
+      headerPositions.push({ header: line, index: offset });
+    }
+    offset += line.length + 1;
+  }
+  const emptySections = [];
+  for (let i = 0; i < headerPositions.length - 1; i++) {
+    const current = headerPositions[i];
+    const next = headerPositions[i + 1];
+    const sectionContent = content.slice(current.index + current.header.length, next.index).trim();
+    if (sectionContent.length < 20) {
+      const sectionName = current.header.replace(/^#+\s+/, "");
+      emptySections.push(sectionName);
+    }
+  }
+  if (headerPositions.length > 0) {
+    const last = headerPositions[headerPositions.length - 1];
+    const tailContent = content.slice(last.index + last.header.length).trim();
+    if (tailContent.length < 20) {
+      const sectionName = last.header.replace(/^#+\s+/, "");
+      emptySections.push(sectionName);
+    }
+  }
+  const codeBlocks = countCodeBlocks(content);
+  const exampleCoverage = Math.min(100, codeBlocks * 25);
+  let score = 100;
+  if (todoCount > 0) score -= Math.min(30, todoCount * 10);
+  if (emptySections.length > 0) score -= Math.min(30, emptySections.length * 10);
+  if (codeBlocks < 2) score -= 20;
+  else if (codeBlocks < 4) score -= 10;
+  return {
+    score: Math.max(0, score),
+    hasTodos: todoCount > 0,
+    todoCount,
+    emptySections,
+    exampleCoverage
+  };
+}
+function evaluateAdvanced(content) {
+  const deprecatedPatterns = detectDeprecatedPatterns(content);
+  const conflictingInstructions = detectConflictingInstructions(content);
+  const securityIssues = detectSecurityPatterns(content);
+  const completeness = assessCompleteness(content);
+  let score = 100;
+  score -= Math.min(30, deprecatedPatterns.length * 10);
+  score -= Math.min(30, conflictingInstructions.length * 15);
+  score -= Math.min(25, securityIssues.length * 10);
+  score -= Math.round((100 - completeness.score) * 0.15);
+  return {
+    score: Math.max(0, score),
+    deprecatedPatterns,
+    conflictingInstructions,
+    securityIssues,
+    completeness
+  };
+}
+function evaluateSpecificity(content) {
+  const hasConcreteCommands = countMatches(content, COMMAND_PATTERNS) > 0;
+  const hasFilePatterns = hasPattern(content, FILE_PATTERN_PATTERNS);
+  const codeBlockCount = countCodeBlocks(content);
+  const hasCodeExamples = codeBlockCount >= 2;
+  const vagueTermCount = countVagueTerms(content);
+  let score = 0;
+  if (hasConcreteCommands) score += 30;
+  if (hasFilePatterns) score += 25;
+  if (hasCodeExamples) score += 30;
+  if (vagueTermCount === 0) score += 15;
+  else if (vagueTermCount <= 2) score += 10;
+  else if (vagueTermCount <= 5) score += 5;
+  return {
+    score: Math.min(100, score),
+    hasConcreteCommands,
+    hasFilePatterns,
+    hasCodeExamples,
+    vagueTermCount
+  };
+}
+function generateWarnings(structure, clarity, specificity, advanced) {
+  const warnings = [];
+  if (!structure.hasMetadata) {
+    warnings.push("Missing frontmatter metadata");
+  }
+  if (!structure.hasTriggers) {
+    warnings.push("No trigger conditions defined");
+  }
+  if (!structure.hasBoundaries) {
+    warnings.push("No boundaries or constraints specified");
+  }
+  if (clarity.lineCount > 500) {
+    warnings.push(`Skill is too long (${clarity.lineCount} lines)`);
+  }
+  if (clarity.tokenCount > 4e3) {
+    warnings.push(`High token usage (${clarity.tokenCount} tokens)`);
+  }
+  if (specificity.vagueTermCount > 5) {
+    warnings.push(`Contains ${specificity.vagueTermCount} vague terms`);
+  }
+  if (!structure.hasExamples) {
+    warnings.push("No code examples provided");
+  } else if (!specificity.hasCodeExamples) {
+    warnings.push("Only one code example provided");
+  }
+  for (const issue of advanced.securityIssues) {
+    warnings.push(`Security: ${issue}`);
+  }
+  for (const conflict of advanced.conflictingInstructions) {
+    warnings.push(conflict);
+  }
+  if (advanced.completeness.hasTodos) {
+    warnings.push(`Contains ${advanced.completeness.todoCount} TODO/FIXME comment(s)`);
+  }
+  if (advanced.completeness.emptySections.length > 0) {
+    warnings.push(`Empty sections: ${advanced.completeness.emptySections.join(", ")}`);
+  }
+  return warnings;
+}
+function generateSuggestions(structure, clarity, specificity, advanced) {
+  const suggestions = [];
+  if (!structure.hasMetadata) {
+    suggestions.push("Add YAML frontmatter with name, description, and globs");
+  }
+  if (!structure.hasTriggers) {
+    suggestions.push('Add a "When to Use" section with specific trigger conditions');
+  }
+  if (!structure.hasExamples) {
+    suggestions.push("Include code examples showing expected output");
+  }
+  if (!structure.hasBoundaries) {
+    suggestions.push("Define boundaries: what the agent should never do");
+  }
+  if (clarity.lineCount > 300) {
+    suggestions.push("Consider splitting into multiple focused skills");
+  }
+  if (!clarity.hasHeaders) {
+    suggestions.push("Use markdown headers to organize content");
+  }
+  if (specificity.vagueTermCount > 0) {
+    suggestions.push("Replace vague terms with specific instructions");
+  }
+  if (!specificity.hasConcreteCommands) {
+    suggestions.push("Add concrete executable commands with flags");
+  }
+  if (advanced.deprecatedPatterns.length > 0) {
+    suggestions.push("Update code examples to use modern patterns (ES modules, hooks, async/await)");
+  }
+  if (advanced.securityIssues.length > 0) {
+    suggestions.push("Review and remove potential security risks from examples");
+  }
+  if (advanced.completeness.hasTodos) {
+    suggestions.push("Complete or remove TODO/FIXME comments");
+  }
+  if (advanced.completeness.emptySections.length > 0) {
+    suggestions.push("Add content to empty sections or remove them");
+  }
+  if (advanced.completeness.exampleCoverage < 50) {
+    suggestions.push("Add more code examples to improve coverage");
+  }
+  return suggestions;
+}
+function evaluateSkillContent(content) {
+  const structure = evaluateStructure(content);
+  const clarity = evaluateClarity(content);
+  const specificity = evaluateSpecificity(content);
+  const advanced = evaluateAdvanced(content);
+  const overall = Math.round(
+    structure.score * 0.35 + clarity.score * 0.25 + specificity.score * 0.25 + advanced.score * 0.15
+  );
+  const warnings = generateWarnings(structure, clarity, specificity, advanced);
+  const suggestions = generateSuggestions(structure, clarity, specificity, advanced);
+  return {
+    overall,
+    structure,
+    clarity,
+    specificity,
+    advanced,
+    warnings,
+    suggestions
+  };
+}
+function evaluateSkillFile(filePath) {
+  if (!existsSync34(filePath)) return null;
+  try {
+    const content = readFileSync26(filePath, "utf-8");
+    return evaluateSkillContent(content);
+  } catch {
+    return null;
+  }
+}
+function evaluateSkillDirectory(dirPath) {
+  const skillMdPath = join35(dirPath, "SKILL.md");
+  if (existsSync34(skillMdPath)) {
+    return evaluateSkillFile(skillMdPath);
+  }
+  const mdcFiles = ["index.mdc", `${basename12(dirPath)}.mdc`];
+  for (const file of mdcFiles) {
+    const mdcPath = join35(dirPath, file);
+    if (existsSync34(mdcPath)) {
+      return evaluateSkillFile(mdcPath);
+    }
+  }
+  return null;
+}
+function getQualityGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function isHighQuality(score) {
+  return score.overall >= 80 && score.warnings.length <= 2;
+}
 export {
   AGENT_CLI_CONFIGS,
   AGENT_CONFIG,
@@ -17462,9 +18609,12 @@ export {
   WORKFLOW_EXTENSION,
   WindsurfTranslator,
   WorkflowOrchestrator,
+  addToManifest,
   agentExists,
   analyzeProject,
+  benchmarkSkill,
   buildSkillIndex,
+  calculatePercentile,
   canTranslate,
   copilotTranslator,
   createAPIBasedCompressor,
@@ -17502,6 +18652,7 @@ export {
   createWorkflowOrchestrator,
   createWorkflowTemplate,
   cursorTranslator,
+  detectCategory,
   detectProvider,
   detectSkillFormat,
   discoverAgents,
@@ -17512,6 +18663,9 @@ export {
   discoverSkills,
   dryRunExecutor,
   estimateTokens,
+  evaluateSkillContent,
+  evaluateSkillDirectory,
+  evaluateSkillFile,
   executeWithAgent,
   exportBundle,
   extractAgentContent,
@@ -17523,9 +18677,13 @@ export {
   findAgent,
   findAllAgents,
   findAllSkills,
+  findManifestPath,
   findSkill,
   formatSkillAsPrompt,
   fromCanonicalAgent,
+  generateComparisonNotes,
+  generateManifestFromInstalled,
+  generateRecommendations,
   generateSkillsConfig,
   getAgentCLIConfig,
   getAgentConfigFile,
@@ -17537,16 +18695,19 @@ export {
   getAgentStats,
   getAgentTargetDirectory,
   getAgentsDirectory,
+  getAllCategories,
   getAllProviders,
   getAllSkillsDirs,
   getAvailableCLIAgents,
   getBuiltinPacksDir,
   getCICDTemplate,
+  getCategoryStats,
   getConfigFile,
   getConfigFormat,
   getExecutionStrategy,
   getGlobalConfigPath,
   getGlobalSkillsDir,
+  getGrade,
   getIndexStatus,
   getInstallDir,
   getManualExecutionInstructions,
@@ -17554,6 +18715,7 @@ export {
   getMemoryStatus,
   getProjectConfigPath,
   getProvider,
+  getQualityGrade,
   getSearchDirs,
   getSkillsDir,
   getStackTags,
@@ -17562,11 +18724,13 @@ export {
   globalMemoryDirectoryExists,
   importBundle,
   initContext,
+  initManifest,
   initProject,
   initializeMemoryDirectory,
   isAgentCLIAvailable,
   isAgentCompatible,
   isGitUrl,
+  isHighQuality,
   isIndexStale,
   isLocalPath,
   isPathInside,
@@ -17576,6 +18740,7 @@ export {
   loadConfig,
   loadContext,
   loadIndex,
+  loadManifest,
   loadMetadata,
   loadPlugin,
   loadPluginsFromDirectory,
@@ -17594,9 +18759,11 @@ export {
   parseWorkflow,
   readAgentContent,
   readSkillContent,
+  removeFromManifest,
   runTestSuite,
   saveConfig,
   saveIndex,
+  saveManifest,
   saveSkillMetadata,
   saveWorkflow,
   serializeWorkflow,