@monoes/monograph 1.1.0 → 1.2.0

package/src/__tests__/mcp-tools/query.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { monographQueryTool } from '../../mcp-tools/query.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
+      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0,
+      properties TEXT);
+  `);
+  db.prepare(`INSERT INTO nodes VALUES ('n1','Process','PaymentFlow',null,'/pay.ts',1,20,1,1,null,null)`).run();
+  db.prepare(`INSERT INTO nodes VALUES ('n2','Function','processPayment',null,'/pay.ts',5,15,1,1,null,null)`).run();
+  return db;
+}
+
+describe('monographQueryTool', () => {
+  it('has correct name', () => {
+    expect(monographQueryTool.name).toBe('monograph_query');
+  });
+
+  it('has query parameter in schema', () => {
+    expect(monographQueryTool.inputSchema.properties).toHaveProperty('query');
+  });
+
+  it('has repoPath parameter in schema', () => {
+    expect(monographQueryTool.inputSchema.properties).toHaveProperty('repoPath');
+  });
+
+  it('has includeProcesses parameter', () => {
+    expect(monographQueryTool.inputSchema.properties).toHaveProperty('includeProcesses');
+  });
+
+  it('returns results array when neither repoPath nor db provided', async () => {
+    const result = await monographQueryTool.handler({ query: 'payment' } as any);
+    expect(result).toHaveProperty('results');
+    expect(Array.isArray(result.results)).toBe(true);
+  });
+});

package/src/__tests__/parsers/language-parsers.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { extractSymbolsForLanguage } from '../../parsers/language-parsers.js';
+
+describe('Scala extraction', () => {
+  it('extracts object and class definitions', () => {
+    const src = `object PaymentService { def process(order: Order): Unit = {} }\nclass OrderRepo extends BaseRepo {}`;
+    const r = extractSymbolsForLanguage(src, '/pay.scala', 'scala');
+    const names = r.map(s => s.name);
+    expect(names).toContain('PaymentService');
+    expect(names).toContain('OrderRepo');
+  });
+});
+
+describe('Lua extraction', () => {
+  it('extracts function definitions', () => {
+    const src = `function greet(name)\n  return "Hello " .. name\nend\nlocal function helper() end`;
+    const r = extractSymbolsForLanguage(src, '/util.lua', 'lua');
+    const names = r.map(s => s.name);
+    expect(names).toContain('greet');
+    expect(names).toContain('helper');
+  });
+});
+
+describe('Zig extraction', () => {
+  it('extracts pub fn declarations', () => {
+    const src = `pub fn allocate(size: usize) anyerror![]u8 {}\nfn helper() void {}`;
+    const r = extractSymbolsForLanguage(src, '/alloc.zig', 'zig');
+    const names = r.map(s => s.name);
+    expect(names).toContain('allocate');
+    expect(names).toContain('helper');
+  });
+});
+
+describe('PowerShell extraction', () => {
+  it('extracts function declarations', () => {
+    const src = `function Get-User { param($id) }\nfunction Set-Config { param($cfg) }`;
+    const r = extractSymbolsForLanguage(src, '/util.ps1', 'powershell');
+    const names = r.map(s => s.name);
+    expect(names).toContain('Get-User');
+    expect(names).toContain('Set-Config');
+  });
+});
+
+describe('Elixir extraction', () => {
+  it('extracts defmodule and def', () => {
+    const src = `defmodule PayApp.Payments do\n  def process(order) do\n    :ok\n  end\nend`;
+    const r = extractSymbolsForLanguage(src, '/payments.ex', 'elixir');
+    const names = r.map(s => s.name);
+    expect(names).toContain('PayApp.Payments');
+    expect(names).toContain('process');
+  });
+});

package/src/__tests__/parsers/named-bindings.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { extractNamedBindings } from '../../parsers/named-bindings.js';
+
+describe('extractNamedBindings', () => {
+  it('extracts TypeScript class decorators', () => {
+    const source = `
+@Controller('/api')
+export class UserController {
+  @Get('/users')
+  list() {}
+
+  @Post('/users')
+  create() {}
+}`;
+    const bindings = extractNamedBindings(source, '/app/user.controller.ts', 'typescript');
+    const names = bindings.map(b => b.decoratorName);
+    expect(names).toContain('Controller');
+    expect(names).toContain('Get');
+    expect(names).toContain('Post');
+  });
+
+  it('extracts Python function decorators', () => {
+    const source = `
+@app.route('/users', methods=['GET'])
+def list_users():
+    pass
+
+@login_required
+def profile():
+    pass`;
+    const bindings = extractNamedBindings(source, '/app/views.py', 'python');
+    const names = bindings.map(b => b.decoratorName);
+    expect(names).toContain('app.route');
+    expect(names).toContain('login_required');
+  });
+
+  it('extracts Java annotations', () => {
+    const source = `
+@RestController
+@RequestMapping("/api")
+public class UserApi {
+  @GetMapping("/users")
+  public List<User> list() { return null; }
+}`;
+    const bindings = extractNamedBindings(source, '/src/UserApi.java', 'java');
+    const names = bindings.map(b => b.decoratorName);
+    expect(names).toContain('RestController');
+    expect(names).toContain('RequestMapping');
+    expect(names).toContain('GetMapping');
+  });
+
+  it('returns empty for source with no decorators', () => {
+    const source = 'function plain() { return 1; }';
+    const bindings = extractNamedBindings(source, '/app/plain.ts', 'typescript');
+    expect(bindings).toEqual([]);
+  });
+
+  it('includes line number in result', () => {
+    const source = '\n\n@Injectable()\nexport class Service {}';
+    const bindings = extractNamedBindings(source, '/app/svc.ts', 'typescript');
+    const inj = bindings.find(b => b.decoratorName === 'Injectable');
+    expect(inj).toBeDefined();
+    expect(inj!.line).toBe(3);
+  });
+
+  it('extracts decorator arguments', () => {
+    const source = `@Module({ imports: [AuthModule] })\nexport class AppModule {}`;
+    const bindings = extractNamedBindings(source, '/app.module.ts', 'typescript');
+    const mod = bindings.find(b => b.decoratorName === 'Module');
+    expect(mod).toBeDefined();
+    expect(mod!.hasArguments).toBe(true);
+  });
+});

package/src/__tests__/pipeline/cluster-only.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { runClusterOnly } from '../../pipeline/cluster-only.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, name TEXT, label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER, norm_label TEXT, is_exported INTEGER, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
+    INSERT INTO nodes VALUES ('n1', 'A', 'Class', '/a.ts', 1, 10, null, 'a', 1, 'typescript', null);
+    INSERT INTO nodes VALUES ('n2', 'B', 'Class', '/b.ts', 1, 10, null, 'b', 1, 'typescript', null);
+    INSERT INTO nodes VALUES ('n3', 'C', 'Function', '/c.ts', 1, 5, null, 'c', 1, 'typescript', null);
+    INSERT INTO edges VALUES ('e1', 'n1', 'n2', 'CALLS', 'EXTRACTED', 1.0);
+    INSERT INTO edges VALUES ('e2', 'n2', 'n3', 'CALLS', 'EXTRACTED', 1.0);
+  `);
+  return db;
+}
+
+describe('runClusterOnly', () => {
+  it('assigns community_id to nodes based on graph structure', async () => {
+    const db = makeDb();
+    await runClusterOnly(db);
+    const updated = db.prepare('SELECT community_id FROM nodes').all() as { community_id: number | null }[];
+    // At least some nodes should have community_id set
+    expect(updated.some(n => n.community_id !== null)).toBe(true);
+  });
+
+  it('returns community count', async () => {
+    const db = makeDb();
+    const result = await runClusterOnly(db);
+    expect(result.communityCount).toBeGreaterThanOrEqual(1);
+  });
+});

