cognitive-core 0.1.0 → 0.2.0

package/tests/integration/unified-pipeline-e2e.test.ts

@@ -0,0 +1,634 @@
+/**
+ * End-to-end integration tests for UnifiedLearningPipeline.
+ *
+ * Exercises the full three-speed lifecycle with real (non-mocked)
+ * MemorySystem and SqlitePersistence:
+ *
+ *   Immediate: InstantLoop → experience, playbooks, knowledge, causal, reflexion
+ *   Batch:     EnergyEvaluator → analysis, playbook extraction, compression, clustering
+ *   Maintenance: HealingOrchestrator, knowledge defrag, meta-strategy generation
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  createTrajectory,
+  createStep,
+  createTask,
+  successOutcome,
+  failureOutcome,
+  type Trajectory,
+} from '../../src/types/index.js';
+
+import { MemorySystem } from '../../src/memory/system.js';
+import { createSqlitePersistence, type SqlitePersistence } from '../../src/persistence/index.js';
+import {
+  UnifiedLearningPipeline,
+  createUnifiedPipeline,
+} from '../../src/learning/unified-pipeline.js';
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function makeTrajectory(
+  description: string,
+  success: boolean,
+  domain = 'typescript',
+  opts?: { errorInfo?: string },
+): Trajectory {
+  return createTrajectory({
+    task: createTask({ domain, description }),
+    steps: [
+      createStep({
+        thought: 'Analyzing the task',
+        action: 'ReadFile src/index.ts',
+        observation: 'File content: import { foo } from "./bar"',
+      }),
+      createStep({
+        thought: 'Implementing the fix',
+        action: 'EditFile src/index.ts',
+        observation: success ? 'File updated successfully' : 'error: compilation failed',
+      }),
+      createStep({
+        thought: 'Verifying the result',
+        action: 'Bash npm test',
+        observation: success
+          ? 'All tests passed'
+          : `error: ${opts?.errorInfo ?? 'assertion error'}`,
+      }),
+    ],
+    outcome: success
+      ? successOutcome('Fixed the issue')
+      : failureOutcome(opts?.errorInfo ?? 'Task failed'),
+    agentId: 'test-agent',
+  });
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('UnifiedLearningPipeline E2E', () => {
+  let tempDir: string;
+  let persistence: SqlitePersistence;
+  let memory: MemorySystem;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'unified-pipeline-e2e-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = new MemorySystem(persistence, tempDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  // --------------------------------------------------------------------------
+  // 1. Immediate phase — single trajectory lifecycle
+  // --------------------------------------------------------------------------
+  describe('immediate phase', () => {
+    it('should store experience and extract signals from a single trajectory', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 100 },
+          energy: { countThreshold: 100 },
+        },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      const t = makeTrajectory('Fix import path in index.ts', true);
+      const result = await pipeline.processTrajectory(t);
+
+      // Immediate phase ran
+      expect(result.instantLoop.experienceId).toBeDefined();
+      expect(result.instantLoop.durationMs).toBeGreaterThanOrEqual(0);
+
+      // Batch NOT triggered (threshold=100)
+      expect(result.batchTriggered).toBe(false);
+      expect(result.maintenanceTriggered).toBe(false);
+
+      // Experience is actually in memory
+      const exp = await memory.experiences.get(result.instantLoop.experienceId);
+      expect(exp).toBeDefined();
+      expect(exp!.success).toBe(true);
+      expect(exp!.domain).toBe('typescript');
+
+      // Stats updated
+      expect(pipeline.getStats().totalProcessed).toBe(1);
+      expect(pipeline.getStats().pendingForBatch).toBe(1);
+    });
+
+    it('should generate reflexion episode for failed trajectory', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 100 },
+          energy: { countThreshold: 100 },
+        },
+        features: { reflexion: true, healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      const t = makeTrajectory(
+        'Fix TypeScript compiler error',
+        false,
+        'typescript',
+        { errorInfo: 'TypeError: Cannot read properties of undefined' },
+      );
+      const result = await pipeline.processTrajectory(t);
+
+      // Experience stored for failures too
+      expect(result.instantLoop.experienceId).toBeDefined();
+      const exp = await memory.experiences.get(result.instantLoop.experienceId);
+      expect(exp).toBeDefined();
+      expect(exp!.success).toBe(false);
+
+      // Reflexion episode generated
+      expect(result.instantLoop.reflexionEpisodeId).toBeDefined();
+      const reflexionCount = await memory.reflexion.count();
+      expect(reflexionCount).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should extract causal edges from trajectory', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 100 },
+          energy: { countThreshold: 100 },
+        },
+        features: { causalExtraction: true, healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      const t = makeTrajectory(
+        'Fix authentication bypass vulnerability',
+        false,
+        'security',
+        { errorInfo: 'TypeError: auth token validation failed' },
+      );
+      const result = await pipeline.processTrajectory(t);
+
+      // Causal edges may or may not be extracted depending on heuristics,
+      // but the pipeline should not error
+      expect(result.instantLoop.causalEdgesExtracted).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 2. Batch phase — count-threshold trigger
+  // --------------------------------------------------------------------------
+  describe('batch phase — count threshold', () => {
+    it('should trigger batch after reaching count threshold', async () => {
+      const THRESHOLD = 3;
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: THRESHOLD },
+          energy: { countThreshold: THRESHOLD, minIntervalMs: 0 },
+        },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      // Process N-1 trajectories — no batch
+      for (let i = 0; i < THRESHOLD - 1; i++) {
+        const r = await pipeline.processTrajectory(
+          makeTrajectory(`Task variant ${i}`, true),
+        );
+        expect(r.batchTriggered).toBe(false);
+      }
+
+      // Nth trajectory triggers batch
+      const result = await pipeline.processTrajectory(
+        makeTrajectory(`Task variant final`, true),
+      );
+
+      expect(result.batchTriggered).toBe(true);
+      expect(result.batchResult).toBeDefined();
+      expect(result.batchResult!.trajectoriesProcessed).toBe(THRESHOLD);
+      expect(result.batchResult!.triggerReasons).toContain('count_threshold');
+      expect(result.batchResult!.successRate).toBe(1.0);
+
+      // Accumulated count resets after batch
+      expect(pipeline.getAccumulatedCount()).toBe(0);
+      expect(pipeline.getStats().batchCyclesRun).toBe(1);
+
+      // Experiences are still in memory (not cleared)
+      const count = await memory.experiences.count();
+      expect(count).toBe(THRESHOLD);
+    });
+
+    it('should run temporal compression and clustering in batch', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 3 },
+          energy: { countThreshold: 3, minIntervalMs: 0 },
+        },
+        features: {
+          temporalCompression: true,
+          reasoningBank: true,
+          healing: false,
+        },
+      }, persistence);
+      await pipeline.init();
+
+      for (let i = 0; i < 3; i++) {
+        await pipeline.processTrajectory(
+          makeTrajectory(`Fix import error variant ${i}`, true),
+        );
+      }
+
+      // The last processTrajectory should have triggered batch
+      const stats = pipeline.getStats();
+      expect(stats.batchCyclesRun).toBe(1);
+
+      // Compression result is in the batch result — check that it ran without error
+      // (actual compression logic requires time-based tier transitions,
+      // so promoted/demoted/evicted may be 0 in a fresh test)
+      const experiences = await memory.experiences.getAll();
+      expect(experiences.length).toBe(3);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 3. Batch phase — energy-signal early trigger
+  // --------------------------------------------------------------------------
+  describe('batch phase — energy signal', () => {
+    it('should trigger batch early on contradiction signal', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 100 },
+          energy: {
+            countThreshold: 100,
+            energyThreshold: 0.3,
+            minIntervalMs: 0,
+          },
+        },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      const result = await pipeline.processTrajectory(
+        makeTrajectory('Fix database query', true),
+        { contradictionDetected: true },
+      );
+
+      expect(result.batchTriggered).toBe(true);
+      expect(result.batchResult!.triggerReasons).toContain('contradiction_detected');
+      // Count threshold is 100 but we only processed 1
+      expect(result.batchResult!.trajectoriesProcessed).toBe(1);
+    });
+
+    it('should trigger batch on novel domain signal', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 100 },
+          energy: {
+            countThreshold: 100,
+            energyThreshold: 0.3,
+            minIntervalMs: 0,
+          },
+        },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      const result = await pipeline.processTrajectory(
+        makeTrajectory('Deploy Kubernetes cluster', true, 'devops'),
+        { novelDomain: true },
+      );
+
+      expect(result.batchTriggered).toBe(true);
+      expect(result.batchResult!.triggerReasons).toContain('novel_domain');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 4. Maintenance phase — triggered after N batches
+  // --------------------------------------------------------------------------
+  describe('maintenance phase', () => {
+    it('should trigger maintenance after N batches', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 1 },
+          energy: { countThreshold: 1, minIntervalMs: 0 },
+        },
+        maintenance: { mode: 'afterNBatches', batchInterval: 2 },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      // 1st batch — no maintenance
+      const r1 = await pipeline.processTrajectory(
+        makeTrajectory('Task 1', true),
+      );
+      expect(r1.batchTriggered).toBe(true);
+      expect(r1.maintenanceTriggered).toBe(false);
+
+      // 2nd batch — triggers maintenance
+      const r2 = await pipeline.processTrajectory(
+        makeTrajectory('Task 2', true),
+      );
+      expect(r2.batchTriggered).toBe(true);
+      expect(r2.maintenanceTriggered).toBe(true);
+      expect(r2.maintenanceResult).toBeDefined();
+      expect(r2.maintenanceResult!.ran).toBe(true);
+
+      // Maintenance tasks executed (built-in: healing-cycle, knowledge-defrag, meta-strategy-generation)
+      const taskNames = r2.maintenanceResult!.taskResults.map(t => t.taskName);
+      expect(taskNames).toContain('healing-cycle');
+
+      expect(pipeline.getStats().maintenanceCyclesRun).toBe(1);
+    });
+
+    it('should support manual maintenance with custom tasks', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        maintenance: { mode: 'manual' },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      let taskRan = false;
+      pipeline.registerMaintenanceTask({
+        name: 'custom-cleanup',
+        priority: 50,
+        execute: async () => {
+          taskRan = true;
+          return {
+            taskName: 'custom-cleanup',
+            success: true,
+            durationMs: 1,
+            details: { cleaned: 10 },
+          };
+        },
+      });
+
+      const result = await pipeline.runMaintenance({ force: true });
+      expect(result.ran).toBe(true);
+      expect(taskRan).toBe(true);
+      expect(result.taskResults.some(t => t.taskName === 'custom-cleanup')).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 5. Full lifecycle — trajectory → experience → playbook → maintenance
+  // --------------------------------------------------------------------------
+  describe('full lifecycle', () => {
+    it('should process trajectories through all three speeds', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 3 },
+          energy: { countThreshold: 3, minIntervalMs: 0 },
+        },
+        maintenance: { mode: 'afterNBatches', batchInterval: 2 },
+        features: {
+          temporalCompression: true,
+          reasoningBank: true,
+          reflexion: true,
+          causalExtraction: true,
+          knowledgeExtraction: true,
+          healing: true,
+        },
+      }, persistence);
+      await pipeline.init();
+
+      // --- Batch 1: 3 similar successful trajectories ---
+      for (let i = 0; i < 2; i++) {
+        await pipeline.processTrajectory(
+          makeTrajectory(`Fix TypeScript import error variant ${i}`, true),
+        );
+      }
+      const batch1Result = await pipeline.processTrajectory(
+        makeTrajectory('Fix TypeScript import error variant 2', true),
+      );
+
+      expect(batch1Result.batchTriggered).toBe(true);
+      expect(batch1Result.maintenanceTriggered).toBe(false);
+      expect(batch1Result.batchResult!.trajectoriesProcessed).toBe(3);
+
+      // Experiences stored
+      const expCountAfterBatch1 = await memory.experiences.count();
+      expect(expCountAfterBatch1).toBe(3);
+
+      // --- Batch 2: 3 more trajectories → triggers maintenance ---
+      for (let i = 0; i < 2; i++) {
+        await pipeline.processTrajectory(
+          makeTrajectory(`Fix CSS layout issue variant ${i}`, true, 'css'),
+        );
+      }
+      const batch2Result = await pipeline.processTrajectory(
+        makeTrajectory('Fix CSS layout issue variant 2', true, 'css'),
+      );
+
+      expect(batch2Result.batchTriggered).toBe(true);
+      expect(batch2Result.maintenanceTriggered).toBe(true);
+      expect(batch2Result.maintenanceResult!.ran).toBe(true);
+
+      // All 6 experiences in memory
+      const finalExpCount = await memory.experiences.count();
+      expect(finalExpCount).toBe(6);
+
+      // Stats reflect full lifecycle
+      const stats = pipeline.getStats();
+      expect(stats.totalProcessed).toBe(6);
+      expect(stats.batchCyclesRun).toBe(2);
+      expect(stats.maintenanceCyclesRun).toBe(1);
+      expect(stats.pendingForBatch).toBe(0); // cleared after each batch
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 6. Mixed success/failure trajectories
+  // --------------------------------------------------------------------------
+  describe('mixed success/failure', () => {
+    it('should track success rate across mixed trajectories', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 4 },
+          energy: { countThreshold: 4, minIntervalMs: 0 },
+        },
+        features: { healing: false, reflexion: true },
+      }, persistence);
+      await pipeline.init();
+
+      // 2 success + 2 failure = 50% success rate
+      await pipeline.processTrajectory(makeTrajectory('Task A', true));
+      await pipeline.processTrajectory(
+        makeTrajectory('Task B', false, 'typescript', { errorInfo: 'ReferenceError' }),
+      );
+      await pipeline.processTrajectory(makeTrajectory('Task C', true));
+      const result = await pipeline.processTrajectory(
+        makeTrajectory('Task D', false, 'typescript', { errorInfo: 'SyntaxError' }),
+      );
+
+      expect(result.batchTriggered).toBe(true);
+      expect(result.batchResult!.successRate).toBe(0.5);
+      expect(result.batchResult!.trajectoriesProcessed).toBe(4);
+
+      // All trajectories stored as experiences
+      const allExp = await memory.experiences.getAll();
+      expect(allExp.length).toBe(4);
+      expect(allExp.filter(e => e.success).length).toBe(2);
+      expect(allExp.filter(e => !e.success).length).toBe(2);
+
+      // Reflexion episodes generated for failures
+      const reflexionCount = await memory.reflexion.count();
+      expect(reflexionCount).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 7. Pipeline stats tracking
+  // --------------------------------------------------------------------------
+  describe('stats tracking', () => {
+    it('should accurately track stats across the full lifecycle', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 2 },
+          energy: { countThreshold: 2, minIntervalMs: 0 },
+        },
+        maintenance: { mode: 'afterNBatches', batchInterval: 1 },
+        features: { healing: false },
+      }, persistence);
+      await pipeline.init();
+
+      // Initial state
+      let stats = pipeline.getStats();
+      expect(stats.totalProcessed).toBe(0);
+      expect(stats.batchCyclesRun).toBe(0);
+      expect(stats.maintenanceCyclesRun).toBe(0);
+
+      // Process 1 trajectory — pending, no batch
+      await pipeline.processTrajectory(makeTrajectory('Task 1', true));
+      stats = pipeline.getStats();
+      expect(stats.totalProcessed).toBe(1);
+      expect(stats.pendingForBatch).toBe(1);
+      expect(stats.batchCyclesRun).toBe(0);
+
+      // Process 2nd — triggers batch + maintenance (batchInterval=1)
+      await pipeline.processTrajectory(makeTrajectory('Task 2', true));
+      stats = pipeline.getStats();
+      expect(stats.totalProcessed).toBe(2);
+      expect(stats.batchCyclesRun).toBe(1);
+      expect(stats.maintenanceCyclesRun).toBe(1);
+      expect(stats.pendingForBatch).toBe(0);
+
+      // Maintenance tasks registered
+      expect(stats.maintenanceTasks.length).toBeGreaterThan(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 8. Healing orchestrator integration
+  // --------------------------------------------------------------------------
+  describe('healing integration', () => {
+    it('should run healing with built-in detectors during maintenance', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 1, maxExperiences: 1000 },
+          energy: { countThreshold: 1, minIntervalMs: 0 },
+        },
+        maintenance: { mode: 'afterNBatches', batchInterval: 1 },
+        features: { healing: true },
+      }, persistence);
+      await pipeline.init();
+
+      // Process trajectory → batch → maintenance (with healing)
+      const result = await pipeline.processTrajectory(
+        makeTrajectory('Fix login bug', true),
+      );
+
+      expect(result.maintenanceTriggered).toBe(true);
+
+      // Healing-cycle task should have run
+      const healingTask = result.maintenanceResult!.taskResults.find(
+        t => t.taskName === 'healing-cycle',
+      );
+      expect(healingTask).toBeDefined();
+      expect(healingTask!.success).toBe(true);
+
+      // Built-in detectors are registered
+      const stats = pipeline.getStats();
+      expect(stats.anomalyDetectors).toContain('playbook-drift');
+      expect(stats.anomalyDetectors).toContain('memory-bloat');
+    });
+
+    it('should execute custom repair strategy when anomaly detected', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        maintenance: { mode: 'manual' },
+        features: { healing: true },
+      }, persistence);
+      await pipeline.init();
+
+      let repaired = false;
+      pipeline.addAnomalyDetector({
+        name: 'test-detector',
+        detect: async () => [{
+          type: 'test-anomaly',
+          severity: 'medium' as const,
+          description: 'Test anomaly for repair',
+          detectorName: 'test-detector',
+        }],
+      });
+      pipeline.addRepairStrategy({
+        name: 'test-repair',
+        canRepair: (a) => a.type === 'test-anomaly',
+        repair: async () => {
+          repaired = true;
+          return {
+            success: true,
+            action: 'repaired test anomaly',
+            strategyName: 'test-repair',
+            durationMs: 1,
+          };
+        },
+      });
+
+      await pipeline.runMaintenance({ force: true });
+      expect(repaired).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 9. Feature toggle isolation
+  // --------------------------------------------------------------------------
+  describe('feature toggles', () => {
+    it('should skip disabled features without errors', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 1 },
+          energy: { countThreshold: 1, minIntervalMs: 0 },
+        },
+        features: {
+          temporalCompression: false,
+          reasoningBank: false,
+          reflexion: false,
+          causalExtraction: false,
+          knowledgeExtraction: false,
+          healing: false,
+          metaLearning: false,
+          effectivenessTracking: false,
+        },
+      }, persistence);
+      await pipeline.init();
+
+      const result = await pipeline.processTrajectory(
+        makeTrajectory('Simple fix', true),
+      );
+
+      // Immediate phase still works
+      expect(result.instantLoop.experienceId).toBeDefined();
+      // Batch triggered (threshold=1)
+      expect(result.batchTriggered).toBe(true);
+      // No reflexion or causal edges
+      expect(result.instantLoop.reflexionEpisodeId).toBeUndefined();
+      expect(result.instantLoop.causalEdgesExtracted).toBe(0);
+    });
+  });
+});

package/tests/learning/analyzer.test.ts

@@ -170,7 +170,7 @@ describe('TrajectoryAnalyzer', () => {
       expect(result.success).toBe(false);
       expect(result.errorPatterns.length).toBeGreaterThan(0);
       // Should match type error pattern
-      expect(result.errorPatterns.some(p => p.type === 'type' || p.type === 'general')).toBe(true);
+      expect(result.errorPatterns.some(p => p.type === 'type-error' || p.type === 'general-error')).toBe(true);
     });
 
     it('should detect timeout errors', async () => {