@monoes/monograph 1.5.6 → 1.5.8

package/src/__tests__/graph/topo-sort.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { topologicalLevelSort } from '../../graph/topo-sort.js';
-import { openDb } from '../../storage/db.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-topo-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'File', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'IMPORTS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('topologicalLevelSort', () => {
-  it('returns empty levels and 0 cycleCount for empty graph', () => {
-    const db = makeTempDb();
-    const result = topologicalLevelSort(db);
-    expect(result.levels).toEqual([]);
-    expect(result.cycleCount).toBe(0);
-    db.close();
-  });
-
-  it('returns single level for single node with no edges', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    const result = topologicalLevelSort(db);
-    expect(result.levels.length).toBe(1);
-    expect(result.levels[0]).toContain('a');
-    expect(result.cycleCount).toBe(0);
-    db.close();
-  });
-
-  it('orders a linear chain leaf-first: a->b->c => [c, b, a]', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = topologicalLevelSort(db);
-    // c has no outgoing IMPORTS => level 0, then b, then a
-    expect(result.cycleCount).toBe(0);
-    expect(result.levels.length).toBeGreaterThanOrEqual(2);
-    const allNodes = result.levels.flat();
-    expect(allNodes).toContain('a');
-    expect(allNodes).toContain('b');
-    expect(allNodes).toContain('c');
-    // leaf (c) must appear before root (a)
-    const levelC = result.levels.findIndex(l => l.includes('c'));
-    const levelA = result.levels.findIndex(l => l.includes('a'));
-    expect(levelC).toBeLessThan(levelA);
-    db.close();
-  });
-
-  it('puts independent nodes in level 0', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    // no edges
-    const result = topologicalLevelSort(db);
-    expect(result.levels.length).toBe(1);
-    expect(result.levels[0]).toContain('x');
-    expect(result.levels[0]).toContain('y');
-    expect(result.cycleCount).toBe(0);
-    db.close();
-  });
-
-  it('detects a cycle and appends cycle nodes at end', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    const result = topologicalLevelSort(db);
-    expect(result.cycleCount).toBeGreaterThan(0);
-    // cycle nodes must still appear somewhere in levels
-    const allNodes = result.levels.flat();
-    expect(allNodes).toContain('a');
-    expect(allNodes).toContain('b');
-    db.close();
-  });
-
-  it('handles diamond dependency: a->b, a->c, b->d, c->d', () => {
-    const db = makeTempDb();
-    ['a', 'b', 'c', 'd'].forEach(n => insertNode(db, n));
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'a', 'c');
-    insertEdge(db, 'b', 'd');
-    insertEdge(db, 'c', 'd');
-    const result = topologicalLevelSort(db);
-    expect(result.cycleCount).toBe(0);
-    const allNodes = result.levels.flat();
-    expect(allNodes.sort()).toEqual(['a', 'b', 'c', 'd'].sort());
-    // d must appear in earlier level than a
-    const levelD = result.levels.findIndex(l => l.includes('d'));
-    const levelA = result.levels.findIndex(l => l.includes('a'));
-    expect(levelD).toBeLessThan(levelA);
-    db.close();
-  });
-});

package/src/__tests__/graph/wcc.test.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { weaklyConnectedComponents } from '../../graph/wcc.js';
-import { openDb } from '../../storage/db.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-wcc-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('weaklyConnectedComponents', () => {
-  it('returns empty array for empty graph', () => {
-    const db = makeTempDb();
-    expect(weaklyConnectedComponents(db)).toEqual([]);
-    db.close();
-  });
-
-  it('returns single component for single node', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(1);
-    expect(result[0]).toContain('a');
-    db.close();
-  });
-
-  it('returns single component for connected chain a->b->c', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(1);
-    expect(result[0].sort()).toEqual(['a', 'b', 'c'].sort());
-    db.close();
-  });
-
-  it('returns two components for two disconnected pairs', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertNode(db, 'd');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'c', 'd');
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(2);
-    const allNodes = result.flat().sort();
-    expect(allNodes).toEqual(['a', 'b', 'c', 'd'].sort());
-    db.close();
-  });
-
-  it('treats directed edges as undirected (weak connectivity)', () => {
-    const db = makeTempDb();
-    // b->a but they should still be in same WCC
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'b', 'a');
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(1);
-    expect(result[0].sort()).toEqual(['a', 'b'].sort());
-    db.close();
-  });
-
-  it('returns isolated nodes as separate components', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    // no edges — 3 separate components
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(3);
-    db.close();
-  });
-
-  it('handles cycle within a component', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    const result = weaklyConnectedComponents(db);
-    expect(result.length).toBe(1);
-    db.close();
-  });
-});

