cognitive-core 0.2.4 → 0.3.1

package/tests/learning/unified-pipeline-efficacy.test.ts

@@ -1,232 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { UnifiedLearningPipeline, createUnifiedPipeline } from '../../src/learning/unified-pipeline.js';
-import { MemorySystem } from '../../src/memory/system.js';
-import { createTrajectory, type Trajectory } from '../../src/types/trajectory.js';
-import { createTask } from '../../src/types/task.js';
-import { createStep } from '../../src/types/step.js';
-import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
-import { createPlaybook } from '../../src/types/playbook.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-import type { SqlitePersistence } from '../../src/persistence/index.js';
-import type { Playbook } from '../../src/types/playbook.js';
-
-function makeTrajectory(overrides?: {
-  success?: boolean;
-  domain?: string;
-  description?: string;
-}): Trajectory {
-  const success = overrides?.success ?? true;
-  return createTrajectory({
-    task: createTask({
-      description: overrides?.description ?? 'Fix the typescript import error',
-      domain: overrides?.domain ?? 'typescript',
-    }),
-    steps: [
-      createStep({
-        thought: 'Let me check the imports',
-        action: 'ReadFile src/index.ts',
-        observation: 'File content: import { foo } from "./bar"',
-      }),
-      createStep({
-        thought: 'The import path is wrong',
-        action: 'EditFile src/index.ts',
-        observation: 'File updated successfully',
-      }),
-    ],
-    outcome: success
-      ? successOutcome('Fixed import path')
-      : failureOutcome('Could not resolve import'),
-    agentId: 'test-agent',
-  });
-}
-
-function makePlaybook(overrides?: Partial<{
-  name: string;
-  domain: string;
-  successCount: number;
-  failureCount: number;
-  confidence: number;
-}>): Playbook {
-  return createPlaybook({
-    name: overrides?.name ?? 'test-playbook',
-    applicability: {
-      situations: ['fix import'],
-      domains: [overrides?.domain ?? 'typescript'],
-      triggers: ['import error'],
-      antiPatterns: [],
-    },
-    guidance: {
-      strategy: 'Check and fix import paths',
-      tactics: ['Read the file', 'Fix the path'],
-      verification: [],
-      commonPitfalls: [],
-    },
-    successCount: overrides?.successCount ?? 5,
-    failureCount: overrides?.failureCount ?? 1,
-    confidence: overrides?.confidence ?? 0.8,
-  });
-}
-
-describe('UnifiedLearningPipeline — efficacy maintenance', () => {
-  let tempDir: string;
-  let memory: MemorySystem;
-  let pipeline: UnifiedLearningPipeline;
-  let persistence: SqlitePersistence;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'atlas-efficacy-test-'));
-    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 });
-  });
-
-  it('should register efficacy tasks by default', async () => {
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-    }, persistence);
-    await pipeline.init();
-
-    const stats = pipeline.getStats();
-    expect(stats.maintenanceTasks).toContain('playbook-decay-detection');
-    expect(stats.maintenanceTasks).toContain('playbook-efficacy-audit');
-    expect(stats.maintenanceTasks).toContain('playbook-lifecycle-review');
-  });
-
-  it('should NOT register efficacy tasks when feature is disabled', async () => {
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false, efficacy: false },
-    }, persistence);
-    await pipeline.init();
-
-    const stats = pipeline.getStats();
-    expect(stats.maintenanceTasks).not.toContain('playbook-decay-detection');
-    expect(stats.maintenanceTasks).not.toContain('playbook-efficacy-audit');
-    expect(stats.maintenanceTasks).not.toContain('playbook-lifecycle-review');
-  });
-
-  it('decay detection should skip when no playbooks exist', async () => {
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-    }, persistence);
-    await pipeline.init();
-
-    const result = await pipeline.runMaintenance({ force: true });
-
-    expect(result.ran).toBe(true);
-    const decayTask = result.taskResults.find(t => t.taskName === 'playbook-decay-detection');
-    expect(decayTask).toBeDefined();
-    expect(decayTask!.success).toBe(true);
-    expect((decayTask!.details as Record<string, unknown>).skipped).toBe(true);
-  });
-
-  it('decay detection should run with playbooks and annotations', async () => {
-    // Add playbooks
-    const pb = makePlaybook({ name: 'import-fixer', successCount: 10, failureCount: 5 });
-    await memory.playbooks.add(pb);
-
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 3 },
-    }, persistence);
-    await pipeline.init();
-
-    const result = await pipeline.runMaintenance({ force: true });
-
-    const decayTask = result.taskResults.find(t => t.taskName === 'playbook-decay-detection');
-    expect(decayTask).toBeDefined();
-    expect(decayTask!.success).toBe(true);
-    const details = decayTask!.details as Record<string, unknown>;
-    expect(details.skipped).toBeUndefined();
-    expect(typeof details.healthyCount).toBe('number');
-  });
-
-  it('efficacy audit should skip when no decay results found flagged playbooks', async () => {
-    const pb = makePlaybook({ name: 'stable-playbook', confidence: 0.9 });
-    await memory.playbooks.add(pb);
-
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 3 },
-    }, persistence);
-    await pipeline.init();
-
-    const result = await pipeline.runMaintenance({ force: true });
-
-    const auditTask = result.taskResults.find(t => t.taskName === 'playbook-efficacy-audit');
-    expect(auditTask).toBeDefined();
-    expect(auditTask!.success).toBe(true);
-    const details = auditTask!.details as Record<string, unknown>;
-    // Should be skipped because decay detection found no flagged playbooks
-    expect(details.skipped).toBe(true);
-  });
-
-  it('lifecycle review should respect frequency setting', async () => {
-    const pb = makePlaybook({ name: 'lifecycle-test' });
-    await memory.playbooks.add(pb);
-
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 2 },
-    }, persistence);
-    await pipeline.init();
-
-    // First maintenance (cycle 0) — should run (0 % 2 === 0)
-    const result1 = await pipeline.runMaintenance({ force: true });
-    const lifecycleTask1 = result1.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
-    expect(lifecycleTask1).toBeDefined();
-    const details1 = lifecycleTask1!.details as Record<string, unknown>;
-    expect(details1.totalPlaybooks).toBeDefined();
-
-    // Second maintenance (cycle 1) — should skip (1 % 2 !== 0)
-    const result2 = await pipeline.runMaintenance({ force: true });
-    const lifecycleTask2 = result2.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
-    expect(lifecycleTask2).toBeDefined();
-    const details2 = lifecycleTask2!.details as Record<string, unknown>;
-    expect(details2.skipped).toBe(true);
-
-    // Third maintenance (cycle 2) — should run again (2 % 2 === 0)
-    const result3 = await pipeline.runMaintenance({ force: true });
-    const lifecycleTask3 = result3.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
-    expect(lifecycleTask3).toBeDefined();
-    const details3 = lifecycleTask3!.details as Record<string, unknown>;
-    expect(details3.totalPlaybooks).toBeDefined();
-  });
-
-  it('lifecycle review returns portfolio snapshot data', async () => {
-    await memory.playbooks.add(makePlaybook({ name: 'pb-1', confidence: 0.9 }));
-    await memory.playbooks.add(makePlaybook({ name: 'pb-2', confidence: 0.4, domain: 'python' }));
-
-    pipeline = createUnifiedPipeline(memory, {
-      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-      features: { healing: false },
-      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 1 },
-    }, persistence);
-    await pipeline.init();
-
-    const result = await pipeline.runMaintenance({ force: true });
-
-    const lifecycleTask = result.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
-    expect(lifecycleTask).toBeDefined();
-    const details = lifecycleTask!.details as Record<string, unknown>;
-    expect(details.totalPlaybooks).toBe(2);
-    expect(details.snapshot).toBeDefined();
-    const snapshot = details.snapshot as Record<string, unknown>;
-    expect(snapshot.confidenceBands).toBeDefined();
-  });
-});

