@monoes/monograph 1.5.6 → 1.5.7

package/__tests__/wiki/gist-publisher.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { publishToGist } from '../../src/wiki/gist-publisher.js';
-
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-function makeResponse(body: unknown, ok = true, status = 200) {
-  return { ok, status, statusText: ok ? 'OK' : 'Error', json: async () => body };
-}
-
-beforeEach(() => mockFetch.mockReset());
-
-const FILES = { 'README.md': '# Hello', 'api.md': '## API' };
-
-describe('publishToGist', () => {
-  it('POSTs to create a new gist', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      id: 'abc123', html_url: 'https://gist.github.com/abc123',
-      files: { 'README.md': {}, 'api.md': {} },
-    }));
-    const result = await publishToGist(FILES, { token: 'ghp_test' });
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://api.github.com/gists',
-      expect.objectContaining({ method: 'POST' }),
-    );
-    expect(result.gistId).toBe('abc123');
-    expect(result.url).toBe('https://gist.github.com/abc123');
-    expect(result.filesPublished).toBe(2);
-  });
-
-  it('PATCHes an existing gist when gistId is set', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      id: 'existing', html_url: 'https://gist.github.com/existing',
-      files: { 'README.md': {} },
-    }));
-    await publishToGist({ 'README.md': '# Hi' }, { token: 'ghp_test', gistId: 'existing' });
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://api.github.com/gists/existing',
-      expect.objectContaining({ method: 'PATCH' }),
-    );
-  });
-
-  it('includes Authorization header', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      id: 'x', html_url: 'https://gist.github.com/x', files: {},
-    }));
-    await publishToGist({}, { token: 'ghp_mytoken' });
-    const [, opts] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect((opts.headers as Record<string, string>)['Authorization']).toBe('Bearer ghp_mytoken');
-  });
-
-  it('throws on non-2xx response', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({}, false, 401));
-    await expect(publishToGist(FILES, { token: 'bad' })).rejects.toThrow('401');
-  });
-
-  it('sets public flag in request body', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      id: 'y', html_url: 'https://gist.github.com/y', files: { 'f.md': {} },
-    }));
-    await publishToGist({ 'f.md': 'content' }, { token: 'tok', public: true });
-    const [, opts] = mockFetch.mock.calls[0] as [string, RequestInit];
-    const body = JSON.parse(opts.body as string) as { public: boolean };
-    expect(body.public).toBe(true);
-  });
-});

package/__tests__/wiki/providers.test.ts

@@ -1,69 +0,0 @@
-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();
-vi.stubGlobal('fetch', mockFetch);
-
-function makeResponse(body: unknown, ok = true, status = 200) {
-  return { ok, status, statusText: ok ? 'OK' : 'Error', json: async () => body };
-}
-
-beforeEach(() => {
-  mockFetch.mockReset();
-  mockClaudeCliCall.mockReset();
-});
-
-describe('callLLM - anthropic', () => {
-  it('returns text from response', async () => {
-    mockClaudeCliCall.mockResolvedValueOnce('Hello from Claude');
-    const r = await callLLM('Say hi', { provider: 'anthropic', apiKey: 'sk-test' });
-    expect(r.text).toBe('Hello from Claude');
-    expect(mockClaudeCliCall).toHaveBeenCalledWith('Say hi');
-  });
-
-  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',
-    );
-  });
-});
-
-describe('callLLM - openai', () => {
-  it('returns text from choices', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({
-      choices: [{ message: { content: 'Hello from GPT' } }],
-      usage: { prompt_tokens: 8, completion_tokens: 4 },
-    }));
-    const r = await callLLM('Say hi', { provider: 'openai', apiKey: 'sk-test' });
-    expect(r.text).toBe('Hello from GPT');
-    expect(r.outputTokens).toBe(4);
-  });
-});
-
-describe('callLLM - ollama', () => {
-  it('returns text from response field', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({ response: 'Hello from Ollama' }));
-    const r = await callLLM('Say hi', { provider: 'ollama' });
-    expect(r.text).toBe('Hello from Ollama');
-  });
-
-  it('uses custom baseUrl', async () => {
-    mockFetch.mockResolvedValueOnce(makeResponse({ response: 'ok' }));
-    await callLLM('hi', { provider: 'ollama', baseUrl: 'http://myhost:9999' });
-    expect(mockFetch).toHaveBeenCalledWith(
-      'http://myhost:9999/api/generate',
-      expect.anything(),
-    );
-  });
-});

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

