@kodus/kodus-graph 0.2.8 → 0.2.10

package/src/graph/builder.ts

@@ -1,209 +0,0 @@
-import { deriveEdges } from './edges';
-import type { GraphData, GraphEdge, GraphNode, ImportEdge, RawCallEdge, RawGraph } from './types';
-
-export function buildGraphData(
-  raw: RawGraph,
-  callEdges: RawCallEdge[],
-  importEdges: ImportEdge[],
-  _repoDir: string,
-  fileHashes: Map<string, string>,
-): GraphData {
-  const nodes: GraphNode[] = [];
-  const edges: GraphEdge[] = [];
-
-  // Functions -> nodes
-  for (const f of raw.functions) {
-    nodes.push({
-      kind: f.kind,
-      name: f.name,
-      qualified_name: f.qualified,
-      file_path: f.file,
-      line_start: f.line_start,
-      line_end: f.line_end,
-      language: detectLang(f.file),
-      parent_name: f.className || undefined,
-      params: f.params || undefined,
-      return_type: f.returnType || undefined,
-      is_test: false,
-      file_hash: fileHashes.get(f.file) || '',
-      content_hash: f.content_hash,
-    });
-  }
-
-  // Classes -> nodes
-  for (const c of raw.classes) {
-    nodes.push({
-      kind: 'Class',
-      name: c.name,
-      qualified_name: c.qualified,
-      file_path: c.file,
-      line_start: c.line_start,
-      line_end: c.line_end,
-      language: detectLang(c.file),
-      is_test: false,
-      file_hash: fileHashes.get(c.file) || '',
-      content_hash: c.content_hash,
-    });
-  }
-
-  // Interfaces -> nodes
-  for (const i of raw.interfaces) {
-    nodes.push({
-      kind: 'Interface',
-      name: i.name,
-      qualified_name: i.qualified,
-      file_path: i.file,
-      line_start: i.line_start,
-      line_end: i.line_end,
-      language: detectLang(i.file),
-      is_test: false,
-      file_hash: fileHashes.get(i.file) || '',
-      content_hash: i.content_hash,
-    });
-  }
-
-  // Enums -> nodes
-  for (const e of raw.enums) {
-    nodes.push({
-      kind: 'Enum',
-      name: e.name,
-      qualified_name: e.qualified,
-      file_path: e.file,
-      line_start: e.line_start,
-      line_end: e.line_end,
-      language: detectLang(e.file),
-      is_test: false,
-      file_hash: fileHashes.get(e.file) || '',
-      content_hash: e.content_hash,
-    });
-  }
-
-  // Tests -> nodes
-  for (const t of raw.tests) {
-    nodes.push({
-      kind: 'Test',
-      name: t.name,
-      qualified_name: t.qualified,
-      file_path: t.file,
-      line_start: t.line_start,
-      line_end: t.line_end,
-      language: detectLang(t.file),
-      is_test: true,
-      file_hash: fileHashes.get(t.file) || '',
-      content_hash: t.content_hash,
-    });
-  }
-
-  // Build file→functions index to resolve caller from line number
-  const functionsByFile = new Map<string, Array<{ qualified_name: string; line_start: number; line_end: number }>>();
-  for (const node of nodes) {
-    if (node.kind === 'Class' || node.kind === 'Interface' || node.kind === 'Enum') continue;
-    const entry = { qualified_name: node.qualified_name, line_start: node.line_start, line_end: node.line_end };
-    const list = functionsByFile.get(node.file_path);
-    if (list) list.push(entry);
-    else functionsByFile.set(node.file_path, [entry]);
-  }
-  // Sort descending by line_start so inner/nested functions match first
-  for (const list of functionsByFile.values()) {
-    list.sort((a, b) => b.line_start - a.line_start);
-  }
-
-  // CALLS edges — resolve caller function from call line number
-  for (const ce of callEdges) {
-    const sourceFile = ce.source.includes('::') ? ce.source.split('::')[0] : ce.source;
-    let sourceQualified: string;
-
-    if (ce.source.includes('::')) {
-      sourceQualified = ce.source;
-    } else {
-      // Find the innermost function containing this call line
-      const fns = functionsByFile.get(ce.source);
-      let resolved: string | undefined;
-      if (fns) {
-        for (const fn of fns) {
-          if (ce.line >= fn.line_start && ce.line <= fn.line_end) {
-            resolved = fn.qualified_name;
-            break;
-          }
-        }
-      }
-      sourceQualified = resolved || `${ce.source}::unknown`;
-    }
-
-    edges.push({
-      kind: 'CALLS',
-      source_qualified: sourceQualified,
-      target_qualified: ce.target,
-      file_path: sourceFile,
-      line: ce.line,
-      confidence: ce.confidence,
-    });
-  }
-
-  // IMPORTS edges
-  for (const ie of importEdges) {
-    edges.push({
-      kind: 'IMPORTS',
-      source_qualified: ie.source,
-      target_qualified: ie.target,
-      file_path: ie.source,
-      line: ie.line,
-    });
-  }
-
-  // Derived edges
-  const derived = deriveEdges(raw, importEdges);
-
-  for (const e of derived.inherits) {
-    edges.push({
-      kind: 'INHERITS',
-      source_qualified: e.source,
-      target_qualified: e.target,
-      file_path: e.file || '',
-      line: 0,
-    });
-  }
-  for (const e of derived.implements) {
-    edges.push({
-      kind: 'IMPLEMENTS',
-      source_qualified: e.source,
-      target_qualified: e.target,
-      file_path: e.file || '',
-      line: 0,
-    });
-  }
-  for (const e of derived.testedBy) {
-    edges.push({
-      kind: 'TESTED_BY',
-      source_qualified: e.source,
-      target_qualified: e.target,
-      file_path: e.target || '',
-      line: 0,
-    });
-  }
-  for (const e of derived.contains) {
-    edges.push({
-      kind: 'CONTAINS',
-      source_qualified: e.source,
-      target_qualified: e.target,
-      file_path: e.source,
-      line: 0,
-    });
-  }
-
-  return { nodes, edges };
-}
-
-function detectLang(file: string): string {
-  if (file.endsWith('.ts') || file.endsWith('.tsx')) return 'typescript';
-  if (file.endsWith('.js') || file.endsWith('.jsx') || file.endsWith('.mjs') || file.endsWith('.cjs'))
-    return 'javascript';
-  if (file.endsWith('.py')) return 'python';
-  if (file.endsWith('.rb')) return 'ruby';
-  if (file.endsWith('.go')) return 'go';
-  if (file.endsWith('.java')) return 'java';
-  if (file.endsWith('.rs')) return 'rust';
-  if (file.endsWith('.cs')) return 'csharp';
-  if (file.endsWith('.php')) return 'php';
-  return 'unknown';
-}

