@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/index.js

@@ -1,787 +0,0 @@
-/**
- * Bootspring Skills Module
- * Unified access to built-in patterns and optional external skills catalog.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const crypto = require('crypto');
-
-const PATTERNS_DIR = path.join(__dirname, 'patterns');
-const EXTERNAL_SKILLS_DIR = path.join(__dirname, 'external');
-const EXTERNAL_MANIFEST_PATH = path.join(EXTERNAL_SKILLS_DIR, 'manifest.json');
-const DEFAULT_EXTERNAL_CACHE_ROOT = path.join(os.homedir(), '.bootspring', 'skills-cache');
-const EXTERNAL_CONTENT_FILENAME = 'SKILL.md';
-const MANIFEST_SIGNATURE_OMIT_KEYS = new Set(['signature', 'signatureAlgorithm', 'signatureValue', 'signedBy']);
-
-let builtInCache = null;
-let externalCache = null;
-
-function titleCase(value) {
-  return value
-    .split(/[-_]/)
-    .filter(Boolean)
-    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-    .join(' ');
-}
-
-function normalizeSlug(value) {
-  return String(value || '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
-function parseBoolean(value) {
-  if (typeof value === 'boolean') return value;
-  if (value === null || value === undefined) return false;
-  const normalized = String(value).trim().toLowerCase();
-  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
-}
-
-function stableStringify(value) {
-  if (value === null) return 'null';
-  if (typeof value === 'number' || typeof value === 'boolean') return JSON.stringify(value);
-  if (typeof value === 'string') return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return `[${value.map(item => stableStringify(item)).join(',')}]`;
-  }
-  if (typeof value === 'object') {
-    const keys = Object.keys(value).sort();
-    const entries = keys.map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
-    return `{${entries.join(',')}}`;
-  }
-  return JSON.stringify(value);
-}
-
-function canonicalManifestPayload(manifest) {
-  const clone = {};
-  for (const [key, value] of Object.entries(manifest || {})) {
-    if (!MANIFEST_SIGNATURE_OMIT_KEYS.has(key)) {
-      clone[key] = value;
-    }
-  }
-  return stableStringify(clone);
-}
-
-function parseFrontmatter(content) {
-  if (!content.startsWith('---\n')) {
-    return {};
-  }
-
-  const end = content.indexOf('\n---\n', 4);
-  if (end === -1) {
-    return {};
-  }
-
-  const block = content.slice(4, end);
-  const data = {};
-  for (const line of block.split('\n')) {
-    const separator = line.indexOf(':');
-    if (separator === -1) continue;
-    const key = line.slice(0, separator).trim();
-    const raw = line.slice(separator + 1).trim();
-    data[key] = raw.replace(/^['"]|['"]$/g, '');
-  }
-  return data;
-}
-
-function parseMarkdownMetadata(content, fallbackName) {
-  const titleMatch = content.match(/^#\s+(.+)$/m);
-  const title = titleMatch ? titleMatch[1].trim() : titleCase(fallbackName);
-
-  const withoutFrontmatter = content.replace(/^---[\s\S]*?---\n?/, '');
-  const lines = withoutFrontmatter.split('\n');
-  let description = '';
-  let h1Seen = false;
-  for (const line of lines) {
-    if (!h1Seen && /^#\s+/.test(line)) {
-      h1Seen = true;
-      continue;
-    }
-    if (h1Seen && line.trim() && !line.startsWith('#')) {
-      description = line.trim();
-      break;
-    }
-  }
-
-  return { title, description };
-}
-
-function scanBuiltInSkills() {
-  const categories = {};
-  const metadata = {};
-
-  if (!fs.existsSync(PATTERNS_DIR)) {
-    return { categories, metadata };
-  }
-
-  const categoryDirs = fs.readdirSync(PATTERNS_DIR, { withFileTypes: true })
-    .filter(entry => entry.isDirectory())
-    .map(entry => entry.name)
-    .sort();
-
-  for (const category of categoryDirs) {
-    const categoryPath = path.join(PATTERNS_DIR, category);
-    const patterns = fs.readdirSync(categoryPath, { withFileTypes: true })
-      .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
-      .map(entry => entry.name.replace(/\.md$/, ''))
-      .sort();
-
-    categories[category] = patterns;
-
-    for (const pattern of patterns) {
-      const id = `${category}/${pattern}`;
-      const filePath = path.join(categoryPath, `${pattern}.md`);
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const parsed = parseMarkdownMetadata(content, pattern);
-      const codeBlocks = Math.floor((content.match(/```/g) || []).length / 2);
-
-      metadata[id] = {
-        id,
-        source: 'built-in',
-        category,
-        name: parsed.title,
-        description: parsed.description,
-        title: parsed.title,
-        codeBlocks,
-        lines: content.split('\n').length,
-        path: filePath
-      };
-    }
-  }
-
-  return { categories, metadata };
-}
-
-function getExternalCacheRoot(options = {}) {
-  return path.resolve(String(options.cacheDir || process.env.BOOTSPRING_SKILL_CACHE_DIR || DEFAULT_EXTERNAL_CACHE_ROOT));
-}
-
-function getExternalCacheManifestPath(options = {}) {
-  return path.join(getExternalCacheRoot(options), 'external', 'manifest.json');
-}
-
-function parseExternalSkill(skillDirName, source = {}) {
-  const skillPath = path.join(source.skillsDir || EXTERNAL_SKILLS_DIR, skillDirName, EXTERNAL_CONTENT_FILENAME);
-  if (!fs.existsSync(skillPath)) {
-    return null;
-  }
-
-  const content = fs.readFileSync(skillPath, 'utf-8');
-  const frontmatter = parseFrontmatter(content);
-  const parsed = parseMarkdownMetadata(content, skillDirName);
-
-  const rawName = frontmatter.name || source.name || skillDirName;
-  const slug = normalizeSlug(rawName) || normalizeSlug(skillDirName) || skillDirName;
-  const title = parsed.title || titleCase(rawName);
-  const description = frontmatter.description || source.description || parsed.description || '';
-
-  return {
-    id: `external/${slug}`,
-    source: source.source || 'external',
-    slug,
-    name: title,
-    description,
-    category: 'external',
-    path: skillPath,
-    lines: content.split('\n').length,
-    tier: source.tier,
-    version: source.version,
-    checksum: source.checksum
-  };
-}
-
-function loadExternalManifest(manifestPath = EXTERNAL_MANIFEST_PATH) {
-  if (!fs.existsSync(manifestPath)) {
-    return [];
-  }
-
-  try {
-    const raw = fs.readFileSync(manifestPath, 'utf-8');
-    const manifest = JSON.parse(raw);
-    if (!manifest || !Array.isArray(manifest.skills)) {
-      return [];
-    }
-
-    return manifest.skills
-      .map(item => {
-        if (typeof item === 'string') {
-          return { slug: String(item || '').trim() };
-        }
-        if (item && typeof item === 'object') {
-          return {
-            slug: normalizeSlug(item.slug || item.id || item.name || ''),
-            name: item.name,
-            description: item.description,
-            tier: item.tier,
-            version: item.version,
-            checksum: item.checksum
-          };
-        }
-        return null;
-      })
-      .filter(Boolean)
-      .filter(item => item.slug)
-      .map(item => ({ ...item, slug: String(item.slug).trim() }))
-      .filter(item => item.slug.length > 0);
-  } catch {
-    return [];
-  }
-}
-
-function scanExternalSkillsFromSource(source) {
-  const metadata = {};
-  const { skillsDir, manifestPath } = source;
-
-  if (!fs.existsSync(skillsDir) || !fs.existsSync(manifestPath)) {
-    return metadata;
-  }
-
-  const manifestSkills = loadExternalManifest(manifestPath);
-  for (const item of manifestSkills) {
-    const parsed = parseExternalSkill(item.slug, {
-      skillsDir,
-      source: source.source,
-      name: item.name,
-      description: item.description,
-      tier: item.tier,
-      version: item.version,
-      checksum: item.checksum
-    });
-    if (!parsed) continue;
-    if (!metadata[parsed.id]) {
-      metadata[parsed.id] = parsed;
-    }
-  }
-
-  return metadata;
-}
-
-function scanExternalSkills(options = {}) {
-  const metadata = {};
-  const cacheRoot = getExternalCacheRoot(options);
-  const sourcePriority = String(process.env.BOOTSPRING_SKILL_CATALOG_SOURCE || 'auto').toLowerCase();
-  const localSource = {
-    source: 'external-local',
-    skillsDir: EXTERNAL_SKILLS_DIR,
-    manifestPath: EXTERNAL_MANIFEST_PATH
-  };
-  const cacheSource = {
-    source: 'external-cache',
-    skillsDir: path.join(cacheRoot, 'external'),
-    manifestPath: getExternalCacheManifestPath(options)
-  };
-
-  const sources = sourcePriority === 'cache'
-    ? [cacheSource]
-    : sourcePriority === 'local'
-      ? [localSource]
-      : [cacheSource, localSource];
-
-  for (const source of sources) {
-    const items = scanExternalSkillsFromSource(source);
-    for (const [id, item] of Object.entries(items)) {
-      if (!metadata[id]) {
-        metadata[id] = item;
-      }
-    }
-  }
-
-  return metadata;
-}
-
-function hashContent(content) {
-  return crypto.createHash('sha256').update(content).digest('hex');
-}
-
-function normalizeChecksum(checksum) {
-  const raw = String(checksum || '').trim().toLowerCase();
-  if (!raw) return '';
-  return raw.startsWith('sha256:') ? raw.slice(7) : raw;
-}
-
-function assertChecksum(content, checksum) {
-  const expected = normalizeChecksum(checksum);
-  if (!expected) return true;
-  return hashContent(content) === expected;
-}
-
-function decodeSignature(signature) {
-  const normalized = String(signature || '').trim().replace(/-/g, '+').replace(/_/g, '/');
-  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
-  return Buffer.from(padded, 'base64');
-}
-
-function verifyManifestSignature(manifest, options = {}) {
-  const signature = String(options.manifestSignature || manifest.signature || '').trim();
-  const publicKey = String(options.manifestPublicKey || process.env.BOOTSPRING_SKILL_MANIFEST_PUBLIC_KEY || '').trim();
-  const requireSignature = parseBoolean(
-    options.requireManifestSignature ?? process.env.BOOTSPRING_SKILL_MANIFEST_REQUIRE_SIGNATURE
-  );
-
-  if (!signature) {
-    if (requireSignature) {
-      throw new Error('Missing manifest signature while signature verification is required.');
-    }
-    return { verified: false, required: false, reason: 'not_provided' };
-  }
-
-  if (!publicKey) {
-    throw new Error('Manifest signature provided but no public key configured. Set BOOTSPRING_SKILL_MANIFEST_PUBLIC_KEY or pass manifestPublicKey.');
-  }
-
-  const algorithm = String(options.manifestSignatureAlgorithm || manifest.signatureAlgorithm || 'sha256')
-    .trim()
-    .toLowerCase();
-  if (algorithm !== 'sha256') {
-    throw new Error(`Unsupported manifest signature algorithm: ${algorithm}`);
-  }
-
-  const payload = canonicalManifestPayload(manifest);
-  const signatureBuffer = decodeSignature(signature);
-  const verified = crypto.verify('sha256', Buffer.from(payload, 'utf-8'), publicKey, signatureBuffer);
-
-  if (!verified) {
-    throw new Error('Manifest signature verification failed.');
-  }
-
-  return { verified: true, required: requireSignature, algorithm: 'sha256' };
-}
-
-function defaultHeaders(options = {}) {
-  const headers = { accept: 'application/json' };
-  const token = options.token || process.env.BOOTSPRING_SKILL_TOKEN;
-  if (token) {
-    headers.authorization = `Bearer ${token}`;
-  }
-  return headers;
-}
-
-async function fetchJson(url, options = {}) {
-  const timeoutMs = Number(options.timeoutMs || 15000);
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: defaultHeaders(options),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status} for ${url}`);
-    }
-    return await response.json();
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-async function fetchText(url, options = {}) {
-  const timeoutMs = Number(options.timeoutMs || 15000);
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: defaultHeaders(options),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status} for ${url}`);
-    }
-    return await response.text();
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-function resolveContentUrl(entry, options = {}) {
-  if (entry.contentUrl) {
-    return entry.contentUrl;
-  }
-  const contentBaseUrl = options.contentBaseUrl || process.env.BOOTSPRING_SKILL_CONTENT_BASE_URL;
-  if (!contentBaseUrl) {
-    return '';
-  }
-  const base = String(contentBaseUrl).replace(/\/+$/, '');
-  return `${base}/${entry.slug}/${EXTERNAL_CONTENT_FILENAME}`;
-}
-
-function resetExternalCache() {
-  externalCache = null;
-}
-
-async function syncExternalCatalog(options = {}) {
-  const manifestUrl = options.manifestUrl || process.env.BOOTSPRING_SKILL_MANIFEST_URL;
-  if (!manifestUrl) {
-    throw new Error('Missing manifest URL. Set BOOTSPRING_SKILL_MANIFEST_URL or pass manifestUrl.');
-  }
-
-  const cacheRoot = getExternalCacheRoot(options);
-  const externalRoot = path.join(cacheRoot, 'external');
-  fs.mkdirSync(externalRoot, { recursive: true });
-
-  const manifest = await fetchJson(manifestUrl, options);
-  if (!manifest || !Array.isArray(manifest.skills)) {
-    throw new Error('Invalid remote manifest: expected { skills: [] }');
-  }
-  const signature = verifyManifestSignature(manifest, options);
-
-  const savedManifest = {
-    version: manifest.version || 1,
-    description: manifest.description || 'Remote external skill catalog',
-    syncedAt: new Date().toISOString(),
-    signatureVerified: Boolean(signature.verified),
-    skills: []
-  };
-
-  let fetched = 0;
-  const skipped = [];
-
-  for (const item of manifest.skills) {
-    const entry = typeof item === 'string'
-      ? { slug: normalizeSlug(item) }
-      : {
-        slug: normalizeSlug(item.slug || item.id || item.name || ''),
-        name: item.name,
-        description: item.description,
-        tier: item.tier,
-        version: item.version,
-        checksum: item.checksum,
-        contentUrl: item.contentUrl,
-        content: item.content
-      };
-
-    if (!entry.slug) continue;
-
-    let content = typeof entry.content === 'string' ? entry.content : '';
-    if (!content) {
-      const contentUrl = resolveContentUrl(entry, options);
-      if (!contentUrl) {
-        skipped.push(entry.slug);
-        continue;
-      }
-      content = await fetchText(contentUrl, options);
-    }
-
-    if (!assertChecksum(content, entry.checksum)) {
-      skipped.push(entry.slug);
-      continue;
-    }
-
-    const skillDir = path.join(externalRoot, entry.slug);
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, EXTERNAL_CONTENT_FILENAME), content, 'utf-8');
-
-    savedManifest.skills.push({
-      slug: entry.slug,
-      name: entry.name || titleCase(entry.slug),
-      description: entry.description || '',
-      tier: entry.tier || 'pro',
-      version: entry.version || '1.0.0',
-      checksum: entry.checksum || `sha256:${hashContent(content)}`
-    });
-    fetched++;
-  }
-
-  fs.writeFileSync(path.join(externalRoot, 'manifest.json'), JSON.stringify(savedManifest, null, 2), 'utf-8');
-  resetExternalCache();
-
-  return {
-    fetched,
-    skipped,
-    cacheRoot,
-    manifestPath: path.join(externalRoot, 'manifest.json'),
-    signatureVerified: Boolean(signature.verified)
-  };
-}
-
-function loadExternalManifestIds(manifestPath = EXTERNAL_MANIFEST_PATH) {
-  return loadExternalManifest(manifestPath)
-    .map(item => String(item.slug || '').trim())
-    .filter(Boolean);
-}
-
-function getBuiltInCache() {
-  if (!builtInCache) {
-    builtInCache = scanBuiltInSkills();
-  }
-  return builtInCache;
-}
-
-function getExternalCache() {
-  if (!externalCache) {
-    externalCache = scanExternalSkills();
-  }
-  return externalCache;
-}
-
-function getCategories() {
-  return Object.keys(getBuiltInCache().categories);
-}
-
-function getPatternsByCategory(category) {
-  return getBuiltInCache().categories[category] || [];
-}
-
-function listSkills(options = {}) {
-  const { includeExternal = false } = options;
-  const builtIn = Object.keys(getBuiltInCache().metadata).sort();
-  if (!includeExternal) {
-    return builtIn;
-  }
-
-  const external = Object.keys(getExternalCache()).sort();
-  return [...builtIn, ...external];
-}
-
-function listExternalSkills(options = {}) {
-  const { limit } = options;
-  const all = Object.values(getExternalCache())
-    .map(skill => skill.id)
-    .sort();
-  if (typeof limit === 'number' && limit >= 0) {
-    return all.slice(0, limit);
-  }
-  return all;
-}
-
-function getSkillPath(skillName) {
-  const skill = getBuiltInCache().metadata[skillName];
-  return skill ? skill.path : undefined;
-}
-
-function resolveExternalSkillName(skillName) {
-  if (!skillName) return null;
-  if (skillName.startsWith('external/')) {
-    return skillName;
-  }
-  const direct = `external/${skillName}`;
-  if (getExternalCache()[direct]) {
-    return direct;
-  }
-  return null;
-}
-
-function loadSkill(skillName, options = {}) {
-  const { includeExternal = false } = options;
-
-  const builtInPath = getSkillPath(skillName);
-  if (builtInPath && fs.existsSync(builtInPath)) {
-    return fs.readFileSync(builtInPath, 'utf-8');
-  }
-
-  if (!includeExternal) {
-    return null;
-  }
-
-  const externalId = resolveExternalSkillName(skillName);
-  if (!externalId) {
-    return null;
-  }
-
-  const externalSkill = getExternalCache()[externalId];
-  if (!externalSkill || !fs.existsSync(externalSkill.path)) {
-    return null;
-  }
-
-  return fs.readFileSync(externalSkill.path, 'utf-8');
-}
-
-function searchSkills(query, options = {}) {
-  const { includeExternal = false, limit } = options;
-  const lowerQuery = String(query || '').toLowerCase();
-  if (!lowerQuery) return [];
-
-  const builtInResults = Object.values(getBuiltInCache().metadata)
-    .filter(skill => {
-      return skill.id.toLowerCase().includes(lowerQuery) ||
-             skill.name.toLowerCase().includes(lowerQuery) ||
-             skill.description.toLowerCase().includes(lowerQuery);
-    })
-    .map(skill => skill.id);
-
-  let results = builtInResults;
-
-  if (includeExternal) {
-    const externalResults = Object.values(getExternalCache())
-      .filter(skill => {
-        return skill.id.toLowerCase().includes(lowerQuery) ||
-               skill.slug.toLowerCase().includes(lowerQuery) ||
-               skill.name.toLowerCase().includes(lowerQuery) ||
-               skill.description.toLowerCase().includes(lowerQuery);
-      })
-      .map(skill => skill.id);
-    results = results.concat(externalResults);
-  }
-
-  const deduped = [...new Set(results)].sort();
-  if (typeof limit === 'number' && limit >= 0) {
-    return deduped.slice(0, limit);
-  }
-  return deduped;
-}
-
-function getSkillMetadata(skillName) {
-  const builtIn = getBuiltInCache().metadata[skillName];
-  if (builtIn) return builtIn;
-
-  const externalId = resolveExternalSkillName(skillName);
-  if (externalId) {
-    return getExternalCache()[externalId] || null;
-  }
-
-  return null;
-}
-
-function hasExternalSkillLibrary() {
-  const cacheManifestPath = getExternalCacheManifestPath();
-  return fs.existsSync(EXTERNAL_MANIFEST_PATH) || fs.existsSync(cacheManifestPath);
-}
-
-function parseHeadings(content) {
-  const headings = [];
-  const lines = content.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const match = line.match(/^(#{1,6})\s+(.+)$/);
-    if (match) {
-      headings.push({
-        level: match[1].length,
-        title: match[2].trim(),
-        line: i
-      });
-    }
-  }
-  return headings;
-}
-
-function buildSummary(content) {
-  const withoutFrontmatter = content.replace(/^---[\s\S]*?---\n?/, '');
-  const titleMatch = withoutFrontmatter.match(/^#\s+(.+)$/m);
-  const title = titleMatch ? titleMatch[1].trim() : 'Skill';
-
-  const lines = withoutFrontmatter.split('\n');
-  let firstParagraph = '';
-  let seenTitle = false;
-  for (const line of lines) {
-    if (!seenTitle && /^#\s+/.test(line)) {
-      seenTitle = true;
-      continue;
-    }
-    if (seenTitle && line.trim() && !line.startsWith('#')) {
-      firstParagraph = line.trim();
-      break;
-    }
-  }
-
-  const headings = parseHeadings(withoutFrontmatter)
-    .filter(h => h.level <= 3)
-    .slice(0, 8)
-    .map(h => `- ${h.title}`);
-
-  let out = `# ${title}\n\n`;
-  if (firstParagraph) {
-    out += `${firstParagraph}\n\n`;
-  }
-  if (headings.length > 0) {
-    out += '## Key Sections\n';
-    out += `${headings.join('\n')}\n`;
-  }
-
-  return out.trim();
-}
-
-function selectSections(content, requestedSections) {
-  const lines = content.split('\n');
-  const headings = parseHeadings(content);
-  const requested = requestedSections
-    .map(value => String(value || '').trim().toLowerCase())
-    .filter(Boolean);
-
-  if (requested.length === 0 || headings.length === 0) {
-    return content;
-  }
-
-  const blocks = [];
-  for (let i = 0; i < headings.length; i++) {
-    const current = headings[i];
-    const next = headings[i + 1];
-    const startLine = current.line;
-    const endLine = next ? next.line : lines.length;
-    const title = current.title.toLowerCase();
-    const match = requested.some(section => title.includes(section));
-    if (match) {
-      blocks.push(lines.slice(startLine, endLine).join('\n').trim());
-    }
-  }
-
-  if (blocks.length === 0) {
-    return '';
-  }
-
-  return blocks.join('\n\n');
-}
-
-function applyMaxChars(content, maxChars) {
-  if (!Number.isFinite(maxChars) || maxChars <= 0) {
-    return content;
-  }
-
-  if (content.length <= maxChars) {
-    return content;
-  }
-
-  const clipped = content.slice(0, maxChars).trimEnd();
-  return `${clipped}\n\n... [truncated]`;
-}
-
-function formatSkillContent(content, options = {}) {
-  const {
-    summary = false,
-    sections,
-    maxChars
-  } = options;
-
-  let output = summary ? buildSummary(content) : content;
-
-  const sectionList = Array.isArray(sections)
-    ? sections
-    : (typeof sections === 'string' ? sections.split(',') : []);
-  if (!summary && sectionList.length > 0) {
-    output = selectSections(output, sectionList);
-  }
-
-  const parsedMax = Number(maxChars);
-  output = applyMaxChars(output, parsedMax);
-
-  return output;
-}
-
-module.exports = {
-  PATTERNS_DIR,
-  EXTERNAL_SKILLS_DIR,
-  EXTERNAL_MANIFEST_PATH,
-  DEFAULT_EXTERNAL_CACHE_ROOT,
-  getExternalCacheRoot,
-  getExternalCacheManifestPath,
-  syncExternalCatalog,
-  canonicalManifestPayload,
-  verifyManifestSignature,
-  resetExternalCache,
-  loadExternalManifestIds,
-  getCategories,
-  getPatternsByCategory,
-  listSkills,
-  listExternalSkills,
-  getSkillPath,
-  loadSkill,
-  searchSkills,
-  getSkillMetadata,
-  hasExternalSkillLibrary,
-  formatSkillContent
-};