@monoes/monograph 1.5.6 → 1.5.8

package/src/__tests__/pipeline/phases/import-resolver.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { detectWorkspacePackages, resolveWorkspaceImport, type WorkspacePackage } from '../../../pipeline/phases/import-resolver.js';
-
-describe('detectWorkspacePackages', () => {
-  let tmpDir: string;
-
-  beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), 'monorepo-test-')); });
-  afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
-
-  it('detects npm workspace packages', () => {
-    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({
-      workspaces: ['packages/*'],
-    }));
-    mkdirSync(join(tmpDir, 'packages', 'core'), { recursive: true });
-    mkdirSync(join(tmpDir, 'packages', 'utils'), { recursive: true });
-    writeFileSync(join(tmpDir, 'packages', 'core', 'package.json'), JSON.stringify({ name: '@myapp/core' }));
-    writeFileSync(join(tmpDir, 'packages', 'utils', 'package.json'), JSON.stringify({ name: '@myapp/utils' }));
-
-    const packages = detectWorkspacePackages(tmpDir);
-    const names = packages.map(p => p.name);
-    expect(names).toContain('@myapp/core');
-    expect(names).toContain('@myapp/utils');
-  });
-
-  it('returns empty array when no workspace config', () => {
-    const packages = detectWorkspacePackages(tmpDir);
-    expect(packages).toEqual([]);
-  });
-});
-
-describe('resolveWorkspaceImport', () => {
-  it('resolves a workspace package name to its local path', () => {
-    const packages: WorkspacePackage[] = [
-      { name: '@myapp/core', path: '/repo/packages/core' },
-      { name: '@myapp/utils', path: '/repo/packages/utils' },
-    ];
-    const result = resolveWorkspaceImport('@myapp/core', packages);
-    expect(result).toBe('/repo/packages/core');
-  });
-
-  it('returns null for a non-workspace import', () => {
-    const packages: WorkspacePackage[] = [
-      { name: '@myapp/core', path: '/repo/packages/core' },
-    ];
-    const result = resolveWorkspaceImport('lodash', packages);
-    expect(result).toBeNull();
-  });
-
-  it('returns null for empty packages list', () => {
-    const result = resolveWorkspaceImport('@myapp/core', []);
-    expect(result).toBeNull();
-  });
-
-  it('handles scoped packages with subpath (@scope/pkg/subpath)', () => {
-    const packages: WorkspacePackage[] = [
-      { name: '@myapp/core', path: '/repo/packages/core' },
-    ];
-    const result = resolveWorkspaceImport('@myapp/core/utils', packages);
-    expect(result).toBe('/repo/packages/core');
-  });
-});

package/src/__tests__/pipeline/phases/parse-arrow.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractArrowFunctions } from '../../../pipeline/phases/parse.js';
-
-const ARROW_SOURCE = `
-export const handleRequest = async (req, res) => {
-  res.send('ok');
-};
-
-const helper = (x) => x * 2;
-export const transform = (items) => items.map(helper);
-`;
-
-describe('parse phase arrow functions', () => {
-  it('extracts named arrow functions as Function nodes', () => {
-    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
-    const names = nodes.map(n => n.name);
-    expect(names).toContain('handleRequest');
-    expect(names).toContain('helper');
-    expect(names).toContain('transform');
-  });
-
-  it('marks exported arrow functions as exported', () => {
-    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
-    const handleRequest = nodes.find(n => n.name === 'handleRequest');
-    expect(handleRequest?.isExported).toBe(true);
-  });
-
-  it('marks non-exported arrow functions as not exported', () => {
-    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
-    const helper = nodes.find(n => n.name === 'helper');
-    expect(helper?.isExported).toBe(false);
-  });
-});

