anvil-dev-framework 0.1.6

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

@@ -0,0 +1,272 @@
+/**
+ * Integration tests for Anvil Memory hooks
+ *
+ * Tests hook execution as subprocesses with stdin/stdout.
+ * Validates JSON output structure, error handling, and graceful degradation.
+ */
+
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { AnvilMemoryDb } from '../db';
+import { cleanupDb, getTestDbPath, ensureTestDir } from './test-utils';
+
+// Project paths
+const PROJECT_ROOT = join(__dirname, '../../../../..');
+const HOOKS_DIR = join(PROJECT_ROOT, 'global/hooks');
+
+/**
+ * Runs a hook as a subprocess with given stdin input
+ */
+async function runHook(
+  hookName: string,
+  input: Record<string, unknown>,
+  dbPath?: string
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const hookPath = join(HOOKS_DIR, hookName);
+  const inputJson = JSON.stringify(input);
+
+  // Set DB_PATH environment variable if provided
+  const env = { ...process.env };
+  if (dbPath) {
+    env.ANVIL_MEMORY_DB_PATH = dbPath;
+  }
+
+  const proc = Bun.spawn(['bun', 'run', hookPath], {
+    stdin: new Blob([inputJson]),
+    stdout: 'pipe',
+    stderr: 'pipe',
+    cwd: PROJECT_ROOT,
+    env,
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  await proc.exited;
+
+  return {
+    stdout: stdout.trim(),
+    stderr: stderr.trim(),
+    exitCode: proc.exitCode ?? 0,
+  };
+}
+
+describe('anvil_memory_observe hook', () => {
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+  });
+
+  beforeEach(() => {
+    testDbPath = getTestDbPath('hook-observe');
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+    db.close();
+  });
+
+  afterEach(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('outputs empty JSON for skipped tools', async () => {
+    const result = await runHook('anvil_memory_observe.ts', {
+      tool_name: 'Glob',
+      tool_result: 'Some file results',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('outputs empty JSON for empty results', async () => {
+    const result = await runHook('anvil_memory_observe.ts', {
+      tool_name: 'Write',
+      tool_result: '',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('outputs empty JSON for short results', async () => {
+    const result = await runHook('anvil_memory_observe.ts', {
+      tool_name: 'Write',
+      tool_result: 'too short',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('outputs empty JSON without database', async () => {
+    // Use non-existent db path
+    const result = await runHook('anvil_memory_observe.ts', {
+      tool_name: 'Write',
+      tool_input: { file_path: '/test/file.ts' },
+      tool_result: 'File written successfully to /test/file.ts. This is a significant result.',
+    }, '/tmp/nonexistent-db-abc123.db');
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('handles malformed JSON input gracefully', async () => {
+    const hookPath = join(HOOKS_DIR, 'anvil_memory_observe.ts');
+
+    const proc = Bun.spawn(['bun', 'run', hookPath], {
+      stdin: new Blob(['not valid json']),
+      stdout: 'pipe',
+      stderr: 'pipe',
+      cwd: PROJECT_ROOT,
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    expect(proc.exitCode).toBe(0);
+    expect(stdout.trim()).toBe('{}');
+  });
+});
+
+describe('anvil_memory_session hook', () => {
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+  });
+
+  beforeEach(() => {
+    // Create isolated test database for session hook tests
+    testDbPath = getTestDbPath('hook-session');
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+    db.close();
+  });
+
+  afterEach(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('outputs valid JSON response', async () => {
+    // Use isolated test database
+    const result = await runHook('anvil_memory_session.ts', {}, testDbPath);
+
+    expect(result.exitCode).toBe(0);
+    // Should output valid JSON (either {} or {additionalContext: ...})
+    expect(() => JSON.parse(result.stdout)).not.toThrow();
+  });
+
+  test('response has correct structure', async () => {
+    const result = await runHook('anvil_memory_session.ts', {}, testDbPath);
+
+    expect(result.exitCode).toBe(0);
+    const output = JSON.parse(result.stdout);
+    // Should be either empty or have additionalContext
+    if (Object.keys(output).length > 0) {
+      expect(output.additionalContext).toBeDefined();
+      expect(typeof output.additionalContext).toBe('string');
+    }
+  });
+
+  test('handles malformed JSON input gracefully', async () => {
+    const hookPath = join(HOOKS_DIR, 'anvil_memory_session.ts');
+
+    const env = { ...process.env, ANVIL_MEMORY_DB_PATH: testDbPath };
+    const proc = Bun.spawn(['bun', 'run', hookPath], {
+      stdin: new Blob(['{ invalid json']),
+      stdout: 'pipe',
+      stderr: 'pipe',
+      cwd: PROJECT_ROOT,
+      env,
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    expect(proc.exitCode).toBe(0);
+    // Should still output valid JSON (empty or with context)
+    expect(() => JSON.parse(stdout)).not.toThrow();
+  });
+});
+
+describe('anvil_memory_stop hook', () => {
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+  });
+
+  beforeEach(() => {
+    testDbPath = getTestDbPath('hook-stop');
+    const db = new AnvilMemoryDb(testDbPath);
+    db.init();
+    db.close();
+  });
+
+  afterEach(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('outputs empty JSON on success', async () => {
+    const result = await runHook('anvil_memory_stop.ts', {
+      duration_seconds: 300,
+      context_used_percent: 50,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('outputs empty JSON without database', async () => {
+    const result = await runHook('anvil_memory_stop.ts', {}, '/tmp/nonexistent-db-stop123.db');
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('handles empty input', async () => {
+    const result = await runHook('anvil_memory_stop.ts', {});
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('{}');
+  });
+
+  test('handles malformed JSON input gracefully', async () => {
+    const hookPath = join(HOOKS_DIR, 'anvil_memory_stop.ts');
+
+    const proc = Bun.spawn(['bun', 'run', hookPath], {
+      stdin: new Blob(['not json at all']),
+      stdout: 'pipe',
+      stderr: 'pipe',
+      cwd: PROJECT_ROOT,
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    expect(proc.exitCode).toBe(0);
+    expect(stdout.trim()).toBe('{}');
+  });
+});
+
+describe('Hook helper functions', () => {
+  // These tests verify the internal logic by importing the modules directly
+  // We test the main execution flow in the subprocess tests above
+
+  test('hooks exist at expected paths', () => {
+    expect(existsSync(join(HOOKS_DIR, 'anvil_memory_observe.ts'))).toBe(true);
+    expect(existsSync(join(HOOKS_DIR, 'anvil_memory_session.ts'))).toBe(true);
+    expect(existsSync(join(HOOKS_DIR, 'anvil_memory_stop.ts'))).toBe(true);
+  });
+
+  test('hooks are executable', async () => {
+    // Each hook should run and exit cleanly with empty input
+    const hooks = ['anvil_memory_observe.ts', 'anvil_memory_session.ts', 'anvil_memory_stop.ts'];
+
+    for (const hook of hooks) {
+      const result = await runHook(hook, {});
+      expect(result.exitCode).toBe(0);
+    }
+  });
+});

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

@@ -0,0 +1,427 @@
+/**
+ * Performance tests for Anvil Memory Database
+ *
+ * Verifies:
+ * - Query plans use indexes appropriately
+ * - Operations complete in <100ms
+ * - FTS5 queries are optimized
+ * - System scales to 10k+ observations
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { AnvilMemoryDb } from '../db';
+import {
+  cleanupDb,
+  getTestDbPath,
+  ensureTestDir,
+  measureTime,
+  randomType,
+  randomWords,
+} from './test-utils';
+
+describe('Query Plan Analysis', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('perf-query');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    // Add sample data for query plan analysis
+    for (let i = 0; i < 100; i++) {
+      db.createObservation({
+        timestamp: new Date(Date.now() - i * 60000).toISOString(),
+        type: randomType(),
+        title: `Observation ${i}: ${randomWords(3)}`,
+        content: randomWords(20),
+        project: i % 3 === 0 ? 'project-a' : 'project-b',
+        files: [`file${i}.ts`],
+        concepts: [randomWords(1), randomWords(1)],
+      });
+    }
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('getObservation uses PRIMARY KEY index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query('EXPLAIN QUERY PLAN SELECT * FROM observations WHERE id = ?').all(1);
+    const planStr = JSON.stringify(plan);
+
+    // Should use primary key (SEARCH using INTEGER PRIMARY KEY)
+    expect(planStr).toMatch(/SEARCH|PRIMARY/i);
+    expect(planStr).not.toMatch(/SCAN/i);
+  });
+
+  test('getRecentObservations uses timestamp index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query('EXPLAIN QUERY PLAN SELECT * FROM observations ORDER BY timestamp DESC LIMIT ?').all(20);
+
+    // Should use idx_observations_timestamp or be efficient
+    // Note: SQLite may choose SCAN if table is small, which is actually faster
+    expect(plan.length).toBeGreaterThan(0);
+  });
+
+  test('getRecentObservations with type filter uses index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query("EXPLAIN QUERY PLAN SELECT * FROM observations WHERE type IN (?, ?) ORDER BY timestamp DESC LIMIT ?").all('bugfix', 'feature', 20);
+
+    // Query plan should exist; actual index usage depends on table size
+    expect(plan.length).toBeGreaterThan(0);
+  });
+
+  test('getRecentObservations with project filter uses index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query('EXPLAIN QUERY PLAN SELECT * FROM observations WHERE project = ? ORDER BY timestamp DESC LIMIT ?').all('project-a', 20);
+
+    // Query plan should exist; actual index usage depends on table size
+    expect(plan.length).toBeGreaterThan(0);
+  });
+
+  test('searchObservations FTS5 query is optimized', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query(`
+      EXPLAIN QUERY PLAN
+      SELECT o.* FROM observations o
+      JOIN observations_fts fts ON o.id = fts.rowid
+      WHERE observations_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all('database', 20);
+
+    // FTS5 queries should use virtual table efficiently
+    expect(plan.length).toBeGreaterThan(0);
+  });
+
+  test('getSession uses PRIMARY KEY index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query('EXPLAIN QUERY PLAN SELECT * FROM sessions WHERE id = ?').all(1);
+    const planStr = JSON.stringify(plan);
+
+    expect(planStr).toMatch(/SEARCH|PRIMARY/i);
+  });
+
+  test('getCheckpoint uses PRIMARY KEY index', () => {
+    const rawDb = db.getDb();
+    const plan = rawDb.query('EXPLAIN QUERY PLAN SELECT * FROM checkpoints WHERE id = ?').all(1);
+    const planStr = JSON.stringify(plan);
+
+    expect(planStr).toMatch(/SEARCH|PRIMARY/i);
+  });
+});
+
+describe('Operation Timing (<100ms target)', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('perf-timing');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    // Add 1000 observations for timing tests
+    for (let i = 0; i < 1000; i++) {
+      db.createObservation({
+        timestamp: new Date(Date.now() - i * 60000).toISOString(),
+        type: randomType(),
+        title: `Observation ${i}: ${randomWords(3)}`,
+        content: randomWords(50),
+        project: `project-${i % 10}`,
+        files: [`src/file${i}.ts`, `test/file${i}.test.ts`],
+        concepts: [randomWords(1), randomWords(1), randomWords(1)],
+      });
+    }
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('createObservation completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.createObservation({
+        timestamp: new Date().toISOString(),
+        type: 'discovery',
+        title: 'Test observation',
+        content: 'Test content for timing',
+        project: 'test-project',
+      });
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`createObservation: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('getObservation completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.getObservation(500);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`getObservation: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('searchObservations completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.searchObservations('database optimization', 20);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`searchObservations: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('getRecentObservations completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.getRecentObservations(50);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`getRecentObservations: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('getRecentObservations with filters completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.getRecentObservations(50, ['bugfix', 'feature'], 'project-1');
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`getRecentObservations (filtered): ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('createSession completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.createSession({
+        started_at: new Date().toISOString(),
+        project: 'test-project',
+        branch: 'feature/test',
+      });
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`createSession: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('createCheckpoint completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.createCheckpoint({
+        timestamp: new Date().toISOString(),
+        level: 'L1',
+        context_percent: 50,
+      });
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`createCheckpoint: ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('createPrompt completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.createPrompt({
+        timestamp: new Date().toISOString(),
+        content: 'Help me implement a new feature',
+        project: 'test-project',
+      });
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`createPrompt: ${timeMs.toFixed(2)}ms`);
+  });
+});
+
+describe('Scale Testing (10k+ observations)', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('perf-scale');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    console.log('Creating 10,000 observations for scale test...');
+    const startTime = performance.now();
+
+    // Batch insert for faster setup
+    const rawDb = db.getDb();
+    rawDb.exec('BEGIN TRANSACTION');
+
+    for (let i = 0; i < 10000; i++) {
+      db.createObservation({
+        timestamp: new Date(Date.now() - i * 60000).toISOString(),
+        type: randomType(),
+        title: `Scale test observation ${i}: ${randomWords(3)}`,
+        content: randomWords(100),
+        project: `project-${i % 50}`,
+        files: [`src/module${i % 100}/file${i}.ts`],
+        concepts: [randomWords(1), randomWords(1)],
+        work_tokens: Math.floor(Math.random() * 1000),
+      });
+
+      // Log progress every 1000
+      if ((i + 1) % 1000 === 0) {
+        console.log(`  Created ${i + 1} observations...`);
+      }
+    }
+
+    rawDb.exec('COMMIT');
+
+    const setupTime = performance.now() - startTime;
+    console.log(`Setup complete in ${(setupTime / 1000).toFixed(2)}s`);
+  });
+
+  afterAll(() => {
+    db.close();
+    cleanupDb(testDbPath);
+  });
+
+  test('searchObservations at 10k scale completes in <100ms', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.searchObservations('database performance', 20);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`searchObservations (10k): ${timeMs.toFixed(2)}ms, found ${result.length} results`);
+  });
+
+  test('getRecentObservations at 10k scale completes in <100ms', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.getRecentObservations(50);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    expect(result.length).toBe(50);
+    console.log(`getRecentObservations (10k): ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('getRecentObservations with type filter at 10k scale completes in <100ms', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.getRecentObservations(50, ['bugfix', 'feature']);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`getRecentObservations filtered by type (10k): ${timeMs.toFixed(2)}ms, found ${result.length} results`);
+  });
+
+  test('getRecentObservations with project filter at 10k scale completes in <100ms', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.getRecentObservations(50, undefined, 'project-1');
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`getRecentObservations filtered by project (10k): ${timeMs.toFixed(2)}ms, found ${result.length} results`);
+  });
+
+  test('getObservation at 10k scale completes in <100ms', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.getObservation(5000);
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    expect(result).not.toBeNull();
+    console.log(`getObservation (10k): ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('createObservation at 10k scale completes in <100ms', () => {
+    const { timeMs } = measureTime(() => {
+      db.createObservation({
+        timestamp: new Date().toISOString(),
+        type: 'discovery',
+        title: 'New observation at scale',
+        content: 'Content after 10k observations exist',
+        project: 'test-project',
+      });
+    });
+
+    expect(timeMs).toBeLessThan(100);
+    console.log(`createObservation (10k): ${timeMs.toFixed(2)}ms`);
+  });
+
+  test('integrityCheck at 10k scale completes in reasonable time', () => {
+    const { result, timeMs } = measureTime(() => {
+      return db.integrityCheck();
+    });
+
+    expect(result.ok).toBe(true);
+    // Integrity check can take longer, allow up to 1 second
+    expect(timeMs).toBeLessThan(1000);
+    console.log(`integrityCheck (10k): ${timeMs.toFixed(2)}ms`);
+  });
+});
+
+describe('FTS5 Search Quality', () => {
+  let db: AnvilMemoryDb;
+  let testDbPath: string;
+
+  beforeAll(() => {
+    ensureTestDir();
+    testDbPath = getTestDbPath('perf-fts');
+    db = new AnvilMemoryDb(testDbPath);
+    db.init();
+
+    // Add specific observations for search quality testing
+    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('FTS5 finds exact matches', () => {
+    const results = db.searchObservations('FTS5');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.title).toContain('FTS5');
+  });
+
+  test('FTS5 finds stemmed matches', () => {
+    // "searching" should match "search" due to Porter stemmer
+    const results = db.searchObservations('searching');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  test('FTS5 finds matches in concepts', () => {
+    const results = db.searchObservations('jwt');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.concepts).toContain('jwt');
+  });
+
+  test('FTS5 handles multi-word queries', () => {
+    const results = db.searchObservations('database connection');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  test('FTS5 returns results in relevance order', () => {
+    const results = db.searchObservations('database');
+    // Should find multiple results with "database"
+    expect(results.length).toBeGreaterThanOrEqual(2);
+  });
+});