cognitive-core 0.2.5 → 0.3.1

package/tests/memory/playbook.test.ts

@@ -1,644 +0,0 @@
-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';
-
-describe('PlaybookLibrary', () => {
-  let tempDir: string;
-  let library: PlaybookLibrary;
-  let persistence: any;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
-    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 });
-  });
-
-  function createSamplePlaybook(overrides?: Partial<Playbook>): Playbook {
-    return {
-      id: `playbook-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-      name: 'fix-type-error',
-      applicability: {
-        situations: ['Debugging TypeScript type errors'],
-        triggers: ['TS2322', 'Type error'],
-        antiPatterns: ['Simple typo'],
-        domains: ['typescript', 'code'],
-      },
-      guidance: {
-        strategy: 'Analyze the error message and trace back to the source',
-        tactics: [
-          'Read the full error message',
-          'Identify the expected vs actual types',
-          'Check the variable declaration',
-        ],
-        steps: ['npm run typecheck', 'Fix the type mismatch'],
-      },
-      verification: {
-        successIndicators: ['Build passes', 'No type errors'],
-        failureIndicators: ['Same error persists', 'New errors appear'],
-      },
-      evolution: {
-        version: '1.0.0',
-        createdFrom: [],
-        failures: [],
-        refinements: [],
-        successCount: 0,
-        failureCount: 0,
-      },
-      confidence: 0.7,
-      complexity: 'moderate',
-      estimatedEffort: 3,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      ...overrides,
-    };
-  }
-
-  describe('add and get', () => {
-    it('should store and retrieve a playbook', async () => {
-      const playbook = createSamplePlaybook();
-      await library.add(playbook);
-
-      const retrieved = await library.get(playbook.id);
-      expect(retrieved).toBeDefined();
-      expect(retrieved?.name).toBe('fix-type-error');
-      expect(retrieved?.guidance.tactics).toHaveLength(3);
-    });
-
-    it('should return undefined for non-existent id', async () => {
-      const result = await library.get('non-existent');
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('findMatching', () => {
-    it('should find matching playbooks by context', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'type-fix',
-        applicability: {
-          situations: ['Fix TypeScript type errors in code'],
-          triggers: ['TS2322'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-      }));
-      await library.add(createSamplePlaybook({
-        name: 'perf-opt',
-        applicability: {
-          situations: ['Optimize database queries'],
-          triggers: ['slow query'],
-          antiPatterns: [],
-          domains: ['database'],
-        },
-      }));
-
-      const results = await library.findMatching('typescript type error', { k: 2 });
-      expect(results.length).toBeGreaterThanOrEqual(1);
-      expect(results[0].playbook.name).toBe('type-fix');
-    });
-
-    it('should match against triggers', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'specific-error-playbook',
-        applicability: {
-          situations: ['General error handling'],
-          triggers: ['TS2322: Type string is not assignable'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-      }));
-
-      const results = await library.findMatching('TS2322: Type string', { k: 1 });
-      expect(results.length).toBeGreaterThanOrEqual(1);
-      expect(results[0].playbook.name).toBe('specific-error-playbook');
-    });
-
-    it('should filter by domain', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'ts-playbook',
-        applicability: {
-          situations: ['TypeScript task'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-      }));
-      await library.add(createSamplePlaybook({
-        name: 'py-playbook',
-        applicability: {
-          situations: ['Python task'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['python'],
-        },
-      }));
-
-      const results = await library.findMatching('test', { domains: ['typescript'] });
-      expect(results.every(r => r.playbook.applicability.domains.includes('typescript'))).toBe(true);
-    });
-
-    it('should filter by minimum confidence', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'high-conf',
-        confidence: 0.9,
-      }));
-      await library.add(createSamplePlaybook({
-        name: 'low-conf',
-        confidence: 0.3,
-      }));
-
-      const results = await library.findMatching('test', { minConfidence: 0.8 });
-      expect(results.every(r => r.playbook.confidence >= 0.8)).toBe(true);
-    });
-
-    it('should exclude anti-patterns when requested', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'with-antipattern',
-        applicability: {
-          situations: ['General task'],
-          triggers: ['error'],
-          antiPatterns: ['simple typo', 'network issue'],
-          domains: ['code'],
-        },
-      }));
-
-      const resultsIncluding = await library.findMatching('simple typo error', {
-        excludeAntiPatterns: false,
-      });
-      const resultsExcluding = await library.findMatching('simple typo error', {
-        excludeAntiPatterns: true,
-      });
-
-      // When excluding anti-patterns, the match should be filtered out
-      expect(resultsIncluding.length).toBeGreaterThanOrEqual(resultsExcluding.length);
-    });
-  });
-
-  describe('recordSuccess and recordFailure', () => {
-    it('should update success statistics', async () => {
-      const playbook = createSamplePlaybook({ confidence: 0.5 });
-      const initialConfidence = playbook.confidence;
-      await library.add(playbook);
-
-      await library.recordSuccess(playbook.id, 'traj-1');
-      await library.recordSuccess(playbook.id, 'traj-2');
-
-      const updated = await library.get(playbook.id);
-      expect(updated?.evolution.successCount).toBe(2);
-      // Confidence should increase after successes (at least not decrease)
-      expect(updated?.confidence).toBeGreaterThanOrEqual(initialConfidence);
-    });
-
-    it('should update failure statistics', async () => {
-      const playbook = createSamplePlaybook({ confidence: 0.8 });
-      const initialConfidence = playbook.confidence;
-      await library.add(playbook);
-
-      await library.recordFailure(playbook.id, 'traj-1', 'monorepo', 'Failed with symlinks');
-
-      const updated = await library.get(playbook.id);
-      expect(updated?.evolution.failureCount).toBe(1);
-      expect(updated?.evolution.failures).toHaveLength(1);
-      // Confidence should decrease after failure (at least not increase)
-      expect(updated?.confidence).toBeLessThanOrEqual(initialConfidence);
-    });
-  });
-
-  describe('addRefinement', () => {
-    it('should add a refinement to the playbook', async () => {
-      const playbook = createSamplePlaybook();
-      await library.add(playbook);
-
-      await library.addRefinement(
-        playbook.id,
-        'monorepo',
-        'Also check workspace symlinks',
-        'failure'
-      );
-
-      const updated = await library.get(playbook.id);
-      expect(updated?.evolution.refinements).toHaveLength(1);
-      expect(updated?.evolution.refinements[0].context).toBe('monorepo');
-      expect(updated?.evolution.refinements[0].addition).toBe('Also check workspace symlinks');
-    });
-  });
-
-  describe('getByDomain and getMostEffective', () => {
-    it('should return playbooks by domain', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'ts1',
-        applicability: {
-          situations: ['TS task'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-      }));
-      await library.add(createSamplePlaybook({
-        name: 'ts2',
-        applicability: {
-          situations: ['TS task 2'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-      }));
-      await library.add(createSamplePlaybook({
-        name: 'py1',
-        applicability: {
-          situations: ['Python task'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['python'],
-        },
-      }));
-
-      const tsPlaybooks = await library.getByDomain('typescript');
-      expect(tsPlaybooks).toHaveLength(2);
-    });
-
-    it('should return most effective playbooks', async () => {
-      const p1 = createSamplePlaybook({ name: 'p1', confidence: 0.9 });
-      const p2 = createSamplePlaybook({ name: 'p2', confidence: 0.5 });
-      const p3 = createSamplePlaybook({ name: 'p3', confidence: 0.8 });
-      await library.add(p1);
-      await library.add(p2);
-      await library.add(p3);
-
-      // Add enough usage (getMostEffective requires at least 3 total uses)
-      await library.recordSuccess(p1.id, 'traj-1');
-      await library.recordSuccess(p1.id, 'traj-2');
-      await library.recordSuccess(p1.id, 'traj-3');
-
-      await library.recordSuccess(p2.id, 'traj-4');
-      await library.recordFailure(p2.id, 'traj-5', 'test', 'failed');
-      await library.recordFailure(p2.id, 'traj-6', 'test', 'failed');
-
-      const mostEffective = await library.getMostEffective(2);
-      expect(mostEffective).toHaveLength(2);
-      // p1 should be first (100% success rate) over p2 (33% success rate)
-      expect(mostEffective[0].id).toBe(p1.id);
-    });
-  });
-
-  describe('exists', () => {
-    it('should find existing playbook by name', async () => {
-      await library.add(createSamplePlaybook({ name: 'existing-playbook' }));
-
-      const result = await library.exists('existing-playbook');
-      expect(result).toBeDefined();
-      expect(result?.name).toBe('existing-playbook');
-    });
-
-    it('should find existing playbook by similarity', async () => {
-      await library.add(createSamplePlaybook({
-        name: 'unique-playbook',
-        applicability: {
-          situations: ['Very specific and unique situation description'],
-          triggers: [],
-          antiPatterns: [],
-          domains: ['code'],
-        },
-      }));
-
-      const result = await library.exists(
-        'Very specific and unique situation description',
-        0.85
-      );
-      expect(result).toBeDefined();
-    });
-
-    it('should return undefined if no match', async () => {
-      await library.add(createSamplePlaybook());
-
-      const result = await library.exists('completely unrelated topic');
-      expect(result).toBeUndefined();
-    });
-  });
-
-  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);
-
-      await library.add(createSamplePlaybook({ name: 'p1' }));
-      await library.add(createSamplePlaybook({ name: 'p2' }));
-
-      expect(await library.count()).toBe(2);
-
-      const all = await library.getAll();
-      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');
-    });
-  });
-});