package/src/__tests__/pipeline/phases/parse-csharp.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractCsharpNamespaces } from '../../../pipeline/phases/parse.js';
-
-const CSHARP_SOURCE = `
-namespace MyApp.Services {
-  public class PaymentService {
-    public void Process() {}
-  }
-}
-
-namespace MyApp.Models {
-  public class Order {}
-}
-`;
-
-describe('C# namespace extraction', () => {
-  it('extracts namespace declarations', () => {
-    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
-    const names = result.map(n => n.name);
-    expect(names).toContain('MyApp.Services');
-    expect(names).toContain('MyApp.Models');
-  });
-
-  it('returns Namespace label', () => {
-    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
-    expect(result.every(n => n.label === 'Namespace')).toBe(true);
-  });
-
-  it('returns correct file path', () => {
-    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
-    expect(result.every(n => n.filePath === '/PaymentService.cs')).toBe(true);
-  });
-});

package/src/__tests__/pipeline/phases/scan.monographignore.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { scanPhase } from '../../../pipeline/phases/scan.js';
-
-function makeCtx(repoPath: string, ignore: string[] = []): any {
-  return { repoPath, options: { ignore, codeOnly: false }, onProgress: undefined };
-}
-
-describe('scanPhase .monographignore', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'scan-ignore-test-'));
-    writeFileSync(join(tmpDir, 'app.ts'), 'export const x = 1;');
-    mkdirSync(join(tmpDir, 'generated'));
-    writeFileSync(join(tmpDir, 'generated', 'schema.ts'), 'export type T = string;');
-    writeFileSync(join(tmpDir, 'generated', 'types.ts'), 'export type U = number;');
-    mkdirSync(join(tmpDir, 'dist'));
-    writeFileSync(join(tmpDir, 'dist', 'index.js'), 'module.exports = {};');
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('respects .monographignore glob patterns for directories', async () => {
-    writeFileSync(join(tmpDir, '.monographignore'), 'generated/\n');
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
-    expect(names.some((n: string) => n.includes('generated'))).toBe(false);
-    expect(names.some((n: string) => n.includes('app.ts'))).toBe(true);
-  });
-
-  it('works fine when .monographignore does not exist', async () => {
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    expect(out.filePaths.length).toBeGreaterThan(0);
-  });
-
-  it('handles empty .monographignore', async () => {
-    writeFileSync(join(tmpDir, '.monographignore'), '');
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    expect(out.filePaths.some((p: string) => p.includes('generated'))).toBe(true);
-  });
-
-  it('ignores comment lines in .monographignore', async () => {
-    writeFileSync(join(tmpDir, '.monographignore'), '# This is a comment\ngenerated/\n');
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
-    expect(names.some((n: string) => n.includes('generated'))).toBe(false);
-  });
-});

package/src/__tests__/pipeline/phases/scan.negation.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { scanPhase } from '../../../pipeline/phases/scan.js';
-
-function makeCtx(repoPath: string): any {
-  return { repoPath, options: { ignore: [], codeOnly: false }, onProgress: undefined };
-}
-
-describe('scanPhase .monographignore negation', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'scan-neg-test-'));
-    mkdirSync(join(tmpDir, 'generated'));
-    writeFileSync(join(tmpDir, 'generated', 'schema.ts'), 'export type T = string;');
-    writeFileSync(join(tmpDir, 'generated', 'keep-this.ts'), 'export type K = number;');
-    writeFileSync(join(tmpDir, 'app.ts'), 'export const x = 1;');
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('negation pattern !file preserves file even when parent dir is ignored', async () => {
-    // Ignore all generated/ but keep keep-this.ts via negation
-    writeFileSync(join(tmpDir, '.monographignore'), 'generated/\n!generated/keep-this.ts\n');
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
-    expect(names.some((n: string) => n.includes('keep-this.ts'))).toBe(true);
-    expect(names.some((n: string) => n.includes('schema.ts'))).toBe(false);
-  });
-
-  it('negation without prior ignore is a no-op (file already included)', async () => {
-    writeFileSync(join(tmpDir, '.monographignore'), '!app.ts\n');
-    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
-    expect(out.filePaths.some((p: string) => p.includes('app.ts'))).toBe(true);
-  });
-});

