@monoes/monograph 1.1.0 → 1.2.0

package/__tests__/pipeline/phases/wildcard-synthesis.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import {
+  extractWildcardBindings,
+  extractWildcardMemberAccesses,
+  synthesizeWildcardImports,
+} from '../../../src/pipeline/phases/wildcard-synthesis.js';
+import type { MonographNode, MonographEdge } from '../../../src/types.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeNode(overrides: Partial<MonographNode> & { id: string; name: string }): MonographNode {
+  return {
+    label: 'Function',
+    normLabel: overrides.name.toLowerCase(),
+    isExported: true,
+    ...overrides,
+  };
+}
+
+// ── extractWildcardBindings ───────────────────────────────────────────────────
+
+describe('extractWildcardBindings', () => {
+  it('detects a single wildcard import with single quotes', () => {
+    const src = `import * as utils from './utils';`;
+    const bindings = extractWildcardBindings(src);
+    expect(bindings).toHaveLength(1);
+    expect(bindings[0]).toEqual({ alias: 'utils', moduleSpecifier: './utils' });
+  });
+
+  it('detects a wildcard import with double quotes', () => {
+    const src = `import * as helpers from "../helpers"`;
+    const bindings = extractWildcardBindings(src);
+    expect(bindings).toHaveLength(1);
+    expect(bindings[0]).toEqual({ alias: 'helpers', moduleSpecifier: '../helpers' });
+  });
+
+  it('detects multiple wildcard imports', () => {
+    const src = [
+      `import * as ns1 from './module-a';`,
+      `import * as ns2 from './module-b';`,
+      `import { foo } from './module-c';`,
+    ].join('\n');
+    const bindings = extractWildcardBindings(src);
+    expect(bindings).toHaveLength(2);
+    expect(bindings.map(b => b.alias)).toEqual(['ns1', 'ns2']);
+  });
+
+  it('returns empty array when no wildcard imports exist', () => {
+    const src = `import { foo, bar } from './utils';\nimport DefaultExport from './default';`;
+    expect(extractWildcardBindings(src)).toHaveLength(0);
+  });
+
+  it('is not confused by regular imports containing "as"', () => {
+    const src = `import { foo as bar } from './utils';`;
+    expect(extractWildcardBindings(src)).toHaveLength(0);
+  });
+});
+
+// ── extractWildcardMemberAccesses ─────────────────────────────────────────────
+
+describe('extractWildcardMemberAccesses', () => {
+  it('detects a simple member access', () => {
+    const src = `const x = ns.foo();`;
+    const accesses = extractWildcardMemberAccesses(src, 'ns');
+    expect(accesses).toHaveLength(1);
+    expect(accesses[0]).toMatchObject({ alias: 'ns', member: 'foo', line: 1 });
+  });
+
+  it('detects multiple different members on different lines', () => {
+    const src = [`ns.alpha();`, `ns.beta = 1;`, `console.log(ns.gamma);`].join('\n');
+    const accesses = extractWildcardMemberAccesses(src, 'ns');
+    expect(accesses.map(a => a.member)).toEqual(['alpha', 'beta', 'gamma']);
+    expect(accesses.map(a => a.line)).toEqual([1, 2, 3]);
+  });
+
+  it('deduplicates the same member accessed multiple times on the same line', () => {
+    const src = `if (ns.enabled && ns.enabled) {}`;
+    const accesses = extractWildcardMemberAccesses(src, 'ns');
+    const enabledAccesses = accesses.filter(a => a.member === 'enabled');
+    expect(enabledAccesses).toHaveLength(1);
+  });
+
+  it('does not match a different namespace with similar prefix', () => {
+    const src = `nsExtra.foo(); ns.bar();`;
+    const accesses = extractWildcardMemberAccesses(src, 'ns');
+    expect(accesses.map(a => a.member)).toEqual(['bar']);
+  });
+
+  it('returns empty array when alias is never used as a member accessor', () => {
+    const src = `const ns = 1;\nconsole.log(ns);`;
+    expect(extractWildcardMemberAccesses(src, 'ns')).toHaveLength(0);
+  });
+});
+
+// ── synthesizeWildcardImports ─────────────────────────────────────────────────
+
+describe('synthesizeWildcardImports', () => {
+  it('creates an IMPORTS edge from source file to the accessed exported symbol', () => {
+    const src = [
+      `import * as utils from './utils';`,
+      `utils.formatDate();`,
+    ].join('\n');
+
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/utils.ts:formatDate', name: 'formatDate', filePath: 'src/utils.ts' }),
+    ];
+
+    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, []);
+
+    expect(result.synthesizedEdges).toHaveLength(1);
+    const edge = result.synthesizedEdges[0];
+    expect(edge.sourceId).toBe('file:src/app.ts');
+    expect(edge.targetId).toBe('fn:src/utils.ts:formatDate');
+    expect(edge.relation).toBe('IMPORTS');
+    expect(edge.confidence).toBe('INFERRED');
+  });
+
+  it('creates edges for multiple member accesses', () => {
+    const src = [
+      `import * as math from './math';`,
+      `math.add(1, 2);`,
+      `math.subtract(5, 3);`,
+    ].join('\n');
+
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/math.ts:add', name: 'add' }),
+      makeNode({ id: 'fn:src/math.ts:subtract', name: 'subtract' }),
+    ];
+
+    const result = synthesizeWildcardImports('file:src/calc.ts', src, nodes, []);
+
+    const memberNames = result.synthesizedEdges.map(e => {
+      const target = nodes.find(n => n.id === e.targetId);
+      return target?.name;
+    });
+    expect(memberNames.sort()).toEqual(['add', 'subtract']);
+  });
+
+  it('does not create edges for non-exported symbols', () => {
+    const src = [
+      `import * as internal from './internal';`,
+      `internal.privateHelper();`,
+    ].join('\n');
+
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/internal.ts:privateHelper', name: 'privateHelper', isExported: false }),
+    ];
+
+    const result = synthesizeWildcardImports('file:src/consumer.ts', src, nodes, []);
+    expect(result.synthesizedEdges).toHaveLength(0);
+  });
+
+  it('does not duplicate edges that already exist', () => {
+    const src = [
+      `import * as utils from './utils';`,
+      `utils.helper();`,
+    ].join('\n');
+
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/utils.ts:helper', name: 'helper' }),
+    ];
+
+    const existingEdge: MonographEdge = {
+      id: 'file_src_app_ts_fn_src_utils_ts_helper_wildcard_helper',
+      sourceId: 'file:src/app.ts',
+      targetId: 'fn:src/utils.ts:helper',
+      relation: 'IMPORTS',
+      confidence: 'INFERRED',
+      confidenceScore: 0.5,
+    };
+
+    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, [existingEdge]);
+    expect(result.synthesizedEdges).toHaveLength(0);
+  });
+
+  it('returns empty result when there are no wildcard imports', () => {
+    const src = `import { foo } from './utils';\nfoo();`;
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/utils.ts:foo', name: 'foo' }),
+    ];
+    const result = synthesizeWildcardImports('file:src/app.ts', src, nodes, []);
+    expect(result.synthesizedEdges).toHaveLength(0);
+  });
+
+  it('handles multiple wildcard imports from different modules', () => {
+    const src = [
+      `import * as a from './module-a';`,
+      `import * as b from './module-b';`,
+      `a.alpha();`,
+      `b.beta();`,
+    ].join('\n');
+
+    const nodes: MonographNode[] = [
+      makeNode({ id: 'fn:src/module-a.ts:alpha', name: 'alpha' }),
+      makeNode({ id: 'fn:src/module-b.ts:beta', name: 'beta' }),
+    ];
+
+    const result = synthesizeWildcardImports('file:src/consumer.ts', src, nodes, []);
+    expect(result.synthesizedEdges).toHaveLength(2);
+  });
+
+  it('returns empty result when source is empty', () => {
+    expect(synthesizeWildcardImports('file:src/empty.ts', '', [], [])).toEqual({
+      synthesizedEdges: [],
+    });
+  });
+});

