cognitive-core 0.1.2 → 0.2.1

package/tests/memory/reflexion.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ReflexionMemory } from '../../src/memory/reflexion.js';
+import type { ReflexionEpisode } from '../../src/types/memory.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+function createSampleEpisode(overrides?: Partial<ReflexionEpisode>): ReflexionEpisode {
+  return {
+    id: overrides?.id ?? crypto.randomUUID(),
+    trajectoryId: overrides?.trajectoryId ?? `traj-${crypto.randomUUID()}`,
+    taskSummary: overrides?.taskSummary ?? 'Fix the typescript import error',
+    outcome: overrides?.outcome ?? 'success',
+    selfCritique: overrides?.selfCritique ?? 'Completed efficiently in 2 steps',
+    keyInsights: overrides?.keyInsights ?? ['Tools used: ReadFile, EditFile'],
+    strategyAssessment: overrides?.strategyAssessment ?? 'Succeeded without playbook guidance',
+    suggestedPlaybookUpdates: overrides?.suggestedPlaybookUpdates ?? [],
+    domain: overrides?.domain ?? 'typescript',
+    createdAt: overrides?.createdAt ?? new Date(),
+  };
+}
+
+describe('ReflexionMemory', () => {
+  let tempDir: string;
+  let memory: ReflexionMemory;
+  let persistence: any;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-reflexion-test-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = new ReflexionMemory(persistence);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('add and get', () => {
+    it('should store and retrieve a reflexion episode', async () => {
+      const episode = createSampleEpisode();
+      await memory.add(episode);
+
+      const retrieved = await memory.get(episode.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.taskSummary).toBe('Fix the typescript import error');
+      expect(retrieved?.outcome).toBe('success');
+      expect(retrieved?.keyInsights).toHaveLength(1);
+    });
+
+    it('should return undefined for non-existent id', async () => {
+      const result = await memory.get('non-existent');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getByTrajectory', () => {
+    it('should find an episode by trajectory ID', async () => {
+      const trajectoryId = 'specific-trajectory-id';
+      const episode = createSampleEpisode({ trajectoryId });
+      await memory.add(episode);
+
+      const retrieved = await memory.getByTrajectory(trajectoryId);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.trajectoryId).toBe(trajectoryId);
+      expect(retrieved?.id).toBe(episode.id);
+    });
+
+    it('should return undefined for non-existent trajectory', async () => {
+      await memory.add(createSampleEpisode());
+
+      const result = await memory.getByTrajectory('no-such-trajectory');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getRecent', () => {
+    it('should return episodes sorted by most recent first', async () => {
+      const ep1 = createSampleEpisode({
+        taskSummary: 'First task',
+        createdAt: new Date('2025-01-01'),
+      });
+      const ep2 = createSampleEpisode({
+        taskSummary: 'Second task',
+        createdAt: new Date('2025-06-01'),
+      });
+      const ep3 = createSampleEpisode({
+        taskSummary: 'Third task',
+        createdAt: new Date('2025-03-01'),
+      });
+
+      await memory.add(ep1);
+      await memory.add(ep2);
+      await memory.add(ep3);
+
+      const recent = await memory.getRecent({ k: 3 });
+      expect(recent).toHaveLength(3);
+      expect(recent[0].taskSummary).toBe('Second task');
+      expect(recent[1].taskSummary).toBe('Third task');
+      expect(recent[2].taskSummary).toBe('First task');
+    });
+
+    it('should limit results to k', async () => {
+      for (let i = 0; i < 5; i++) {
+        await memory.add(createSampleEpisode({ taskSummary: `Task ${i}` }));
+      }
+
+      const recent = await memory.getRecent({ k: 2 });
+      expect(recent).toHaveLength(2);
+    });
+
+    it('should filter by domain', async () => {
+      await memory.add(createSampleEpisode({ domain: 'typescript' }));
+      await memory.add(createSampleEpisode({ domain: 'python' }));
+      await memory.add(createSampleEpisode({ domain: 'typescript' }));
+
+      const results = await memory.getRecent({ domain: 'typescript' });
+      expect(results).toHaveLength(2);
+      expect(results.every((ep) => ep.domain === 'typescript')).toBe(true);
+    });
+
+    it('should filter by outcome', async () => {
+      await memory.add(createSampleEpisode({ outcome: 'success' }));
+      await memory.add(createSampleEpisode({ outcome: 'failure' }));
+      await memory.add(createSampleEpisode({ outcome: 'success' }));
+      await memory.add(createSampleEpisode({ outcome: 'partial' }));
+
+      const failures = await memory.getRecent({ outcome: 'failure' });
+      expect(failures).toHaveLength(1);
+      expect(failures[0].outcome).toBe('failure');
+
+      const successes = await memory.getRecent({ outcome: 'success' });
+      expect(successes).toHaveLength(2);
+    });
+
+    it('should combine domain and outcome filters', async () => {
+      await memory.add(createSampleEpisode({ domain: 'typescript', outcome: 'success' }));
+      await memory.add(createSampleEpisode({ domain: 'typescript', outcome: 'failure' }));
+      await memory.add(createSampleEpisode({ domain: 'python', outcome: 'success' }));
+
+      const results = await memory.getRecent({
+        domain: 'typescript',
+        outcome: 'failure',
+      });
+      expect(results).toHaveLength(1);
+      expect(results[0].domain).toBe('typescript');
+      expect(results[0].outcome).toBe('failure');
+    });
+  });
+
+  describe('count', () => {
+    it('should return correct count', async () => {
+      expect(await memory.count()).toBe(0);
+
+      await memory.add(createSampleEpisode());
+      expect(await memory.count()).toBe(1);
+
+      await memory.add(createSampleEpisode());
+      expect(await memory.count()).toBe(2);
+    });
+  });
+});

package/tests/memory/skill-exporter.test.ts

@@ -9,6 +9,7 @@ import {
   exportPlaybooksAsSkills,
   exportPlaybookAsSkill,
 } from '../../src/memory/skill-exporter.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import type { Playbook } from '../../src/types/playbook.js';
 
 function createSamplePlaybook(overrides?: Partial<Playbook>): Playbook {
@@ -272,16 +273,20 @@ describe('exportPlaybooksAsSkills', () => {
   let tempDir: string;
   let outputDir: string;
   let library: PlaybookLibrary;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-skill-export-'));
     outputDir = join(tempDir, 'skills-output');
-    library = createPlaybookLibrary(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    library = createPlaybookLibrary(persistence);
     await library.init();
   });
 
   afterEach(async () => {
     await library.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 

package/tests/memory/system.test.ts

@@ -2,17 +2,21 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
 import { createTrajectory, createStep, createTask, successOutcome, failureOutcome } from '../../src/types/index.js';
 import { createPlaybook } from '../../src/types/playbook.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 
 describe('MemorySystem', () => {
   let memory: MemorySystem;
   let testDir: string;
+  let persistence: any;
 
   beforeEach(async () => {
     testDir = path.join(process.cwd(), '.test-memory-system-' + Date.now());
     await fs.mkdir(testDir, { recursive: true });
-    memory = createMemorySystem(testDir, {
+    persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, testDir, {
       maxExperiences: 4,
       maxStrategies: 3,
     });
@@ -21,6 +25,7 @@ describe('MemorySystem', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await fs.rm(testDir, { recursive: true, force: true });
   });
 

package/tests/memory/temporal-compressor.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TemporalCompressor, type CompressionResult } from '../../src/memory/temporal-compressor.js';
+import type { Experience } from '../../src/types/memory.js';
+
+function makeExperience(overrides: Partial<Experience> = {}): Experience {
+  return {
+    id: overrides.id ?? `exp-${crypto.randomUUID().slice(0, 8)}`,
+    taskInput: overrides.taskInput ?? 'Fix the broken authentication module in the login flow',
+    solutionOutput: overrides.solutionOutput ?? 'Updated the auth middleware to check token expiry. Fixed the session refresh logic. Added error handling for expired tokens.',
+    feedback: overrides.feedback ?? 'All tests pass. Authentication working correctly.',
+    success: overrides.success ?? true,
+    domain: overrides.domain ?? 'backend',
+    trajectoryId: overrides.trajectoryId ?? `traj-${crypto.randomUUID().slice(0, 8)}`,
+    usageCount: overrides.usageCount ?? 0,
+    accessScore: overrides.accessScore ?? 1.0,
+    retrievalCount: overrides.retrievalCount ?? 0,
+    createdAt: overrides.createdAt ?? new Date(),
+    tier: overrides.tier ?? 'hot',
+    compressed: overrides.compressed,
+    metadata: overrides.metadata ?? {},
+  } as Experience;
+}
+
+describe('TemporalCompressor', () => {
+  let compressor: TemporalCompressor;
+
+  beforeEach(() => {
+    compressor = new TemporalCompressor({
+      hotThreshold: 0.5,
+      warmThreshold: 0.2,
+      evictionThreshold: 0.05,
+      hysteresis: 0.05,
+    });
+  });
+
+  describe('hot experiences with high accessScore stay hot', () => {
+    it('should not change tier for high-scoring experiences', async () => {
+      const experiences = [
+        makeExperience({ id: 'high-1', accessScore: 0.9, tier: 'hot' }),
+        makeExperience({ id: 'high-2', accessScore: 0.7, tier: 'hot' }),
+      ];
+
+      const result = await compressor.compress(experiences);
+
+      expect(result.unchanged).toContain('high-1');
+      expect(result.unchanged).toContain('high-2');
+      expect(result.demoted).toHaveLength(0);
+      expect(result.evicted).toHaveLength(0);
+    });
+  });
+
+  describe('low accessScore experiences demote to warm', () => {
+    it('should mark low-scoring hot experience as pending on first pass', async () => {
+      const experiences = [
+        makeExperience({ id: 'low-1', accessScore: 0.3, tier: 'hot' }),
+      ];
+
+      // First pass: should be unchanged (hysteresis)
+      const result1 = await compressor.compress(experiences);
+      expect(result1.unchanged).toContain('low-1');
+      expect(result1.demoted).toHaveLength(0);
+    });
+
+    it('should demote on second consecutive pass below threshold', async () => {
+      const experiences = [
+        makeExperience({ id: 'low-1', accessScore: 0.3, tier: 'hot' }),
+      ];
+
+      // First pass: marks pending
+      await compressor.compress(experiences);
+
+      // Second pass: should demote
+      const result2 = await compressor.compress(experiences);
+      expect(result2.demoted).toContain('low-1');
+      expect(result2.updates.has('low-1')).toBe(true);
+      expect(result2.updates.get('low-1')!.tier).toBe('warm');
+    });
+  });
+
+  describe('warm to cold strips to summary', () => {
+    it('should demote warm to cold after two passes', async () => {
+      const experiences = [
+        makeExperience({
+          id: 'warm-1',
+          accessScore: 0.1,
+          tier: 'warm',
+          compressed: {
+            keySteps: ['Step 1: Check auth', 'Step 2: Fix token'],
+            summary: '',
+            originalStepCount: 5,
+          },
+        }),
+      ];
+
+      // First pass: mark pending
+      await compressor.compress(experiences);
+
+      // Second pass: demote
+      const result2 = await compressor.compress(experiences);
+      expect(result2.demoted).toContain('warm-1');
+      expect(result2.updates.get('warm-1')!.tier).toBe('cold');
+    });
+  });
+
+  describe('cold to evicted returns eviction recommendation', () => {
+    it('should evict cold experience below eviction threshold after two passes', async () => {
+      const experiences = [
+        makeExperience({
+          id: 'cold-1',
+          accessScore: 0.02,
+          tier: 'cold',
+          compressed: {
+            keySteps: [],
+            summary: 'Old task summary',
+            originalStepCount: 3,
+          },
+        }),
+      ];
+
+      // First pass: mark pending
+      await compressor.compress(experiences);
+
+      // Second pass: evict
+      const result2 = await compressor.compress(experiences);
+      expect(result2.evicted).toContain('cold-1');
+    });
+
+    it('should not evict non-cold experiences even if below eviction threshold', async () => {
+      const experiences = [
+        makeExperience({ id: 'hot-low', accessScore: 0.01, tier: 'hot' }),
+      ];
+
+      // Two passes: should demote to warm, not evict
+      await compressor.compress(experiences);
+      const result2 = await compressor.compress(experiences);
+
+      expect(result2.evicted).toHaveLength(0);
+      expect(result2.demoted).toContain('hot-low');
+      expect(result2.updates.get('hot-low')!.tier).toBe('warm');
+    });
+  });
+
+  describe('hysteresis prevents single-pass oscillation', () => {
+    it('should not demote on a single pass', async () => {
+      const experiences = [
+        makeExperience({ id: 'hyst-1', accessScore: 0.3, tier: 'hot' }),
+      ];
+
+      const result = await compressor.compress(experiences);
+      expect(result.demoted).toHaveLength(0);
+      expect(result.unchanged).toContain('hyst-1');
+    });
+
+    it('should require score above threshold+hysteresis for promotion', async () => {
+      const experiences = [
+        makeExperience({ id: 'promo-1', accessScore: 0.22, tier: 'cold' }),
+      ];
+
+      // 0.22 < warmThreshold(0.2) + hysteresis(0.05) = 0.25
+      const result = await compressor.compress(experiences);
+      expect(result.promoted).toHaveLength(0);
+      expect(result.unchanged).toContain('promo-1');
+    });
+
+    it('should promote when score is above threshold+hysteresis', async () => {
+      const experiences = [
+        makeExperience({ id: 'promo-2', accessScore: 0.3, tier: 'cold' }),
+      ];
+
+      // 0.3 >= warmThreshold(0.2) + hysteresis(0.05) = 0.25
+      const result = await compressor.compress(experiences);
+      expect(result.promoted).toContain('promo-2');
+      expect(result.updates.get('promo-2')!.tier).toBe('warm');
+    });
+  });
+
+  describe('compression preserves critical fields', () => {
+    it('compressToWarm should preserve id, domain, success, taskInput', () => {
+      const exp = makeExperience({
+        id: 'preserve-1',
+        domain: 'frontend',
+        success: true,
+        taskInput: 'Fix the CSS layout issue',
+      });
+
+      const warm = compressor.compressToWarm(exp);
+
+      expect(warm.id).toBe('preserve-1');
+      expect(warm.domain).toBe('frontend');
+      expect(warm.success).toBe(true);
+      expect(warm.taskInput).toBe('Fix the CSS layout issue');
+      expect(warm.tier).toBe('warm');
+    });
+
+    it('compressToCold should preserve id, domain, success', () => {
+      const exp = makeExperience({
+        id: 'preserve-2',
+        domain: 'backend',
+        success: false,
+        taskInput: 'A very long task input that should be truncated at two hundred characters maximum to save space in the cold tier representation while still preserving enough context for future retrieval purposes',
+        compressed: {
+          keySteps: ['Step 1'],
+          summary: '',
+          originalStepCount: 5,
+        },
+      });
+
+      const cold = compressor.compressToCold(exp);
+
+      expect(cold.id).toBe('preserve-2');
+      expect(cold.domain).toBe('backend');
+      expect(cold.success).toBe(false);
+      expect(cold.tier).toBe('cold');
+      expect(cold.taskInput.length).toBeLessThanOrEqual(200);
+    });
+  });
+
+  describe('compressToWarm keeps key steps', () => {
+    it('should extract key steps from metadata trajectory steps', () => {
+      const exp = makeExperience({
+        metadata: {
+          steps: [
+            { action: 'Read src/auth.ts', observation: 'File contains auth logic', attributionScore: 0.8 },
+            { action: 'Think about approach', observation: 'Considering options', attributionScore: 0.1 },
+            { action: 'Edit src/auth.ts', observation: 'File updated successfully', attributionScore: 0.9 },
+            { action: 'Bash npm test', observation: 'All 15 tests pass', attributionScore: 0.6 },
+          ],
+          stepCount: 4,
+        },
+      });
+
+      const warm = compressor.compressToWarm(exp);
+
+      expect(warm.compressed).toBeDefined();
+      expect(warm.compressed!.keySteps.length).toBeGreaterThan(0);
+      expect(warm.compressed!.originalStepCount).toBe(4);
+      expect(warm.tier).toBe('warm');
+    });
+
+    it('should fall back to line-based extraction without metadata', () => {
+      const exp = makeExperience({
+        solutionOutput: 'Line 1: Started investigation\nLine 2: Found the bug\nLine 3: Error in auth module\nLine 4: Applied fix\nLine 5: Ran tests\nLine 6: All tests pass\nLine 7: Done',
+        metadata: {},
+      });
+
+      const warm = compressor.compressToWarm(exp);
+
+      expect(warm.compressed).toBeDefined();
+      expect(warm.compressed!.keySteps.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('compressToCold produces readable summary', () => {
+    it('should generate a summary from key steps', () => {
+      const exp = makeExperience({
+        taskInput: 'Fix authentication bug in login handler',
+        domain: 'backend',
+        success: true,
+        feedback: 'All tests pass',
+        compressed: {
+          keySteps: ['Check auth middleware', 'Fix token validation', 'Add error handling'],
+          summary: '',
+          originalStepCount: 8,
+        },
+      });
+
+      const cold = compressor.compressToCold(exp);
+
+      expect(cold.compressed).toBeDefined();
+      expect(cold.compressed!.summary.length).toBeGreaterThan(0);
+      expect(cold.compressed!.summary).toContain('backend');
+      expect(cold.compressed!.summary).toContain('Successfully');
+      expect(cold.solutionOutput).toBe(cold.compressed!.summary);
+    });
+
+    it('should reflect failure in summary', () => {
+      const exp = makeExperience({
+        taskInput: 'Deploy to production',
+        domain: 'devops',
+        success: false,
+        feedback: 'Deployment failed',
+        compressed: {
+          keySteps: ['Build step failed'],
+          summary: '',
+          originalStepCount: 3,
+        },
+      });
+
+      const cold = compressor.compressToCold(exp);
+
+      expect(cold.compressed!.summary).toContain('Failed to');
+    });
+  });
+
+  describe('mixed scenarios', () => {
+    it('should handle a batch with mixed tiers and scores', async () => {
+      const experiences = [
+        makeExperience({ id: 'hot-high', accessScore: 0.8, tier: 'hot' }),
+        makeExperience({ id: 'hot-low', accessScore: 0.15, tier: 'hot' }),
+        makeExperience({ id: 'warm-ok', accessScore: 0.3, tier: 'warm' }),
+        makeExperience({ id: 'cold-dead', accessScore: 0.01, tier: 'cold' }),
+      ];
+
+      // First pass
+      const result1 = await compressor.compress(experiences);
+      expect(result1.unchanged).toContain('hot-high');
+      // hot-low is pending demotion
+      // warm-ok should be promoted (0.3 > 0.5+0.05? No, 0.3 < 0.55)
+      // Actually warm → hot needs 0.55, and 0.3 < 0.55 so unchanged
+      expect(result1.promoted).toHaveLength(0);
+
+      // Second pass
+      const result2 = await compressor.compress(experiences);
+      expect(result2.demoted).toContain('hot-low');
+      expect(result2.unchanged).toContain('hot-high');
+    });
+  });
+});