cognitive-core 0.2.5 → 0.3.1

package/tests/workspace/manager.test.ts

@@ -1,215 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { readFile, readdir, access, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { WorkspaceManager } from 'agent-workspace';
-import type { WorkspaceHandle } from 'agent-workspace';
-
-/**
- * Integration tests verifying that the agent-workspace package works
- * correctly within cognitive-core's context (atlas-workspaces prefix,
- * skills/ as additional directory, handle-based I/O).
- */
-describe('WorkspaceManager (agent-workspace integration)', () => {
-  let manager: WorkspaceManager;
-  let testBaseDir: string;
-  let handles: WorkspaceHandle[];
-
-  beforeEach(() => {
-    testBaseDir = join(tmpdir(), `atlas-test-${randomUUID().slice(0, 8)}`);
-    manager = new WorkspaceManager({ baseDir: testBaseDir, prefix: 'atlas-workspaces' });
-    handles = [];
-  });
-
-  afterEach(async () => {
-    for (const handle of handles) {
-      try {
-        await manager.cleanup(handle);
-      } catch {
-        // ignore cleanup errors
-      }
-    }
-  });
-
-  async function createWorkspace(taskType = 'test-task'): Promise<WorkspaceHandle> {
-    const handle = await manager.create(taskType, { additionalDirs: ['skills'] });
-    handles.push(handle);
-    return handle;
-  }
-
-  describe('workspace creation with atlas conventions', () => {
-    it('should create workspace under atlas-workspaces prefix', async () => {
-      const handle = await createWorkspace();
-
-      expect(handle.id).toContain('test-task-');
-      expect(handle.path).toContain('atlas-workspaces');
-    });
-
-    it('should create default directories plus skills/', async () => {
-      const handle = await createWorkspace();
-
-      // Default dirs: input, output, resources, scratch
-      for (const dir of ['input', 'output', 'resources', 'scratch', 'skills']) {
-        const stats = await stat(handle.dir(dir));
-        expect(stats.isDirectory()).toBe(true);
-      }
-    });
-
-    it('should provide convenience accessors for default dirs', async () => {
-      const handle = await createWorkspace();
-
-      expect(handle.inputDir).toContain('input');
-      expect(handle.outputDir).toContain('output');
-      expect(handle.resourcesDir).toContain('resources');
-      expect(handle.scratchDir).toContain('scratch');
-    });
-
-    it('should create unique workspace IDs', async () => {
-      const h1 = await createWorkspace();
-      const h2 = await createWorkspace();
-
-      expect(h1.id).not.toBe(h2.id);
-      expect(h1.path).not.toBe(h2.path);
-    });
-  });
-
-  describe('handle-based I/O for cognitive-core usage', () => {
-    it('should write and read JSON via handle', async () => {
-      const handle = await createWorkspace();
-      const data = { key: 'value', nested: { count: 42 } };
-
-      await handle.writeJson('input', 'data.json', data);
-
-      const result = await handle.readJson('input', 'data.json');
-      expect(result).toEqual(data);
-    });
-
-    it('should write and read JSONL via handle', async () => {
-      const handle = await createWorkspace();
-      const items = [
-        { step: 1, action: 'read' },
-        { step: 2, action: 'write' },
-      ];
-
-      await handle.writeJsonl('input', 'trajectory.jsonl', items);
-
-      const result = await handle.readJsonl('input', 'trajectory.jsonl');
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({ step: 1, action: 'read' });
-    });
-
-    it('should write and read markdown with frontmatter via handle', async () => {
-      const handle = await createWorkspace();
-
-      await handle.writeMarkdown('input', 'context.md', {
-        frontmatter: { domain: 'typescript', outcome: 'success' },
-        body: 'This is the body text.',
-      });
-
-      const result = await handle.readMarkdown('input', 'context.md');
-      expect(result.frontmatter).toEqual({ domain: 'typescript', outcome: 'success' });
-      expect(result.body).toContain('This is the body text.');
-    });
-
-    it('should write skills to skills/ directory', async () => {
-      const handle = await createWorkspace();
-
-      await handle.writeRaw('skills', 'trajectory-analysis/SKILL.md', '# Trajectory Analysis\n\nAnalyze step sequences.');
-
-      const content = await readFile(
-        join(handle.dir('skills'), 'trajectory-analysis', 'SKILL.md'),
-        'utf-8'
-      );
-      expect(content).toBe('# Trajectory Analysis\n\nAnalyze step sequences.');
-    });
-
-    it('should write file resources', async () => {
-      const handle = await createWorkspace();
-
-      await handle.writeRaw('resources', 'docs/api.md', '# API Documentation\n\nEndpoints...');
-
-      const content = await readFile(join(handle.resourcesDir, 'docs/api.md'), 'utf-8');
-      expect(content).toContain('API Documentation');
-    });
-  });
-
-  describe('output validation', () => {
-    it('should validate required files exist', async () => {
-      const handle = await createWorkspace();
-      await handle.writeJson('output', 'result.json', { score: 0.95 });
-
-      const result = await handle.validateOutput({
-        files: [
-          { path: 'result.json', format: 'json', required: true, description: 'Main result' },
-        ],
-      });
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it('should report missing required files', async () => {
-      const handle = await createWorkspace();
-
-      const result = await handle.validateOutput({
-        files: [
-          { path: 'result.json', format: 'json', required: true, description: 'Required result' },
-          { path: 'optional.json', format: 'json', required: false, description: 'Optional' },
-        ],
-      });
-
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-      expect(result.errors[0].path).toBe('result.json');
-    });
-
-    it('should pass when only optional files are missing', async () => {
-      const handle = await createWorkspace();
-
-      const result = await handle.validateOutput({
-        files: [
-          { path: 'optional.json', format: 'json', required: false, description: 'Optional' },
-        ],
-      });
-
-      expect(result.valid).toBe(true);
-    });
-  });
-
-  describe('lifecycle', () => {
-    it('should cleanup workspace directory', async () => {
-      const handle = await manager.create('cleanup-test', { additionalDirs: ['skills'] });
-      await handle.writeRaw('input', 'data.txt', 'test');
-
-      await manager.cleanup(handle);
-
-      await expect(access(handle.path)).rejects.toThrow();
-    });
-
-    it('should list active workspaces', async () => {
-      await createWorkspace('task-a');
-      await createWorkspace('task-b');
-
-      const active = await manager.list();
-      expect(active).toHaveLength(2);
-      expect(active.map(h => h.id)).toEqual(
-        expect.arrayContaining([
-          expect.stringContaining('task-a'),
-          expect.stringContaining('task-b'),
-        ])
-      );
-    });
-
-    it('should prune stale workspaces', async () => {
-      await createWorkspace('old-task');
-
-      const pruned = await manager.pruneStale(0);
-      expect(pruned).toBe(1);
-
-      const active = await manager.list();
-      expect(active).toHaveLength(0);
-      handles = []; // already cleaned up
-    });
-  });
-});

package/tests/workspace/runner.test.ts

@@ -1,336 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { access } from 'node:fs/promises';
-import { randomUUID } from 'node:crypto';
-import { WorkspaceManager } from 'agent-workspace';
-import type { WorkspaceHandle } from 'agent-workspace';
-import { AgenticTaskRunner } from '../../src/workspace/runner.js';
-import { AgenticTaskOutputError } from '../../src/workspace/types.js';
-import type {
-  AgenticTaskTemplate,
-  ProcessingContext,
-} from '../../src/workspace/types.js';
-import type { AgenticTaskRunnerConfig } from '../../src/types/config.js';
-import { createMockBackend } from '../../src/runtime/backends/mock.js';
-import { AgentManager, createAgentManager } from '../../src/runtime/manager.js';
-import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
-import { UnifiedLearningPipeline, createUnifiedPipeline } from '../../src/learning/unified-pipeline.js';
-import { createSqlitePersistence } from '../../src/persistence/index.js';
-
-// Simple test input/output types
-interface TestInput {
-  data: string;
-  complexity?: 'simple' | 'complex';
-}
-
-interface TestOutput {
-  result: string;
-  score: number;
-}
-
-// Mock template that writes output to the workspace via WorkspaceHandle
-function createTestTemplate(options?: {
-  heuristic?: boolean;
-  outputData?: TestOutput;
-  failOutput?: boolean;
-}): AgenticTaskTemplate<TestInput, TestOutput> {
-  const outputData = options?.outputData ?? { result: 'analyzed', score: 0.9 };
-
-  return {
-    taskType: 'test-analysis',
-    domain: 'test-analysis',
-    description: 'Test analysis template',
-
-    assessComplexity(input: TestInput) {
-      if (options?.heuristic && input.complexity !== 'complex') {
-        return 'heuristic';
-      }
-      return input.complexity === 'complex' ? 'thorough' : 'standard';
-    },
-
-    agentType: 'mock',
-
-    heuristicFallback: options?.heuristic
-      ? async (_input: TestInput) => ({ result: 'heuristic-result', score: 1.0 })
-      : undefined,
-
-    async prepareWorkspace(input: TestInput, handle: WorkspaceHandle) {
-      await handle.writeJson('input', 'data.json', { data: input.data });
-      // Pre-write the output file to simulate what a real agent would produce.
-      // In production, the agent writes this; in tests, the mock backend doesn't
-      // actually write files, so we simulate it here.
-      if (!options?.failOutput) {
-        await handle.writeJson('output', 'result.json', outputData);
-      }
-    },
-
-    buildTaskPrompt(input: TestInput) {
-      return `Analyze this data: ${input.data}. Write results to output/result.json.`;
-    },
-
-    getSkills(_input: TestInput) {
-      return [];
-    },
-
-    getResources(_input: TestInput) {
-      return [];
-    },
-
-    outputConfig: {
-      files: [
-        {
-          path: 'result.json',
-          format: 'json' as const,
-          required: true,
-          description: 'Analysis result',
-        },
-      ],
-    },
-
-    async collectOutput(handle: WorkspaceHandle) {
-      if (options?.failOutput) {
-        throw new Error('Output validation failed');
-      }
-      // Read output via handle's typed I/O
-      try {
-        return await handle.readJson<TestOutput>('output', 'result.json');
-      } catch {
-        return outputData;
-      }
-    },
-
-    async processOutput(
-      _output: TestOutput,
-      _input: TestInput,
-      _context: ProcessingContext
-    ) {
-      // No-op for testing
-    },
-  };
-}
-
-describe('AgenticTaskRunner', () => {
-  let testBaseDir: string;
-  let workspaceManager: WorkspaceManager;
-  let agentManager: AgentManager;
-  let memory: MemorySystem;
-  let learning: UnifiedLearningPipeline;
-  let runner: AgenticTaskRunner;
-  let config: AgenticTaskRunnerConfig;
-  let persistence: any;
-
-  beforeEach(async () => {
-    testBaseDir = join(tmpdir(), `atlas-runner-test-${randomUUID().slice(0, 8)}`);
-
-    workspaceManager = new WorkspaceManager({
-      baseDir: testBaseDir,
-      prefix: 'atlas-workspaces',
-    });
-    const atlasDir = join(testBaseDir, '.atlas');
-    persistence = createSqlitePersistence({ baseDir: atlasDir });
-    await persistence.init();
-    memory = createMemorySystem(persistence, atlasDir);
-    await memory.init();
-    learning = createUnifiedPipeline(memory);
-    agentManager = createAgentManager(memory);
-
-    // Register mock backend that simulates agent writing output
-    const mockBackend = createMockBackend({
-      success: true,
-      result: 'Analysis complete',
-      durationMs: 50,
-      toolCalls: [
-        {
-          name: 'write_file',
-          input: { path: 'output/result.json' },
-          output: 'written',
-        },
-      ],
-    });
-    agentManager.registerBackend(mockBackend);
-
-    config = {
-      cleanupWorkspaces: true,
-      keepFailedWorkspaces: true,
-      maxConcurrentAgents: 3,
-      staleWorkspaceMaxAgeMs: 3600_000,
-    };
-
-    runner = new AgenticTaskRunner(
-      workspaceManager,
-      agentManager,
-      memory,
-      learning,
-      config
-    );
-  });
-
-  afterEach(async () => {
-    // Cleanup any remaining workspaces
-    const active = await workspaceManager.list();
-    for (const ws of active) {
-      await workspaceManager.cleanup(ws);
-    }
-    await memory.close();
-    persistence.close();
-  });
-
-  describe('heuristic fallback path', () => {
-    it('should use heuristic when complexity is simple and fallback exists', async () => {
-      const template = createTestTemplate({ heuristic: true });
-      const result = await runner.run(template, { data: 'simple data' });
-
-      expect(result.method).toBe('heuristic');
-      expect(result.output.result).toBe('heuristic-result');
-      expect(result.output.score).toBe(1.0);
-      expect(result.metrics.tokensUsed).toBe(0);
-      expect(result.agentTrajectoryId).toBeUndefined();
-    });
-
-    it('should use agentic path when complexity is complex even with fallback', async () => {
-      const template = createTestTemplate({ heuristic: true });
-      const result = await runner.run(template, { data: 'complex data', complexity: 'complex' });
-
-      expect(result.method).toBe('agentic');
-      expect(result.agentTrajectoryId).toBeDefined();
-    });
-  });
-
-  describe('agentic path', () => {
-    it('should run full agentic pipeline', async () => {
-      const template = createTestTemplate();
-      const result = await runner.run(template, { data: 'test data' });
-
-      expect(result.method).toBe('agentic');
-      expect(result.agentTrajectoryId).toBeDefined();
-      expect(result.metrics.totalTimeMs).toBeGreaterThan(0);
-    });
-
-    it('should populate workspace with input files', async () => {
-      let capturedPath = '';
-
-      const template = createTestTemplate();
-      const origPrepare = template.prepareWorkspace.bind(template);
-      template.prepareWorkspace = async (input, handle) => {
-        capturedPath = handle.path;
-        await origPrepare(input, handle);
-      };
-
-      await runner.run(template, { data: 'workspace test' });
-
-      // Workspace path should use atlas-workspaces prefix
-      expect(capturedPath).toContain('atlas-workspaces');
-    });
-
-    it('should cleanup workspace on success by default', async () => {
-      let capturedPath = '';
-
-      const template = createTestTemplate();
-      const origPrepare = template.prepareWorkspace.bind(template);
-      template.prepareWorkspace = async (input, handle) => {
-        capturedPath = handle.path;
-        await origPrepare(input, handle);
-      };
-
-      await runner.run(template, { data: 'cleanup test' });
-
-      // Workspace should be cleaned up
-      await expect(access(capturedPath)).rejects.toThrow();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should throw AgenticTaskOutputError on collection failure', async () => {
-      const template = createTestTemplate({ failOutput: true });
-
-      await expect(runner.run(template, { data: 'fail' }))
-        .rejects.toThrow(AgenticTaskOutputError);
-    });
-
-    it('should keep workspace on failure when keepFailedWorkspaces is true', async () => {
-      const template = createTestTemplate({ failOutput: true });
-
-      try {
-        await runner.run(template, { data: 'fail' });
-      } catch {
-        // Expected
-      }
-
-      // Workspace should still exist
-      const active = await workspaceManager.list();
-      expect(active.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should cleanup workspace on failure when keepFailedWorkspaces is false', async () => {
-      const runnerNoKeep = new AgenticTaskRunner(
-        workspaceManager,
-        agentManager,
-        memory,
-        learning,
-        { ...config, keepFailedWorkspaces: false }
-      );
-
-      const template = createTestTemplate({ failOutput: true });
-
-      try {
-        await runnerNoKeep.run(template, { data: 'fail' });
-      } catch {
-        // Expected
-      }
-
-      const active = await workspaceManager.list();
-      expect(active).toHaveLength(0);
-    });
-  });
-
-  describe('timeout adjustment', () => {
-    it('should adjust timeout based on complexity', async () => {
-      let capturedTimeout = 0;
-
-      // Spy on agentManager.spawn to capture the timeout
-      const originalSpawn = agentManager.spawn.bind(agentManager);
-      agentManager.spawn = async (config) => {
-        capturedTimeout = config.timeout ?? 0;
-        return originalSpawn(config);
-      };
-
-      const template = createTestTemplate();
-      template.timeout = 60_000;
-
-      // Standard complexity
-      await runner.run(template, { data: 'standard', complexity: undefined });
-      expect(capturedTimeout).toBe(60_000);
-
-      // Thorough complexity
-      await runner.run(template, { data: 'thorough', complexity: 'complex' });
-      expect(capturedTimeout).toBe(120_000); // base * 2
-    });
-  });
-
-  describe('knowledge injection', () => {
-    it('should query memory for domain knowledge', async () => {
-      const querySpy = vi.spyOn(memory, 'queryV2');
-
-      const template = createTestTemplate();
-      await runner.run(template, { data: 'knowledge test' });
-
-      expect(querySpy).toHaveBeenCalledWith(
-        'Test analysis template',
-        expect.objectContaining({ domains: ['test-analysis'] })
-      );
-    });
-  });
-
-  describe('meta-learning', () => {
-    it('should process analysis agent trajectory through learning pipeline', async () => {
-      const processTrajectory = vi.spyOn(learning, 'processTrajectory');
-
-      const template = createTestTemplate();
-      await runner.run(template, { data: 'meta-learn test' });
-
-      // The runner should process the analysis agent's trajectory
-      expect(processTrajectory).toHaveBeenCalledTimes(1);
-    });
-  });
-});