@monoes/monograph 1.5.5 → 1.5.7

package/__tests__/storage/stores.test.ts

@@ -1,165 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync } from 'fs';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { insertNode, getNode, deleteNodesForFile } from '../../src/storage/node-store.js';
-import { insertEdge, getEdgesForSource } from '../../src/storage/edge-store.js';
-import { ftsSearch, extractSearchTerms } from '../../src/storage/fts-store.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-const dbPath = join(tmpdir(), `monograph-stores-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-beforeAll(() => {
-  db = openDb(dbPath);
-});
-
-afterAll(() => {
-  closeDb(db);
-  if (existsSync(dbPath)) {
-    unlinkSync(dbPath);
-  }
-  // Also cleanup WAL files
-  if (existsSync(dbPath + '-wal')) unlinkSync(dbPath + '-wal');
-  if (existsSync(dbPath + '-shm')) unlinkSync(dbPath + '-shm');
-});
-
-describe('node-store', () => {
-  const node: MonographNode = {
-    id: 'foo_bar',
-    label: 'Function',
-    name: 'bar',
-    normLabel: 'bar',
-    filePath: 'src/foo.ts',
-    startLine: 10,
-    endLine: 20,
-    isExported: true,
-    language: 'typescript',
-  };
-
-  it('inserts and retrieves a node', () => {
-    insertNode(db, node);
-    const fetched = getNode(db, 'foo_bar');
-    expect(fetched?.name).toBe('bar');
-    expect(fetched?.isExported).toBe(true);
-  });
-
-  it('deletes nodes by file path', () => {
-    deleteNodesForFile(db, 'src/foo.ts');
-    expect(getNode(db, 'foo_bar')).toBeUndefined();
-  });
-});
-
-describe('edge-store', () => {
-  beforeAll(() => {
-    insertNode(db, {
-      id: 'n1',
-      label: 'Class',
-      name: 'A',
-      normLabel: 'a',
-      isExported: false,
-    });
-    insertNode(db, {
-      id: 'n2',
-      label: 'Class',
-      name: 'B',
-      normLabel: 'b',
-      isExported: false,
-    });
-  });
-
-  it('inserts and retrieves edges by source', () => {
-    const edge: MonographEdge = {
-      id: 'e1',
-      sourceId: 'n1',
-      targetId: 'n2',
-      relation: 'EXTENDS',
-      confidence: 'EXTRACTED',
-      confidenceScore: 1.0,
-    };
-    insertEdge(db, edge);
-    const edges = getEdgesForSource(db, 'n1');
-    expect(edges).toHaveLength(1);
-    expect(edges[0].relation).toBe('EXTENDS');
-  });
-});
-
-describe('fts-store', () => {
-  it('finds nodes by keyword', () => {
-    insertNode(db, {
-      id: 'auth_service',
-      label: 'Class',
-      name: 'AuthService',
-      normLabel: 'authservice',
-      filePath: 'src/auth.ts',
-      isExported: true,
-    });
-    const results = ftsSearch(db, 'auth', 10);
-    expect(results.some((r) => r.id === 'auth_service')).toBe(true);
-  });
-
-  // Regression tests for issue #37 follow-up: monograph_augment identifier+keyword gap.
-  // extractSearchTerms used to bail out entirely for short (<=3 word), stopword-free
-  // queries under the assumption they were "already a bare identifier" — but that's
-  // wrong for multi-token identifier+keyword combos like "ExtensionBridge keepalive
-  // reconnect", which the raw FTS5 MATCH ANDs together and never finds as one row.
-  describe('identifier+keyword combo queries (issue #37 follow-up)', () => {
-    beforeAll(() => {
-      insertNode(db, {
-        id: 'extension_bridge',
-        label: 'Class',
-        name: 'ExtensionBridge',
-        normLabel: 'extensionbridge',
-        filePath: 'src/browser/extension-bridge.ts',
-        isExported: true,
-      });
-    });
-
-    it('finds a node for a combined identifier+keyword query (previously zero results)', () => {
-      const results = ftsSearch(db, 'ExtensionBridge keepalive reconnect', 10);
-      expect(results.some((r) => r.id === 'extension_bridge')).toBe(true);
-    });
-
-    it('still finds the node for a bare identifier query (regression guard)', () => {
-      const results = ftsSearch(db, 'ExtensionBridge', 10);
-      expect(results.some((r) => r.id === 'extension_bridge')).toBe(true);
-    });
-
-    it('still finds the node for a full natural-language sentence (regression guard, 2.5.8 fix)', () => {
-      const results = ftsSearch(
-        db,
-        'where is the browser extension bridge connection established and how does the keepalive detect dead connections',
-        10,
-      );
-      expect(results.some((r) => r.id === 'extension_bridge')).toBe(true);
-    });
-
-    it('still strips file extensions from queries (regression guard, "CLAUDE.md")', () => {
-      insertNode(db, {
-        id: 'claude_md',
-        label: 'File',
-        name: 'CLAUDE',
-        normLabel: 'claude',
-        filePath: 'CLAUDE.md',
-        isExported: false,
-      });
-      const results = ftsSearch(db, 'CLAUDE.md', 10);
-      expect(results.some((r) => r.id === 'claude_md')).toBe(true);
-    });
-  });
-
-  describe('extractSearchTerms', () => {
-    it('extracts identifier parts from a 3-word stopword-free combo query', () => {
-      const terms = extractSearchTerms('ExtensionBridge keepalive reconnect');
-      expect(terms).toContain('ExtensionBridge');
-      expect(terms).toContain('Extension');
-      expect(terms).toContain('Bridge');
-      expect(terms).toContain('keepalive');
-      expect(terms).toContain('reconnect');
-    });
-
-    it('returns empty for a single bare identifier token', () => {
-      expect(extractSearchTerms('ExtensionBridge')).toEqual([]);
-    });
-  });
-});

