@monoes/monograph 1.5.5 → 1.5.7

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
-  });
-});

package/src/__tests__/pipeline/runner.parallel.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PipelineRunner } from '../../pipeline/runner.js';
-import type { PipelinePhase, PipelineContext } from '../../pipeline/types.js';
-
-function makeCtx(): PipelineContext {
-  return { repoPath: '/tmp', options: { ignore: [], codeOnly: false } } as any;
-}
-
-describe('PipelineRunner parallel execution', () => {
-  it('runs independent phases concurrently', async () => {
-    const startTimes: Record<string, number> = {};
-    const endTimes: Record<string, number> = {};
-
-    function makeDelayPhase(name: string, deps: string[], delayMs: number): PipelinePhase<{ name: string }> {
-      return {
-        name,
-        deps,
-        async execute() {
-          startTimes[name] = Date.now();
-          await new Promise(r => setTimeout(r, delayMs));
-          endTimes[name] = Date.now();
-          return { name };
-        },
-      };
-    }
-
-    // a and b are independent, c depends on both
-    const phases = [
-      makeDelayPhase('a', [], 50),
-      makeDelayPhase('b', [], 50),
-      makeDelayPhase('c', ['a', 'b'], 10),
-    ];
-
-    const runner = new PipelineRunner(phases);
-    const t0 = Date.now();
-    await runner.run(makeCtx());
-    const elapsed = Date.now() - t0;
-
-    // Sequential would take 110ms+; parallel finishes in ~65ms (200ms budget for CI/load variance)
-    expect(elapsed).toBeLessThan(200);
-  });
-
-  it('respects deps — c starts only after a and b finish', async () => {
-    const endTimes: Record<string, number> = {};
-    let cStartTime = 0;
-
-    const phases: PipelinePhase<unknown>[] = [
-      { name: 'a', deps: [], async execute() { await new Promise(r => setTimeout(r, 30)); endTimes['a'] = Date.now(); return {}; } },
-      { name: 'b', deps: [], async execute() { await new Promise(r => setTimeout(r, 30)); endTimes['b'] = Date.now(); return {}; } },
-      { name: 'c', deps: ['a', 'b'], async execute() { cStartTime = Date.now(); return {}; } },
-    ];
-
-    const runner = new PipelineRunner(phases);
-    await runner.run(makeCtx());
-
-    expect(cStartTime).toBeGreaterThanOrEqual(endTimes['a']!);
-    expect(cStartTime).toBeGreaterThanOrEqual(endTimes['b']!);
-  });
-
-  it('outputs map contains all phase results', async () => {
-    const phases: PipelinePhase<unknown>[] = [
-      { name: 'x', deps: [], async execute() { return { val: 1 }; } },
-      { name: 'y', deps: ['x'], async execute(_ctx, deps) { const x = deps.get('x') as any; return { val: x.val + 1 }; } },
-    ];
-    const runner = new PipelineRunner(phases);
-    const outputs = await runner.run(makeCtx());
-    expect((outputs.get('x') as any).val).toBe(1);
-    expect((outputs.get('y') as any).val).toBe(2);
-  });
-
-  it('throws on cycle detection', () => {
-    const phases: PipelinePhase<unknown>[] = [
-      { name: 'a', deps: ['b'], async execute() { return {}; } },
-      { name: 'b', deps: ['a'], async execute() { return {}; } },
-    ];
-    expect(() => new PipelineRunner(phases)).toThrow();
-  });
-});

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

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { generateGraphReport } from '../../reporting/graph-report.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);
-    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
-      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0,
-      properties TEXT);
-  `);
-  db.prepare(`INSERT INTO nodes VALUES ('n1','Function','foo',null,'/a.ts',1,5,null,1,null,null)`).run();
-  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','bar',null,'/b.ts',1,3,null,0,null,null)`).run();
-  db.prepare(`INSERT INTO edges VALUES ('e1','n1','n2','CALLS','EXTRACTED',0.9,null)`).run();
-  db.prepare(`INSERT INTO edges VALUES ('e2','n2','n1','CALLS','INFERRED',0.5,null)`).run();
-  db.prepare(`INSERT INTO edges VALUES ('e3','n1','n2','IMPORTS','AMBIGUOUS',0.3,null)`).run();
-  return db;
-}
-
-describe('generateGraphReport confidence audit', () => {
-  it('includes confidence breakdown percentages', () => {
-    const db = makeDb();
-    const result = generateGraphReport(db, '/tmp');
-    expect(result.markdown).toContain('EXTRACTED');
-    expect(result.markdown).toContain('INFERRED');
-    expect(result.markdown).toContain('AMBIGUOUS');
-  });
-
-  it('includes numeric percentage values', () => {
-    const db = makeDb();
-    const result = generateGraphReport(db, '/tmp');
-    expect(result.markdown).toMatch(/\d+\.\d+%|\d+%/);
-  });
-
-  it('includes confidence audit section heading', () => {
-    const db = makeDb();
-    const result = generateGraphReport(db, '/tmp');
-    expect(result.markdown).toContain('Confidence');
-  });
-});

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

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { generateGraphReport } from '../../reporting/graph-report.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);
-    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
-      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0, properties TEXT);
-  `);
-  // 2 isolated nodes (no edges)
-  db.prepare(`INSERT INTO nodes VALUES ('iso1','Function','orphan1',null,'/a.ts',1,5,99,1,null,null)`).run();
-  db.prepare(`INSERT INTO nodes VALUES ('iso2','Function','orphan2',null,'/b.ts',1,3,99,1,null,null)`).run();
-  // thin community: only 1 node
-  db.prepare(`INSERT INTO nodes VALUES ('thin1','Function','alone',null,'/c.ts',1,3,7,1,null,null)`).run();
-  // normal connected nodes
-  db.prepare(`INSERT INTO nodes VALUES ('n1','Function','foo',null,'/d.ts',1,5,1,1,null,null)`).run();
-  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','bar',null,'/e.ts',1,3,1,1,null,null)`).run();
-  db.prepare(`INSERT INTO edges VALUES ('e1','n1','n2','CALLS','AMBIGUOUS',0.1,null)`).run();
-  return db;
-}
-
-describe('graph report knowledge gap section', () => {
-  it('includes knowledge gap heading', () => {
-    const r = generateGraphReport(makeDb(), '/tmp');
-    expect(r.markdown).toMatch(/knowledge.gap|Knowledge Gap/i);
-  });
-
-  it('reports isolated nodes', () => {
-    const r = generateGraphReport(makeDb(), '/tmp');
-    expect(r.markdown).toMatch(/isolated|orphan/i);
-  });
-
-  it('reports thin communities', () => {
-    const r = generateGraphReport(makeDb(), '/tmp');
-    expect(r.markdown).toMatch(/thin|small.*communit/i);
-  });
-});