package/tests/learning/unified-pipeline.test.ts

@@ -1,322 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { UnifiedLearningPipeline, createUnifiedPipeline } from '../../src/learning/unified-pipeline.js';
-import { MemorySystem } from '../../src/memory/system.js';
-import { createTrajectory, type Trajectory } from '../../src/types/trajectory.js';
-import { createTask } from '../../src/types/task.js';
-import { createStep } from '../../src/types/step.js';
-import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
-import { createPlaybook } from '../../src/types/playbook.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-import type { SqlitePersistence } from '../../src/persistence/index.js';
-
-function makeTrajectory(overrides?: {
-  success?: boolean;
-  domain?: string;
-  description?: string;
-  errorInfo?: string;
-}): Trajectory {
-  const success = overrides?.success ?? true;
-  return createTrajectory({
-    task: createTask({
-      description: overrides?.description ?? 'Fix the typescript import error',
-      domain: overrides?.domain ?? 'typescript',
-    }),
-    steps: [
-      createStep({
-        thought: 'Let me check the imports',
-        action: 'ReadFile src/index.ts',
-        observation: 'File content: import { foo } from "./bar"',
-      }),
-      createStep({
-        thought: 'The import path is wrong',
-        action: 'EditFile src/index.ts',
-        observation: 'File updated successfully',
-      }),
-    ],
-    outcome: success
-      ? successOutcome('Fixed import path')
-      : failureOutcome(overrides?.errorInfo ?? 'Could not resolve import'),
-    agentId: 'test-agent',
-  });
-}
-
-describe('UnifiedLearningPipeline', () => {
-  let tempDir: string;
-  let memory: MemorySystem;
-  let pipeline: UnifiedLearningPipeline;
-  let persistence: SqlitePersistence;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'atlas-unified-pipeline-test-'));
-    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 });
-  });
-
-  describe('three-speed processing', () => {
-    it('should process trajectory through immediate phase', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      const t = makeTrajectory();
-      const result = await pipeline.processTrajectory(t);
-
-      expect(result.instantLoop.experienceId).toBeDefined();
-      expect(result.energyEval.shouldTriggerBatch).toBe(false);
-      expect(result.batchTriggered).toBe(false);
-      expect(result.maintenanceTriggered).toBe(false);
-    });
-
-    it('should trigger batch when count threshold reached', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 3 },
-          energy: { countThreshold: 3, minIntervalMs: 0 },
-        },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      await pipeline.processTrajectory(makeTrajectory());
-      await pipeline.processTrajectory(makeTrajectory({ description: 'second task' }));
-      const result = await pipeline.processTrajectory(makeTrajectory({ description: 'third task' }));
-
-      expect(result.batchTriggered).toBe(true);
-      expect(result.batchResult).toBeDefined();
-      expect(result.batchResult!.trajectoriesProcessed).toBe(3);
-      expect(result.batchResult!.triggerReasons).toContain('count_threshold');
-    });
-
-    it('should trigger batch on energy signal before count threshold', async () => {
-      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(),
-        { contradictionDetected: true },
-      );
-
-      expect(result.batchTriggered).toBe(true);
-      expect(result.batchResult!.triggerReasons).toContain('contradiction_detected');
-    });
-
-    it('should trigger maintenance after N batches', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 1 },
-          energy: { countThreshold: 1, minIntervalMs: 0 },
-        },
-        maintenance: { mode: 'afterNBatches', batchInterval: 2 },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      // First batch
-      await pipeline.processTrajectory(makeTrajectory());
-      // Second batch — should trigger maintenance
-      const result = await pipeline.processTrajectory(makeTrajectory({ description: 'second' }));
-
-      expect(result.batchTriggered).toBe(true);
-      expect(result.maintenanceTriggered).toBe(true);
-      expect(result.maintenanceResult).toBeDefined();
-      expect(result.maintenanceResult!.ran).toBe(true);
-    });
-  });
-
-  describe('batch processing', () => {
-    it('should extract playbooks from accumulated trajectories', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 100 },
-          energy: { countThreshold: 100 },
-        },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      // Add several similar successful trajectories
-      for (let i = 0; i < 5; i++) {
-        await pipeline.processTrajectory(makeTrajectory({
-          description: `Fix typescript import error in file-${i}.ts`,
-        }));
-      }
-
-      const result = await pipeline.runBatch();
-      expect(result.trajectoriesProcessed).toBe(5);
-      expect(result.successRate).toBe(1.0);
-    });
-
-    it('should return empty result when nothing accumulated', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      const result = await pipeline.runBatch();
-      expect(result.trajectoriesProcessed).toBe(0);
-    });
-  });
-
-  describe('maintenance', () => {
-    it('should support manual maintenance', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        maintenance: { mode: 'manual' },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      // Register a custom task
-      pipeline.registerMaintenanceTask({
-        name: 'custom-cleanup',
-        priority: 50,
-        execute: async () => ({
-          taskName: 'custom-cleanup',
-          success: true,
-          durationMs: 1,
-          details: { cleaned: 42 },
-        }),
-      });
-
-      const result = await pipeline.runMaintenance({ force: true });
-      expect(result.ran).toBe(true);
-      expect(result.taskResults.some(t => t.taskName === 'custom-cleanup')).toBe(true);
-    });
-  });
-
-  describe('healing orchestrator', () => {
-    it('should detect anomalies via built-in detectors', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { maxExperiences: 100 },
-          energy: { countThreshold: 100 },
-        },
-        features: { healing: true },
-      }, persistence);
-      await pipeline.init();
-
-      // Add the drift detector with a low threshold
-      pipeline.addAnomalyDetector({
-        name: 'test-drift',
-        detect: async () => [{
-          type: 'test-anomaly',
-          severity: 'low',
-          description: 'test issue',
-          detectorName: 'test-drift',
-        }],
-      });
-
-      // Run healing directly
-      const healResult = await pipeline.getHealingOrchestrator().runCycle({
-        trajectoriesProcessed: 100,
-        experienceCount: 500,
-        playbookCount: 10,
-        recentSuccessRate: 0.8,
-        batchesSinceLastMaintenance: 5,
-        metrics: {},
-      });
-
-      expect(healResult.anomaliesDetected.length).toBeGreaterThan(0);
-    });
-
-    it('should support custom repair strategies', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        features: { healing: true },
-      }, persistence);
-      await pipeline.init();
-
-      let repaired = false;
-      pipeline.addRepairStrategy({
-        name: 'auto-fix',
-        canRepair: (a) => a.type === 'custom-issue',
-        repair: async () => {
-          repaired = true;
-          return { success: true, action: 'auto-fixed', strategyName: 'auto-fix', durationMs: 1 };
-        },
-      });
-
-      pipeline.addAnomalyDetector({
-        name: 'custom-det',
-        detect: async () => [{
-          type: 'custom-issue',
-          severity: 'medium',
-          description: 'needs fixing',
-          detectorName: 'custom-det',
-        }],
-      });
-
-      await pipeline.runMaintenance({ force: true });
-      expect(repaired).toBe(true);
-    });
-  });
-
-  describe('statistics', () => {
-    it('should track processing stats', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 100 },
-          energy: { countThreshold: 100 },
-        },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      await pipeline.processTrajectory(makeTrajectory());
-      await pipeline.processTrajectory(makeTrajectory({ description: 'another' }));
-
-      const stats = pipeline.getStats();
-      expect(stats.totalProcessed).toBe(2);
-      expect(stats.pendingForBatch).toBe(2);
-      expect(stats.batchCyclesRun).toBe(0);
-    });
-  });
-
-  describe('latency warnings', () => {
-    it('should fire latency warning when instant loop is slow', async () => {
-      pipeline = createUnifiedPipeline(memory, {
-        maxInstantLatencyMs: -1, // Any non-negative duration triggers warning
-        batch: {
-          learning: { minTrajectories: 100 },
-          energy: { countThreshold: 100 },
-        },
-        features: { healing: false },
-      }, persistence);
-      await pipeline.init();
-
-      let warned = false;
-      pipeline.onLatencyWarning(() => { warned = true; });
-
-      await pipeline.processTrajectory(makeTrajectory());
-      expect(warned).toBe(true);
-    });
-  });
-
-  describe('factory function', () => {
-    it('should create pipeline via createUnifiedPipeline', async () => {
-      const p = createUnifiedPipeline(memory, undefined, persistence);
-      expect(p).toBeInstanceOf(UnifiedLearningPipeline);
-    });
-  });
-});