package/__tests__/types.test.ts

@@ -1,13 +0,0 @@
-import { CONFIDENCE_SCORE } from '../src/types.js';
-
-describe('CONFIDENCE_SCORE', () => {
-  it('assigns 1.0 to EXTRACTED', () => {
-    expect(CONFIDENCE_SCORE.EXTRACTED).toBe(1.0);
-  });
-  it('assigns 0.5 to INFERRED', () => {
-    expect(CONFIDENCE_SCORE.INFERRED).toBe(0.5);
-  });
-  it('assigns 0.2 to AMBIGUOUS', () => {
-    expect(CONFIDENCE_SCORE.AMBIGUOUS).toBe(0.2);
-  });
-});

package/__tests__/validation/extraction-validator.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateExtraction } from '../../src/validation/extraction-validator.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-const validNode: MonographNode = {
-  id: 'n1', label: 'Function', name: 'myFn', normLabel: 'myfn',
-  filePath: 'src/a.ts', startLine: 1, endLine: 5, isExported: true,
-};
-const validEdge: MonographEdge = {
-  id: 'e1', sourceId: 'n1', targetId: 'n1',
-  relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0,
-};
-
-describe('validateExtraction', () => {
-  it('passes on valid nodes and edges', () => {
-    const r = validateExtraction([validNode], [validEdge]);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toHaveLength(0);
-  });
-
-  it('rejects node with missing id', () => {
-    const bad = { ...validNode, id: '' };
-    const r = validateExtraction([bad], []);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.includes('id'))).toBe(true);
-  });
-
-  it('rejects node with invalid label', () => {
-    const bad = { ...validNode, label: 'Goblin' as any };
-    const r = validateExtraction([bad], []);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.includes('label'))).toBe(true);
-  });
-
-  it('rejects edge referencing unknown node', () => {
-    const badEdge = { ...validEdge, targetId: 'unknown_node' };
-    const r = validateExtraction([validNode], [badEdge]);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.includes('targetId'))).toBe(true);
-  });
-
-  it('rejects edge with invalid confidence', () => {
-    const badEdge = { ...validEdge, confidence: 'MADE_UP' as any };
-    const r = validateExtraction([validNode], [badEdge]);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.includes('confidence'))).toBe(true);
-  });
-});

package/__tests__/watch/watcher.test.ts

@@ -1,31 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, appendFileSync } from 'fs';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { MonographWatcher } from '../../src/watch/watcher.js';
-
-const tmpRepo = join(tmpdir(), `monograph-watch-test-${Date.now()}`);
-
-beforeAll(() => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-  writeFileSync(join(tmpRepo, 'src', 'index.ts'), 'export const x = 1;');
-});
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-describe('MonographWatcher', () => {
-  it('emits monograph:updated within 5s after a file change', async () => {
-    const updates: string[] = [];
-    const watcher = new MonographWatcher(tmpRepo, { debounceMs: 200 });
-    watcher.on('monograph:updated', (paths: string[]) => updates.push(...paths));
-    await watcher.start();
-
-    // Trigger a file change
-    await new Promise(r => setTimeout(r, 300));
-    appendFileSync(join(tmpRepo, 'src', 'index.ts'), '\nexport const y = 2;');
-    await new Promise(r => setTimeout(r, 2000));
-
-    await watcher.stop();
-    expect(updates.length).toBeGreaterThan(0);
-  }, 15000);
-});