@@ -1,260 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync } from 'fs';
-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';
-import { generateWikiPage, generateAllWikiPages } from '../../src/wiki/wiki-generator.js';
-import { upsertWikiPage, getWikiPage, listWikiPages } from '../../src/wiki/wiki-store.js';
-import { buildWikiPrompt } from '../../src/wiki/prompt-builder.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-const dbPath = join(tmpdir(), `monograph-wiki-${Date.now()}.db`);
-let db: ReturnType<typeof openDb>;
-
-const mockLlmClient = {
-  generate: async (prompt: string): Promise<string> => {
-    return `# Mock Wiki Page\n\nThis is a generated wiki page.\n\nPrompt length: ${prompt.length}`;
-  },
-};
-
-const nodeA: MonographNode = {
-  id: 'wiki_a',
-  label: 'Function',
-  name: 'doSomething',
-  normLabel: 'dosomething',
-  filePath: 'src/a.ts',
-  startLine: 1,
-  isExported: true,
-  communityId: 1,
-};
-
-const nodeB: MonographNode = {
-  id: 'wiki_b',
-  label: 'Class',
-  name: 'MyService',
-  normLabel: 'myservice',
-  filePath: 'src/b.ts',
-  startLine: 10,
-  isExported: true,
-  communityId: 1,
-};
-
-const nodeC: MonographNode = {
-  id: 'wiki_c',
-  label: 'Function',
-  name: 'helperFn',
-  normLabel: 'helperfn',
-  filePath: 'src/c.ts',
-  startLine: 5,
-  isExported: false,
-  communityId: 2,
-};
-
-const edgeAB: MonographEdge = {
-  id: 'e_ab',
-  sourceId: 'wiki_a',
-  targetId: 'wiki_b',
-  relation: 'CALLS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-const edgeBC: MonographEdge = {
-  id: 'e_bc',
-  sourceId: 'wiki_b',
-  targetId: 'wiki_c',
-  relation: 'IMPORTS',
-  confidence: 'EXTRACTED',
-  confidenceScore: 1.0,
-};
-
-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);
-  db.prepare('INSERT OR IGNORE INTO communities (id, label, size) VALUES (?, ?, ?)').run(2, 'Utilities', 1);
-  // Insert nodes
-  insertNode(db, nodeA);
-  insertNode(db, nodeB);
-  insertNode(db, nodeC);
-  // Insert edges
-  insertEdge(db, edgeAB);
-  insertEdge(db, edgeBC);
-});
-
-afterEach(() => {
-  closeDb(db);
-  if (existsSync(dbPath)) unlinkSync(dbPath);
-});
-
-describe('wiki-store', () => {
-  it('upsertWikiPage stores and retrieves a wiki page', () => {
-    upsertWikiPage(db, '1', '# Core Module\n\nThis is the core module.');
-    const page = getWikiPage(db, '1');
-    expect(page).not.toBeNull();
-    expect(page!.communityId).toBe('1');
-    expect(page!.content).toContain('Core Module');
-    expect(page!.generatedAt).toBeTruthy();
-  });
-
-  it('upsertWikiPage updates existing page on conflict', () => {
-    upsertWikiPage(db, '1', 'first content');
-    upsertWikiPage(db, '1', 'updated content');
-    const page = getWikiPage(db, '1');
-    expect(page!.content).toBe('updated content');
-  });
-
-  it('getWikiPage returns null for non-existent community', () => {
-    const page = getWikiPage(db, '999');
-    expect(page).toBeNull();
-  });
-
-  it('listWikiPages returns all stored pages', () => {
-    upsertWikiPage(db, '1', 'page 1');
-    upsertWikiPage(db, '2', 'page 2');
-    const pages = listWikiPages(db);
-    expect(pages).toHaveLength(2);
-    expect(pages.map(p => p.communityId)).toEqual(['1', '2']);
-  });
-
-  it('listWikiPages returns empty array when no pages stored', () => {
-    const pages = listWikiPages(db);
-    expect(pages).toHaveLength(0);
-  });
-});
-
-describe('prompt-builder', () => {
-  it('buildWikiPrompt includes community label and symbols', () => {
-    const prompt = buildWikiPrompt({
-      communityId: '1',
-      label: 'Core Module',
-      topSymbols: [
-        { name: 'doSomething', label: 'Function', filePath: 'src/a.ts' },
-        { name: 'MyService', label: 'Class', filePath: 'src/b.ts' },
-      ],
-      incomingCount: 5,
-      outgoingCount: 3,
-    });
-
-    expect(prompt).toContain('Core Module');
-    expect(prompt).toContain('doSomething');
-    expect(prompt).toContain('MyService');
-    expect(prompt).toContain('src/a.ts');
-    expect(prompt).toContain('5');
-    expect(prompt).toContain('3');
-  });
-
-  it('buildWikiPrompt handles empty symbols', () => {
-    const prompt = buildWikiPrompt({
-      communityId: '42',
-      label: 'Community 42',
-      topSymbols: [],
-      incomingCount: 0,
-      outgoingCount: 0,
-    });
-    expect(prompt).toContain('(none)');
-  });
-});
-
-describe('generateWikiPage', () => {
-  it('calls the llmClient and returns generated content', async () => {
-    const content = await generateWikiPage(db, '1', { llmClient: mockLlmClient });
-    expect(content).toContain('Mock Wiki Page');
-    expect(content).toContain('generated wiki page');
-  });
-
-  it('persists generated content to the DB', async () => {
-    await generateWikiPage(db, '1', { llmClient: mockLlmClient });
-    const page = getWikiPage(db, '1');
-    expect(page).not.toBeNull();
-    expect(page!.content).toContain('Mock Wiki Page');
-  });
-
-  it('passes a non-empty prompt to llmClient', async () => {
-    let capturedPrompt = '';
-    const capturingClient = {
-      generate: async (prompt: string): Promise<string> => {
-        capturedPrompt = prompt;
-        return '# Generated';
-      },
-    };
-    await generateWikiPage(db, '1', { llmClient: capturingClient });
-    expect(capturedPrompt.length).toBeGreaterThan(50);
-    expect(capturedPrompt).toContain('Core Module');
-  });
-
-  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');
-  });
-});
-
-describe('generateAllWikiPages', () => {
-  it('generates pages for all communities', async () => {
-    const result = await generateAllWikiPages(db, { llmClient: mockLlmClient });
-    expect(result.generated).toBe(2);
-    expect(result.skipped).toBe(0);
-    expect(result.errors).toBe(0);
-  });
-
-  it('skips already-generated communities when force=false', async () => {
-    // Pre-generate community 1
-    upsertWikiPage(db, '1', 'existing page');
-
-    const result = await generateAllWikiPages(db, { llmClient: mockLlmClient, force: false });
-    expect(result.skipped).toBe(1);
-    expect(result.generated).toBe(1);
-
-    // Existing page should remain unchanged
-    const page = getWikiPage(db, '1');
-    expect(page!.content).toBe('existing page');
-  });
-
-  it('regenerates all when force=true', async () => {
-    upsertWikiPage(db, '1', 'old content');
-    const result = await generateAllWikiPages(db, { llmClient: mockLlmClient, force: true });
-    expect(result.generated).toBe(2);
-    expect(result.skipped).toBe(0);
-
-    // Should have new content
-    const page = getWikiPage(db, '1');
-    expect(page!.content).toContain('Mock Wiki Page');
-  });
-
-  it('filters by communityId when provided', async () => {
-    const result = await generateAllWikiPages(db, { llmClient: mockLlmClient, communityId: '1' });
-    expect(result.generated).toBe(1);
-    const page1 = getWikiPage(db, '1');
-    const page2 = getWikiPage(db, '2');
-    expect(page1).not.toBeNull();
-    expect(page2).toBeNull();
-  });
-
-  it('counts errors for failed generations', async () => {
-    const failingClient = {
-      generate: async (): Promise<string> => {
-        throw new Error('LLM failure');
-      },
-    };
-    const result = await generateAllWikiPages(db, { llmClient: failingClient });
-    expect(result.errors).toBe(2);
-    expect(result.generated).toBe(0);
-  });
-});

