cognitive-core 0.1.0 → 0.2.0

package/tests/memory/playbook.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
 import type { Playbook } from '../../src/types/playbook.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';
@@ -8,15 +9,19 @@ import { tmpdir } from 'node:os';
 describe('PlaybookLibrary', () => {
   let tempDir: string;
   let library: PlaybookLibrary;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
-    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 });
   });
 
@@ -322,6 +327,164 @@ describe('PlaybookLibrary', () => {
     });
   });
 
+  describe('stability-plasticity', () => {
+    it('should dampen confidence changes for high consolidationStrength', async () => {
+      // Create a highly consolidated playbook
+      const consolidated = createSamplePlaybook({
+        name: 'consolidated',
+        confidence: 0.7,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 50,
+          failureCount: 2,
+          consolidationStrength: 5,
+        },
+      });
+      await library.add(consolidated);
+
+      // Create a fresh playbook
+      const fresh = createSamplePlaybook({
+        name: 'fresh',
+        confidence: 0.7,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 0,
+          failureCount: 0,
+          consolidationStrength: 0,
+        },
+      });
+      await library.add(fresh);
+
+      // Apply failure to both
+      await library.recordFailure(consolidated.id, 'traj-1', 'test', 'test fail');
+      await library.recordFailure(fresh.id, 'traj-2', 'test', 'test fail');
+
+      const updatedConsolidated = await library.get(consolidated.id);
+      const updatedFresh = await library.get(fresh.id);
+
+      // Both should decrease, but consolidated should decrease less
+      const consolidatedDelta = 0.7 - updatedConsolidated!.confidence;
+      const freshDelta = 0.7 - updatedFresh!.confidence;
+      expect(consolidatedDelta).toBeLessThan(freshDelta);
+    });
+
+    it('should behave as before when consolidationStrength is 0', async () => {
+      // A playbook with no consolidation should update like the original EMA
+      const playbook = createSamplePlaybook({
+        confidence: 0.5,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 0,
+          failureCount: 0,
+          consolidationStrength: 0,
+        },
+      });
+      await library.add(playbook);
+
+      await library.recordSuccess(playbook.id, 'traj-1');
+
+      const updated = await library.get(playbook.id);
+      // With cs=0: dampedDelta = rawDelta / (1 + 0) = rawDelta
+      // rawDelta = (1 - 0.5) * 0.1 = 0.05
+      // new confidence = 0.5 + 0.05 = 0.55
+      expect(updated!.confidence).toBeCloseTo(0.55, 2);
+    });
+
+    it('should grow consolidationStrength on success', async () => {
+      const playbook = createSamplePlaybook({
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 0,
+          failureCount: 0,
+          consolidationStrength: 0,
+        },
+      });
+      await library.add(playbook);
+
+      await library.recordSuccess(playbook.id, 'traj-1');
+      const after1 = await library.get(playbook.id);
+      expect(after1!.evolution.consolidationStrength).toBeCloseTo(0.05, 3);
+
+      await library.recordSuccess(playbook.id, 'traj-2');
+      const after2 = await library.get(playbook.id);
+      expect(after2!.evolution.consolidationStrength).toBeCloseTo(0.10, 3);
+    });
+
+    it('should not reduce consolidationStrength on failure', async () => {
+      const playbook = createSamplePlaybook({
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 0,
+          consolidationStrength: 2.0,
+        },
+      });
+      await library.add(playbook);
+
+      await library.recordFailure(playbook.id, 'traj-1', 'test', 'failed');
+      const updated = await library.get(playbook.id);
+      // consolidationStrength should remain at 2.0 (failures don't reduce it)
+      expect(updated!.evolution.consolidationStrength).toBe(2.0);
+    });
+
+    it('should cap consolidationStrength at 10', async () => {
+      const playbook = createSamplePlaybook({
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 100,
+          failureCount: 0,
+          consolidationStrength: 9.98,
+        },
+      });
+      await library.add(playbook);
+
+      await library.recordSuccess(playbook.id, 'traj-1');
+      const updated = await library.get(playbook.id);
+      expect(updated!.evolution.consolidationStrength).toBeLessThanOrEqual(10);
+    });
+
+    it('should backward compat — missing consolidationStrength defaults to 0', async () => {
+      // Playbook without consolidationStrength field
+      const playbook = createSamplePlaybook({
+        confidence: 0.5,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 0,
+          failureCount: 0,
+          // No consolidationStrength or domainBreadth
+        },
+      });
+      await library.add(playbook);
+
+      await library.recordSuccess(playbook.id, 'traj-1');
+      const updated = await library.get(playbook.id);
+      // Should still work, same as cs=0
+      expect(updated!.confidence).toBeCloseTo(0.55, 2);
+      expect(updated!.evolution.consolidationStrength).toBeCloseTo(0.05, 3);
+    });
+  });
+
   describe('count and getAll', () => {
     it('should return correct counts', async () => {
       expect(await library.count()).toBe(0);
@@ -335,4 +498,147 @@ describe('PlaybookLibrary', () => {
       expect(all).toHaveLength(2);
     });
   });
+
+  describe('MMR diversity', () => {
+    it('should match pure relevance ranking when lambda=1.0', async () => {
+      await library.add(createSamplePlaybook({
+        name: 'pb-a',
+        applicability: {
+          situations: ['Fix TypeScript type errors in production code'],
+          triggers: ['TS2322'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Analyze and fix type mismatches',
+          tactics: [],
+          steps: [],
+        },
+      }));
+      await library.add(createSamplePlaybook({
+        name: 'pb-b',
+        applicability: {
+          situations: ['Fix TypeScript import errors'],
+          triggers: ['import'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Check and resolve import paths',
+          tactics: [],
+          steps: [],
+        },
+      }));
+
+      // lambda=1.0 should give same order as no MMR
+      const pureRelevance = await library.findMatching('TypeScript type errors', { k: 2 });
+      const mmr1 = await library.findMatching('TypeScript type errors', { k: 2, lambda: 1.0 });
+
+      expect(pureRelevance.length).toBe(mmr1.length);
+      // Same top result
+      expect(pureRelevance[0].playbook.name).toBe(mmr1[0].playbook.name);
+    });
+
+    it('should diversify results when lambda is low', async () => {
+      // Add two very similar playbooks and one different
+      await library.add(createSamplePlaybook({
+        name: 'similar-1',
+        applicability: {
+          situations: ['Debug TypeScript type error in code'],
+          triggers: ['type error'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Read the full error message and trace back to the source type declaration',
+          tactics: [],
+          steps: [],
+        },
+      }));
+      await library.add(createSamplePlaybook({
+        name: 'similar-2',
+        applicability: {
+          situations: ['Debug TypeScript type error in tests'],
+          triggers: ['type error'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Read the full error message and trace back to the source type declaration',
+          tactics: [],
+          steps: [],
+        },
+      }));
+      await library.add(createSamplePlaybook({
+        name: 'different',
+        applicability: {
+          situations: ['Debug TypeScript type error using alternative approach'],
+          triggers: ['type error'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Use the TypeScript compiler API to programmatically analyze types',
+          tactics: [],
+          steps: [],
+        },
+      }));
+
+      // With low lambda, MMR should prefer the diverse playbook over the near-duplicate
+      const diverseResults = await library.findMatching('TypeScript type error', {
+        k: 3,
+        lambda: 0.3,
+      });
+
+      expect(diverseResults.length).toBe(3);
+      // The "different" strategy playbook should appear in the top results
+      const names = diverseResults.map((r) => r.playbook.name);
+      expect(names).toContain('different');
+    });
+
+    it('should avoid returning near-duplicates with strong diversity bias', async () => {
+      // Add 3 playbooks with identical strategies
+      for (let i = 0; i < 3; i++) {
+        await library.add(createSamplePlaybook({
+          name: `clone-${i}`,
+          applicability: {
+            situations: ['Resolve eslint warnings in codebase'],
+            triggers: ['eslint warning'],
+            antiPatterns: [],
+            domains: ['typescript'],
+          },
+          guidance: {
+            strategy: 'Run eslint with auto-fix flag',
+            tactics: [],
+            steps: [],
+          },
+        }));
+      }
+
+      // Add one unique playbook
+      await library.add(createSamplePlaybook({
+        name: 'unique-lint',
+        applicability: {
+          situations: ['Resolve eslint warnings using custom rules'],
+          triggers: ['eslint warning'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+        guidance: {
+          strategy: 'Create custom eslint rule to prevent the warning pattern',
+          tactics: [],
+          steps: [],
+        },
+      }));
+
+      // With diversity bias, the unique one should appear by position 2
+      const results = await library.findMatching('eslint warnings', {
+        k: 2,
+        lambda: 0.3,
+      });
+
+      const names = results.map((r) => r.playbook.name);
+      expect(names).toContain('unique-lint');
+    });
+  });
 });

package/tests/memory/provenance.test.ts

@@ -3,6 +3,7 @@ import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playboo
 import { loadCuratedPlaybooks, type CuratedPlaybookFile } from '../../src/memory/curated-loader.js';
 import type { Playbook, PlaybookProvenance } from '../../src/types/playbook.js';
 import { createPlaybook } from '../../src/types/playbook.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -10,15 +11,19 @@ import { tmpdir } from 'node:os';
 describe('Playbook Provenance', () => {
   let tempDir: string;
   let library: PlaybookLibrary;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-prov-test-'));
-    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 });
   });
 
@@ -373,17 +378,21 @@ describe('Curated Playbook Loader', () => {
   let tempDir: string;
   let curatedDir: string;
   let library: PlaybookLibrary;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-curated-test-'));
     curatedDir = join(tempDir, 'curated');
     await mkdir(curatedDir, { recursive: true });
-    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/reasoning-bank.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect } from 'vitest';
+import { ReasoningBank } from '../../src/memory/reasoning-bank.js';
+import { createExperience } from '../../src/types/memory.js';
+
+function makeExperience(
+  taskInput: string,
+  domain: string,
+  success = true,
+  accessScore = 1.0
+) {
+  return createExperience({
+    taskInput,
+    solutionOutput: `Solution for: ${taskInput}`,
+    feedback: success ? 'Success' : 'Failed',
+    success,
+    domain,
+    trajectoryId: `traj-${crypto.randomUUID().slice(0, 8)}`,
+    metadata: { accessScore },
+  });
+}
+
+describe('ReasoningBank', () => {
+  describe('buildClusters', () => {
+    it('should form clusters from similar experiences', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2, maxClusters: 5 });
+
+      const experiences = [
+        // Cluster 1: TypeScript type errors
+        makeExperience('Fix TypeScript type error in component', 'typescript'),
+        makeExperience('Resolve TypeScript type mismatch in handler', 'typescript'),
+        makeExperience('Debug TypeScript type assertion failure', 'typescript'),
+        // Cluster 2: CSS styling
+        makeExperience('Fix CSS layout alignment issue in sidebar', 'css'),
+        makeExperience('Correct CSS flexbox alignment in header', 'css'),
+        makeExperience('Fix CSS grid alignment on main page', 'css'),
+      ];
+
+      bank.buildClusters(experiences);
+
+      expect(bank.clusterCount).toBeGreaterThanOrEqual(2);
+      const clusters = bank.getClusters();
+      expect(clusters.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('should not cluster when too few experiences', () => {
+      const bank = new ReasoningBank({ minClusterSize: 5 });
+
+      const experiences = [
+        makeExperience('Fix a bug', 'typescript'),
+        makeExperience('Add a feature', 'typescript'),
+      ];
+
+      bank.buildClusters(experiences);
+
+      expect(bank.clusterCount).toBe(0);
+    });
+
+    it('should only cluster successful experiences', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      const experiences = [
+        makeExperience('Fix TypeScript error', 'typescript', true),
+        makeExperience('Fix TypeScript import', 'typescript', true),
+        makeExperience('Fix TypeScript build', 'typescript', true),
+        makeExperience('Fix failing deploy', 'devops', false),
+        makeExperience('Fix broken pipeline', 'devops', false),
+        makeExperience('Fix CI configuration', 'devops', false),
+      ];
+
+      bank.buildClusters(experiences);
+
+      // All clusters should only contain successful experiences
+      for (const cluster of bank.getClusters()) {
+        expect(cluster.successRate).toBe(1.0);
+      }
+    });
+  });
+
+  describe('findInCluster', () => {
+    it('should return experiences from matching cluster', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      const experiences = [
+        makeExperience('Fix TypeScript type error in component', 'typescript'),
+        makeExperience('Fix TypeScript type mismatch in API', 'typescript'),
+        makeExperience('Fix TypeScript type assertion issue', 'typescript'),
+        makeExperience('Fix CSS layout bug in sidebar', 'css'),
+        makeExperience('Fix CSS flexbox alignment issue', 'css'),
+        makeExperience('Fix CSS grid layout problem', 'css'),
+      ];
+
+      bank.buildClusters(experiences);
+
+      const results = bank.findInCluster('TypeScript type error', { k: 3 });
+
+      expect(results.length).toBeGreaterThan(0);
+      // Results should come from the typescript cluster
+      for (const r of results) {
+        expect(r.experience.domain).toBe('typescript');
+        expect(r.clusterId).toBeDefined();
+        expect(r.score).toBeGreaterThan(0);
+      }
+    });
+
+    it('should return empty array when no clusters exist', () => {
+      const bank = new ReasoningBank();
+      const results = bank.findInCluster('anything');
+      expect(results).toHaveLength(0);
+    });
+
+    it('should filter by domain', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      const experiences = [
+        makeExperience('Fix error in production code', 'typescript'),
+        makeExperience('Fix error in production system', 'typescript'),
+        makeExperience('Fix error in production app', 'typescript'),
+        makeExperience('Fix error in production deploy', 'devops'),
+        makeExperience('Fix error in production pipeline', 'devops'),
+        makeExperience('Fix error in production build', 'devops'),
+      ];
+
+      bank.buildClusters(experiences);
+
+      const results = bank.findInCluster('production error', {
+        domain: 'devops',
+      });
+
+      for (const r of results) {
+        expect(r.experience.domain).toBe('devops');
+      }
+    });
+  });
+
+  describe('cluster labels', () => {
+    it('should reflect common task patterns', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      const experiences = [
+        makeExperience('Fix TypeScript type error in component file', 'typescript'),
+        makeExperience('Fix TypeScript type error in module export', 'typescript'),
+        makeExperience('Fix TypeScript type error in interface', 'typescript'),
+      ];
+
+      bank.buildClusters(experiences);
+
+      const clusters = bank.getClusters();
+      expect(clusters.length).toBeGreaterThan(0);
+
+      // Label should contain common tokens like "fix", "typescript", "type", or "error"
+      const label = clusters[0].label.toLowerCase();
+      const hasCommonToken =
+        label.includes('fix') ||
+        label.includes('typescript') ||
+        label.includes('type') ||
+        label.includes('error');
+      expect(hasCommonToken).toBe(true);
+    });
+  });
+
+  describe('cluster stats', () => {
+    it('should report correct success rates', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      // All successful (failures are filtered out before clustering)
+      const experiences = [
+        makeExperience('Fix TypeScript error one', 'typescript', true),
+        makeExperience('Fix TypeScript error two', 'typescript', true),
+        makeExperience('Fix TypeScript error three', 'typescript', true),
+      ];
+
+      bank.buildClusters(experiences);
+
+      const stats = bank.getClusterStats();
+      expect(stats.length).toBeGreaterThan(0);
+
+      for (const stat of stats) {
+        expect(stat.successRate).toBe(1.0); // Only successful ones clustered
+        expect(stat.size).toBeGreaterThanOrEqual(2);
+        expect(stat.label).toBeDefined();
+        expect(stat.clusterId).toBeDefined();
+      }
+    });
+  });
+
+  describe('re-clustering', () => {
+    it('should track experiences since last cluster', () => {
+      const bank = new ReasoningBank({ reclusterInterval: 3 });
+
+      expect(bank.shouldRecluster()).toBe(false);
+
+      bank.notifyNewExperience();
+      bank.notifyNewExperience();
+      expect(bank.shouldRecluster()).toBe(false);
+
+      bank.notifyNewExperience();
+      expect(bank.shouldRecluster()).toBe(true);
+    });
+
+    it('should reset counter after buildClusters', () => {
+      const bank = new ReasoningBank({ reclusterInterval: 2 });
+
+      bank.notifyNewExperience();
+      bank.notifyNewExperience();
+      expect(bank.shouldRecluster()).toBe(true);
+
+      bank.buildClusters([
+        makeExperience('Task A one', 'typescript'),
+        makeExperience('Task A two', 'typescript'),
+        makeExperience('Task A three', 'typescript'),
+      ]);
+
+      expect(bank.shouldRecluster()).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty experience list', () => {
+      const bank = new ReasoningBank();
+      bank.buildClusters([]);
+      expect(bank.clusterCount).toBe(0);
+      expect(bank.getClusters()).toHaveLength(0);
+      expect(bank.getClusterStats()).toHaveLength(0);
+    });
+
+    it('should handle all identical experiences', () => {
+      const bank = new ReasoningBank({ minClusterSize: 2 });
+
+      const experiences = Array.from({ length: 5 }, () =>
+        makeExperience('Fix TypeScript error', 'typescript')
+      );
+
+      bank.buildClusters(experiences);
+
+      // Should form at least one cluster
+      expect(bank.clusterCount).toBeGreaterThanOrEqual(1);
+    });
+  });
+});