package/src/__tests__/scope-resolution/call-sites.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  extractGoCallSites,
-  extractJavaCallSites,
-  extractRustCallSites,
-} from '../../pipeline/phases/scope-resolution.js';
-
-describe('extractCallSites (TS/JS)', async () => {
-  const mod = await import('../../pipeline/phases/scope-resolution.js');
-  // extractCallSites is not exported, but extractGoCallSites etc. are.
-  // We test TS/JS extraction indirectly through the phase, but can test the
-  // exported language-specific extractors directly.
-
-  describe('Go call sites', () => {
-    it('extracts method calls', () => {
-      const sites = extractGoCallSites('svc.DoThing()', 'main.go', 'file_main_go');
-      expect(sites).toContainEqual(expect.objectContaining({
-        form: 'method',
-        receiverName: 'svc',
-        methodName: 'DoThing',
-      }));
-    });
-
-    it('extracts direct calls', () => {
-      const sites = extractGoCallSites('fmt.Println("hi")\nDoWork()', 'main.go', 'file_main_go');
-      expect(sites).toContainEqual(expect.objectContaining({
-        form: 'direct',
-        calleeRaw: 'DoWork',
-      }));
-    });
-
-    it('skips Go keywords', () => {
-      const sites = extractGoCallSites('if (true) { for range }', 'main.go', 'file_main_go');
-      const directNames = sites.filter(s => s.form === 'direct').map(s => s.calleeRaw);
-      expect(directNames).not.toContain('if');
-      expect(directNames).not.toContain('for');
-    });
-  });
-
-  describe('Java call sites', () => {
-    it('extracts method calls', () => {
-      const sites = extractJavaCallSites('list.add(item)', 'Main.java', 'file_main_java');
-      expect(sites).toContainEqual(expect.objectContaining({
-        form: 'method',
-        receiverName: 'list',
-        methodName: 'add',
-      }));
-    });
-
-    it('skips Java keywords', () => {
-      const sites = extractJavaCallSites('if (true) {}', 'Main.java', 'file_main_java');
-      const directNames = sites.filter(s => s.form === 'direct').map(s => s.calleeRaw);
-      expect(directNames).not.toContain('if');
-    });
-  });
-
-  describe('Rust call sites', () => {
-    it('extracts method calls', () => {
-      const sites = extractRustCallSites('v.push(42)', 'main.rs', 'file_main_rs');
-      expect(sites).toContainEqual(expect.objectContaining({
-        form: 'method',
-        receiverName: 'v',
-        methodName: 'push',
-      }));
-    });
-
-    it('skips Rust keywords', () => {
-      const sites = extractRustCallSites('let x = match y { }', 'main.rs', 'file_main_rs');
-      const directNames = sites.filter(s => s.form === 'direct').map(s => s.calleeRaw);
-      expect(directNames).not.toContain('let');
-      expect(directNames).not.toContain('match');
-    });
-  });
-});
-
-describe('TS/JS call patterns', () => {
-  // Test via the Go/Java/Rust extractors as proxy — the TS/JS patterns use
-  // the same regex structure but with generics support. We verify the generics
-  // support through an integration-style test using extractGoCallSites as a
-  // baseline (Go doesn't have generics in call syntax).
-
-  it('Go does not match generics syntax', () => {
-    const sites = extractGoCallSites('process<T>(x)', 'main.go', 'f');
-    // <T> breaks the direct call regex — that's expected for Go
-    const direct = sites.filter(s => s.form === 'direct');
-    // The regex sees `T` as the direct call and `process` is before `<`
-    expect(direct.map(s => s.calleeRaw)).not.toContain('process');
-  });
-});