package/src/__tests__/pipeline/phases/scope-resolution.go.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractGoCallSites } from '../../../pipeline/phases/scope-resolution.js';
-
-describe('extractGoCallSites', () => {
-  it('extracts method calls (receiver.Method)', () => {
-    const source = `
-func run(s *Server) {
-  s.Listen(":8080")
-  db.Query("SELECT 1")
-}`;
-    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
-    expect(sites.some(s => s.calleeRaw === 's.Listen')).toBe(true);
-    expect(sites.some(s => s.calleeRaw === 'db.Query')).toBe(true);
-  });
-
-  it('extracts direct function calls', () => {
-    const source = `
-func init() {
-  setupRoutes()
-  fmt.Println("started")
-}`;
-    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
-    expect(sites.some(s => s.calleeRaw === 'setupRoutes')).toBe(true);
-  });
-
-  it('skips Go keywords', () => {
-    const source = `for i := range items { if ok { return } }`;
-    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
-    const names = sites.map(s => s.calleeRaw);
-    expect(names).not.toContain('for');
-    expect(names).not.toContain('if');
-    expect(names).not.toContain('return');
-  });
-});

package/src/__tests__/pipeline/phases/scope-resolution.java.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractJavaCallSites } from '../../../pipeline/phases/scope-resolution.js';
-
-describe('extractJavaCallSites', () => {
-  it('extracts method calls', () => {
-    const source = `
-public void run() {
-  service.process(request);
-  logger.info("done");
-}`;
-    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
-    expect(sites.some(s => s.calleeRaw === 'service.process')).toBe(true);
-    expect(sites.some(s => s.calleeRaw === 'logger.info')).toBe(true);
-  });
-
-  it('extracts direct function calls', () => {
-    const source = `Objects.requireNonNull(val);`;
-    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
-    expect(sites.length).toBeGreaterThan(0);
-  });
-
-  it('skips Java keywords', () => {
-    const source = `if (x) { for (int i = 0; i < 10; i++) { return; } }`;
-    const sites = extractJavaCallSites(source, '/src/Main.java', 'fn1');
-    const names = sites.map(s => s.calleeRaw);
-    expect(names).not.toContain('if');
-    expect(names).not.toContain('for');
-    expect(names).not.toContain('return');
-  });
-});

package/src/__tests__/pipeline/phases/scope-resolution.rust.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractRustCallSites } from '../../../pipeline/phases/scope-resolution.js';
-
-describe('extractRustCallSites', () => {
-  it('extracts method calls', () => {
-    const source = `
-fn main() {
-  server.run();
-  db.connect("sqlite::memory:");
-}`;
-    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
-    expect(sites.some(s => s.calleeRaw === 'server.run')).toBe(true);
-    expect(sites.some(s => s.calleeRaw === 'db.connect')).toBe(true);
-  });
-
-  it('extracts direct function calls', () => {
-    const source = `fn setup() { init_logging(); register_handlers(); }`;
-    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
-    expect(sites.some(s => s.calleeRaw === 'init_logging')).toBe(true);
-    expect(sites.some(s => s.calleeRaw === 'register_handlers')).toBe(true);
-  });
-
-  it('skips Rust keywords', () => {
-    const source = `if let Some(x) = val { for item in list { return Ok(()); } }`;
-    const sites = extractRustCallSites(source, '/src/main.rs', 'fn1');
-    const names = sites.map(s => s.calleeRaw);
-    expect(names).not.toContain('if');
-    expect(names).not.toContain('for');
-    expect(names).not.toContain('return');
-  });
-});

