cognitive-core 0.0.2 → 0.1.0

package/tests/memory/playbook.test.ts

@@ -0,0 +1,338 @@
+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 { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('PlaybookLibrary', () => {
+  let tempDir: string;
+  let library: PlaybookLibrary;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
+    library = createPlaybookLibrary(tempDir);
+    await library.init();
+  });
+
+  afterEach(async () => {
+    await library.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('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);
+    });
+  });
+});