package/src/graph/edges.ts

@@ -1,101 +0,0 @@
-import { basename, extname } from 'path';
-import type { ImportEdge, RawGraph } from './types';
-
-interface DerivedEdge {
-  source: string;
-  target: string;
-  file?: string;
-}
-
-export interface DerivedEdges {
-  inherits: DerivedEdge[];
-  implements: DerivedEdge[];
-  testedBy: DerivedEdge[];
-  contains: DerivedEdge[];
-}
-
-/**
- * Extract the "stem" from a test file name by stripping test-related
- * prefixes/suffixes. Returns null if no test pattern was found.
- */
-export function extractTestStem(testFile: string): string | null {
-  const base = basename(testFile, extname(testFile));
-  const cleaned = base
-    .replace(/_spec$/, '') // user_spec → user (Ruby/RSpec)
-    .replace(/_test$/, '') // user_test → user (Python/Go)
-    .replace(/^test_/, '') // test_user → user (Python)
-    .replace(/\.test$/, '') // user.test → user (JS/TS)
-    .replace(/\.spec$/, '') // user.spec → user (JS/TS)
-    .replace(/-test$/, '') // user-test → user
-    .replace(/-spec$/, '') // user-spec → user
-    .replace(/^spec_/, '') // spec_user → user
-    .replace(/Test$/, '') // UserTest → User (Java)
-    .replace(/Spec$/, ''); // UserSpec → User (Scala)
-  if (!cleaned || cleaned === base) return null;
-  return cleaned;
-}
-
-export function deriveEdges(graph: RawGraph, importEdges: ImportEdge[]): DerivedEdges {
-  // INHERITS: class extends another class
-  const inherits = graph.classes
-    .filter((c) => c.extends)
-    .map((c) => ({ source: c.qualified, target: c.extends, file: c.file }));
-
-  // IMPLEMENTS: class implements interface
-  const implements_ = graph.classes
-    .filter((c) => c.implements)
-    .map((c) => ({ source: c.qualified, target: c.implements, file: c.file }));
-
-  // TESTED_BY: two heuristics, deduplicated
-  const testFiles = new Set(graph.tests.map((t) => t.file));
-  const testedBySet = new Set<string>();
-  const testedBy: DerivedEdge[] = [];
-
-  const addTestedBy = (source: string, target: string) => {
-    const key = `${source}|${target}`;
-    if (testedBySet.has(key)) return;
-    testedBySet.add(key);
-    testedBy.push({ source, target });
-  };
-
-  // Heuristic 1: Resolved imports from test files (high signal)
-  for (const e of importEdges) {
-    if (testFiles.has(e.source) && e.resolved) {
-      addTestedBy(e.target, e.source);
-    }
-  }
-
-  // Heuristic 2: File-name matching (catches Ruby, Python, and any
-  // language where imports don't resolve)
-  const allSourceFiles = new Set<string>();
-  for (const f of graph.functions) allSourceFiles.add(f.file);
-  for (const c of graph.classes) allSourceFiles.add(c.file);
-  for (const i of graph.interfaces) allSourceFiles.add(i.file);
-  for (const e of graph.enums) allSourceFiles.add(e.file);
-  for (const tf of testFiles) allSourceFiles.delete(tf);
-
-  const sourceByBase = new Map<string, string[]>();
-  for (const file of allSourceFiles) {
-    const base = basename(file, extname(file));
-    const list = sourceByBase.get(base);
-    if (list) list.push(file);
-    else sourceByBase.set(base, [file]);
-  }
-
-  for (const testFile of testFiles) {
-    const stem = extractTestStem(testFile);
-    if (!stem) continue;
-    const matches = sourceByBase.get(stem);
-    if (!matches) continue;
-    for (const sourceFile of matches) {
-      addTestedBy(sourceFile, testFile);
-    }
-  }
-
-  // CONTAINS: file contains function/class
-  const contains: DerivedEdge[] = [];
-  for (const f of graph.functions) contains.push({ source: f.file, target: f.qualified });
-  for (const c of graph.classes) contains.push({ source: c.file, target: c.qualified });
-
-  return { inherits, implements: implements_, testedBy, contains };
-}

