@anokye-labs/kbexplorer-engine 0.1.0

package/dist/chunk-ASLGNOYV.js

@@ -0,0 +1,220 @@
+import { assignIdentity } from './chunk-JNQVSNLC.js';
+import { checkProviderCompatibility, PROVIDER_API_VERSION } from '@anokye-labs/kbexplorer-core';
+import { isAbsolute, resolve, sep } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/providers/wikipedia-provider.ts
+var WikipediaProvider = class {
+  id;
+  name;
+  dependencies = [];
+  articles;
+  defaultCluster;
+  constructor(config) {
+    this.id = `wikipedia-${config.name?.replace(/\s+/g, "-").toLowerCase() ?? "default"}`;
+    this.name = config.name ?? "Wikipedia";
+    this.defaultCluster = config.cluster ?? "reference";
+    this.articles = config.options?.articles ?? [];
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = [];
+    const fetches = this.articles.map(async (article) => {
+      try {
+        const encoded = encodeURIComponent(article.title.replace(/\s+/g, "_"));
+        const resp = await fetch(`https://en.wikipedia.org/api/rest_v1/page/summary/${encoded}`);
+        if (!resp.ok) return null;
+        const data = await resp.json();
+        return { article, data };
+      } catch {
+        return null;
+      }
+    });
+    const results = await Promise.all(fetches);
+    for (const result of results) {
+      if (!result) continue;
+      const { article, data } = result;
+      const nodeId = article.id ?? `wiki-${data.title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+      const connections = (article.connections ?? []).map((to) => ({
+        to,
+        description: `Referenced by ${data.title}`
+      }));
+      const content = `<p>${data.extract_html ?? data.extract}</p>
+<p><a href="${data.content_urls.desktop.page}" target="_blank">Read on Wikipedia \u2192</a></p>`;
+      const rawContent = `${data.extract}
+
+[Read on Wikipedia \u2192](${data.content_urls.desktop.page})`;
+      const node = {
+        id: nodeId,
+        title: data.title,
+        cluster: article.cluster ?? this.defaultCluster,
+        content,
+        rawContent,
+        emoji: "Globe",
+        connections,
+        source: { type: "external", provider: this.id },
+        provider: this.id
+      };
+      const identity = assignIdentity(node);
+      if (identity !== void 0) node.identity = identity;
+      nodes.push(node);
+    }
+    return { nodes, edges: [] };
+  }
+};
+
+// src/providers/orgchart-provider.ts
+var OrgChartProvider = class {
+  id;
+  name;
+  dependencies = [];
+  people;
+  defaultCluster;
+  constructor(config) {
+    this.id = `orgchart-${config.name?.replace(/\s+/g, "-").toLowerCase() ?? "default"}`;
+    this.name = config.name ?? "Org Chart";
+    this.defaultCluster = config.cluster ?? "team";
+    this.people = config.options?.people ?? [];
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = [];
+    for (const person of this.people) {
+      const connections = [];
+      for (const managerId of person.reports ?? []) {
+        connections.push({
+          to: `org-${managerId}`,
+          description: `Reports to`
+        });
+      }
+      for (const target of person.connections ?? []) {
+        connections.push({
+          to: target,
+          description: `Owns`
+        });
+      }
+      const role = person.role ?? "";
+      const content = `<h2>${person.name}</h2><p><strong>${role}</strong></p>`;
+      const rawContent = `## ${person.name}
+
+**${role}**`;
+      const node = {
+        id: `org-${person.id}`,
+        title: person.name,
+        cluster: this.defaultCluster,
+        content,
+        rawContent,
+        emoji: person.emoji ?? "Person",
+        connections,
+        source: { type: "external", provider: this.id },
+        provider: this.id
+      };
+      const identity = assignIdentity(node);
+      if (identity !== void 0) node.identity = identity;
+      nodes.push(node);
+    }
+    return { nodes, edges: [] };
+  }
+};
+
+// src/plugin-loader.ts
+var HOST_CONTRACT = {
+  apiVersion: PROVIDER_API_VERSION,
+  capabilities: ["graph:nodes", "graph:edges"]
+};
+function resolveImportBaseUrl(importBaseUrl) {
+  if (importBaseUrl instanceof URL) {
+    const normalizedBaseUrl = new URL(importBaseUrl.href);
+    if (normalizedBaseUrl.protocol === "file:" && !normalizedBaseUrl.pathname.endsWith("/")) {
+      normalizedBaseUrl.pathname = `${normalizedBaseUrl.pathname}/`;
+    }
+    return normalizedBaseUrl;
+  }
+  if (importBaseUrl.startsWith("file:")) {
+    const normalizedBaseUrl = new URL(importBaseUrl);
+    if (normalizedBaseUrl.protocol === "file:" && !normalizedBaseUrl.pathname.endsWith("/")) {
+      normalizedBaseUrl.pathname = `${normalizedBaseUrl.pathname}/`;
+    }
+    return normalizedBaseUrl;
+  }
+  const absolutePath = isAbsolute(importBaseUrl) ? importBaseUrl : resolve(importBaseUrl);
+  const normalizedPath = absolutePath.endsWith(sep) ? absolutePath : `${absolutePath}${sep}`;
+  return pathToFileURL(normalizedPath);
+}
+function classifySpecifier(specifier) {
+  if (specifier.startsWith("./") || specifier.startsWith("../")) return "local";
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(specifier) || specifier.startsWith("/") || specifier.startsWith("\\")) {
+    return "rejected";
+  }
+  return "bare";
+}
+function adaptCoreProvider(provider) {
+  return {
+    id: provider.id,
+    name: provider.name,
+    dependencies: provider.dependencies ?? [],
+    async resolve(config, existingNodes) {
+      const { nodes, edges } = await provider.resolve({ config, existingNodes });
+      return { nodes, edges };
+    }
+  };
+}
+async function loadModuleProvider(config, options) {
+  const specifier = config.module;
+  if (!specifier) return null;
+  if (classifySpecifier(specifier) === "rejected") {
+    console.warn(
+      `[kbexplorer] Provider module "${specifier}" is not a local (\`./\`, \`../\`) or bare npm package specifier; absolute/URL specifiers are not supported (no remote code execution). Skipping.`
+    );
+    return null;
+  }
+  const importTarget = classifySpecifier(specifier) === "local" && options?.importBaseUrl ? new URL(specifier, resolveImportBaseUrl(options.importBaseUrl)).href : specifier;
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      importTarget
+    );
+    const factory = mod.default;
+    if (typeof factory !== "function") {
+      console.warn(
+        `[kbexplorer] Provider module "${specifier}" has no default-export factory (use defineProvider()).`
+      );
+      return null;
+    }
+    const compat = checkProviderCompatibility(mod, HOST_CONTRACT);
+    if (!compat.compatible) {
+      console.warn(
+        `[kbexplorer] Provider module "${specifier}" ${compat.reason}. Skipping.`
+      );
+      return null;
+    }
+    return adaptCoreProvider(factory(config));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`[kbexplorer] Failed to load provider module "${specifier}": ${message}`);
+    return null;
+  }
+}
+async function loadExternalProviders(configs, options) {
+  const providers = [];
+  for (const config of configs) {
+    if (config.module) {
+      const provider = await loadModuleProvider(config, options);
+      if (provider) providers.push(provider);
+      continue;
+    }
+    switch (config.type) {
+      case "wikipedia":
+        providers.push(new WikipediaProvider(config));
+        break;
+      case "orgchart":
+        providers.push(new OrgChartProvider(config));
+        break;
+      default:
+        console.warn(
+          `[kbexplorer] Provider "${config.name ?? config.type}" is not a built-in type and declares no "module" specifier; skipping.`
+        );
+    }
+  }
+  return providers;
+}
+
+export { OrgChartProvider, WikipediaProvider, loadExternalProviders };