package/src/__tests__/analysis/benchmark.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { runBenchmark, estimateTokens } from '../../analysis/benchmark.js';
-
-function makeDb(nodeCount: number): 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);
-    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
-  `);
-  const insert = db.prepare('INSERT INTO nodes VALUES (?,?,?,?,?,?,?)');
-  for (let i = 0; i < nodeCount; i++) {
-    insert.run(`n${i}`, `symbol_${i}`, 'Function', `/app/file${i % 10}.ts`, i * 5 + 1, i * 5 + 4, i % 3);
-  }
-  for (let i = 1; i < Math.min(nodeCount, 20); i++) {
-    db.prepare('INSERT INTO edges VALUES (?,?,?,?,?,?)').run(`e${i}`, `n${i - 1}`, `n${i}`, 'CALLS', 'EXTRACTED', 0.9);
-  }
-  return db;
-}
-
-describe('estimateTokens', () => {
-  it('estimates tokens as text length divided by 4', () => {
-    expect(estimateTokens('a'.repeat(400))).toBe(100);
-    expect(estimateTokens('')).toBe(0);
-  });
-});
-
-describe('runBenchmark', () => {
-  it('returns corpus_tokens, avg_query_tokens, and reduction_ratio', () => {
-    const db = makeDb(50);
-    const result = runBenchmark(db, { corpusWordCount: 5000 });
-    expect(result.corpus_tokens).toBeGreaterThan(0);
-    expect(result.avg_query_tokens).toBeGreaterThanOrEqual(0);
-    expect(result.reduction_ratio).toBeGreaterThanOrEqual(0);
-    expect(result.nodes).toBe(50);
-  });
-
-  it('returns per_question breakdown', () => {
-    const db = makeDb(30);
-    const result = runBenchmark(db, {
-      questions: ['how does authentication work', 'what is the entry point'],
-      corpusWordCount: 3000,
-    });
-    expect(Array.isArray(result.per_question)).toBe(true);
-  });
-
-  it('works with no matching nodes gracefully', () => {
-    const db = makeDb(5);
-    const result = runBenchmark(db, { questions: ['zzz_nonexistent_xyz'] });
-    expect(result.nodes).toBe(5);
-    expect(typeof result.reduction_ratio).toBe('number');
-  });
-
-  it('uses default questions when none provided', () => {
-    const db = makeDb(20);
-    const result = runBenchmark(db);
-    expect(result.per_question.length).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/analysis/cluster-quality.test.ts

@@ -1,106 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { silhouetteScore, modularityScore } from '../../analysis/cluster-quality.js';
-
-describe('silhouetteScore', () => {
-  it('returns 0 for a single node', () => {
-    const memberships = new Map([['a', 0]]);
-    const edges: Array<{ sourceId: string; targetId: string }> = [];
-    expect(silhouetteScore(memberships, edges)).toBeCloseTo(0);
-  });
-
-  it('returns 1 for two perfectly separated communities with no cross edges', () => {
-    // Community 0: a-b-c fully connected, Community 1: d-e-f fully connected
-    const memberships = new Map([
-      ['a', 0], ['b', 0], ['c', 0],
-      ['d', 1], ['e', 1], ['f', 1],
-    ]);
-    const edges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'b', targetId: 'c' },
-      { sourceId: 'a', targetId: 'c' },
-      { sourceId: 'd', targetId: 'e' },
-      { sourceId: 'e', targetId: 'f' },
-      { sourceId: 'd', targetId: 'f' },
-    ];
-    const score = silhouetteScore(memberships, edges);
-    expect(score).toBeGreaterThan(0.5);
-  });
-
-  it('returns negative score for misassigned nodes (cross edges dominate)', () => {
-    // Node 'a' is in community 0 but only connected to community 1 nodes
-    const memberships = new Map([
-      ['a', 0],
-      ['b', 1], ['c', 1], ['d', 1],
-    ]);
-    const edges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'a', targetId: 'c' },
-      { sourceId: 'a', targetId: 'd' },
-      { sourceId: 'b', targetId: 'c' },
-      { sourceId: 'c', targetId: 'd' },
-    ];
-    const score = silhouetteScore(memberships, edges);
-    // 'a' is isolated in its community, so its silhouette is negative
-    expect(score).toBeLessThan(0.5);
-  });
-
-  it('handles nodes with no edges gracefully', () => {
-    const memberships = new Map([['x', 0], ['y', 1]]);
-    const edges: Array<{ sourceId: string; targetId: string }> = [];
-    const score = silhouetteScore(memberships, edges);
-    expect(typeof score).toBe('number');
-    expect(isNaN(score)).toBe(false);
-  });
-});
-
-describe('modularityScore', () => {
-  it('returns 0 for empty graph', () => {
-    const memberships = new Map<string, number>();
-    const edges: Array<{ sourceId: string; targetId: string }> = [];
-    expect(modularityScore(memberships, edges)).toBeCloseTo(0);
-  });
-
-  it('returns positive value for well-structured communities', () => {
-    // Two dense clusters with few cross edges
-    const memberships = new Map([
-      ['a', 0], ['b', 0], ['c', 0],
-      ['d', 1], ['e', 1], ['f', 1],
-    ]);
-    const edges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'b', targetId: 'c' },
-      { sourceId: 'a', targetId: 'c' },
-      { sourceId: 'd', targetId: 'e' },
-      { sourceId: 'e', targetId: 'f' },
-      { sourceId: 'd', targetId: 'f' },
-      { sourceId: 'c', targetId: 'd' }, // one bridge edge
-    ];
-    const q = modularityScore(memberships, edges);
-    expect(q).toBeGreaterThan(0);
-  });
-
-  it('returns close to 0 or negative for random partition', () => {
-    // All edges cross community boundaries
-    const memberships = new Map([
-      ['a', 0], ['b', 1], ['c', 0], ['d', 1],
-    ]);
-    const edges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'b', targetId: 'c' },
-      { sourceId: 'c', targetId: 'd' },
-      { sourceId: 'd', targetId: 'a' },
-    ];
-    const q = modularityScore(memberships, edges);
-    expect(q).toBeLessThan(0.3);
-  });
-
-  it('handles single-community graph', () => {
-    const memberships = new Map([['a', 0], ['b', 0], ['c', 0]]);
-    const edges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'b', targetId: 'c' },
-    ];
-    const q = modularityScore(memberships, edges);
-    expect(typeof q).toBe('number');
-  });
-});

package/src/__tests__/analysis/corpus-health.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { checkCorpusHealth, type CorpusHealthResult } from '../../analysis/corpus-health.js';
-
-describe('checkCorpusHealth', () => {
-  it('passes for healthy corpus', () => {
-    const r = checkCorpusHealth({ wordCount: 100_000, fileCount: 50 });
-    expect(r.healthy).toBe(true);
-    expect(r.warnings).toHaveLength(0);
-  });
-
-  it('warns when corpus too small', () => {
-    const r = checkCorpusHealth({ wordCount: 10_000, fileCount: 10 });
-    expect(r.healthy).toBe(false);
-    expect(r.warnings.some(w => /small/i.test(w))).toBe(true);
-  });
-
-  it('warns when corpus too large', () => {
-    const r = checkCorpusHealth({ wordCount: 600_000, fileCount: 100 });
-    expect(r.healthy).toBe(false);
-    expect(r.warnings.some(w => /large/i.test(w))).toBe(true);
-  });
-
-  it('warns when file count too high', () => {
-    const r = checkCorpusHealth({ wordCount: 200_000, fileCount: 250 });
-    expect(r.healthy).toBe(false);
-    expect(r.warnings.some(w => /file/i.test(w))).toBe(true);
-  });
-
-  it('collects multiple warnings', () => {
-    const r = checkCorpusHealth({ wordCount: 600_000, fileCount: 300 });
-    expect(r.warnings.length).toBeGreaterThanOrEqual(2);
-  });
-});