cognitive-core 0.0.2 → 0.1.0

package/tests/memory/system.test.ts

@@ -0,0 +1,325 @@
+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 * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+describe('MemorySystem', () => {
+  let memory: MemorySystem;
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = path.join(process.cwd(), '.test-memory-system-' + Date.now());
+    await fs.mkdir(testDir, { recursive: true });
+    memory = createMemorySystem(testDir, {
+      maxExperiences: 4,
+      maxStrategies: 3,
+    });
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('storeTrajectory', () => {
+    it('should store trajectory and return experience', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'test', description: 'Test task' }),
+        steps: [
+          createStep({ thought: 'Step 1', action: 'action1', observation: 'obs1' }),
+        ],
+        outcome: successOutcome({ result: 'done' }),
+        agentId: 'agent-1',
+      });
+
+      const experience = await memory.storeTrajectory(trajectory);
+
+      expect(experience.taskInput).toBe('Test task');
+      expect(experience.success).toBe(true);
+      expect(experience.domain).toBe('test');
+      expect(experience.trajectoryId).toBe(trajectory.id);
+    });
+
+    it('should preserve trajectory structure in metadata', async () => {
+      // Create steps and manually set attributionScore (normally set by analyzer)
+      const step1 = createStep({
+        thought: 'Analyzing the error',
+        action: 'read main.ts',
+        observation: 'Found the issue',
+      });
+      step1.attributionScore = 0.3;
+
+      const step2 = createStep({
+        thought: 'Applying fix',
+        action: 'edit main.ts',
+        observation: 'Fixed successfully',
+      });
+      step2.attributionScore = 0.8;
+
+      const trajectory = createTrajectory({
+        task: createTask({
+          domain: 'code',
+          description: 'Fix the bug',
+          context: { file: 'main.ts' },
+        }),
+        steps: [step1, step2],
+        outcome: successOutcome({ linesChanged: 5 }),
+        agentId: 'claude-code',
+        wallTimeSeconds: 45.5,
+        llmCalls: 3,
+        metadata: { customField: 'value' },
+      });
+
+      const experience = await memory.storeTrajectory(trajectory);
+
+      // Check that trajectory structure is preserved in metadata
+      expect(experience.metadata).toBeDefined();
+      const meta = experience.metadata as Record<string, unknown>;
+
+      // Steps should be preserved (limited content)
+      expect(meta.steps).toBeDefined();
+      expect(Array.isArray(meta.steps)).toBe(true);
+      const steps = meta.steps as Array<Record<string, unknown>>;
+      expect(steps).toHaveLength(2);
+      expect(steps[0].thought).toBe('Analyzing the error');
+      expect(steps[0].action).toBe('read main.ts');
+      expect(steps[0].observation).toBe('Found the issue');
+      expect(steps[0].attributionScore).toBe(0.3);
+      expect(steps[1].attributionScore).toBe(0.8);
+
+      // Agent and timing info
+      expect(meta.agentId).toBe('claude-code');
+      expect(meta.wallTimeSeconds).toBe(45.5);
+      expect(meta.llmCalls).toBe(3);
+      expect(meta.stepCount).toBe(2);
+
+      // Task context
+      expect(meta.taskContext).toEqual({ file: 'main.ts' });
+
+      // Custom metadata
+      expect(meta.customField).toBe('value');
+    });
+
+    it('should handle failed trajectory', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'test', description: 'Failing task' }),
+        steps: [
+          createStep({ thought: 'Trying', action: 'attempt', observation: 'error' }),
+        ],
+        outcome: failureOutcome('Something went wrong'),
+        agentId: 'agent-1',
+      });
+
+      const experience = await memory.storeTrajectory(trajectory);
+
+      expect(experience.success).toBe(false);
+      expect(experience.feedback).toContain('Something went wrong');
+
+      // Check outcome details in metadata
+      const meta = experience.metadata as Record<string, unknown>;
+      const outcome = meta.outcome as Record<string, unknown>;
+      expect(outcome.errorInfo).toBe('Something went wrong');
+    });
+
+    it('should handle undefined solution in failed trajectory', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'test', description: 'No solution task' }),
+        steps: [],
+        outcome: {
+          success: false,
+          solution: undefined,
+          errorInfo: 'No solution found',
+          partialScore: 0.2,
+        },
+        agentId: 'agent-1',
+      });
+
+      const experience = await memory.storeTrajectory(trajectory);
+
+      expect(experience.success).toBe(false);
+      expect(experience.solutionOutput).toContain('No solution found');
+    });
+  });
+
+  describe('queryV2', () => {
+    beforeEach(async () => {
+      // Add test data
+      await memory.storeTrajectory(createTrajectory({
+        task: createTask({ domain: 'code', description: 'Fix TypeScript error' }),
+        steps: [createStep({ thought: 't', action: 'a', observation: 'o' })],
+        outcome: successOutcome({ fixed: true }),
+        agentId: 'agent',
+      }));
+
+      await memory.playbooks.add(createPlaybook({
+        name: 'Debug TypeScript',
+        applicability: {
+          situations: ['TypeScript errors'],
+          triggers: ['typescript', 'type error'],
+          antiPatterns: [],
+          domains: ['code'],
+        },
+        guidance: {
+          strategy: 'Check types',
+          tactics: ['Use strict mode'],
+        },
+        verification: {
+          successIndicators: ['compiles'],
+          failureIndicators: [],
+          commands: [],
+        },
+        confidence: 0.8,
+      }));
+    });
+
+    it('should query both experiences and playbooks', async () => {
+      const result = await memory.queryV2('typescript error');
+
+      expect(result.experiences).toBeDefined();
+      expect(result.playbooks).toBeDefined();
+    });
+
+    it('should filter by domain', async () => {
+      const result = await memory.queryV2('error', {
+        domains: ['code'],
+      });
+
+      expect(result.experiences.length).toBeGreaterThanOrEqual(0);
+      expect(result.playbooks.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should respect includeExperiences option', async () => {
+      const result = await memory.queryV2('error', {
+        includeExperiences: false,
+        includePlaybooks: true,
+      });
+
+      expect(result.experiences).toHaveLength(0);
+    });
+
+    it('should respect includePlaybooks option', async () => {
+      const result = await memory.queryV2('error', {
+        includeExperiences: true,
+        includePlaybooks: false,
+      });
+
+      expect(result.playbooks).toHaveLength(0);
+    });
+  });
+
+  describe('formatForPromptV2', () => {
+    it('should format query results for prompt injection', async () => {
+      await memory.playbooks.add(createPlaybook({
+        name: 'Test Playbook',
+        applicability: {
+          situations: ['testing'],
+          triggers: ['test'],
+          antiPatterns: [],
+          domains: ['test'],
+        },
+        guidance: {
+          strategy: 'Test strategy',
+          tactics: ['Tactic 1', 'Tactic 2'],
+          steps: ['Step 1', 'Step 2'],
+        },
+        verification: {
+          successIndicators: ['success'],
+          failureIndicators: [],
+          commands: [],
+        },
+        confidence: 0.9,
+      }));
+
+      const queryResult = await memory.queryV2('test');
+      const formatted = memory.formatForPromptV2(queryResult);
+
+      expect(formatted).toContain('Test Playbook');
+      expect(formatted).toContain('Test strategy');
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return memory statistics', async () => {
+      const stats = await memory.getStats();
+
+      expect(stats).toHaveProperty('experienceCount');
+      expect(stats).toHaveProperty('playbookCount');
+      expect(stats).toHaveProperty('metaObservationCount');
+      expect(typeof stats.experienceCount).toBe('number');
+    });
+  });
+
+  describe('capacity management', () => {
+    it('should return capacity status', async () => {
+      const status = await memory.getCapacityStatus();
+
+      expect(status.experiences).toHaveProperty('current');
+      expect(status.experiences).toHaveProperty('limit');
+      expect(status.playbooks).toHaveProperty('current');
+      expect(status.pruningEnabled).toBeDefined();
+    });
+
+    it('should update capacity config', () => {
+      memory.updateCapacityConfig({
+        maxExperiences: 500,
+        autoPrune: false,
+      });
+
+      // Config should be updated (tested via capacity status)
+      // Note: This is a unit test for the method, full pruning tested elsewhere
+    });
+  });
+
+  describe('effectiveness integration', () => {
+    it('should include annotationCount in stats', async () => {
+      const stats = await memory.getStats();
+      expect(stats).toHaveProperty('annotationCount');
+      expect(stats.annotationCount).toBe(0);
+    });
+
+    it('should return effectiveness metrics', async () => {
+      const metrics = await memory.getEffectivenessMetrics();
+
+      expect(metrics).toHaveProperty('totalTasks');
+      expect(metrics).toHaveProperty('guidedSuccessRate');
+      expect(metrics).toHaveProperty('unguidedSuccessRate');
+      expect(metrics).toHaveProperty('playbookEffectiveness');
+      expect(metrics.totalTasks).toBe(0);
+    });
+
+    it('should expose effectiveness tracker for direct annotation', async () => {
+      expect(memory.effectiveness).toBeDefined();
+
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'test', description: 'Eff test' }),
+        steps: [createStep({ thought: 't', action: 'a', observation: 'o' })],
+        outcome: successOutcome({ result: 'done' }),
+        agentId: 'agent',
+      });
+
+      const annotation = await memory.effectiveness.annotate(trajectory, [], [], []);
+      expect(annotation.trajectoryId).toBe(trajectory.id);
+
+      const stats = await memory.getStats();
+      expect(stats.annotationCount).toBe(1);
+    });
+
+    it('should accept time window in getEffectivenessMetrics', async () => {
+      const since = new Date('2025-01-01');
+      const until = new Date('2025-12-31');
+
+      const metrics = await memory.getEffectivenessMetrics({ since, until });
+      expect(metrics.windowStart).toEqual(since);
+      expect(metrics.windowEnd).toEqual(until);
+    });
+  });
+
+  describe('close', () => {
+    it('should close all stores without error', async () => {
+      await expect(memory.close()).resolves.not.toThrow();
+    });
+  });
+});