@monoes/monograph 1.2.7 → 1.2.9

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

@@ -1,21 +1,24 @@
-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 { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { embedBatch } from '../../src/search/embed-batch.js';
 import { HttpEmbedder } from '../../src/search/http-embedder.js';
 
+// Spy on the prototype method instead of mocking the whole module via a
+// factory: constructing a class through a vi.mock() factory's returned
+// vi.fn() doesn't reliably preserve the factory's `mockImplementation`
+// return value under this vitest/tinyspy version — `new MockedClass()`
+// silently produces an empty auto-mock instance instead. Spying on the real
+// prototype method keeps the real constructor (harmless — it only assigns
+// config, no network call) and avoids that pitfall entirely.
+let embedBatchSpy: ReturnType<typeof vi.spyOn>;
+
 beforeEach(() => {
-  vi.clearAllMocks();
+  embedBatchSpy = vi
+    .spyOn(HttpEmbedder.prototype, 'embedBatch')
+    .mockResolvedValue([[0.1, 0.2], [0.3, 0.4]]);
+});
+
+afterEach(() => {
+  embedBatchSpy.mockRestore();
 });
 
 describe('embedBatch with remote config', () => {
@@ -23,7 +26,11 @@ describe('embedBatch with remote config', () => {
     const result = await embedBatch(['hello', 'world'], {
       remote: { endpoint: 'http://localhost:1234/embed' },
     });
-    expect(HttpEmbedder).toHaveBeenCalledWith({ endpoint: 'http://localhost:1234/embed' });
+    expect(embedBatchSpy).toHaveBeenCalledWith(['hello', 'world']);
+    const instance = embedBatchSpy.mock.contexts[0] as InstanceType<typeof HttpEmbedder> & {
+      config: { endpoint: string };
+    };
+    expect(instance.config.endpoint).toBe('http://localhost:1234/embed');
     expect(result).toEqual([[0.1, 0.2], [0.3, 0.4]]);
   });
 
@@ -31,7 +38,10 @@ describe('embedBatch with remote config', () => {
     await embedBatch(['text'], {
       remote: { endpoint: 'http://host/embed', apiKey: 'sk-test', model: 'nomic' },
     });
-    expect(HttpEmbedder).toHaveBeenCalledWith({
+    const instance = embedBatchSpy.mock.contexts[0] as InstanceType<typeof HttpEmbedder> & {
+      config: { endpoint: string; apiKey: string; model: string };
+    };
+    expect(instance.config).toMatchObject({
       endpoint: 'http://host/embed',
       apiKey: 'sk-test',
       model: 'nomic',
@@ -42,11 +52,11 @@ describe('embedBatch with remote config', () => {
 describe('embedBatch without remote config', () => {
   it('does not instantiate HttpEmbedder when no remote config', async () => {
     // Local embedder may fail or hang in test env — race against a short timeout
-    // so we just verify HttpEmbedder was NOT instantiated regardless of outcome.
+    // so we just verify HttpEmbedder.embedBatch was NOT called regardless of outcome.
     await Promise.race([
       embedBatch(['hello']).catch(() => { /* expected in CI without a real local model */ }),
       new Promise(resolve => setTimeout(resolve, 500)),
     ]);
-    expect(HttpEmbedder).not.toHaveBeenCalled();
+    expect(embedBatchSpy).not.toHaveBeenCalled();
   }, 2000);
 });

package/__tests__/wiki/providers.test.ts

@@ -1,4 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// callAnthropic routes through the local Claude Code CLI (claudeCliCall), not
+// fetch — it reuses the host's existing auth instead of an ANTHROPIC_API_KEY.
+// Mock that call directly rather than fetch, or these tests spawn the real
+// `claude` CLI (slow, and dependent on this machine's Claude Code install).
+const mockClaudeCliCall = vi.fn();
+vi.mock('../../src/claude-cli.js', () => ({
+  claudeCliCall: mockClaudeCliCall,
+}));
+
 import { callLLM } from '../../src/wiki/providers.js';
 
 const mockFetch = vi.fn();
@@ -8,22 +18,24 @@ function makeResponse(body: unknown, ok = true, status = 200) {
   return { ok, status, statusText: ok ? 'OK' : 'Error', json: async () => body };
 }
 
-beforeEach(() => mockFetch.mockReset());
+beforeEach(() => {
+  mockFetch.mockReset();
+  mockClaudeCliCall.mockReset();
+});
 
 describe('callLLM - anthropic', () => {
   it('returns text from response', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      content: [{ text: 'Hello from Claude' }],
-      usage: { input_tokens: 10, output_tokens: 5 },
-    }));
+    mockClaudeCliCall.mockResolvedValueOnce('Hello from Claude');
     const r = await callLLM('Say hi', { provider: 'anthropic', apiKey: 'sk-test' });
     expect(r.text).toBe('Hello from Claude');
-    expect(r.inputTokens).toBe(10);
+    expect(mockClaudeCliCall).toHaveBeenCalledWith('Say hi');
   });
 
-  it('throws on non-2xx', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({}, false, 401));
-    await expect(callLLM('hi', { provider: 'anthropic', apiKey: 'bad' })).rejects.toThrow('401');
+  it('throws when the claude CLI call fails', async () => {
+    mockClaudeCliCall.mockRejectedValueOnce(new Error('claude exited with code 1'));
+    await expect(callLLM('hi', { provider: 'anthropic', apiKey: 'bad' })).rejects.toThrow(
+      'claude exited with code 1',
+    );
   });
 });
 

package/__tests__/wiki/wiki-generator.test.ts

@@ -1,7 +1,19 @@
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { unlinkSync, existsSync } from 'fs';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// The no-llmClient/no-llmConfig default path in generateWikiPage now routes
+// through the local Claude Code CLI (see claude-cli.ts) instead of requiring
+// ANTHROPIC_API_KEY directly. Mock isClaudeCliAvailable so the "no client
+// configured" failure test doesn't depend on whether this machine happens to
+// have the CLI installed.
+const mockIsClaudeCliAvailable = vi.fn();
+vi.mock('../../src/claude-cli.js', () => ({
+  isClaudeCliAvailable: mockIsClaudeCliAvailable,
+  claudeCliCall: vi.fn(),
+}));
+
 import { openDb, closeDb } from '../../src/storage/db.js';
 import { insertNode } from '../../src/storage/node-store.js';
 import { insertEdge } from '../../src/storage/edge-store.js';
@@ -71,6 +83,7 @@ const edgeBC: MonographEdge = {
 };
 
 beforeEach(() => {
+  mockIsClaudeCliAvailable.mockReset();
   db = openDb(dbPath);
   // Insert community records
   db.prepare('INSERT OR IGNORE INTO communities (id, label, size) VALUES (?, ?, ?)').run(1, 'Core Module', 2);
@@ -185,14 +198,11 @@ describe('generateWikiPage', () => {
     expect(capturedPrompt).toContain('Core Module');
   });
 
-  it('throws ANTHROPIC_API_KEY not set error when no key and no client', async () => {
-    const origKey = process.env['ANTHROPIC_API_KEY'];
-    delete process.env['ANTHROPIC_API_KEY'];
-    try {
-      await expect(generateWikiPage(db, '1')).rejects.toThrow('ANTHROPIC_API_KEY not set');
-    } finally {
-      if (origKey !== undefined) process.env['ANTHROPIC_API_KEY'] = origKey;
-    }
+  it('throws Claude Code CLI not found error when no client and CLI unavailable', async () => {
+    // The no-llmClient/no-llmConfig default path checks isClaudeCliAvailable()
+    // rather than an API key — it reuses the host's Claude Code auth instead.
+    mockIsClaudeCliAvailable.mockReturnValue(false);
+    await expect(generateWikiPage(db, '1')).rejects.toThrow('Claude Code CLI not found');
   });
 });