openlore 2.0.0

package/src/viewer/utils/graph-helpers.js

@@ -0,0 +1,303 @@
+import { CLUSTER_PALETTE } from './constants.js';
+export { CLUSTER_PALETTE } from './constants.js';
+export { CLUSTER_PALETTE_LIGHT } from './constants.js';
+
+export function parseSpecRequirements(mdText) {
+  const reqs = {};
+  if (!mdText) return reqs;
+  const sections = mdText.split(/^#{3,4}\s+Requirement:\s*/m);
+  for (let i = 1; i < sections.length; i++) {
+    const lines = sections[i].split('\n');
+    const rawTitle = lines[0].trim();
+    if (!rawTitle) continue;
+    const body = lines.slice(1).join('\n').trim();
+    reqs[rawTitle] = { title: rawTitle, body };
+  }
+  return reqs;
+}
+
+export function buildMappingIndex(mappingJson) {
+  const index = {};
+  if (!mappingJson?.mappings) return index;
+  for (const m of mappingJson.mappings) {
+    for (const fn of m.functions || []) {
+      const key = fn.file.replace(/\\/g, '/');
+      if (!index[key]) index[key] = [];
+      index[key].push({
+        requirement: m.requirement,
+        service: m.service,
+        domain: m.domain,
+        specFile: m.specFile,
+        fnName: fn.name,
+        fnLine: fn.line,
+        confidence: fn.confidence,
+      });
+    }
+  }
+  return index;
+}
+
+export function normalizePath(p) {
+  return (p || '').replace(/\\/g, '/').replace(/^\/+/, '');
+}
+
+export function parseGraph(raw, palette = CLUSTER_PALETTE) {
+  const clusterByNode = {};
+  (raw.clusters || []).forEach((cl, ci) => {
+    cl.files.forEach((fid) => {
+      clusterByNode[fid] = {
+        name: cl.name,
+        index: ci,
+        id: cl.id,
+        color: palette[ci % palette.length],
+      };
+    });
+  });
+
+  const nodes = (raw.nodes || []).map((n) => ({
+    id: n.id,
+    label: n.file.name,
+    path: n.file.path,
+    ext: n.file.extension,
+    dir: n.file.directory,
+    lines: n.file.lines,
+    size: n.file.size,
+    isEntry: n.isEntryPoint,
+    isConfig: n.isConfig,
+    isTest: n.isTest,
+    score: n.importanceScore ?? 0,
+    cluster: clusterByNode[n.id] || { name: '?', index: 0, id: 'unknown', color: '#555' },
+    exports: n.exports || [],
+    tags: n.tags || [],
+    metrics: n.metrics || {},
+    refactor: null,
+  }));
+
+  const edges = (raw.edges || []).map((e) => ({
+    id: `${e.source}->${e.target}`,
+    source: e.source,
+    target: e.target,
+    isType: e.isTypeOnly || false,
+    isCall: e.isCallEdge || false,
+    importedNames: e.importedNames || [],
+  }));
+
+  const clusters = (raw.clusters || []).map((cl, ci) => ({
+    id: cl.id,
+    name: cl.name,
+    files: cl.files,
+    color: palette[ci % palette.length],
+  }));
+
+  return {
+    nodes,
+    edges,
+    clusters,
+    structuralClusters: raw.structuralClusters || clusters.filter(c => c.internalEdges > 0),
+    directoryClusters: raw.directoryClusters || [],
+    statistics: raw.statistics || {},
+    rankings: raw.rankings || {},
+  };
+}
+
+export function enrichGraphWithRefactors(graph, refReport) {
+  if (!graph || !refReport || !refReport.priorities) return graph;
+
+  const byFile = new Map();
+  refReport.priorities.forEach((entry) => {
+    const list = byFile.get(entry.file) || [];
+    list.push(entry);
+    byFile.set(entry.file, list);
+  });
+
+  const nodes = graph.nodes.map((n) => {
+    const entries = byFile.get(n.path) || [];
+    if (!entries.length) return { ...n, refactor: null };
+
+    let maxPriority = 0;
+    const issuesSet = new Set();
+    entries.forEach((e) => {
+      if (typeof e.priorityScore === 'number') {
+        maxPriority = Math.max(maxPriority, e.priorityScore);
+      }
+      (e.issues || []).forEach((iss) => issuesSet.add(iss));
+    });
+
+    return {
+      ...n,
+      refactor: {
+        functions: entries.length,
+        maxPriority,
+        issues: Array.from(issuesSet),
+      },
+    };
+  });
+
+  return {
+    ...graph,
+    nodes,
+    refactorStats: refReport.stats || null,
+  };
+}
+
+export function computeBlast(edges, nodeId) {
+  const affected = new Set();
+  const q = [nodeId];
+  while (q.length) {
+    const cur = q.shift();
+    edges.forEach((e) => {
+      if (e.source === cur && !affected.has(e.target)) {
+        affected.add(e.target);
+        q.push(e.target);
+      }
+    });
+  }
+  return [...affected];
+}
+
+export function computeLayout(nodes, edges, W = 900, H = 540) {
+  if (!nodes.length) return {};
+  const pos = {};
+
+  const byCluster = {};
+  nodes.forEach((n) => {
+    if (!byCluster[n.cluster.id]) byCluster[n.cluster.id] = [];
+    byCluster[n.cluster.id].push(n.id);
+  });
+  const clIds = Object.keys(byCluster);
+  clIds.forEach((cid, ci) => {
+    const angle = (ci / clIds.length) * Math.PI * 2 - Math.PI / 2;
+    const cx = W / 2 + Math.cos(angle) * W * 0.33;
+    const cy = H / 2 + Math.sin(angle) * H * 0.3;
+    byCluster[cid].forEach((nid, mi) => {
+      const a2 = (mi / Math.max(byCluster[cid].length, 1)) * Math.PI * 2;
+      const r = Math.min(60, 13 * Math.sqrt(byCluster[cid].length));
+      pos[nid] = { x: cx + Math.cos(a2) * r, y: cy + Math.sin(a2) * r };
+    });
+  });
+
+  const k = 55;
+  for (let iter = 0; iter < 80; iter++) {
+    const disp = {};
+    nodes.forEach((n) => {
+      disp[n.id] = { x: 0, y: 0 };
+    });
+
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const a = nodes[i],
+          b = nodes[j];
+        const dx = pos[a.id].x - pos[b.id].x;
+        const dy = pos[a.id].y - pos[b.id].y;
+        const d = Math.max(Math.sqrt(dx * dx + dy * dy), 0.01);
+        const f = (k * k) / d;
+        disp[a.id].x += (dx / d) * f;
+        disp[a.id].y += (dy / d) * f;
+        disp[b.id].x -= (dx / d) * f;
+        disp[b.id].y -= (dy / d) * f;
+      }
+    }
+
+    edges.forEach((e) => {
+      if (!pos[e.source] || !pos[e.target]) return;
+      const dx = pos[e.source].x - pos[e.target].x;
+      const dy = pos[e.source].y - pos[e.target].y;
+      const d = Math.max(Math.sqrt(dx * dx + dy * dy), 0.01);
+      const f = (d * d) / (k * (e.isType ? 2 : 1));
+      disp[e.source].x -= (dx / d) * f;
+      disp[e.source].y -= (dy / d) * f;
+      disp[e.target].x += (dx / d) * f;
+      disp[e.target].y += (dy / d) * f;
+    });
+
+    // Gravity toward center
+    const gravity = 0.04;
+    nodes.forEach((n) => {
+      disp[n.id].x += (W / 2 - pos[n.id].x) * gravity;
+      disp[n.id].y += (H / 2 - pos[n.id].y) * gravity;
+    });
+
+    const temp = k * Math.max(0.05, 1 - iter / 80) * 0.5;
+    nodes.forEach((n) => {
+      const d = Math.sqrt(disp[n.id].x ** 2 + disp[n.id].y ** 2);
+      if (d > 0) {
+        pos[n.id].x += (disp[n.id].x / d) * Math.min(d, temp);
+        pos[n.id].y += (disp[n.id].y / d) * Math.min(d, temp);
+      }
+      pos[n.id].x = Math.max(36, Math.min(W - 36, pos[n.id].x));
+      pos[n.id].y = Math.max(36, Math.min(H - 36, pos[n.id].y));
+    });
+  }
+  return pos;
+}
+
+export function computeClusterLayout(clusters, W = 900, H = 540) {
+  const pos = {};
+  clusters.forEach((cl, i) => {
+    const angle = (i / clusters.length) * Math.PI * 2 - Math.PI / 2;
+    pos[cl.id] = {
+      x: W / 2 + Math.cos(angle) * W * 0.34,
+      y: H / 2 + Math.sin(angle) * H * 0.32,
+    };
+  });
+  return pos;
+}
+
+export function inferClusterRole(entryCount, hubCount, fileCount) {
+  if (entryCount > fileCount * 0.5) return 'entry_layer';
+  if (hubCount > 0 && entryCount > 0) return 'orchestrator';
+  if (hubCount > 0) return 'core_utilities';
+  if (entryCount > 0) return 'api_layer';
+  return 'internal';
+}
+
+export function computeArchOverview(graph, llmCtx) {
+  if (!graph) return null;
+
+  const hubFiles = new Set((llmCtx?.callGraph?.hubFunctions ?? []).map(h => h.filePath));
+  const entryFiles = new Set((llmCtx?.callGraph?.entryPoints ?? []).map(e => e.filePath));
+
+  const clusterOfNode = {};
+  (graph.nodes ?? []).forEach(n => {
+    if (n.cluster?.id) clusterOfNode[n.id] = n.cluster.id;
+    const rel = n.path?.replace(/^\/+/, '') ?? '';
+    if (rel && n.cluster?.id) clusterOfNode[rel] = n.cluster.id;
+  });
+
+  const clusterEdges = {};
+  (graph.edges ?? []).forEach(e => {
+    const from = clusterOfNode[e.source];
+    const to = clusterOfNode[e.target];
+    if (from && to && from !== to) {
+      if (!clusterEdges[from]) clusterEdges[from] = new Set();
+      clusterEdges[from].add(to);
+    }
+  });
+
+  const clusters = (graph.clusters ?? []).map(cl => {
+    const clNodes = (graph.nodes ?? []).filter(n => n.cluster?.id === cl.id);
+    const relPaths = clNodes.map(n => n.path?.replace(/^\/+/, '') ?? '');
+    const hubCount = relPaths.filter(p => hubFiles.has(p)).length;
+    const entryCount = relPaths.filter(p => entryFiles.has(p)).length;
+    const role = inferClusterRole(entryCount, hubCount, clNodes.length || cl.files?.length || 1);
+    const dependsOn = [...(clusterEdges[cl.id] ?? [])];
+    const keyFiles = relPaths.filter(p => hubFiles.has(p) || entryFiles.has(p)).slice(0, 5);
+    return { id: cl.id, name: cl.name ?? cl.id, fileCount: clNodes.length || cl.files?.length || 0, role, entryPointCount: entryCount, hubCount, dependsOn, keyFiles, color: cl.color };
+  }).sort((a, b) => b.fileCount - a.fileCount);
+
+  const globalEntryPoints = (llmCtx?.callGraph?.entryPoints ?? []).slice(0, 20).map(n => ({ name: n.name, file: n.filePath, language: n.language }));
+  const criticalHubs = (llmCtx?.callGraph?.hubFunctions ?? []).slice(0, 10).map(n => ({ name: n.name, file: n.filePath, fanIn: n.fanIn, fanOut: n.fanOut }));
+
+  return {
+    summary: {
+      totalFiles: graph.statistics?.nodeCount ?? (graph.nodes?.length ?? 0),
+      totalClusters: clusters.length,
+      totalEdges: graph.statistics?.edgeCount ?? (graph.edges?.length ?? 0),
+      cycles: graph.statistics?.cycleCount ?? 0,
+      layerViolations: llmCtx?.callGraph?.layerViolations?.length ?? 0,
+    },
+    clusters,
+    globalEntryPoints,
+    criticalHubs,
+  };
+}