package/src/graph/json-writer.ts

@@ -1,43 +0,0 @@
-import { openSync, writeSync, closeSync } from 'fs';
-import type { GraphEdge, GraphNode, ParseMetadata } from './types';
-
-/**
- * Write graph output as JSON to disk using incremental serialization.
- *
- * Instead of JSON.stringify on the full output (which creates a ~100-300 MB
- * string for large repos), this writes each node/edge individually.
- * Peak memory: only one JSON.stringify(singleNode) string at a time (~1 KB).
- */
-export function writeGraphJSON(
-  out: string,
-  metadata: ParseMetadata,
-  nodes: GraphNode[],
-  edges: GraphEdge[],
-): void {
-  const fd = openSync(out, 'w');
-
-  try {
-    writeSync(fd, '{"metadata":');
-    writeSync(fd, JSON.stringify(metadata));
-
-    // Nodes
-    writeSync(fd, ',"nodes":[');
-    for (let i = 0; i < nodes.length; i++) {
-      if (i > 0) writeSync(fd, ',');
-      writeSync(fd, '\n');
-      writeSync(fd, JSON.stringify(nodes[i]));
-    }
-    writeSync(fd, '\n]');
-
-    // Edges
-    writeSync(fd, ',"edges":[');
-    for (let i = 0; i < edges.length; i++) {
-      if (i > 0) writeSync(fd, ',');
-      writeSync(fd, '\n');
-      writeSync(fd, JSON.stringify(edges[i]));
-    }
-    writeSync(fd, '\n]}');
-  } finally {
-    closeSync(fd);
-  }
-}

package/src/graph/loader.ts

