cognitive-core 0.2.4 → 0.3.1

package/tests/runtime/macro-agent-backend.test.ts

@@ -1,266 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  MacroAgentBackendAdapter,
-  adaptMacroBackend,
-  createMacroAgentSource,
-  type MacroAgentBackendLike,
-  type MacroSessionLike,
-} from '../../src/runtime/backends/macro-agent.js';
-import type { AgentBackend, AgentSession } from '../../src/runtime/types.js';
-import { createTask } from '../../src/types/task.js';
-
-// ── Mock macro-agent backend ──────────────────────────────────
-
-function createMockMacroBackend(
-  overrides?: Partial<MacroAgentBackendLike>,
-): MacroAgentBackendLike {
-  const sessions = new Map<string, MacroSessionLike>();
-  let idCounter = 0;
-
-  return {
-    name: 'macro-agent',
-    supportedTypes: ['claude-code'],
-    isAvailable: vi.fn().mockResolvedValue(true),
-    spawn: vi.fn().mockImplementation(async (config: { agentType: string; task: { description: string } }) => {
-      const session: MacroSessionLike = {
-        id: `cognitive_${++idCounter}`,
-        agentType: config.agentType,
-        task: config.task,
-        state: 'running',
-        messages: [],
-        toolCalls: [],
-        startTime: new Date(),
-        metadata: { macroAgentId: `agent_${idCounter}` },
-      };
-      sessions.set(session.id, session);
-      return session;
-    }),
-    getSession: vi.fn().mockImplementation(async (id: string) => sessions.get(id)),
-    terminate: vi.fn().mockImplementation(async (id: string) => {
-      const session = sessions.get(id);
-      if (session) {
-        session.state = 'failed';
-        session.error = 'Terminated by caller';
-        session.endTime = new Date();
-      }
-    }),
-    listSessions: vi.fn().mockImplementation(async () => Array.from(sessions.values())),
-    ...overrides,
-  };
-}
-
-// ── MacroAgentBackendAdapter ──────────────────────────────────
-
-describe('MacroAgentBackendAdapter', () => {
-  let mockBackend: MacroAgentBackendLike;
-  let adapter: MacroAgentBackendAdapter;
-
-  beforeEach(() => {
-    mockBackend = createMockMacroBackend();
-    adapter = new MacroAgentBackendAdapter(mockBackend);
-  });
-
-  describe('constructor and properties', () => {
-    it('should expose name and supportedTypes from inner backend', () => {
-      expect(adapter.name).toBe('macro-agent');
-      expect(adapter.supportedTypes).toEqual(['claude-code']);
-    });
-
-    it('should copy supportedTypes (not share reference)', () => {
-      expect(adapter.supportedTypes).not.toBe(mockBackend.supportedTypes);
-    });
-  });
-
-  describe('isAvailable', () => {
-    it('should delegate to inner backend', async () => {
-      expect(await adapter.isAvailable()).toBe(true);
-      expect(mockBackend.isAvailable).toHaveBeenCalled();
-    });
-
-    it('should propagate false', async () => {
-      const backend = createMockMacroBackend({
-        isAvailable: vi.fn().mockResolvedValue(false),
-      });
-      const a = new MacroAgentBackendAdapter(backend);
-      expect(await a.isAvailable()).toBe(false);
-    });
-  });
-
-  describe('spawn', () => {
-    it('should return an AgentSession with full Task', async () => {
-      const task = createTask({
-        domain: 'analysis',
-        description: 'Analyze trajectory patterns',
-      });
-
-      const session = await adapter.spawn({ agentType: 'claude-code', task });
-
-      expect(session.id).toBeDefined();
-      expect(session.agentType).toBe('claude-code');
-      expect(session.state).toBe('running');
-      expect(session.messages).toEqual([]);
-      expect(session.toolCalls).toEqual([]);
-      // Full Task is preserved (not just CognitiveTask subset)
-      expect(session.task).toBe(task);
-      expect(session.task.id).toBe(task.id);
-      expect(session.task.domain).toBe('analysis');
-    });
-
-    it('should forward config to inner backend', async () => {
-      const task = createTask({
-        domain: 'test',
-        description: 'Test task',
-      });
-
-      await adapter.spawn({ agentType: 'claude-code', task });
-
-      expect(mockBackend.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          agentType: 'claude-code',
-          task: expect.objectContaining({ description: 'Test task' }),
-        }),
-      );
-    });
-
-    it('should preserve metadata from inner session', async () => {
-      const task = createTask({ domain: 'test', description: 'test' });
-      const session = await adapter.spawn({ agentType: 'claude-code', task });
-
-      expect(session.metadata.macroAgentId).toBeDefined();
-    });
-  });
-
-  describe('getSession', () => {
-    it('should return session with cached Task', async () => {
-      const task = createTask({
-        domain: 'analysis',
-        description: 'Find patterns',
-      });
-      const spawned = await adapter.spawn({ agentType: 'claude-code', task });
-
-      const retrieved = await adapter.getSession(spawned.id);
-
-      expect(retrieved).toBeDefined();
-      expect(retrieved!.id).toBe(spawned.id);
-      // Task is preserved from original spawn call
-      expect(retrieved!.task).toBe(task);
-      expect(retrieved!.task.domain).toBe('analysis');
-    });
-
-    it('should return undefined for non-existent session', async () => {
-      const result = await adapter.getSession('non-existent');
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('terminate', () => {
-    it('should delegate to inner backend', async () => {
-      const task = createTask({ domain: 'test', description: 'task' });
-      const session = await adapter.spawn({ agentType: 'claude-code', task });
-
-      await adapter.terminate(session.id);
-
-      expect(mockBackend.terminate).toHaveBeenCalledWith(session.id);
-    });
-
-    it('should reflect terminated state on subsequent getSession', async () => {
-      const task = createTask({ domain: 'test', description: 'Long task' });
-      const session = await adapter.spawn({ agentType: 'claude-code', task });
-
-      await adapter.terminate(session.id);
-
-      const updated = await adapter.getSession(session.id);
-      expect(updated?.state).toBe('failed');
-      expect(updated?.error).toBe('Terminated by caller');
-    });
-  });
-
-  describe('listSessions', () => {
-    it('should return all sessions with cached Tasks', async () => {
-      const task1 = createTask({ domain: 'test', description: 'Task 1' });
-      const task2 = createTask({ domain: 'analysis', description: 'Task 2' });
-
-      await adapter.spawn({ agentType: 'claude-code', task: task1 });
-      await adapter.spawn({ agentType: 'claude-code', task: task2 });
-
-      const sessions = await adapter.listSessions();
-
-      expect(sessions).toHaveLength(2);
-      expect(sessions[0].task.domain).toBe('test');
-      expect(sessions[1].task.domain).toBe('analysis');
-    });
-
-    it('should return empty array when no sessions', async () => {
-      const sessions = await adapter.listSessions();
-      expect(sessions).toEqual([]);
-    });
-  });
-});
-
-// ── adaptMacroBackend ─────────────────────────────────────────
-
-describe('adaptMacroBackend', () => {
-  it('should return an AgentBackend', () => {
-    const mock = createMockMacroBackend();
-    const backend = adaptMacroBackend(mock);
-
-    expect(backend.name).toBe('macro-agent');
-    expect(backend.supportedTypes).toContain('claude-code');
-    expect(typeof backend.isAvailable).toBe('function');
-    expect(typeof backend.spawn).toBe('function');
-    expect(typeof backend.getSession).toBe('function');
-    expect(typeof backend.terminate).toBe('function');
-    expect(typeof backend.listSessions).toBe('function');
-  });
-
-  it('should satisfy AgentBackend interface', async () => {
-    const mock = createMockMacroBackend();
-    const backend: AgentBackend = adaptMacroBackend(mock);
-
-    const task = createTask({ domain: 'test', description: 'verify interface' });
-    const session = await backend.spawn({ agentType: 'claude-code', task });
-
-    expect(session.id).toBeDefined();
-    expect(session.task).toBe(task);
-  });
-});
-
-// ── createMacroAgentSource ────────────────────────────────────
-
-describe('createMacroAgentSource', () => {
-  it('should create a ComputeSource with defaults', () => {
-    const mock = createMockMacroBackend();
-    const source = createMacroAgentSource(mock);
-
-    expect(source.name).toBe('macro-agent');
-    expect(source.costTier).toBe('medium');
-    expect(source.location).toBe('local');
-    expect(source.priority).toBe(50);
-    expect(source.backend).toBeDefined();
-    expect(source.backend.name).toBe('macro-agent');
-  });
-
-  it('should accept custom options', () => {
-    const mock = createMockMacroBackend();
-    const source = createMacroAgentSource(mock, {
-      costTier: 'high',
-      location: 'remote',
-      priority: 10,
-    });
-
-    expect(source.costTier).toBe('high');
-    expect(source.location).toBe('remote');
-    expect(source.priority).toBe(10);
-  });
-
-  it('should create a functional backend in the source', async () => {
-    const mock = createMockMacroBackend();
-    const source = createMacroAgentSource(mock);
-
-    expect(await source.backend.isAvailable()).toBe(true);
-
-    const task = createTask({ domain: 'test', description: 'via source' });
-    const session = await source.backend.spawn({ agentType: 'claude-code', task });
-    expect(session.task).toBe(task);
-  });
-});

package/tests/runtime/mock-backend.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { MockBackend, createMockBackend } from '../../src/runtime/backends/mock.js';
-import { createTask } from '../../src/types/task.js';
-
-describe('MockBackend', () => {
-  let backend: MockBackend;
-
-  beforeEach(() => {
-    backend = new MockBackend();
-  });
-
-  describe('constructor and availability', () => {
-    it('should have correct name and supported types', () => {
-      expect(backend.name).toBe('mock');
-      expect(backend.supportedTypes).toContain('mock');
-      expect(backend.supportedTypes).toContain('test');
-    });
-
-    it('should always be available', async () => {
-      expect(await backend.isAvailable()).toBe(true);
-    });
-  });
-
-  describe('spawn', () => {
-    it('should spawn a session with default success behavior', async () => {
-      const task = createTask({
-        domain: 'test',
-        description: 'Test task',
-      });
-
-      const session = await backend.spawn({
-        agentType: 'mock',
-        task,
-      });
-
-      expect(session.id).toBeDefined();
-      expect(session.agentType).toBe('mock');
-      expect(session.task).toEqual(task);
-      expect(session.state).toBe('running');
-      expect(session.messages).toEqual([]);
-      expect(session.toolCalls).toEqual([]);
-
-      // Wait for completion
-      await new Promise(resolve => setTimeout(resolve, 150));
-
-      const updatedSession = await backend.getSession(session.id);
-      expect(updatedSession?.state).toBe('completed');
-      expect(updatedSession?.result).toBe('Mock result');
-    });
-
-    it('should use custom default behavior', async () => {
-      const customBackend = createMockBackend({
-        success: true,
-        result: { custom: 'result' },
-        durationMs: 50,
-      });
-
-      const task = createTask({ domain: 'test', description: 'Custom test' });
-      const session = await customBackend.spawn({ agentType: 'mock', task });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const updated = await customBackend.getSession(session.id);
-      expect(updated?.result).toEqual({ custom: 'result' });
-    });
-
-    it('should use task-specific behavior', async () => {
-      backend.setBehavior('Special task', {
-        success: true,
-        result: 'Special result',
-        durationMs: 50,
-      });
-
-      const task = createTask({ domain: 'test', description: 'Special task' });
-      const session = await backend.spawn({ agentType: 'mock', task });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const updated = await backend.getSession(session.id);
-      expect(updated?.result).toBe('Special result');
-    });
-
-    it('should handle failure behavior', async () => {
-      backend.setDefaultBehavior({
-        success: false,
-        error: 'Test error',
-        durationMs: 50,
-      });
-
-      const task = createTask({ domain: 'test', description: 'Failing task' });
-      const session = await backend.spawn({ agentType: 'mock', task });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const updated = await backend.getSession(session.id);
-      expect(updated?.state).toBe('failed');
-      expect(updated?.error).toBe('Test error');
-    });
-
-    it('should emit messages with callbacks', async () => {
-      const onMessage = vi.fn();
-
-      backend.setDefaultBehavior({
-        success: true,
-        messages: [
-          { role: 'assistant', content: 'Hello' },
-          { role: 'assistant', content: 'Working...' },
-        ],
-        durationMs: 50,
-      });
-
-      const task = createTask({ domain: 'test', description: 'Message task' });
-      await backend.spawn({
-        agentType: 'mock',
-        task,
-        onMessage,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(onMessage).toHaveBeenCalledTimes(2);
-      expect(onMessage).toHaveBeenCalledWith(
-        expect.objectContaining({ role: 'assistant', content: 'Hello' })
-      );
-    });
-
-    it('should emit tool calls with callbacks', async () => {
-      const onToolCall = vi.fn();
-
-      backend.setDefaultBehavior({
-        success: true,
-        toolCalls: [
-          { name: 'read_file', input: { path: 'test.ts' }, output: 'content' },
-          { name: 'write_file', input: { path: 'out.ts' }, output: 'ok' },
-        ],
-        durationMs: 50,
-      });
-
-      const task = createTask({ domain: 'test', description: 'Tool task' });
-      await backend.spawn({
-        agentType: 'mock',
-        task,
-        onToolCall,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(onToolCall).toHaveBeenCalledTimes(2);
-      expect(onToolCall).toHaveBeenCalledWith(
-        expect.objectContaining({ name: 'read_file' })
-      );
-    });
-
-    it('should track injected knowledge in metadata', async () => {
-      const task = createTask({ domain: 'test', description: 'Knowledge task' });
-      const session = await backend.spawn({
-        agentType: 'mock',
-        task,
-        injectedKnowledge: { experiences: [], strategies: [] },
-        systemPromptAdditions: 'Additional context',
-      });
-
-      expect(session.metadata.injectedKnowledge).toBe(true);
-      expect(session.metadata.hasSystemPromptAdditions).toBe(true);
-    });
-  });
-
-  describe('getSession', () => {
-    it('should return session by id', async () => {
-      const task = createTask({ domain: 'test', description: 'Get session task' });
-      const session = await backend.spawn({ agentType: 'mock', task });
-
-      const retrieved = await backend.getSession(session.id);
-      expect(retrieved).toBeDefined();
-      expect(retrieved?.id).toBe(session.id);
-    });
-
-    it('should return undefined for non-existent session', async () => {
-      const result = await backend.getSession('non-existent');
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('sendMessage', () => {
-    it('should throw for non-existent session', async () => {
-      await expect(
-        backend.sendMessage('non-existent', 'hello')
-      ).rejects.toThrow('Session not found');
-    });
-
-    it('should not throw for existing session', async () => {
-      const task = createTask({ domain: 'test', description: 'test' });
-      const session = await backend.spawn({ agentType: 'mock', task });
-
-      await expect(
-        backend.sendMessage(session.id, 'hello')
-      ).resolves.not.toThrow();
-    });
-  });
-
-  describe('terminate', () => {
-    it('should terminate a running session', async () => {
-      backend.setDefaultBehavior({ success: true, durationMs: 500 });
-
-      const task = createTask({ domain: 'test', description: 'Long task' });
-      const session = await backend.spawn({ agentType: 'mock', task });
-
-      expect(session.state).toBe('running');
-
-      await backend.terminate(session.id);
-
-      const updated = await backend.getSession(session.id);
-      expect(updated?.state).toBe('failed');
-      expect(updated?.error).toBe('Terminated');
-    });
-
-    it('should handle non-existent session gracefully', async () => {
-      await expect(backend.terminate('non-existent')).resolves.not.toThrow();
-    });
-  });
-
-  describe('listSessions', () => {
-    it('should list all sessions', async () => {
-      const task1 = createTask({ domain: 'test', description: 'Task 1' });
-      const task2 = createTask({ domain: 'test', description: 'Task 2' });
-
-      await backend.spawn({ agentType: 'mock', task: task1 });
-      await backend.spawn({ agentType: 'mock', task: task2 });
-
-      const sessions = await backend.listSessions();
-      expect(sessions).toHaveLength(2);
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear all sessions and behaviors', async () => {
-      backend.setBehavior('Special', { success: true });
-      const task = createTask({ domain: 'test', description: 'Task' });
-      await backend.spawn({ agentType: 'mock', task });
-
-      expect((await backend.listSessions()).length).toBe(1);
-
-      backend.clear();
-
-      expect((await backend.listSessions()).length).toBe(0);
-    });
-  });
-});