@monoes/monograph 1.5.6 → 1.5.7

package/src/__tests__/export/adjacency-matrix.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  buildAdjacencyMatrix,
-  buildAdjacencyMatrixFromDb,
-  adjacencyMatrixToCsv,
-} from '../../export/adjacency-matrix.js';
-import { openDb } from '../../storage/db.js';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-adjmatrix-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: ReturnType<typeof openDb>, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: ReturnType<typeof openDb>, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-function makeNode(id: string): MonographNode {
-  return { id, label: 'Function', name: id, normLabel: id.toLowerCase(), isExported: false };
-}
-
-function makeEdge(src: string, tgt: string): MonographEdge {
-  return { id: `${src}_${tgt}`, sourceId: src, targetId: tgt, relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0 };
-}
-
-describe('buildAdjacencyMatrix', () => {
-  it('builds a zero matrix for no edges', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const result = buildAdjacencyMatrix(nodes, []);
-    expect(result.nodeIds).toEqual(['a', 'b']);
-    expect(result.matrix[0]).toEqual([0, 0]);
-    expect(result.matrix[1]).toEqual([0, 0]);
-  });
-
-  it('counts a single edge correctly', () => {
-    const nodes = [makeNode('a'), makeNode('b'), makeNode('c')];
-    const edges = [makeEdge('a', 'b')];
-    const result = buildAdjacencyMatrix(nodes, edges);
-    // a→b: matrix[0][1] = 1, all others = 0
-    expect(result.matrix[0][1]).toBe(1);
-    expect(result.matrix[0][0]).toBe(0);
-    expect(result.matrix[1][0]).toBe(0);
-  });
-
-  it('counts multi-edges between the same pair', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const e1: MonographEdge = { ...makeEdge('a', 'b'), id: 'e1' };
-    const e2: MonographEdge = { ...makeEdge('a', 'b'), id: 'e2' };
-    const result = buildAdjacencyMatrix(nodes, [e1, e2]);
-    expect(result.matrix[0][1]).toBe(2);
-  });
-
-  it('ignores edges whose endpoints are not in the node list', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const dangling = makeEdge('a', 'z'); // 'z' not in nodes
-    const result = buildAdjacencyMatrix(nodes, [dangling]);
-    expect(result.matrix[0][0]).toBe(0);
-    expect(result.matrix[0][1]).toBe(0);
-  });
-});
-
-describe('buildAdjacencyMatrixFromDb', () => {
-  it('builds matrix from all nodes in db', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = buildAdjacencyMatrixFromDb(db);
-    expect(result.nodeIds).toHaveLength(3);
-    // Find indices
-    const ai = result.nodeIds.indexOf('a');
-    const bi = result.nodeIds.indexOf('b');
-    expect(result.matrix[ai][bi]).toBe(1);
-    db.close();
-  });
-
-  it('restricts to given nodeIds subset', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    const result = buildAdjacencyMatrixFromDb(db, ['a', 'b']);
-    expect(result.nodeIds).toHaveLength(2);
-    expect(result.nodeIds).not.toContain('c');
-    db.close();
-  });
-});
-
-describe('adjacencyMatrixToCsv', () => {
-  it('generates a CSV with node names as headers', () => {
-    const am = buildAdjacencyMatrix([makeNode('a'), makeNode('b')], [makeEdge('a', 'b')]);
-    const csv = adjacencyMatrixToCsv(am);
-    const lines = csv.split('\n');
-    expect(lines[0]).toContain('"a"');
-    expect(lines[0]).toContain('"b"');
-    // Row for 'a': first cell is "a", second is 1
-    const aRow = lines.find(l => l.startsWith('"a"'))!;
-    expect(aRow).toContain('1');
-  });
-
-  it('escapes double quotes in node names', () => {
-    const node: MonographNode = { id: 'x', label: 'Function', name: 'say "hello"', normLabel: 'say hello', isExported: false };
-    const am = buildAdjacencyMatrix([node], []);
-    const csv = adjacencyMatrixToCsv(am);
-    expect(csv).toContain('""hello""');
-  });
-});