package/src/__tests__/groups/grpc-extractor.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractGrpcContracts, type GrpcContract } from '../../groups/grpc-extractor.js';
-
-const PROTO_SOURCE = `
-syntax = "proto3";
-package payments;
-
-service PaymentService {
-  rpc ProcessPayment (PaymentRequest) returns (PaymentResponse);
-  rpc RefundPayment (RefundRequest) returns (RefundResponse);
-}
-
-message PaymentRequest { string amount = 1; }
-message PaymentResponse { bool success = 1; }
-`;
-
-const GO_GRPC_SOURCE = `
-conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
-client := pb.NewPaymentServiceClient(conn)
-resp, err := client.ProcessPayment(ctx, req)
-`;
-
-describe('extractGrpcContracts', () => {
-  it('extracts service definitions from proto files', () => {
-    const result = extractGrpcContracts(PROTO_SOURCE, '/api.proto');
-    const services = result.filter(c => c.role === 'provider');
-    expect(services.some(s => s.serviceName === 'PaymentService')).toBe(true);
-  });
-
-  it('extracts RPC method names', () => {
-    const result = extractGrpcContracts(PROTO_SOURCE, '/api.proto');
-    const methods = result.flatMap(c => c.methods);
-    expect(methods).toContain('ProcessPayment');
-    expect(methods).toContain('RefundPayment');
-  });
-
-  it('detects consumer pattern in Go gRPC client code', () => {
-    const result = extractGrpcContracts(GO_GRPC_SOURCE, '/client.go');
-    const consumers = result.filter(c => c.role === 'consumer');
-    expect(consumers.length).toBeGreaterThan(0);
-  });
-
-  it('returns empty for unrelated source', () => {
-    const result = extractGrpcContracts('const x = 1;', '/utils.ts');
-    expect(result).toHaveLength(0);
-  });
-});

