anvil-dev-framework 0.1.6

package/global/tools/anvil-memory/src/__tests__/db.test.ts

@@ -0,0 +1,641 @@
+/**
+ * Unit tests for Anvil Memory Database
+ *
+ * Tests all CRUD operations, FTS5 search, triggers, and integrity.
+ */
+
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
+import { AnvilMemoryDb, getDefaultDbPath, dbExists } from '../db';
+import { existsSync } from 'fs';
+import type { Observation, Session, Checkpoint, RalphIteration, Prompt } from '../types';
+import { cleanupDb, getTestDbPath, ensureTestDir } from './test-utils';
+
+describe('AnvilMemoryDb - Initialization', () => {
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+  });
+
+  beforeEach(() => {
+    testDbPath = getTestDbPath('db-init');
+  });
+
+  afterEach(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('creates new database on init', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    const result = db.init();
+
+    expect(result.created).toBe(true);
+    expect(result.version).toBe(1);
+    expect(existsSync(testDbPath)).toBe(true);
+
+    db.close();
+  });
+
+  test('returns existing version on re-init', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    const result = db.init();
+    expect(result.created).toBe(false);
+    expect(result.version).toBe(1);
+
+    db.close();
+  });
+
+  test('getSchemaVersion returns 0 for new database', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    expect(db.getSchemaVersion()).toBe(0);
+    db.close();
+  });
+
+  test('getSchemaVersion returns version after init', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+    expect(db.getSchemaVersion()).toBe(1);
+    db.close();
+  });
+
+  test('getConfig returns correct info', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    const config = db.getConfig();
+    expect(config.path).toBe(testDbPath);
+    expect(config.migrated).toBe(true);
+    expect(config.version).toBe(1);
+
+    db.close();
+  });
+
+  test('integrityCheck passes on fresh database', () => {
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    const result = db.integrityCheck();
+    expect(result.ok).toBe(true);
+    expect(result.errors).toEqual([]);
+
+    db.close();
+  });
+});
+
+describe('AnvilMemoryDb - Observations CRUD', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-obs');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createObservation returns observation with id', () => {
+    const obs = db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'discovery',
+      title: 'Test discovery',
+      content: 'Testing observation creation',
+    });
+
+    expect(obs.id).toBeDefined();
+    expect(obs.id).toBeGreaterThan(0);
+    expect(obs.type).toBe('discovery');
+    expect(obs.title).toBe('Test discovery');
+  });
+
+  test('createObservation handles all observation types', () => {
+    const types: Observation['type'][] = [
+      'bugfix', 'feature', 'refactor', 'discovery', 'decision',
+      'change', 'checkpoint', 'ralph_iteration', 'handoff',
+      'shard', 'linear_sync', 'session_request',
+    ];
+
+    for (const type of types) {
+      const obs = db.createObservation({
+        timestamp: new Date().toISOString(),
+        type,
+        title: `Test ${type}`,
+        content: `Content for ${type}`,
+      });
+      expect(obs.type).toBe(type);
+    }
+  });
+
+  test('createObservation stores files as JSON array', () => {
+    const obs = db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'feature',
+      title: 'Test with files',
+      content: 'Has files',
+      files: ['src/file1.ts', 'src/file2.ts'],
+    });
+
+    const retrieved = db.getObservation(obs.id!);
+    expect(retrieved?.files).toEqual(['src/file1.ts', 'src/file2.ts']);
+  });
+
+  test('createObservation stores concepts as JSON array', () => {
+    const obs = db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'discovery',
+      title: 'Test with concepts',
+      content: 'Has concepts',
+      concepts: ['database', 'testing'],
+    });
+
+    const retrieved = db.getObservation(obs.id!);
+    expect(retrieved?.concepts).toEqual(['database', 'testing']);
+  });
+
+  test('getObservation returns null for non-existent id', () => {
+    const result = db.getObservation(999999);
+    expect(result).toBeNull();
+  });
+
+  test('getObservation retrieves observation by id', () => {
+    const obs = db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'bugfix',
+      title: 'Test retrieval',
+      content: 'Content to retrieve',
+      project: 'test-project',
+      work_tokens: 500,
+    });
+
+    const retrieved = db.getObservation(obs.id!);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved?.title).toBe('Test retrieval');
+    expect(retrieved?.project).toBe('test-project');
+    expect(retrieved?.work_tokens).toBe(500);
+  });
+
+  test('getRecentObservations returns observations in descending order', () => {
+    // Create observations with clearly different timestamps
+    const now = Date.now();
+    for (let i = 0; i < 5; i++) {
+      db.createObservation({
+        // Use 1 hour intervals to ensure distinct timestamps
+        timestamp: new Date(now - i * 3600000).toISOString(),
+        type: 'discovery',
+        title: `Recent test ${i}`,
+        content: `Content ${i}`,
+      });
+    }
+
+    const recent = db.getRecentObservations(3);
+    expect(recent.length).toBe(3);
+    // Most recent should be first
+    expect(new Date(recent[0]!.timestamp).getTime()).toBeGreaterThanOrEqual(
+      new Date(recent[1]!.timestamp).getTime()
+    );
+  });
+
+  test('getRecentObservations filters by type', () => {
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'bugfix',
+      title: 'Bugfix obs',
+      content: 'Bugfix content',
+    });
+
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'feature',
+      title: 'Feature obs',
+      content: 'Feature content',
+    });
+
+    const bugfixes = db.getRecentObservations(10, ['bugfix']);
+    expect(bugfixes.every(o => o.type === 'bugfix')).toBe(true);
+  });
+
+  test('getRecentObservations filters by project', () => {
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'discovery',
+      title: 'Project A obs',
+      content: 'Content',
+      project: 'project-a',
+    });
+
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'discovery',
+      title: 'Project B obs',
+      content: 'Content',
+      project: 'project-b',
+    });
+
+    const projectA = db.getRecentObservations(10, undefined, 'project-a');
+    expect(projectA.every(o => o.project === 'project-a')).toBe(true);
+  });
+});
+
+describe('AnvilMemoryDb - FTS5 Search', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-fts');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    // Add test observations for search
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'discovery',
+      title: 'SQLite FTS5 full-text search implementation',
+      content: 'Implemented full-text search using FTS5 with Porter stemmer',
+      concepts: ['database', 'search', 'fts5'],
+    });
+
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'bugfix',
+      title: 'Fixed database connection leak',
+      content: 'Resolved issue where database connections were not properly closed',
+      concepts: ['database', 'memory', 'leak'],
+    });
+
+    db.createObservation({
+      timestamp: new Date().toISOString(),
+      type: 'feature',
+      title: 'Added user authentication',
+      content: 'Implemented JWT-based authentication for API endpoints',
+      concepts: ['auth', 'jwt', 'security'],
+    });
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('searchObservations finds exact matches', () => {
+    const results = db.searchObservations('FTS5');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.title).toContain('FTS5');
+  });
+
+  test('searchObservations finds stemmed matches', () => {
+    // "searching" should match "search" due to Porter stemmer
+    const results = db.searchObservations('searching');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  test('searchObservations finds matches in concepts', () => {
+    const results = db.searchObservations('jwt');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.concepts).toContain('jwt');
+  });
+
+  test('searchObservations handles multi-word queries', () => {
+    const results = db.searchObservations('database connection');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  test('searchObservations returns results in relevance order', () => {
+    const results = db.searchObservations('database');
+    // Should find multiple results with "database"
+    expect(results.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('searchObservations returns empty array for no matches', () => {
+    const results = db.searchObservations('xyznonexistent123');
+    expect(results).toEqual([]);
+  });
+
+  test('searchObservations respects limit', () => {
+    const results = db.searchObservations('database', 1);
+    expect(results.length).toBe(1);
+  });
+});
+
+describe('AnvilMemoryDb - Sessions CRUD', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-session');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createSession returns session with id', () => {
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+    });
+
+    expect(session.id).toBeDefined();
+    expect(session.id).toBeGreaterThan(0);
+    expect(session.project).toBe('test-project');
+  });
+
+  test('createSession stores optional fields', () => {
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+      branch: 'feature/test',
+      git_hash: 'abc123',
+    });
+
+    const retrieved = db.getSession(session.id!);
+    expect(retrieved?.branch).toBe('feature/test');
+    expect(retrieved?.git_hash).toBe('abc123');
+  });
+
+  test('getSession returns null for non-existent id', () => {
+    const result = db.getSession(999999);
+    expect(result).toBeNull();
+  });
+
+  test('endSession updates session', () => {
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+    });
+
+    db.endSession(session.id!, 'Session summary', 75);
+
+    const retrieved = db.getSession(session.id!);
+    expect(retrieved?.ended_at).toBeDefined();
+    expect(retrieved?.summary).toBe('Session summary');
+    expect(retrieved?.context_peak_percent).toBe(75);
+  });
+
+  test('endSession handles null summary (FTS5 trigger fix)', () => {
+    // This tests the FTS5 trigger fix - ending a session without summary should not error
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+    });
+
+    // End without summary first
+    db.endSession(session.id!);
+
+    const retrieved = db.getSession(session.id!);
+    expect(retrieved?.ended_at).toBeDefined();
+
+    // Now add summary (should trigger sessions_au_insert)
+    db.endSession(session.id!, 'Late summary', 80);
+
+    const updated = db.getSession(session.id!);
+    expect(updated?.summary).toBe('Late summary');
+  });
+
+  test('session with initial summary can be updated', () => {
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+      summary: 'Initial summary',
+    });
+
+    // Update summary (should trigger sessions_au)
+    db.endSession(session.id!, 'Updated summary', 90);
+
+    const retrieved = db.getSession(session.id!);
+    expect(retrieved?.summary).toBe('Updated summary');
+  });
+});
+
+describe('AnvilMemoryDb - Checkpoints CRUD', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-checkpoint');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createCheckpoint returns checkpoint with id', () => {
+    const checkpoint = db.createCheckpoint({
+      timestamp: new Date().toISOString(),
+      level: 'L1',
+      context_percent: 50,
+    });
+
+    expect(checkpoint.id).toBeDefined();
+    expect(checkpoint.id).toBeGreaterThan(0);
+    expect(checkpoint.level).toBe('L1');
+  });
+
+  test('createCheckpoint handles all levels', () => {
+    const levels: Checkpoint['level'][] = ['L1', 'L2', 'L3'];
+
+    for (const level of levels) {
+      const checkpoint = db.createCheckpoint({
+        timestamp: new Date().toISOString(),
+        level,
+        context_percent: 60,
+      });
+      expect(checkpoint.level).toBe(level);
+    }
+  });
+
+  test('createCheckpoint stores optional fields', () => {
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+    });
+
+    const checkpoint = db.createCheckpoint({
+      timestamp: new Date().toISOString(),
+      level: 'L2',
+      context_percent: 80,
+      handoff_file: '.claude/handoffs/test.md',
+      session_id: session.id,
+      resumed: true,
+    });
+
+    const retrieved = db.getCheckpoint(checkpoint.id!);
+    expect(retrieved?.handoff_file).toBe('.claude/handoffs/test.md');
+    expect(retrieved?.session_id).toBe(session.id);
+    expect(retrieved?.resumed).toBe(true);
+  });
+
+  test('getCheckpoint returns null for non-existent id', () => {
+    const result = db.getCheckpoint(999999);
+    expect(result).toBeNull();
+  });
+});
+
+describe('AnvilMemoryDb - Ralph Iterations CRUD', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-ralph');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createRalphIteration returns iteration with id', () => {
+    const iteration = db.createRalphIteration({
+      session_id: 'ralph-session-123',
+      iteration: 1,
+      started_at: new Date().toISOString(),
+      status: 'running',
+    });
+
+    expect(iteration.id).toBeDefined();
+    expect(iteration.id).toBeGreaterThan(0);
+    expect(iteration.session_id).toBe('ralph-session-123');
+    expect(iteration.status).toBe('running');
+  });
+
+  test('createRalphIteration handles all statuses', () => {
+    const statuses: RalphIteration['status'][] = ['running', 'completed', 'failed', 'checkpointed'];
+
+    for (const status of statuses) {
+      const iteration = db.createRalphIteration({
+        session_id: `ralph-${status}`,
+        iteration: 1,
+        started_at: new Date().toISOString(),
+        status,
+      });
+      expect(iteration.status).toBe(status);
+    }
+  });
+
+  test('updateRalphIteration updates fields', () => {
+    const iteration = db.createRalphIteration({
+      session_id: 'ralph-update-test',
+      iteration: 1,
+      started_at: new Date().toISOString(),
+      status: 'running',
+    });
+
+    db.updateRalphIteration(iteration.id!, {
+      ended_at: new Date().toISOString(),
+      status: 'completed',
+      items_completed: 10,
+      items_total: 10,
+    });
+
+    // Verify using getRalphIteration method
+    const retrieved = db.getRalphIteration(iteration.id!);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved?.status).toBe('completed');
+    expect(retrieved?.items_completed).toBe(10);
+  });
+
+  test('getRalphIteration returns null for non-existent id', () => {
+    const result = db.getRalphIteration(999999);
+    expect(result).toBeNull();
+  });
+});
+
+describe('AnvilMemoryDb - Prompts CRUD', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('db-prompt');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    // Add prompts for search tests
+    db.createPrompt({
+      timestamp: new Date().toISOString(),
+      content: 'Help me implement a new feature for user authentication',
+      project: 'test-project',
+    });
+
+    db.createPrompt({
+      timestamp: new Date().toISOString(),
+      content: 'Fix the database connection pooling issue',
+      project: 'test-project',
+    });
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createPrompt returns prompt with id', () => {
+    const prompt = db.createPrompt({
+      timestamp: new Date().toISOString(),
+      content: 'Test prompt content',
+      project: 'test-project',
+    });
+
+    expect(prompt.id).toBeDefined();
+    expect(prompt.id).toBeGreaterThan(0);
+    expect(prompt.content).toBe('Test prompt content');
+  });
+
+  test('searchPrompts finds matching prompts', () => {
+    const results = db.searchPrompts('authentication');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.content).toContain('authentication');
+  });
+
+  test('searchPrompts uses FTS5 stemming', () => {
+    // "connecting" should match "connection"
+    const results = db.searchPrompts('connecting');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  test('searchPrompts returns empty array for no matches', () => {
+    const results = db.searchPrompts('xyznonexistent456');
+    expect(results).toEqual([]);
+  });
+});
+
+describe('AnvilMemoryDb - Utility Functions', () => {
+  test('getDefaultDbPath returns expected path', () => {
+    const path = getDefaultDbPath();
+    expect(path).toContain('.anvil');
+    expect(path).toContain('memory.db');
+  });
+
+  test('dbExists returns false for non-existent database', () => {
+    expect(dbExists('/tmp/nonexistent-db-12345.db')).toBe(false);
+  });
+
+  test('dbExists returns true for existing database', () => {
+    ensureTestDir();
+    const testPath = getTestDbPath('db-exists');
+    const db = new AnvilMemoryDb(testPath);
+    db.init();
+    db.close();
+
+    expect(dbExists(testPath)).toBe(true);
+
+    cleanupDb(testPath);
+  });
+});