package/__tests__/registry/repo-registry.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Tests for repo-registry.ts
+ *
+ * Uses MONOGRAPH_REGISTRY_PATH env var to point at a temp directory,
+ * avoiding any writes to ~/.monograph/registry.json during tests.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  getRegistryPath,
+  loadRegistry,
+  registerRepo,
+  unregisterRepo,
+  listRepos,
+} from '../../src/registry/repo-registry.js';
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'monograph-registry-test-'));
+  vi.stubEnv('MONOGRAPH_REGISTRY_PATH', join(tempDir, 'registry.json'));
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('getRegistryPath', () => {
+  it('returns the path set via env var', () => {
+    const p = getRegistryPath();
+    expect(p).toBe(join(tempDir, 'registry.json'));
+  });
+});
+
+describe('loadRegistry', () => {
+  it('returns empty registry when file does not exist', () => {
+    const reg = loadRegistry();
+    expect(reg).toEqual({ repos: [] });
+  });
+});
+
+describe('registerRepo', () => {
+  it('adds a new repo entry', () => {
+    registerRepo('/projects/alpha', { nodeCount: 100, edgeCount: 200 });
+    const repos = listRepos();
+    expect(repos).toHaveLength(1);
+    expect(repos[0].path).toBe('/projects/alpha');
+    expect(repos[0].name).toBe('alpha');
+    expect(repos[0].nodeCount).toBe(100);
+    expect(repos[0].edgeCount).toBe(200);
+    expect(repos[0].lastIndexed).toBeTruthy();
+  });
+
+  it('upserts an existing repo (updates timestamp and counts)', async () => {
+    registerRepo('/projects/alpha', { nodeCount: 50 });
+    const firstIndexed = listRepos()[0].lastIndexed;
+
+    await new Promise((r) => setTimeout(r, 10));
+    registerRepo('/projects/alpha', { nodeCount: 150, edgeCount: 300 });
+
+    const repos = listRepos();
+    expect(repos).toHaveLength(1);
+    expect(repos[0].nodeCount).toBe(150);
+    expect(repos[0].edgeCount).toBe(300);
+    expect(repos[0].lastIndexed).not.toBe(firstIndexed);
+  });
+
+  it('handles multiple repos independently', () => {
+    registerRepo('/projects/alpha');
+    registerRepo('/projects/beta');
+    registerRepo('/projects/gamma');
+    const repos = listRepos();
+    expect(repos).toHaveLength(3);
+    const names = repos.map((r) => r.name).sort();
+    expect(names).toEqual(['alpha', 'beta', 'gamma']);
+  });
+});
+
+describe('unregisterRepo', () => {
+  it('removes a registered repo', () => {
+    registerRepo('/projects/alpha');
+    registerRepo('/projects/beta');
+    unregisterRepo('/projects/alpha');
+    const repos = listRepos();
+    expect(repos).toHaveLength(1);
+    expect(repos[0].path).toBe('/projects/beta');
+  });
+
+  it('is a no-op when path is not registered', () => {
+    registerRepo('/projects/alpha');
+    unregisterRepo('/projects/nonexistent');
+    expect(listRepos()).toHaveLength(1);
+  });
+});
+
+describe('listRepos', () => {
+  it('returns repos sorted alphabetically by name', () => {
+    registerRepo('/z/zebra');
+    registerRepo('/a/ant');
+    registerRepo('/m/monkey');
+    const names = listRepos().map((r) => r.name);
+    expect(names).toEqual(['ant', 'monkey', 'zebra']);
+  });
+
+  it('returns empty array when no repos are registered', () => {
+    expect(listRepos()).toEqual([]);
+  });
+});
+
+describe('saveRegistry / loadRegistry round-trip', () => {
+  it('persists and reloads registry correctly', () => {
+    registerRepo('/projects/alpha', { nodeCount: 42 });
+
+    expect(existsSync(getRegistryPath())).toBe(true);
+
+    const raw = JSON.parse(readFileSync(getRegistryPath(), 'utf8')) as { repos: unknown[] };
+    expect(raw.repos).toHaveLength(1);
+
+    const reloaded = loadRegistry();
+    expect(reloaded.repos[0].path).toBe('/projects/alpha');
+    expect((reloaded.repos[0] as { nodeCount: number }).nodeCount).toBe(42);
+  });
+});

