cognitive-core 0.2.4 → 0.3.1

package/tests/runtime/compute-provider.test.ts

@@ -1,288 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  DefaultComputeProvider,
-  createComputeProvider,
-  type ComputeSource,
-} from '../../src/runtime/compute-provider.js';
-import type { AgentBackend, AgentSpawnConfig, AgentSession } from '../../src/runtime/types.js';
-
-/**
- * Create a minimal test backend with configurable name and supported types.
- */
-function createTestBackend(
-  name: string,
-  supportedTypes: string[],
-  options?: { available?: boolean }
-): AgentBackend {
-  return {
-    name,
-    supportedTypes,
-    async isAvailable() {
-      return options?.available ?? true;
-    },
-    async spawn(_config: AgentSpawnConfig): Promise<AgentSession> {
-      return {
-        id: crypto.randomUUID(),
-        agentType: _config.agentType,
-        task: _config.task,
-        state: 'completed',
-        messages: [],
-        toolCalls: [],
-        startTime: new Date(),
-        endTime: new Date(),
-        result: `result from ${name}`,
-        metadata: {},
-      };
-    },
-    async getSession() {
-      return undefined;
-    },
-  };
-}
-
-describe('DefaultComputeProvider', () => {
-  let provider: DefaultComputeProvider;
-  let localBackend: AgentBackend;
-  let remoteBackend: AgentBackend;
-
-  beforeEach(() => {
-    provider = createComputeProvider();
-    localBackend = createTestBackend('local-acp', ['claude-code', 'test']);
-    remoteBackend = createTestBackend('remote-api', ['claude-code', 'gpt']);
-  });
-
-  describe('register and listSources', () => {
-    it('should register and list compute sources', () => {
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-
-      const sources = provider.listSources();
-      expect(sources).toHaveLength(1);
-      expect(sources[0].name).toBe('local-acp');
-    });
-
-    it('should sort sources by priority', () => {
-      provider.register({
-        name: 'remote-api',
-        backend: remoteBackend,
-        costTier: 'medium',
-        location: 'remote',
-        priority: 20,
-      });
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 5,
-      });
-
-      const sources = provider.listSources();
-      expect(sources[0].name).toBe('local-acp');
-      expect(sources[1].name).toBe('remote-api');
-    });
-
-    it('should re-register source with same name', () => {
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'high',
-        location: 'local',
-        priority: 5,
-      });
-
-      const sources = provider.listSources();
-      expect(sources).toHaveLength(1);
-      expect(sources[0].costTier).toBe('high');
-    });
-  });
-
-  describe('unregister', () => {
-    it('should remove a compute source', () => {
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-
-      provider.unregister('local-acp');
-      expect(provider.listSources()).toHaveLength(0);
-    });
-
-    it('should be a no-op for nonexistent source', () => {
-      provider.unregister('nonexistent');
-      expect(provider.listSources()).toHaveLength(0);
-    });
-  });
-
-  describe('supports', () => {
-    it('should return true for supported agent types', () => {
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-
-      expect(provider.supports('claude-code')).toBe(true);
-      expect(provider.supports('test')).toBe(true);
-      expect(provider.supports('unknown')).toBe(false);
-    });
-  });
-
-  describe('resolve', () => {
-    const registerBoth = () => {
-      provider.register({
-        name: 'local-acp',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-      provider.register({
-        name: 'remote-api',
-        backend: remoteBackend,
-        costTier: 'medium',
-        location: 'remote',
-        priority: 20,
-      });
-    };
-
-    it('should resolve to highest-priority available backend', async () => {
-      registerBoth();
-      const target = await provider.resolve('claude-code');
-      expect(target.source).toBe('local-acp');
-      expect(target.backend).toBe(localBackend);
-    });
-
-    it('should throw for unsupported agent type', async () => {
-      registerBoth();
-      await expect(provider.resolve('nonexistent')).rejects.toThrow(
-        /No compute source supports agent type/
-      );
-    });
-
-    it('should prefer local when mode=local', async () => {
-      registerBoth();
-      const target = await provider.resolve('claude-code', { mode: 'local' });
-      expect(target.source).toBe('local-acp');
-    });
-
-    it('should prefer remote when mode=remote', async () => {
-      registerBoth();
-      const target = await provider.resolve('claude-code', { mode: 'remote' });
-      expect(target.source).toBe('remote-api');
-    });
-
-    it('should accept any location when mode=any', async () => {
-      registerBoth();
-      const target = await provider.resolve('claude-code', { mode: 'any' });
-      expect(target.source).toBe('local-acp');
-    });
-
-    it('should filter by cost budget', async () => {
-      registerBoth();
-      // Budget of 1 cent should exclude 'medium' (5 cents)
-      const target = await provider.resolve('claude-code', { maxCostCents: 1 });
-      expect(target.source).toBe('local-acp');
-    });
-
-    it('should fall back when budget too restrictive', async () => {
-      registerBoth();
-      // Budget of 0 excludes everything (low = 1) — falls back
-      const target = await provider.resolve('claude-code', { maxCostCents: 0 });
-      expect(target.backend).toBeDefined();
-    });
-
-    it('should fall back when location preference has no match for agent type', async () => {
-      registerBoth();
-      // 'test' only supported by local; requesting remote falls back
-      const target = await provider.resolve('test', { mode: 'remote' });
-      expect(target.source).toBe('local-acp');
-    });
-
-    it('should resolve agent types unique to one backend', async () => {
-      registerBoth();
-      const target = await provider.resolve('gpt');
-      expect(target.source).toBe('remote-api');
-    });
-
-    it('should skip unavailable backends and use next in priority', async () => {
-      const unavailableBackend = createTestBackend('unavailable', ['special'], {
-        available: false,
-      });
-      const availableBackend = createTestBackend('available', ['special']);
-
-      provider.register({
-        name: 'unavailable',
-        backend: unavailableBackend,
-        costTier: 'free',
-        location: 'local',
-        priority: 1,  // Higher priority but unavailable
-      });
-      provider.register({
-        name: 'available',
-        backend: availableBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-
-      const target = await provider.resolve('special');
-      expect(target.source).toBe('available');
-    });
-
-    it('should fall back to first candidate when all are unavailable', async () => {
-      const backend1 = createTestBackend('b1', ['agent'], { available: false });
-      const backend2 = createTestBackend('b2', ['agent'], { available: false });
-
-      provider.register({
-        name: 'b1',
-        backend: backend1,
-        costTier: 'low',
-        location: 'local',
-        priority: 1,
-      });
-      provider.register({
-        name: 'b2',
-        backend: backend2,
-        costTier: 'low',
-        location: 'local',
-        priority: 2,
-      });
-
-      const target = await provider.resolve('agent');
-      expect(target.source).toBe('b1');
-    });
-
-    it('should resolve by backend name as fallback', async () => {
-      provider.register({
-        name: 'my-backend',
-        backend: localBackend,
-        costTier: 'low',
-        location: 'local',
-        priority: 10,
-      });
-
-      // 'my-backend' is not in localBackend's supportedTypes
-      // but matches the source name → backend name fallback
-      const target = await provider.resolve('my-backend');
-      expect(target.backend).toBe(localBackend);
-    });
-  });
-});

package/tests/runtime/delegate.test.ts

@@ -1,354 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { AgentManager, createAgentManager } from '../../src/runtime/manager.js';
-import { createMockBackend, type MockBackend } from '../../src/runtime/backends/mock.js';
-import { createAtlasWithAgents } from '../../src/atlas.js';
-import type { Atlas } from '../../src/atlas.js';
-import type {
-  AgentDelegate,
-  AgentDelegateResult,
-  AgentObserverCallbacks,
-} from '../../src/runtime/types.js';
-import { createTask } from '../../src/types/task.js';
-import { createTrajectory, createStep, successOutcome } from '../../src/types/index.js';
-import { createMemorySystem } from '../../src/memory/index.js';
-import type { MemorySystem } from '../../src/memory/system.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-
-describe('AgentDelegate', () => {
-  let tempDir: string;
-  let memory: MemorySystem;
-  let mockBackend: MockBackend;
-  let persistence: any;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'delegate-test-'));
-    persistence = createSqlitePersistence({ baseDir: tempDir });
-    await persistence.init();
-    memory = createMemorySystem(persistence, tempDir);
-    mockBackend = createMockBackend({
-      success: true,
-      result: 'Mock result',
-      durationMs: 50,
-      toolCalls: [],
-    });
-  });
-
-  afterEach(async () => {
-    persistence.close();
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  function createTestDelegate(
-    response?: Partial<AgentDelegateResult>
-  ): AgentDelegate & { calls: Array<{ prompt: string; options: any }> } {
-    const calls: Array<{ prompt: string; options: any }> = [];
-    return {
-      calls,
-      async execute(prompt, options) {
-        calls.push({ prompt, options });
-        return {
-          success: true,
-          output: 'Delegate completed the task',
-          ...response,
-        };
-      },
-    };
-  }
-
-  describe('delegate execution', () => {
-    it('calls delegate.execute() with correct prompt and options', async () => {
-      const delegate = createTestDelegate();
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({
-        domain: 'test',
-        description: 'Analyze the codebase for security issues',
-      });
-
-      await manager.spawn({
-        agentType: 'mock',
-        task,
-        cwd: '/tmp/test-workspace',
-        timeout: 30000,
-      });
-
-      expect(delegate.calls).toHaveLength(1);
-      expect(delegate.calls[0].prompt).toBe('Analyze the codebase for security issues');
-      expect(delegate.calls[0].options.cwd).toBe('/tmp/test-workspace');
-      expect(delegate.calls[0].options.timeoutMs).toBe(30000);
-    });
-
-    it('maps delegate result to AgentResult with minimal trajectory', async () => {
-      const delegate = createTestDelegate({
-        success: true,
-        output: 'Found 3 issues',
-        structured: { issues: 3 },
-      });
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({
-        domain: 'security',
-        description: 'Scan for vulnerabilities',
-      });
-
-      const result = await manager.spawn({ agentType: 'mock', task });
-
-      expect(result.success).toBe(true);
-      expect(result.trajectory).toBeDefined();
-      expect(result.trajectory.steps).toHaveLength(1);
-      expect(result.trajectory.steps[0].action).toBe('delegate_execution');
-      expect(result.trajectory.steps[0].observation).toBe('Found 3 issues');
-      expect(result.trajectory.outcome.success).toBe(true);
-      expect(result.trajectory.outcome.solution).toEqual({ issues: 3 });
-      expect(result.trajectory.agentId).toBe('delegate');
-      expect(result.session.agentType).toBe('delegate');
-    });
-
-    it('uses delegate-provided trajectory directly', async () => {
-      const task = createTask({
-        domain: 'test',
-        description: 'Run analysis',
-      });
-
-      const customTrajectory = createTrajectory({
-        task,
-        steps: [
-          createStep({ action: 'read_file', observation: 'File contents' }),
-          createStep({ action: 'analyze', observation: 'Analysis complete' }),
-        ],
-        outcome: successOutcome('Custom result'),
-        agentId: 'my-custom-agent',
-        llmCalls: 5,
-        totalTokens: 1500,
-      });
-
-      const delegate = createTestDelegate({
-        success: true,
-        output: 'Analysis done',
-        trajectory: customTrajectory,
-      });
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const result = await manager.spawn({ agentType: 'mock', task });
-
-      expect(result.trajectory.steps).toHaveLength(2);
-      expect(result.trajectory.agentId).toBe('my-custom-agent');
-      expect(result.trajectory.llmCalls).toBe(5);
-      expect(result.trajectory.totalTokens).toBe(1500);
-    });
-
-    it('includes structured field in trajectory outcome', async () => {
-      const delegate = createTestDelegate({
-        success: true,
-        output: 'Done',
-        structured: { score: 0.95, issues: [] },
-      });
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({ domain: 'test', description: 'Evaluate' });
-      const result = await manager.spawn({ agentType: 'mock', task });
-
-      expect(result.trajectory.outcome.solution).toEqual({
-        score: 0.95,
-        issues: [],
-      });
-    });
-
-    it('passes formatted knowledge in systemContext', async () => {
-      const delegate = createTestDelegate();
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({
-        domain: 'database',
-        description: 'Fix migration',
-      });
-
-      // Inject knowledge explicitly
-      await manager.spawn({
-        agentType: 'mock',
-        task,
-        systemPromptAdditions: 'Use best practices',
-        injectedKnowledge: {
-          experiences: [],
-          playbooks: [],
-        },
-      });
-
-      // systemContext should contain the system prompt additions
-      expect(delegate.calls[0].options.systemContext).toContain('Use best practices');
-    });
-  });
-
-  describe('fallback behavior', () => {
-    it('falls back to backend when no delegate is set', async () => {
-      const manager = createAgentManager(memory);
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({
-        domain: 'test',
-        description: 'Test task',
-      });
-
-      const result = await manager.spawn({ agentType: 'mock', task });
-
-      // Result should come from mock backend (not delegate)
-      expect(result.session.agentType).toBe('mock');
-      expect(result.success).toBe(true);
-    });
-
-    it('reverts to backend after clearDelegate()', async () => {
-      const delegate = createTestDelegate();
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const task = createTask({
-        domain: 'test',
-        description: 'Test task',
-      });
-
-      // First call uses delegate
-      const result1 = await manager.spawn({ agentType: 'mock', task });
-      expect(result1.session.agentType).toBe('delegate');
-
-      // Clear delegate
-      manager.clearDelegate();
-
-      // Second call uses backend
-      const result2 = await manager.spawn({ agentType: 'mock', task });
-      expect(result2.session.agentType).toBe('mock');
-    });
-  });
-
-  describe('observer integration', () => {
-    it('notifies observers on session start and end', async () => {
-      const delegate = createTestDelegate();
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const onSessionStart = vi.fn();
-      const onSessionEnd = vi.fn();
-      manager.addObserver({ onSessionStart, onSessionEnd });
-
-      const task = createTask({ domain: 'test', description: 'Observe me' });
-      await manager.spawn({ agentType: 'mock', task });
-
-      expect(onSessionStart).toHaveBeenCalledOnce();
-      expect(onSessionEnd).toHaveBeenCalledOnce();
-
-      // Verify session and trajectory are passed to onSessionEnd
-      const [session, trajectory] = onSessionEnd.mock.calls[0];
-      expect(session.agentType).toBe('delegate');
-      expect(trajectory.task.description).toBe('Observe me');
-    });
-
-    it('trajectory from delegate path is available in onSessionEnd', async () => {
-      const task = createTask({ domain: 'test', description: 'Track me' });
-      const customTrajectory = createTrajectory({
-        task,
-        steps: [createStep({ action: 'step1', observation: 'done' })],
-        outcome: successOutcome('result'),
-        agentId: 'tracked-agent',
-      });
-
-      const delegate = createTestDelegate({
-        success: true,
-        output: 'Tracked',
-        trajectory: customTrajectory,
-      });
-      const manager = createAgentManager(memory, { delegate });
-      manager.registerBackend(mockBackend);
-
-      const onSessionEnd = vi.fn();
-      manager.addObserver({ onSessionEnd });
-
-      await manager.spawn({ agentType: 'mock', task });
-
-      const [, trajectory] = onSessionEnd.mock.calls[0];
-      expect(trajectory.agentId).toBe('tracked-agent');
-    });
-  });
-
-  describe('Atlas integration', () => {
-    let atlas: Atlas;
-
-    afterEach(async () => {
-      if (atlas) await atlas.close();
-    });
-
-    it('createAtlasWithAgents passes delegate to agent manager', async () => {
-      const delegate = createTestDelegate();
-
-      atlas = createAtlasWithAgents([mockBackend], {
-        storage: { baseDir: tempDir },
-        execution: {
-          defaultAgentType: 'mock',
-          maxExecutionTime: 60,
-          captureToolCalls: true,
-        },
-      }, { delegate });
-
-      await atlas.init();
-
-      expect(atlas.getDelegate()).toBe(delegate);
-    });
-
-    it('atlas.setDelegate() and atlas.getDelegate() work correctly', async () => {
-      atlas = createAtlasWithAgents([mockBackend], {
-        storage: { baseDir: tempDir },
-        execution: {
-          defaultAgentType: 'mock',
-          maxExecutionTime: 60,
-          captureToolCalls: true,
-        },
-      });
-
-      await atlas.init();
-
-      // No delegate initially
-      expect(atlas.getDelegate()).toBeUndefined();
-
-      // Set delegate
-      const delegate = createTestDelegate();
-      atlas.setDelegate(delegate);
-      expect(atlas.getDelegate()).toBe(delegate);
-    });
-
-    it('atlas.solve() with delegate returns valid SolveResult', async () => {
-      const delegate = createTestDelegate({
-        success: true,
-        output: 'Task solved via delegate',
-      });
-
-      atlas = createAtlasWithAgents([mockBackend], {
-        storage: { baseDir: tempDir },
-        execution: {
-          defaultAgentType: 'mock',
-          maxExecutionTime: 60,
-          captureToolCalls: true,
-        },
-      }, { delegate });
-
-      await atlas.init();
-
-      const task = createTask({
-        domain: 'test',
-        description: 'Solve this task via delegate',
-      });
-
-      const result = await atlas.solve(task);
-
-      expect(result.trajectory).toBeDefined();
-      expect(result.trajectory.agentId).toBe('delegate');
-      expect(result.usedAgentManager).toBe(true);
-      expect(result.trajectory.outcome.success).toBe(true);
-    });
-  });
-});