@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/pipeline/phases/variables.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractVariables } from '../../../src/pipeline/phases/variables.js';
-
-describe('extractVariables', () => {
-  it('extracts top-level const declarations', () => {
-    const src = `export const MAX_RETRIES = 3;\nconst DEFAULT_TIMEOUT = 5000;`;
-    const vars = extractVariables(src, 'src/config.ts');
-    expect(vars.some(v => v.name === 'MAX_RETRIES' && v.isExported)).toBe(true);
-    expect(vars.some(v => v.name === 'DEFAULT_TIMEOUT' && !v.isExported)).toBe(true);
-  });
-
-  it('extracts let declarations', () => {
-    const src = `let count = 0;\nexport let currentUser: User | null = null;`;
-    const vars = extractVariables(src, 'src/state.ts');
-    expect(vars.some(v => v.name === 'count')).toBe(true);
-    expect(vars.some(v => v.name === 'currentUser' && v.isExported)).toBe(true);
-  });
-
-  it('does not extract variables inside functions', () => {
-    const src = `function fn() { const inner = 1; }\nconst outer = 2;`;
-    const vars = extractVariables(src, 'src/a.ts');
-    expect(vars.some(v => v.name === 'outer')).toBe(true);
-    expect(vars.some(v => v.name === 'inner')).toBe(false);
-  });
-
-  it('returns empty array for files with no variables', () => {
-    const src = `class Foo {}`;
-    expect(extractVariables(src, 'src/a.ts')).toHaveLength(0);
-  });
-});