@@ -1,113 +0,0 @@
-// src/graph/loader.ts
-import { readFileSync } from 'fs';
-import { z } from 'zod';
-import type { GraphData, GraphEdge, GraphNode, ParseMetadata } from './types';
-
-const ParseOutputSchema = z.object({
-  metadata: z.object({
-    repo_dir: z.string(),
-    files_parsed: z.number(),
-    total_nodes: z.number(),
-    total_edges: z.number(),
-    duration_ms: z.number(),
-    parse_errors: z.number(),
-    extract_errors: z.number(),
-    files_unchanged: z.number().optional(),
-    incremental: z.boolean().optional(),
-  }),
-  nodes: z.array(
-    z.object({
-      kind: z.enum(['Function', 'Method', 'Constructor', 'Class', 'Interface', 'Enum', 'Test']),
-      name: z.string(),
-      qualified_name: z.string(),
-      file_path: z.string(),
-      line_start: z.number(),
-      line_end: z.number(),
-      language: z.string(),
-      is_test: z.boolean(),
-      file_hash: z.string(),
-      parent_name: z.string().optional(),
-      params: z.string().optional(),
-      return_type: z.string().optional(),
-      modifiers: z.string().optional(),
-    }),
-  ),
-  edges: z.array(
-    z.object({
-      kind: z.enum(['CALLS', 'IMPORTS', 'INHERITS', 'IMPLEMENTS', 'TESTED_BY', 'CONTAINS']),
-      source_qualified: z.string(),
-      target_qualified: z.string(),
-      file_path: z.string(),
-      line: z.number(),
-      confidence: z.number().optional(),
-    }),
-  ),
-});
-
-export interface IndexedGraph {
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-  byQualified: Map<string, GraphNode>;
-  byFile: Map<string, GraphNode[]>;
-  adjacency: Map<string, GraphEdge[]>;
-  reverseAdjacency: Map<string, GraphEdge[]>;
-  edgesByKind: Map<string, GraphEdge[]>;
-  metadata: ParseMetadata;
-}
-
-export function indexGraph(data: GraphData, metadata?: ParseMetadata): IndexedGraph {
-  const { nodes, edges } = data;
-  const meta: ParseMetadata = metadata ?? {
-    repo_dir: '',
-    files_parsed: 0,
-    total_nodes: nodes.length,
-    total_edges: edges.length,
-    duration_ms: 0,
-    parse_errors: 0,
-    extract_errors: 0,
-  };
-
-  const byQualified = new Map<string, GraphNode>();
-  const byFile = new Map<string, GraphNode[]>();
-  const adjacency = new Map<string, GraphEdge[]>();
-  const reverseAdjacency = new Map<string, GraphEdge[]>();
-  const edgesByKind = new Map<string, GraphEdge[]>();
-
-  for (const node of nodes) {
-    byQualified.set(node.qualified_name, node);
-    const list = byFile.get(node.file_path);
-    if (list) list.push(node);
-    else byFile.set(node.file_path, [node]);
-  }
-
-  for (const edge of edges) {
-    const fwd = adjacency.get(edge.source_qualified);
-    if (fwd) fwd.push(edge);
-    else adjacency.set(edge.source_qualified, [edge]);
-
-    const rev = reverseAdjacency.get(edge.target_qualified);
-    if (rev) rev.push(edge);
-    else reverseAdjacency.set(edge.target_qualified, [edge]);
-
-    const byKind = edgesByKind.get(edge.kind);
-    if (byKind) byKind.push(edge);
-    else edgesByKind.set(edge.kind, [edge]);
-  }
-
-  return { nodes, edges, byQualified, byFile, adjacency, reverseAdjacency, edgesByKind, metadata: meta };
-}
-
-export function loadGraph(path: string): IndexedGraph {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf-8'));
-  } catch (err) {
-    throw new Error(`Failed to read graph file: ${path} — ${String(err)}`);
-  }
-
-  const parsed = ParseOutputSchema.parse(raw);
-  return indexGraph(
-    { nodes: parsed.nodes as GraphNode[], edges: parsed.edges as GraphEdge[] },
-    parsed.metadata as ParseMetadata,
-  );
-}

package/src/graph/merger.ts

@@ -1,25 +0,0 @@
-import type { GraphData, MainGraphInput } from './types';
-
-/**
- * Merge local parse (PR changed files) with the main graph (from Postgres).
- * Replaces all nodes/edges from changed files with the local parse.
- * Keeps everything else from the main graph intact.
- */
-export function mergeGraphs(
-  mainGraph: MainGraphInput | null,
-  localParse: GraphData,
-  changedFiles: string[],
-): GraphData {
-  if (!mainGraph) return localParse;
-
-  const changedSet = new Set(changedFiles);
-
-  // Keep main graph nodes/edges NOT in changed files
-  const mainNodes = mainGraph.nodes.filter((n) => !changedSet.has(n.file_path));
-  const mainEdges = mainGraph.edges.filter((e) => !changedSet.has(e.file_path));
-
-  return {
-    nodes: [...mainNodes, ...localParse.nodes],
-    edges: [...mainEdges, ...localParse.edges],
-  };
-}