@monoes/monograph 1.5.6 → 1.5.8

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

@@ -1,133 +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 { getMonographImpact } from '../../src/mcp-tools/impact.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-// Graph: a() calls b(), b() calls c()
-// Impact on c: directCallers=[b], transitiveCallers=[a at depth 2]
-
-const dbPath = join(tmpdir(), `monograph-impact-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const nodeA: MonographNode = {
-  id: 'imp_a',
-  label: 'Function',
-  name: 'funcA',
-  normLabel: 'funca',
-  filePath: 'src/a.ts',
-  startLine: 1,
-  isExported: true,
-};
-const nodeB: MonographNode = {
-  id: 'imp_b',
-  label: 'Function',
-  name: 'funcB',
-  normLabel: 'funcb',
-  filePath: 'src/b.ts',
-  startLine: 1,
-  isExported: true,
-};
-const nodeC: MonographNode = {
-  id: 'imp_c',
-  label: 'Function',
-  name: 'funcC',
-  normLabel: 'funcc',
-  filePath: 'src/c.ts',
-  startLine: 1,
-  isExported: false,
-};
-
-// a calls b
-const edgeAB: MonographEdge = {
-  id: 'e_ab',
-  sourceId: 'imp_a',
-  targetId: 'imp_b',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-// b calls c
-const edgeBC: MonographEdge = {
-  id: 'e_bc',
-  sourceId: 'imp_b',
-  targetId: 'imp_c',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, nodeA);
-  insertNode(db, nodeB);
-  insertNode(db, nodeC);
-  insertEdge(db, edgeAB);
-  insertEdge(db, edgeBC);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-describe('getMonographImpact', () => {
-  it('returns null node for unknown symbol', () => {
-    const result = getMonographImpact(db, { name: 'nonexistent' });
-    expect(result.node).toBeNull();
-    expect(result.directCallers).toHaveLength(0);
-    expect(result.riskScore).toBe(0);
-  });
-
-  it('finds the node by name', () => {
-    const result = getMonographImpact(db, { name: 'funcC' });
-    expect(result.node).not.toBeNull();
-    expect(result.node?.id).toBe('imp_c');
-  });
-
-  it('directCallers contains funcB', () => {
-    const result = getMonographImpact(db, { name: 'funcC' });
-    expect(result.directCallers).toHaveLength(1);
-    expect(result.directCallers[0].id).toBe('imp_b');
-  });
-
-  it('transitiveCallers contains funcA at depth 2', () => {
-    const result = getMonographImpact(db, { name: 'funcC' });
-    expect(result.transitiveCallers.length).toBeGreaterThan(0);
-    const depth2 = result.transitiveCallers.find(t => t.depth === 2);
-    expect(depth2).toBeDefined();
-    expect(depth2!.nodes.some(n => n.id === 'imp_a')).toBe(true);
-  });
-
-  it('affectedFiles contains file of funcB', () => {
-    const result = getMonographImpact(db, { name: 'funcC' });
-    expect(result.affectedFiles).toContain('src/b.ts');
-  });
-
-  it('riskScore is greater than 0 when there are callers', () => {
-    const result = getMonographImpact(db, { name: 'funcC' });
-    expect(result.riskScore).toBeGreaterThan(0);
-  });
-
-  it('riskScore is 0 for leaf nodes with no callers', () => {
-    const result = getMonographImpact(db, { name: 'funcA' });
-    // funcA has no callers
-    expect(result.directCallers).toHaveLength(0);
-    expect(result.riskScore).toBe(0);
-  });
-
-  it('respects depth limit', () => {
-    // With depth=1, only direct callers of c (b), no transitive (a)
-    const result = getMonographImpact(db, { name: 'funcC', depth: 1 });
-    expect(result.directCallers).toHaveLength(1);
-    const hasATransitive = result.transitiveCallers.some(t =>
-      t.nodes.some(n => n.id === 'imp_a'),
-    );
-    expect(hasATransitive).toBe(false);
-  });
-});

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

@@ -1,117 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, unlinkSync, rmdirSync, 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 { getMonographRename } from '../../src/mcp-tools/rename.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-// Build a small repo:
-// auth.ts exports authenticate()
-// api.ts imports authenticate() and calls it
-
-const repoDir = join(tmpdir(), `monograph-rename-repo-${Date.now()}`);
-const dbPath = join(tmpdir(), `monograph-rename-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const authFilePath = join(repoDir, 'auth.ts');
-const apiFilePath = join(repoDir, 'api.ts');
-
-const nodeAuthenticate: MonographNode = {
-  id: 'ren_auth',
-  label: 'Function',
-  name: 'authenticate',
-  normLabel: 'authenticate',
-  filePath: authFilePath,
-  startLine: 1,
-  isExported: true,
-};
-
-const nodeApiHandler: MonographNode = {
-  id: 'ren_api',
-  label: 'Function',
-  name: 'handleRequest',
-  normLabel: 'handlerequest',
-  filePath: apiFilePath,
-  startLine: 4, // line 4: "  return authenticate(user);" — contains the reference
-  isExported: true,
-};
-
-// api calls authenticate
-const edgeApiCallsAuth: MonographEdge = {
-  id: 'e_api_auth_calls',
-  sourceId: 'ren_api',
-  targetId: 'ren_auth',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-beforeAll(() => {
-  mkdirSync(repoDir, { recursive: true });
-
-  // Write source files with the symbol name on the relevant lines
-  writeFileSync(authFilePath, `export function authenticate(user: string): boolean {\n  return user.length > 0;\n}\n`);
-  writeFileSync(apiFilePath, `import { authenticate } from './auth';\n\nexport function handleRequest(user: string) {\n  return authenticate(user);\n}\n`);
-
-  db = openDb(dbPath);
-  insertNode(db, nodeAuthenticate);
-  insertNode(db, nodeApiHandler);
-  insertEdge(db, edgeApiCallsAuth);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-  // Cleanup temp files
-  for (const f of [authFilePath, apiFilePath]) {
-    if (existsSync(f)) unlinkSync(f);
-  }
-  if (existsSync(repoDir)) rmdirSync(repoDir);
-});
-
-describe('getMonographRename', () => {
-  it('returns null symbol for unknown name', () => {
-    const result = getMonographRename(db, { oldName: 'nonexistent', newName: 'newName' });
-    expect(result.symbol).toBeNull();
-    expect(result.referencingFiles).toHaveLength(0);
-    expect(result.changes).toHaveLength(0);
-  });
-
-  it('finds the canonical symbol', () => {
-    const result = getMonographRename(db, { oldName: 'authenticate', newName: 'login' });
-    expect(result.symbol).not.toBeNull();
-    expect(result.symbol?.id).toBe('ren_auth');
-  });
-
-  it('referencingFiles includes api.ts', () => {
-    const result = getMonographRename(db, { oldName: 'authenticate', newName: 'login' });
-    expect(result.referencingFiles).toContain(apiFilePath);
-  });
-
-  it('changes array has before/after entries', () => {
-    const result = getMonographRename(db, { oldName: 'authenticate', newName: 'login' });
-    expect(result.changes.length).toBeGreaterThan(0);
-    const change = result.changes[0];
-    expect(change.before).toContain('authenticate');
-    expect(change.after).toContain('login');
-    expect(change.after).not.toContain('authenticate');
-  });
-
-  it('does NOT write files (dry run always)', async () => {
-    const result = getMonographRename(db, { oldName: 'authenticate', newName: 'login', dryRun: false });
-    // File should still contain the old name
-    const { readFileSync } = await import('node:fs');
-    const content = readFileSync(apiFilePath, 'utf-8');
-    expect(content).toContain('authenticate');
-    expect(result.changes.length).toBeGreaterThan(0);
-  });
-
-  it('disambiguates by filePath', () => {
-    const result = getMonographRename(db, { oldName: 'authenticate', newName: 'login', filePath: authFilePath });
-    expect(result.symbol?.filePath).toBe(authFilePath);
-  });
-});

package/__tests__/mcp-tools/route-map.test.ts

@@ -1,237 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync, writeFileSync, mkdirSync } 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 { getMonographRouteMap } from '../../src/mcp-tools/route-map.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-/**
- * Graph:
- *   Route node: "ANY /api/users"  → HANDLES_ROUTE → handler function "getUsers"
- *   Route node: "GET /health"     (no handler)
- */
-
-const dbPath = join(tmpdir(), `monograph-route-map-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const routeApiUsers: MonographNode = {
-  id: '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: 'route_health',
-  label: 'Route',
-  name: 'GET /health',
-  normLabel: 'get /health',
-  filePath: 'pages/health.ts',
-  startLine: 0,
-  isExported: false,
-};
-
-const handlerGetUsers: MonographNode = {
-  id: 'fn_get_users',
-  label: 'Function',
-  name: 'getUsers',
-  normLabel: 'getusers',
-  filePath: 'pages/api/users.ts',
-  startLine: 5,
-  isExported: true,
-};
-
-const handlesRouteEdge: MonographEdge = {
-  id: 'e_route_handler',
-  sourceId: 'route_api_users',
-  targetId: 'fn_get_users',
-  relation: 'HANDLES_ROUTE',
-  confidence: 'EXTRACTED',
-  confidenceScore: 0.9,
-};
-
-beforeAll(() => {
-  db = openDb(dbPath);
-  insertNode(db, routeApiUsers);
-  insertNode(db, routeHealth);
-  insertNode(db, handlerGetUsers);
-  insertEdge(db, handlesRouteEdge);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-});
-
-describe('getMonographRouteMap', () => {
-  it('returns all routes when no filter is given', () => {
-    const result = getMonographRouteMap(db, {});
-    expect(result.total).toBe(2);
-    expect(result.routes).toHaveLength(2);
-  });
-
-  it('routes array contains route with path /api/users', () => {
-    const result = getMonographRouteMap(db, {});
-    const userRoute = result.routes.find((r) => r.path === '/api/users');
-    expect(userRoute).toBeDefined();
-    expect(userRoute!.routeNodeId).toBe('route_api_users');
-  });
-
-  it('attaches handler info when HANDLES_ROUTE edge exists', () => {
-    const result = getMonographRouteMap(db, {});
-    const userRoute = result.routes.find((r) => r.path === '/api/users');
-    expect(userRoute).toBeDefined();
-    expect(userRoute!.handlerName).toBe('getUsers');
-    expect(userRoute!.handlerFile).toBe('pages/api/users.ts');
-    expect(userRoute!.handlerLine).toBe(5);
-  });
-
-  it('handlerName is null for routes without a handler', () => {
-    const result = getMonographRouteMap(db, {});
-    const healthRoute = result.routes.find((r) => r.path === '/health');
-    expect(healthRoute).toBeDefined();
-    expect(healthRoute!.handlerName).toBeNull();
-  });
-
-  it('prefix filter /api returns only API routes', () => {
-    const result = getMonographRouteMap(db, { prefix: '/api' });
-    expect(result.total).toBe(1);
-    expect(result.routes[0].path).toBe('/api/users');
-  });
-
-  it('prefix filter /health returns only health route', () => {
-    const result = getMonographRouteMap(db, { prefix: '/health' });
-    expect(result.total).toBe(1);
-    expect(result.routes[0].path).toBe('/health');
-  });
-
-  it('prefix filter with no match returns empty', () => {
-    const result = getMonographRouteMap(db, { prefix: '/nonexistent' });
-    expect(result.total).toBe(0);
-    expect(result.routes).toHaveLength(0);
-  });
-
-  it('method filter GET returns GET routes (and ANY routes since ANY handles all methods)', () => {
-    const result = getMonographRouteMap(db, { method: 'GET' });
-    // "GET /health" matches strictly; "ANY /api/users" also matches since ANY includes GET
-    expect(result.total).toBeGreaterThanOrEqual(1);
-    const paths = result.routes.map((r) => r.path);
-    expect(paths).toContain('/health');
-  });
-
-  it('method filter POST returns routes with POST or ANY method', () => {
-    const result = getMonographRouteMap(db, { method: 'POST' });
-    // "ANY /api/users" should match POST since ANY handles any method
-    const paths = result.routes.map((r) => r.path);
-    expect(paths).toContain('/api/users');
-  });
-
-  it('total matches routes array length', () => {
-    const result = getMonographRouteMap(db, {});
-    expect(result.total).toBe(result.routes.length);
-  });
-
-  it('middlewareChain is empty array when includeMiddleware is not set', () => {
-    const result = getMonographRouteMap(db, {});
-    for (const route of result.routes) {
-      expect(Array.isArray(route.middlewareChain)).toBe(true);
-      expect(route.middlewareChain).toEqual([]);
-    }
-  });
-
-  it('middlewareChain is empty when includeMiddleware=true but repoPath not provided', () => {
-    const result = getMonographRouteMap(db, { includeMiddleware: true });
-    for (const route of result.routes) {
-      expect(route.middlewareChain).toEqual([]);
-    }
-  });
-});
-
-describe('getMonographRouteMap — middleware detection (query-time)', () => {
-  const repoPath = join(tmpdir(), `monograph-mw-repo-${Date.now()}`);
-  const dbPath2 = join(tmpdir(), `monograph-mw-${Date.now()}.db`);
-  let db2: ReturnType<typeof openDb>;
-
-  const routeNode: MonographNode = {
-    id: 'route_mw_test',
-    label: 'Route',
-    name: 'GET /protected',
-    normLabel: 'get /protected',
-    filePath: 'src/handlers/protected.ts',
-    startLine: 0,
-    isExported: false,
-  };
-
-  const handlerNode: MonographNode = {
-    id: 'fn_get_protected',
-    label: 'Function',
-    name: 'getProtected',
-    normLabel: 'getprotected',
-    filePath: 'src/handlers/protected.ts',
-    startLine: 3,
-    isExported: true,
-  };
-
-  const handlerEdge: MonographEdge = {
-    id: 'e_mw_route_handler',
-    sourceId: 'route_mw_test',
-    targetId: 'fn_get_protected',
-    relation: 'HANDLES_ROUTE',
-    confidence: 'EXTRACTED',
-    confidenceScore: 0.9,
-  };
-
-  beforeAll(() => {
-    // Set up an in-memory repo directory with a handler file that has middleware wrapping
-    mkdirSync(join(repoPath, 'src/handlers'), { recursive: true });
-    writeFileSync(
-      join(repoPath, 'src/handlers/protected.ts'),
-      `export default withAuth(withRateLimit(getProtected));\nfunction getProtected(req, res) { res.send('ok'); }`,
-      'utf-8',
-    );
-
-    db2 = openDb(dbPath2);
-    insertNode(db2, routeNode);
-    insertNode(db2, handlerNode);
-    insertEdge(db2, handlerEdge);
-  });
-
-  afterAll(() => {
-    closeDb(db2);
-    for (const p of [dbPath2, dbPath2 + '-wal', dbPath2 + '-shm']) {
-      if (existsSync(p)) unlinkSync(p);
-    }
-  });
-
-  it('populates middlewareChain when includeMiddleware=true and repoPath is provided', () => {
-    const result = getMonographRouteMap(db2, { includeMiddleware: true, repoPath });
-    const route = result.routes.find((r) => r.path === '/protected');
-    expect(route).toBeDefined();
-    expect(route!.middlewareChain).toEqual(['withAuth', 'withRateLimit']);
-  });
-
-  it('middlewareChain is empty when includeMiddleware=false even with repoPath', () => {
-    const result = getMonographRouteMap(db2, { includeMiddleware: false, repoPath });
-    const route = result.routes.find((r) => r.path === '/protected');
-    expect(route).toBeDefined();
-    expect(route!.middlewareChain).toEqual([]);
-  });
-
-  it('middlewareChain is empty array when handler file does not exist on disk', () => {
-    // Use db from outer describe (handlerFile is 'pages/api/users.ts' which doesn't exist in repoPath)
-    const result = getMonographRouteMap(db2, {
-      includeMiddleware: true,
-      repoPath: join(tmpdir(), 'nonexistent-repo-xyz'),
-    });
-    for (const route of result.routes) {
-      expect(route.middlewareChain).toEqual([]);
-    }
-  });
-});

package/__tests__/mcp-tools/shape-check.test.ts

@@ -1,202 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdtempSync, writeFileSync, unlinkSync, existsSync, rmSync } from 'fs';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-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 { getShapeCheck } from '../../src/mcp-tools/shape-check.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-// ── Fixtures ──────────────────────────────────────────────────────────────────
-
-const dbPath = join(tmpdir(), `monograph-shape-check-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-let repoPath: string;
-
-const ROUTE_FILE = 'api/users.ts';
-const HANDLER_FILE = 'api/users.ts';
-const CONSUMER_FILE = 'client/fetchUsers.ts';
-
-const routeNode: MonographNode = {
-  id: 'route_users',
-  label: 'Route',
-  name: 'GET /api/users',
-  normLabel: 'get /api/users',
-  filePath: ROUTE_FILE,
-  startLine: 1,
-  isExported: false,
-};
-
-const handlerNode: MonographNode = {
-  id: 'fn_get_users',
-  label: 'Function',
-  name: 'getUsers',
-  normLabel: 'getusers',
-  filePath: HANDLER_FILE,
-  startLine: 5,
-  isExported: true,
-};
-
-const consumerNode: MonographNode = {
-  id: 'fn_fetch_users',
-  label: 'Function',
-  name: 'fetchUsers',
-  normLabel: 'fetchusers',
-  filePath: CONSUMER_FILE,
-  startLine: 3,
-  isExported: true,
-};
-
-const handlesRouteEdge: MonographEdge = {
-  id: 'e_handles_route',
-  sourceId: 'route_users',
-  targetId: 'fn_get_users',
-  relation: 'HANDLES_ROUTE',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-const callsEdge: MonographEdge = {
-  id: 'e_calls_handler',
-  sourceId: 'fn_fetch_users',
-  targetId: 'fn_get_users',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 0.9,
-};
-
-// ── Setup ─────────────────────────────────────────────────────────────────────
-
-beforeAll(() => {
-  db = openDb(dbPath);
-
-  // Create a temp repo directory with source files
-  repoPath = mkdtempSync(join(tmpdir(), 'shape-check-repo-'));
-
-  // Ensure api/ and client/ directories exist within the temp repo
-  const { mkdirSync } = require('fs');
-  mkdirSync(join(repoPath, 'api'), { recursive: true });
-  mkdirSync(join(repoPath, 'client'), { recursive: true });
-
-  // Handler returns { id, name, email }
-  writeFileSync(
-    join(repoPath, HANDLER_FILE),
-    `
-export function getUsers(req, res) {
-  const users = db.query('SELECT * FROM users');
-  return res.json({ id: users[0].id, name: users[0].name, email: users[0].email });
-}
-`,
-  );
-
-  // Consumer accesses { id, name }
-  writeFileSync(
-    join(repoPath, CONSUMER_FILE),
-    `
-export async function fetchUsers() {
-  const data = await fetch('/api/users').then(r => r.json());
-  console.log(data.id, data.name);
-}
-`,
-  );
-
-  // Insert graph nodes and edges
-  insertNode(db, routeNode);
-  insertNode(db, handlerNode);
-  insertNode(db, consumerNode);
-  insertEdge(db, handlesRouteEdge);
-  insertEdge(db, callsEdge);
-});
-
-afterAll(() => {
-  closeDb(db);
-  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm']) {
-    if (existsSync(p)) unlinkSync(p);
-  }
-  rmSync(repoPath, { recursive: true, force: true });
-});
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('getShapeCheck', () => {
-  it('finds the route and handler by route path substring', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/api/users' });
-    expect(result.route).not.toBeNull();
-    expect(result.route!.path).toBe('/api/users');
-    expect(result.route!.method).toBe('GET');
-    expect(result.route!.handlerName).toBe('getUsers');
-    expect(result.route!.handlerFile).toBe(HANDLER_FILE);
-  });
-
-  it('extracts returned keys from handler source', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/api/users' });
-    expect(result.shape.returnedKeys).toEqual(['email', 'id', 'name']);
-  });
-
-  it('extracts accessed keys from consumer source', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/api/users' });
-    // Consumer accesses data.id and data.name
-    expect(result.shape.accessedKeys).toEqual(expect.arrayContaining(['id', 'name']));
-  });
-
-  it('lists consumers', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/api/users' });
-    expect(result.consumers).toHaveLength(1);
-    expect(result.consumers[0].name).toBe('fetchUsers');
-    expect(result.consumers[0].filePath).toBe(CONSUMER_FILE);
-  });
-
-  it('returns MATCH when accessed keys are subset of returned keys', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/api/users' });
-    // handler returns id, name, email; consumer accesses id, name → MATCH
-    expect(result.shape.status).toBe('MATCH');
-    expect(result.shape.mismatches).toHaveLength(0);
-  });
-
-  it('returns null route when route not found', () => {
-    const result = getShapeCheck(db, repoPath, { route: '/nonexistent' });
-    expect(result.route).toBeNull();
-    expect(result.message).toBe('Route not found');
-    expect(result.shape.status).toBe('UNKNOWN');
-  });
-
-  it('handles missing source file gracefully (UNKNOWN status)', () => {
-    // Insert a route+handler that points to a non-existent file
-    const ghostRouteNode: MonographNode = {
-      id: 'route_ghost',
-      label: 'Route',
-      name: 'POST /api/ghost',
-      normLabel: 'post /api/ghost',
-      filePath: 'api/ghost.ts',
-      startLine: 1,
-      isExported: false,
-    };
-    const ghostHandlerNode: MonographNode = {
-      id: 'fn_ghost_handler',
-      label: 'Function',
-      name: 'ghostHandler',
-      normLabel: 'ghosthandler',
-      filePath: 'api/nonexistent-file-that-does-not-exist.ts',
-      startLine: 1,
-      isExported: true,
-    };
-    const ghostEdge: MonographEdge = {
-      id: 'e_ghost_handles',
-      sourceId: 'route_ghost',
-      targetId: 'fn_ghost_handler',
-      relation: 'HANDLES_ROUTE',
-      confidence: 'EXTRACTED',
-      confidenceScore: 1.0,
-    };
-
-    insertNode(db, ghostRouteNode);
-    insertNode(db, ghostHandlerNode);
-    insertEdge(db, ghostEdge);
-
-    const result = getShapeCheck(db, repoPath, { route: '/api/ghost' });
-    expect(result.route).not.toBeNull();
-    // File doesn't exist → no return keys extracted → UNKNOWN
-    expect(result.shape.status).toBe('UNKNOWN');
-  });
-});