cognitive-core 0.0.2 → 0.1.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();
+    });
+  });
+});