cognitive-core 0.0.2 → 0.1.2

package/tests/learning/usage-inference.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect } from 'vitest';
+import {
+  PlaybookUsageInference,
+  createUsageInference,
+} from '../../src/learning/usage-inference.js';
+import type { Playbook } from '../../src/types/playbook.js';
+import type { Trajectory } from '../../src/types/trajectory.js';
+
+describe('PlaybookUsageInference', () => {
+  let inference: PlaybookUsageInference;
+
+  beforeEach(() => {
+    inference = createUsageInference({
+      minMatchConfidence: 0.3,
+      tacticMatchThreshold: 0.5,
+    });
+  });
+
+  function createSamplePlaybook(overrides?: Partial<Playbook>): Playbook {
+    return {
+      id: `playbook-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name: 'debug-error',
+      applicability: {
+        situations: ['Debugging runtime errors'],
+        triggers: ['Error:', 'Exception'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Identify the error, trace the cause, fix it',
+        tactics: [
+          'Read the error message carefully',
+          'Check the stack trace',
+          'Identify the root cause',
+          'Apply the fix',
+          'Verify the fix works',
+        ],
+      },
+      verification: {
+        successIndicators: ['Error resolved', 'Tests pass'],
+        failureIndicators: ['Error persists', 'New errors'],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 0,
+        failureCount: 0,
+      },
+      confidence: 0.8,
+      complexity: 'moderate',
+      estimatedEffort: 3,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  function createSampleTrajectory(steps: Array<{
+    thought?: string;
+    action: string;
+    observation?: string;
+  }>, overrides?: Partial<Trajectory>): Trajectory {
+    return {
+      id: `traj-${Date.now()}`,
+      task: {
+        id: 'task-1',
+        description: 'Fix the error in the code',
+        domain: 'code',
+        context: {},
+        metadata: {},
+        createdAt: new Date(),
+      },
+      steps: steps.map((s, i) => ({
+        index: i,
+        thought: s.thought,
+        action: s.action,
+        observation: s.observation,
+        timestamp: new Date(),
+      })),
+      outcome: { success: true, quality: 'good' },
+      metadata: {},
+      startedAt: new Date(),
+      completedAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  describe('inferUsage', () => {
+    it('should detect playbook usage when tactics match', async () => {
+      const playbook = createSamplePlaybook({
+        guidance: {
+          strategy: 'Debug by reading errors',
+          tactics: [
+            'Read the error message',
+            'Check the stack trace',
+            'Fix the issue',
+          ],
+        },
+      });
+
+      const trajectory = createSampleTrajectory([
+        {
+          thought: 'Let me read the error message carefully',
+          action: 'cat error.log',
+          observation: 'TypeError: Cannot read property of undefined',
+        },
+        {
+          thought: 'I should check the stack trace',
+          action: 'cat stacktrace.txt',
+          observation: 'at line 42 in main.ts',
+        },
+        {
+          thought: 'Now I will fix the issue',
+          action: 'edit main.ts',
+          observation: 'File updated',
+        },
+      ]);
+
+      const results = await inference.inferUsage(trajectory, [playbook]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].wasUsed).toBe(true);
+      expect(results[0].usageConfidence).toBeGreaterThan(0);
+    });
+
+    it('should detect non-usage when tactics do not match', async () => {
+      const playbook = createSamplePlaybook({
+        guidance: {
+          strategy: 'Performance optimization',
+          tactics: [
+            'Profile the application',
+            'Identify bottlenecks',
+            'Optimize hot paths',
+          ],
+        },
+      });
+
+      // Trajectory that does something completely different
+      const trajectory = createSampleTrajectory([
+        {
+          thought: 'Adding a new feature',
+          action: 'create new_feature.ts',
+          observation: 'File created',
+        },
+        {
+          thought: 'Writing the implementation',
+          action: 'edit new_feature.ts',
+          observation: 'Code added',
+        },
+      ]);
+
+      const results = await inference.inferUsage(trajectory, [playbook]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].wasUsed).toBe(false);
+    });
+
+    it('should infer success based on trajectory outcome', async () => {
+      const playbook = createSamplePlaybook({
+        guidance: {
+          strategy: 'Debug and fix',
+          tactics: ['Read the error', 'Fix the issue', 'Verify the fix'],
+        },
+        verification: {
+          successIndicators: ['Tests pass', 'Build succeeds'],
+          failureIndicators: ['Tests fail', 'Build error'],
+        },
+      });
+
+      // Create trajectory with matching tactics and successful outcome
+      const successfulTrajectory = createSampleTrajectory([
+        {
+          thought: 'Let me read the error carefully',
+          action: 'cat error.log',
+          observation: 'Error found',
+        },
+        {
+          thought: 'Now I will fix the issue',
+          action: 'edit file.ts',
+          observation: 'Fixed',
+        },
+        {
+          thought: 'Let me verify the fix works',
+          action: 'npm test',
+          observation: 'All tests pass',
+        },
+      ], {
+        outcome: { success: true, quality: 'good' },
+      });
+
+      const results = await inference.inferUsage(successfulTrajectory, [playbook]);
+
+      // Should infer success from the trajectory outcome when playbook is used
+      // If wasUsed is true and trajectory succeeded, wasSuccessful should reflect that
+      expect(results).toHaveLength(1);
+      if (results[0].wasUsed) {
+        expect(results[0].wasSuccessful).toBe(true);
+      }
+    });
+
+    it('should handle multiple playbooks', async () => {
+      const playbook1 = createSamplePlaybook({
+        id: 'playbook-1',
+        name: 'error-fixing',
+        guidance: {
+          strategy: 'Fix errors',
+          tactics: ['Read error', 'Fix code'],
+        },
+      });
+
+      const playbook2 = createSamplePlaybook({
+        id: 'playbook-2',
+        name: 'testing',
+        guidance: {
+          strategy: 'Test code',
+          tactics: ['Run tests', 'Check coverage'],
+        },
+      });
+
+      const trajectory = createSampleTrajectory([
+        {
+          thought: 'Reading the error message',
+          action: 'cat error.log',
+          observation: 'Found error',
+        },
+        {
+          thought: 'Fixing the code',
+          action: 'edit file.ts',
+          observation: 'Fixed',
+        },
+      ]);
+
+      const results = await inference.inferUsage(trajectory, [playbook1, playbook2]);
+
+      expect(results).toHaveLength(2);
+      // playbook1 should have higher usage confidence
+      const pb1Result = results.find(r => r.playbookId === 'playbook-1');
+      const pb2Result = results.find(r => r.playbookId === 'playbook-2');
+      expect(pb1Result?.usageConfidence).toBeGreaterThan(pb2Result?.usageConfidence || 0);
+    });
+
+    it('should return empty array when no playbooks provided', async () => {
+      const trajectory = createSampleTrajectory([
+        { action: 'some action', observation: 'result' },
+      ]);
+
+      const results = await inference.inferUsage(trajectory, []);
+
+      expect(results).toHaveLength(0);
+    });
+  });
+});

package/tests/mcp/playbook-server.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PlaybookMCPServer, createPlaybookMCPServer } from '../../src/mcp/playbook-server.js';
+import { PlaybookLibrary } from '../../src/memory/playbook.js';
+import { createPlaybook } from '../../src/types/playbook.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+describe('PlaybookMCPServer', () => {
+  let server: PlaybookMCPServer;
+  let playbooks: PlaybookLibrary;
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = path.join(process.cwd(), '.test-mcp-' + Date.now());
+    await fs.mkdir(testDir, { recursive: true });
+    playbooks = new PlaybookLibrary(testDir);
+    await playbooks.init();
+    server = createPlaybookMCPServer(playbooks, undefined, {
+      maxResults: 5,
+      minConfidence: 0.3,
+    });
+
+    // Add test playbooks
+    await playbooks.add(createPlaybook({
+      name: 'Debug TypeScript Errors',
+      applicability: {
+        situations: ['When encountering TypeScript compilation errors'],
+        triggers: ['type error', 'typescript', 'TS2'],
+        antiPatterns: [],
+        domains: ['code', 'typescript'],
+      },
+      guidance: {
+        strategy: 'Systematically identify and fix type mismatches',
+        tactics: ['Check type definitions', 'Use type assertions carefully'],
+        steps: ['Read error message', 'Find source file', 'Fix type'],
+      },
+      verification: {
+        successIndicators: ['tsc compiles successfully'],
+        failureIndicators: ['errors persist'],
+        commands: [],
+      },
+      confidence: 0.8,
+    }));
+
+    await playbooks.add(createPlaybook({
+      name: 'Write Unit Tests',
+      applicability: {
+        situations: ['When adding test coverage'],
+        triggers: ['test', 'unit test', 'vitest'],
+        antiPatterns: [],
+        domains: ['testing'],
+      },
+      guidance: {
+        strategy: 'Write focused tests for individual functions',
+        tactics: ['Use describe/it blocks', 'Test edge cases'],
+      },
+      verification: {
+        successIndicators: ['tests pass'],
+        failureIndicators: ['tests fail'],
+        commands: [],
+      },
+      confidence: 0.9,
+    }));
+  });
+
+  afterEach(async () => {
+    await playbooks.close();
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('getTools', () => {
+    it('should return available MCP tools', () => {
+      const tools = server.getTools();
+
+      expect(tools).toHaveLength(4);
+      expect(tools.map(t => t.name)).toContain('search_playbooks');
+      expect(tools.map(t => t.name)).toContain('get_playbook_details');
+      expect(tools.map(t => t.name)).toContain('list_domains');
+      expect(tools.map(t => t.name)).toContain('get_playbooks_by_domain');
+    });
+
+    it('should have proper input schemas', () => {
+      const tools = server.getTools();
+      const searchTool = tools.find(t => t.name === 'search_playbooks');
+
+      expect(searchTool?.inputSchema.type).toBe('object');
+      expect(searchTool?.inputSchema.required).toContain('query');
+      expect(searchTool?.inputSchema.properties).toHaveProperty('query');
+    });
+  });
+
+  describe('handleToolCall - search_playbooks', () => {
+    it('should search playbooks by query', async () => {
+      const result = await server.handleToolCall({
+        name: 'search_playbooks',
+        arguments: { query: 'typescript error' },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('Debug TypeScript Errors');
+    });
+
+    it('should filter by domain', async () => {
+      const result = await server.handleToolCall({
+        name: 'search_playbooks',
+        arguments: { query: 'test coverage', domain: 'testing' },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('Write Unit Tests');
+      expect(result.content[0].text).not.toContain('Debug TypeScript Errors');
+    });
+
+    it('should return message when no results found', async () => {
+      const result = await server.handleToolCall({
+        name: 'search_playbooks',
+        arguments: { query: 'nonexistent query xyz123' },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('No playbooks found');
+    });
+
+    it('should validate required arguments', async () => {
+      const result = await server.handleToolCall({
+        name: 'search_playbooks',
+        arguments: {}, // Missing query
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Error');
+    });
+
+    it('should respect maxResults limit', async () => {
+      const result = await server.handleToolCall({
+        name: 'search_playbooks',
+        arguments: { query: 'typescript error', maxResults: 1 },
+      });
+
+      expect(result.isError).toBeFalsy();
+      // Should only return at most 1 result (could be 0 if no match)
+      const text = result.content[0].text;
+      if (!text.includes('No playbooks found')) {
+        const matches = text.match(/## /g);
+        expect(matches?.length ?? 0).toBeLessThanOrEqual(1);
+      }
+    });
+  });
+
+  describe('handleToolCall - get_playbook_details', () => {
+    it('should get playbook details by ID', async () => {
+      const allPlaybooks = await playbooks.getAll();
+      const playbookId = allPlaybooks[0].id;
+
+      const result = await server.handleToolCall({
+        name: 'get_playbook_details',
+        arguments: { playbookId },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain(allPlaybooks[0].name);
+      expect(result.content[0].text).toContain('Strategy');
+      expect(result.content[0].text).toContain('Tactics');
+    });
+
+    it('should return error for non-existent playbook', async () => {
+      const result = await server.handleToolCall({
+        name: 'get_playbook_details',
+        arguments: { playbookId: 'non-existent-id' },
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('not found');
+    });
+
+    it('should validate required arguments', async () => {
+      const result = await server.handleToolCall({
+        name: 'get_playbook_details',
+        arguments: {}, // Missing playbookId
+      });
+
+      expect(result.isError).toBe(true);
+    });
+  });
+
+  describe('handleToolCall - list_domains', () => {
+    it('should list all domains', async () => {
+      const result = await server.handleToolCall({
+        name: 'list_domains',
+        arguments: {},
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('code');
+      expect(result.content[0].text).toContain('typescript');
+      expect(result.content[0].text).toContain('testing');
+    });
+  });
+
+  describe('handleToolCall - get_playbooks_by_domain', () => {
+    it('should get playbooks for a specific domain', async () => {
+      const result = await server.handleToolCall({
+        name: 'get_playbooks_by_domain',
+        arguments: { domain: 'testing' },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('Write Unit Tests');
+    });
+
+    it('should return message when no playbooks in domain', async () => {
+      const result = await server.handleToolCall({
+        name: 'get_playbooks_by_domain',
+        arguments: { domain: 'nonexistent-domain' },
+      });
+
+      expect(result.isError).toBeFalsy();
+      expect(result.content[0].text).toContain('No playbooks found');
+    });
+
+    it('should validate required arguments', async () => {
+      const result = await server.handleToolCall({
+        name: 'get_playbooks_by_domain',
+        arguments: {}, // Missing domain
+      });
+
+      expect(result.isError).toBe(true);
+    });
+  });
+
+  describe('handleToolCall - unknown tool', () => {
+    it('should return error for unknown tool', async () => {
+      const result = await server.handleToolCall({
+        name: 'unknown_tool',
+        arguments: {},
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Unknown tool');
+    });
+  });
+
+  describe('getServerInfo', () => {
+    it('should return server information', () => {
+      const info = server.getServerInfo();
+
+      expect(info.name).toBe('atlas-playbook-server');
+      expect(info.version).toBeDefined();
+      expect(info.description).toBeDefined();
+    });
+  });
+});

package/tests/memory/experience.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ExperienceMemory } from '../../src/memory/experience.js';
+import { createExperience, type Experience } from '../../src/types/memory.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('ExperienceMemory', () => {
+  let tempDir: string;
+  let memory: ExperienceMemory;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
+    memory = new ExperienceMemory(tempDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  function createSampleExperience(overrides?: Partial<Experience>): Experience {
+    return createExperience({
+      taskInput: 'Write a function to add two numbers',
+      solutionOutput: 'function add(a, b) { return a + b; }',
+      feedback: 'Correct implementation',
+      success: true,
+      domain: 'code',
+      trajectoryId: 'traj-1',
+      ...overrides,
+    });
+  }
+
+  describe('add and get', () => {
+    it('should store and retrieve an experience', async () => {
+      const exp = createSampleExperience();
+      await memory.add(exp);
+
+      const retrieved = await memory.get(exp.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.taskInput).toBe(exp.taskInput);
+      expect(retrieved?.success).toBe(true);
+    });
+
+    it('should return undefined for non-existent id', async () => {
+      const result = await memory.get('non-existent-id');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('findSimilar', () => {
+    it('should find similar experiences by text', async () => {
+      await memory.add(createSampleExperience({
+        taskInput: 'Write a function to add two numbers',
+      }));
+      await memory.add(createSampleExperience({
+        taskInput: 'Write a function to multiply two numbers',
+      }));
+      await memory.add(createSampleExperience({
+        taskInput: 'Create a database schema',
+      }));
+
+      const results = await memory.findSimilar('function to add numbers', { k: 2 });
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0].experience.taskInput).toContain('add');
+    });
+
+    it('should filter by domain', async () => {
+      await memory.add(createSampleExperience({ domain: 'code' }));
+      await memory.add(createSampleExperience({ domain: 'reasoning' }));
+
+      const results = await memory.findSimilar('test', { domain: 'code' });
+      expect(results.every(r => r.experience.domain === 'code')).toBe(true);
+    });
+
+    it('should filter by success', async () => {
+      await memory.add(createSampleExperience({ success: true }));
+      await memory.add(createSampleExperience({ success: false }));
+
+      const results = await memory.findSimilar('test', { successOnly: true });
+      expect(results.every(r => r.experience.success)).toBe(true);
+    });
+
+    it('should filter by minimum score', async () => {
+      await memory.add(createSampleExperience({
+        taskInput: 'exact match query here',
+      }));
+      await memory.add(createSampleExperience({
+        taskInput: 'something completely unrelated',
+      }));
+
+      const results = await memory.findSimilar('exact match query here', {
+        minScore: 0.9,
+      });
+      // Only high-scoring results should be returned
+      expect(results.every(r => r.score >= 0.9)).toBe(true);
+    });
+  });
+
+  describe('update', () => {
+    it('should update an experience', async () => {
+      const exp = createSampleExperience();
+      await memory.add(exp);
+
+      const updated = await memory.update(exp.id, {
+        feedback: 'Updated feedback',
+      });
+
+      expect(updated?.feedback).toBe('Updated feedback');
+      expect(updated?.id).toBe(exp.id); // ID preserved
+    });
+
+    it('should return undefined for non-existent id', async () => {
+      const result = await memory.update('non-existent', { feedback: 'new' });
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('recordUsage', () => {
+    it('should increment usage count', async () => {
+      const exp = createSampleExperience();
+      await memory.add(exp);
+
+      await memory.recordUsage(exp.id);
+      await memory.recordUsage(exp.id);
+
+      const updated = await memory.get(exp.id);
+      expect(updated?.usageCount).toBe(2);
+      expect(updated?.lastAccessedAt).toBeDefined();
+    });
+  });
+
+  describe('getAll and getByTrajectory', () => {
+    it('should get all experiences', async () => {
+      await memory.add(createSampleExperience());
+      await memory.add(createSampleExperience());
+      await memory.add(createSampleExperience());
+
+      const all = await memory.getAll();
+      expect(all).toHaveLength(3);
+    });
+
+    it('should get experiences by trajectory', async () => {
+      await memory.add(createSampleExperience({ trajectoryId: 'traj-a' }));
+      await memory.add(createSampleExperience({ trajectoryId: 'traj-a' }));
+      await memory.add(createSampleExperience({ trajectoryId: 'traj-b' }));
+
+      const results = await memory.getByTrajectory('traj-a');
+      expect(results).toHaveLength(2);
+    });
+  });
+
+  describe('prune', () => {
+    it('should prune experiences by count', async () => {
+      for (let i = 0; i < 5; i++) {
+        await memory.add(createSampleExperience());
+      }
+
+      const pruned = await memory.prune({ maxCount: 3 });
+      expect(pruned.totalPruned).toBe(2);
+      expect(pruned.prunedByReason.capacity).toHaveLength(2);
+
+      const remaining = await memory.count();
+      expect(remaining).toBe(3);
+    });
+  });
+
+  describe('count', () => {
+    it('should return correct count', async () => {
+      expect(await memory.count()).toBe(0);
+
+      await memory.add(createSampleExperience());
+      expect(await memory.count()).toBe(1);
+
+      await memory.add(createSampleExperience());
+      expect(await memory.count()).toBe(2);
+    });
+  });
+
+  describe('persistence', () => {
+    it('should persist data across reloads', async () => {
+      const exp = createSampleExperience();
+      await memory.add(exp);
+      await memory.close();
+
+      // Create new memory instance
+      const memory2 = new ExperienceMemory(tempDir);
+      await memory2.init();
+
+      const retrieved = await memory2.get(exp.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.taskInput).toBe(exp.taskInput);
+
+      await memory2.close();
+    });
+  });
+});