package/__tests__/web/analyze-api.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect, afterEach, vi } from 'vitest';
-import { createServer } from 'http';
-import { registerAnalyzeRoute } from '../../src/web/analyze-api.js';
-
-// Mock buildAsync so tests don't need a real repo
-vi.mock('../../src/pipeline/orchestrator.js', () => ({
-  buildAsync: vi.fn().mockImplementation(async (_path: string, opts: { onProgress?: (p: { phase: string; message?: string }) => void }) => {
-    opts.onProgress?.({ phase: 'scan', message: 'Scanning...' });
-    opts.onProgress?.({ phase: 'parse', message: 'Parsing...' });
-  }),
-}));
-
-vi.mock('../../src/storage/node-store.js', () => ({
-  countNodes: vi.fn().mockReturnValue(42),
-}));
-
-vi.mock('../../src/storage/edge-store.js', () => ({
-  countEdges: vi.fn().mockReturnValue(17),
-}));
-
-vi.mock('../../src/storage/db.js', () => ({
-  openDb: vi.fn().mockReturnValue({}),
-  closeDb: vi.fn(),
-}));
-
-let httpServer: ReturnType<typeof createServer>;
-
-afterEach(() => {
-  if (httpServer?.listening) httpServer.close();
-});
-
-describe('registerAnalyzeRoute', () => {
-  it('returns SSE content-type', async () => {
-    httpServer = createServer();
-    registerAnalyzeRoute(httpServer);
-    await new Promise<void>(resolve => httpServer.listen(0, '127.0.0.1', resolve));
-    const port = (httpServer.address() as { port: number }).port;
-
-    const res = await fetch(`http://127.0.0.1:${port}/api/analyze?repoPath=/tmp/test`);
-    expect(res.headers.get('content-type')).toContain('text/event-stream');
-    await res.text(); // consume
-  });
-
-  it('emits progress and complete events', async () => {
-    httpServer = createServer();
-    registerAnalyzeRoute(httpServer);
-    await new Promise<void>(resolve => httpServer.listen(0, '127.0.0.1', resolve));
-    const port = (httpServer.address() as { port: number }).port;
-
-    const res = await fetch(`http://127.0.0.1:${port}/api/analyze?repoPath=/tmp/test`);
-    const body = await res.text();
-    expect(body).toContain('"type":"progress"');
-    expect(body).toContain('"type":"complete"');
-    expect(body).toContain('"nodeCount":42');
-  });
-
-  it('returns 400 if repoPath is missing', async () => {
-    httpServer = createServer();
-    registerAnalyzeRoute(httpServer);
-    await new Promise<void>(resolve => httpServer.listen(0, '127.0.0.1', resolve));
-    const port = (httpServer.address() as { port: number }).port;
-
-    const res = await fetch(`http://127.0.0.1:${port}/api/analyze`);
-    expect(res.status).toBe(400);
-  });
-});

