@monoes/monograph 1.5.6 → 1.5.8

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

package/src/__tests__/security/safe-fetch.test.ts

@@ -1,125 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { safeFetch, validateUrl, isPrivateUrl } from '../../security/safe-fetch.js';
-
-describe('isPrivateUrl', () => {
-  it('returns true for localhost', () => {
-    expect(isPrivateUrl('http://localhost/path')).toBe(true);
-  });
-  it('returns true for 127.x address', () => {
-    expect(isPrivateUrl('http://127.0.0.1/')).toBe(true);
-  });
-  it('returns true for 10.x private', () => {
-    expect(isPrivateUrl('http://10.0.0.1/')).toBe(true);
-  });
-  it('returns true for 192.168.x.x', () => {
-    expect(isPrivateUrl('http://192.168.1.1/')).toBe(true);
-  });
-  it('returns false for public IP', () => {
-    expect(isPrivateUrl('https://8.8.8.8/')).toBe(false);
-  });
-  it('returns false for public hostname', () => {
-    expect(isPrivateUrl('https://example.com/')).toBe(false);
-  });
-  it('returns true for cloud metadata address', () => {
-    expect(isPrivateUrl('http://169.254.169.254/latest/meta-data')).toBe(true);
-  });
-});
-
-describe('validateUrl', () => {
-  it('throws on file: scheme', () => {
-    expect(() => validateUrl('file:///etc/passwd')).toThrow(/Unsupported scheme/);
-  });
-  it('throws on ftp: scheme', () => {
-    expect(() => validateUrl('ftp://example.com/')).toThrow(/Unsupported scheme/);
-  });
-  it('throws on invalid URL', () => {
-    expect(() => validateUrl('not-a-url')).toThrow(/Invalid URL/);
-  });
-  it('throws on private IP', () => {
-    expect(() => validateUrl('http://10.0.0.1/')).toThrow(/private\/reserved/);
-  });
-  it('passes for valid public https URL', () => {
-    expect(() => validateUrl('https://example.com/')).not.toThrow();
-  });
-});
-
-describe('safeFetch — streaming size enforcement', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', undefined);
-  });
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('rejects when streamed bytes exceed maxBytes before body is complete', async () => {
-    // Simulate a response whose body stream sends more than maxBytes
-    const encoder = new TextEncoder();
-    const chunk1 = encoder.encode('A'.repeat(50));
-    const chunk2 = encoder.encode('B'.repeat(50));
-
-    const mockBody = {
-      getReader() {
-        let call = 0;
-        return {
-          read() {
-            call++;
-            if (call === 1) return Promise.resolve({ value: chunk1, done: false });
-            if (call === 2) return Promise.resolve({ value: chunk2, done: false });
-            return Promise.resolve({ value: undefined, done: true });
-          },
-          releaseLock() {},
-        };
-      },
-    };
-
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-      ok: true,
-      body: mockBody,
-      text: () => Promise.resolve('A'.repeat(100)),
-    }));
-
-    // maxBytes = 60 — stream sends 100 bytes total, should abort at 60
-    await expect(
-      safeFetch('https://example.com/', { maxBytes: 60 })
-    ).rejects.toThrow(/exceeds/);
-  });
-
-  it('succeeds when response body is within maxBytes', async () => {
-    const encoder = new TextEncoder();
-    const chunk = encoder.encode('hello world');
-
-    const mockBody = {
-      getReader() {
-        let done = false;
-        return {
-          read() {
-            if (!done) {
-              done = true;
-              return Promise.resolve({ value: chunk, done: false });
-            }
-            return Promise.resolve({ value: undefined, done: true });
-          },
-          releaseLock() {},
-        };
-      },
-    };
-
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-      ok: true,
-      body: mockBody,
-    }));
-
-    const result = await safeFetch('https://example.com/', { maxBytes: 1024 });
-    expect(result).toBe('hello world');
-  });
-
-  it('throws when response is not ok', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-      ok: false,
-      status: 404,
-      body: null,
-    }));
-
-    await expect(safeFetch('https://example.com/')).rejects.toThrow(/HTTP 404/);
-  });
-});

