@monoes/monograph 1.0.0 → 1.2.0

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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,131 @@
+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();
+  });
+});

package/src/__tests__/graph/dead-code.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { detectDeadCode } from '../../graph/dead-code.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-deadcode-test-'));
+  return openDb(join(dir, 'test.db'));
+}
+
+function insertNode(db: Database.Database, id: string, isExported = 0) {
+  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, ?)`)
+    .run(id, id, id.toLowerCase(), isExported);
+}
+
+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('detectDeadCode', () => {
+  it('returns empty array for empty graph', () => {
+    const db = makeTempDb();
+    expect(detectDeadCode(db)).toEqual([]);
+    db.close();
+  });
+
+  it('detects a node with in-degree 0 that is not exported', () => {
+    const db = makeTempDb();
+    // orphan: no incoming edges, not exported
+    insertNode(db, 'orphan', 0);
+    insertNode(db, 'b');
+    insertEdge(db, 'b', 'orphan');
+    // orphan has in-degree 1 — not dead
+    // let's make a true orphan
+    insertNode(db, 'dead', 0);
+    // dead has no incoming edges
+    const result = detectDeadCode(db);
+    expect(result).toContain('dead');
+    db.close();
+  });
+
+  it('does NOT flag exported nodes as dead code', () => {
+    const db = makeTempDb();
+    // exported root with in-degree 0 — this is an entrypoint, not dead code
+    insertNode(db, 'entry', 1);
+    const result = detectDeadCode(db);
+    expect(result).not.toContain('entry');
+    db.close();
+  });
+
+  it('does NOT flag nodes that have incoming edges', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a');
+    insertNode(db, 'b');
+    insertEdge(db, 'a', 'b');
+    // b has in-degree 1 — reachable from a
+    const result = detectDeadCode(db);
+    expect(result).not.toContain('b');
+    db.close();
+  });
+
+  it('flags node with in-degree 0 and not exported', () => {
+    const db = makeTempDb();
+    insertNode(db, 'unused', 0);
+    const result = detectDeadCode(db);
+    expect(result).toContain('unused');
+    db.close();
+  });
+
+  it('handles mix of dead and live nodes', () => {
+    const db = makeTempDb();
+    insertNode(db, 'live_exported', 1);  // exported — not dead
+    insertNode(db, 'live_used');          // has incoming
+    insertNode(db, 'dead1');             // orphan, not exported
+    insertNode(db, 'dead2');             // orphan, not exported
+    insertEdge(db, 'live_exported', 'live_used');
+    const result = detectDeadCode(db);
+    expect(result).toContain('dead1');
+    expect(result).toContain('dead2');
+    expect(result).not.toContain('live_exported');
+    expect(result).not.toContain('live_used');
+    db.close();
+  });
+
+  it('returns array of node id strings', () => {
+    const db = makeTempDb();
+    insertNode(db, 'unused');
+    const result = detectDeadCode(db);
+    expect(Array.isArray(result)).toBe(true);
+    for (const id of result) {
+      expect(typeof id).toBe('string');
+    }
+    db.close();
+  });
+});

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

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { dfsTraversal } from '../../graph/dfs.js';
+
+function makeGraph(): Map<string, string[]> {
+  const adj = new Map<string, string[]>();
+  adj.set('a', ['b', 'c']);
+  adj.set('b', ['d']);
+  adj.set('c', ['d', 'e']);
+  adj.set('d', []);
+  adj.set('e', []);
+  return adj;
+}
+
+describe('dfsTraversal', () => {
+  it('visits all reachable nodes', () => {
+    const visited: string[] = [];
+    dfsTraversal('a', makeGraph(), (node) => { visited.push(node.id); });
+    expect(visited.sort()).toEqual(['a', 'b', 'c', 'd', 'e'].sort());
+  });
+
+  it('respects depth limit', () => {
+    const visited: string[] = [];
+    dfsTraversal('a', makeGraph(), (node) => { visited.push(node.id); }, { maxDepth: 1 });
+    expect(visited).toContain('a');
+    expect(visited).toContain('b');
+    expect(visited).toContain('c');
+    expect(visited).not.toContain('d');
+    expect(visited).not.toContain('e');
+  });
+
+  it('provides depth info in visitor', () => {
+    const depths: Record<string, number> = {};
+    dfsTraversal('a', makeGraph(), (node) => { depths[node.id] = node.depth; });
+    expect(depths['a']).toBe(0);
+    expect(depths['b']).toBe(1);
+    expect(depths['d']).toBe(2);
+  });
+
+  it('does not revisit nodes (cycle safety)', () => {
+    const cyclic = new Map<string, string[]>();
+    cyclic.set('a', ['b']);
+    cyclic.set('b', ['c']);
+    cyclic.set('c', ['a']); // cycle
+    const visited: string[] = [];
+    dfsTraversal('a', cyclic, (node) => { visited.push(node.id); });
+    expect(visited.length).toBe(3);
+    expect(new Set(visited).size).toBe(3);
+  });
+
+  it('returns empty when start node not in graph', () => {
+    const visited: string[] = [];
+    dfsTraversal('z', makeGraph(), (node) => { visited.push(node.id); });
+    expect(visited).toEqual([]);
+  });
+
+  it('returns nodes in DFS pre-order', () => {
+    const visited: string[] = [];
+    dfsTraversal('a', makeGraph(), (node) => { visited.push(node.id); });
+    expect(visited.indexOf('a')).toBeLessThan(visited.indexOf('b'));
+    expect(visited.indexOf('b')).toBeLessThan(visited.indexOf('d'));
+  });
+});

package/src/__tests__/graph/diff-summary.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { diffSnapshots, type GraphSnapshot } from '../../graph/diff.js';
+import type { MonographNode, MonographEdge } from '../../types.js';
+
+function node(id: string): MonographNode {
+  return {
+    id,
+    label: 'function',
+    name: id,
+    normLabel: id,
+    filePath: `${id}.ts`,
+    startLine: 1,
+    endLine: 10,
+    communityId: 0,
+    isExported: false,
+    language: 'typescript',
+    properties: {},
+  } as MonographNode;
+}
+
+function edge(sourceId: string, targetId: string): MonographEdge {
+  return { id: `${sourceId}->${targetId}`, sourceId, targetId, relation: 'imports' } as MonographEdge;
+}
+
+describe('GraphDiff.summary', () => {
+  it('includes summary string in diff result', () => {
+    const before: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [], capturedAt: '' };
+    const after: GraphSnapshot = { nodes: [node('a'), node('b'), node('c')], edges: [edge('a', 'c')], capturedAt: '' };
+    const diff = diffSnapshots(before, after);
+    expect(typeof diff.summary).toBe('string');
+  });
+
+  it('reports new nodes in summary', () => {
+    const before: GraphSnapshot = { nodes: [node('a')], edges: [], capturedAt: '' };
+    const after: GraphSnapshot = { nodes: [node('a'), node('b'), node('c')], edges: [], capturedAt: '' };
+    const diff = diffSnapshots(before, after);
+    expect(diff.summary).toMatch(/2 new node/);
+  });
+
+  it('reports removed nodes in summary', () => {
+    const before: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [], capturedAt: '' };
+    const after: GraphSnapshot = { nodes: [node('a')], edges: [], capturedAt: '' };
+    const diff = diffSnapshots(before, after);
+    expect(diff.summary).toMatch(/1 node removed/);
+  });
+
+  it('reports new edges in summary', () => {
+    const before: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [], capturedAt: '' };
+    const after: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [edge('a', 'b')], capturedAt: '' };
+    const diff = diffSnapshots(before, after);
+    expect(diff.summary).toMatch(/1 new edge/);
+  });
+
+  it('reports removed edges in summary', () => {
+    const before: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [edge('a', 'b')], capturedAt: '' };
+    const after: GraphSnapshot = { nodes: [node('a'), node('b')], edges: [], capturedAt: '' };
+    const diff = diffSnapshots(before, after);
+    expect(diff.summary).toMatch(/1 edge removed/);
+  });
+
+  it('returns "no changes" when graph is unchanged', () => {
+    const snap: GraphSnapshot = { nodes: [node('a')], edges: [], capturedAt: '' };
+    const diff = diffSnapshots(snap, snap);
+    expect(diff.summary).toMatch(/no changes/i);
+  });
+
+  it('combines multiple changes in one summary', () => {
+    const before: GraphSnapshot = {
+      nodes: [node('a'), node('b')],
+      edges: [edge('a', 'b')],
+      capturedAt: '',
+    };
+    const after: GraphSnapshot = {
+      nodes: [node('a'), node('c')],
+      edges: [edge('a', 'c')],
+      capturedAt: '',
+    };
+    const diff = diffSnapshots(before, after);
+    // Should mention new node, removed node, new edge, removed edge
+    expect(diff.summary.length).toBeGreaterThan(5);
+    expect(typeof diff.summary).toBe('string');
+  });
+});

package/src/__tests__/graph/edge-filter.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { filterEdges, filterEdgesInMemory } from '../../graph/edge-filter.js';
+import { openDb } from '../../storage/db.js';
+import { join } from 'path';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import type { MonographEdge } from '../../types.js';
+
+function makeTempDb() {
+  const dir = mkdtempSync(join(tmpdir(), 'monograph-edge-filter-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>,
+  id: string,
+  src: string,
+  tgt: string,
+  relation = 'CALLS',
+  confidence = 'EXTRACTED',
+  score = 1.0,
+) {
+  db.prepare(
+    `INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(id, src, tgt, relation, confidence, score);
+}
+
+describe('filterEdges (DB-backed)', () => {
+  it('returns all edges when no filter options are given', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 1.0);
+    insertEdge(db, 'e2', 'b', 'c', 'IMPORTS', 'INFERRED', 0.5);
+    const result = filterEdges(db);
+    expect(result).toHaveLength(2);
+    db.close();
+  });
+
+  it('filters by relation type', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 1.0);
+    insertEdge(db, 'e2', 'b', 'c', 'IMPORTS', 'EXTRACTED', 1.0);
+    const result = filterEdges(db, { relations: ['CALLS'] });
+    expect(result).toHaveLength(1);
+    expect(result[0].relation).toBe('CALLS');
+    db.close();
+  });
+
+  it('filters by confidence label', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 1.0);
+    insertEdge(db, 'e2', 'b', 'c', 'CALLS', 'INFERRED', 0.5);
+    const result = filterEdges(db, { confidences: ['INFERRED'] });
+    expect(result).toHaveLength(1);
+    expect(result[0].confidence).toBe('INFERRED');
+    db.close();
+  });
+
+  it('filters by minConfidenceScore', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 0.9);
+    insertEdge(db, 'e2', 'b', 'c', 'CALLS', 'INFERRED', 0.3);
+    const result = filterEdges(db, { minConfidenceScore: 0.8 });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('e1');
+    db.close();
+  });
+
+  it('filters by maxConfidenceScore', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 0.9);
+    insertEdge(db, 'e2', 'b', 'c', 'CALLS', 'AMBIGUOUS', 0.2);
+    const result = filterEdges(db, { maxConfidenceScore: 0.5 });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('e2');
+    db.close();
+  });
+
+  it('combines relation and confidence filters (AND)', () => {
+    const db = makeTempDb();
+    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
+    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'EXTRACTED', 1.0);
+    insertEdge(db, 'e2', 'b', 'c', 'IMPORTS', 'INFERRED', 0.5);
+    insertEdge(db, 'e3', 'a', 'c', 'CALLS', 'INFERRED', 0.5);
+    const result = filterEdges(db, { relations: ['CALLS'], confidences: ['INFERRED'] });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('e3');
+    db.close();
+  });
+});
+
+describe('filterEdgesInMemory', () => {
+  const edges: MonographEdge[] = [
+    { id: 'e1', sourceId: 'a', targetId: 'b', relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0 },
+    { id: 'e2', sourceId: 'b', targetId: 'c', relation: 'IMPORTS', confidence: 'INFERRED', confidenceScore: 0.5 },
+    { id: 'e3', sourceId: 'c', targetId: 'a', relation: 'CALLS', confidence: 'AMBIGUOUS', confidenceScore: 0.2 },
+  ];
+
+  it('returns all edges with no options', () => {
+    expect(filterEdgesInMemory(edges)).toHaveLength(3);
+  });
+
+  it('filters by relation', () => {
+    const result = filterEdgesInMemory(edges, { relations: ['CALLS'] });
+    expect(result).toHaveLength(2);
+  });
+
+  it('filters by confidence', () => {
+    const result = filterEdgesInMemory(edges, { confidences: ['EXTRACTED'] });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('e1');
+  });
+
+  it('filters by minConfidenceScore and maxConfidenceScore', () => {
+    const result = filterEdgesInMemory(edges, { minConfidenceScore: 0.3, maxConfidenceScore: 0.8 });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('e2');
+  });
+});