package/__tests__/reporting/graph-report.suggest.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { buildMarkdownWithQuestions } from '../../src/reporting/graph-report.js';
+import type { SuggestedQuestion } from '../../src/types.js';
+
+describe('buildMarkdownWithQuestions', () => {
+  it('renders Suggested Questions section when questions provided', () => {
+    const questions: SuggestedQuestion[] = [
+      { type: 'bridge_node', node: { id: 'n1', name: 'UserService', label: 'Class' } as any, commA: 0, commB: 1 },
+      { type: 'ambiguous_edge', edge: { sourceId: 'n1', targetId: 'n2', confidence: 'AMBIGUOUS' } as any, reason: 'Dynamic dispatch' },
+      { type: 'isolated_nodes', nodes: [{ id: 'n3', name: 'Orphan', label: 'Function' } as any], reason: 'No edges' },
+    ];
+    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], questions);
+    expect(md).toContain('## Suggested Questions');
+    expect(md).toContain('bridge_node');
+    expect(md).toContain('UserService');
+    expect(md).toContain('ambiguous_edge');
+    expect(md).toContain('isolated_nodes');
+    expect(md).toContain('Orphan');
+  });
+
+  it('omits Suggested Questions section when no questions', () => {
+    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], []);
+    expect(md).not.toContain('## Suggested Questions');
+  });
+
+  it('caps rendered questions at 20', () => {
+    const questions: SuggestedQuestion[] = Array.from({ length: 25 }, (_, i) => ({
+      type: 'ambiguous_edge' as const,
+      edge: { sourceId: `n${i}`, targetId: `n${i}x`, confidence: 'AMBIGUOUS' } as any,
+      reason: 'test',
+    }));
+    const md = buildMarkdownWithQuestions(1, 0, [], [], [], [], [], questions);
+    const matches = md.match(/ambiguous_edge/g) ?? [];
+    expect(matches.length).toBeLessThanOrEqual(20);
+  });
+});