package/src/__tests__/pipeline/incremental.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import Database from 'better-sqlite3';
+import { runIncrementalAst } from '../../pipeline/runner.js';
+
+function makeDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, name TEXT NOT NULL,
+      norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER,
+      community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
+    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT NOT NULL, target_id TEXT NOT NULL,
+      relation TEXT NOT NULL, confidence TEXT DEFAULT 'EXTRACTED', confidence_score REAL DEFAULT 1.0,
+      properties TEXT);
+  `);
+  db.prepare(`INSERT INTO nodes VALUES ('existing','Function','old',null,'/x.ts',1,3,null,1,null,null)`).run();
+  db.prepare(`INSERT INTO edges VALUES ('inf1','existing','existing','CALLS','INFERRED',0.5,null)`).run();
+  return db;
+}
+
+describe('runIncrementalAst', () => {
+  it('is exported from runner', () => {
+    expect(typeof runIncrementalAst).toBe('function');
+  });
+
+  it('preserves INFERRED edges when running code-only update', async () => {
+    const db = makeDb();
+    const beforeEdges = db.prepare(`SELECT id FROM edges WHERE confidence = 'INFERRED'`).all();
+    expect(beforeEdges).toHaveLength(1);
+    await runIncrementalAst(db as any, [], { preserveInferred: true });
+    const afterEdges = db.prepare(`SELECT id FROM edges WHERE confidence = 'INFERRED'`).all();
+    expect(afterEdges).toHaveLength(1);
+  });
+
+  it('removes EXTRACTED edges when running code-only update', async () => {
+    const db = makeDb();
+    db.prepare(`INSERT INTO edges VALUES ('ext1','existing','existing','CALLS','EXTRACTED',0.9,null)`).run();
+    await runIncrementalAst(db as any, [], { preserveInferred: true });
+    const afterExtracted = db.prepare(`SELECT id FROM edges WHERE confidence = 'EXTRACTED'`).all();
+    expect(afterExtracted).toHaveLength(0);
+  });
+});

package/src/__tests__/pipeline/phases/communities.cohesion.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { computeCohesion } from '../../../pipeline/phases/communities.js';
+
+describe('computeCohesion', () => {
+  it('returns 1.0 for fully connected community', () => {
+    // 3 nodes, 3 edges (fully connected: 3 possible edges)
+    const memberships = new Map([['a', 0], ['b', 0], ['c', 0]]);
+    const edges = [
+      { sourceId: 'a', targetId: 'b' },
+      { sourceId: 'b', targetId: 'c' },
+      { sourceId: 'a', targetId: 'c' },
+    ];
+    const score = computeCohesion(0, memberships, edges);
+    expect(score).toBeCloseTo(1.0);
+  });
+
+  it('returns 0 for community with no internal edges', () => {
+    const memberships = new Map([['a', 0], ['b', 0], ['c', 1], ['d', 1]]);
+    const edges = [
+      { sourceId: 'a', targetId: 'c' }, // cross-community
+    ];
+    const score = computeCohesion(0, memberships, edges);
+    expect(score).toBe(0);
+  });
+
+  it('returns value between 0 and 1 for partial connectivity', () => {
+    const memberships = new Map([['a', 0], ['b', 0], ['c', 0], ['d', 0]]);
+    const edges = [
+      { sourceId: 'a', targetId: 'b' },
+      { sourceId: 'c', targetId: 'd' },
+      // 2 out of 12 possible edges (directed: 4*(4-1)=12)
+    ];
+    const score = computeCohesion(0, memberships, edges);
+    expect(score).toBeGreaterThan(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  it('returns 1 for single-node community', () => {
+    const memberships = new Map([['a', 0]]);
+    const score = computeCohesion(0, memberships, []);
+    expect(score).toBe(1);
+  });
+});

package/src/__tests__/pipeline/phases/community-split.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { splitOversizedCommunity } from '../../../pipeline/phases/communities.js';
+
+describe('splitOversizedCommunity', () => {
+  it('splits a community with 30 members into smaller groups', () => {
+    const members = Array.from({ length: 30 }, (_, i) => `node${i}`);
+    const result = splitOversizedCommunity(members, 10);
+    expect(result.length).toBeGreaterThan(1);
+    expect(result.every(g => g.length <= 10)).toBe(true);
+  });
+
+  it('does not split a small community', () => {
+    const members = ['a', 'b', 'c'];
+    const result = splitOversizedCommunity(members, 10);
+    expect(result).toHaveLength(1);
+  });
+
+  it('preserves all member IDs', () => {
+    const members = Array.from({ length: 25 }, (_, i) => `n${i}`);
+    const result = splitOversizedCommunity(members, 10);
+    const allNodes = result.flat();
+    expect(allNodes.sort()).toEqual([...members].sort());
+  });
+
+  it('respects maxGroupSize', () => {
+    const members = Array.from({ length: 50 }, (_, i) => `n${i}`);
+    const result = splitOversizedCommunity(members, 15);
+    expect(result.every(g => g.length <= 15)).toBe(true);
+  });
+});

package/src/__tests__/pipeline/phases/framework-detect.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { detectFrameworks } from '../../../pipeline/phases/framework-detect.js';
+
+describe('detectFrameworks', () => {
+  let tmpDir: string;
+
+  beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), 'fw-detect-')); });
+  afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
+
+  it('detects React from package.json dependencies', () => {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({
+      dependencies: { react: '^18.0.0', 'react-dom': '^18.0.0' },
+    }));
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('react');
+    expect(result.primaryLanguage).toBe('javascript');
+  });
+
+  it('detects Express from package.json', () => {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({
+      dependencies: { express: '^4.18.0' },
+    }));
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('express');
+  });
+
+  it('detects Django from requirements.txt', () => {
+    writeFileSync(join(tmpDir, 'requirements.txt'), 'Django==4.2\npsycopg2-binary\n');
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('django');
+    expect(result.primaryLanguage).toBe('python');
+  });
+
+  it('detects Spring from pom.xml', () => {
+    writeFileSync(join(tmpDir, 'pom.xml'),
+      '<project><dependencies><dependency><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies></project>');
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('spring');
+    expect(result.primaryLanguage).toBe('java');
+  });
+
+  it('detects Vue from package.json', () => {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({ dependencies: { vue: '^3.0.0' } }));
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('vue');
+  });
+
+  it('returns empty arrays when no framework files exist', () => {
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toEqual([]);
+    expect(result.primaryLanguage).toBeNull();
+  });
+
+  it('detects multiple frameworks', () => {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({
+      dependencies: { react: '^18', express: '^4' },
+    }));
+    const result = detectFrameworks(tmpDir);
+    expect(result.frameworks).toContain('react');
+    expect(result.frameworks).toContain('express');
+  });
+});

package/src/__tests__/pipeline/phases/import-resolver.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { detectWorkspacePackages, resolveWorkspaceImport, type WorkspacePackage } from '../../../pipeline/phases/import-resolver.js';
+
+describe('detectWorkspacePackages', () => {
+  let tmpDir: string;
+
+  beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), 'monorepo-test-')); });
+  afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
+
+  it('detects npm workspace packages', () => {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({
+      workspaces: ['packages/*'],
+    }));
+    mkdirSync(join(tmpDir, 'packages', 'core'), { recursive: true });
+    mkdirSync(join(tmpDir, 'packages', 'utils'), { recursive: true });
+    writeFileSync(join(tmpDir, 'packages', 'core', 'package.json'), JSON.stringify({ name: '@myapp/core' }));
+    writeFileSync(join(tmpDir, 'packages', 'utils', 'package.json'), JSON.stringify({ name: '@myapp/utils' }));
+
+    const packages = detectWorkspacePackages(tmpDir);
+    const names = packages.map(p => p.name);
+    expect(names).toContain('@myapp/core');
+    expect(names).toContain('@myapp/utils');
+  });
+
+  it('returns empty array when no workspace config', () => {
+    const packages = detectWorkspacePackages(tmpDir);
+    expect(packages).toEqual([]);
+  });
+});
+
+describe('resolveWorkspaceImport', () => {
+  it('resolves a workspace package name to its local path', () => {
+    const packages: WorkspacePackage[] = [
+      { name: '@myapp/core', path: '/repo/packages/core' },
+      { name: '@myapp/utils', path: '/repo/packages/utils' },
+    ];
+    const result = resolveWorkspaceImport('@myapp/core', packages);
+    expect(result).toBe('/repo/packages/core');
+  });
+
+  it('returns null for a non-workspace import', () => {
+    const packages: WorkspacePackage[] = [
+      { name: '@myapp/core', path: '/repo/packages/core' },
+    ];
+    const result = resolveWorkspaceImport('lodash', packages);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for empty packages list', () => {
+    const result = resolveWorkspaceImport('@myapp/core', []);
+    expect(result).toBeNull();
+  });
+
+  it('handles scoped packages with subpath (@scope/pkg/subpath)', () => {
+    const packages: WorkspacePackage[] = [
+      { name: '@myapp/core', path: '/repo/packages/core' },
+    ];
+    const result = resolveWorkspaceImport('@myapp/core/utils', packages);
+    expect(result).toBe('/repo/packages/core');
+  });
+});

package/src/__tests__/pipeline/phases/parse-arrow.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { extractArrowFunctions } from '../../../pipeline/phases/parse.js';
+
+const ARROW_SOURCE = `
+export const handleRequest = async (req, res) => {
+  res.send('ok');
+};
+
+const helper = (x) => x * 2;
+export const transform = (items) => items.map(helper);
+`;
+
+describe('parse phase arrow functions', () => {
+  it('extracts named arrow functions as Function nodes', () => {
+    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
+    const names = nodes.map(n => n.name);
+    expect(names).toContain('handleRequest');
+    expect(names).toContain('helper');
+    expect(names).toContain('transform');
+  });
+
+  it('marks exported arrow functions as exported', () => {
+    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
+    const handleRequest = nodes.find(n => n.name === 'handleRequest');
+    expect(handleRequest?.isExported).toBe(true);
+  });
+
+  it('marks non-exported arrow functions as not exported', () => {
+    const nodes = extractArrowFunctions(ARROW_SOURCE, '/tmp/handler.ts');
+    const helper = nodes.find(n => n.name === 'helper');
+    expect(helper?.isExported).toBe(false);
+  });
+});

package/src/__tests__/pipeline/phases/parse-csharp.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { extractCsharpNamespaces } from '../../../pipeline/phases/parse.js';
+
+const CSHARP_SOURCE = `
+namespace MyApp.Services {
+  public class PaymentService {
+    public void Process() {}
+  }
+}
+
+namespace MyApp.Models {
+  public class Order {}
+}
+`;
+
+describe('C# namespace extraction', () => {
+  it('extracts namespace declarations', () => {
+    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
+    const names = result.map(n => n.name);
+    expect(names).toContain('MyApp.Services');
+    expect(names).toContain('MyApp.Models');
+  });
+
+  it('returns Namespace label', () => {
+    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
+    expect(result.every(n => n.label === 'Namespace')).toBe(true);
+  });
+
+  it('returns correct file path', () => {
+    const result = extractCsharpNamespaces(CSHARP_SOURCE, '/PaymentService.cs');
+    expect(result.every(n => n.filePath === '/PaymentService.cs')).toBe(true);
+  });
+});

package/src/__tests__/pipeline/phases/scan.monographignore.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { scanPhase } from '../../../pipeline/phases/scan.js';
+
+function makeCtx(repoPath: string, ignore: string[] = []): any {
+  return { repoPath, options: { ignore, codeOnly: false }, onProgress: undefined };
+}
+
+describe('scanPhase .monographignore', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'scan-ignore-test-'));
+    writeFileSync(join(tmpDir, 'app.ts'), 'export const x = 1;');
+    mkdirSync(join(tmpDir, 'generated'));
+    writeFileSync(join(tmpDir, 'generated', 'schema.ts'), 'export type T = string;');
+    writeFileSync(join(tmpDir, 'generated', 'types.ts'), 'export type U = number;');
+    mkdirSync(join(tmpDir, 'dist'));
+    writeFileSync(join(tmpDir, 'dist', 'index.js'), 'module.exports = {};');
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('respects .monographignore glob patterns for directories', async () => {
+    writeFileSync(join(tmpDir, '.monographignore'), 'generated/\n');
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
+    expect(names.some((n: string) => n.includes('generated'))).toBe(false);
+    expect(names.some((n: string) => n.includes('app.ts'))).toBe(true);
+  });
+
+  it('works fine when .monographignore does not exist', async () => {
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    expect(out.filePaths.length).toBeGreaterThan(0);
+  });
+
+  it('handles empty .monographignore', async () => {
+    writeFileSync(join(tmpDir, '.monographignore'), '');
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    expect(out.filePaths.some((p: string) => p.includes('generated'))).toBe(true);
+  });
+
+  it('ignores comment lines in .monographignore', async () => {
+    writeFileSync(join(tmpDir, '.monographignore'), '# This is a comment\ngenerated/\n');
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
+    expect(names.some((n: string) => n.includes('generated'))).toBe(false);
+  });
+});

package/src/__tests__/pipeline/phases/scan.negation.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { scanPhase } from '../../../pipeline/phases/scan.js';
+
+function makeCtx(repoPath: string): any {
+  return { repoPath, options: { ignore: [], codeOnly: false }, onProgress: undefined };
+}
+
+describe('scanPhase .monographignore negation', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'scan-neg-test-'));
+    mkdirSync(join(tmpDir, 'generated'));
+    writeFileSync(join(tmpDir, 'generated', 'schema.ts'), 'export type T = string;');
+    writeFileSync(join(tmpDir, 'generated', 'keep-this.ts'), 'export type K = number;');
+    writeFileSync(join(tmpDir, 'app.ts'), 'export const x = 1;');
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('negation pattern !file preserves file even when parent dir is ignored', async () => {
+    // Ignore all generated/ but keep keep-this.ts via negation
+    writeFileSync(join(tmpDir, '.monographignore'), 'generated/\n!generated/keep-this.ts\n');
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    const names = out.filePaths.map((p: string) => p.replace(tmpDir, ''));
+    expect(names.some((n: string) => n.includes('keep-this.ts'))).toBe(true);
+    expect(names.some((n: string) => n.includes('schema.ts'))).toBe(false);
+  });
+
+  it('negation without prior ignore is a no-op (file already included)', async () => {
+    writeFileSync(join(tmpDir, '.monographignore'), '!app.ts\n');
+    const out = await scanPhase.execute(makeCtx(tmpDir), new Map());
+    expect(out.filePaths.some((p: string) => p.includes('app.ts'))).toBe(true);
+  });
+});

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

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { extractGoCallSites } from '../../../pipeline/phases/scope-resolution.js';
+
+describe('extractGoCallSites', () => {
+  it('extracts method calls (receiver.Method)', () => {
+    const source = `
+func run(s *Server) {
+  s.Listen(":8080")
+  db.Query("SELECT 1")
+}`;
+    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
+    expect(sites.some(s => s.calleeRaw === 's.Listen')).toBe(true);
+    expect(sites.some(s => s.calleeRaw === 'db.Query')).toBe(true);
+  });
+
+  it('extracts direct function calls', () => {
+    const source = `
+func init() {
+  setupRoutes()
+  fmt.Println("started")
+}`;
+    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
+    expect(sites.some(s => s.calleeRaw === 'setupRoutes')).toBe(true);
+  });
+
+  it('skips Go keywords', () => {
+    const source = `for i := range items { if ok { return } }`;
+    const sites = extractGoCallSites(source, '/app/main.go', 'fn1');
+    const names = sites.map(s => s.calleeRaw);
+    expect(names).not.toContain('for');
+    expect(names).not.toContain('if');
+    expect(names).not.toContain('return');
+  });
+});