package/src/__tests__/export/csv.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toCsv } from '../../export/csv.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-const node: MonographNode = {
-  id: 'n1', label: 'Function', name: 'doStuff',
-  normLabel: 'function', filePath: '/a.ts',
-  startLine: 1, endLine: 5, isExported: true,
-};
-const edge: MonographEdge = {
-  id: 'e1', sourceId: 'n1', targetId: 'n2',
-  relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 0.9,
-};
-
-describe('toCsv', () => {
-  it('emits node CSV header and row', () => {
-    const { nodes } = toCsv([node], []);
-    expect(nodes).toContain('id,label,name,filePath,isExported,startLine,endLine');
-    expect(nodes).toContain('n1,Function,doStuff,/a.ts,true,1,5');
-  });
-
-  it('emits edge CSV header and row', () => {
-    const { edges } = toCsv([node], [edge]);
-    expect(edges).toContain('id,sourceId,targetId,relation,confidence,confidenceScore');
-    expect(edges).toContain('e1,n1,n2,CALLS,EXTRACTED,0.9');
-  });
-
-  it('escapes commas in names', () => {
-    const n = { ...node, name: 'foo,bar' };
-    const { nodes } = toCsv([n], []);
-    expect(nodes).toContain('"foo,bar"');
-  });
-
-  it('returns two separate CSV strings', () => {
-    const result = toCsv([node], [edge]);
-    expect(typeof result.nodes).toBe('string');
-    expect(typeof result.edges).toBe('string');
-  });
-});

package/src/__tests__/export/dot.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toDot } from '../../export/dot.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-function makeNode(id: string, label = 'Function', name = id, filePath?: string): MonographNode {
-  return { id, label: label as MonographNode['label'], name, isExported: false, filePath };
-}
-
-function makeEdge(id: string, sourceId: string, targetId: string, relation = 'CALLS'): MonographEdge {
-  return { id, sourceId, targetId, relation, confidence: 'EXTRACTED', confidenceScore: 1.0 };
-}
-
-describe('toDot', () => {
-  it('returns a string starting with "digraph"', () => {
-    const result = toDot([], []);
-    expect(typeof result).toBe('string');
-    expect(result.trim()).toMatch(/^digraph/);
-  });
-
-  it('produces valid DOT structure with braces', () => {
-    const result = toDot([], []);
-    expect(result).toContain('{');
-    expect(result).toContain('}');
-  });
-
-  it('includes node ids in output', () => {
-    const nodes = [makeNode('node_a'), makeNode('node_b')];
-    const result = toDot(nodes, []);
-    expect(result).toContain('node_a');
-    expect(result).toContain('node_b');
-  });
-
-  it('includes edge arrows', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const edges = [makeEdge('e1', 'a', 'b')];
-    const result = toDot(nodes, edges);
-    expect(result).toContain('->');
-    expect(result).toContain('"a"');
-    expect(result).toContain('"b"');
-  });
-
-  it('escapes special characters in node names', () => {
-    const nodes = [makeNode('id1', 'Function', 'my "func"')];
-    const result = toDot(nodes, []);
-    // The quoted name should be escaped
-    expect(result).toContain('id1');
-  });
-
-  it('includes label attribute on nodes', () => {
-    const nodes = [makeNode('fn1', 'Function', 'myFunction')];
-    const result = toDot(nodes, []);
-    expect(result).toContain('label');
-    expect(result).toContain('myFunction');
-  });
-
-  it('includes relation as edge label', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const edges = [makeEdge('e1', 'a', 'b', 'IMPORTS')];
-    const result = toDot(nodes, edges);
-    expect(result).toContain('IMPORTS');
-  });
-
-  it('handles empty nodes and edges', () => {
-    const result = toDot([], []);
-    expect(result).toBeTruthy();
-    expect(result).toContain('digraph');
-  });
-
-  it('accepts an optional graph name', () => {
-    const result = toDot([], [], { graphName: 'MyGraph' });
-    expect(result).toContain('MyGraph');
-  });
-
-  it('uses "monograph" as default graph name', () => {
-    const result = toDot([], []);
-    expect(result).toContain('monograph');
-  });
-
-  it('produces parseable DOT for multiple nodes and edges', () => {
-    const nodes = [makeNode('a'), makeNode('b'), makeNode('c')];
-    const edges = [makeEdge('e1', 'a', 'b'), makeEdge('e2', 'b', 'c')];
-    const result = toDot(nodes, edges);
-    expect(result).toContain('"a" ->');
-    expect(result).toContain('"b" ->');
-  });
-});

