cognitive-core 0.0.2 → 0.1.2

package/tests/runtime/agent-manager.test.ts

@@ -0,0 +1,512 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { AgentManager, createAgentManager, DefaultKnowledgeInjector, DefaultTrajectoryExtractor } from '../../src/runtime/manager.js';
+import { MockBackend, createMockBackend } from '../../src/runtime/backends/mock.js';
+import { createMemorySystem } from '../../src/memory/system.js';
+import { createTask } from '../../src/types/task.js';
+import type { MemorySystem } from '../../src/memory/system.js';
+import type { AgentSession, ToolCall, AgentMessage } from '../../src/runtime/types.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('AgentManager', () => {
+  let tempDir: string;
+  let memory: MemorySystem;
+  let manager: AgentManager;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'agent-manager-test-'));
+    memory = createMemorySystem(tempDir);
+    await memory.init();
+
+    manager = createAgentManager(memory);
+    mockBackend = createMockBackend({
+      success: true,
+      result: 'Test result',
+      durationMs: 50,
+    });
+    manager.registerBackend(mockBackend);
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('backend registration', () => {
+    it('should register and retrieve backends', () => {
+      expect(manager.getBackend('mock')).toBe(mockBackend);
+    });
+
+    it('should list registered backends', () => {
+      const backends = manager.listBackends();
+      expect(backends).toContain('mock');
+    });
+
+    it('should return undefined for unregistered backend', () => {
+      expect(manager.getBackend('nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('spawn', () => {
+    it('should spawn an agent and return result', async () => {
+      const task = createTask({
+        domain: 'test',
+        description: 'Test task',
+      });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.trajectory).toBeDefined();
+      expect(result.trajectory.task).toEqual(task);
+      expect(result.session.state).toBe('completed');
+    });
+
+    it('should throw error for unsupported agent type', async () => {
+      const task = createTask({ domain: 'test', description: 'Test' });
+
+      await expect(
+        manager.spawn({ agentType: 'unsupported', task })
+      ).rejects.toThrow(/No compute source supports agent type 'unsupported'/);
+    });
+
+    it('should inject knowledge into system prompt', async () => {
+      // Provide custom knowledge directly to ensure injection
+      const customKnowledge = {
+        experiences: [{
+          experience: {
+            id: 'exp-1',
+            taskInput: 'Similar test task',
+            solutionOutput: 'Solution approach',
+            feedback: 'Success',
+            success: true,
+            domain: 'test',
+            trajectoryId: 'traj-1',
+            usageCount: 0,
+            createdAt: new Date(),
+            metadata: {},
+          },
+          score: 0.9,
+        }],
+        playbooks: [],
+      };
+
+      const task = createTask({
+        domain: 'test',
+        description: 'Test task matching experience',
+      });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+        injectedKnowledge: customKnowledge,
+      });
+
+      expect(result.session.metadata.injectedKnowledge).toBe(true);
+    });
+
+    it('should use provided injectedKnowledge instead of querying memory', async () => {
+      const customKnowledge = {
+        experiences: [],
+        playbooks: [{
+          playbook: {
+            id: 'playbook-1',
+            name: 'Test Playbook',
+            guidance: { strategy: 'Custom strategy', tactics: [] },
+            applicability: { situations: [], triggers: [], antiPatterns: [], domains: ['test'] },
+            verification: { successIndicators: [], failureIndicators: [] },
+            evolution: { version: '1.0.0', createdFrom: [], failures: [], refinements: [], successCount: 0, failureCount: 0 },
+            confidence: 0.8,
+            complexity: 'simple' as const,
+            estimatedEffort: 1,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+          score: 0.9,
+          matchType: 'situation' as const,
+        }],
+      };
+
+      const task = createTask({ domain: 'test', description: 'Test' });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+        injectedKnowledge: customKnowledge,
+      });
+
+      expect(result.session.metadata.injectedKnowledge).toBe(true);
+    });
+
+    it('should pass systemPromptAdditions to backend', async () => {
+      const task = createTask({ domain: 'test', description: 'Test' });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+        systemPromptAdditions: 'Custom instructions',
+      });
+
+      expect(result.session.metadata.hasSystemPromptAdditions).toBe(true);
+    });
+
+    it('should invoke callbacks during execution', async () => {
+      const onMessage = vi.fn();
+      const onToolCall = vi.fn();
+
+      mockBackend.setDefaultBehavior({
+        success: true,
+        messages: [{ role: 'assistant', content: 'Working...' }],
+        toolCalls: [{ name: 'read_file', input: { path: 'test.ts' }, output: 'content' }],
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Test with callbacks' });
+
+      await manager.spawn({
+        agentType: 'mock',
+        task,
+        onMessage,
+        onToolCall,
+      });
+
+      expect(onMessage).toHaveBeenCalled();
+      expect(onToolCall).toHaveBeenCalled();
+    });
+
+    it('should handle failed agent execution', async () => {
+      mockBackend.setDefaultBehavior({
+        success: false,
+        error: 'Execution failed',
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Failing task' });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.trajectory.outcome.success).toBe(false);
+    });
+
+    it('should extract trajectory from completed session', async () => {
+      mockBackend.setDefaultBehavior({
+        success: true,
+        result: 'Final result',
+        messages: [
+          { role: 'assistant', content: 'Analyzing task...' },
+          { role: 'assistant', content: 'Implementing solution...' },
+        ],
+        toolCalls: [
+          { name: 'read_file', input: { path: 'src/main.ts' }, output: 'code content' },
+          { name: 'write_file', input: { path: 'src/main.ts', content: 'new code' }, output: 'written' },
+        ],
+        durationMs: 100,
+      });
+
+      const task = createTask({ domain: 'code', description: 'Modify file' });
+
+      const result = await manager.spawn({
+        agentType: 'mock',
+        task,
+      });
+
+      expect(result.trajectory.steps.length).toBe(2);
+      expect(result.trajectory.outcome.success).toBe(true);
+      expect(result.metrics.toolCallCount).toBe(2);
+    });
+  });
+
+  describe('spawnBaseline', () => {
+    it('should spawn without knowledge injection', async () => {
+      // Add experience that would normally be injected
+      await memory.experiences.add({
+        id: 'exp-baseline',
+        taskInput: 'Baseline test task',
+        solutionOutput: 'Solution',
+        feedback: 'Success',
+        success: true,
+        domain: 'test',
+        trajectoryId: 'traj-baseline',
+        usageCount: 0,
+        createdAt: new Date(),
+        metadata: {},
+      });
+
+      const task = createTask({ domain: 'test', description: 'Baseline test task' });
+
+      const result = await manager.spawnBaseline({
+        agentType: 'mock',
+        task,
+      });
+
+      // Should still succeed but with empty knowledge
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('compareWithKnowledge', () => {
+    it('should run both baseline and knowledge-enhanced executions', async () => {
+      const task = createTask({ domain: 'test', description: 'Comparison task' });
+
+      const comparison = await manager.compareWithKnowledge({
+        agentType: 'mock',
+        task,
+      });
+
+      expect(comparison.baseline).toBeDefined();
+      expect(comparison.withKnowledge).toBeDefined();
+      expect(comparison.improvement).toBeDefined();
+      expect(comparison.improvement.timeDelta).toBeDefined();
+      expect(comparison.improvement.toolCallDelta).toBeDefined();
+      expect(comparison.improvement.successDelta).toBeDefined();
+    });
+  });
+
+  describe('observers', () => {
+    it('should notify observers on session events', async () => {
+      const onSessionStart = vi.fn();
+      const onSessionEnd = vi.fn();
+
+      manager.addObserver({
+        onSessionStart,
+        onSessionEnd,
+      });
+
+      mockBackend.setDefaultBehavior({
+        success: true,
+        result: 'Done',
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Observer test' });
+      await manager.spawn({ agentType: 'mock', task });
+
+      expect(onSessionStart).toHaveBeenCalled();
+      expect(onSessionEnd).toHaveBeenCalled();
+    });
+
+    it('should remove observers', async () => {
+      const observer = {
+        onSessionStart: vi.fn(),
+        onSessionEnd: vi.fn(),
+      };
+
+      manager.addObserver(observer);
+      manager.removeObserver(observer);
+
+      const task = createTask({ domain: 'test', description: 'Test' });
+      await manager.spawn({ agentType: 'mock', task });
+
+      expect(observer.onSessionStart).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('session management', () => {
+    it('should track active sessions', async () => {
+      mockBackend.setDefaultBehavior({ success: true, durationMs: 200 });
+
+      const task = createTask({ domain: 'test', description: 'Long task' });
+
+      // Start spawn but don't await yet
+      const spawnPromise = manager.spawn({ agentType: 'mock', task });
+
+      // Give it a moment to start
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const activeSessions = manager.getActiveSessions();
+      expect(activeSessions.length).toBeGreaterThanOrEqual(0);
+
+      // Wait for completion
+      await spawnPromise;
+    });
+
+    it('should terminate active sessions', async () => {
+      mockBackend.setDefaultBehavior({ success: true, durationMs: 500 });
+
+      const task = createTask({ domain: 'test', description: 'Terminable task' });
+
+      const spawnPromise = manager.spawn({ agentType: 'mock', task });
+
+      // Give it a moment to start
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const sessions = manager.getActiveSessions();
+      if (sessions.length > 0) {
+        await manager.terminate(sessions[0].id);
+      }
+
+      // Complete spawn (may have been terminated)
+      try {
+        await spawnPromise;
+      } catch {
+        // Expected if terminated
+      }
+    });
+  });
+
+  describe('observeAndLearn', () => {
+    it('should extract trajectory from external session and store in memory', async () => {
+      const externalSession: AgentSession = {
+        id: 'external-session-1',
+        agentType: 'external',
+        task: createTask({ domain: 'test', description: 'External task' }),
+        state: 'completed',
+        messages: [],
+        toolCalls: [
+          {
+            id: 'tc-1',
+            name: 'read_file',
+            input: { path: 'test.ts' },
+            output: 'file content',
+            startTime: new Date(),
+            endTime: new Date(),
+          },
+        ],
+        startTime: new Date(),
+        endTime: new Date(),
+        result: 'External result',
+        metadata: {},
+      };
+
+      const task = createTask({ domain: 'test', description: 'External task' });
+      const trajectory = await manager.observeAndLearn(externalSession, task);
+
+      expect(trajectory).toBeDefined();
+      expect(trajectory.agentId).toContain('external');
+      expect(trajectory.steps.length).toBe(1);
+    });
+  });
+});
+
+describe('DefaultKnowledgeInjector', () => {
+  const injector = new DefaultKnowledgeInjector();
+
+  it('should format markdown by default', () => {
+    const knowledge = {
+      experiences: [{
+        experience: {
+          id: 'exp-1',
+          taskInput: 'Test task',
+          solutionOutput: 'Test solution',
+          feedback: 'Good',
+          success: true,
+          domain: 'test',
+          trajectoryId: 'traj-1',
+          usageCount: 1,
+          createdAt: new Date(),
+          metadata: {},
+        },
+        score: 0.85,
+      }],
+      playbooks: [],
+    };
+
+    const formatted = injector.format(knowledge, 'test');
+    expect(formatted).toContain('Similar Past Experiences');
+    expect(formatted).toContain('85%');
+  });
+
+  it('should format JSON when specified', () => {
+    const knowledge = {
+      experiences: [],
+      playbooks: [],
+    };
+
+    const formatted = injector.format(knowledge, 'test', { format: 'json' });
+    expect(() => JSON.parse(formatted)).not.toThrow();
+  });
+
+  it('should format XML when specified', () => {
+    const knowledge = {
+      experiences: [],
+      playbooks: [{
+        playbook: {
+          id: 'pb-1',
+          name: 'Test Playbook',
+          guidance: { strategy: 'Test strategy', tactics: ['tactic1'] },
+          applicability: { situations: [], triggers: [], antiPatterns: [], domains: ['test'] },
+          verification: { successIndicators: [], failureIndicators: [] },
+          evolution: { version: '1.0.0', createdFrom: [], failures: [], refinements: [], successCount: 0, failureCount: 0 },
+          confidence: 0.8,
+          complexity: 'simple' as const,
+          estimatedEffort: 1,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        score: 0.9,
+        matchType: 'situation' as const,
+      }],
+    };
+
+    const formatted = injector.format(knowledge, 'test', { format: 'xml' });
+    expect(formatted).toContain('<atlas-knowledge>');
+    expect(formatted).toContain('<playbooks>');
+  });
+});
+
+describe('DefaultTrajectoryExtractor', () => {
+  const extractor = new DefaultTrajectoryExtractor();
+
+  it('should extract trajectory from session', () => {
+    const session: AgentSession = {
+      id: 'session-1',
+      agentType: 'test',
+      task: createTask({ domain: 'test', description: 'Test task' }),
+      state: 'completed',
+      messages: [
+        { role: 'assistant', content: 'Thinking about solution', timestamp: new Date() },
+      ],
+      toolCalls: [
+        {
+          id: 'tc-1',
+          name: 'write_code',
+          input: { code: 'console.log("hello")' },
+          output: 'success',
+          startTime: new Date(),
+          endTime: new Date(),
+        },
+      ],
+      startTime: new Date(),
+      endTime: new Date(),
+      result: 'Done',
+      metadata: {},
+    };
+
+    const task = createTask({ domain: 'test', description: 'Test task' });
+    const trajectory = extractor.extract(session, task);
+
+    expect(trajectory.steps.length).toBe(1);
+    expect(trajectory.outcome.success).toBe(true);
+    expect(trajectory.agentId).toContain('test:session-1');
+  });
+
+  it('should handle failed sessions', () => {
+    const session: AgentSession = {
+      id: 'session-fail',
+      agentType: 'test',
+      task: createTask({ domain: 'test', description: 'Failing task' }),
+      state: 'failed',
+      messages: [],
+      toolCalls: [],
+      startTime: new Date(),
+      endTime: new Date(),
+      error: 'Something went wrong',
+      metadata: {},
+    };
+
+    const task = createTask({ domain: 'test', description: 'Failing task' });
+    const trajectory = extractor.extract(session, task);
+
+    expect(trajectory.outcome.success).toBe(false);
+    expect(trajectory.outcome.errorInfo).toBe('Something went wrong');
+  });
+});