@anokye-labs/kbexplorer-engine 0.1.0

package/dist/chunk-XVI6CBSX.js

@@ -0,0 +1,412 @@
+import { splitIntoSections, renderSafeMarkdown } from './chunk-FJ4GTN4U.js';
+import yaml from 'yaml';
+
+function basename(filePath) {
+  const name = filePath.split("/").pop() ?? filePath;
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.substring(0, dot) : name;
+}
+function extname(filePath) {
+  const name = filePath.split("/").pop() ?? filePath;
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.substring(dot) : "";
+}
+function isMarkdown(path) {
+  const ext = extname(path).toLowerCase();
+  return ext === ".md" || ext === ".mdx";
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderHtml(content, filePath) {
+  if (isMarkdown(filePath)) {
+    return renderSafeMarkdown(content);
+  }
+  return `<pre><code>${escapeHtml(content)}</code></pre>`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function getNodePath(node) {
+  if (node.source.type === "file") return node.source.path;
+  if (node.source.type === "authored") return node.source.file;
+  return void 0;
+}
+function globToRegex(pattern) {
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i += 1;
+      if (pattern[i + 1] === "/") i += 1;
+    } else if (c === "*") {
+      re += "[^/]*";
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (".+^${}()|[]\\".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchesAnyGlob(path, patterns) {
+  return patterns.some((p) => globToRegex(p).test(path));
+}
+function buildFileNode(id, title, filePath, content, entry) {
+  const isMd = isMarkdown(filePath);
+  const display = entry.display ?? (isMd ? void 0 : "code");
+  const source = isMd ? { type: "authored", file: filePath } : { type: "file", path: filePath };
+  return {
+    id,
+    title,
+    cluster: entry.cluster ?? "default",
+    content: renderHtml(content, filePath),
+    rawContent: content,
+    ...entry.emoji !== void 0 ? { emoji: entry.emoji } : {},
+    ...display !== void 0 ? { display } : {},
+    derived: true,
+    connections: [],
+    identity: `urn:file:${filePath}`,
+    source
+  };
+}
+async function processSingleFile(entry, readFile) {
+  const filePath = entry.file;
+  const content = await readFile(filePath);
+  if (content === null) return [];
+  const id = entry.id;
+  const title = entry.title ?? basename(filePath);
+  if (entry.split === "headings") {
+    const isMd = isMarkdown(filePath);
+    const source = isMd ? { type: "authored", file: filePath } : { type: "file", path: filePath };
+    const sections = splitIntoSections(
+      id,
+      title,
+      content,
+      entry.cluster ?? "default",
+      entry.emoji ?? "Document",
+      source,
+      []
+      // cross-ref nodes added in the connection-derivation pass
+    );
+    if (sections.length > 0) {
+      if (entry.display) {
+        const parent = sections.find((n) => n.nodeType === "parent");
+        if (parent) parent.display = entry.display;
+      }
+      return sections;
+    }
+  }
+  return [buildFileNode(id, title, filePath, content, entry)];
+}
+async function processMerge(entry, readFile) {
+  const files = entry.files;
+  const parts = [];
+  for (const filePath of files) {
+    const content = await readFile(filePath);
+    if (content === null) continue;
+    const name = filePath.split("/").pop() ?? filePath;
+    parts.push(`## ${name}
+
+${content}`);
+  }
+  if (parts.length === 0) return [];
+  const merged = parts.join("\n\n---\n\n");
+  const html = renderSafeMarkdown(merged);
+  const display = entry.display ?? "file-list";
+  return [
+    {
+      id: entry.id,
+      title: entry.title ?? entry.id,
+      cluster: entry.cluster ?? "default",
+      content: html,
+      rawContent: merged,
+      ...entry.emoji !== void 0 ? { emoji: entry.emoji } : {},
+      display,
+      derived: true,
+      connections: [],
+      source: { type: "file", path: files[0] }
+    }
+  ];
+}
+async function processGlob(entry, readFile, listFiles) {
+  if (!listFiles) return [];
+  let paths = await listFiles(entry.glob);
+  if (entry.exclude?.length) {
+    paths = paths.filter((p) => !matchesAnyGlob(p, entry.exclude));
+  }
+  const nodes = [];
+  for (const filePath of paths) {
+    const content = await readFile(filePath);
+    if (content === null) continue;
+    const fileBase = basename(filePath);
+    const nodeId = `${entry.id}-${fileBase}`;
+    let title;
+    if (entry.titleFrom === "heading") {
+      const m = content.match(/^#\s+(.+)/m);
+      title = m ? m[1].trim() : fileBase;
+    } else {
+      title = fileBase;
+    }
+    nodes.push(buildFileNode(nodeId, title, filePath, content, entry));
+  }
+  return nodes;
+}
+async function processDirectory(entry, listDirectory) {
+  if (!listDirectory) return [];
+  const dir = entry.directory;
+  const items = await listDirectory(dir);
+  const lines = items.map((item) => {
+    const icon = item.type === "tree" ? "\u{1F4C1}" : "\u{1F4C4}";
+    const name = item.path.split("/").pop() ?? item.path;
+    const size = item.size != null ? ` (${formatBytes(item.size)})` : "";
+    return `${icon} ${name}${size}`;
+  });
+  const title = entry.title ?? dir;
+  const rawContent = `## ${title}
+
+${lines.join("\n")}`;
+  const html = renderSafeMarkdown(rawContent);
+  return [
+    {
+      id: entry.id,
+      title,
+      cluster: entry.cluster ?? "default",
+      content: html,
+      rawContent,
+      emoji: entry.emoji ?? "Folder",
+      display: entry.display ?? "tree",
+      derived: true,
+      connections: [],
+      source: { type: "file", path: dir }
+    }
+  ];
+}
+function resolveImportPath(importPath, fromFile) {
+  const lastSlash = fromFile.lastIndexOf("/");
+  const fromDir = lastSlash >= 0 ? fromFile.substring(0, lastSlash) : "";
+  const combined = fromDir ? `${fromDir}/${importPath}` : importPath;
+  const parts = combined.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") {
+      if (resolved.length) resolved.pop();
+      continue;
+    }
+    resolved.push(part);
+  }
+  return resolved.join("/");
+}
+function extractImportPaths(content, fromFile) {
+  const paths = [];
+  for (const m of content.matchAll(/\bfrom\s+['"]([^'"]+)['"]/g)) {
+    const spec = m[1];
+    if (spec.startsWith("."))
+      paths.push(resolveImportPath(spec, fromFile));
+  }
+  for (const m of content.matchAll(/^\s*import\s+['"]([^'"]+)['"]/gm)) {
+    const spec = m[1];
+    if (spec.startsWith("."))
+      paths.push(resolveImportPath(spec, fromFile));
+  }
+  for (const m of content.matchAll(
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  )) {
+    const spec = m[1];
+    if (spec.startsWith("."))
+      paths.push(resolveImportPath(spec, fromFile));
+  }
+  return [...new Set(paths)];
+}
+function findNodeIdByPath(resolved, pathToId) {
+  if (pathToId.has(resolved)) return pathToId.get(resolved);
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]) {
+    if (pathToId.has(resolved + ext)) return pathToId.get(resolved + ext);
+  }
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (pathToId.has(`${resolved}/index${ext}`))
+      return pathToId.get(`${resolved}/index${ext}`);
+  }
+  return void 0;
+}
+function deriveConnections(allNodes, entries, entryNodeIds) {
+  const pathToId = /* @__PURE__ */ new Map();
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    nodeById.set(node.id, node);
+    const p = getNodePath(node);
+    if (p) {
+      const existing = pathToId.get(p);
+      if (!existing || node.source.type === "authored") {
+        pathToId.set(p, node.id);
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.connections) continue;
+    const nodeIds = entryNodeIds.get(entry.id) ?? [];
+    if (Array.isArray(entry.connections)) {
+      for (const nodeId of nodeIds) {
+        const node = nodeById.get(nodeId);
+        if (node) node.connections.push(...entry.connections);
+      }
+      continue;
+    }
+    if (entry.connections === "imports") {
+      for (const nodeId of nodeIds) {
+        const node = nodeById.get(nodeId);
+        if (!node) continue;
+        const fromPath = getNodePath(node);
+        if (!fromPath) continue;
+        const imports = extractImportPaths(node.rawContent, fromPath);
+        for (const imp of imports) {
+          const targetId = findNodeIdByPath(imp, pathToId);
+          if (targetId && targetId !== nodeId) {
+            node.connections.push({
+              to: targetId,
+              type: "references",
+              description: `Imports ${imp.split("/").pop() ?? imp}`,
+              source: "inferred"
+            });
+          }
+        }
+      }
+      continue;
+    }
+    if (entry.connections === "references") {
+      for (const nodeId of nodeIds) {
+        const node = nodeById.get(nodeId);
+        if (!node) continue;
+        const lower = node.rawContent.toLowerCase();
+        const seen = new Set(node.connections.map((c) => c.to));
+        for (const other of allNodes) {
+          if (other.id === nodeId || seen.has(other.id)) continue;
+          if (lower.includes(other.id.toLowerCase())) {
+            node.connections.push({
+              to: other.id,
+              type: "mentions",
+              description: `Mentions ${other.title}`,
+              source: "inferred"
+            });
+            seen.add(other.id);
+            continue;
+          }
+          const words = other.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+          if (words.length === 0) continue;
+          const hits = words.filter((w) => lower.includes(w)).length;
+          if (hits >= Math.ceil(words.length * 0.6)) {
+            node.connections.push({
+              to: other.id,
+              type: "mentions",
+              description: `Mentions ${other.title}`,
+              source: "inferred"
+            });
+            seen.add(other.id);
+          }
+        }
+      }
+    }
+  }
+}
+async function loadNodeMap(nodemapRaw, readFile, listFiles, listDirectory) {
+  const map = yaml.parse(nodemapRaw);
+  if (!map?.nodes?.length) return [];
+  const allNodes = [];
+  const entryNodeIds = /* @__PURE__ */ new Map();
+  for (const entry of map.nodes) {
+    let nodes = [];
+    if (entry.file) {
+      nodes = await processSingleFile(entry, readFile);
+    } else if (entry.files) {
+      nodes = await processMerge(entry, readFile);
+    } else if (entry.glob && entry.each === "file") {
+      nodes = await processGlob(entry, readFile, listFiles);
+    } else if (entry.directory) {
+      nodes = await processDirectory(entry, listDirectory);
+    }
+    entryNodeIds.set(entry.id, nodes.map((n) => n.id));
+    allNodes.push(...nodes);
+  }
+  deriveConnections(allNodes, map.nodes, entryNodeIds);
+  return allNodes;
+}
+async function collectNodemapData(nodemapRaw, tree, readFile, listDirectory) {
+  let map;
+  try {
+    map = yaml.parse(nodemapRaw);
+  } catch {
+    return { nodemapFiles: {}, nodemapDirs: {} };
+  }
+  if (!map?.nodes?.length) return { nodemapFiles: {}, nodemapDirs: {} };
+  const nodemapFiles = {};
+  const nodemapDirs = {};
+  const expandGlob = (pattern, exclude) => {
+    const regex = globToRegex(pattern);
+    let matches = tree.filter((e) => e.type === "blob" && regex.test(e.path)).map((e) => e.path);
+    if (exclude?.length) {
+      matches = matches.filter((p) => !matchesAnyGlob(p, exclude));
+    }
+    return matches;
+  };
+  for (const entry of map.nodes) {
+    if (entry.file) {
+      const content = await readFile(entry.file);
+      if (content !== null) nodemapFiles[entry.file] = content;
+    }
+    if (entry.files) {
+      for (const f of entry.files) {
+        const content = await readFile(f);
+        if (content !== null) nodemapFiles[f] = content;
+      }
+    }
+    if (entry.glob && entry.each === "file") {
+      for (const match of expandGlob(entry.glob, entry.exclude)) {
+        const content = await readFile(match);
+        if (content !== null) nodemapFiles[match] = content;
+      }
+    }
+    if (entry.directory) {
+      nodemapDirs[entry.directory] = await listDirectory(entry.directory);
+    }
+  }
+  return { nodemapFiles, nodemapDirs };
+}
+
+// src/structured-content.ts
+var DEFAULT_STRUCTURED_CONTENT_PATH = "content-model";
+function normalizeRepoRelativeDir(raw) {
+  if (typeof raw !== "string") return null;
+  let value = raw.trim().replace(/\\/g, "/");
+  while (value.startsWith("./")) value = value.slice(2);
+  value = value.replace(/\/+$/g, "");
+  if (!value || /^[a-zA-Z]:\//.test(value) || value.startsWith("/") || value.includes("://") || value === ".." || value.startsWith("../") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    return null;
+  }
+  return value;
+}
+function resolveStructuredContentPath(config, env) {
+  const engineEnv = env ?? {};
+  const envValue = engineEnv.VITE_KB_STRUCTURED_CONTENT_PATH ?? engineEnv.VITE_KB_CONTENT_MODEL_PATH;
+  const normalizedEnv = normalizeRepoRelativeDir(envValue);
+  if (normalizedEnv) return normalizedEnv;
+  const cfg = config;
+  const configured = cfg.structuredContent?.path ?? cfg.contentModel?.path;
+  const normalizedConfig = normalizeRepoRelativeDir(configured);
+  return normalizedConfig ?? DEFAULT_STRUCTURED_CONTENT_PATH;
+}
+function hasExplicitStructuredContentPath(config, env) {
+  const engineEnv = env ?? {};
+  const envValue = engineEnv.VITE_KB_STRUCTURED_CONTENT_PATH ?? engineEnv.VITE_KB_CONTENT_MODEL_PATH;
+  if (normalizeRepoRelativeDir(envValue)) return true;
+  const cfg = config;
+  const configured = cfg.structuredContent?.path ?? cfg.contentModel?.path;
+  return normalizeRepoRelativeDir(configured) !== null;
+}
+
+export { DEFAULT_STRUCTURED_CONTENT_PATH, collectNodemapData, extractImportPaths, hasExplicitStructuredContentPath, loadNodeMap, normalizeRepoRelativeDir, resolveImportPath, resolveStructuredContentPath };