package/__tests__/reporting/graph-report.test.ts

@@ -0,0 +1,165 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { unlinkSync, existsSync, readFileSync, mkdirSync } 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 { generateGraphReport } from '../../src/reporting/graph-report.js';
+import type { MonographDb } from '../../src/storage/db.js';
+
+const testDir = join(tmpdir(), `monograph-report-${Date.now()}`);
+const dbPath = join(testDir, 'graph.db');
+const outputPath = join(testDir, 'GRAPH_REPORT.md');
+let db: MonographDb;
+
+beforeAll(() => {
+  mkdirSync(testDir, { recursive: true });
+  db = openDb(dbPath);
+
+  // Insert test nodes
+  insertNode(db, {
+    id: 'n1',
+    label: 'Function',
+    name: 'processData',
+    normLabel: 'processdata',
+    filePath: 'src/data.ts',
+    isExported: true,
+    communityId: 1,
+  });
+  insertNode(db, {
+    id: 'n2',
+    label: 'Class',
+    name: 'DataService',
+    normLabel: 'dataservice',
+    filePath: 'src/service.ts',
+    isExported: true,
+    communityId: 1,
+  });
+  insertNode(db, {
+    id: 'n3',
+    label: 'Function',
+    name: 'fetchItems',
+    normLabel: 'fetchitems',
+    filePath: 'src/api.ts',
+    isExported: false,
+    communityId: 2,
+  });
+  insertNode(db, {
+    id: 'n4',
+    label: 'Interface',
+    name: 'DataItem',
+    normLabel: 'dataitem',
+    filePath: 'src/types.ts',
+    isExported: true,
+  });
+
+  // Insert test edges
+  insertEdge(db, {
+    id: 'e1',
+    sourceId: 'n2',
+    targetId: 'n1',
+    relation: 'CALLS',
+    confidence: 'EXTRACTED',
+    confidenceScore: 1.0,
+  });
+  insertEdge(db, {
+    id: 'e2',
+    sourceId: 'n3',
+    targetId: 'n2',
+    relation: 'IMPORTS',
+    confidence: 'EXTRACTED',
+    confidenceScore: 1.0,
+  });
+  insertEdge(db, {
+    id: 'e3',
+    sourceId: 'n1',
+    targetId: 'n4',
+    relation: 'REFERENCES',
+    confidence: 'INFERRED',
+    confidenceScore: 0.5,
+  });
+
+  closeDb(db);
+});
+
+afterAll(() => {
+  for (const p of [dbPath, dbPath + '-wal', dbPath + '-shm', outputPath]) {
+    if (existsSync(p)) {
+      try { unlinkSync(p); } catch { /* ignore */ }
+    }
+  }
+});
+
+describe('generateGraphReport', () => {
+  it('returns GraphReportResult with correct shape', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+
+    expect(result).toMatchObject({
+      markdown: expect.any(String),
+      path: outputPath,
+      stats: {
+        nodeCount: expect.any(Number),
+        edgeCount: expect.any(Number),
+        communityCount: expect.any(Number),
+      },
+    });
+  });
+
+  it('markdown contains # Graph Report header', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.markdown).toContain('# Graph Report');
+  });
+
+  it('markdown contains node count in summary', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.stats.nodeCount).toBe(4);
+    expect(result.markdown).toContain('4');
+  });
+
+  it('markdown contains edge count in summary', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.stats.edgeCount).toBe(3);
+    expect(result.markdown).toContain('3');
+  });
+
+  it('writes file to the specified output path', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(existsSync(result.path)).toBe(true);
+    const contents = readFileSync(result.path, 'utf8');
+    expect(contents).toBe(result.markdown);
+  });
+
+  it('markdown contains Nodes by Type section', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.markdown).toContain('## Nodes by Type');
+    expect(result.markdown).toContain('Function');
+    expect(result.markdown).toContain('Class');
+  });
+
+  it('markdown contains Edges by Relation section', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.markdown).toContain('## Edges by Relation');
+    expect(result.markdown).toContain('CALLS');
+    expect(result.markdown).toContain('IMPORTS');
+  });
+
+  it('markdown contains Top Nodes by Degree section', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.markdown).toContain('## Top Nodes by Degree');
+  });
+
+  it('stats reflect actual DB content', async () => {
+    const result = await generateGraphReport(testDir, outputPath, dbPath);
+    expect(result.stats.nodeCount).toBe(4);
+    expect(result.stats.edgeCount).toBe(3);
+    // 2 communities (id 1 and 2)
+    expect(result.stats.communityCount).toBe(2);
+  });
+
+  it('uses default output path when not specified', async () => {
+    const result = await generateGraphReport(testDir, undefined, dbPath);
+    expect(result.path).toBe(join(testDir, 'GRAPH_REPORT.md'));
+    if (existsSync(result.path)) unlinkSync(result.path);
+  });
+});

