@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/mcp-tools/api-impact.test.ts

@@ -1,188 +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 } from '../../src/storage/node-store.js';
-import { insertEdge } from '../../src/storage/edge-store.js';
-import { getMonographApiImpact } from '../../src/mcp-tools/api-impact.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-/**
- * Graph:
- *   Route "ANY /api/users"
- *     └─ HANDLES_ROUTE → handler "getUsersHandler"
- *          └─ CALLS → "fetchUsersFromDb"
- *               └─ CALLS → "runQuery"
- *
- *   Route "GET /health" (no handler, no callees)
- */
-
-const dbPath = join(tmpdir(), `monograph-api-impact-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const routeApiUsers: MonographNode = {
-  id: 'ai_route_api_users',
-  label: 'Route',
-  name: 'ANY /api/users',
-  normLabel: 'any /api/users',
-  filePath: 'pages/api/users.ts',
-  startLine: 0,
-  isExported: false,
-};
-
-const routeHealth: MonographNode = {
-  id: 'ai_route_health',
-  label: 'Route',
-  name: 'GET /health',
-  normLabel: 'get /health',
-  filePath: 'pages/health.ts',
-  startLine: 0,
-  isExported: false,
-};
-
-const handler: MonographNode = {
-  id: 'ai_fn_handler',
-  label: 'Function',
-  name: 'getUsersHandler',
-  normLabel: 'getusershandler',
-  filePath: 'pages/api/users.ts',
-  startLine: 10,
-  isExported: true,
-};
-
-const fetchFn: MonographNode = {
-  id: 'ai_fn_fetch',
-  label: 'Function',
-  name: 'fetchUsersFromDb',
-  normLabel: 'fetchusersfromdb',
-  filePath: 'src/db/users.ts',
-  startLine: 20,
-  isExported: false,
-};
-
-const queryFn: MonographNode = {
-  id: 'ai_fn_query',
-  label: 'Function',
-  name: 'runQuery',
-  normLabel: 'runquery',
-  filePath: 'src/db/query.ts',
-  startLine: 5,
-  isExported: false,
-};
-
-const edgeHandlesRoute: MonographEdge = {
-  id: 'ai_e_handles_route',
-  sourceId: 'ai_route_api_users',
-  targetId: 'ai_fn_handler',
-  relation: 'HANDLES_ROUTE',
-  confidence: 'EXTRACTED',
-  confidenceScore: 0.9,
-};
-
-const edgeHandlerCallsFetch: MonographEdge = {
-  id: 'ai_e_handler_fetch',
-  sourceId: 'ai_fn_handler',
-  targetId: 'ai_fn_fetch',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-const edgeFetchCallsQuery: MonographEdge = {
-  id: 'ai_e_fetch_query',
-  sourceId: 'ai_fn_fetch',
-  targetId: 'ai_fn_query',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, routeApiUsers);
-  insertNode(db, routeHealth);
-  insertNode(db, handler);
-  insertNode(db, fetchFn);
-  insertNode(db, queryFn);
-  insertEdge(db, edgeHandlesRoute);
-  insertEdge(db, edgeHandlerCallsFetch);
-  insertEdge(db, edgeFetchCallsQuery);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-describe('getMonographApiImpact', () => {
-  it('returns null route for unknown path', () => {
-    const result = getMonographApiImpact(db, { routePath: '/nonexistent' });
-    expect(result.route).toBeNull();
-    expect(result.handler).toBeNull();
-    expect(result.callees).toHaveLength(0);
-    expect(result.riskScore).toBe(0);
-  });
-
-  it('finds route for /api/users', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(result.route).not.toBeNull();
-    expect(result.route!.path).toBe('/api/users');
-    expect(result.route!.nodeId).toBe('ai_route_api_users');
-  });
-
-  it('returns handler node for the route', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(result.handler).not.toBeNull();
-    expect(result.handler!.name).toBe('getUsersHandler');
-    expect(result.handler!.id).toBe('ai_fn_handler');
-  });
-
-  it('callees array contains the directly called function', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(result.callees.length).toBeGreaterThan(0);
-    const fetchCallee = result.callees.find((c) => c.node.id === 'ai_fn_fetch');
-    expect(fetchCallee).toBeDefined();
-    expect(fetchCallee!.depth).toBe(1);
-  });
-
-  it('callees array contains transitively called function', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    const queryCallee = result.callees.find((c) => c.node.id === 'ai_fn_query');
-    expect(queryCallee).toBeDefined();
-    expect(queryCallee!.depth).toBe(2);
-  });
-
-  it('riskScore is greater than 0 when callees exist', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(result.riskScore).toBeGreaterThan(0);
-  });
-
-  it('riskScore is capped at 10', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(result.riskScore).toBeLessThanOrEqual(10);
-  });
-
-  it('route with no handler returns handler null but route set', () => {
-    const result = getMonographApiImpact(db, { routePath: '/health' });
-    expect(result.route).not.toBeNull();
-    expect(result.route!.path).toBe('/health');
-    expect(result.handler).toBeNull();
-    expect(result.callees).toHaveLength(0);
-  });
-
-  it('method filter narrows results correctly', () => {
-    // Route is "ANY /api/users" — filtering by GET should still match since ANY is not GET
-    // But there's no GET /api/users route, so result.route should be null when strict method is used
-    // The implementation falls back to all matches if filtered list is empty
-    const result = getMonographApiImpact(db, { routePath: '/health', method: 'GET' });
-    expect(result.route).not.toBeNull();
-    expect(result.route!.method).toBe('GET');
-  });
-
-  it('affectedProcesses is an array (may be empty if no STEP_IN_PROCESS edges)', () => {
-    const result = getMonographApiImpact(db, { routePath: '/api/users' });
-    expect(Array.isArray(result.affectedProcesses)).toBe(true);
-  });
-});

package/__tests__/mcp-tools/context.test.ts

@@ -1,130 +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 } from '../../src/storage/node-store.js';
-import { insertEdge } from '../../src/storage/edge-store.js';
-import { getMonographContext } from '../../src/mcp-tools/context.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-const dbPath = join(tmpdir(), `monograph-context-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const nodeA: MonographNode = {
-  id: 'ctx_a',
-  label: 'Function',
-  name: 'alpha',
-  normLabel: 'alpha',
-  filePath: 'src/a.ts',
-  startLine: 1,
-  isExported: true,
-};
-const nodeB: MonographNode = {
-  id: 'ctx_b',
-  label: 'Function',
-  name: 'beta',
-  normLabel: 'beta',
-  filePath: 'src/b.ts',
-  startLine: 5,
-  isExported: false,
-};
-const nodeC: MonographNode = {
-  id: 'ctx_c',
-  label: 'Class',
-  name: 'Gamma',
-  normLabel: 'gamma',
-  filePath: 'src/c.ts',
-  startLine: 1,
-  isExported: true,
-};
-
-// b calls a, a imports c
-const edgeCallBA: MonographEdge = {
-  id: 'e_ba_calls',
-  sourceId: 'ctx_b',
-  targetId: 'ctx_a',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-const edgeImportAC: MonographEdge = {
-  id: 'e_ac_imports',
-  sourceId: 'ctx_a',
-  targetId: 'ctx_c',
-  relation: 'IMPORTS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, nodeA);
-  insertNode(db, nodeB);
-  insertNode(db, nodeC);
-  insertEdge(db, edgeCallBA);
-  insertEdge(db, edgeImportAC);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-describe('getMonographContext', () => {
-  it('returns null node for unknown symbol', () => {
-    const result = getMonographContext(db, { name: 'nonexistent' });
-    expect(result.node).toBeNull();
-    expect(result.callers).toHaveLength(0);
-  });
-
-  it('finds the node by name', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.node).not.toBeNull();
-    expect(result.node?.id).toBe('ctx_a');
-  });
-
-  it('populates callers correctly (b calls a)', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.callers).toHaveLength(1);
-    expect(result.callers[0].id).toBe('ctx_b');
-  });
-
-  it('populates callees correctly (a calls nothing here)', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.callees).toHaveLength(0);
-  });
-
-  it('populates imports correctly (a imports c)', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.imports).toHaveLength(1);
-    expect(result.imports[0].id).toBe('ctx_c');
-  });
-
-  it('populates importedBy correctly (c is imported by a)', () => {
-    const result = getMonographContext(db, { name: 'Gamma' });
-    expect(result.importedBy).toHaveLength(1);
-    expect(result.importedBy[0].id).toBe('ctx_a');
-  });
-
-  it('disambiguates by filePath', () => {
-    const result = getMonographContext(db, { name: 'alpha', filePath: 'src/a.ts' });
-    expect(result.node?.id).toBe('ctx_a');
-  });
-
-  it('returns null for wrong filePath', () => {
-    const result = getMonographContext(db, { name: 'alpha', filePath: 'src/wrong.ts' });
-    expect(result.node).toBeNull();
-  });
-
-  it('community is null when node has no communityId', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.community).toBeNull();
-  });
-
-  it('inProcesses is empty when no STEP_IN_PROCESS edges', () => {
-    const result = getMonographContext(db, { name: 'alpha' });
-    expect(result.inProcesses).toHaveLength(0);
-  });
-});