package/dist/chunk-YTMIERYM.js

@@ -0,0 +1,67 @@
+import { DEFAULT_TRANSFORMS, applyTransforms, buildGraph } from './chunk-DJ2DBEEK.js';
+import { extractClusters } from './chunk-FJ4GTN4U.js';
+import { hashProviderResultPrefix, GRAPH_STORE_DERIVATION_VERSION } from './chunk-HXAS3BSD.js';
+import { GRAPH_STORE_CACHE_KEY_VERSION, GRAPH_STORE_API_VERSION } from '@anokye-labs/kbexplorer-core';
+
+async function orchestrateWithProviderResultStore(registry, config, ctx, store, buildCacheKey, transforms = DEFAULT_TRANSFORMS) {
+  const providers = registry.getExecutionOrder();
+  let allNodes = [];
+  let previousContentHash;
+  for (const provider of providers) {
+    const key = await buildCacheKey(provider.id, previousContentHash);
+    const cached = await store.get(key);
+    if (cached) {
+      allNodes = cloneProviderResult(
+        validateProviderResult(cached.value, `cached graph store entry for ${provider.id}`)
+      ).nodes;
+      previousContentHash = await hashProviderResultPrefix(provider.id, allNodes);
+      continue;
+    }
+    const result = await provider.resolve(config, allNodes);
+    allNodes.push(...result.nodes);
+    const value = cloneProviderResult({ nodes: allNodes, edges: [] });
+    await store.put({
+      key,
+      value,
+      dependencies: [dependencyFor(key, previousContentHash)],
+      metadata: {
+        graphStoreApiVersion: GRAPH_STORE_API_VERSION,
+        graphStoreCacheKeyVersion: GRAPH_STORE_CACHE_KEY_VERSION,
+        graphStoreDerivationVersion: GRAPH_STORE_DERIVATION_VERSION,
+        providerId: provider.id
+      }
+    });
+    previousContentHash = await hashProviderResultPrefix(provider.id, allNodes);
+  }
+  const transformed = applyTransforms(allNodes, ctx, transforms);
+  return buildGraph(transformed, extractClusters(transformed, config));
+}
+function dependencyFor(key, previousContentHash) {
+  return {
+    href: previousContentHash ? `${key.sourceId ?? key.providerId}#previous` : key.sourceId ?? key.providerId,
+    contentHash: previousContentHash ?? key.contentHash,
+    ...key.sourceId !== void 0 ? { sourceId: key.sourceId } : {}
+  };
+}
+function cloneProviderResult(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function validateProviderResult(value, label) {
+  if (!value || !Array.isArray(value.nodes) || !Array.isArray(value.edges)) {
+    throw new Error(`Invalid ${label}: expected ProviderResult with nodes and edges arrays.`);
+  }
+  for (const node of value.nodes) {
+    validateNode(node, label);
+  }
+  return value;
+}
+function validateNode(node, label) {
+  if (!node || typeof node.id !== "string" || typeof node.title !== "string" || typeof node.cluster !== "string" || !Array.isArray(node.connections)) {
+    throw new Error(`Invalid ${label}: malformed KBNode.`);
+  }
+}
+
+export { orchestrateWithProviderResultStore };

package/dist/github-api-source-KV5HZARH.js

@@ -0,0 +1,4 @@
+export { GitHubApiSource } from './chunk-NOGBKE7C.js';
+import './chunk-XVI6CBSX.js';
+import './chunk-FJ4GTN4U.js';
+import './chunk-JNQVSNLC.js';