cognitive-core 0.1.0 → 0.2.0

package/tests/workspace/manager.test.ts

@@ -0,0 +1,215 @@
+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

@@ -0,0 +1,336 @@
+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);
+    });
+  });
+});