package/src/__tests__/skills/platform-skills.extra.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { installPlatformSkill, SUPPORTED_PLATFORMS } from '../../skills/platform-skills.js';
-
-describe('additional platform skills', () => {
-  let tmpDir: string;
-
-  beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), 'skills-extra-')); });
-  afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
-
-  it('SUPPORTED_PLATFORMS includes codex, gemini, aider, copilot, kiro', () => {
-    expect(SUPPORTED_PLATFORMS).toContain('codex');
-    expect(SUPPORTED_PLATFORMS).toContain('gemini');
-    expect(SUPPORTED_PLATFORMS).toContain('aider');
-    expect(SUPPORTED_PLATFORMS).toContain('copilot');
-    expect(SUPPORTED_PLATFORMS).toContain('kiro');
-  });
-
-  it('installs codex skill file', () => {
-    const result = installPlatformSkill(tmpDir, 'codex', []);
-    expect(result.filesWritten.length).toBeGreaterThan(0);
-    expect(result.filesWritten.some(f => existsSync(f))).toBe(true);
-  });
-
-  it('installs gemini skill file', () => {
-    const result = installPlatformSkill(tmpDir, 'gemini', []);
-    expect(result.filesWritten.length).toBeGreaterThan(0);
-  });
-
-  it('installs kiro skill file', () => {
-    const result = installPlatformSkill(tmpDir, 'kiro', []);
-    expect(result.filesWritten.length).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/web/api.clusters.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { queryClusters, queryCluster, queryProcessesList, queryProcess } from '../../web/api.js';
-
-function makeDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE nodes (id TEXT PRIMARY KEY, name TEXT, label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER);
-    CREATE TABLE communities (id INTEGER PRIMARY KEY, label TEXT);
-    INSERT INTO communities VALUES (1, 'auth');
-    INSERT INTO communities VALUES (2, 'payment');
-    INSERT INTO nodes VALUES ('n1', 'UserService', 'Class', '/app/user.ts', 1, 50, 1);
-    INSERT INTO nodes VALUES ('n2', 'PaymentProcessor', 'Class', '/app/pay.ts', 1, 100, 2);
-    INSERT INTO nodes VALUES ('n3', 'processOrder', 'Process', '/app/order.ts', 5, 30, null);
-  `);
-  return db;
-}
-
-describe('queryClusters', () => {
-  it('returns list of all communities', () => {
-    const db = makeDb();
-    const result = queryClusters(db);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBeGreaterThanOrEqual(2);
-    expect(result.some(c => c.label === 'auth')).toBe(true);
-  });
-});
-
-describe('queryCluster', () => {
-  it('returns cluster with members for known name', () => {
-    const db = makeDb();
-    const result = queryCluster(db, 'auth');
-    expect(result).not.toBeNull();
-    expect((result as any).label).toBe('auth');
-    expect(Array.isArray((result as any).members)).toBe(true);
-  });
-
-  it('returns null for unknown cluster', () => {
-    const db = makeDb();
-    expect(queryCluster(db, 'nonexistent')).toBeNull();
-  });
-});
-
-describe('queryProcessesList', () => {
-  it('returns process nodes', () => {
-    const db = makeDb();
-    const result = queryProcessesList(db);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.some(p => p.name === 'processOrder')).toBe(true);
-  });
-});
-
-describe('queryProcess', () => {
-  it('returns process for known name', () => {
-    const db = makeDb();
-    const result = queryProcess(db, 'processOrder');
-    expect(result).not.toBeNull();
-    expect((result as any).name).toBe('processOrder');
-  });
-
-  it('returns null for unknown process', () => {
-    const db = makeDb();
-    expect(queryProcess(db, 'nonexistent')).toBeNull();
-  });
-});

package/src/__tests__/web/api.file.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { readFileContent } from '../../web/api.js';
-
-describe('readFileContent', () => {
-  let tmpDir: string;
-  let filePath: string;
-
-  beforeAll(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'api-file-test-'));
-    filePath = join(tmpDir, 'sample.ts');
-    writeFileSync(filePath, 'line1\nline2\nline3\nline4\nline5\n');
-  });
-
-  afterAll(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns full file content with lines', () => {
-    const result = readFileContent(filePath);
-    expect(result.lines.length).toBe(5);
-    expect(result.lines[0]).toEqual({ number: 1, content: 'line1' });
-    expect(result.lines[4]).toEqual({ number: 5, content: 'line5' });
-  });
-
-  it('returns a slice when startLine and endLine provided', () => {
-    const result = readFileContent(filePath, 2, 4);
-    expect(result.lines.length).toBe(3);
-    expect(result.lines[0]).toEqual({ number: 2, content: 'line2' });
-    expect(result.lines[2]).toEqual({ number: 4, content: 'line4' });
-  });
-
-  it('throws for non-existent file', () => {
-    expect(() => readFileContent('/nonexistent/path.ts')).toThrow();
-  });
-
-  it('result has totalLines field', () => {
-    const result = readFileContent(filePath);
-    expect(result.totalLines).toBe(5);
-    expect(result.path).toBe(filePath);
-  });
-});

package/src/__tests__/web/api.grep.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { queryGrep } from '../../web/api.js';
-
-function makeDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE nodes (id TEXT PRIMARY KEY, name TEXT, label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER);
-    CREATE VIRTUAL TABLE nodes_fts USING fts5(id, name, label, content='nodes', content_rowid='rowid');
-    INSERT INTO nodes VALUES ('n1', 'fetchUser', 'Function', '/app/user.ts', 10, 20, null);
-    INSERT INTO nodes VALUES ('n2', 'UserService', 'Class', '/app/service.ts', 1, 100, 1);
-    INSERT INTO nodes VALUES ('n3', 'formatDate', 'Function', '/app/utils.ts', 5, 15, null);
-  `);
-  return db;
-}
-
-describe('queryGrep', () => {
-  it('returns nodes whose name matches pattern case-insensitively', () => {
-    const db = makeDb();
-    const results = queryGrep(db, 'user', false);
-    expect(results.length).toBe(2); // fetchUser and UserService
-    expect(results.some(r => r.name === 'fetchUser')).toBe(true);
-    expect(results.some(r => r.name === 'UserService')).toBe(true);
-  });
-
-  it('returns empty array for no match', () => {
-    const db = makeDb();
-    const results = queryGrep(db, 'nonexistent', false);
-    expect(results).toEqual([]);
-  });
-
-  it('limits to 100 results', () => {
-    const db = makeDb();
-    const results = queryGrep(db, 'Date', false);
-    expect(results.length).toBeLessThanOrEqual(100);
-  });
-
-  it('returns results with correct shape', () => {
-    const db = makeDb();
-    const results = queryGrep(db, 'format', false);
-    expect(results[0]).toHaveProperty('id');
-    expect(results[0]).toHaveProperty('name');
-    expect(results[0]).toHaveProperty('label');
-    expect(results[0]).toHaveProperty('filePath');
-    expect(results[0]).toHaveProperty('startLine');
-  });
-});

package/src/__tests__/web/api.info.test.ts

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getServerInfo } from '../../web/api.js';
-
-describe('getServerInfo', () => {
-  it('returns version and nodeVersion', () => {
-    const info = getServerInfo();
-    expect(info.version).toBeDefined();
-    expect(typeof info.version).toBe('string');
-    expect(info.nodeVersion).toBe(process.version);
-    expect(info.name).toBe('monograph');
-  });
-
-  it('includes uptime', () => {
-    const info = getServerInfo();
-    expect(typeof info.uptimeSeconds).toBe('number');
-    expect(info.uptimeSeconds).toBeGreaterThanOrEqual(0);
-  });
-});