package/src/__tests__/export/gexf.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toGexf } from '../../export/gexf.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-function makeNode(id: string, label = 'Function', name = id): MonographNode {
-  return { id, label: label as MonographNode['label'], name, isExported: false };
-}
-
-function makeEdge(id: string, sourceId: string, targetId: string, relation = 'CALLS'): MonographEdge {
-  return { id, sourceId, targetId, relation, confidence: 'EXTRACTED', confidenceScore: 1.0 };
-}
-
-describe('toGexf', () => {
-  it('returns a string', () => {
-    expect(typeof toGexf([], [])).toBe('string');
-  });
-
-  it('starts with XML declaration', () => {
-    const result = toGexf([], []);
-    expect(result).toMatch(/^<\?xml/);
-  });
-
-  it('contains gexf root element', () => {
-    const result = toGexf([], []);
-    expect(result).toContain('<gexf');
-    expect(result).toContain('</gexf>');
-  });
-
-  it('contains graph element', () => {
-    const result = toGexf([], []);
-    expect(result).toContain('<graph');
-    expect(result).toContain('</graph>');
-  });
-
-  it('includes nodes section', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const result = toGexf(nodes, []);
-    expect(result).toContain('<nodes>');
-    expect(result).toContain('</nodes>');
-    expect(result).toContain('"a"');
-    expect(result).toContain('"b"');
-  });
-
-  it('includes edges section', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const edges = [makeEdge('e1', 'a', 'b')];
-    const result = toGexf(nodes, edges);
-    expect(result).toContain('<edges>');
-    expect(result).toContain('</edges>');
-    expect(result).toContain('e1');
-  });
-
-  it('includes node label attribute', () => {
-    const nodes = [makeNode('fn1', 'Function', 'myFunc')];
-    const result = toGexf(nodes, []);
-    expect(result).toContain('myFunc');
-  });
-
-  it('includes edge source and target', () => {
-    const nodes = [makeNode('a'), makeNode('b')];
-    const edges = [makeEdge('e1', 'a', 'b')];
-    const result = toGexf(nodes, edges);
-    expect(result).toContain('source="a"');
-    expect(result).toContain('target="b"');
-  });
-
-  it('handles empty nodes and edges gracefully', () => {
-    const result = toGexf([], []);
-    expect(result).toBeTruthy();
-    expect(result).toContain('<nodes');
-    expect(result).toContain('<edges');
-  });
-
-  it('marks graph as directed', () => {
-    const result = toGexf([], []);
-    expect(result).toContain('directed');
-  });
-});

package/src/__tests__/export/graphml.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toGraphml } from '../../export/graphml.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-const nodeWithCommunity: MonographNode = {
-  id: 'n1', label: 'Function', name: 'doStuff',
-  normLabel: 'function', filePath: '/a.ts',
-  isExported: true, communityId: 42,
-};
-const nodeWithoutCommunity: MonographNode = {
-  id: 'n2', label: 'Class', name: 'Foo',
-  normLabel: 'class', filePath: '/b.ts',
-  isExported: false,
-};
-const edge: MonographEdge = {
-  id: 'e1', sourceId: 'n1', targetId: 'n2',
-  relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0,
-};
-
-describe('toGraphml', () => {
-  it('includes community key declaration in header', () => {
-    const out = toGraphml([nodeWithCommunity], []);
-    expect(out).toContain('<key id="community"');
-    expect(out).toContain('attr.name="community"');
-    expect(out).toContain('attr.type="int"');
-  });
-
-  it('includes community data element for node with communityId', () => {
-    const out = toGraphml([nodeWithCommunity], []);
-    expect(out).toContain('<data key="community">42</data>');
-  });
-
-  it('omits community data element when communityId is absent', () => {
-    const out = toGraphml([nodeWithoutCommunity], []);
-    // Should not have a community data tag for this node
-    const nodeSection = out.split('<node id="n2">')[1]?.split('</node>')[0] ?? '';
-    expect(nodeSection).not.toContain('<data key="community">');
-  });
-
-  it('produces valid graphml with edges', () => {
-    const out = toGraphml([nodeWithCommunity, nodeWithoutCommunity], [edge]);
-    expect(out).toContain('<?xml version="1.0"');
-    expect(out).toContain('<graphml');
-    expect(out).toContain('<edge id="e1"');
-    expect(out).toContain('<data key="relation">CALLS</data>');
-  });
-
-  it('escapes XML special characters in names', () => {
-    const n: MonographNode = {
-      id: 'n3', label: 'Function', name: 'foo<bar>&baz',
-      normLabel: 'function', isExported: false,
-    };
-    const out = toGraphml([n], []);
-    expect(out).toContain('foo&lt;bar&gt;&amp;baz');
-    expect(out).not.toContain('foo<bar>');
-  });
-});

