@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/cli/augment.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, existsSync, unlinkSync } from 'fs';
-
-// Mock the db and search modules so tests don't require a real indexed repo
-vi.mock('../../src/storage/db.js', () => ({
-  openDb: vi.fn(),
-  closeDb: vi.fn(),
-}));
-
-vi.mock('../../src/search/hybrid-query.js', () => ({
-  hybridQuery: vi.fn(),
-}));
-
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { hybridQuery } from '../../src/search/hybrid-query.js';
-import { augmentContext } from '../../src/cli/augment.js';
-import type { HybridResult } from '../../src/search/hybrid-query.js';
-
-const mockDb = {} as ReturnType<typeof openDb>;
-
-const sampleResults: HybridResult[] = [
-  {
-    id: 'n1',
-    label: 'Function',
-    name: 'parseFile',
-    normLabel: 'parsefile',
-    filePath: 'src/pipeline/phases/parse.ts',
-    score: 0.95,
-  },
-  {
-    id: 'n2',
-    label: 'Class',
-    name: 'ExtractionCache',
-    normLabel: 'extractioncache',
-    filePath: 'src/cache/extraction-cache.ts',
-    score: 0.82,
-  },
-];
-
-beforeEach(() => {
-  vi.mocked(openDb).mockReturnValue(mockDb);
-  vi.mocked(closeDb).mockImplementation(() => {});
-  vi.mocked(hybridQuery).mockResolvedValue(sampleResults);
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('augmentContext', () => {
-  const repoPath = join(tmpdir(), 'augment-test-repo');
-
-  it('returns a non-empty string for a simple query', async () => {
-    const result = await augmentContext({ query: 'parse file', repoPath });
-    expect(typeof result).toBe('string');
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  it('markdown output contains a heading and node names', async () => {
-    const result = await augmentContext({ query: 'parse file', repoPath, format: 'markdown' });
-    expect(result).toContain('## Relevant Code Context');
-    expect(result).toContain('parseFile');
-    expect(result).toContain('ExtractionCache');
-  });
-
-  it('markdown output contains file paths', async () => {
-    const result = await augmentContext({ query: 'parse file', repoPath, format: 'markdown' });
-    expect(result).toContain('src/pipeline/phases/parse.ts');
-    expect(result).toContain('src/cache/extraction-cache.ts');
-  });
-
-  it('format: json returns valid JSON', async () => {
-    const result = await augmentContext({ query: 'parse file', repoPath, format: 'json' });
-    let parsed: unknown;
-    expect(() => { parsed = JSON.parse(result); }).not.toThrow();
-    const obj = parsed as Record<string, unknown>;
-    expect(obj).toHaveProperty('query', 'parse file');
-    expect(Array.isArray(obj['results'])).toBe(true);
-  });
-
-  it('format: json includes result fields', async () => {
-    const result = await augmentContext({ query: 'cache', repoPath, format: 'json' });
-    const obj = JSON.parse(result) as { results: unknown[] };
-    expect(obj.results.length).toBe(2);
-    const first = obj.results[0] as Record<string, unknown>;
-    expect(first).toHaveProperty('id');
-    expect(first).toHaveProperty('name');
-    expect(first).toHaveProperty('filePath');
-    expect(first).toHaveProperty('score');
-  });
-
-  it('topK: 0 returns empty context without calling hybridQuery', async () => {
-    const result = await augmentContext({ query: 'anything', repoPath, topK: 0 });
-    expect(result).toBe('');
-    expect(hybridQuery).not.toHaveBeenCalled();
-  });
-
-  it('topK: 0 with json format returns valid JSON with empty results', async () => {
-    const result = await augmentContext({ query: 'anything', repoPath, topK: 0, format: 'json' });
-    const obj = JSON.parse(result) as { results: unknown[] };
-    expect(obj.results).toHaveLength(0);
-  });
-
-  it('empty query returns empty string', async () => {
-    const result = await augmentContext({ query: '', repoPath });
-    expect(result).toBe('');
-    expect(hybridQuery).not.toHaveBeenCalled();
-  });
-
-  it('passes topK as limit to hybridQuery', async () => {
-    await augmentContext({ query: 'test', repoPath, topK: 5 });
-    expect(hybridQuery).toHaveBeenCalledWith(mockDb, 'test', { limit: 5 });
-  });
-
-  it('when hybridQuery returns empty results, returns no-results message', async () => {
-    vi.mocked(hybridQuery).mockResolvedValueOnce([]);
-    const result = await augmentContext({ query: 'unknown_xyz', repoPath, format: 'markdown' });
-    expect(result).toContain('No relevant code context found');
-  });
-
-  it('opens and closes the DB even when hybridQuery throws', async () => {
-    vi.mocked(hybridQuery).mockRejectedValueOnce(new Error('db error'));
-    await expect(augmentContext({ query: 'test', repoPath })).rejects.toThrow('db error');
-    expect(closeDb).toHaveBeenCalledWith(mockDb);
-  });
-});

package/__tests__/cli/doctor.test.ts

@@ -1,125 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import { runDoctor } from '../../src/cli/doctor.js';
-
-let tempDir: string;
-
-beforeEach(async () => {
-  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'monograph-doctor-'));
-});
-
-afterEach(async () => {
-  await fs.rm(tempDir, { recursive: true, force: true });
-});
-
-describe('runDoctor', () => {
-  it('returns a DoctorResult with checks array and healthy boolean', async () => {
-    const result = await runDoctor(tempDir);
-
-    expect(result).toHaveProperty('checks');
-    expect(result).toHaveProperty('healthy');
-    expect(Array.isArray(result.checks)).toBe(true);
-    expect(typeof result.healthy).toBe('boolean');
-  });
-
-  it('each check has name, status, and message fields', async () => {
-    const result = await runDoctor(tempDir);
-
-    for (const check of result.checks) {
-      expect(check).toHaveProperty('name');
-      expect(check).toHaveProperty('status');
-      expect(check).toHaveProperty('message');
-      expect(['ok', 'warn', 'error']).toContain(check.status);
-    }
-  });
-
-  it('Node version check passes on the current Node.js runtime', async () => {
-    const result = await runDoctor(tempDir);
-
-    const nodeCheck = result.checks.find((c) => c.name === 'Node version');
-    expect(nodeCheck).toBeDefined();
-    // The test environment must run Node >= 18 (CI requirement)
-    expect(nodeCheck!.status).toBe('ok');
-    expect(nodeCheck!.message).toMatch(/^v\d+\.\d+\.\d+/);
-  });
-
-  it('returns an error check for missing DB file', async () => {
-    // No .monomind/monograph.db present in tempDir
-    const result = await runDoctor(tempDir);
-
-    const dbCheck = result.checks.find((c) => c.name === 'SQLite DB exists');
-    expect(dbCheck).toBeDefined();
-    expect(dbCheck!.status).toBe('error');
-  });
-
-  it('is not healthy when DB is missing', async () => {
-    const result = await runDoctor(tempDir);
-    expect(result.healthy).toBe(false);
-  });
-
-  it('marks dependent checks as error when DB is missing', async () => {
-    const result = await runDoctor(tempDir);
-
-    const readableCheck = result.checks.find((c) => c.name === 'SQLite DB readable');
-    const countCheck = result.checks.find((c) => c.name === 'DB node count');
-
-    expect(readableCheck).toBeDefined();
-    expect(countCheck).toBeDefined();
-    // Both should be errors (skipped due to missing DB)
-    expect(readableCheck!.status).toBe('error');
-    expect(countCheck!.status).toBe('error');
-  });
-
-  it('includes a disk space check', async () => {
-    const result = await runDoctor(tempDir);
-
-    const diskCheck = result.checks.find((c) => c.name === 'Disk space');
-    expect(diskCheck).toBeDefined();
-    // Disk check is either ok or warn (never errors out — platform-safe)
-    expect(['ok', 'warn']).toContain(diskCheck!.status);
-  });
-
-  it('includes a tree-sitter check', async () => {
-    const result = await runDoctor(tempDir);
-
-    const tsCheck = result.checks.find((c) => c.name === 'Tree-sitter');
-    expect(tsCheck).toBeDefined();
-    expect(['ok', 'warn']).toContain(tsCheck!.status);
-  });
-
-  it('is healthy when DB exists and is readable with nodes', async () => {
-    // Create a minimal SQLite DB with a nodes table and one row
-    const monomindDir = path.join(tempDir, '.monomind');
-    await fs.mkdir(monomindDir, { recursive: true });
-    const dbPath = path.join(monomindDir, 'monograph.db');
-
-    const Database = (await import('better-sqlite3')).default;
-    const db = new Database(dbPath);
-    db.exec(`
-      CREATE TABLE nodes (
-        id TEXT PRIMARY KEY,
-        label TEXT,
-        name TEXT,
-        file_path TEXT,
-        community_id INTEGER
-      );
-      CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
-      CREATE TABLE index_meta (key TEXT PRIMARY KEY, value TEXT);
-      CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(id, name, label, file_path, content=nodes, content_rowid=rowid);
-      CREATE TABLE IF NOT EXISTS wiki_pages (id TEXT PRIMARY KEY);
-      CREATE TABLE IF NOT EXISTS embeddings (node_id TEXT PRIMARY KEY);
-      CREATE TABLE IF NOT EXISTS communities (id INTEGER PRIMARY KEY, label TEXT);
-    `);
-    db.prepare("INSERT INTO nodes (id, label, name) VALUES ('n1', 'Function', 'main')").run();
-    db.close();
-
-    const result = await runDoctor(tempDir);
-
-    expect(result.healthy).toBe(true);
-    const nodeCheck = result.checks.find((c) => c.name === 'DB node count');
-    expect(nodeCheck!.status).toBe('ok');
-    expect(nodeCheck!.message).toContain('1 nodes');
-  });
-});

package/__tests__/cli/eval-server.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { createEvalServer } from '../../src/cli/eval-server.js';
-import { openDb, closeDb } from '../../src/storage/db.js';
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function makeTempRepo(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'monograph-eval-'));
-  const monographDir = path.join(dir, '.monograph');
-  fs.mkdirSync(monographDir, { recursive: true });
-
-  // Create a minimal valid monograph DB
-  const db = openDb(path.join(monographDir, 'graph.db'));
-  closeDb(db);
-
-  return dir;
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('createEvalServer', () => {
-  let repoDir: string;
-  let port: number;
-  let baseUrl: string;
-  let handle: ReturnType<typeof createEvalServer>;
-
-  beforeAll(async () => {
-    repoDir = makeTempRepo();
-    port = 47820; // unlikely to be in use
-    handle = createEvalServer(repoDir, port);
-    await handle.start(port);
-    baseUrl = `http://127.0.0.1:${port}`;
-  });
-
-  afterAll(() => {
-    handle.stop();
-    fs.rmSync(repoDir, { recursive: true, force: true });
-  });
-
-  it('returns an object with app, start, and stop', () => {
-    expect(handle).toHaveProperty('app');
-    expect(typeof handle.start).toBe('function');
-    expect(typeof handle.stop).toBe('function');
-  });
-
-  it('app is an Express application', () => {
-    // Express apps are functions with a `listen` method
-    expect(typeof handle.app).toBe('function');
-    expect(typeof (handle.app as any).listen).toBe('function');
-  });
-
-  it('GET /health returns { status: "ok" } with nodeCount and edgeCount', async () => {
-    const res = await fetch(`${baseUrl}/health`);
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body['status']).toBe('ok');
-    expect(typeof body['nodeCount']).toBe('number');
-    expect(typeof body['edgeCount']).toBe('number');
-  });
-
-  it('POST /query with { q: "test" } returns { results: [] } on empty DB', async () => {
-    const res = await fetch(`${baseUrl}/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ q: 'test' }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body).toHaveProperty('results');
-    expect(Array.isArray(body['results'])).toBe(true);
-    expect((body['results'] as unknown[]).length).toBe(0);
-  });
-
-  it('POST /search with { query: "test" } returns { results: [] } on empty DB', async () => {
-    const res = await fetch(`${baseUrl}/search`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query: 'test' }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body).toHaveProperty('results');
-    expect(Array.isArray(body['results'])).toBe(true);
-    expect((body['results'] as unknown[]).length).toBe(0);
-  });
-});

package/__tests__/cli/setup.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import { setupMonograph } from '../../src/cli/setup.js';
-
-let tempDir: string;
-
-beforeEach(async () => {
-  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'monograph-setup-'));
-});
-
-afterEach(async () => {
-  await fs.rm(tempDir, { recursive: true, force: true });
-});
-
-// ─── CLAUDE.md ────────────────────────────────────────────────────────────────
-
-describe('setupMonograph — CLAUDE.md', () => {
-  it('creates CLAUDE.md when it does not exist', async () => {
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'CLAUDE.md'), 'utf-8');
-    expect(content).toContain('@monoes/monograph');
-    expect(content).toContain('mcpServers');
-    expect(result.configured).toContain('CLAUDE.md');
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('appends to existing CLAUDE.md without overwriting existing content', async () => {
-    const existing = '# My Project\n\nSome instructions here.\n';
-    await fs.writeFile(path.join(tempDir, 'CLAUDE.md'), existing, 'utf-8');
-
-    await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'CLAUDE.md'), 'utf-8');
-    expect(content).toContain('# My Project');
-    expect(content).toContain('Some instructions here.');
-    expect(content).toContain('@monoes/monograph');
-  });
-
-  it('is idempotent — running twice does not duplicate the block', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-    await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'CLAUDE.md'), 'utf-8');
-    const occurrences = (content.match(/@monoes\/monograph/g) ?? []).length;
-    expect(occurrences).toBe(1);
-  });
-
-  it('marks file as skipped on second run', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-
-    expect(result.skipped).toContain('CLAUDE.md');
-    expect(result.configured).not.toContain('CLAUDE.md');
-  });
-
-  it('injects valid JSON in a fenced code block', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['claude'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'CLAUDE.md'), 'utf-8');
-    const match = content.match(/```json\n([\s\S]*?)```/);
-    expect(match).not.toBeNull();
-    const parsed = JSON.parse(match![1]);
-    expect(parsed.mcpServers.monograph.command).toBe('npx');
-    expect(parsed.mcpServers.monograph.args).toEqual(['@monoes/monograph', 'mcp']);
-  });
-});
-
-// ─── .cursor/mcp.json ────────────────────────────────────────────────────────
-
-describe('setupMonograph — .cursor/mcp.json', () => {
-  it('creates .cursor/mcp.json when the directory does not exist', async () => {
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-
-    const filePath = path.join(tempDir, '.cursor', 'mcp.json');
-    const content = await fs.readFile(filePath, 'utf-8');
-    const parsed = JSON.parse(content);
-
-    expect(parsed.mcpServers.monograph.command).toBe('npx');
-    expect(parsed.mcpServers.monograph.args).toEqual(['@monoes/monograph', 'mcp']);
-    expect(result.configured).toContain('.cursor/mcp.json');
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('preserves existing mcpServers when merging', async () => {
-    const cursorDir = path.join(tempDir, '.cursor');
-    await fs.mkdir(cursorDir, { recursive: true });
-    await fs.writeFile(
-      path.join(cursorDir, 'mcp.json'),
-      JSON.stringify({ mcpServers: { other: { command: 'keep-me' } } }, null, 2),
-      'utf-8',
-    );
-
-    await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-
-    const content = await fs.readFile(path.join(cursorDir, 'mcp.json'), 'utf-8');
-    const parsed = JSON.parse(content);
-
-    expect(parsed.mcpServers.other).toEqual({ command: 'keep-me' });
-    expect(parsed.mcpServers.monograph).toBeDefined();
-  });
-
-  it('is idempotent — running twice does not duplicate the entry', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-    await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-
-    const content = await fs.readFile(path.join(tempDir, '.cursor', 'mcp.json'), 'utf-8');
-    const parsed = JSON.parse(content);
-    const monographEntries = Object.keys(parsed.mcpServers).filter((k) => k === 'monograph');
-    expect(monographEntries).toHaveLength(1);
-  });
-
-  it('marks file as skipped on second run', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-
-    expect(result.skipped).toContain('.cursor/mcp.json');
-    expect(result.configured).not.toContain('.cursor/mcp.json');
-  });
-
-  it('leaves a corrupt JSON file untouched and reports an error', async () => {
-    const cursorDir = path.join(tempDir, '.cursor');
-    await fs.mkdir(cursorDir, { recursive: true });
-    const corrupt = '{ "mcpServers": broken !!!';
-    await fs.writeFile(path.join(cursorDir, 'mcp.json'), corrupt, 'utf-8');
-
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['cursor'] });
-
-    const content = await fs.readFile(path.join(cursorDir, 'mcp.json'), 'utf-8');
-    expect(content).toBe(corrupt);
-    expect(result.errors.length).toBeGreaterThan(0);
-    expect(result.errors[0]).toContain('.cursor/mcp.json');
-  });
-});
-
-// ─── AGENTS.md ────────────────────────────────────────────────────────────────
-
-describe('setupMonograph — AGENTS.md', () => {
-  it('creates AGENTS.md when it does not exist', async () => {
-    const result = await setupMonograph({ repoPath: tempDir, tools: ['agents-md'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-    expect(content).toContain('@monoes/monograph');
-    expect(result.configured).toContain('AGENTS.md');
-  });
-
-  it('is idempotent — running twice does not duplicate the block', async () => {
-    await setupMonograph({ repoPath: tempDir, tools: ['agents-md'] });
-    await setupMonograph({ repoPath: tempDir, tools: ['agents-md'] });
-
-    const content = await fs.readFile(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-    const occurrences = (content.match(/@monoes\/monograph/g) ?? []).length;
-    expect(occurrences).toBe(1);
-  });
-});
-
-// ─── All tools together ───────────────────────────────────────────────────────
-
-describe('setupMonograph — all tools (default)', () => {
-  it('configures all three targets when no tools option is provided', async () => {
-    const result = await setupMonograph({ repoPath: tempDir });
-
-    expect(result.configured).toContain('CLAUDE.md');
-    expect(result.configured).toContain('.cursor/mcp.json');
-    expect(result.configured).toContain('AGENTS.md');
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('returns empty configured array when all targets are already present', async () => {
-    await setupMonograph({ repoPath: tempDir });
-    const result = await setupMonograph({ repoPath: tempDir });
-
-    expect(result.configured).toHaveLength(0);
-    expect(result.skipped).toHaveLength(3);
-  });
-});