package/__tests__/pipeline/phases/wildcard-synthesis.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  extractWildcardBindings,
-  extractWildcardMemberAccesses,
-  synthesizeWildcardImports,
-} from '../../../src/pipeline/phases/wildcard-synthesis.js';
-import type { MonographNode, MonographEdge } from '../../../src/types.js';
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function makeNode(overrides: Partial<MonographNode> & { id: string; name: string }): MonographNode {
-  return {
-    label: 'Function',
-    normLabel: overrides.name.toLowerCase(),
-    isExported: true,
-    ...overrides,
-  };
-}
-
-// ── extractWildcardBindings ───────────────────────────────────────────────────
-
-describe('extractWildcardBindings', () => {
-  it('detects a single wildcard import with single quotes', () => {
-    const src = `import * as utils from './utils';`;
-    const bindings = extractWildcardBindings(src);
-    expect(bindings).toHaveLength(1);
-    expect(bindings[0]).toEqual({ alias: 'utils', moduleSpecifier: './utils' });
-  });
-
-  it('detects a wildcard import with double quotes', () => {
-    const src = `import * as helpers from "../helpers"`;
-    const bindings = extractWildcardBindings(src);
-    expect(bindings).toHaveLength(1);
-    expect(bindings[0]).toEqual({ alias: 'helpers', moduleSpecifier: '../helpers' });
-  });
-
-  it('detects multiple wildcard imports', () => {
-    const src = [
-      `import * as ns1 from './module-a';`,
-      `import * as ns2 from './module-b';`,
-      `import { foo } from './module-c';`,
-    ].join('\n');
-    const bindings = extractWildcardBindings(src);
-    expect(bindings).toHaveLength(2);
-    expect(bindings.map(b => b.alias)).toEqual(['ns1', 'ns2']);
-  });
-
-  it('returns empty array when no wildcard imports exist', () => {
-    const src = `import { foo, bar } from './utils';\nimport DefaultExport from './default';`;
-    expect(extractWildcardBindings(src)).toHaveLength(0);
-  });
-
-  it('is not confused by regular imports containing "as"', () => {
-    const src = `import { foo as bar } from './utils';`;
-    expect(extractWildcardBindings(src)).toHaveLength(0);
-  });
-});
-
-// ── extractWildcardMemberAccesses ─────────────────────────────────────────────
-
-describe('extractWildcardMemberAccesses', () => {
-  it('detects a simple member access', () => {
-    const src = `const x = ns.foo();`;
-    const accesses = extractWildcardMemberAccesses(src, 'ns');
-    expect(accesses).toHaveLength(1);
-    expect(accesses[0]).toMatchObject({ alias: 'ns', member: 'foo', line: 1 });
-  });
-
-  it('detects multiple different members on different lines', () => {
-    const src = [`ns.alpha();`, `ns.beta = 1;`, `console.log(ns.gamma);`].join('\n');
-    const accesses = extractWildcardMemberAccesses(src, 'ns');
-    expect(accesses.map(a => a.member)).toEqual(['alpha', 'beta', 'gamma']);
-    expect(accesses.map(a => a.line)).toEqual([1, 2, 3]);
-  });
-
-  it('deduplicates the same member accessed multiple times on the same line', () => {
-    const src = `if (ns.enabled && ns.enabled) {}`;
-    const accesses = extractWildcardMemberAccesses(src, 'ns');
-    const enabledAccesses = accesses.filter(a => a.member === 'enabled');
-    expect(enabledAccesses).toHaveLength(1);
-  });
-
-  it('does not match a different namespace with similar prefix', () => {
-    const src = `nsExtra.foo(); ns.bar();`;
-    const accesses = extractWildcardMemberAccesses(src, 'ns');
-    expect(accesses.map(a => a.member)).toEqual(['bar']);
-  });
-
-  it('returns empty array when alias is never used as a member accessor', () => {
-    const src = `const ns = 1;\nconsole.log(ns);`;
-    expect(extractWildcardMemberAccesses(src, 'ns')).toHaveLength(0);
-  });
-});
-
-// ── synthesizeWildcardImports ─────────────────────────────────────────────────
-
-describe('synthesizeWildcardImports', () => {
-  it('creates an IMPORTS edge from source file to the accessed exported symbol', () => {
-    const src = [
-      `import * as utils from './utils';`,
-      `utils.formatDate();`,
-    ].join('\n');
-
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/utils.ts:formatDate', name: 'formatDate', filePath: 'src/utils.ts' }),
-    ];
-
-    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, []);
-
-    expect(result.synthesizedEdges).toHaveLength(1);
-    const edge = result.synthesizedEdges[0];
-    expect(edge.sourceId).toBe('file:src/app.ts');
-    expect(edge.targetId).toBe('fn:src/utils.ts:formatDate');
-    expect(edge.relation).toBe('IMPORTS');
-    expect(edge.confidence).toBe('INFERRED');
-  });
-
-  it('creates edges for multiple member accesses', () => {
-    const src = [
-      `import * as math from './math';`,
-      `math.add(1, 2);`,
-      `math.subtract(5, 3);`,
-    ].join('\n');
-
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/math.ts:add', name: 'add', filePath: 'src/math.ts' }),
-      makeNode({ id: 'fn:src/math.ts:subtract', name: 'subtract', filePath: 'src/math.ts' }),
-    ];
-
-    const result = synthesizeWildcardImports('file:src/calc.ts', src, nodes, []);
-
-    const memberNames = result.synthesizedEdges.map(e => {
-      const target = nodes.find(n => n.id === e.targetId);
-      return target?.name;
-    });
-    expect(memberNames.sort()).toEqual(['add', 'subtract']);
-  });
-
-  it('does not create edges for non-exported symbols', () => {
-    const src = [
-      `import * as internal from './internal';`,
-      `internal.privateHelper();`,
-    ].join('\n');
-
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/internal.ts:privateHelper', name: 'privateHelper', isExported: false }),
-    ];
-
-    const result = synthesizeWildcardImports('file:src/consumer.ts', src, nodes, []);
-    expect(result.synthesizedEdges).toHaveLength(0);
-  });
-
-  it('does not duplicate edges that already exist', () => {
-    const src = [
-      `import * as utils from './utils';`,
-      `utils.helper();`,
-    ].join('\n');
-
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/utils.ts:helper', name: 'helper' }),
-    ];
-
-    const existingEdge: MonographEdge = {
-      id: 'file_src_app_ts_fn_src_utils_ts_helper_wildcard_helper',
-      sourceId: 'file:src/app.ts',
-      targetId: 'fn:src/utils.ts:helper',
-      relation: 'IMPORTS',
-      confidence: 'INFERRED',
-      confidenceScore: 0.5,
-    };
-
-    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, [existingEdge]);
-    expect(result.synthesizedEdges).toHaveLength(0);
-  });
-
-  it('returns empty result when there are no wildcard imports', () => {
-    const src = `import { foo } from './utils';\nfoo();`;
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/utils.ts:foo', name: 'foo' }),
-    ];
-    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, []);
-    expect(result.synthesizedEdges).toHaveLength(0);
-  });
-
-  it('handles multiple wildcard imports from different modules', () => {
-    const src = [
-      `import * as a from './module-a';`,
-      `import * as b from './module-b';`,
-      `a.alpha();`,
-      `b.beta();`,
-    ].join('\n');
-
-    const nodes: MonographNode[] = [
-      makeNode({ id: 'fn:src/module-a.ts:alpha', name: 'alpha', filePath: 'src/module-a.ts' }),
-      makeNode({ id: 'fn:src/module-b.ts:beta', name: 'beta', filePath: 'src/module-b.ts' }),
-    ];
-
-    const result = synthesizeWildcardImports('file:src/consumer.ts', src, nodes, []);
-    expect(result.synthesizedEdges).toHaveLength(2);
-  });
-
-  it('returns empty result when source is empty', () => {
-    expect(synthesizeWildcardImports('file:src/empty.ts', '', [], [])).toEqual({
-      synthesizedEdges: [],
-    });
-  });
-});