package/src/viewer/utils/graph-helpers.test.ts

@@ -0,0 +1,39 @@
+import { parseGraph } from './graph-helpers.js';
+
+describe('parseGraph', () => {
+  it('should parse structuralClusters and directoryClusters from raw data', () => {
+    const raw = {
+      nodes: [],
+      edges: [],
+      clusters: [],
+      structuralClusters: [
+        { id: 'cluster1', name: 'Structural Cluster 1', files: ['file1.js'], color: '#ff0000' },
+      ],
+      directoryClusters: [
+        { id: 'dir1', name: 'Directory Cluster 1', files: ['dir/file.js'], color: '#00ff00' },
+      ],
+      statistics: {},
+      rankings: {},
+    };
+
+    const result = parseGraph(raw);
+
+    expect(result.structuralClusters).toEqual(raw.structuralClusters);
+    expect(result.directoryClusters).toEqual(raw.directoryClusters);
+  });
+
+  it('should provide empty arrays for missing structuralClusters and directoryClusters', () => {
+    const raw = {
+      nodes: [],
+      edges: [],
+      clusters: [],
+      statistics: {},
+      rankings: {},
+    };
+
+    const result = parseGraph(raw);
+
+    expect(result.structuralClusters).toEqual([]);
+    expect(result.directoryClusters).toEqual([]);
+  });
+});

