@cleocode/caamp 1.0.5 → 1.1.1

package/dist/{chunk-HUMRYJPE.js → chunk-7YV3KXEJ.js}

@@ -100,6 +100,36 @@ async function injectAll(providers, projectDir, scope, content) {
 }
 
 // src/core/instructions/templates.ts
+function buildInjectionContent(template) {
+  const lines = [];
+  for (const ref of template.references) {
+    lines.push(ref);
+  }
+  if (template.content && template.content.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(...template.content);
+  }
+  return lines.join("\n");
+}
+function parseInjectionContent(content) {
+  const references = [];
+  const contentLines = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("@")) {
+      references.push(trimmed);
+    } else {
+      contentLines.push(line);
+    }
+  }
+  return {
+    references,
+    content: contentLines.length > 0 ? contentLines : void 0
+  };
+}
 function generateInjectionContent(options) {
   const lines = [];
   lines.push("## CAAMP Managed Configuration");
@@ -117,6 +147,16 @@ function generateInjectionContent(options) {
   }
   return lines.join("\n");
 }
+function generateSkillsSection(skillNames) {
+  if (skillNames.length === 0) return "";
+  const lines = [];
+  lines.push("### Installed Skills");
+  lines.push("");
+  for (const name of skillNames) {
+    lines.push(`- \`${name}\` - Available via SKILL.md`);
+  }
+  return lines.join("\n");
+}
 function groupByInstructFile(providers) {
   const groups = /* @__PURE__ */ new Map();
   for (const provider of providers) {
@@ -155,8 +195,8 @@ function getNestedValue(obj, keyPath) {
 }
 async function ensureDir(filePath) {
   const { mkdir: mkdir5 } = await import("fs/promises");
-  const { dirname: dirname5 } = await import("path");
-  await mkdir5(dirname5(filePath), { recursive: true });
+  const { dirname: dirname6 } = await import("path");
+  await mkdir5(dirname6(filePath), { recursive: true });
 }
 
 // src/core/logger.ts
@@ -2063,9 +2103,250 @@ var MarketplaceClient = class {
   }
 };
 
+// src/core/skills/library-loader.ts
+import { createRequire } from "module";
+import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname5, join as join6 } from "path";
+var require2 = createRequire(import.meta.url);
+function loadLibraryFromModule(root) {
+  let mod;
+  try {
+    mod = require2(root);
+  } catch {
+    throw new Error(`Failed to load skill library module from ${root}`);
+  }
+  const requiredMethods = [
+    "listSkills",
+    "getSkill",
+    "getSkillPath",
+    "getSkillDir",
+    "readSkillContent",
+    "getCoreSkills",
+    "getSkillsByCategory",
+    "getSkillDependencies",
+    "resolveDependencyTree",
+    "listProfiles",
+    "getProfile",
+    "resolveProfile",
+    "listSharedResources",
+    "getSharedResourcePath",
+    "readSharedResource",
+    "listProtocols",
+    "getProtocolPath",
+    "readProtocol",
+    "validateSkillFrontmatter",
+    "validateAll",
+    "getDispatchMatrix"
+  ];
+  for (const method of requiredMethods) {
+    if (typeof mod[method] !== "function") {
+      throw new Error(
+        `Skill library at ${root} does not implement required method: ${method}`
+      );
+    }
+  }
+  if (!mod.version || typeof mod.version !== "string") {
+    throw new Error(`Skill library at ${root} is missing 'version' property`);
+  }
+  if (!mod.libraryRoot || typeof mod.libraryRoot !== "string") {
+    throw new Error(`Skill library at ${root} is missing 'libraryRoot' property`);
+  }
+  return mod;
+}
+function buildLibraryFromFiles(root) {
+  const catalogPath = join6(root, "skills.json");
+  if (!existsSync11(catalogPath)) {
+    throw new Error(`No skills.json found at ${root}`);
+  }
+  const catalogData = JSON.parse(readFileSync2(catalogPath, "utf-8"));
+  const entries = catalogData.skills ?? [];
+  const version = catalogData.version ?? "0.0.0";
+  const manifestPath = join6(root, "skills", "manifest.json");
+  let manifest;
+  if (existsSync11(manifestPath)) {
+    manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  } else {
+    manifest = {
+      $schema: "",
+      _meta: {},
+      dispatch_matrix: { by_task_type: {}, by_keyword: {}, by_protocol: {} },
+      skills: []
+    };
+  }
+  const profilesDir = join6(root, "profiles");
+  const profiles = /* @__PURE__ */ new Map();
+  if (existsSync11(profilesDir)) {
+    for (const file of readdirSync(profilesDir)) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const profile = JSON.parse(
+          readFileSync2(join6(profilesDir, file), "utf-8")
+        );
+        profiles.set(profile.name, profile);
+      } catch {
+      }
+    }
+  }
+  const skillMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    skillMap.set(entry.name, entry);
+  }
+  function getSkillDir2(name) {
+    const entry = skillMap.get(name);
+    if (entry) {
+      return dirname5(join6(root, entry.path));
+    }
+    return join6(root, "skills", name);
+  }
+  function resolveDeps(names, visited = /* @__PURE__ */ new Set()) {
+    const result = [];
+    for (const name of names) {
+      if (visited.has(name)) continue;
+      visited.add(name);
+      const entry = skillMap.get(name);
+      if (entry && entry.dependencies.length > 0) {
+        result.push(...resolveDeps(entry.dependencies, visited));
+      }
+      result.push(name);
+    }
+    return result;
+  }
+  function resolveProfileByName(name, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(name)) return [];
+    visited.add(name);
+    const profile = profiles.get(name);
+    if (!profile) return [];
+    let skills = [];
+    if (profile.extends) {
+      skills = resolveProfileByName(profile.extends, visited);
+    }
+    skills.push(...profile.skills);
+    return resolveDeps([...new Set(skills)]);
+  }
+  function discoverFiles(dir, ext) {
+    if (!existsSync11(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => basename2(f, ext));
+  }
+  const library = {
+    version,
+    libraryRoot: root,
+    skills: entries,
+    manifest,
+    listSkills() {
+      return entries.map((e) => e.name);
+    },
+    getSkill(name) {
+      return skillMap.get(name);
+    },
+    getSkillPath(name) {
+      const entry = skillMap.get(name);
+      if (entry) {
+        return join6(root, entry.path);
+      }
+      return join6(root, "skills", name, "SKILL.md");
+    },
+    getSkillDir: getSkillDir2,
+    readSkillContent(name) {
+      const skillPath = library.getSkillPath(name);
+      if (!existsSync11(skillPath)) {
+        throw new Error(`Skill content not found: ${skillPath}`);
+      }
+      return readFileSync2(skillPath, "utf-8");
+    },
+    getCoreSkills() {
+      return entries.filter((e) => e.core);
+    },
+    getSkillsByCategory(category) {
+      return entries.filter((e) => e.category === category);
+    },
+    getSkillDependencies(name) {
+      return skillMap.get(name)?.dependencies ?? [];
+    },
+    resolveDependencyTree(names) {
+      return resolveDeps(names);
+    },
+    listProfiles() {
+      return [...profiles.keys()];
+    },
+    getProfile(name) {
+      return profiles.get(name);
+    },
+    resolveProfile(name) {
+      return resolveProfileByName(name);
+    },
+    listSharedResources() {
+      return discoverFiles(join6(root, "skills", "_shared"), ".md");
+    },
+    getSharedResourcePath(name) {
+      const resourcePath = join6(root, "skills", "_shared", `${name}.md`);
+      return existsSync11(resourcePath) ? resourcePath : void 0;
+    },
+    readSharedResource(name) {
+      const resourcePath = library.getSharedResourcePath(name);
+      if (!resourcePath) return void 0;
+      return readFileSync2(resourcePath, "utf-8");
+    },
+    listProtocols() {
+      const rootProtocols = discoverFiles(join6(root, "protocols"), ".md");
+      if (rootProtocols.length > 0) return rootProtocols;
+      return discoverFiles(join6(root, "skills", "protocols"), ".md");
+    },
+    getProtocolPath(name) {
+      const rootPath = join6(root, "protocols", `${name}.md`);
+      if (existsSync11(rootPath)) return rootPath;
+      const skillsPath = join6(root, "skills", "protocols", `${name}.md`);
+      return existsSync11(skillsPath) ? skillsPath : void 0;
+    },
+    readProtocol(name) {
+      const protocolPath = library.getProtocolPath(name);
+      if (!protocolPath) return void 0;
+      return readFileSync2(protocolPath, "utf-8");
+    },
+    validateSkillFrontmatter(name) {
+      const entry = skillMap.get(name);
+      if (!entry) {
+        return {
+          valid: false,
+          issues: [{ level: "error", field: "name", message: `Skill not found: ${name}` }]
+        };
+      }
+      const issues = [];
+      if (!entry.name) {
+        issues.push({ level: "error", field: "name", message: "Missing name" });
+      }
+      if (!entry.description) {
+        issues.push({ level: "error", field: "description", message: "Missing description" });
+      }
+      if (!entry.version) {
+        issues.push({ level: "warn", field: "version", message: "Missing version" });
+      }
+      const skillPath = join6(root, entry.path);
+      if (!existsSync11(skillPath)) {
+        issues.push({ level: "error", field: "path", message: `SKILL.md not found at ${entry.path}` });
+      }
+      return {
+        valid: !issues.some((i) => i.level === "error"),
+        issues
+      };
+    },
+    validateAll() {
+      const results = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        results.set(entry.name, library.validateSkillFrontmatter(entry.name));
+      }
+      return results;
+    },
+    getDispatchMatrix() {
+      return manifest.dispatch_matrix;
+    }
+  };
+  return library;
+}
+
 // src/core/skills/catalog.ts
 var catalog_exports = {};
 __export(catalog_exports, {
+  clearRegisteredLibrary: () => clearRegisteredLibrary,
   getCoreSkills: () => getCoreSkills,
   getDispatchMatrix: () => getDispatchMatrix,
   getLibraryRoot: () => getLibraryRoot,
@@ -2088,114 +2369,161 @@ __export(catalog_exports, {
   readProtocol: () => readProtocol,
   readSharedResource: () => readSharedResource,
   readSkillContent: () => readSkillContent,
+  registerSkillLibrary: () => registerSkillLibrary,
+  registerSkillLibraryFromPath: () => registerSkillLibraryFromPath,
   resolveDependencyTree: () => resolveDependencyTree,
   resolveProfile: () => resolveProfile,
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var _ctSkills;
-function getCtSkills() {
-  if (!_ctSkills) {
+import { existsSync as existsSync12 } from "fs";
+import { join as join7 } from "path";
+var _library = null;
+function registerSkillLibrary(library) {
+  _library = library;
+}
+function registerSkillLibraryFromPath(root) {
+  const indexPath = join7(root, "index.js");
+  if (existsSync12(indexPath)) {
+    _library = loadLibraryFromModule(root);
+    return;
+  }
+  _library = buildLibraryFromFiles(root);
+}
+function clearRegisteredLibrary() {
+  _library = null;
+}
+function discoverLibrary() {
+  const envPath = process.env["CAAMP_SKILL_LIBRARY"];
+  if (envPath && existsSync12(envPath)) {
     try {
-      _ctSkills = require2("@cleocode/ct-skills");
+      const indexPath = join7(envPath, "index.js");
+      if (existsSync12(indexPath)) {
+        return loadLibraryFromModule(envPath);
+      }
+      if (existsSync12(join7(envPath, "skills.json"))) {
+        return buildLibraryFromFiles(envPath);
+      }
     } catch {
-      throw new Error(
-        "@cleocode/ct-skills is not installed. Run: npm install @cleocode/ct-skills"
-      );
     }
   }
-  return _ctSkills;
+  const canonicalPath = join7(getAgentsHome(), "skill-library");
+  if (existsSync12(canonicalPath)) {
+    try {
+      const indexPath = join7(canonicalPath, "index.js");
+      if (existsSync12(indexPath)) {
+        return loadLibraryFromModule(canonicalPath);
+      }
+      if (existsSync12(join7(canonicalPath, "skills.json"))) {
+        return buildLibraryFromFiles(canonicalPath);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getLibrary() {
+  if (!_library) {
+    const discovered = discoverLibrary();
+    if (discovered) {
+      _library = discovered;
+    }
+  }
+  if (!_library) {
+    throw new Error(
+      "No skill library registered. Register one with registerSkillLibraryFromPath() or set the CAAMP_SKILL_LIBRARY environment variable."
+    );
+  }
+  return _library;
+}
+function isCatalogAvailable() {
+  try {
+    getLibrary();
+    return true;
+  } catch {
+    return false;
+  }
 }
 function getSkills() {
-  return getCtSkills().skills;
+  return getLibrary().skills;
 }
 function getManifest() {
-  return getCtSkills().manifest;
+  return getLibrary().manifest;
 }
 function listSkills() {
-  return getCtSkills().listSkills();
+  return getLibrary().listSkills();
 }
 function getSkill(name) {
-  return getCtSkills().getSkill(name);
+  return getLibrary().getSkill(name);
 }
 function getSkillPath(name) {
-  return getCtSkills().getSkillPath(name);
+  return getLibrary().getSkillPath(name);
 }
 function getSkillDir(name) {
-  return getCtSkills().getSkillDir(name);
+  return getLibrary().getSkillDir(name);
 }
 function readSkillContent(name) {
-  return getCtSkills().readSkillContent(name);
+  return getLibrary().readSkillContent(name);
 }
 function getCoreSkills() {
-  return getCtSkills().getCoreSkills();
+  return getLibrary().getCoreSkills();
 }
 function getSkillsByCategory(category) {
-  return getCtSkills().getSkillsByCategory(category);
+  return getLibrary().getSkillsByCategory(category);
 }
 function getSkillDependencies(name) {
-  return getCtSkills().getSkillDependencies(name);
+  return getLibrary().getSkillDependencies(name);
 }
 function resolveDependencyTree(names) {
-  return getCtSkills().resolveDependencyTree(names);
+  return getLibrary().resolveDependencyTree(names);
 }
 function listProfiles() {
-  return getCtSkills().listProfiles();
+  return getLibrary().listProfiles();
 }
 function getProfile(name) {
-  return getCtSkills().getProfile(name);
+  return getLibrary().getProfile(name);
 }
 function resolveProfile(name) {
-  return getCtSkills().resolveProfile(name);
+  return getLibrary().resolveProfile(name);
 }
 function listSharedResources() {
-  return getCtSkills().listSharedResources();
+  return getLibrary().listSharedResources();
 }
 function getSharedResourcePath(name) {
-  return getCtSkills().getSharedResourcePath(name);
+  return getLibrary().getSharedResourcePath(name);
 }
 function readSharedResource(name) {
-  return getCtSkills().readSharedResource(name);
+  return getLibrary().readSharedResource(name);
 }
 function listProtocols() {
-  return getCtSkills().listProtocols();
+  return getLibrary().listProtocols();
 }
 function getProtocolPath(name) {
-  return getCtSkills().getProtocolPath(name);
+  return getLibrary().getProtocolPath(name);
 }
 function readProtocol(name) {
-  return getCtSkills().readProtocol(name);
+  return getLibrary().readProtocol(name);
 }
 function validateSkillFrontmatter(name) {
-  return getCtSkills().validateSkillFrontmatter(name);
+  return getLibrary().validateSkillFrontmatter(name);
 }
 function validateAll() {
-  return getCtSkills().validateAll();
+  return getLibrary().validateAll();
 }
 function getDispatchMatrix() {
-  return getCtSkills().getDispatchMatrix();
+  return getLibrary().getDispatchMatrix();
 }
 function getVersion() {
-  return getCtSkills().version;
+  return getLibrary().version;
 }
 function getLibraryRoot() {
-  return getCtSkills().libraryRoot;
-}
-function isCatalogAvailable() {
-  try {
-    getCtSkills();
-    return true;
-  } catch {
-    return false;
-  }
+  return getLibrary().libraryRoot;
 }
 
 // src/core/skills/discovery.ts
 import { readFile as readFile7, readdir } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join8 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -2219,8 +2547,8 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join6(skillDir, "SKILL.md");
-  if (!existsSync11(skillFile)) return null;
+  const skillFile = join8(skillDir, "SKILL.md");
+  if (!existsSync13(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -2231,12 +2559,12 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync11(rootDir)) return [];
+  if (!existsSync13(rootDir)) return [];
   const entries = await readdir(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join6(rootDir, entry.name);
+    const skillDir = join8(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -2616,7 +2944,7 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { readFile as readFile8 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
@@ -2996,7 +3324,7 @@ var SEVERITY_WEIGHTS = {
   info: 0
 };
 async function scanFile(filePath, rules) {
-  if (!existsSync12(filePath)) {
+  if (!existsSync14(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
   const content = await readFile8(filePath, "utf-8");
@@ -3028,14 +3356,14 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join7 } = await import("path");
-  if (!existsSync12(dirPath)) return [];
+  const { join: join9 } = await import("path");
+  if (!existsSync14(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join7(dirPath, entry.name, "SKILL.md");
-      if (existsSync12(skillFile)) {
+      const skillFile = join9(dirPath, entry.name, "SKILL.md");
+      if (existsSync14(skillFile)) {
         results.push(await scanFile(skillFile));
       }
     }
@@ -3088,7 +3416,7 @@ function toSarif(results) {
 
 // src/core/skills/validator.ts
 import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
   "anthropic",
@@ -3109,7 +3437,7 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync13(filePath)) {
+  if (!existsSync15(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
@@ -3227,7 +3555,10 @@ export {
   removeInjection,
   checkAllInjections,
   injectAll,
+  buildInjectionContent,
+  parseInjectionContent,
   generateInjectionContent,
+  generateSkillsSection,
   groupByInstructFile,
   deepMerge,
   getNestedValue,
@@ -3301,12 +3632,17 @@ export {
   isMarketplaceScoped,
   formatNetworkError,
   MarketplaceClient,
+  loadLibraryFromModule,
+  buildLibraryFromFiles,
+  registerSkillLibrary,
+  registerSkillLibraryFromPath,
+  clearRegisteredLibrary,
+  isCatalogAvailable,
   listSkills,
   getSkill,
   getSkillDir,
   listProfiles,
   resolveProfile,
-  isCatalogAvailable,
   catalog_exports,
   parseSkillFile,
   discoverSkill,
@@ -3330,4 +3666,4 @@ export {
   toSarif,
   validateSkill
 };
-//# sourceMappingURL=chunk-HUMRYJPE.js.map
+//# sourceMappingURL=chunk-7YV3KXEJ.js.map