@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/groups/group-search.test.ts

@@ -1,221 +0,0 @@
-/**
- * Tests for cross-repo group search (group-search.ts)
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import Database from 'better-sqlite3';
-import { groupQuery } from '../../src/groups/group-search.js';
-import type { GroupConfig } from '../../src/groups/group-config.js';
-
-// ── helpers ───────────────────────────────────────────────────────────────────
-
-/**
- * Create a minimal monograph SQLite DB at the given path with some nodes.
- */
-function createTestDb(
-  dbPath: string,
-  nodes: { id: string; name: string; label: string; filePath?: string }[],
-): void {
-  mkdirSync(join(dbPath, '..'), { recursive: true });
-  const db = new Database(dbPath);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS nodes (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      name TEXT NOT NULL,
-      norm_label TEXT NOT NULL DEFAULT '',
-      file_path TEXT,
-      start_line INTEGER,
-      end_line INTEGER,
-      community_id INTEGER,
-      is_exported INTEGER NOT NULL DEFAULT 0,
-      language TEXT,
-      properties TEXT
-    )
-  `);
-
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
-      id UNINDEXED,
-      name,
-      norm_label,
-      file_path,
-      label UNINDEXED,
-      content='nodes',
-      content_rowid='rowid'
-    )
-  `);
-
-  // FTS sync insert trigger
-  db.exec(`
-    CREATE TRIGGER IF NOT EXISTS nodes_ai AFTER INSERT ON nodes BEGIN
-      INSERT INTO nodes_fts(rowid, id, name, norm_label, file_path, label)
-        VALUES (new.rowid, new.id, new.name, new.norm_label, new.file_path, new.label);
-    END
-  `);
-
-  const insert = db.prepare(
-    `INSERT INTO nodes (id, label, name, norm_label, file_path) VALUES (?, ?, ?, ?, ?)`,
-  );
-
-  for (const n of nodes) {
-    insert.run(n.id, n.label, n.name, n.label.toLowerCase(), n.filePath ?? null);
-  }
-
-  db.close();
-}
-
-// ── fixtures ──────────────────────────────────────────────────────────────────
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'monograph-group-test-'));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function makeRepo(repoName: string, nodes: { id: string; name: string; label: string; filePath?: string }[]) {
-  const repoPath = join(tmpDir, repoName);
-  const dbPath = join(repoPath, '.monomind', 'monograph.db');
-  mkdirSync(join(repoPath, '.monomind'), { recursive: true });
-  createTestDb(dbPath, nodes);
-  return repoPath;
-}
-
-// ── tests ─────────────────────────────────────────────────────────────────────
-
-describe('groupQuery', () => {
-  it('merges results from two repos', async () => {
-    const repoAPath = makeRepo('repoA', [
-      { id: 'a1', name: 'UserService', label: 'Class', filePath: 'src/user.ts' },
-      { id: 'a2', name: 'AuthService', label: 'Class', filePath: 'src/auth.ts' },
-    ]);
-    const repoBPath = makeRepo('repoB', [
-      { id: 'b1', name: 'UserController', label: 'Class', filePath: 'src/user-ctrl.ts' },
-    ]);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [
-        { name: 'repoA', path: repoAPath },
-        { name: 'repoB', path: repoBPath },
-      ],
-    };
-
-    const results = await groupQuery(config, 'User');
-    expect(results.length).toBeGreaterThanOrEqual(2);
-
-    const names = results.map((r) => r.name);
-    expect(names.some((n) => n.includes('User'))).toBe(true);
-  });
-
-  it('tags results with the correct repo name', async () => {
-    const repoAPath = makeRepo('repoA', [
-      { id: 'a1', name: 'UserService', label: 'Class' },
-    ]);
-    const repoBPath = makeRepo('repoB', [
-      { id: 'b1', name: 'UserRepository', label: 'Class' },
-    ]);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [
-        { name: 'repoA', path: repoAPath },
-        { name: 'repoB', path: repoBPath },
-      ],
-    };
-
-    const results = await groupQuery(config, 'User');
-    const repos = results.map((r) => r.repo);
-    expect(repos).toContain('repoA');
-    expect(repos).toContain('repoB');
-  });
-
-  it('skips repos whose DB file does not exist', async () => {
-    const repoAPath = makeRepo('repoA', [
-      { id: 'a1', name: 'HealthService', label: 'Class' },
-    ]);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [
-        { name: 'repoA', path: repoAPath },
-        { name: 'missing-repo', path: join(tmpDir, 'does-not-exist') },
-      ],
-    };
-
-    // Should not throw; missing repo is warned and skipped
-    const results = await groupQuery(config, 'Health');
-    expect(results.length).toBeGreaterThan(0);
-    const repos = results.map((r) => r.repo);
-    expect(repos).not.toContain('missing-repo');
-    expect(repos).toContain('repoA');
-  });
-
-  it('returns empty array when no repos match', async () => {
-    const repoAPath = makeRepo('repoA', [
-      { id: 'a1', name: 'SomeClass', label: 'Class' },
-    ]);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [{ name: 'repoA', path: repoAPath }],
-    };
-
-    const results = await groupQuery(config, 'xyzzy_not_found_anywhere');
-    expect(results).toEqual([]);
-  });
-
-  it('respects the limit option', async () => {
-    const nodes = Array.from({ length: 20 }, (_, i) => ({
-      id: `n${i}`,
-      name: `UserModule${i}`,
-      label: 'Class',
-    }));
-    const repoAPath = makeRepo('repoA', nodes);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [{ name: 'repoA', path: repoAPath }],
-    };
-
-    const results = await groupQuery(config, 'User', { limit: 5 });
-    expect(results.length).toBeLessThanOrEqual(5);
-  });
-
-  it('result objects have the required shape', async () => {
-    const repoAPath = makeRepo('repoA', [
-      { id: 'a1', name: 'PaymentService', label: 'Class', filePath: 'src/payment.ts' },
-    ]);
-
-    const config: GroupConfig = {
-      name: 'test-group',
-      repos: [{ name: 'repoA', path: repoAPath }],
-    };
-
-    const results = await groupQuery(config, 'Payment');
-    expect(results.length).toBeGreaterThan(0);
-
-    const r = results[0];
-    expect(typeof r.id).toBe('string');
-    expect(typeof r.name).toBe('string');
-    expect(typeof r.label).toBe('string');
-    expect(typeof r.repo).toBe('string');
-    expect(typeof r.score).toBe('number');
-    // filePath may be string or null
-    expect(r.filePath === null || typeof r.filePath === 'string').toBe(true);
-  });
-
-  it('handles empty repos array gracefully', async () => {
-    const config: GroupConfig = { name: 'empty', repos: [] };
-    const results = await groupQuery(config, 'anything');
-    expect(results).toEqual([]);
-  });
-});