package/src/viewer/utils/themes.js

@@ -0,0 +1,206 @@
+/**
+ * Viewer themes — each theme is a map of CSS custom properties.
+ *
+ * The root <div> of InteractiveGraphViewer applies `theme.vars` as inline style,
+ * making all CSS variables available to every descendant via `var(--xxx)`.
+ */
+
+export const THEMES = {
+  space: {
+    label: '⬡ space',
+    vars: {
+      '--lc-cyan':         '#3ecfcf',
+      '--lc-yellow':       '#f7c76a',
+      '--lc-green':        '#4ade80',
+      '--lc-orange':       '#f97316',
+      '--lc-purple':       '#7c6af7',
+      '--lc-red':          '#f77c6a',
+      '--lc-pink':         '#f76ac8',
+      '--bg-base':         '#07091a',
+      '--bg-panel':        '#080a1c',
+      '--bg-raised':       '#0e1028',
+      '--bg-input':        '#0d0f22',
+      '--bg-hover':        '#131630',
+      '--bg-select':       '#181b38',
+      '--bg-deep':         '#080b1e',
+      '--bg-node':         '#0b0d1e',
+      '--bd-faint':        '#0f1224',
+      '--bd-muted':        '#1a1f38',
+      '--bd-dim':          '#0e1025',
+      '--bd-edge':         '#181c36',
+      '--tx-primary':      '#c8cde8',
+      '--tx-secondary':    '#8890b0',
+      '--tx-bright':       '#e0e4f0',
+      '--tx-muted':        '#6a70a0',
+      '--tx-dim':          '#3a4060',
+      '--tx-faint':        '#2a2f4a',
+      '--tx-ghost':        '#3a3f5c',
+      '--tx-node':         '#5a6090',
+      '--tx-node-sel':     '#ffffff',
+      '--ac-primary':      '#7c6af7',
+      '--ac-teal':         '#3ecfcf',
+      '--ac-edge-type':    '#252a4a',
+      '--ac-arrow':        '#1e2340',
+      '--ac-cluster-arr':  '#2a3060',
+    },
+  },
+
+  terminal: {
+    label: '▶ terminal',
+    vars: {
+      '--lc-cyan':         '#00d4aa',
+      '--lc-yellow':       '#c8e050',
+      '--lc-green':        '#4ade80',
+      '--lc-orange':       '#f0a040',
+      '--lc-purple':       '#90d0ff',
+      '--lc-red':          '#f07070',
+      '--lc-pink':         '#d080c0',
+      '--bg-base':         '#010d01',
+      '--bg-panel':        '#020e02',
+      '--bg-raised':       '#061206',
+      '--bg-input':        '#041004',
+      '--bg-hover':        '#0a1a0a',
+      '--bg-select':       '#0d200d',
+      '--bg-deep':         '#030e03',
+      '--bg-node':         '#040f04',
+      '--bd-faint':        '#071807',
+      '--bd-muted':        '#0f2f0f',
+      '--bd-dim':          '#061806',
+      '--bd-edge':         '#0d200d',
+      '--tx-primary':      '#80ee80',
+      '--tx-secondary':    '#50a050',
+      '--tx-bright':       '#c0ffc0',
+      '--tx-muted':        '#408040',
+      '--tx-dim':          '#285028',
+      '--tx-faint':        '#1a3a1a',
+      '--tx-ghost':        '#204020',
+      '--tx-node':         '#40704a',
+      '--tx-node-sel':     '#c0ffc0',
+      '--ac-primary':      '#4ade80',
+      '--ac-teal':         '#00d4aa',
+      '--ac-edge-type':    '#103020',
+      '--ac-arrow':        '#0d2010',
+      '--ac-cluster-arr':  '#143820',
+    },
+  },
+
+  midnight: {
+    label: '◈ midnight',
+    vars: {
+      '--lc-cyan':         '#00e5ff',
+      '--lc-yellow':       '#ffe066',
+      '--lc-green':        '#00ff88',
+      '--lc-orange':       '#ff9040',
+      '--lc-purple':       '#b090ff',
+      '--lc-red':          '#ff6060',
+      '--lc-pink':         '#ff60c0',
+      '--bg-base':         '#000000',
+      '--bg-panel':        '#050505',
+      '--bg-raised':       '#0a0a0a',
+      '--bg-input':        '#080808',
+      '--bg-hover':        '#111111',
+      '--bg-select':       '#161616',
+      '--bg-deep':         '#060606',
+      '--bg-node':         '#090909',
+      '--bd-faint':        '#0e0e0e',
+      '--bd-muted':        '#1c1c1c',
+      '--bd-dim':          '#0c0c0c',
+      '--bd-edge':         '#141414',
+      '--tx-primary':      '#00d4e8',
+      '--tx-secondary':    '#007a88',
+      '--tx-bright':       '#80eeff',
+      '--tx-muted':        '#005060',
+      '--tx-dim':          '#003040',
+      '--tx-faint':        '#001a20',
+      '--tx-ghost':        '#002530',
+      '--tx-node':         '#004558',
+      '--tx-node-sel':     '#80eeff',
+      '--ac-primary':      '#00e5ff',
+      '--ac-teal':         '#00ff88',
+      '--ac-edge-type':    '#001828',
+      '--ac-arrow':        '#001020',
+      '--ac-cluster-arr':  '#001e30',
+    },
+  },
+
+  warm: {
+    label: '☀ warm',
+    vars: {
+      '--lc-cyan':         '#40c0a0',
+      '--lc-yellow':       '#e8c040',
+      '--lc-green':        '#70c050',
+      '--lc-orange':       '#e87020',
+      '--lc-purple':       '#c090e0',
+      '--lc-red':          '#e06040',
+      '--lc-pink':         '#e080a0',
+      '--bg-base':         '#1c1711',
+      '--bg-panel':        '#221e17',
+      '--bg-raised':       '#2a2318',
+      '--bg-input':        '#261f14',
+      '--bg-hover':        '#302818',
+      '--bg-select':       '#38301e',
+      '--bg-deep':         '#201b11',
+      '--bg-node':         '#201a0e',
+      '--bd-faint':        '#2a2218',
+      '--bd-muted':        '#3a3020',
+      '--bd-dim':          '#281f14',
+      '--bd-edge':         '#302810',
+      '--tx-primary':      '#d4c59a',
+      '--tx-secondary':    '#9a8060',
+      '--tx-bright':       '#ede0c0',
+      '--tx-muted':        '#806840',
+      '--tx-dim':          '#605038',
+      '--tx-faint':        '#483820',
+      '--tx-ghost':        '#504030',
+      '--tx-node':         '#706040',
+      '--tx-node-sel':     '#ede0c0',
+      '--ac-primary':      '#e8a020',
+      '--ac-teal':         '#50b060',
+      '--ac-edge-type':    '#382808',
+      '--ac-arrow':        '#302408',
+      '--ac-cluster-arr':  '#402808',
+    },
+  },
+
+  light: {
+    label: '○ light',
+    vars: {
+      '--lc-cyan':         '#0a7a8a',
+      '--lc-yellow':       '#8a6000',
+      '--lc-green':        '#1a7a3a',
+      '--lc-orange':       '#b04000',
+      '--lc-purple':       '#4a28c0',
+      '--lc-red':          '#b03020',
+      '--lc-pink':         '#a01870',
+      '--bg-base':         '#f4f5f9',
+      '--bg-panel':        '#eef0f6',
+      '--bg-raised':       '#ffffff',
+      '--bg-input':        '#ffffff',
+      '--bg-hover':        '#e8eaf2',
+      '--bg-select':       '#dde0ef',
+      '--bg-deep':         '#f0f1f8',
+      '--bg-node':         '#f8f9fd',
+      '--bd-faint':        '#dde0ec',
+      '--bd-muted':        '#8890c8',
+      '--bd-dim':          '#d0d4e8',
+      '--bd-edge':         '#6870b0',
+      '--tx-primary':      '#1a1c2e',
+      '--tx-secondary':    '#3a3f60',
+      '--tx-bright':       '#0a0c1a',
+      '--tx-muted':        '#505580',
+      '--tx-dim':          '#7880a8',
+      '--tx-faint':        '#9098b8',
+      '--tx-ghost':        '#a8aec8',
+      '--tx-node':         '#1a1f40',
+      '--tx-node-sel':     '#0a0c1a',
+      '--ac-primary':      '#5b4de0',
+      '--ac-teal':         '#0e9e9e',
+      '--ac-edge-type':    '#8890c8',
+      '--ac-arrow':        '#6870b0',
+      '--ac-cluster-arr':  '#5b4de0',
+    },
+  },
+};
+
+export const THEME_KEYS = Object.keys(THEMES);
+export const DEFAULT_THEME = 'space';

package/stubs/tree-sitter-cli-stub/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "tree-sitter-cli",
+  "version": "0.23.2",
+  "description": "Stub — prevents postinstall binary download in restricted networks. tree-sitter language packages ship prebuilds; the CLI is not needed at runtime.",
+  "license": "MIT"
+}