package/__tests__/web/api.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { tmpdir } from 'os';
-import { join } from 'path';
-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 { queryGraphData as queryGraph, queryNode, querySearch, queryStats } from '../../src/web/api.js';
-import { startServer } from '../../src/web/server.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-// ── Shared test DB ────────────────────────────────────────────────────────────
-
-const dbPath = join(tmpdir(), `monograph-web-api-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const nodeA: MonographNode = {
-  id: 'web_a',
-  label: 'Function',
-  name: 'webAlpha',
-  normLabel: 'webalpha',
-  filePath: 'src/web/a.ts',
-  startLine: 1,
-  endLine: 10,
-  isExported: true,
-  communityId: 1,
-};
-
-const nodeB: MonographNode = {
-  id: 'web_b',
-  label: 'Class',
-  name: 'WebBeta',
-  normLabel: 'webbeta',
-  filePath: 'src/web/b.ts',
-  startLine: 5,
-  endLine: 50,
-  isExported: false,
-  communityId: 2,
-};
-
-const nodeC: MonographNode = {
-  id: 'web_c',
-  label: 'Function',
-  name: 'buildAsync',
-  normLabel: 'buildasync',
-  filePath: 'src/build.ts',
-  startLine: 1,
-  endLine: 20,
-  isExported: true,
-  communityId: 1,
-};
-
-const edge: MonographEdge = {
-  id: 'web_e_ab',
-  sourceId: 'web_a',
-  targetId: 'web_b',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, nodeA);
-  insertNode(db, nodeB);
-  insertNode(db, nodeC);
-  insertEdge(db, edge);
-});
-
-afterAll(() => {
-  closeDb(db);
-});
-
-// ── queryGraph ────────────────────────────────────────────────────────────────
-
-describe('queryGraph', () => {
-  it('returns nodes array with expected fields', () => {
-    const result = queryGraph(db);
-    expect(result.nodes.length).toBeGreaterThanOrEqual(2);
-    const a = result.nodes.find((n) => n.id === 'web_a');
-    expect(a).toBeDefined();
-    expect(a?.name).toBe('webAlpha');
-    expect(a?.label).toBe('Function');
-  });
-
-  it('returns edges array', () => {
-    const result = queryGraph(db);
-    const e = result.edges.find(
-      (ed) => ed.sourceId === 'web_a' && ed.targetId === 'web_b',
-    );
-    expect(e).toBeDefined();
-    expect(e?.relation).toBe('CALLS');
-  });
-
-  it('groups communities by communityId', () => {
-    const result = queryGraph(db);
-    expect(result.communities['1']).toContain('web_a');
-    expect(result.communities['2']).toContain('web_b');
-  });
-});
-
-// ── queryNode ─────────────────────────────────────────────────────────────────
-
-describe('queryNode', () => {
-  it('returns node details for existing id', () => {
-    const result = queryNode(db, 'web_b');
-    expect(result.node).not.toBeNull();
-    expect(result.node?.name).toBe('WebBeta');
-  });
-
-  it('returns callers for node b (a calls b)', () => {
-    const result = queryNode(db, 'web_b');
-    expect(result.callers.some((c) => c.id === 'web_a')).toBe(true);
-  });
-
-  it('returns callees for node a (a calls b)', () => {
-    const result = queryNode(db, 'web_a');
-    expect(result.callees.some((c) => c.id === 'web_b')).toBe(true);
-  });
-
-  it('returns null node for unknown id', () => {
-    const result = queryNode(db, 'nonexistent');
-    expect(result.node).toBeNull();
-    expect(result.callers).toHaveLength(0);
-  });
-});
-
-// ── querySearch ───────────────────────────────────────────────────────────────
-
-describe('querySearch', () => {
-  it('returns results for matching query', () => {
-    const results = querySearch(db, 'webAlpha');
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].name).toBe('webAlpha');
-  });
-
-  it('returns empty array for non-matching query', () => {
-    const results = querySearch(db, 'zzzunlikelymatch999');
-    expect(results).toHaveLength(0);
-  });
-});
-
-// ── queryStats ────────────────────────────────────────────────────────────────
-
-describe('queryStats', () => {
-  it('returns correct node and edge counts', () => {
-    const stats = queryStats(db);
-    expect(stats.nodeCount).toBeGreaterThanOrEqual(2);
-    expect(stats.edgeCount).toBeGreaterThanOrEqual(1);
-  });
-
-  it('returns community count', () => {
-    const stats = queryStats(db);
-    expect(stats.communityCount).toBeGreaterThanOrEqual(2);
-  });
-
-  it('returns buildAt (may be null if not built)', () => {
-    const stats = queryStats(db);
-    // buildAt can be null if index_meta has no indexed_at key
-    expect(stats).toHaveProperty('buildAt');
-  });
-});
-
-// ── startServer / stop ────────────────────────────────────────────────────────
-
-describe('server lifecycle', () => {
-  it('starts and stops cleanly on port 0', async () => {
-    const handle = await startServer({ port: 0, db });
-    expect(handle.url).toMatch(/^http:\/\/localhost:\d+$/);
-    await handle.stop();
-  });
-
-  it('serves /api/stats endpoint', async () => {
-    const handle = await startServer({ port: 0, db });
-    try {
-      const url = handle.url;
-      const res = await fetch(`${url}/api/stats`);
-      expect(res.ok).toBe(true);
-      const json = await res.json() as { nodeCount: number };
-      expect(typeof json.nodeCount).toBe('number');
-    } finally {
-      await handle.stop();
-    }
-  });
-
-  it('serves /api/graph endpoint', async () => {
-    const handle = await startServer({ port: 0, db });
-    try {
-      const res = await fetch(`${handle.url}/api/graph`);
-      expect(res.ok).toBe(true);
-      const json = await res.json() as { nodes: unknown[]; edges: unknown[]; communities: unknown };
-      expect(Array.isArray(json.nodes)).toBe(true);
-      expect(Array.isArray(json.edges)).toBe(true);
-    } finally {
-      await handle.stop();
-    }
-  });
-
-  it('serves /api/search?q=build returns ≥1 result', async () => {
-    const handle = await startServer({ port: 0, db });
-    try {
-      const res = await fetch(`${handle.url}/api/search?q=build`);
-      expect(res.ok).toBe(true);
-      const json = await res.json() as unknown[];
-      expect(Array.isArray(json)).toBe(true);
-      expect(json.length).toBeGreaterThanOrEqual(1);
-    } finally {
-      await handle.stop();
-    }
-  });
-});

package/__tests__/web/mcp-http.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { createMcpHttpServer } from '../../src/web/mcp-http.js';
-
-const echoTool = {
-  name: 'echo',
-  description: 'Echo the input',
-  handler: async (args: Record<string, unknown>) => ({ echoed: args['text'] }),
-};
-
-let server: ReturnType<typeof createMcpHttpServer>;
-
-afterEach(async () => {
-  if (server) await server.stop();
-});
-
-describe('McpHttpServer', () => {
-  it('starts and exposes a port', async () => {
-    server = createMcpHttpServer({ port: 0, tools: [echoTool] });
-    await server.start();
-    expect(server.port).toBeGreaterThan(0);
-    expect(server.url).toMatch(/^http:\/\//);
-  });
-
-  it('GET /mcp/tools returns JSON', async () => {
-    server = createMcpHttpServer({ port: 0, tools: [echoTool] });
-    await server.start();
-    const res = await fetch(`${server.url}/mcp/tools`);
-    expect(res.ok).toBe(true);
-    const body = await res.json() as { tools: unknown[] };
-    expect(Array.isArray(body.tools) || body.tools !== undefined).toBe(true);
-  });
-
-  it('POST /mcp/call invokes a tool', async () => {
-    server = createMcpHttpServer({ port: 0, tools: [echoTool] });
-    await server.start();
-    const res = await fetch(`${server.url}/mcp/call`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: 'echo', arguments: { text: 'hello' } }),
-    });
-    expect(res.ok).toBe(true);
-    const body = await res.json() as { echoed: string };
-    expect(body.echoed).toBe('hello');
-  });
-
-  it('POST /mcp/call returns 404 for unknown tool', async () => {
-    server = createMcpHttpServer({ port: 0, tools: [echoTool] });
-    await server.start();
-    const res = await fetch(`${server.url}/mcp/call`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: 'nonexistent', arguments: {} }),
-    });
-    expect(res.status).toBe(404);
-  });
-
-  it('GET /mcp/stream emits SSE events', async () => {
-    server = createMcpHttpServer({ port: 0, tools: [echoTool] });
-    await server.start();
-    const args = encodeURIComponent(JSON.stringify({ text: 'world' }));
-    const res = await fetch(`${server.url}/mcp/stream?name=echo&args=${args}`);
-    expect(res.headers.get('content-type')).toContain('text/event-stream');
-    const text = await res.text();
-    expect(text).toContain('[DONE]');
-    expect(text).toContain('world');
-  });
-});

package/__tests__/web/react-ui.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getReactUiHtml } from '../../src/web/react-ui.js';
-
-describe('getReactUiHtml', () => {
-  it('returns a non-empty HTML string', () => {
-    const html = getReactUiHtml();
-    expect(typeof html).toBe('string');
-    expect(html.length).toBeGreaterThan(100);
-  });
-
-  it('includes DOCTYPE and html tags', () => {
-    const html = getReactUiHtml();
-    expect(html).toContain('<!DOCTYPE html>');
-    expect(html).toContain('<html');
-    expect(html).toContain('</html>');
-  });
-
-  it('includes React CDN scripts', () => {
-    const html = getReactUiHtml();
-    expect(html).toContain('react@18');
-    expect(html).toContain('react-dom@18');
-  });
-
-  it('includes the root mount point', () => {
-    const html = getReactUiHtml();
-    expect(html).toContain('id="root"');
-  });
-
-  it('includes required UI element ids', () => {
-    const html = getReactUiHtml();
-    expect(html).toContain('search-input');
-    expect(html).toContain('search-btn');
-    expect(html).toContain('analyze-btn');
-    expect(html).toContain('results');
-    expect(html).toContain('progress');
-  });
-
-  it('includes Babel standalone for JSX', () => {
-    const html = getReactUiHtml();
-    expect(html).toContain('babel');
-    expect(html).toContain('text/babel');
-  });
-});