package/__tests__/pipeline/phases.test.ts

@@ -1,41 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-import { scanPhase } from '../../src/pipeline/phases/scan.js';
-import { structurePhase } from '../../src/pipeline/phases/structure.js';
-import type { PipelineContext } from '../../src/pipeline/types.js';
-
-const tmpRepo = join(tmpdir(), `monograph-test-repo-${Date.now()}`);
-
-beforeAll(() => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-  writeFileSync(join(tmpRepo, 'src', 'index.ts'), 'export const x = 1;');
-  writeFileSync(join(tmpRepo, 'src', 'util.py'), 'def helper(): pass');
-});
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-const ctx = {
-  repoPath: tmpRepo,
-  onProgress: vi.fn(),
-  options: { codeOnly: false, ignore: [], maxFileSizeBytes: 524288, workerPoolThreshold: 15, workerChunkBudgetBytes: 20971520 },
-} as unknown as PipelineContext;
-
-describe('scan phase', () => {
-  it('finds source files', async () => {
-    const outputs = new Map<string, unknown>();
-    const result = await scanPhase.execute(ctx, outputs) as { filePaths: string[] };
-    expect(result.filePaths.length).toBeGreaterThan(0);
-    expect(result.filePaths.some(p => p.endsWith('index.ts'))).toBe(true);
-  });
-});
-
-describe('structure phase', () => {
-  it('creates File and Folder nodes', async () => {
-    const outputs = new Map<string, unknown>();
-    const scanOutput = await scanPhase.execute(ctx, outputs);
-    outputs.set('scan', scanOutput);
-    const result = await structurePhase.execute(ctx, outputs) as { fileNodes: unknown[] };
-    expect(result.fileNodes.length).toBeGreaterThan(0);
-  });
-});

package/__tests__/pipeline/runner.test.ts

