@a-company/paradigm 3.44.0 → 5.3.3

package/dist/chunk-2T6BTYBN.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/docs-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var SCAN_INDEX_PATH = ".paradigm/scan-index.json";
+var FLOW_INDEX_PATH = ".paradigm/flow-index.json";
+var CONFIG_PATH = ".paradigm/config.yaml";
+var PORTAL_FILE = "portal.yaml";
+var UNIVERSITY_INDEX_PATH = ".paradigm/university/index.yaml";
+var DEFAULT_CONFIG = {
+  enabled: true,
+  title: null,
+  theme: "dark",
+  customCss: null,
+  customContent: "docs/",
+  exclude: { tags: [], patterns: [] },
+  sidebar: { collapsed: [] },
+  output: ".paradigm/docs-site"
+};
+function loadDocsConfig(rootDir) {
+  const configPath = path.join(rootDir, CONFIG_PATH);
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const data = yaml.load(raw);
+    if (!data || !data.docs) return { ...DEFAULT_CONFIG };
+    const docs = data.docs;
+    return {
+      enabled: docs.enabled ?? DEFAULT_CONFIG.enabled,
+      title: docs.title ?? DEFAULT_CONFIG.title,
+      theme: docs.theme ?? DEFAULT_CONFIG.theme,
+      customCss: docs.customCss ?? DEFAULT_CONFIG.customCss,
+      customContent: docs.customContent ?? DEFAULT_CONFIG.customContent,
+      exclude: {
+        tags: docs.exclude?.tags ?? DEFAULT_CONFIG.exclude.tags,
+        patterns: docs.exclude?.patterns ?? DEFAULT_CONFIG.exclude.patterns
+      },
+      sidebar: {
+        collapsed: docs.sidebar?.collapsed ?? DEFAULT_CONFIG.sidebar.collapsed
+      },
+      output: docs.output ?? DEFAULT_CONFIG.output
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function loadScanIndex(rootDir) {
+  const filePath = path.join(rootDir, SCAN_INDEX_PATH);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function loadFlowIndex(rootDir) {
+  const filePath = path.join(rootDir, FLOW_INDEX_PATH);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function loadPortal(rootDir) {
+  const filePath = path.join(rootDir, PORTAL_FILE);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return yaml.load(raw);
+  } catch {
+    return null;
+  }
+}
+function loadUniversityIndex(rootDir) {
+  const filePath = path.join(rootDir, UNIVERSITY_INDEX_PATH);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return yaml.load(raw);
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = yaml.load(match[1]);
+    return { frontmatter, body: match[2].trim() };
+  } catch {
+    return null;
+  }
+}
+function allEntries(scanIndex) {
+  const entries = /* @__PURE__ */ new Map();
+  const categories = [
+    scanIndex.components,
+    scanIndex.features,
+    scanIndex.flows,
+    scanIndex.state,
+    scanIndex.gates,
+    scanIndex.signals,
+    scanIndex.aspects
+  ];
+  for (const cat of categories) {
+    if (!cat) continue;
+    for (const [id, entry] of Object.entries(cat)) {
+      entries.set(id, entry);
+    }
+  }
+  return entries;
+}
+function categoryToSearchKind(category) {
+  const mapping = {
+    components: "component",
+    features: "component",
+    flows: "flow",
+    state: "component",
+    gates: "gate",
+    signals: "signal",
+    aspects: "aspect"
+  };
+  return mapping[category] || "component";
+}
+function isExcluded(entry, config) {
+  if (config.exclude.tags.length > 0 && entry.visualTags) {
+    for (const tag of entry.visualTags) {
+      if (config.exclude.tags.includes(tag)) return true;
+    }
+  }
+  if (config.exclude.patterns.length > 0 && entry.path) {
+    for (const pattern of config.exclude.patterns) {
+      if (pattern.endsWith("*")) {
+        const prefix = pattern.slice(0, -1);
+        if (entry.path.includes(prefix)) return true;
+      } else if (entry.path.includes(pattern)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function loadCustomPages(rootDir, customContentDir) {
+  const dir = path.join(rootDir, customContentDir);
+  if (!fs.existsSync(dir)) return [];
+  const pages = [];
+  try {
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      try {
+        const raw = fs.readFileSync(path.join(dir, file), "utf8");
+        const slug = file.replace(/\.md$/, "");
+        const parsed = parseFrontmatter(raw);
+        if (parsed) {
+          pages.push({
+            slug,
+            title: parsed.frontmatter.title || slug,
+            body: parsed.body,
+            order: typeof parsed.frontmatter.order === "number" ? parsed.frontmatter.order : void 0,
+            description: parsed.frontmatter.description || void 0
+          });
+        } else {
+          pages.push({
+            slug,
+            title: slug,
+            body: raw.trim()
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  pages.sort((a, b) => {
+    if (a.order != null && b.order != null) return a.order - b.order;
+    if (a.order != null) return -1;
+    if (b.order != null) return 1;
+    return a.title.localeCompare(b.title);
+  });
+  return pages;
+}
+function loadCustomPage(rootDir, slug, config) {
+  const resolvedConfig = config || loadDocsConfig(rootDir);
+  const dir = path.join(rootDir, resolvedConfig.customContent);
+  const filePath = path.join(dir, `${slug}.md`);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = parseFrontmatter(raw);
+    if (parsed) {
+      return {
+        slug,
+        title: parsed.frontmatter.title || slug,
+        body: parsed.body,
+        order: typeof parsed.frontmatter.order === "number" ? parsed.frontmatter.order : void 0,
+        description: parsed.frontmatter.description || void 0
+      };
+    }
+    return {
+      slug,
+      title: slug,
+      body: raw.trim()
+    };
+  } catch {
+    return null;
+  }
+}
+function buildDocsManifest(rootDir, config) {
+  const resolvedConfig = config || loadDocsConfig(rootDir);
+  const scanIndex = loadScanIndex(rootDir);
+  const flowIndex = loadFlowIndex(rootDir);
+  const portal = loadPortal(rootDir);
+  const customPages = loadCustomPages(rootDir, resolvedConfig.customContent);
+  const uniIndex = loadUniversityIndex(rootDir);
+  const projectName = scanIndex?.$meta?.project || path.basename(rootDir);
+  const title = resolvedConfig.title || `${projectName} Docs`;
+  const groups = [];
+  const symbolCounts = {};
+  let totalSymbols = 0;
+  if (customPages.length > 0) {
+    groups.push({
+      id: "custom-pages",
+      label: "Pages",
+      collapsed: resolvedConfig.sidebar.collapsed.includes("custom-pages"),
+      items: customPages.map((p) => ({
+        id: p.slug,
+        label: p.title,
+        kind: "custom",
+        description: p.description
+      }))
+    });
+  }
+  if (uniIndex && uniIndex.entries.length > 0) {
+    const guideEntries = uniIndex.entries.filter(
+      (e) => (e.type === "note" || e.type === "policy") && e.symbols.length > 0
+    );
+    if (guideEntries.length > 0) {
+      groups.push({
+        id: "guides",
+        label: "Guides",
+        collapsed: resolvedConfig.sidebar.collapsed.includes("guides"),
+        items: guideEntries.map((e) => ({
+          id: e.id,
+          label: e.title,
+          kind: "guide",
+          description: void 0,
+          badge: e.symbols.length > 0 ? `${e.symbols.length} symbols` : void 0
+        }))
+      });
+    }
+  }
+  if (scanIndex) {
+    const componentEntries = Object.values(scanIndex.components || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    if (componentEntries.length > 0) {
+      const byType = /* @__PURE__ */ new Map();
+      for (const entry of componentEntries) {
+        const cType = entry.componentType || "other";
+        if (!byType.has(cType)) byType.set(cType, []);
+        byType.get(cType).push(entry);
+      }
+      const sortedTypes = [...byType.entries()].sort((a, b) => b[1].length - a[1].length);
+      const subgroups = sortedTypes.map(([cType, entries]) => ({
+        id: `components-${cType}`,
+        label: `${cType.charAt(0).toUpperCase() + cType.slice(1)} (${entries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes(`components-${cType}`),
+        items: entries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+          id: e.id,
+          label: e.name,
+          kind: "component",
+          description: e.description,
+          badge: e.componentType
+        }))
+      }));
+      groups.push({
+        id: "components",
+        label: `Components (${componentEntries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("components"),
+        items: [],
+        subgroups
+      });
+      symbolCounts["components"] = componentEntries.length;
+      totalSymbols += componentEntries.length;
+    }
+    const featureEntries = Object.values(scanIndex.features || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    if (featureEntries.length > 0) {
+      groups.push({
+        id: "features",
+        label: `Features (${featureEntries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("features"),
+        items: featureEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+          id: e.id,
+          label: e.name,
+          kind: "component",
+          description: e.description
+        }))
+      });
+      symbolCounts["features"] = featureEntries.length;
+      totalSymbols += featureEntries.length;
+    }
+    const flowEntries = Object.values(scanIndex.flows || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    const flowIds = new Set(flowEntries.map((f) => f.id));
+    const additionalFlows = [];
+    if (flowIndex) {
+      for (const [fId, flow] of Object.entries(flowIndex.flows)) {
+        const cleanId = fId.replace(/^\$/, "");
+        if (!flowIds.has(cleanId)) {
+          additionalFlows.push({
+            id: cleanId,
+            label: flow.name || cleanId,
+            kind: "flow",
+            description: flow.description
+          });
+        }
+      }
+    }
+    const allFlowItems = [
+      ...flowEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+        id: e.id,
+        label: e.name,
+        kind: "flow",
+        description: e.description
+      })),
+      ...additionalFlows
+    ];
+    if (allFlowItems.length > 0) {
+      groups.push({
+        id: "flows",
+        label: `Flows (${allFlowItems.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("flows"),
+        items: allFlowItems
+      });
+      symbolCounts["flows"] = allFlowItems.length;
+      totalSymbols += allFlowItems.length;
+    }
+    const gateEntries = Object.values(scanIndex.gates || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    if (gateEntries.length > 0) {
+      groups.push({
+        id: "gates",
+        label: `Gates (${gateEntries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("gates"),
+        items: gateEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+          id: e.id,
+          label: e.name,
+          kind: "gate",
+          description: e.description
+        }))
+      });
+      symbolCounts["gates"] = gateEntries.length;
+      totalSymbols += gateEntries.length;
+    }
+    const signalEntries = Object.values(scanIndex.signals || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    if (signalEntries.length > 0) {
+      groups.push({
+        id: "signals",
+        label: `Signals (${signalEntries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("signals"),
+        items: signalEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+          id: e.id,
+          label: e.name,
+          kind: "signal",
+          description: e.description
+        }))
+      });
+      symbolCounts["signals"] = signalEntries.length;
+      totalSymbols += signalEntries.length;
+    }
+    const aspectEntries = Object.values(scanIndex.aspects || {}).filter((e) => !isExcluded(e, resolvedConfig));
+    if (aspectEntries.length > 0) {
+      groups.push({
+        id: "aspects",
+        label: `Aspects (${aspectEntries.length})`,
+        collapsed: resolvedConfig.sidebar.collapsed.includes("aspects"),
+        items: aspectEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
+          id: e.id,
+          label: e.name,
+          kind: "aspect",
+          description: e.description
+        }))
+      });
+      symbolCounts["aspects"] = aspectEntries.length;
+      totalSymbols += aspectEntries.length;
+    }
+  }
+  if (portal) {
+    const routeCount = Object.keys(portal.routes || {}).length;
+    const gateCount = Object.keys(portal.gates || {}).length;
+    groups.push({
+      id: "portal",
+      label: "Portal",
+      collapsed: resolvedConfig.sidebar.collapsed.includes("portal"),
+      items: [{
+        id: "portal-overview",
+        label: "Authorization Overview",
+        kind: "portal",
+        description: `${gateCount} gates, ${routeCount} routes`,
+        badge: `${routeCount} routes`
+      }]
+    });
+  }
+  return {
+    title,
+    project: projectName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    groups,
+    totalSymbols,
+    symbolCounts
+  };
+}
+function buildSymbolPage(rootDir, symbolId) {
+  const scanIndex = loadScanIndex(rootDir);
+  if (!scanIndex) return null;
+  const entries = allEntries(scanIndex);
+  const entry = entries.get(symbolId);
+  if (!entry) return null;
+  const referencedBy = [];
+  for (const [otherId, otherEntry] of entries) {
+    if (otherId === symbolId) continue;
+    if (otherEntry.related && otherEntry.related.includes(entry.symbol)) {
+      referencedBy.push(otherEntry.symbol);
+    }
+  }
+  const references = (entry.related || []).slice();
+  const flows = [];
+  const flowIndex = loadFlowIndex(rootDir);
+  if (flowIndex) {
+    for (const [fId, flow] of Object.entries(flowIndex.flows)) {
+      const stepSymbols = (flow.steps || []).map((s) => s.symbol);
+      if (stepSymbols.includes(entry.symbol) || stepSymbols.includes(`#${symbolId}`)) {
+        flows.push({ id: fId.replace(/^\$/, ""), name: flow.name || fId });
+      }
+    }
+  }
+  if (scanIndex.flows) {
+    for (const [fId, flow] of Object.entries(scanIndex.flows)) {
+      if (flows.some((f) => f.id === fId)) continue;
+      const stepSymbols = (flow.steps || []).map((s) => s.symbol).filter(Boolean);
+      if (stepSymbols.includes(entry.symbol) || stepSymbols.includes(`#${symbolId}`)) {
+        flows.push({ id: fId, name: flow.name });
+      }
+    }
+  }
+  const gates = [];
+  const portal = loadPortal(rootDir);
+  if (portal && entry.category === "gates") {
+    const gateKey = Object.keys(portal.gates || {}).find(
+      (k) => k.replace(/^\^/, "") === symbolId
+    );
+    if (gateKey) {
+      gates.push({
+        id: gateKey.replace(/^\^/, ""),
+        description: portal.gates[gateKey].description
+      });
+    }
+  } else if (portal) {
+    const relatedGateSymbols = new Set((entry.related || []).filter((r) => r.startsWith("^")));
+    for (const [_route, routeGates] of Object.entries(portal.routes || {})) {
+      for (const gateRef of routeGates) {
+        const cleanGate = gateRef.replace(/^\^/, "");
+        if (relatedGateSymbols.has(gateRef) || relatedGateSymbols.has(`^${cleanGate}`)) {
+          const gateEntry = portal.gates[gateRef] || portal.gates[`^${cleanGate}`] || portal.gates[cleanGate];
+          if (gateEntry && !gates.some((g) => g.id === cleanGate)) {
+            gates.push({ id: cleanGate, description: gateEntry.description });
+          }
+        }
+      }
+    }
+  }
+  const aspects = [];
+  if (scanIndex.aspects) {
+    for (const [_aId, aspect] of Object.entries(scanIndex.aspects)) {
+      if (aspect.related && aspect.related.includes(entry.symbol)) {
+        aspects.push(aspect.symbol);
+      }
+    }
+  }
+  for (const ref of entry.related || []) {
+    if (ref.startsWith("~") && !aspects.includes(ref)) {
+      aspects.push(ref);
+    }
+  }
+  const guides = [];
+  const uniIndex = loadUniversityIndex(rootDir);
+  if (uniIndex) {
+    for (const uEntry of uniIndex.entries) {
+      if (uEntry.symbols.includes(entry.symbol)) {
+        guides.push({ id: uEntry.id, title: uEntry.title });
+      }
+    }
+  }
+  const parent = entry.parent || void 0;
+  const children = [];
+  if (scanIndex.components) {
+    for (const comp of Object.values(scanIndex.components)) {
+      if (comp.parent === entry.symbol) {
+        children.push(comp.symbol);
+      }
+    }
+  }
+  return {
+    id: entry.id,
+    symbol: entry.symbol,
+    name: entry.name,
+    description: entry.description || "",
+    category: entry.category || "components",
+    componentType: entry.componentType,
+    tags: entry.visualTags || [],
+    path: entry.path || "",
+    related: entry.related || [],
+    referencedBy,
+    references,
+    flows,
+    gates,
+    aspects,
+    guides,
+    parent,
+    children
+  };
+}
+function buildFlowPage(rootDir, flowId) {
+  const flowIndex = loadFlowIndex(rootDir);
+  const scanIndex = loadScanIndex(rootDir);
+  if (flowIndex) {
+    const flowKey = flowIndex.flows[`$${flowId}`] ? `$${flowId}` : flowId;
+    const flow = flowIndex.flows[flowKey];
+    if (flow) {
+      const steps = (flow.steps || []).map((s) => ({
+        type: s.type || "action",
+        symbol: s.symbol || "",
+        description: s.description
+      }));
+      const scanEntry = scanIndex?.flows?.[flowId.replace(/^\$/, "")];
+      return {
+        id: flowId.replace(/^\$/, ""),
+        symbol: `$${flowId.replace(/^\$/, "")}`,
+        name: flow.name || flowId,
+        description: flow.description,
+        trigger: flow.trigger,
+        steps,
+        successSignal: flow.successSignal,
+        errorSignal: flow.errorSignal,
+        tags: scanEntry?.visualTags || [],
+        path: scanEntry?.path || flow.definedIn || ""
+      };
+    }
+  }
+  if (scanIndex?.flows) {
+    const cleanId = flowId.replace(/^\$/, "");
+    const scanFlow = scanIndex.flows[cleanId];
+    if (scanFlow) {
+      const steps = (scanFlow.steps || []).map((s) => ({
+        type: "action",
+        symbol: s.symbol || "",
+        description: s.action || s.name
+      }));
+      return {
+        id: cleanId,
+        symbol: `$${cleanId}`,
+        name: scanFlow.name,
+        description: scanFlow.description,
+        steps,
+        tags: scanFlow.visualTags || [],
+        path: scanFlow.path || ""
+      };
+    }
+  }
+  return null;
+}
+function buildPortalPage(rootDir) {
+  const portal = loadPortal(rootDir);
+  if (!portal) {
+    return { version: "0", gates: [], routes: [] };
+  }
+  const gateRouteMap = /* @__PURE__ */ new Map();
+  for (const [routeKey, routeGates] of Object.entries(portal.routes || {})) {
+    for (const gateRef of routeGates) {
+      const cleanGate = gateRef.replace(/^\^/, "");
+      if (!gateRouteMap.has(cleanGate)) gateRouteMap.set(cleanGate, []);
+      gateRouteMap.get(cleanGate).push(routeKey);
+    }
+  }
+  const gates = Object.entries(portal.gates || {}).map(([key, gate]) => {
+    const cleanKey = key.replace(/^\^/, "");
+    return {
+      symbol: `^${cleanKey}`,
+      description: gate.description,
+      check: gate.check,
+      routes: gateRouteMap.get(cleanKey) || []
+    };
+  });
+  const routes = Object.entries(portal.routes || {}).map(([routeKey, routeGates]) => {
+    const spaceIdx = routeKey.indexOf(" ");
+    const method = spaceIdx > 0 ? routeKey.substring(0, spaceIdx) : "GET";
+    const route = spaceIdx > 0 ? routeKey.substring(spaceIdx + 1) : routeKey;
+    return {
+      route,
+      method,
+      gates: routeGates.map((gateRef) => {
+        const cleanGate = gateRef.replace(/^\^/, "");
+        const gateEntry = portal.gates[gateRef] || portal.gates[`^${cleanGate}`] || portal.gates[cleanGate];
+        return {
+          symbol: `^${cleanGate}`,
+          description: gateEntry?.description
+        };
+      })
+    };
+  });
+  return {
+    version: portal.version || "1.0",
+    gates,
+    routes
+  };
+}
+function searchDocs(rootDir, query, limit) {
+  const maxResults = limit || 20;
+  const results = [];
+  const queryLower = query.toLowerCase();
+  const scanIndex = loadScanIndex(rootDir);
+  if (scanIndex) {
+    const entries = allEntries(scanIndex);
+    for (const [_id, entry] of entries) {
+      const score = scoreMatch(entry.name, entry.description || "", entry.visualTags || [], queryLower);
+      if (score > 0) {
+        results.push({
+          id: entry.id,
+          kind: categoryToSearchKind(entry.category),
+          label: entry.name,
+          description: entry.description || "",
+          matchContext: buildMatchContext(entry.name, entry.description || "", queryLower),
+          score
+        });
+      }
+    }
+  }
+  const config = loadDocsConfig(rootDir);
+  const customPages = loadCustomPages(rootDir, config.customContent);
+  for (const page of customPages) {
+    const bodySnippet = page.body.substring(0, 200);
+    const score = scoreMatch(page.title, bodySnippet, [], queryLower);
+    if (score > 0) {
+      results.push({
+        id: page.slug,
+        kind: "custom",
+        label: page.title,
+        description: page.description || bodySnippet.substring(0, 100),
+        matchContext: buildMatchContext(page.title, page.body, queryLower),
+        score
+      });
+    }
+  }
+  const portal = loadPortal(rootDir);
+  if (portal) {
+    for (const [key, gate] of Object.entries(portal.gates || {})) {
+      const cleanKey = key.replace(/^\^/, "");
+      const score = scoreMatch(cleanKey, gate.description, [], queryLower);
+      if (score > 0) {
+        results.push({
+          id: cleanKey,
+          kind: "portal",
+          label: `^${cleanKey}`,
+          description: gate.description,
+          score
+        });
+      }
+    }
+  }
+  results.sort((a, b) => b.score - a.score || a.label.localeCompare(b.label));
+  return results.slice(0, maxResults);
+}
+function scoreMatch(name, description, tags, queryLower) {
+  const nameLower = name.toLowerCase();
+  const descLower = description.toLowerCase();
+  if (nameLower === queryLower) return 1;
+  if (nameLower.startsWith(queryLower)) return 0.8;
+  if (nameLower.includes(queryLower)) return 0.6;
+  if (descLower.includes(queryLower)) return 0.5;
+  if (tags.some((t) => t.toLowerCase().includes(queryLower))) return 0.3;
+  return 0;
+}
+function buildMatchContext(name, text, queryLower) {
+  const textLower = text.toLowerCase();
+  const idx = textLower.indexOf(queryLower);
+  if (idx < 0) {
+    if (name.toLowerCase().includes(queryLower)) {
+      return name;
+    }
+    return void 0;
+  }
+  const start = Math.max(0, idx - 40);
+  const end = Math.min(text.length, idx + queryLower.length + 40);
+  let snippet = text.substring(start, end).trim();
+  if (start > 0) snippet = `...${snippet}`;
+  if (end < text.length) snippet = `${snippet}...`;
+  return snippet;
+}
+
+export {
+  loadDocsConfig,
+  loadCustomPages,
+  loadCustomPage,
+  buildDocsManifest,
+  buildSymbolPage,
+  buildFlowPage,
+  buildPortalPage,
+  searchDocs
+};