package/src/__tests__/export/mermaid.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toMermaid } from '../../export/mermaid.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-const fn: MonographNode = {
-  id: 'fn_alpha', label: 'Function', name: 'alpha',
-  normLabel: 'function', filePath: '/src/a.ts',
-  isExported: true,
-};
-const cls: MonographNode = {
-  id: 'cls_beta', label: 'Class', name: 'Beta',
-  normLabel: 'class', filePath: '/src/b.ts',
-  isExported: false,
-};
-const edge: MonographEdge = {
-  id: 'e1', sourceId: 'fn_alpha', targetId: 'cls_beta',
-  relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0,
-};
-
-describe('toMermaid', () => {
-  it('starts with "graph" declaration', () => {
-    const out = toMermaid([fn], []);
-    expect(out).toMatch(/^graph\s+(TD|LR|RL|BT)/);
-  });
-
-  it('includes all node ids', () => {
-    const out = toMermaid([fn, cls], [edge]);
-    expect(out).toContain('fn_alpha');
-    expect(out).toContain('cls_beta');
-  });
-
-  it('includes an edge arrow between connected nodes', () => {
-    const out = toMermaid([fn, cls], [edge]);
-    // Arrow may include a label: fn_alpha -->|CALLS| cls_beta
-    expect(out).toMatch(/fn_alpha\s*-->(\|[^|]+\|)?\s*cls_beta/);
-  });
-
-  it('includes edge label with relation', () => {
-    const out = toMermaid([fn, cls], [edge]);
-    expect(out).toContain('CALLS');
-  });
-
-  it('includes node type/label in the diagram', () => {
-    const out = toMermaid([fn], []);
-    expect(out).toContain('Function');
-  });
-
-  it('returns empty graph declaration for empty inputs', () => {
-    const out = toMermaid([], []);
-    expect(out).toMatch(/^graph\s+(TD|LR|RL|BT)/);
-    expect(out).not.toContain('-->');
-  });
-
-  it('caps nodes at 200 to avoid huge diagrams', () => {
-    const nodes: MonographNode[] = Array.from({ length: 300 }, (_, i) => ({
-      id: `n${i}`, label: 'Function', name: `fn${i}`,
-      normLabel: 'function', isExported: false,
-    }));
-    const out = toMermaid(nodes, []);
-    // Should only contain up to 200 node definitions
-    const matches = out.match(/\bn\d+\b/g) ?? [];
-    const uniqueIds = new Set(matches);
-    expect(uniqueIds.size).toBeLessThanOrEqual(200);
-  });
-
-  it('sanitizes special characters in node names', () => {
-    const n: MonographNode = {
-      id: 'n_special', label: 'Function', name: 'foo<bar>"baz"',
-      normLabel: 'function', isExported: false,
-    };
-    const out = toMermaid([n], []);
-    expect(out).not.toContain('<bar>');
-    expect(out).not.toContain('"baz"');
-  });
-
-  it('includes community groupings as subgraphs when nodes have communityId', () => {
-    const a: MonographNode = { ...fn, communityId: 1 };
-    const b: MonographNode = { ...cls, communityId: 2 };
-    const out = toMermaid([a, b], []);
-    expect(out).toContain('subgraph');
-  });
-
-  it('uses dashed arrows for non-EXTRACTED edges', () => {
-    const inferredEdge: MonographEdge = { ...edge, id: 'e2', confidence: 'INFERRED' };
-    const out = toMermaid([fn, cls], [inferredEdge]);
-    // Dashed arrow syntax: -..-> or -.->
-    expect(out).toMatch(/fn_alpha\s*-\.+->(\|[^|]+\|)?\s*cls_beta/);
-  });
-});