@@ -1,28 +0,0 @@
-import { PipelineRunner } from '../../src/pipeline/runner.js';
-import type { PipelinePhase, PipelineContext } from '../../src/pipeline/types.js';
-
-describe('PipelineRunner', () => {
-  it('executes phases in dependency order', async () => {
-    const order: string[] = [];
-
-    const phases: PipelinePhase<unknown>[] = [
-      { name: 'c', deps: ['a', 'b'], execute: async () => { order.push('c'); return 'c'; } },
-      { name: 'a', deps: [],         execute: async () => { order.push('a'); return 'a'; } },
-      { name: 'b', deps: ['a'],      execute: async () => { order.push('b'); return 'b'; } },
-    ];
-
-    const runner = new PipelineRunner(phases);
-    await runner.run({} as PipelineContext);
-
-    expect(order.indexOf('a')).toBeLessThan(order.indexOf('b'));
-    expect(order.indexOf('b')).toBeLessThan(order.indexOf('c'));
-  });
-
-  it('throws on cycle detection', () => {
-    const phases: PipelinePhase<unknown>[] = [
-      { name: 'a', deps: ['b'], execute: async () => null },
-      { name: 'b', deps: ['a'], execute: async () => null },
-    ];
-    expect(() => new PipelineRunner(phases)).toThrow(/cycle/i);
-  });
-});

package/__tests__/registry/repo-registry.test.ts