package/__tests__/mcp-tools/cypher.test.ts

@@ -1,258 +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 } from '../../src/storage/node-store.js';
-import { insertEdge } from '../../src/storage/edge-store.js';
-import { getMonographCypher } from '../../src/mcp-tools/cypher.js';
-import {
-  parseCypherQuery,
-  cypherToSql,
-  executeCypherQuery,
-} from '../../src/query/cypher-parser.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-// ── Shared test DB setup ───────────────────────────────────────────────────────
-
-const dbPath = join(tmpdir(), `monograph-cypher-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const fnBuildAsync: MonographNode = {
-  id: 'cy_build',
-  label: 'Function',
-  name: 'buildAsync',
-  normLabel: 'buildasync',
-  filePath: 'src/pipeline/runner.ts',
-  startLine: 10,
-  endLine: 50,
-  isExported: true,
-  language: 'typescript',
-};
-
-const fnAuthenticate: MonographNode = {
-  id: 'cy_auth',
-  label: 'Function',
-  name: 'authenticate',
-  normLabel: 'authenticate',
-  filePath: 'src/auth/index.ts',
-  startLine: 5,
-  endLine: 30,
-  isExported: true,
-  language: 'typescript',
-};
-
-const clsUserService: MonographNode = {
-  id: 'cy_us',
-  label: 'Class',
-  name: 'UserService',
-  normLabel: 'userservice',
-  filePath: 'src/user/service.ts',
-  startLine: 1,
-  endLine: 120,
-  isExported: true,
-  language: 'typescript',
-};
-
-// buildAsync --CALLS--> authenticate
-const edgeCalls: MonographEdge = {
-  id: 'cy_e_calls',
-  sourceId: 'cy_build',
-  targetId: 'cy_auth',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, fnBuildAsync);
-  insertNode(db, fnAuthenticate);
-  insertNode(db, clsUserService);
-  insertEdge(db, edgeCalls);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-// ── parseCypherQuery unit tests ────────────────────────────────────────────────
-
-describe('parseCypherQuery', () => {
-  it('parses a simple node pattern with inline prop', () => {
-    const { parsed, error } = parseCypherQuery(
-      'MATCH (n:Function {name: "buildAsync"}) RETURN n.name',
-    );
-    expect(error).toBeUndefined();
-    expect(parsed).not.toBeNull();
-    expect(parsed!.type).toBe('node');
-    expect(parsed!.nodeA.label).toBe('Function');
-    expect(parsed!.nodeA.props).toEqual({ name: 'buildAsync' });
-    expect(parsed!.returnFields).toEqual([{ alias: 'n', field: 'name' }]);
-  });
-
-  it('parses a relationship pattern', () => {
-    const { parsed, error } = parseCypherQuery(
-      'MATCH (a:Function)-[:CALLS]->(b:Function {name: "authenticate"}) RETURN a.name, a.filePath',
-    );
-    expect(error).toBeUndefined();
-    expect(parsed).not.toBeNull();
-    expect(parsed!.type).toBe('relationship');
-    expect(parsed!.relation).toBe('CALLS');
-    expect(parsed!.nodeA.alias).toBe('a');
-    expect(parsed!.nodeB!.alias).toBe('b');
-    expect(parsed!.nodeB!.props).toEqual({ name: 'authenticate' });
-    expect(parsed!.returnFields).toEqual([
-      { alias: 'a', field: 'name' },
-      { alias: 'a', field: 'filePath' },
-    ]);
-  });
-
-  it('parses a node pattern with WHERE clause', () => {
-    const { parsed, error } = parseCypherQuery(
-      'MATCH (n:Function) WHERE n.name = "buildAsync" RETURN n.name, n.filePath',
-    );
-    expect(error).toBeUndefined();
-    expect(parsed).not.toBeNull();
-    expect(parsed!.whereClause).toEqual({ alias: 'n', field: 'name', value: 'buildAsync' });
-  });
-
-  it('blocks CREATE — returns error', () => {
-    const { parsed, error } = parseCypherQuery('CREATE (n:Node) RETURN n.name');
-    expect(parsed).toBeNull();
-    expect(error).toContain('Write operations not supported');
-    expect(error).toContain('CREATE');
-  });
-
-  it('blocks MERGE — returns error', () => {
-    const { parsed, error } = parseCypherQuery('MERGE (n:Node {name: "x"}) RETURN n.name');
-    expect(parsed).toBeNull();
-    expect(error).toContain('Write operations not supported');
-  });
-
-  it('blocks DELETE — returns error', () => {
-    const { parsed, error } = parseCypherQuery('MATCH (n) DELETE n');
-    expect(parsed).toBeNull();
-    expect(error).toContain('Write operations not supported');
-  });
-
-  it('returns parse error for invalid query string', () => {
-    const { parsed, error } = parseCypherQuery('invalid query string');
-    expect(parsed).toBeNull();
-    expect(error).toMatch(/parse error/i);
-  });
-
-  it('returns parse error for missing RETURN', () => {
-    const { parsed, error } = parseCypherQuery('MATCH (n:Function)');
-    expect(parsed).toBeNull();
-    expect(error).toMatch(/RETURN/i);
-  });
-
-  it('rejects unknown RETURN field', () => {
-    const { parsed, error } = parseCypherQuery('MATCH (n:Function) RETURN n.unknownField');
-    expect(parsed).toBeNull();
-    expect(error).toMatch(/unknown|invalid/i);
-  });
-});
-
-// ── cypherToSql unit tests ─────────────────────────────────────────────────────
-
-describe('cypherToSql', () => {
-  it('generates correct SQL for a node-only query', () => {
-    const { parsed } = parseCypherQuery(
-      'MATCH (n:Class {name: "UserService"}) RETURN n.name, n.filePath',
-    );
-    const { sql, params } = cypherToSql(parsed!);
-    expect(sql).toContain('FROM nodes n');
-    expect(sql).toContain('n.label = ?');
-    expect(sql).toContain('n.name = ?');
-    expect(params).toContain('Class');
-    expect(params).toContain('UserService');
-    expect(sql).toContain('LIMIT 200');
-    expect(sql).toContain('n.name AS "n_name"');
-    expect(sql).toContain('n.file_path AS "n_filePath"');
-  });
-
-  it('generates correct SQL for a relationship query', () => {
-    const { parsed } = parseCypherQuery(
-      'MATCH (a:Function)-[:CALLS]->(b:Function {name: "authenticate"}) RETURN a.name, a.filePath',
-    );
-    const { sql, params } = cypherToSql(parsed!);
-    expect(sql).toContain('FROM nodes a');
-    expect(sql).toContain('e.relation = ?');
-    expect(params).toContain('CALLS');
-    expect(sql).toContain('JOIN nodes b ON b.id = e.target_id');
-    expect(sql).toContain('b.name = ?');
-    expect(params).toContain('authenticate');
-    expect(sql).toContain('LIMIT 200');
-  });
-});
-
-// ── executeCypherQuery integration tests ─────────────────────────────────────
-
-describe('executeCypherQuery', () => {
-  it('returns rows for a matching node query', () => {
-    const result = executeCypherQuery(
-      db,
-      'MATCH (n:Function {name: "buildAsync"}) RETURN n.name',
-    );
-    expect(result.error).toBeUndefined();
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0]['n_name']).toBe('buildAsync');
-    expect(result.queryTime).toBeGreaterThanOrEqual(0);
-  });
-
-  it('returns empty rows when no match', () => {
-    const result = executeCypherQuery(
-      db,
-      'MATCH (n:Function {name: "nonexistent"}) RETURN n.name',
-    );
-    expect(result.error).toBeUndefined();
-    expect(result.rows).toHaveLength(0);
-  });
-
-  it('returns rows for a relationship query', () => {
-    const result = executeCypherQuery(
-      db,
-      'MATCH (a:Function)-[:CALLS]->(b:Function {name: "authenticate"}) RETURN a.name, a.filePath',
-    );
-    expect(result.error).toBeUndefined();
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0]['a_name']).toBe('buildAsync');
-    expect(result.rows[0]['a_filePath']).toBe('src/pipeline/runner.ts');
-  });
-
-  it('returns error (not throw) for write operation', () => {
-    const result = executeCypherQuery(db, 'CREATE (n:Node) RETURN n.name');
-    expect(result.error).toContain('Write operations not supported');
-    expect(result.rows).toHaveLength(0);
-  });
-
-  it('returns error (not throw) for invalid query', () => {
-    const result = executeCypherQuery(db, 'garbage query here');
-    expect(result.error).toMatch(/parse error/i);
-    expect(result.rows).toHaveLength(0);
-  });
-});
-
-// ── getMonographCypher (MCP facade) ───────────────────────────────────────────
-
-describe('getMonographCypher', () => {
-  it('delegates to executeCypherQuery and returns results', () => {
-    const result = getMonographCypher(
-      db,
-      'MATCH (n:Class {name: "UserService"}) RETURN n.name, n.filePath',
-    );
-    expect(result.error).toBeUndefined();
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0]['n_name']).toBe('UserService');
-  });
-
-  it('returns error gracefully for forbidden operation', () => {
-    const result = getMonographCypher(db, 'DROP TABLE nodes');
-    expect(result.error).toContain('Write operations not supported');
-    expect(result.rows).toHaveLength(0);
-  });
-});

package/__tests__/mcp-tools/detect-changes.test.ts

@@ -1,114 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync } from 'fs';
-import { vi, describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { insertNode } from '../../src/storage/node-store.js';
-import { detectMonographChanges } from '../../src/mcp-tools/detect-changes.js';
-import type { MonographNode } from '../../src/types.js';
-
-// vi.mock must be at the top level for Vitest to hoist it correctly
-vi.mock('child_process', () => ({
-  spawnSync: vi.fn(),
-}));
-
-// After the mock, import the mocked module to control it
-import { spawnSync } from 'child_process';
-
-function mockGitOutput(stdout: string) {
-  vi.mocked(spawnSync).mockReturnValue({ stdout, stderr: '', status: 0, error: undefined } as any);
-}
-
-const dbPath = join(tmpdir(), `monograph-detect-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const nodeAuth: MonographNode = {
-  id: 'det_auth',
-  label: 'Function',
-  name: 'authenticate',
-  normLabel: 'authenticate',
-  filePath: 'src/auth.ts',
-  startLine: 10,
-  isExported: true,
-};
-
-const nodeOther: MonographNode = {
-  id: 'det_other',
-  label: 'Function',
-  name: 'otherFunc',
-  normLabel: 'otherfunc',
-  filePath: 'src/other.ts',
-  startLine: 1,
-  isExported: false,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, nodeAuth);
-  insertNode(db, nodeOther);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('detectMonographChanges', () => {
-  it('returns affected symbols for a changed file', () => {
-    mockGitOutput('src/auth.ts\n');
-
-    const result = detectMonographChanges(db, { baseBranch: 'main' }, '/fake/repo');
-
-    expect(result.changedFiles).toContain('src/auth.ts');
-    expect(result.affectedSymbols.some(s => s.name === 'authenticate')).toBe(true);
-    expect(result.error).toBeUndefined();
-  });
-
-  it('filters out test files when includeTests=false', () => {
-    mockGitOutput('src/auth.ts\nsrc/auth.test.ts\n');
-
-    const result = detectMonographChanges(db, { baseBranch: 'main', includeTests: false }, '/fake/repo');
-
-    expect(result.changedFiles).toContain('src/auth.ts');
-    expect(result.changedFiles).not.toContain('src/auth.test.ts');
-  });
-
-  it('returns empty result when no files changed', () => {
-    mockGitOutput('');
-
-    const result = detectMonographChanges(db, { baseBranch: 'main' }, '/fake/repo');
-
-    expect(result.changedFiles).toHaveLength(0);
-    expect(result.affectedSymbols).toHaveLength(0);
-    expect(result.error).toBeUndefined();
-  });
-
-  it('handles git errors gracefully', () => {
-    vi.mocked(spawnSync).mockReturnValue({ stdout: '', stderr: 'git: not a repository', status: 128, error: undefined } as any);
-
-    const result = detectMonographChanges(db, { baseBranch: 'main' }, '/fake/repo');
-
-    expect(result.changedFiles).toHaveLength(0);
-    expect(result.affectedSymbols).toHaveLength(0);
-    expect(result.error).toBeDefined();
-    expect(result.error).toContain('git');
-  });
-
-  it('uses main as default base branch', () => {
-    mockGitOutput('');
-
-    detectMonographChanges(db, {}, '/fake/repo');
-
-    expect(spawnSync).toHaveBeenCalledWith(
-      'git',
-      expect.arrayContaining(['main...HEAD']),
-      expect.any(Object),
-    );
-  });
-});