package/src/__tests__/graph/betweenness.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getBetweennessCentrality } from '../../graph/analyzer.js';
-import Database from 'better-sqlite3';
-import { openDb } from '../../storage/db.js';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string, name = id) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, name, name.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('getBetweennessCentrality', () => {
-  it('returns a map from node id to centrality score', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-
-    const result = getBetweennessCentrality(db);
-    expect(result).toBeInstanceOf(Map);
-    expect(result.has('a')).toBe(true);
-    expect(result.has('b')).toBe(true);
-    expect(result.has('c')).toBe(true);
-    db.close();
-  });
-
-  it('node on all shortest paths has highest centrality', () => {
-    // a -> b -> c: b is on all paths between a and c
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-
-    const result = getBetweennessCentrality(db);
-    // b should have higher betweenness than a and c (endpoints)
-    expect(result.get('b')!).toBeGreaterThan(result.get('a')!);
-    expect(result.get('b')!).toBeGreaterThan(result.get('c')!);
-    db.close();
-  });
-
-  it('returns zero for isolated nodes', () => {
-    const db = makeTempDb();
-    insertNode(db, 'isolated');
-
-    const result = getBetweennessCentrality(db);
-    expect(result.get('isolated')).toBe(0);
-    db.close();
-  });
-
-  it('returns empty map for empty graph', () => {
-    const db = makeTempDb();
-    const result = getBetweennessCentrality(db);
-    expect(result.size).toBe(0);
-    db.close();
-  });
-
-  it('all scores are non-negative numbers', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    insertNode(db, 'z');
-    insertEdge(db, 'x', 'y');
-    insertEdge(db, 'y', 'z');
-    insertEdge(db, 'x', 'z');
-
-    const result = getBetweennessCentrality(db);
-    for (const [, score] of result) {
-      expect(typeof score).toBe('number');
-      expect(score).toBeGreaterThanOrEqual(0);
-    }
-    db.close();
-  });
-});

package/src/__tests__/graph/cycles.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findCycles } from '../../graph/cycles.js';
-import { openDb } from '../../storage/db.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-cycles-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('findCycles', () => {
-  it('returns empty array for empty graph', () => {
-    const db = makeTempDb();
-    expect(findCycles(db)).toEqual([]);
-    db.close();
-  });
-
-  it('returns empty array for single node with no self-loop', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    expect(findCycles(db)).toEqual([]);
-    db.close();
-  });
-
-  it('returns empty array for a DAG (no cycles)', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const cycles = findCycles(db);
-    expect(cycles).toEqual([]);
-    db.close();
-  });
-
-  it('detects a simple 2-node cycle: a->b->a', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    const cycles = findCycles(db);
-    expect(cycles.length).toBeGreaterThan(0);
-    db.close();
-  });
-
-  it('detects a 3-node cycle: a->b->c->a', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    insertEdge(db, 'c', 'a');
-    const cycles = findCycles(db);
-    expect(cycles.length).toBeGreaterThan(0);
-    db.close();
-  });
-
-  it('each cycle is an array of node ids forming the cycle', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    insertEdge(db, 'x', 'y');
-    insertEdge(db, 'y', 'x');
-    const cycles = findCycles(db);
-    expect(cycles.length).toBeGreaterThan(0);
-    const cycle = cycles[0];
-    expect(Array.isArray(cycle)).toBe(true);
-    expect(cycle.length).toBeGreaterThan(0);
-    for (const id of cycle) {
-      expect(typeof id).toBe('string');
-    }
-    db.close();
-  });
-
-  it('does not detect cycles in a tree', () => {
-    const db = makeTempDb();
-    // a tree: a->b, a->c, b->d, b->e
-    ['a', 'b', 'c', 'd', 'e'].forEach(id => insertNode(db, id));
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'a', 'c');
-    insertEdge(db, 'b', 'd');
-    insertEdge(db, 'b', 'e');
-    expect(findCycles(db)).toEqual([]);
-    db.close();
-  });
-
-  it('detects self-loop as a cycle', () => {
-    const db = makeTempDb();
-    insertNode(db, 'loop');
-    // bypass FK by doing the insertion with FK off
-    db.pragma('foreign_keys = OFF');
-    db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES ('self', 'loop', 'loop', 'CALLS', 'EXTRACTED', 1.0)`).run();
-    db.pragma('foreign_keys = ON');
-    const cycles = findCycles(db);
-    expect(cycles.length).toBeGreaterThan(0);
-    db.close();
-  });
-
-  it('handles multiple disconnected cycles', () => {
-    const db = makeTempDb();
-    // cycle 1: a->b->a
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    // cycle 2: c->d->c
-    insertNode(db, 'c');
-    insertNode(db, 'd');
-    insertEdge(db, 'c', 'd');
-    insertEdge(db, 'd', 'c');
-    const cycles = findCycles(db);
-    expect(cycles.length).toBeGreaterThanOrEqual(2);
-    db.close();
-  });
-});