@@ -1,127 +0,0 @@
-/**
- * Tests for repo-registry.ts
- *
- * Uses MONOGRAPH_REGISTRY_PATH env var to point at a temp directory,
- * avoiding any writes to ~/.monograph/registry.json during tests.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  getRegistryPath,
-  loadRegistry,
-  registerRepo,
-  unregisterRepo,
-  listRepos,
-} from '../../src/registry/repo-registry.js';
-
-let tempDir: string;
-
-beforeEach(() => {
-  tempDir = mkdtempSync(join(tmpdir(), 'monograph-registry-test-'));
-  vi.stubEnv('MONOGRAPH_REGISTRY_PATH', join(tempDir, 'registry.json'));
-});
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-  rmSync(tempDir, { recursive: true, force: true });
-});
-
-describe('getRegistryPath', () => {
-  it('returns the path set via env var', () => {
-    const p = getRegistryPath();
-    expect(p).toBe(join(tempDir, 'registry.json'));
-  });
-});
-
-describe('loadRegistry', () => {
-  it('returns empty registry when file does not exist', () => {
-    const reg = loadRegistry();
-    expect(reg).toEqual({ repos: [] });
-  });
-});
-
-describe('registerRepo', () => {
-  it('adds a new repo entry', () => {
-    registerRepo('/projects/alpha', { nodeCount: 100, edgeCount: 200 });
-    const repos = listRepos();
-    expect(repos).toHaveLength(1);
-    expect(repos[0].path).toBe('/projects/alpha');
-    expect(repos[0].name).toBe('alpha');
-    expect(repos[0].nodeCount).toBe(100);
-    expect(repos[0].edgeCount).toBe(200);
-    expect(repos[0].lastIndexed).toBeTruthy();
-  });
-
-  it('upserts an existing repo (updates timestamp and counts)', async () => {
-    registerRepo('/projects/alpha', { nodeCount: 50 });
-    const firstIndexed = listRepos()[0].lastIndexed;
-
-    await new Promise((r) => setTimeout(r, 10));
-    registerRepo('/projects/alpha', { nodeCount: 150, edgeCount: 300 });
-
-    const repos = listRepos();
-    expect(repos).toHaveLength(1);
-    expect(repos[0].nodeCount).toBe(150);
-    expect(repos[0].edgeCount).toBe(300);
-    expect(repos[0].lastIndexed).not.toBe(firstIndexed);
-  });
-
-  it('handles multiple repos independently', () => {
-    registerRepo('/projects/alpha');
-    registerRepo('/projects/beta');
-    registerRepo('/projects/gamma');
-    const repos = listRepos();
-    expect(repos).toHaveLength(3);
-    const names = repos.map((r) => r.name).sort();
-    expect(names).toEqual(['alpha', 'beta', 'gamma']);
-  });
-});
-
-describe('unregisterRepo', () => {
-  it('removes a registered repo', () => {
-    registerRepo('/projects/alpha');
-    registerRepo('/projects/beta');
-    unregisterRepo('/projects/alpha');
-    const repos = listRepos();
-    expect(repos).toHaveLength(1);
-    expect(repos[0].path).toBe('/projects/beta');
-  });
-
-  it('is a no-op when path is not registered', () => {
-    registerRepo('/projects/alpha');
-    unregisterRepo('/projects/nonexistent');
-    expect(listRepos()).toHaveLength(1);
-  });
-});
-
-describe('listRepos', () => {
-  it('returns repos sorted alphabetically by name', () => {
-    registerRepo('/z/zebra');
-    registerRepo('/a/ant');
-    registerRepo('/m/monkey');
-    const names = listRepos().map((r) => r.name);
-    expect(names).toEqual(['ant', 'monkey', 'zebra']);
-  });
-
-  it('returns empty array when no repos are registered', () => {
-    expect(listRepos()).toEqual([]);
-  });
-});
-
-describe('saveRegistry / loadRegistry round-trip', () => {
-  it('persists and reloads registry correctly', () => {
-    registerRepo('/projects/alpha', { nodeCount: 42 });
-
-    expect(existsSync(getRegistryPath())).toBe(true);
-
-    const raw = JSON.parse(readFileSync(getRegistryPath(), 'utf8')) as { repos: unknown[] };
-    expect(raw.repos).toHaveLength(1);
-
-    const reloaded = loadRegistry();
-    expect(reloaded.repos[0].path).toBe('/projects/alpha');
-    expect((reloaded.repos[0] as { nodeCount: number }).nodeCount).toBe(42);
-  });
-});

package/__tests__/reporting/graph-report.suggest.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildMarkdownWithQuestions } from '../../src/reporting/graph-report.js';
-import type { SuggestedQuestion } from '../../src/types.js';
-
-describe('buildMarkdownWithQuestions', () => {
-  it('renders Suggested Questions section when questions provided', () => {
-    const questions: SuggestedQuestion[] = [
-      { type: 'bridge_node', node: { id: 'n1', name: 'UserService', label: 'Class' } as any, commA: 0, commB: 1 },
-      { type: 'ambiguous_edge', edge: { sourceId: 'n1', targetId: 'n2', confidence: 'AMBIGUOUS' } as any, reason: 'Dynamic dispatch' },
-      { type: 'isolated_nodes', nodes: [{ id: 'n3', name: 'Orphan', label: 'Function' } as any], reason: 'No edges' },
-    ];
-    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], questions);
-    expect(md).toContain('## Suggested Questions');
-    expect(md).toContain('bridge_node');
-    expect(md).toContain('UserService');
-    expect(md).toContain('ambiguous_edge');
-    expect(md).toContain('isolated_nodes');
-    expect(md).toContain('Orphan');
-  });
-
-  it('omits Suggested Questions section when no questions', () => {
-    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], []);
-    expect(md).not.toContain('## Suggested Questions');
-  });
-
-  it('caps rendered questions at 20', () => {
-    const questions: SuggestedQuestion[] = Array.from({ length: 25 }, (_, i) => ({
-      type: 'ambiguous_edge' as const,
-      edge: { sourceId: `n${i}`, targetId: `n${i}x`, confidence: 'AMBIGUOUS' } as any,
-      reason: 'test',
-    }));
-    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], questions);
-    const matches = md.match(/ambiguous_edge/g) ?? [];
-    expect(matches.length).toBeLessThanOrEqual(20);
-  });
-});

package/__tests__/reporting/graph-report.test.ts

@@ -1,165 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync, readFileSync, mkdirSync } from 'fs';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { insertNode } from '../../src/storage/node-store.js';
-import { insertEdge } from '../../src/storage/edge-store.js';
-import { generateGraphReport } from '../../src/reporting/graph-report.js';
-import type { MonographDb } from '../../src/storage/db.js';
-
-const testDir = join(tmpdir(), `monograph-report-${Date.now()}`);
-const dbPath = join(testDir, 'graph.db');
-const outputPath = join(testDir, 'GRAPH_REPORT.md');
-let db: MonographDb;
-
-beforeAll(() => {
-  mkdirSync(testDir, { recursive: true });
-  db = openDb(dbPath);
-
-  // Insert test nodes
-  insertNode(db, {
-    id: 'n1',
-    label: 'Function',
-    name: 'processData',
-    normLabel: 'processdata',
-    filePath: 'src/data.ts',
-    isExported: true,
-    communityId: 1,
-  });
-  insertNode(db, {
-    id: 'n2',
-    label: 'Class',
-    name: 'DataService',
-    normLabel: 'dataservice',
-    filePath: 'src/service.ts',
-    isExported: true,
-    communityId: 1,
-  });
-  insertNode(db, {
-    id: 'n3',
-    label: 'Function',
-    name: 'fetchItems',
-    normLabel: 'fetchitems',
-    filePath: 'src/api.ts',
-    isExported: false,
-    communityId: 2,
-  });
-  insertNode(db, {
-    id: 'n4',
-    label: 'Interface',
-    name: 'DataItem',
-    normLabel: 'dataitem',
-    filePath: 'src/types.ts',
-    isExported: true,
-  });
-
-  // Insert test edges
-  insertEdge(db, {
-    id: 'e1',
-    sourceId: 'n2',
-    targetId: 'n1',
-    relation: 'CALLS',
-    confidence: 'EXTRACTED',
-    confidenceScore: 1.0,
-  });
-  insertEdge(db, {
-    id: 'e2',
-    sourceId: 'n3',
-    targetId: 'n2',
-    relation: 'IMPORTS',
-    confidence: 'EXTRACTED',
-    confidenceScore: 1.0,
-  });
-  insertEdge(db, {
-    id: 'e3',
-    sourceId: 'n1',
-    targetId: 'n4',
-    relation: 'REFERENCES',
-    confidence: 'INFERRED',
-    confidenceScore: 0.5,
-  });
-
-  closeDb(db);
-});
-
-afterAll(() => {
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm', outputPath]) {
-    if (existsSync(p)) {
-      try { unlinkSync(p); } catch { /* ignore */ }
-    }
-  }
-});
-
-describe('generateGraphReport', () => {
-  it('returns GraphReportResult with correct shape', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-
-    expect(result).toMatchObject({
-      markdown: expect.any(String),
-      path: outputPath,
-      stats: {
-        nodeCount: expect.any(Number),
-        edgeCount: expect.any(Number),
-        communityCount: expect.any(Number),
-      },
-    });
-  });
-
-  it('markdown contains # Graph Report header', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.markdown).toContain('# Graph Report');
-  });
-
-  it('markdown contains node count in summary', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.stats.nodeCount).toBe(4);
-    expect(result.markdown).toContain('4');
-  });
-
-  it('markdown contains edge count in summary', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.stats.edgeCount).toBe(3);
-    expect(result.markdown).toContain('3');
-  });
-
-  it('writes file to the specified output path', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(existsSync(result.path)).toBe(true);
-    const contents = readFileSync(result.path, 'utf8');
-    expect(contents).toBe(result.markdown);
-  });
-
-  it('markdown contains Nodes by Type section', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.markdown).toContain('## Nodes by Type');
-    expect(result.markdown).toContain('Function');
-    expect(result.markdown).toContain('Class');
-  });
-
-  it('markdown contains Edges by Relation section', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.markdown).toContain('## Edges by Relation');
-    expect(result.markdown).toContain('CALLS');
-    expect(result.markdown).toContain('IMPORTS');
-  });
-
-  it('markdown contains Top Nodes by Degree section', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.markdown).toContain('## Top Nodes by Degree');
-  });
-
-  it('stats reflect actual DB content', async () => {
-    const result = await generateGraphReport(testDir, outputPath, dbPath);
-    expect(result.stats.nodeCount).toBe(4);
-    expect(result.stats.edgeCount).toBe(3);
-    // 2 communities (id 1 and 2)
-    expect(result.stats.communityCount).toBe(2);
-  });
-
-  it('uses default output path when not specified', async () => {
-    const result = await generateGraphReport(testDir, undefined, dbPath);
-    expect(result.path).toBe(join(testDir, 'GRAPH_REPORT.md'));
-    if (existsSync(result.path)) unlinkSync(result.path);
-  });
-});