package/dist/chunk-BA526FDQ.js

@@ -0,0 +1,16 @@
+// src/store/config.ts
+function resolveGraphStoreOptions(env) {
+  const engineEnv = env ?? {};
+  const raw = engineEnv.VITE_KB_GRAPH_STORE;
+  const value = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+  if (!value || value === "off" || value === "false" || value === "0") {
+    return { mode: "off" };
+  }
+  if (value === "sqlite") return { mode: "sqlite" };
+  throw new Error(`Unsupported VITE_KB_GRAPH_STORE value: ${String(raw)}`);
+}
+function isGraphStoreEnabled(env) {
+  return resolveGraphStoreOptions(env).mode === "sqlite";
+}
+
+export { isGraphStoreEnabled, resolveGraphStoreOptions };

package/dist/chunk-DJ2DBEEK.js

@@ -0,0 +1,424 @@
+import { filterAccessWithheld, extractIssueRefs, renderSafeMarkdown, splitIntoSections } from './chunk-FJ4GTN4U.js';
+
+// src/edge-weights.ts
+var EDGE_TYPE_WEIGHTS = {
+  contains: 5,
+  derived_from: 3,
+  imports: 2,
+  references: 2,
+  frontmatter: 1.5,
+  cross_references: 1.5,
+  modifies: 1,
+  closes: 2,
+  mentions: 0.5,
+  related: 0.3
+};
+function getEdgeWeight(type) {
+  return EDGE_TYPE_WEIGHTS[type ?? "related"] ?? 1;
+}
+
+// src/node-types/registry.ts
+var registry = /* @__PURE__ */ new Map();
+var BUILT_IN_NODE_TYPES = [
+  { id: "authored", layer: "content", label: "Authored" },
+  { id: "readme", layer: "content", label: "README" },
+  { id: "derived", layer: "content", label: "Derived" },
+  { id: "section", layer: "content", label: "Section" },
+  { id: "structured", layer: "content", label: "Structured" },
+  { id: "issue", layer: "work", label: "Issue" },
+  { id: "pull_request", layer: "work", label: "Pull Request" },
+  { id: "commit", layer: "work", label: "Commit" },
+  { id: "branch", layer: "work", label: "Branch" },
+  { id: "workflow", layer: "work", label: "Workflow" },
+  { id: "repository", layer: "work", label: "Repository" },
+  { id: "release", layer: "work", label: "Release", cluster: "releases", description: "A GitHub release (tag, name, release notes)." },
+  // Person nodes derived from GitHub activity (#235)
+  { id: "person", layer: "work", label: "Person", cluster: "person", description: "A person derived from GitHub activity or a content-model descriptor." },
+  { id: "file", layer: "file", label: "File" },
+  { id: "external", layer: "file", label: "External" }
+];
+function registerType(def) {
+  registry.set(def.id, def);
+}
+function resolveType(id) {
+  if (!id) return void 0;
+  return registry.get(id);
+}
+function hasType(id) {
+  return registry.has(id);
+}
+function getRegisteredTypes() {
+  return [...registry.values()];
+}
+function registerBuiltInNodeTypes() {
+  for (const def of BUILT_IN_NODE_TYPES) {
+    if (!registry.has(def.id)) registry.set(def.id, def);
+  }
+}
+function resetNodeTypeRegistry() {
+  registry.clear();
+  registerBuiltInNodeTypes();
+}
+function resolveNodeLayer(node) {
+  const byEntity = node.entityType ? registry.get(node.entityType) : void 0;
+  if (byEntity?.layer) return byEntity.layer;
+  const bySource = registry.get(node.source.type);
+  if (bySource?.layer) return bySource.layer;
+  return "file";
+}
+function resolveTypeCluster(node) {
+  const byEntity = node.entityType ? registry.get(node.entityType) : void 0;
+  if (byEntity?.cluster) return byEntity.cluster;
+  return registry.get(node.source.type)?.cluster;
+}
+registerBuiltInNodeTypes();
+
+// src/graph.ts
+function buildGraph(nodes, clusters) {
+  nodes = filterAccessWithheld(nodes);
+  for (const node of nodes) {
+    node.layer = resolveNodeLayer(node);
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const prev = nodeMap.get(n.id);
+    if (prev && (prev.provider ?? "(none)") !== (n.provider ?? "(none)")) {
+      console.warn(
+        `[kbexplorer] cross-provider id collision: "${n.id}" is produced by provider "${prev.provider ?? "(none)"}" and provider "${n.provider ?? "(none)"}" \u2014 edge/related resolution will last-win on the latter. Give one a distinct id.`
+      );
+    }
+    nodeMap.set(n.id, n);
+  }
+  const edges = buildEdges(nodes, nodeMap);
+  const connected = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    connected.add(e.from);
+    connected.add(e.to);
+  }
+  const orphans = nodes.filter((n) => !connected.has(n.id));
+  if (orphans.length > 0) {
+    const degrees = /* @__PURE__ */ new Map();
+    for (const n of nodes) degrees.set(n.id, 0);
+    for (const e of edges) {
+      degrees.set(e.from, (degrees.get(e.from) ?? 0) + 1);
+      degrees.set(e.to, (degrees.get(e.to) ?? 0) + 1);
+    }
+    let hubId = nodes[0]?.id;
+    let hubDeg = 0;
+    for (const [id, deg] of degrees) {
+      if (deg > hubDeg) {
+        hubDeg = deg;
+        hubId = id;
+      }
+    }
+    for (const orphan of orphans) {
+      const sibling = nodes.find((n) => n.id !== orphan.id && n.cluster === orphan.cluster && connected.has(n.id));
+      const targetId = sibling?.id ?? hubId;
+      if (targetId && targetId !== orphan.id) {
+        edges.push({ from: targetId, to: orphan.id, type: "related", description: "Related", source: "inferred", weight: EDGE_TYPE_WEIGHTS.related });
+        connected.add(orphan.id);
+      }
+    }
+  }
+  const related = computeRelated(nodes, edges);
+  return { nodes, edges, clusters, related };
+}
+function buildEdges(nodes, nodeMap) {
+  const edgeSet = /* @__PURE__ */ new Map();
+  const addEdge = (edge) => {
+    const key = edgeKey(edge);
+    if (!edgeSet.has(key)) {
+      edgeSet.set(key, edge);
+    }
+  };
+  for (const node of nodes) {
+    for (const conn of node.connections) {
+      if (nodeMap.has(conn.to)) {
+        const edgeType = conn.type ?? "references";
+        addEdge({
+          from: node.id,
+          to: conn.to,
+          type: edgeType,
+          description: conn.description,
+          source: conn.source ?? "frontmatter",
+          weight: conn.weight ?? getEdgeWeight(edgeType),
+          ...conn.relation ? { relation: conn.relation } : {}
+        });
+      }
+    }
+    if (node.parent && nodeMap.has(node.parent)) {
+      addEdge({
+        from: node.parent,
+        to: node.id,
+        type: "contains",
+        description: "Contains",
+        source: "inferred",
+        weight: EDGE_TYPE_WEIGHTS.contains
+      });
+    }
+  }
+  return [...edgeSet.values()];
+}
+function edgeKey(edge) {
+  return `${edge.from}\0${edge.to}\0${edge.type}\0${edge.relation ?? ""}`;
+}
+function computeRelated(nodes, edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    adj.set(node.id, /* @__PURE__ */ new Map());
+  }
+  for (const edge of edges) {
+    const fwd = adj.get(edge.from);
+    const rev = adj.get(edge.to);
+    if (fwd && (!fwd.has(edge.to) || edge.weight > (fwd.get(edge.to) ?? 0))) {
+      fwd.set(edge.to, edge.weight);
+    }
+    if (rev && (!rev.has(edge.from) || edge.weight > (rev.get(edge.from) ?? 0))) {
+      rev.set(edge.from, edge.weight);
+    }
+  }
+  const degree = /* @__PURE__ */ new Map();
+  for (const [id, neighbors] of adj) {
+    degree.set(id, neighbors.size);
+  }
+  const related = {};
+  for (const [id, neighbors] of adj) {
+    related[id] = [...neighbors.entries()].sort((a, b) => {
+      const weightDiff = b[1] - a[1];
+      if (Math.abs(weightDiff) > 0.01) return weightDiff;
+      return (degree.get(b[0]) ?? 0) - (degree.get(a[0]) ?? 0);
+    }).map(([neighborId]) => neighborId).slice(0, 12);
+  }
+  return related;
+}
+function getNodeDegrees(graph) {
+  const degrees = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    degrees.set(node.id, 0);
+  }
+  for (const edge of graph.edges) {
+    degrees.set(edge.from, (degrees.get(edge.from) ?? 0) + 1);
+    degrees.set(edge.to, (degrees.get(edge.to) ?? 0) + 1);
+  }
+  return degrees;
+}
+function getHubNodeId(graph) {
+  if (graph.nodes.some((n) => n.id === "home")) return "home";
+  if (graph.nodes.some((n) => n.id === "readme")) return "readme";
+  if (graph.nodes.some((n) => n.id === "overview")) return "overview";
+  const degrees = getNodeDegrees(graph);
+  let bestId = null;
+  let bestDeg = -1;
+  for (const [id, deg] of degrees) {
+    if (deg > bestDeg) {
+      bestDeg = deg;
+      bestId = id;
+    }
+  }
+  return bestId;
+}
+function getEdgeDescription(graph, from, to) {
+  return graph.edges.find(
+    (e) => e.from === from && e.to === to || e.from === to && e.to === from
+  )?.description;
+}
+var MAX_VISIBLE_NODES = 40;
+var MAX_VISIBLE_EDGES = 80;
+function trimGraphToLimits(graph, currentNodeId, maxNodes = MAX_VISIBLE_NODES, maxEdges = MAX_VISIBLE_EDGES) {
+  const totalNodes = graph.nodes.length;
+  const totalEdges = graph.edges.length;
+  if (totalNodes <= maxNodes && totalEdges <= maxEdges) {
+    return { graph, trimmed: false, totalNodes, totalEdges };
+  }
+  const degree = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) degree.set(n.id, 0);
+  for (const e of graph.edges) {
+    degree.set(e.from, (degree.get(e.from) ?? 0) + 1);
+    degree.set(e.to, (degree.get(e.to) ?? 0) + 1);
+  }
+  let hubId = null;
+  let hubDeg = -1;
+  for (const [id, d] of degree) {
+    if (d > hubDeg) {
+      hubId = id;
+      hubDeg = d;
+    }
+  }
+  if (graph.nodes.some((n) => n.id === "home")) hubId = "home";
+  else if (graph.nodes.some((n) => n.id === "readme")) hubId = "readme";
+  else if (graph.nodes.some((n) => n.id === "overview")) hubId = "overview";
+  const kept = /* @__PURE__ */ new Set();
+  if (hubId) kept.add(hubId);
+  if (currentNodeId && degree.has(currentNodeId)) kept.add(currentNodeId);
+  if (graph.nodes.some((n) => n.id === "readme")) kept.add("readme");
+  if (currentNodeId) {
+    const neighbors = [];
+    for (const e of graph.edges) {
+      if (e.from === currentNodeId && degree.has(e.to)) neighbors.push({ id: e.to, deg: degree.get(e.to) });
+      if (e.to === currentNodeId && degree.has(e.from)) neighbors.push({ id: e.from, deg: degree.get(e.from) });
+    }
+    neighbors.sort((a, b) => b.deg - a.deg);
+    const neighborBudget = Math.min(Math.floor(maxNodes * 0.3), neighbors.length);
+    for (let i = 0; i < neighborBudget; i++) kept.add(neighbors[i].id);
+  }
+  const clusters = new Set(graph.nodes.map((n) => n.cluster).filter(Boolean));
+  for (const cid of clusters) {
+    if ([...kept].some((id) => graph.nodes.find((n) => n.id === id)?.cluster === cid)) continue;
+    const best = graph.nodes.filter((n) => n.cluster === cid).sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0))[0];
+    if (best && kept.size < maxNodes) kept.add(best.id);
+  }
+  const externalNodes = graph.nodes.filter((n) => n.source.type === "external");
+  if (externalNodes.length > 0) {
+    const externalBudget = Math.max(2, Math.floor(maxNodes * 0.2));
+    const externalToAdd = externalNodes.filter((n) => !kept.has(n.id)).sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0));
+    for (const n of externalToAdd) {
+      if (kept.size >= maxNodes) break;
+      const externalKept = [...kept].filter(
+        (id) => graph.nodes.find((nd) => nd.id === id)?.source.type === "external"
+      ).length;
+      if (externalKept >= externalBudget) break;
+      kept.add(n.id);
+    }
+  }
+  const byDegree = [...graph.nodes].sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0));
+  for (const n of byDegree) {
+    if (kept.size >= maxNodes) break;
+    kept.add(n.id);
+  }
+  const nodes = graph.nodes.filter((n) => kept.has(n.id));
+  const edges = graph.edges.filter((e) => kept.has(e.from) && kept.has(e.to));
+  const nodeIdSet = new Set(nodes.map((n) => n.id));
+  const related = {};
+  for (const id of nodeIdSet) {
+    const r = (graph.related[id] ?? []).filter((rid) => nodeIdSet.has(rid));
+    if (r.length > 0) related[id] = r;
+  }
+  return {
+    graph: { nodes, edges, clusters: graph.clusters, related },
+    trimmed: true,
+    totalNodes,
+    totalEdges
+  };
+}
+
+// src/transforms.ts
+function selectIssueNodes(nodes) {
+  return nodes.filter((n) => n.source.type === "issue");
+}
+function selectDirNodes(nodes) {
+  return nodes.filter((n) => n.provider === "files");
+}
+var readmeTransform = {
+  name: "readme",
+  apply(nodes, ctx) {
+    if (!ctx.readme) return nodes;
+    const readme = ctx.readme;
+    const issueNodes = selectIssueNodes(nodes);
+    const dirNodes = selectDirNodes(nodes);
+    const readmeConns = [];
+    const lower = readme.toLowerCase();
+    const issueRefs = extractIssueRefs(readme);
+    for (const num of issueRefs) {
+      const id = `issue-${num}`;
+      if (issueNodes.some((n) => n.id === id)) {
+        readmeConns.push({ to: id, description: `References #${num}` });
+      }
+    }
+    for (const node of issueNodes) {
+      if (readmeConns.some((c) => c.to === node.id)) continue;
+      const titleWords = node.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      if (titleWords.length === 0) continue;
+      const matchCount = titleWords.filter((w) => lower.includes(w)).length;
+      if (matchCount >= Math.ceil(titleWords.length * 0.6)) {
+        readmeConns.push({ to: node.id, description: "Mentions" });
+      }
+    }
+    for (const dir of dirNodes) {
+      const dirName = dir.title.replace(/\/$/, "");
+      if (lower.includes(`${dirName}/`) || lower.includes(`\`${dirName}\``)) {
+        readmeConns.push({ to: dir.id, description: `References ${dirName}/` });
+      }
+    }
+    readmeConns.push({ to: "repo-root", description: "Documents" });
+    const readmeConnectedTo = new Set(readmeConns.map((c) => c.to));
+    for (const m of readme.matchAll(/\[([^\]]+)\]\(([^)]+)\)/g)) {
+      const target = m[2].trim();
+      if (target.startsWith("http") || target.startsWith("#") || target.startsWith("/")) continue;
+      if (target.match(/\.(png|jpg|jpeg|gif|svg|webp|md)$/i)) continue;
+      if (readmeConnectedTo.has(target)) continue;
+      readmeConns.push({ to: target, description: m[1] });
+      readmeConnectedTo.add(target);
+    }
+    const html = renderSafeMarkdown(readme);
+    nodes.push({
+      id: "readme",
+      title: "README",
+      cluster: "docs",
+      content: html,
+      rawContent: readme,
+      emoji: "Document",
+      parent: "repo-root",
+      identity: "urn:content:readme",
+      connections: readmeConns,
+      source: { type: "readme" }
+    });
+    return nodes;
+  }
+};
+var issueDirectoryLinkTransform = {
+  name: "issue-directory-link",
+  apply(nodes) {
+    const issueNodes = selectIssueNodes(nodes);
+    const dirNodes = selectDirNodes(nodes);
+    const dirNames = dirNodes.map((d) => d.title.replace(/\/$/, ""));
+    for (const node of issueNodes) {
+      for (let i = 0; i < dirNames.length; i++) {
+        const dir = dirNames[i];
+        if (node.rawContent && (node.rawContent.includes(`${dir}/`) || node.rawContent.includes(`\`${dir}\``) || node.rawContent.toLowerCase().includes(dir.toLowerCase()))) {
+          node.connections.push({ to: dirNodes[i].id, description: `References ${dir}/` });
+        }
+      }
+    }
+    return nodes;
+  }
+};
+var issueSplitTransform = {
+  name: "issue-split",
+  apply(nodes) {
+    const issueNodes = selectIssueNodes(nodes);
+    const dirNodes = selectDirNodes(nodes);
+    const expandedIssues = [];
+    for (const node of issueNodes) {
+      const sectionNodes = splitIntoSections(
+        node.id,
+        node.title,
+        node.rawContent,
+        node.cluster,
+        node.emoji ?? "Pin",
+        node.source,
+        [...issueNodes, ...dirNodes]
+      );
+      if (sectionNodes.length > 0) {
+        const idx = nodes.indexOf(node);
+        if (idx >= 0) nodes.splice(idx, 1);
+        expandedIssues.push(...sectionNodes);
+      }
+    }
+    nodes.push(...expandedIssues);
+    return nodes;
+  }
+};
+var DEFAULT_TRANSFORMS = [
+  readmeTransform,
+  issueDirectoryLinkTransform,
+  issueSplitTransform
+];
+function applyTransforms(nodes, ctx, transforms = DEFAULT_TRANSFORMS) {
+  let current = nodes;
+  for (const transform of transforms) {
+    current = transform.apply(current, ctx);
+  }
+  return current;
+}
+
+export { DEFAULT_TRANSFORMS, EDGE_TYPE_WEIGHTS, MAX_VISIBLE_EDGES, MAX_VISIBLE_NODES, applyTransforms, buildGraph, getEdgeDescription, getEdgeWeight, getHubNodeId, getNodeDegrees, getRegisteredTypes, hasType, issueDirectoryLinkTransform, issueSplitTransform, readmeTransform, registerBuiltInNodeTypes, registerType, resetNodeTypeRegistry, resolveNodeLayer, resolveType, resolveTypeCluster, trimGraphToLimits };