package/__tests__/search/ast-chunker.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { chunkSource } from '../../src/search/ast-chunker.js';
+
+describe('chunkSource', () => {
+  it('returns empty array for empty source', () => {
+    expect(chunkSource('')).toEqual([]);
+  });
+
+  it('detects import chunk kind', () => {
+    const src = `import { foo } from './foo.js';\nimport { bar } from './bar.js';`;
+    const chunks = chunkSource(src);
+    expect(chunks.length).toBeGreaterThanOrEqual(1);
+    expect(chunks[0].kind).toBe('import');
+    expect(chunks[0].startLine).toBe(1);
+  });
+
+  it('detects function chunk kind', () => {
+    const src = `function myFn() {\n  return 42;\n}`;
+    const chunks = chunkSource(src);
+    const fn = chunks.find(c => c.kind === 'function');
+    expect(fn).toBeDefined();
+  });
+
+  it('detects class chunk kind', () => {
+    const src = `class MyClass {\n  constructor() {}\n}`;
+    const chunks = chunkSource(src);
+    const cls = chunks.find(c => c.kind === 'class');
+    expect(cls).toBeDefined();
+  });
+
+  it('detects comment block kind', () => {
+    const src = `// This is a comment\n// spanning two lines\nconst x = 1;`;
+    const chunks = chunkSource(src);
+    const comment = chunks.find(c => c.kind === 'comment');
+    expect(comment).toBeDefined();
+  });
+
+  it('splits oversized chunk with overlap', () => {
+    // Create a source that is definitely > 512 tokens (>2048 chars)
+    const bigFn = `function big() {\n` + '  const x = 1;\n'.repeat(200) + `}`;
+    const chunks = chunkSource(bigFn, { maxTokens: 50 });
+    expect(chunks.length).toBeGreaterThan(1);
+    // Adjacent chunks should overlap
+    const c0end = chunks[0].endLine;
+    const c1start = chunks[1].startLine;
+    expect(c1start).toBeLessThanOrEqual(c0end);
+  });
+
+  it('discards chunks smaller than minTokens', () => {
+    const src = `const x = 1;`; // ~3 tokens
+    const chunks = chunkSource(src, { minTokens: 100 });
+    expect(chunks).toHaveLength(0);
+  });
+
+  it('1-based line numbers are accurate', () => {
+    const src = `import { a } from 'a';\n\nfunction foo() {\n  return 1;\n}`;
+    const chunks = chunkSource(src);
+    for (const c of chunks) {
+      expect(c.startLine).toBeGreaterThanOrEqual(1);
+      expect(c.endLine).toBeGreaterThanOrEqual(c.startLine);
+    }
+  });
+});

