chub-dev 0.1.0

package/src/lib/registry.js

@@ -0,0 +1,284 @@
+import { loadSourceRegistry } from './cache.js';
+import { loadConfig } from './config.js';
+import { normalizeLanguage } from './normalize.js';
+
+let _merged = null;
+
+/**
+ * Load and merge entries from all configured sources.
+ * Returns { docs: [...], skills: [...] } with each entry tagged with _source/_sourceObj.
+ */
+function getMerged() {
+  if (_merged) return _merged;
+
+  const config = loadConfig();
+  const allDocs = [];
+  const allSkills = [];
+
+  for (const source of config.sources) {
+    const registry = loadSourceRegistry(source);
+    if (!registry) continue;
+
+    // Support both new format (docs/skills) and old format (entries)
+    if (registry.docs) {
+      for (const doc of registry.docs) {
+        allDocs.push({ ...doc, id: doc.id || doc.name, _source: source.name, _sourceObj: source });
+      }
+    }
+    if (registry.skills) {
+      for (const skill of registry.skills) {
+        allSkills.push({ ...skill, id: skill.id || skill.name, _source: source.name, _sourceObj: source });
+      }
+    }
+
+    // Backward compat: old entries[] format
+    if (registry.entries) {
+      for (const entry of registry.entries) {
+        const tagged = { ...entry, _source: source.name, _sourceObj: source };
+        const provides = entry.languages?.[0]?.versions?.[0]?.provides || [];
+        if (provides.includes('skill')) {
+          allSkills.push(tagged);
+        }
+        if (provides.includes('doc') || provides.length === 0) {
+          allDocs.push(tagged);
+        }
+      }
+    }
+  }
+
+  _merged = { docs: allDocs, skills: allSkills };
+  return _merged;
+}
+
+/**
+ * Get all entries (docs + skills combined) for listing/searching.
+ */
+function getAllEntries() {
+  const { docs, skills } = getMerged();
+  // Tag each with _type for display
+  const taggedDocs = docs.map((d) => ({ ...d, _type: 'doc' }));
+  const taggedSkills = skills.map((s) => ({ ...s, _type: 'skill' }));
+  // Deduplicate: if same id+source appears in both, keep both but mark as bundled
+  return [...taggedDocs, ...taggedSkills];
+}
+
+/**
+ * Filter entries by the global source trust policy.
+ */
+function applySourceFilter(entries) {
+  const config = loadConfig();
+  const allowed = config.source.split(',').map((s) => s.trim().toLowerCase());
+  return entries.filter((e) => !e.source || allowed.includes(e.source.toLowerCase()));
+}
+
+/**
+ * Apply tag and language filters.
+ */
+function applyFilters(entries, filters) {
+  let result = entries;
+
+  if (filters.tags) {
+    const filterTags = filters.tags.split(',').map((t) => t.trim().toLowerCase());
+    result = result.filter((e) =>
+      filterTags.every((ft) => e.tags?.some((t) => t.toLowerCase() === ft))
+    );
+  }
+  if (filters.lang) {
+    const lang = normalizeLanguage(filters.lang);
+    result = result.filter((e) =>
+      e.languages?.some((l) => l.language === lang)
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Check if an id has collisions across sources.
+ */
+function getEntriesById(id, entries) {
+  return entries.filter((e) => e.id === id);
+}
+
+/**
+ * Check if we're in multi-source mode.
+ */
+export function isMultiSource() {
+  const config = loadConfig();
+  return config.sources.length > 1;
+}
+
+/**
+ * Get the display id for an entry — namespaced only on collision.
+ */
+export function getDisplayId(entry) {
+  if (!isMultiSource()) return entry.id;
+  const all = applySourceFilter(getAllEntries());
+  const matches = getEntriesById(entry.id, all).filter((e) => e._type === entry._type);
+  if (matches.length > 1) return `${entry._source}:${entry.id}`;
+  return entry.id;
+}
+
+/**
+ * Search entries by query string. Searches both docs and skills.
+ */
+export function searchEntries(query, filters = {}) {
+  const entries = applySourceFilter(getAllEntries());
+  const q = query.toLowerCase();
+  const words = q.split(/\s+/);
+
+  // Deduplicate: same id+source appearing as both doc and skill → show once
+  const seen = new Set();
+  const deduped = [];
+  for (const entry of entries) {
+    const key = `${entry._source}:${entry.id}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(entry);
+    }
+  }
+
+  let results = deduped.map((entry) => {
+    let score = 0;
+
+    if (entry.id === q) score += 100;
+    else if (entry.id.includes(q)) score += 50;
+
+    const nameLower = entry.name.toLowerCase();
+    if (nameLower === q) score += 80;
+    else if (nameLower.includes(q)) score += 40;
+
+    for (const word of words) {
+      if (entry.id.includes(word)) score += 10;
+      if (nameLower.includes(word)) score += 10;
+      if (entry.description?.toLowerCase().includes(word)) score += 5;
+      if (entry.tags?.some((t) => t.toLowerCase().includes(word))) score += 15;
+    }
+
+    return { entry, score };
+  });
+
+  results = results.filter((r) => r.score > 0);
+
+  const filtered = applyFilters(results.map((r) => r.entry), filters);
+  const filteredSet = new Set(filtered);
+  results = results.filter((r) => filteredSet.has(r.entry));
+
+  results.sort((a, b) => b.score - a.score);
+  return results.map((r) => ({ ...r.entry, _score: r.score }));
+}
+
+/**
+ * Get entry by id or source/id, from a specific type array.
+ * type: "doc" or "skill". If null, searches both.
+ */
+export function getEntry(idOrNamespacedId, type = null) {
+  const { docs, skills } = getMerged();
+  let pool;
+  if (type === 'doc') pool = applySourceFilter(docs);
+  else if (type === 'skill') pool = applySourceFilter(skills);
+  else pool = applySourceFilter([...docs, ...skills]);
+
+  // Check for source:id format (colon separates source from id)
+  if (idOrNamespacedId.includes(':')) {
+    const colonIdx = idOrNamespacedId.indexOf(':');
+    const sourceName = idOrNamespacedId.slice(0, colonIdx);
+    const id = idOrNamespacedId.slice(colonIdx + 1);
+    const entry = pool.find((e) => e._source === sourceName && e.id === id);
+    return entry ? { entry, ambiguous: false } : { entry: null, ambiguous: false };
+  }
+
+  // Bare id (may contain slashes like author/name)
+  const matches = pool.filter((e) => e.id === idOrNamespacedId);
+  if (matches.length === 0) return { entry: null, ambiguous: false };
+  if (matches.length === 1) return { entry: matches[0], ambiguous: false };
+
+  // Ambiguous — multiple sources have this id
+  return {
+    entry: null,
+    ambiguous: true,
+    alternatives: matches.map((e) => `${e._source}:${e.id}`),
+  };
+}
+
+/**
+ * List entries with optional filters. Searches both docs and skills, deduped.
+ */
+export function listEntries(filters = {}) {
+  const entries = applySourceFilter(getAllEntries());
+  // Deduplicate
+  const seen = new Set();
+  const deduped = [];
+  for (const entry of entries) {
+    const key = `${entry._source}:${entry.id}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(entry);
+    }
+  }
+  return applyFilters(deduped, filters);
+}
+
+/**
+ * Resolve the doc path + source for a doc entry.
+ * Returns { source, path, files } or null.
+ * If language is null and multiple languages exist, returns { needsLanguage: true, available: [...] }.
+ */
+export function resolveDocPath(entry, language, version) {
+  const lang = language ? normalizeLanguage(language) : null;
+
+  // Skills are flat — no language/version nesting
+  if (!entry.languages) {
+    // This is a skill entry — path is directly on the entry
+    if (!entry.path) return null;
+    return {
+      source: entry._sourceObj,
+      path: entry.path,
+      files: entry.files || [],
+    };
+  }
+
+  let langObj = null;
+  if (lang) {
+    langObj = entry.languages.find((l) => l.language === lang);
+  } else if (entry.languages.length === 1) {
+    langObj = entry.languages[0];
+  } else if (entry.languages.length > 1) {
+    return {
+      needsLanguage: true,
+      available: entry.languages.map((l) => l.language),
+    };
+  }
+
+  if (!langObj) return null;
+
+  let verObj = null;
+  if (version) {
+    verObj = langObj.versions?.find((v) => v.version === version);
+  } else {
+    const rec = langObj.recommendedVersion;
+    verObj = langObj.versions?.find((v) => v.version === rec) || langObj.versions?.[0];
+  }
+
+  if (!verObj?.path) return null;
+  return {
+    source: entry._sourceObj,
+    path: verObj.path,
+    files: verObj.files || [],
+  };
+}
+
+/**
+ * Given a resolved path and a type ("doc" or "skill"), return the entry file path.
+ */
+export function resolveEntryFile(resolved, type) {
+  if (!resolved || resolved.needsLanguage) return { error: 'unresolved' };
+
+  const fileName = type === 'skill' ? 'SKILL.md' : 'DOC.md';
+
+  return {
+    filePath: `${resolved.path}/${fileName}`,
+    basePath: resolved.path,
+    files: resolved.files,
+  };
+}