package/src/__tests__/pipeline/phases/suggest-questions.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { suggestPhase } from '../../../pipeline/phases/suggest.js';
-import type { PipelineContext } from '../../../pipeline/types.js';
-
-function makeCtx(db: Database.Database): PipelineContext {
-  return { repoPath: '/tmp', db, graph: {} as any, options: { ignore: [], codeOnly: false } as any, onProgress: () => {} } as any;
-}
-
-function makeDeps(edges: any[], nodes: any[], memberships = new Map<string, number>()) {
-  return new Map([
-    ['parse', { allEdges: edges, symbolNodes: nodes, parseErrors: [], fileContents: new Map() }],
-    ['cross-file', { resolvedEdges: [], importGraph: new Map() }],
-    ['communities', { memberships }],
-    ['mro', { mroEdges: [] }],
-    ['god-nodes', { godNodes: [] }],
-    ['surprises', { surprises: [] }],
-  ]);
-}
-
-describe('suggestPhase question types', () => {
-  it('generates no_signal question for AMBIGUOUS edges with no evidence', async () => {
-    const db = new Database(':memory:');
-    const edges = [{ id: 'e1', sourceId: 'n1', targetId: 'n2', relation: 'CALLS', confidence: 'AMBIGUOUS', confidenceScore: 0.1 }];
-    const nodes = [
-      { id: 'n1', label: 'Function', name: 'doA', isExported: true, normLabel: 'function' },
-      { id: 'n2', label: 'Function', name: 'doB', isExported: true, normLabel: 'function' },
-    ];
-    const result = await suggestPhase.execute(makeCtx(db), makeDeps(edges, nodes));
-    const types = result.questions.map((q: any) => q.type);
-    expect(types).toContain('no_signal');
-  });
-
-  it('generates thin_community question for community with fewer than 3 members', async () => {
-    const db = new Database(':memory:');
-    const edges: any[] = [];
-    const nodes = [
-      { id: 'n1', label: 'Function', name: 'a', isExported: true, normLabel: 'function' },
-      { id: 'n2', label: 'Function', name: 'b', isExported: true, normLabel: 'function' },
-    ];
-    const memberships = new Map([['n1', 5], ['n2', 5]]);
-    const result = await suggestPhase.execute(makeCtx(db), makeDeps(edges, nodes, memberships));
-    const types = result.questions.map((q: any) => q.type);
-    expect(types).toContain('thin_community');
-  });
-});

package/src/__tests__/pipeline/phases/surprises-scoring.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { surprisesPhase } from '../../../pipeline/phases/surprises.js';
-import type { PipelineContext } from '../../../pipeline/types.js';
-
-function makeCtx(db: Database.Database): PipelineContext {
-  return { repoPath: '/tmp', db, graph: {} as any, options: { ignore: [], codeOnly: false } as any, onProgress: () => {} } as any;
-}
-
-describe('surprises 5-factor scoring', () => {
-  it('cross-filetype edges score higher than same-filetype', async () => {
-    // Labels are uniform (all 'Function') and all in same community so that
-    // crossType and crossCommunity bonuses are equal for both edges.
-    // The only differentiator is file type: e1 crosses CODE→DOCUMENT, e2 stays CODE→CODE.
-    const parseOutput = {
-      allEdges: [
-        { id: 'e1', sourceId: 'n1', targetId: 'n2', relation: 'REFERENCES', confidence: 'INFERRED', confidenceScore: 0.5 },
-        { id: 'e2', sourceId: 'n3', targetId: 'n4', relation: 'REFERENCES', confidence: 'INFERRED', confidenceScore: 0.5 },
-      ],
-      symbolNodes: [
-        { id: 'n1', label: 'Function', name: 'doStuff', filePath: '/src/a.ts', isExported: true, normLabel: 'function' },
-        { id: 'n2', label: 'Function', name: 'readme', filePath: '/docs/README.md', isExported: false, normLabel: 'function' },
-        { id: 'n3', label: 'Function', name: 'doOther', filePath: '/src/b.ts', isExported: true, normLabel: 'function' },
-        { id: 'n4', label: 'Function', name: 'helper', filePath: '/src/c.ts', isExported: true, normLabel: 'function' },
-      ],
-      parseErrors: [], fileContents: new Map(),
-    };
-    const crossFileOutput = { resolvedEdges: [], importGraph: new Map() };
-    // All nodes in same community so crossCommunity bonus is equal (zero) for both edges
-    const communitiesOutput = { memberships: new Map([['n1', 0], ['n2', 0], ['n3', 0], ['n4', 0]]) };
-
-    const db = new Database(':memory:');
-    const deps = new Map<string, any>([
-      ['parse', parseOutput],
-      ['cross-file', crossFileOutput],
-      ['communities', communitiesOutput],
-    ]);
-
-    const result = await surprisesPhase.execute(makeCtx(db), deps);
-    const crossType = result.surprises.find(s => s.edge.id === 'e1');
-    const sameType = result.surprises.find(s => s.edge.id === 'e2');
-    expect(crossType).toBeDefined();
-    expect(sameType).toBeDefined();
-    expect(crossType!.score).toBeGreaterThan(sameType!.score);
-  });
-});