package/__tests__/search/embed-batch-config.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock HttpEmbedder before importing embedBatch.
+// Note: vitest 4.x requires a regular function (not an arrow function) when
+// the mock will be called via `new`, because arrow functions are not constructable.
+vi.mock('../../src/search/http-embedder.js', () => ({
+  HttpEmbedder: vi.fn().mockImplementation(function () {
+    return {
+      embedBatch: vi.fn().mockResolvedValue([[0.1, 0.2], [0.3, 0.4]]),
+    };
+  }),
+}));
+
+import { embedBatch } from '../../src/search/embed-batch.js';
+import { HttpEmbedder } from '../../src/search/http-embedder.js';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('embedBatch with remote config', () => {
+  it('uses HttpEmbedder when remote config is provided', async () => {
+    const result = await embedBatch(['hello', 'world'], {
+      remote: { endpoint: 'http://localhost:1234/embed' },
+    });
+    expect(HttpEmbedder).toHaveBeenCalledWith({ endpoint: 'http://localhost:1234/embed' });
+    expect(result).toEqual([[0.1, 0.2], [0.3, 0.4]]);
+  });
+
+  it('passes all remote config fields to HttpEmbedder', async () => {
+    await embedBatch(['text'], {
+      remote: { endpoint: 'http://host/embed', apiKey: 'sk-test', model: 'nomic' },
+    });
+    expect(HttpEmbedder).toHaveBeenCalledWith({
+      endpoint: 'http://host/embed',
+      apiKey: 'sk-test',
+      model: 'nomic',
+    });
+  });
+});
+
+describe('embedBatch without remote config', () => {
+  it('does not instantiate HttpEmbedder when no remote config', async () => {
+    // Local embedder may fail in test env — that's fine, we just check HttpEmbedder wasn't used
+    try {
+      await embedBatch(['hello']);
+    } catch {
+      // expected in test env without a real local model
+    }
+    expect(HttpEmbedder).not.toHaveBeenCalled();
+  });
+});