cognitive-core 0.2.4 → 0.3.1

package/tests/persistence/sqlite-persistence.test.ts

@@ -1,635 +0,0 @@
-/**
- * Tests for SqlitePersistence — unified SQLite database.
- *
- * Uses :memory: databases (via tmp directories) for isolation.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { SqlitePersistence, createSqlitePersistence } from '../../src/persistence/sqlite-persistence.js';
-import type { Experience } from '../../src/types/memory.js';
-import type { Playbook } from '../../src/types/playbook.js';
-import type { ReflexionEpisode } from '../../src/types/memory.js';
-import type { MetaObservation, MetaStrategy } from '../../src/types/meta.js';
-
-// ============================================================================
-// Test data factories
-// ============================================================================
-
-function createTestExperience(overrides: Partial<Experience> = {}): Experience {
-  return {
-    id: 'exp-1',
-    taskInput: 'Fix the login bug',
-    solutionOutput: 'Updated auth middleware',
-    feedback: 'Works well',
-    success: true,
-    domain: 'code',
-    trajectoryId: 'traj-1',
-    usageCount: 0,
-    accessScore: 0,
-    retrievalCount: 0,
-    tier: 'hot',
-    metadata: {},
-    createdAt: new Date('2024-01-01'),
-    ...overrides,
-  };
-}
-
-function createTestPlaybook(overrides: Partial<Playbook> = {}): Playbook {
-  return {
-    id: 'pb-1',
-    name: 'Error Handling Strategy',
-    applicability: {
-      situations: ['error handling'],
-      triggers: ['try-catch needed'],
-      antiPatterns: ['silent catch'],
-      domains: ['code'],
-    },
-    guidance: {
-      strategy: 'Use structured error handling',
-      tactics: ['validate inputs', 'log errors'],
-    },
-    verification: {
-      successIndicators: ['no unhandled errors'],
-      failureIndicators: ['silent failures'],
-    },
-    evolution: {
-      version: '1.0.0',
-      createdFrom: ['traj-1'],
-      failures: [],
-      refinements: [],
-      successCount: 3,
-      failureCount: 1,
-    },
-    confidence: 0.75,
-    complexity: 'moderate',
-    estimatedEffort: 3,
-    createdAt: new Date('2024-01-01'),
-    updatedAt: new Date('2024-01-02'),
-    ...overrides,
-  };
-}
-
-function createTestReflexion(overrides: Partial<ReflexionEpisode> = {}): ReflexionEpisode {
-  return {
-    id: 'ref-1',
-    trajectoryId: 'traj-1',
-    taskSummary: 'Fixed auth bug',
-    outcome: 'success',
-    selfCritique: 'Could have been faster',
-    keyInsights: ['check middleware first'],
-    strategyAssessment: 'good approach',
-    suggestedPlaybookUpdates: [],
-    domain: 'code',
-    createdAt: new Date('2024-01-01'),
-    ...overrides,
-  };
-}
-
-function createTestMetaObservation(overrides: Partial<MetaObservation> = {}): MetaObservation {
-  return {
-    id: 'obs-1',
-    trajectoryId: 'traj-1',
-    routing: { decision: 'adapt', confidence: 0.8, reasoning: 'similar past experience' },
-    memoryUsage: { experiencesRetrieved: 3, playbooksApplied: ['pb-1'], retrievalQuality: 'helpful' },
-    execution: { decompositionUsed: false, refinementIterations: 1, backtrackingOccurred: false, toolsUsed: ['grep'] },
-    outcome: { success: true, quality: 'good', effortActual: 5, effortEstimate: 8 },
-    lessons: { whatWorked: ['experience retrieval'], whatFailed: [], suggestions: [] },
-    timestamp: new Date('2024-01-01'),
-    ...overrides,
-  };
-}
-
-function createTestMetaStrategy(overrides: Partial<MetaStrategy> = {}): MetaStrategy {
-  return {
-    id: 'strat-1',
-    name: 'Experience-heavy retrieval',
-    condition: { taskCharacteristics: ['familiar domain'], memoryState: ['many experiences'] },
-    adjustment: {
-      routingBias: { adapt: 0.2 },
-      retrievalModification: 'expand query',
-      executionHint: 'prefer decomposition',
-    },
-    applicationCount: 5,
-    successRate: 0.8,
-    createdAt: new Date('2024-01-01'),
-    updatedAt: new Date('2024-01-02'),
-    ...overrides,
-  };
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('SqlitePersistence', () => {
-  let persistence: SqlitePersistence;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'atlas-test-'));
-    persistence = createSqlitePersistence({ baseDir: tmpDir });
-    await persistence.init();
-  });
-
-  afterEach(() => {
-    persistence.close();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // --------------------------------------------------------------------------
-  // Init & lifecycle
-  // --------------------------------------------------------------------------
-
-  describe('initialization', () => {
-    it('should create the database file', () => {
-      expect(persistence.isInitialized).toBe(true);
-    });
-
-    it('should be idempotent (calling init twice is safe)', async () => {
-      await persistence.init();
-      expect(persistence.isInitialized).toBe(true);
-    });
-
-    it('should report dbPath', () => {
-      expect(persistence.dbPath).toContain('cognitive-core.db');
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Schema version
-  // --------------------------------------------------------------------------
-
-  describe('schema version', () => {
-    it('should default to 0 when no version set', () => {
-      expect(persistence.getSchemaVersion()).toBe(0);
-    });
-
-    it('should track schema versions', () => {
-      persistence.setSchemaVersion(1);
-      expect(persistence.getSchemaVersion()).toBe(1);
-
-      persistence.setSchemaVersion(2);
-      expect(persistence.getSchemaVersion()).toBe(2);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Experiences CRUD
-  // --------------------------------------------------------------------------
-
-  describe('experiences', () => {
-    it('should insert and retrieve an experience', () => {
-      const exp = createTestExperience();
-      persistence.insertExperience(exp);
-
-      const row = persistence.getExperience('exp-1');
-      expect(row).toBeDefined();
-      expect(row!.id).toBe('exp-1');
-      expect(row!.task_input).toBe('Fix the login bug');
-      expect(row!.success).toBe(1); // boolean → integer
-      expect(row!.domain).toBe('code');
-      expect(row!.tier).toBe('hot');
-    });
-
-    it('should return undefined for missing experience', () => {
-      expect(persistence.getExperience('nonexistent')).toBeUndefined();
-    });
-
-    it('should get all experiences', () => {
-      persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
-      persistence.insertExperience(createTestExperience({ id: 'exp-2', domain: 'data' }));
-
-      const all = persistence.getAllExperiences();
-      expect(all).toHaveLength(2);
-    });
-
-    it('should filter by domain', () => {
-      persistence.insertExperience(createTestExperience({ id: 'exp-1', domain: 'code' }));
-      persistence.insertExperience(createTestExperience({ id: 'exp-2', domain: 'data' }));
-
-      const codeExps = persistence.getExperiencesByDomain('code');
-      expect(codeExps).toHaveLength(1);
-      expect(codeExps[0].id).toBe('exp-1');
-    });
-
-    it('should filter by trajectory', () => {
-      persistence.insertExperience(createTestExperience({ id: 'exp-1', trajectoryId: 'traj-1' }));
-      persistence.insertExperience(createTestExperience({ id: 'exp-2', trajectoryId: 'traj-2' }));
-
-      const results = persistence.getExperiencesByTrajectory('traj-1');
-      expect(results).toHaveLength(1);
-    });
-
-    it('should get experience IDs for inverted index', () => {
-      persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
-      persistence.insertExperience(createTestExperience({ id: 'exp-2' }));
-
-      const ids = persistence.getExperienceIds();
-      expect(ids).toHaveLength(2);
-      expect(ids[0]).toHaveProperty('id');
-      expect(ids[0]).toHaveProperty('task_input');
-    });
-
-    it('should update an experience', () => {
-      persistence.insertExperience(createTestExperience());
-
-      persistence.updateExperience('exp-1', { usageCount: 5, tier: 'warm' });
-
-      const row = persistence.getExperience('exp-1');
-      expect(row!.usage_count).toBe(5);
-      expect(row!.tier).toBe('warm');
-    });
-
-    it('should delete an experience', () => {
-      persistence.insertExperience(createTestExperience());
-      expect(persistence.deleteExperience('exp-1')).toBe(true);
-      expect(persistence.getExperience('exp-1')).toBeUndefined();
-    });
-
-    it('should return false when deleting nonexistent', () => {
-      expect(persistence.deleteExperience('nonexistent')).toBe(false);
-    });
-
-    it('should count experiences', () => {
-      expect(persistence.getExperienceCount()).toBe(0);
-      persistence.insertExperience(createTestExperience());
-      expect(persistence.getExperienceCount()).toBe(1);
-    });
-
-    it('should handle embedding round-trip', () => {
-      const embedding = [0.1, 0.2, 0.3, 0.4];
-      persistence.insertExperience(createTestExperience({ embedding }));
-
-      const row = persistence.getExperience('exp-1');
-      expect(row!.embedding).toBeDefined();
-      expect(row!.embedding).toBeInstanceOf(Buffer);
-    });
-
-    it('should bulk delete with WHERE clause', () => {
-      persistence.insertExperience(createTestExperience({ id: 'exp-1', tier: 'cold' as 'hot' | 'warm' | 'cold' }));
-      persistence.insertExperience(createTestExperience({ id: 'exp-2', tier: 'hot' }));
-
-      const deleted = persistence.deleteExperiencesWhere('tier = ?', ['cold']);
-      expect(deleted).toBe(1);
-      expect(persistence.getExperienceCount()).toBe(1);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Playbooks CRUD
-  // --------------------------------------------------------------------------
-
-  describe('playbooks', () => {
-    it('should insert and retrieve a playbook', () => {
-      const pb = createTestPlaybook();
-      persistence.insertPlaybook(pb);
-
-      const row = persistence.getPlaybook('pb-1');
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('Error Handling Strategy');
-      expect(row!.confidence).toBe(0.75);
-      expect(row!.primary_domain).toBe('code');
-    });
-
-    it('should get all playbooks', () => {
-      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-1' }));
-      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-2', name: 'Another' }));
-
-      expect(persistence.getAllPlaybooks()).toHaveLength(2);
-    });
-
-    it('should filter by domain', () => {
-      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-1' }));
-      persistence.insertPlaybook(createTestPlaybook({
-        id: 'pb-2',
-        applicability: { situations: [], triggers: [], antiPatterns: [], domains: ['data'] },
-      }));
-
-      const codePlaybooks = persistence.getPlaybooksByDomain('code');
-      expect(codePlaybooks).toHaveLength(1);
-    });
-
-    it('should update a playbook', () => {
-      persistence.insertPlaybook(createTestPlaybook());
-
-      persistence.updatePlaybook('pb-1', { confidence: 0.9, complexity: 'simple' });
-
-      const row = persistence.getPlaybook('pb-1');
-      expect(row!.confidence).toBe(0.9);
-      expect(row!.complexity).toBe('simple');
-    });
-
-    it('should delete a playbook', () => {
-      persistence.insertPlaybook(createTestPlaybook());
-      expect(persistence.deletePlaybook('pb-1')).toBe(true);
-      expect(persistence.getPlaybook('pb-1')).toBeUndefined();
-    });
-
-    it('should count playbooks', () => {
-      expect(persistence.getPlaybookCount()).toBe(0);
-      persistence.insertPlaybook(createTestPlaybook());
-      expect(persistence.getPlaybookCount()).toBe(1);
-    });
-
-    it('should snapshot playbook versions', () => {
-      persistence.insertPlaybook(createTestPlaybook());
-      persistence.snapshotPlaybookVersion('pb-1', '1.0.0', 'Initial version');
-
-      const versions = persistence.getPlaybookVersions('pb-1');
-      expect(versions).toHaveLength(1);
-      expect(versions[0].version).toBe('1.0.0');
-      expect(versions[0].changelog).toBe('Initial version');
-
-      // Snapshot should contain valid JSON of the playbook
-      const snapshot = JSON.parse(versions[0].playbook_snapshot);
-      expect(snapshot.name).toBe('Error Handling Strategy');
-    });
-
-    it('should store JSON fields correctly', () => {
-      persistence.insertPlaybook(createTestPlaybook());
-      const row = persistence.getPlaybook('pb-1');
-
-      const applicability = JSON.parse(row!.applicability);
-      expect(applicability.situations).toContain('error handling');
-
-      const guidance = JSON.parse(row!.guidance);
-      expect(guidance.strategy).toBe('Use structured error handling');
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Reflexion Episodes CRUD
-  // --------------------------------------------------------------------------
-
-  describe('reflexion episodes', () => {
-    it('should insert and retrieve a reflexion episode', () => {
-      persistence.insertReflexionEpisode(createTestReflexion());
-
-      const row = persistence.getReflexionEpisode('ref-1');
-      expect(row).toBeDefined();
-      expect(row!.outcome).toBe('success');
-      expect(row!.domain).toBe('code');
-    });
-
-    it('should filter by domain and outcome', () => {
-      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-1', domain: 'code', outcome: 'success' }));
-      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-2', domain: 'code', outcome: 'failure' }));
-      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-3', domain: 'data', outcome: 'success' }));
-
-      const codeSuccess = persistence.getReflexionEpisodes({ domain: 'code', outcome: 'success' });
-      expect(codeSuccess).toHaveLength(1);
-      expect(codeSuccess[0].id).toBe('ref-1');
-    });
-
-    it('should respect limit', () => {
-      for (let i = 0; i < 5; i++) {
-        persistence.insertReflexionEpisode(createTestReflexion({
-          id: `ref-${i}`,
-          createdAt: new Date(2024, 0, i + 1),
-        }));
-      }
-
-      const limited = persistence.getReflexionEpisodes({ limit: 3 });
-      expect(limited).toHaveLength(3);
-    });
-
-    it('should get by trajectory', () => {
-      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-1', trajectoryId: 'traj-1' }));
-      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-2', trajectoryId: 'traj-2' }));
-
-      const results = persistence.getReflexionByTrajectory('traj-1');
-      expect(results).toHaveLength(1);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Causal Edges CRUD
-  // --------------------------------------------------------------------------
-
-  describe('causal edges', () => {
-    it('should insert and retrieve a causal edge', () => {
-      persistence.insertCausalEdge({
-        id: 'edge-1',
-        cause: 'missing validation',
-        effect: 'runtime error',
-        confidence: 0.9,
-        domain: 'code',
-        sourceTrajectoryIds: ['traj-1'],
-        observedCount: 3,
-        createdAt: new Date('2024-01-01'),
-        updatedAt: new Date('2024-01-02'),
-      });
-
-      const row = persistence.getCausalEdge('edge-1');
-      expect(row).toBeDefined();
-      expect(row!.cause).toBe('missing validation');
-      expect(row!.confidence).toBe(0.9);
-      expect(JSON.parse(row!.source_trajectory_ids)).toEqual(['traj-1']);
-    });
-
-    it('should get all and filter by domain', () => {
-      persistence.insertCausalEdge({
-        id: 'edge-1', cause: 'a', effect: 'b', confidence: 0.5,
-        domain: 'code', sourceTrajectoryIds: [], observedCount: 1,
-        createdAt: new Date(), updatedAt: new Date(),
-      });
-      persistence.insertCausalEdge({
-        id: 'edge-2', cause: 'c', effect: 'd', confidence: 0.5,
-        domain: 'data', sourceTrajectoryIds: [], observedCount: 1,
-        createdAt: new Date(), updatedAt: new Date(),
-      });
-
-      expect(persistence.getAllCausalEdges()).toHaveLength(2);
-      expect(persistence.getCausalEdgesByDomain('code')).toHaveLength(1);
-    });
-
-    it('should update a causal edge', () => {
-      persistence.insertCausalEdge({
-        id: 'edge-1', cause: 'a', effect: 'b', confidence: 0.5,
-        domain: 'code', sourceTrajectoryIds: [], observedCount: 1,
-        createdAt: new Date(), updatedAt: new Date(),
-      });
-
-      persistence.updateCausalEdge('edge-1', { confidence: 0.9, observedCount: 5 });
-
-      const row = persistence.getCausalEdge('edge-1');
-      expect(row!.confidence).toBe(0.9);
-      expect(row!.observed_count).toBe(5);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Meta Observations CRUD
-  // --------------------------------------------------------------------------
-
-  describe('meta observations', () => {
-    it('should insert and retrieve a meta observation', () => {
-      persistence.insertMetaObservation(createTestMetaObservation());
-
-      const row = persistence.getMetaObservation('obs-1');
-      expect(row).toBeDefined();
-      expect(row!.routing_decision).toBe('adapt');
-      expect(row!.outcome_success).toBe(1);
-    });
-
-    it('should filter by routing decision', () => {
-      persistence.insertMetaObservation(createTestMetaObservation({ id: 'obs-1' }));
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-2',
-        routing: { decision: 'direct', confidence: 0.5, reasoning: 'test' },
-      }));
-
-      const adaptObs = persistence.getMetaObservationsByRouting('adapt');
-      expect(adaptObs).toHaveLength(1);
-    });
-
-    it('should aggregate routing effectiveness', () => {
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-1',
-        routing: { decision: 'adapt', confidence: 0.8, reasoning: '' },
-        outcome: { success: true, quality: 'good', effortActual: 5, effortEstimate: 5 },
-      }));
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-2',
-        routing: { decision: 'adapt', confidence: 0.7, reasoning: '' },
-        outcome: { success: false, quality: 'poor', effortActual: 10, effortEstimate: 5 },
-      }));
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-3',
-        routing: { decision: 'direct', confidence: 0.9, reasoning: '' },
-        outcome: { success: true, quality: 'excellent', effortActual: 2, effortEstimate: 3 },
-      }));
-
-      const agg = persistence.aggregateRoutingEffectiveness();
-      expect(agg['adapt']).toEqual({ total: 2, successful: 1 });
-      expect(agg['direct']).toEqual({ total: 1, successful: 1 });
-    });
-
-    it('should delete observations before cutoff', () => {
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-old',
-        timestamp: new Date('2023-01-01'),
-      }));
-      persistence.insertMetaObservation(createTestMetaObservation({
-        id: 'obs-new',
-        timestamp: new Date('2024-06-01'),
-      }));
-
-      const deleted = persistence.deleteMetaObservationsBefore(new Date('2024-01-01'));
-      expect(deleted).toBe(1);
-      expect(persistence.getMetaObservationCount()).toBe(1);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Meta Strategies CRUD
-  // --------------------------------------------------------------------------
-
-  describe('meta strategies', () => {
-    it('should insert and retrieve a meta strategy', () => {
-      persistence.insertMetaStrategy(createTestMetaStrategy());
-
-      const row = persistence.getMetaStrategy('strat-1');
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('Experience-heavy retrieval');
-      expect(row!.success_rate).toBe(0.8);
-    });
-
-    it('should get by name', () => {
-      persistence.insertMetaStrategy(createTestMetaStrategy());
-
-      const row = persistence.getMetaStrategyByName('Experience-heavy retrieval');
-      expect(row).toBeDefined();
-    });
-
-    it('should update a meta strategy', () => {
-      persistence.insertMetaStrategy(createTestMetaStrategy());
-
-      persistence.updateMetaStrategy('strat-1', { applicationCount: 10, successRate: 0.9 });
-
-      const row = persistence.getMetaStrategy('strat-1');
-      expect(row!.application_count).toBe(10);
-      expect(row!.success_rate).toBe(0.9);
-    });
-
-    it('should delete a meta strategy', () => {
-      persistence.insertMetaStrategy(createTestMetaStrategy());
-      expect(persistence.deleteMetaStrategy('strat-1')).toBe(true);
-      expect(persistence.getMetaStrategy('strat-1')).toBeUndefined();
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // System State (key-value)
-  // --------------------------------------------------------------------------
-
-  describe('system state', () => {
-    it('should store and retrieve typed state', () => {
-      persistence.setSystemState('moe_gate', { weights: [0.1, 0.2, 0.7] });
-
-      const state = persistence.getSystemState<{ weights: number[] }>('moe_gate');
-      expect(state).toBeDefined();
-      expect(state!.weights).toEqual([0.1, 0.2, 0.7]);
-    });
-
-    it('should return undefined for missing key', () => {
-      expect(persistence.getSystemState('nonexistent')).toBeUndefined();
-    });
-
-    it('should overwrite existing state', () => {
-      persistence.setSystemState('counter', 1);
-      persistence.setSystemState('counter', 2);
-
-      expect(persistence.getSystemState<number>('counter')).toBe(2);
-    });
-
-    it('should delete state', () => {
-      persistence.setSystemState('temp', 'value');
-      expect(persistence.deleteSystemState('temp')).toBe(true);
-      expect(persistence.getSystemState('temp')).toBeUndefined();
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Transactions
-  // --------------------------------------------------------------------------
-
-  describe('transactions', () => {
-    it('should commit batch inserts atomically', () => {
-      persistence.transaction(() => {
-        for (let i = 0; i < 10; i++) {
-          persistence.insertExperience(createTestExperience({ id: `exp-${i}` }));
-        }
-      });
-
-      expect(persistence.getExperienceCount()).toBe(10);
-    });
-
-    it('should roll back on error', () => {
-      try {
-        persistence.transaction(() => {
-          persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
-          throw new Error('Simulated failure');
-        });
-      } catch {
-        // Expected
-      }
-
-      expect(persistence.getExperienceCount()).toBe(0);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // Factory
-  // --------------------------------------------------------------------------
-
-  describe('factory', () => {
-    it('should create persistence with default config', () => {
-      const p = createSqlitePersistence({ baseDir: tmpDir });
-      expect(p).toBeInstanceOf(SqlitePersistence);
-    });
-  });
-});