package/__tests__/groups/group-sync.test.ts

@@ -1,336 +0,0 @@
-/**
- * Tests for group-sync.ts and contract-registry.ts
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import Database from 'better-sqlite3';
-
-import { syncGroup } from '../../src/groups/group-sync.js';
-import {
-  extractHttpContracts,
-  buildContractLinks,
-  loadContractRegistry,
-  type HttpContract,
-} from '../../src/groups/contract-registry.js';
-
-// ── helpers ───────────────────────────────────────────────────────────────────
-
-/**
- * Creates a minimal monograph-compatible SQLite DB with Route nodes (and
- * optional handler nodes + HANDLES_ROUTE edges).
- */
-function createRepoDb(
-  dbPath: string,
-  routes: Array<{
-    id: string;
-    /** "METHOD /path" — matches how routes.ts constructs node names */
-    name: string;
-    filePath?: string;
-    handlerName?: string;
-    handlerFile?: string;
-  }>,
-): void {
-  mkdirSync(join(dbPath, '..'), { recursive: true });
-  const db = new Database(dbPath);
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS nodes (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      name TEXT NOT NULL,
-      norm_label TEXT NOT NULL DEFAULT '',
-      file_path TEXT,
-      start_line INTEGER,
-      end_line INTEGER,
-      community_id INTEGER,
-      is_exported INTEGER NOT NULL DEFAULT 0,
-      language TEXT,
-      properties TEXT
-    );
-    CREATE TABLE IF NOT EXISTS edges (
-      id TEXT PRIMARY KEY,
-      source_id TEXT NOT NULL,
-      target_id TEXT NOT NULL,
-      relation TEXT NOT NULL,
-      confidence TEXT NOT NULL DEFAULT 'EXTRACTED',
-      confidence_score REAL NOT NULL DEFAULT 1.0
-    );
-  `);
-
-  const insertNode = db.prepare(
-    `INSERT INTO nodes (id, label, name, norm_label, file_path) VALUES (?, ?, ?, ?, ?)`,
-  );
-  const insertEdge = db.prepare(
-    `INSERT INTO edges (id, source_id, target_id, relation) VALUES (?, ?, ?, ?)`,
-  );
-
-  for (const r of routes) {
-    insertNode.run(r.id, 'Route', r.name, r.name.toLowerCase(), r.filePath ?? null);
-
-    if (r.handlerName) {
-      const handlerId = `handler-${r.id}`;
-      insertNode.run(
-        handlerId,
-        'Function',
-        r.handlerName,
-        r.handlerName.toLowerCase(),
-        r.handlerFile ?? null,
-      );
-      // Route is SOURCE of HANDLES_ROUTE edge (matches routes.ts L93-98)
-      insertEdge.run(`edge-${r.id}`, r.id, handlerId, 'HANDLES_ROUTE');
-    }
-  }
-
-  db.close();
-}
-
-/**
- * Creates a group.yaml file pointing to the given repo paths.
- */
-function createGroupYaml(
-  dir: string,
-  groupName: string,
-  repos: Record<string, string>,
-): string {
-  const yamlPath = join(dir, 'group.yaml');
-  const repoLines = Object.entries(repos)
-    .map(([name, path]) => `  ${name}: ${path}`)
-    .join('\n');
-  writeFileSync(yamlPath, `name: ${groupName}\nrepos:\n${repoLines}\n`);
-  return yamlPath;
-}
-
-// ── fixtures ──────────────────────────────────────────────────────────────────
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'monograph-group-sync-'));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function makeRepo(
-  repoName: string,
-  routes: Parameters<typeof createRepoDb>[1],
-): string {
-  const repoPath = join(tmpDir, repoName);
-  const dbPath = join(repoPath, '.monomind', 'monograph.db');
-  mkdirSync(join(repoPath, '.monomind'), { recursive: true });
-  createRepoDb(dbPath, routes);
-  return repoPath;
-}
-
-// ── extractHttpContracts ──────────────────────────────────────────────────────
-
-describe('extractHttpContracts', () => {
-  it('returns Route nodes with parsed method and path', () => {
-    const repoPath = makeRepo('repo-extract', [
-      { id: 'r1', name: 'GET /api/users', filePath: 'src/users.ts' },
-      { id: 'r2', name: 'POST /api/users', filePath: 'src/users.ts' },
-    ]);
-
-    const db = new Database(join(repoPath, '.monomind', 'monograph.db'), { readonly: true });
-    try {
-      const contracts = extractHttpContracts(db, 'myRepo');
-      expect(contracts).toHaveLength(2);
-
-      const get = contracts.find((c) => c.method === 'GET');
-      expect(get).toBeDefined();
-      expect(get!.path).toBe('/api/users');
-      expect(get!.repo).toBe('myRepo');
-    } finally {
-      db.close();
-    }
-  });
-
-  it('includes handler info when HANDLES_ROUTE edge is present', () => {
-    const repoPath = makeRepo('repo-handler', [
-      {
-        id: 'r1',
-        name: 'GET /health',
-        filePath: 'src/health.ts',
-        handlerName: 'getHealth',
-        handlerFile: 'src/health.ts',
-      },
-    ]);
-
-    const db = new Database(join(repoPath, '.monomind', 'monograph.db'), { readonly: true });
-    try {
-      const contracts = extractHttpContracts(db, 'svc');
-      expect(contracts).toHaveLength(1);
-      expect(contracts[0].handlerName).toBe('getHealth');
-      expect(contracts[0].handlerFile).toBe('src/health.ts');
-    } finally {
-      db.close();
-    }
-  });
-
-  it('returns empty array when there are no Route nodes', () => {
-    const repoPath = makeRepo('repo-empty', []);
-    const db = new Database(join(repoPath, '.monomind', 'monograph.db'), { readonly: true });
-    try {
-      const contracts = extractHttpContracts(db, 'empty');
-      expect(contracts).toEqual([]);
-    } finally {
-      db.close();
-    }
-  });
-});
-
-// ── buildContractLinks ────────────────────────────────────────────────────────
-
-describe('buildContractLinks', () => {
-  it('returns a link when 2 repos share the same method + path', () => {
-    const contracts: HttpContract[] = [
-      { method: 'GET', path: '/api/users', handlerName: null, handlerFile: null, repo: 'backend' },
-      { method: 'GET', path: '/api/users', handlerName: null, handlerFile: null, repo: 'frontend' },
-      { method: 'GET', path: '/unique',    handlerName: null, handlerFile: null, repo: 'backend' },
-    ];
-
-    const links = buildContractLinks(contracts);
-    expect(links).toHaveLength(1);
-    expect(links[0].path).toBe('/api/users');
-    expect(links[0].method).toBe('GET');
-    expect(links[0].producerRepo).toBe('backend');
-    expect(links[0].consumerRepos).toContain('frontend');
-  });
-
-  it('deduplicates the same repo appearing multiple times for one route', () => {
-    // A repo that registers the same route in two files should appear only once
-    const contracts: HttpContract[] = [
-      { method: 'POST', path: '/orders', handlerName: 'h1', handlerFile: 'a.ts', repo: 'svc-a' },
-      { method: 'POST', path: '/orders', handlerName: 'h2', handlerFile: 'b.ts', repo: 'svc-a' },
-      { method: 'POST', path: '/orders', handlerName: null,  handlerFile: null,  repo: 'svc-b' },
-    ];
-
-    const links = buildContractLinks(contracts);
-    expect(links).toHaveLength(1);
-    // svc-a is producer (first seen), svc-b is consumer
-    expect(links[0].producerRepo).toBe('svc-a');
-    expect(links[0].consumerRepos).toEqual(['svc-b']);
-  });
-
-  it('returns empty when no routes are shared across repos', () => {
-    const contracts: HttpContract[] = [
-      { method: 'GET', path: '/a', handlerName: null, handlerFile: null, repo: 'repo1' },
-      { method: 'GET', path: '/b', handlerName: null, handlerFile: null, repo: 'repo2' },
-    ];
-    expect(buildContractLinks(contracts)).toEqual([]);
-  });
-
-  it('treats different methods on the same path as distinct links', () => {
-    const contracts: HttpContract[] = [
-      { method: 'GET',  path: '/items', handlerName: null, handlerFile: null, repo: 'a' },
-      { method: 'GET',  path: '/items', handlerName: null, handlerFile: null, repo: 'b' },
-      { method: 'POST', path: '/items', handlerName: null, handlerFile: null, repo: 'a' },
-      { method: 'POST', path: '/items', handlerName: null, handlerFile: null, repo: 'b' },
-    ];
-    const links = buildContractLinks(contracts);
-    expect(links).toHaveLength(2);
-    const methods = links.map((l) => l.method).sort();
-    expect(methods).toEqual(['GET', 'POST']);
-  });
-});
-
-// ── syncGroup ─────────────────────────────────────────────────────────────────
-
-describe('syncGroup', () => {
-  it('finds a cross-repo link when two repos share the same route', async () => {
-    const repoAPath = makeRepo('serviceA', [
-      { id: 'r1', name: 'GET /api/users', filePath: 'src/users.ts' },
-    ]);
-    const repoBPath = makeRepo('serviceB', [
-      { id: 'r2', name: 'GET /api/users', filePath: 'src/proxy.ts' },
-    ]);
-
-    const configPath = createGroupYaml(tmpDir, 'test-group', {
-      serviceA: repoAPath,
-      serviceB: repoBPath,
-    });
-
-    const result = await syncGroup(configPath);
-
-    expect(result.group).toBe('test-group');
-    expect(result.reposScanned).toBe(2);
-    expect(result.contractsFound).toBe(2);
-    expect(result.crossRepoLinks).toBeGreaterThanOrEqual(1);
-    expect(result.registryPath).toContain('test-group.contracts.db');
-  });
-
-  it('skips a repo whose DB does not exist', async () => {
-    const repoAPath = makeRepo('svcA', [
-      { id: 'r1', name: 'GET /ping' },
-    ]);
-
-    // svcB directory exists (parseGroupConfig checks path), but no DB inside
-    const svcBPath = join(tmpDir, 'svcB');
-    mkdirSync(svcBPath, { recursive: true });
-
-    const configPath = createGroupYaml(tmpDir, 'skip-group', {
-      svcA: repoAPath,
-      svcB: svcBPath,
-    });
-
-    const result = await syncGroup(configPath);
-    expect(result.reposScanned).toBe(1);
-  });
-
-  it('throws a descriptive error when config file is missing', async () => {
-    const missing = join(tmpDir, 'does-not-exist.yaml');
-    await expect(syncGroup(missing)).rejects.toThrow(/Group config not found/);
-  });
-
-  it('persists the registry so loadContractRegistry can read it back', async () => {
-    const repoAPath = makeRepo('alpha', [
-      { id: 'r1', name: 'DELETE /api/items/:id', filePath: 'src/items.ts' },
-    ]);
-    const repoBPath = makeRepo('beta', [
-      { id: 'r2', name: 'DELETE /api/items/:id', filePath: 'src/items-proxy.ts' },
-    ]);
-
-    const configPath = createGroupYaml(tmpDir, 'persist-group', {
-      alpha: repoAPath,
-      beta: repoBPath,
-    });
-
-    const result = await syncGroup(configPath);
-    const loaded = loadContractRegistry(result.registryPath);
-
-    expect(loaded).not.toBeNull();
-    expect(loaded!.contracts.length).toBe(2);
-    expect(loaded!.links.length).toBeGreaterThanOrEqual(1);
-    expect(loaded!.links[0].path).toBe('/api/items/:id');
-  });
-
-  it('returns zero cross-repo links when routes are unique per repo', async () => {
-    const repoAPath = makeRepo('repoX', [
-      { id: 'r1', name: 'GET /only-in-x' },
-    ]);
-    const repoBPath = makeRepo('repoY', [
-      { id: 'r2', name: 'GET /only-in-y' },
-    ]);
-
-    const configPath = createGroupYaml(tmpDir, 'no-links-group', {
-      repoX: repoAPath,
-      repoY: repoBPath,
-    });
-
-    const result = await syncGroup(configPath);
-    expect(result.crossRepoLinks).toBe(0);
-  });
-});
-
-// ── loadContractRegistry ──────────────────────────────────────────────────────
-
-describe('loadContractRegistry', () => {
-  it('returns null when the registry file does not exist', () => {
-    const missing = join(tmpDir, 'nonexistent.contracts.db');
-    expect(loadContractRegistry(missing)).toBeNull();
-  });
-});

package/__tests__/integration/build-atomicity.test.ts

@@ -1,61 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { vi } from 'vitest';
-
-// Regression (issue #40 follow-up): a phase crashing mid-build used to leave
-// the DB in a stale, partially-rebuilt state — earlier phases' writes
-// (autocommitted by better-sqlite3 outside an explicit transaction) stayed
-// committed even though the build as a whole failed, and a subsequent build
-// attempt would skip re-scanning cache-hit files, permanently under-counting
-// the index until a hard cache clear. The build is now wrapped in one SQL
-// transaction spanning the whole pipeline run, rolled back on any failure.
-vi.mock('../../src/pipeline/phases/god-nodes.js', () => ({
-  godNodesPhase: {
-    name: 'god-nodes',
-    deps: ['cross-file'],
-    execute: async () => { throw new Error('simulated late-stage phase crash'); },
-  },
-}));
-
-const tmpRepo = join(tmpdir(), `monograph-atomicity-${Date.now()}`);
-
-beforeAll(() => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-  writeFileSync(join(tmpRepo, 'src', 'greeter.ts'), `
-export interface Greeter {
-  greet(name: string): string;
-}
-export class GreeterImpl implements Greeter {
-  greet(name: string): string {
-    return 'hello ' + name;
-  }
-}
-  `);
-});
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-describe('build atomicity — a phase crash rolls back the whole build', () => {
-  it('leaves zero nodes/edges after a mid-build crash, instead of a partial write', async () => {
-    const { buildAsync } = await import('../../src/pipeline/orchestrator.js');
-    await expect(buildAsync(tmpRepo)).rejects.toThrow(/simulated late-stage phase crash/);
-
-    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
-    expect(existsSync(dbPath)).toBe(true);
-
-    const { openDb, closeDb } = await import('../../src/storage/db.js');
-    const { countNodes } = await import('../../src/storage/node-store.js');
-    const { countEdges } = await import('../../src/storage/edge-store.js');
-    const db = openDb(dbPath);
-    try {
-      // parse/cross-file/etc. all ran and wrote real rows before god-nodes
-      // threw — without the transaction wrap, those writes would be
-      // committed already. With it, the whole attempt rolls back to empty.
-      expect(countNodes(db)).toBe(0);
-      expect(countEdges(db)).toBe(0);
-    } finally {
-      closeDb(db);
-    }
-  }, 30000);
-});