package/src/__tests__/groups/service-boundary.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { detectServiceBoundaries, assignService } from '../../groups/service-boundary.js';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-let tmpRoot: string;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(join(tmpdir(), 'monograph-svc-boundary-test-'));
-  // service-a: has package.json
-  mkdirSync(join(tmpRoot, 'service-a'));
-  writeFileSync(join(tmpRoot, 'service-a', 'package.json'), JSON.stringify({ name: 'service-a' }));
-  mkdirSync(join(tmpRoot, 'service-a', 'src'));
-  writeFileSync(join(tmpRoot, 'service-a', 'src', 'index.ts'), '');
-
-  // service-b: has Dockerfile
-  mkdirSync(join(tmpRoot, 'service-b'));
-  writeFileSync(join(tmpRoot, 'service-b', 'Dockerfile'), 'FROM node:20');
-  mkdirSync(join(tmpRoot, 'service-b', 'lib'));
-  writeFileSync(join(tmpRoot, 'service-b', 'lib', 'main.ts'), '');
-
-  // service-c: has go.mod
-  mkdirSync(join(tmpRoot, 'service-c'));
-  writeFileSync(join(tmpRoot, 'service-c', 'go.mod'), 'module github.com/example/service-c');
-
-  // shared: no markers
-  mkdirSync(join(tmpRoot, 'shared'));
-  writeFileSync(join(tmpRoot, 'shared', 'utils.ts'), '');
-});
-
-afterAll(() => {
-  rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-describe('detectServiceBoundaries', () => {
-  it('detects directories with service markers', () => {
-    const boundaries = detectServiceBoundaries(tmpRoot);
-    expect(boundaries.length).toBeGreaterThanOrEqual(2);
-    const paths = boundaries.map(b => b.servicePath);
-    expect(paths.some(p => p.includes('service-a'))).toBe(true);
-    expect(paths.some(p => p.includes('service-b') || p.includes('service-c'))).toBe(true);
-    db?.close?.();
-  });
-
-  it('returns ServiceBoundary objects with required fields', () => {
-    const boundaries = detectServiceBoundaries(tmpRoot);
-    for (const b of boundaries) {
-      expect(typeof b.servicePath).toBe('string');
-      expect(typeof b.serviceName).toBe('string');
-      expect(Array.isArray(b.markers)).toBe(true);
-      expect(typeof b.confidence).toBe('number');
-      expect(b.confidence).toBeGreaterThan(0);
-      expect(b.confidence).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('returns empty array when no markers found', () => {
-    const emptyDir = mkdtempSync(join(tmpdir(), 'monograph-empty-svc-'));
-    const boundaries = detectServiceBoundaries(emptyDir);
-    expect(boundaries).toEqual([]);
-    rmSync(emptyDir, { recursive: true, force: true });
-  });
-});
-
-// Workaround: db was referenced accidentally above — ignore it
-const db = null;
-
-describe('assignService', () => {
-  it('returns the matching service for a file inside a service directory', () => {
-    const boundaries = detectServiceBoundaries(tmpRoot);
-    const file = join(tmpRoot, 'service-a', 'src', 'index.ts');
-    const result = assignService(file, boundaries);
-    expect(result).toBeDefined();
-    expect(result?.servicePath).toContain('service-a');
-  });
-
-  it('returns undefined for a file outside any service boundary', () => {
-    const boundaries = detectServiceBoundaries(tmpRoot);
-    const file = join(tmpRoot, 'shared', 'utils.ts');
-    const result = assignService(file, boundaries);
-    // shared has no markers so may be undefined (depends on whether shared is detected)
-    // The test just asserts the function runs without throwing
-    expect(typeof result === 'undefined' || typeof result === 'object').toBe(true);
-  });
-});

package/src/__tests__/groups/topic-extractor.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractTopicContracts } from '../../groups/topic-extractor.js';
-
-const KAFKA_PRODUCER_TS = `
-producer.send({ topic: 'order.created', messages: [{ value: JSON.stringify(order) }] });
-await producer.send({ topic: 'payment.processed', messages: [{ key: id, value: body }] });
-`;
-
-const KAFKA_CONSUMER_TS = `
-await consumer.subscribe({ topic: 'order.created', fromBeginning: true });
-consumer.run({ eachMessage: async ({ topic, message }) => { } });
-`;
-
-const RABBITMQ_TS = `
-channel.assertExchange('inventory.exchange', 'topic');
-channel.publish('inventory.exchange', 'product.updated', Buffer.from(msg));
-channel.bindQueue(q.queue, 'inventory.exchange', 'product.#');
-`;
-
-describe('extractTopicContracts', () => {
-  it('detects Kafka producer topics', () => {
-    const result = extractTopicContracts(KAFKA_PRODUCER_TS, '/producer.ts');
-    const topics = result.filter(c => c.role === 'producer').map(c => c.topicName);
-    expect(topics).toContain('order.created');
-    expect(topics).toContain('payment.processed');
-  });
-
-  it('detects Kafka consumer topics', () => {
-    const result = extractTopicContracts(KAFKA_CONSUMER_TS, '/consumer.ts');
-    const topics = result.filter(c => c.role === 'consumer').map(c => c.topicName);
-    expect(topics).toContain('order.created');
-  });
-
-  it('detects RabbitMQ exchange/routing key patterns', () => {
-    const result = extractTopicContracts(RABBITMQ_TS, '/rabbit.ts');
-    expect(result.some(c => c.topicName.includes('inventory'))).toBe(true);
-  });
-
-  it('returns empty for unrelated source', () => {
-    const result = extractTopicContracts('const x = 1;', '/utils.ts');
-    expect(result).toHaveLength(0);
-  });
-});

package/src/__tests__/ingest/git-clone.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateGitUrl, extractRepoName, getCloneDir } from '../../ingest/git-clone.js';
-import os from 'os';
-import path from 'path';
-
-// ── validateGitUrl ─────────────────────────────────────────────────────────────
-
-describe('validateGitUrl', () => {
-  // ── Allowed ──────────────────────────────────────────────────────────────────
-  it('allows https:// URLs', () => {
-    expect(() => validateGitUrl('https://github.com/org/repo.git')).not.toThrow();
-  });
-
-  it('allows http:// URLs', () => {
-    expect(() => validateGitUrl('http://github.com/org/repo.git')).not.toThrow();
-  });
-
-  // ── Scheme blocks ─────────────────────────────────────────────────────────────
-  it('blocks git:// scheme', () => {
-    expect(() => validateGitUrl('git://github.com/org/repo.git')).toThrow();
-  });
-
-  it('blocks ssh:// scheme', () => {
-    expect(() => validateGitUrl('ssh://github.com/org/repo.git')).toThrow();
-  });
-
-  it('blocks file:// scheme', () => {
-    expect(() => validateGitUrl('file:///etc/passwd')).toThrow();
-  });
-
-  // ── Blocked hostnames ─────────────────────────────────────────────────────────
-  it('blocks localhost', () => {
-    expect(() => validateGitUrl('https://localhost/repo')).toThrow();
-  });
-
-  it('blocks metadata.google.internal', () => {
-    expect(() => validateGitUrl('https://metadata.google.internal/repo')).toThrow();
-  });
-
-  it('blocks metadata.azure.com', () => {
-    expect(() => validateGitUrl('https://metadata.azure.com/repo')).toThrow();
-  });
-
-  // ── Private IPv4 ──────────────────────────────────────────────────────────────
-  it('blocks 127.0.0.1', () => {
-    expect(() => validateGitUrl('https://127.0.0.1/repo')).toThrow();
-  });
-
-  it('blocks 10.0.0.1', () => {
-    expect(() => validateGitUrl('https://10.0.0.1/repo')).toThrow();
-  });
-
-  it('blocks 192.168.1.1', () => {
-    expect(() => validateGitUrl('https://192.168.1.1/repo')).toThrow();
-  });
-
-  it('blocks 172.16.0.1 (RFC1918)', () => {
-    expect(() => validateGitUrl('https://172.16.0.1/repo')).toThrow();
-  });
-
-  it('blocks 172.31.255.255 (RFC1918)', () => {
-    expect(() => validateGitUrl('https://172.31.255.255/repo')).toThrow();
-  });
-
-  it('blocks 169.254.169.254 (link-local)', () => {
-    expect(() => validateGitUrl('https://169.254.169.254/repo')).toThrow();
-  });
-
-  // ── IPv6 private ──────────────────────────────────────────────────────────────
-  it('blocks IPv6 loopback ::1', () => {
-    expect(() => validateGitUrl('https://[::1]/repo')).toThrow();
-  });
-
-  it('blocks IPv6 Unique Local fc00::', () => {
-    expect(() => validateGitUrl('https://[fc00::1]/repo')).toThrow();
-  });
-
-  it('blocks IPv6 link-local fe80::', () => {
-    expect(() => validateGitUrl('https://[fe80::1]/repo')).toThrow();
-  });
-
-  it('blocks IPv4-mapped IPv6 ::ffff:127.0.0.1', () => {
-    expect(() => validateGitUrl('https://[::ffff:127.0.0.1]/repo')).toThrow();
-  });
-
-  // ── Numeric IP encodings ───────────────────────────────────────────────────────
-  it('blocks decimal IP encoding 2130706433 (127.0.0.1)', () => {
-    expect(() => validateGitUrl('https://2130706433/repo')).toThrow();
-  });
-
-  it('blocks hex IP encoding 0x7f000001 (127.0.0.1)', () => {
-    expect(() => validateGitUrl('https://0x7f000001/repo')).toThrow();
-  });
-
-  // ── Invalid URL ───────────────────────────────────────────────────────────────
-  it('throws for an invalid URL', () => {
-    expect(() => validateGitUrl('not a url')).toThrow();
-  });
-});
-
-// ── extractRepoName ────────────────────────────────────────────────────────────
-
-describe('extractRepoName', () => {
-  it('extracts repo name from https URL with .git suffix', () => {
-    expect(extractRepoName('https://github.com/org/my-repo.git')).toBe('my-repo');
-  });
-
-  it('extracts repo name from https URL without .git suffix', () => {
-    expect(extractRepoName('https://github.com/org/my-repo')).toBe('my-repo');
-  });
-
-  it('extracts repo name from https URL with trailing slash', () => {
-    expect(extractRepoName('https://github.com/org/my-repo/')).toBe('my-repo');
-  });
-
-  it('extracts repo name from SSH URL', () => {
-    expect(extractRepoName('git@github.com:org/my-repo.git')).toBe('my-repo');
-  });
-});
-
-// ── getCloneDir ────────────────────────────────────────────────────────────────
-
-describe('getCloneDir', () => {
-  it('returns path under ~/.monograph/repos/<name>', () => {
-    const expected = path.join(os.homedir(), '.monograph', 'repos', 'my-repo');
-    expect(getCloneDir('my-repo')).toBe(expected);
-  });
-});

package/src/__tests__/ingest/query-memory.test.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { saveQueryResult } from '../../ingest/query-memory.js';
-import { mkdtempSync, readFileSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-function makeTempDir() {
-  return mkdtempSync(join(tmpdir(), 'monograph-qmem-test-'));
-}
-
-describe('saveQueryResult', () => {
-  const dirs: string[] = [];
-  afterEach(() => {
-    for (const d of dirs) {
-      try { rmSync(d, { recursive: true }); } catch { /* ignore */ }
-    }
-    dirs.length = 0;
-  });
-
-  it('creates the memory directory if it does not exist', () => {
-    const memDir = join(makeTempDir(), 'sub', 'memory');
-    dirs.push(memDir.split('/').slice(0, -2).join('/'));
-    saveQueryResult({ question: 'What is X?', answer: 'X is Y.', memoryDir: memDir });
-    const { existsSync } = require('fs');
-    expect(existsSync(memDir)).toBe(true);
-  });
-
-  it('writes a Markdown file with YAML front-matter', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({ question: 'What is X?', answer: 'X is Y.', memoryDir: memDir });
-    const content = readFileSync(result.filePath, 'utf-8');
-    expect(content).toContain('---');
-    expect(content).toContain('type: "query"');
-    expect(content).toContain('question: "What is X?"');
-    expect(content).toContain('contributor: "monograph"');
-    expect(content).toContain('# Q: What is X?');
-    expect(content).toContain('X is Y.');
-  });
-
-  it('includes a date field in the front-matter', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({ question: 'Test?', answer: 'Yes.', memoryDir: memDir });
-    const content = readFileSync(result.filePath, 'utf-8');
-    expect(content).toMatch(/date: "\d{4}-\d{2}-\d{2}/);
-  });
-
-  it('includes source_nodes in front-matter when provided', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({
-      question: 'Who calls auth?',
-      answer: 'login calls auth.',
-      memoryDir: memDir,
-      sourceNodes: ['login', 'auth'],
-    });
-    const content = readFileSync(result.filePath, 'utf-8');
-    expect(content).toContain('source_nodes:');
-    expect(content).toContain('"login"');
-    expect(content).toContain('"auth"');
-  });
-
-  it('includes Source Nodes section in body when sourceNodes provided', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({
-      question: 'Q',
-      answer: 'A',
-      memoryDir: memDir,
-      sourceNodes: ['nodeA'],
-    });
-    const content = readFileSync(result.filePath, 'utf-8');
-    expect(content).toContain('## Source Nodes');
-    expect(content).toContain('- nodeA');
-  });
-
-  it('limits source_nodes to 10 entries in front-matter', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const manyNodes = Array.from({ length: 15 }, (_, i) => `node${i}`);
-    const result = saveQueryResult({
-      question: 'Q',
-      answer: 'A',
-      memoryDir: memDir,
-      sourceNodes: manyNodes,
-    });
-    const content = readFileSync(result.filePath, 'utf-8');
-    // front-matter line has at most 10 quoted node names
-    const fmLine = content.split('\n').find(l => l.startsWith('source_nodes:'))!;
-    const matches = fmLine.match(/"node\d+"/g) ?? [];
-    expect(matches.length).toBeLessThanOrEqual(10);
-  });
-
-  it('uses custom queryType in front-matter', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({ question: 'Q', answer: 'A', memoryDir: memDir, queryType: 'impact' });
-    const content = readFileSync(result.filePath, 'utf-8');
-    expect(content).toContain('type: "impact"');
-  });
-
-  it('returns the written file path and writtenAt timestamp', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const before = new Date().toISOString();
-    const result = saveQueryResult({ question: 'Q', answer: 'A', memoryDir: memDir });
-    const after = new Date().toISOString();
-    expect(result.filePath).toContain(memDir);
-    expect(result.filePath.endsWith('.md')).toBe(true);
-    expect(result.writtenAt >= before).toBe(true);
-    expect(result.writtenAt <= after).toBe(true);
-  });
-
-  it('escapes double quotes in the question', () => {
-    const memDir = makeTempDir();
-    dirs.push(memDir);
-    const result = saveQueryResult({ question: 'Say "hello"?', answer: 'Hi.', memoryDir: memDir });
-    const content = readFileSync(result.filePath, 'utf-8');
-    // YAML value should escape the inner quotes
-    expect(content).toContain('\\"hello\\"');
-  });
-});