@monoes/monograph 1.5.6 → 1.5.7

package/__tests__/pipeline/phases/processes.test.ts

@@ -1,191 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-
-// ── Helper: create a temp project dir and run buildAsync ─────────────────────
-
-async function buildProject(label: string, files: Record<string, string>): Promise<string> {
-  const base = join(tmpdir(), `monograph-processes-${label}-${Date.now()}`);
-  mkdirSync(join(base, 'src'), { recursive: true });
-  for (const [name, content] of Object.entries(files)) {
-    writeFileSync(join(base, 'src', name), content);
-  }
-  await buildAsync(base);
-  return base;
-}
-
-// ── Test: basic entry-point detection + BFS ────────────────────────────────
-
-describe('processes phase — basic entry-point + BFS', () => {
-  let base: string;
-  const dbPathFn = () => join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    base = await buildProject('basic', {
-      'index.ts': [
-        `export function main(): void {`,
-        `  helper();`,
-        `}`,
-        ``,
-        `function helper(): void {`,
-        `  // leaf function`,
-        `}`,
-        ``,
-        `main();`,
-      ].join('\n'),
-    });
-  }, 60_000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPathFn())).toBe(true);
-  });
-
-  it('creates at least one Process node', () => {
-    const db = openDb(dbPathFn());
-    try {
-      const row = db
-        .prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE label = 'Process'`)
-        .get() as { cnt: number };
-      expect(row.cnt).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('the main function process includes main as a step', () => {
-    const db = openDb(dbPathFn());
-    try {
-      // Find a Process named 'main'
-      const proc = db
-        .prepare(`SELECT id FROM nodes WHERE label = 'Process' AND name = 'main'`)
-        .get() as { id: string } | undefined;
-
-      expect(proc).toBeDefined();
-      if (!proc) return;
-
-      // Find the main function node
-      const mainFn = db
-        .prepare(`SELECT id FROM nodes WHERE name = 'main' AND label IN ('Function', 'Method')`)
-        .get() as { id: string } | undefined;
-
-      expect(mainFn).toBeDefined();
-      if (!mainFn) return;
-
-      // Check STEP_IN_PROCESS edge: process → main
-      const stepEdge = db
-        .prepare(
-          `SELECT id FROM edges WHERE source_id = ? AND target_id = ? AND relation = 'STEP_IN_PROCESS'`,
-        )
-        .get(proc.id, mainFn.id) as { id: string } | undefined;
-
-      expect(stepEdge).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates ENTRY_POINT_OF edge from entry symbol to process', () => {
-    const db = openDb(dbPathFn());
-    try {
-      const entryEdge = db
-        .prepare(`SELECT id FROM edges WHERE relation = 'ENTRY_POINT_OF'`)
-        .get() as { id: string } | undefined;
-      expect(entryEdge).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── Test: BFS does NOT infinite-loop on mutually recursive functions ─────────
-
-describe('processes phase — no infinite loop on mutual recursion', () => {
-  let base: string;
-  const dbPathFn = () => join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    base = await buildProject('recursive', {
-      'index.ts': [
-        `export function a(): void {`,
-        `  b();`,
-        `}`,
-        ``,
-        `export function b(): void {`,
-        `  a();`,
-        `}`,
-        ``,
-        `a();`,
-      ].join('\n'),
-    });
-  }, 60_000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('completes build without hanging on cyclic call graph', () => {
-    // If we got here, buildAsync terminated — BFS visited set prevents loops
-    expect(existsSync(dbPathFn())).toBe(true);
-  });
-
-  it('creates Process nodes (recursion does not prevent detection)', () => {
-    const db = openDb(dbPathFn());
-    try {
-      const row = db
-        .prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE label = 'Process'`)
-        .get() as { cnt: number };
-      expect(row.cnt).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── Test: processResult.stats.totalProcesses > 0 ──────────────────────────
-
-describe('processes phase — stats reporting', () => {
-  let base: string;
-  const dbPathFn = () => join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    base = await buildProject('stats', {
-      'app.ts': [
-        `export function run(): void {`,
-        `  compute();`,
-        `}`,
-        ``,
-        `function compute(): number {`,
-        `  return 42;`,
-        `}`,
-      ].join('\n'),
-    });
-  }, 60_000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('has at least one Process node in the DB (stats.totalProcesses > 0)', () => {
-    const db = openDb(dbPathFn());
-    try {
-      const row = db
-        .prepare(`SELECT COUNT(*) as cnt FROM nodes WHERE label = 'Process'`)
-        .get() as { cnt: number };
-      expect(row.cnt).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('has STEP_IN_PROCESS edges', () => {
-    const db = openDb(dbPathFn());
-    try {
-      const row = db
-        .prepare(`SELECT COUNT(*) as cnt FROM edges WHERE relation = 'STEP_IN_PROCESS'`)
-        .get() as { cnt: number };
-      expect(row.cnt).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-});

package/__tests__/pipeline/phases/routes.test.ts

@@ -1,195 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-import { pagesPathToRoute, appPathToRoute, extractExpressRoutes, extractNestRoutes, extractDefaultExportName } from '../../../src/pipeline/phases/routes.js';
-
-// ── Unit tests for pure helpers ───────────────────────────────────────────────
-
-describe('pagesPathToRoute', () => {
-  it('converts pages/index.ts to /', () => {
-    expect(pagesPathToRoute('pages/index.ts')).toBe('/');
-  });
-  it('converts pages/about.ts to /about', () => {
-    expect(pagesPathToRoute('pages/about.ts')).toBe('/about');
-  });
-  it('converts pages/api/users.ts to /api/users', () => {
-    expect(pagesPathToRoute('pages/api/users.ts')).toBe('/api/users');
-  });
-  it('converts dynamic segment [id] to :id', () => {
-    expect(pagesPathToRoute('pages/api/users/[id].ts')).toBe('/api/users/:id');
-  });
-  it('converts catch-all [...slug].ts to *', () => {
-    expect(pagesPathToRoute('pages/[...slug].ts')).toBe('/*');
-  });
-  it('converts optional catch-all [[...slug]].ts to *', () => {
-    expect(pagesPathToRoute('pages/[[...slug]].ts')).toBe('/*');
-  });
-});
-
-describe('appPathToRoute', () => {
-  it('converts app/route.ts to /', () => {
-    expect(appPathToRoute('app/route.ts')).toBe('/');
-  });
-  it('converts app/users/route.ts to /users', () => {
-    expect(appPathToRoute('app/users/route.ts')).toBe('/users');
-  });
-  it('converts app/users/[id]/route.ts to /users/:id', () => {
-    expect(appPathToRoute('app/users/[id]/route.ts')).toBe('/users/:id');
-  });
-});
-
-describe('extractDefaultExportName', () => {
-  it('finds export default function handler', () => {
-    expect(extractDefaultExportName('export default function handler(req, res) {}')).toBe('handler');
-  });
-  it('finds export default async function myFn', () => {
-    expect(extractDefaultExportName('export default async function myFn(req, res) {}')).toBe('myFn');
-  });
-  it('returns undefined when no default export', () => {
-    expect(extractDefaultExportName('export function helper() {}')).toBeUndefined();
-  });
-});
-
-describe('extractExpressRoutes', () => {
-  it('finds app.get() routes', () => {
-    const src = `app.get('/users', getUsers);\napp.post('/users', createUser);`;
-    const routes = extractExpressRoutes(src, 'src/routes.ts', '.ts');
-    expect(routes).toHaveLength(2);
-    expect(routes[0]).toMatchObject({ method: 'GET', path: '/users', handlerName: 'getUsers' });
-    expect(routes[1]).toMatchObject({ method: 'POST', path: '/users', handlerName: 'createUser' });
-  });
-  it('finds router.delete() routes', () => {
-    const src = `router.delete('/items/:id', removeItem);`;
-    const routes = extractExpressRoutes(src, 'src/routes.ts', '.ts');
-    expect(routes).toHaveLength(1);
-    expect(routes[0]).toMatchObject({ method: 'DELETE', path: '/items/:id', handlerName: 'removeItem' });
-  });
-  it('returns empty array for files with no express routes', () => {
-    const routes = extractExpressRoutes('const x = 1;', 'src/util.ts', '.ts');
-    expect(routes).toHaveLength(0);
-  });
-});
-
-describe('extractNestRoutes', () => {
-  it('finds NestJS controller + method decorators', () => {
-    const src = `
-@Controller('users')
-export class UsersController {
-  @Get('/')
-  findAll() {}
-
-  @Post('/')
-  create() {}
-}
-`;
-    const routes = extractNestRoutes(src, 'src/users.controller.ts', '.ts');
-    expect(routes.length).toBeGreaterThanOrEqual(2);
-    const methods = routes.map(r => r.method);
-    expect(methods).toContain('GET');
-    expect(methods).toContain('POST');
-  });
-});
-
-// ── Integration tests via buildAsync ─────────────────────────────────────────
-
-describe('routes phase — Next.js pages', () => {
-  const base = join(tmpdir(), `monograph-routes-pages-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'pages', 'api', 'users'), { recursive: true });
-
-    // Next.js page: default export handler
-    writeFileSync(
-      join(base, 'pages', 'api', 'users.ts'),
-      `export default function handler(req: any, res: any) { res.json([]); }\n`,
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates a Route node for the Next.js page file', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Route'`)
-        .all() as { name: string; file_path: string }[];
-      const route = rows.find(r => r.name.includes('/api/users'));
-      expect(route).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('Route node name contains the correct path', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Route' AND name LIKE '%/api/users%'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toContain('/api/users');
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-describe('routes phase — no route files', () => {
-  it('does not crash when no route files exist', async () => {
-    const noRouteDir = join(tmpdir(), `monograph-noroute-${Date.now()}`);
-    mkdirSync(join(noRouteDir, 'src'), { recursive: true });
-    writeFileSync(join(noRouteDir, 'src', 'index.ts'), 'export const x = 1;\n');
-    try {
-      await expect(buildAsync(noRouteDir)).resolves.not.toThrow();
-    } finally {
-      rmSync(noRouteDir, { recursive: true, force: true });
-    }
-  }, 60000);
-});
-
-describe('routes phase — Express-style routes', () => {
-  const base = join(tmpdir(), `monograph-routes-express-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'server.ts'),
-      [
-        `import express from 'express';`,
-        `const app = express();`,
-        `function getUsers(req: any, res: any) { res.json([]); }`,
-        `app.get('/api/items', getUsers);`,
-        `app.post('/api/items', getUsers);`,
-        `app.listen(3000);`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates Route nodes for Express routes', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Route'`)
-        .all() as { name: string }[];
-      const getRoute = rows.find(r => r.name.includes('GET') && r.name.includes('/api/items'));
-      expect(getRoute).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});

package/__tests__/pipeline/phases/scope-resolution.test.ts

@@ -1,133 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-
-// ── Integration tests via buildAsync ─────────────────────────────────────────
-
-describe('scope-resolution phase — method call resolution', () => {
-  const base = join(tmpdir(), `monograph-scope-resolution-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'service.ts'),
-      [
-        `export class UserService {`,
-        `  findById(id: string) {`,
-        `    return id;`,
-        `  }`,
-        `}`,
-      ].join('\n') + '\n',
-    );
-
-    writeFileSync(
-      join(base, 'src', 'controller.ts'),
-      [
-        `import { UserService } from './service';`,
-        `const svc = new UserService();`,
-        `svc.findById('1');`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates a CALLS edge pointing to UserService.findById with confidence_score >= 0.7', () => {
-    const db = openDb(dbPath);
-    try {
-      // Find the findById method node
-      const methodNode = db
-        .prepare(`SELECT id FROM nodes WHERE name = 'findById' AND label IN ('Function', 'Method')`)
-        .get() as { id: string } | undefined;
-
-      expect(methodNode).toBeDefined();
-
-      if (methodNode) {
-        // Find any CALLS edge targeting findById
-        const callsEdge = db
-          .prepare(`
-            SELECT * FROM edges
-            WHERE target_id = ? AND relation = 'CALLS'
-          `)
-          .get(methodNode.id) as { confidence_score: number } | undefined;
-
-        expect(callsEdge).toBeDefined();
-        expect(callsEdge!.confidence_score).toBeGreaterThanOrEqual(0.7);
-      }
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-describe('scope-resolution phase — no crash on empty file', () => {
-  it('does not crash when files have no call expressions', async () => {
-    const base = join(tmpdir(), `monograph-scope-empty-${Date.now()}`);
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'constants.ts'),
-      `export const VERSION = '1.0.0';\nexport const MAX_RETRIES = 3;\n`,
-    );
-
-    try {
-      await expect(buildAsync(base)).resolves.not.toThrow();
-    } finally {
-      rmSync(base, { recursive: true, force: true });
-    }
-  }, 60000);
-});
-
-describe('scope-resolution phase — dynamic calls produce no edges', () => {
-  const base = join(tmpdir(), `monograph-scope-dynamic-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'dynamic.ts'),
-      [
-        `const handlers: Record<string, () => void> = {};`,
-        `const key = 'myHandler';`,
-        `// Dynamic call: obj[key](`,
-        `const fn = handlers[key];`,
-        `if (fn) fn();`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('does not create CALLS edges for dynamic patterns', () => {
-    const db = openDb(dbPath);
-    try {
-      // There should be no CALLS edges in a file with only dynamic-style calls
-      // (the fn() direct call won't resolve since 'fn' is not a Function/Method node)
-      const callsEdges = db
-        .prepare(`SELECT COUNT(*) as cnt FROM edges WHERE relation = 'CALLS'`)
-        .get() as { cnt: number };
-
-      // No function/method named 'fn' or 'handlers' in DB, so no CALLS edge resolves
-      expect(callsEdges.cnt).toBe(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-});

package/__tests__/pipeline/phases/tools.test.ts

@@ -1,161 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-
-// ── Integration tests via buildAsync ─────────────────────────────────────────
-
-describe('tools phase — server.tool() pattern', () => {
-  const base = join(tmpdir(), `monograph-tools-server-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'mcp-server.ts'),
-      [
-        `import { Server } from '@modelcontextprotocol/sdk/server/index.js';`,
-        `const server = new Server({ name: 'example', version: '1.0.0' });`,
-        ``,
-        `async function greetHandler(args: { name: string }) {`,
-        `  return { greeting: \`Hello, \${args.name}!\` };`,
-        `}`,
-        ``,
-        `server.tool('greet', { name: { type: 'string' } }, greetHandler);`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates a Tool node with name "greet"', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Tool' AND name = 'greet'`)
-        .get() as { name: string; file_path: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('greet');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('Tool node has the correct filePath', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Tool' AND name = 'greet'`)
-        .get() as { file_path: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.file_path).toContain('mcp-server.ts');
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-describe('tools phase — no tool definitions', () => {
-  it('does not crash when no tool definitions exist', async () => {
-    const noToolDir = join(tmpdir(), `monograph-notool-${Date.now()}`);
-    mkdirSync(join(noToolDir, 'src'), { recursive: true });
-    writeFileSync(join(noToolDir, 'src', 'index.ts'), 'export const x = 1;\n');
-    try {
-      await expect(buildAsync(noToolDir)).resolves.not.toThrow();
-    } finally {
-      rmSync(noToolDir, { recursive: true, force: true });
-    }
-  }, 60000);
-});
-
-describe('tools phase — TOOLS array pattern', () => {
-  const base = join(tmpdir(), `monograph-tools-array-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'tools.ts'),
-      [
-        `export const TOOLS = [`,
-        `  {`,
-        `    name: 'search',`,
-        `    description: 'Searches the knowledge base for relevant content',`,
-        `    inputSchema: { query: { type: 'string' } },`,
-        `  },`,
-        `  {`,
-        `    name: 'summarize',`,
-        `    description: 'Summarizes the given text',`,
-        `    inputSchema: { text: { type: 'string' } },`,
-        `  },`,
-        `];`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates Tool nodes from TOOLS array', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Tool'`)
-        .all() as { name: string }[];
-      const names = rows.map(r => r.name);
-      expect(names).toContain('search');
-      expect(names).toContain('summarize');
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-describe('tools phase — exported constant tool pattern', () => {
-  const base = join(tmpdir(), `monograph-tools-const-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'my-tool.ts'),
-      [
-        `export const MY_TOOL = {`,
-        `  name: 'my-tool',`,
-        `  description: 'A useful tool',`,
-        `};`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates a Tool node from exported constant pattern', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Tool' AND name = 'my-tool'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});