package/src/__tests__/pipeline/phases/variables-phase.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { variablesPhase } from '../../../pipeline/phases/variables-phase.js';
-import type { PipelineContext } from '../../../pipeline/types.js';
-
-function makeDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE nodes (
-      id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
-      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
-      community_id INTEGER, is_exported INTEGER DEFAULT 0,
-      language TEXT, properties TEXT
-    );
-  `);
-  return db;
-}
-
-function makeCtx(db: Database.Database): PipelineContext {
-  return {
-    repoPath: '/tmp',
-    db,
-    graph: {} as any,
-    options: { ignore: [], codeOnly: false } as any,
-    onProgress: () => {},
-  } as any;
-}
-
-describe('variablesPhase', () => {
-  it('has name "variables" and deps ["parse"]', () => {
-    expect(variablesPhase.name).toBe('variables');
-    expect(variablesPhase.deps).toContain('parse');
-  });
-
-  it('inserts Variable nodes for exported consts', async () => {
-    const db = makeDb();
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [],
-      parseErrors: [],
-      fileContents: new Map([
-        ['/tmp/app.ts', 'export const API_URL = "https://example.com";\nconst SECRET = "x";'],
-      ]),
-    };
-    const deps = new Map([['parse', parseOutput]]);
-    await variablesPhase.execute(makeCtx(db), deps);
-    const rows = db.prepare('SELECT name, is_exported FROM nodes WHERE label = ?').all('Variable');
-    const names = (rows as any[]).map((r: any) => r.name);
-    expect(names).toContain('API_URL');
-  });
-
-  it('returns variableCount', async () => {
-    const db = makeDb();
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [],
-      parseErrors: [],
-      fileContents: new Map([
-        ['/tmp/b.ts', 'export const X = 1;\nexport const Y = 2;'],
-      ]),
-    };
-    const deps = new Map([['parse', parseOutput]]);
-    const result = await variablesPhase.execute(makeCtx(db), deps);
-    expect((result as any).variableCount).toBeGreaterThanOrEqual(2);
-  });
-
-  it('skips files with no variables gracefully', async () => {
-    const db = makeDb();
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [],
-      parseErrors: [],
-      fileContents: new Map([['/tmp/empty.ts', '// no vars here']]),
-    };
-    const deps = new Map([['parse', parseOutput]]);
-    await expect(variablesPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
-  });
-});

package/src/__tests__/pipeline/phases/wildcard-phase.test.ts

@@ -1,99 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { wildcardSynthesisPhase } from '../../../pipeline/phases/wildcard-phase.js';
-import type { PipelineContext } from '../../../pipeline/types.js';
-import { CREATE_NODES, CREATE_EDGES } from '../../../storage/schema.js';
-
-// Uses the REAL production schema (including the edges FK constraint on
-// source_id/target_id) with foreign_keys actually enabled — the original
-// hand-rolled test schema had neither, so it silently passed inserts that
-// would violate the real edges table's FK constraint in production (issue #40).
-function makeDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.pragma('foreign_keys = ON');
-  db.exec(CREATE_NODES);
-  db.exec(CREATE_EDGES);
-  db.exec(`
-    INSERT INTO nodes (id, label, name, norm_label, file_path, start_line, end_line, is_exported)
-      VALUES ('n1', 'Function', 'greet', 'greet', '/mod.ts', 1, 5, 1);
-    INSERT INTO nodes (id, label, name, norm_label, file_path, is_exported)
-      VALUES ('n2', 'File', 'main.ts', 'main.ts', '/main.ts', 0);
-  `);
-  return db;
-}
-
-function makeCtx(db: Database.Database): PipelineContext {
-  return {
-    repoPath: '/tmp',
-    db,
-    graph: {} as any,
-    options: { ignore: [], codeOnly: false } as any,
-    onProgress: () => {},
-  } as any;
-}
-
-describe('wildcardSynthesisPhase', () => {
-  it('has name "wildcard-synthesis" and deps including "parse" and "cross-file"', () => {
-    expect(wildcardSynthesisPhase.name).toBe('wildcard-synthesis');
-    expect(wildcardSynthesisPhase.deps).toContain('parse');
-    expect(wildcardSynthesisPhase.deps).toContain('cross-file');
-  });
-
-  it('synthesizes IMPORTS edges for wildcard namespace member accesses', async () => {
-    const db = makeDb();
-    const source = `import * as mod from '/mod.ts';\nmod.greet("hello");`;
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [
-        { id: 'n1', name: 'greet', label: 'Function', normLabel: 'greet', filePath: '/mod.ts', isExported: true },
-        { id: 'n2', name: 'main.ts', label: 'File', normLabel: 'main.ts', filePath: '/main.ts', isExported: false },
-      ],
-      parseErrors: [],
-      fileContents: new Map([['/main.ts', source]]),
-    };
-    const crossFileOutput = { resolvedEdges: [] };
-    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
-    const result = await wildcardSynthesisPhase.execute(makeCtx(db), deps);
-    expect((result as any).synthesizedCount).toBeGreaterThanOrEqual(0);
-  });
-
-  it('runs without error when no wildcard imports exist', async () => {
-    const db = makeDb();
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [],
-      parseErrors: [],
-      fileContents: new Map([['/main.ts', 'import { greet } from "./mod.js"; greet("hello");']]),
-    };
-    const crossFileOutput = { resolvedEdges: [] };
-    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
-    await expect(wildcardSynthesisPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
-  });
-
-  it('skips a file with no fileNodeIndex entry instead of fabricating a source_id and violating the edges FK constraint (issue #40)', async () => {
-    // Regression: a file with no parsed symbols (e.g. blank, or a filetype
-    // the parser emits no node for) has no entry in fileNodeIndex. The old
-    // code fell back to a fabricated `file:${filePath}` id that was never a
-    // real row in `nodes`, so the edge insert below violated the edges
-    // table's FOREIGN KEY constraint on source_id and crashed the whole
-    // monograph_build. /empty.ts here is exactly that case: it's present in
-    // fileContents (parsed) but has NO corresponding node in symbolNodes.
-    const db = makeDb();
-    const source = `import * as mod from '/mod.ts';\nmod.greet("hello");`;
-    const parseOutput = {
-      allEdges: [],
-      symbolNodes: [
-        { id: 'n1', name: 'greet', label: 'Function', normLabel: 'greet', filePath: '/mod.ts', isExported: true },
-      ],
-      parseErrors: [],
-      fileContents: new Map([['/empty.ts', source]]),
-    };
-    const crossFileOutput = { resolvedEdges: [] };
-    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
-
-    await expect(wildcardSynthesisPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
-
-    const edgeCount = (db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
-    expect(edgeCount).toBe(0); // nothing could legitimately attach to a file with no real node
-  });
-});