package/src/__tests__/scope-resolution/evidence-weights.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { EvidenceWeights, typeBindingWeightAtDepth } from '../../scope-resolution/evidence-weights.js';
-
-describe('EvidenceWeights', () => {
-  it('local weight is highest origin weight', () => {
-    expect(EvidenceWeights.local).toBeGreaterThan(EvidenceWeights.import);
-    expect(EvidenceWeights.local).toBeGreaterThan(EvidenceWeights.wildcard);
-  });
-
-  it('import weight is higher than wildcard weight', () => {
-    expect(EvidenceWeights.import).toBeGreaterThan(EvidenceWeights.wildcard);
-  });
-
-  it('arity-incompatible is negative', () => {
-    expect(EvidenceWeights.arityMatchIncompatible).toBeLessThan(0);
-  });
-
-  it('unlinkedImportMultiplier is less than 1', () => {
-    expect(EvidenceWeights.unlinkedImportMultiplier).toBeGreaterThan(0);
-    expect(EvidenceWeights.unlinkedImportMultiplier).toBeLessThan(1);
-  });
-
-  it('scopeChainPerDepth is negative', () => {
-    expect(EvidenceWeights.scopeChainPerDepth).toBeLessThan(0);
-  });
-
-  it('has typeBindingByMroDepth as a non-empty array', () => {
-    expect(EvidenceWeights.typeBindingByMroDepth.length).toBeGreaterThan(0);
-  });
-});
-
-describe('typeBindingWeightAtDepth', () => {
-  it('returns first element at depth 0', () => {
-    expect(typeBindingWeightAtDepth(0)).toBe(EvidenceWeights.typeBindingByMroDepth[0]);
-  });
-
-  it('returns last element for depth beyond table length', () => {
-    const last = EvidenceWeights.typeBindingByMroDepth[EvidenceWeights.typeBindingByMroDepth.length - 1];
-    expect(typeBindingWeightAtDepth(100)).toBe(last);
-  });
-
-  it('returns first element for negative depth', () => {
-    expect(typeBindingWeightAtDepth(-1)).toBe(EvidenceWeights.typeBindingByMroDepth[0]);
-  });
-
-  it('decays with depth — depth 1 < depth 0', () => {
-    expect(typeBindingWeightAtDepth(1)).toBeLessThan(typeBindingWeightAtDepth(0));
-  });
-});

package/src/__tests__/search/diacritic.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { stripDiacritics, normalizeSearchTerm } from '../../search/diacritic.js';
-
-describe('stripDiacritics', () => {
-  it('removes accents from French', () => {
-    expect(stripDiacritics('résumé')).toBe('resume');
-  });
-  it('removes umlauts', () => {
-    expect(stripDiacritics('über')).toBe('uber');
-  });
-  it('leaves ASCII unchanged', () => {
-    expect(stripDiacritics('hello world')).toBe('hello world');
-  });
-  it('handles empty string', () => {
-    expect(stripDiacritics('')).toBe('');
-  });
-  it('normalizeSearchTerm lowercases and strips', () => {
-    expect(normalizeSearchTerm('Résumé')).toBe('resume');
-  });
-  it('normalizeSearchTerm trims whitespace', () => {
-    expect(normalizeSearchTerm('  foo  ')).toBe('foo');
-  });
-});