cognitive-core 0.0.2 → 0.1.0

package/tests/surfacing/skill-library.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SkillLibrary, createSkillLibrary } from '../../src/surfacing/skill-library.js';
+import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
+import type { Playbook } from '../../src/types/playbook.js';
+import type { Task } from '../../src/types/task.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('SkillLibrary', () => {
+  let tempDir: string;
+  let playbooks: PlaybookLibrary;
+  let skillLibrary: SkillLibrary;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
+    playbooks = createPlaybookLibrary(tempDir);
+    await playbooks.init();
+    skillLibrary = createSkillLibrary(playbooks, {
+      promotion: {
+        minConfidence: 0.85,
+        minSuccessCount: 3,
+        minSuccessRate: 0.8,
+      },
+      limits: {
+        maxCoreSkills: 5,
+        maxDomainSkills: 3,
+        maxContextualPlaybooks: 2,
+      },
+    });
+  });
+
+  afterEach(async () => {
+    await playbooks.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  function createSamplePlaybook(overrides?: Partial<Playbook>): Playbook {
+    return {
+      id: `playbook-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name: 'sample-playbook',
+      applicability: {
+        situations: ['General coding task'],
+        triggers: [],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Follow best practices',
+        tactics: ['Read code', 'Understand context', 'Make changes'],
+      },
+      verification: {
+        successIndicators: ['Tests pass'],
+        failureIndicators: ['Tests fail'],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 0,
+        failureCount: 0,
+      },
+      confidence: 0.5,
+      complexity: 'moderate',
+      estimatedEffort: 3,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  function createSampleTask(overrides?: Partial<Task>): Task {
+    return {
+      id: `task-${Date.now()}`,
+      description: 'Fix the bug in the code',
+      domain: 'code',
+      context: {},
+      metadata: {},
+      createdAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  describe('refreshTiers', () => {
+    it('should promote high-confidence playbooks to core', async () => {
+      // Create a playbook that meets promotion criteria
+      const coreCandidate = createSamplePlaybook({
+        name: 'core-skill',
+        confidence: 0.9,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 1,
+        },
+      });
+      await playbooks.add(coreCandidate);
+
+      // Create a low-confidence playbook
+      const lowConf = createSamplePlaybook({
+        name: 'low-conf',
+        confidence: 0.3,
+      });
+      await playbooks.add(lowConf);
+
+      const result = await skillLibrary.refreshTiers();
+
+      expect(result.promoted).toContain(coreCandidate.id);
+      expect(result.coreCount).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should respect maxCoreSkills limit', async () => {
+      // Add more than maxCoreSkills (5) high-confidence playbooks
+      for (let i = 0; i < 7; i++) {
+        await playbooks.add(createSamplePlaybook({
+          name: `core-${i}`,
+          confidence: 0.9 + (i * 0.01),
+          evolution: {
+            version: '1.0.0',
+            createdFrom: [],
+            failures: [],
+            refinements: [],
+            successCount: 10,
+            failureCount: 0,
+          },
+        }));
+      }
+
+      const result = await skillLibrary.refreshTiers();
+
+      expect(result.coreCount).toBeLessThanOrEqual(5);
+    });
+  });
+
+  describe('getSkillsForAgent', () => {
+    it('should return skills for a task', async () => {
+      // Add a high-confidence playbook
+      await playbooks.add(createSamplePlaybook({
+        name: 'core-skill',
+        confidence: 0.9,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 1,
+        },
+      }));
+
+      // Add a domain-specific playbook
+      await playbooks.add(createSamplePlaybook({
+        name: 'typescript-skill',
+        confidence: 0.7,
+        applicability: {
+          situations: ['TypeScript debugging'],
+          triggers: ['TS2322'],
+          antiPatterns: [],
+          domains: ['typescript'],
+        },
+      }));
+
+      await skillLibrary.refreshTiers();
+
+      const task = createSampleTask({
+        description: 'Fix TypeScript type error',
+        domain: 'typescript',
+      });
+
+      const skills = await skillLibrary.getSkillsForAgent(task);
+
+      expect(skills).toBeDefined();
+      expect(skills.totalTokenEstimate).toBeGreaterThan(0);
+    });
+
+    it('should respect includeCore option', async () => {
+      await playbooks.add(createSamplePlaybook({
+        name: 'core-skill',
+        confidence: 0.95,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 0,
+        },
+      }));
+
+      await skillLibrary.refreshTiers();
+
+      const task = createSampleTask();
+
+      const withCore = await skillLibrary.getSkillsForAgent(task, { includeCore: true });
+      const withoutCore = await skillLibrary.getSkillsForAgent(task, { includeCore: false });
+
+      expect(withCore.core.length).toBeGreaterThanOrEqual(withoutCore.core.length);
+    });
+  });
+
+  describe('formatForSystemPrompt', () => {
+    it('should format skills as markdown', async () => {
+      await playbooks.add(createSamplePlaybook({
+        name: 'test-skill',
+        confidence: 0.9,
+        guidance: {
+          strategy: 'Test strategy',
+          tactics: ['Tactic 1', 'Tactic 2'],
+        },
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 0,
+        },
+      }));
+
+      await skillLibrary.refreshTiers();
+
+      const skills = await skillLibrary.getSkillsForAgent(createSampleTask());
+      const formatted = skillLibrary.formatForSystemPrompt(skills);
+
+      expect(formatted).toContain('Skills');
+      expect(typeof formatted).toBe('string');
+    });
+  });
+
+  describe('recordOutcome', () => {
+    it('should record playbook usage outcome', async () => {
+      const playbook = createSamplePlaybook({ name: 'tracked-playbook' });
+      await playbooks.add(playbook);
+
+      await skillLibrary.recordOutcome(playbook.id, 'traj-1', true);
+      await skillLibrary.recordOutcome(playbook.id, 'traj-2', true);
+      await skillLibrary.recordOutcome(playbook.id, 'traj-3', false);
+
+      const updated = await playbooks.get(playbook.id);
+      expect(updated?.evolution.successCount).toBe(2);
+      expect(updated?.evolution.failureCount).toBe(1);
+    });
+  });
+
+  describe('getPromotionCandidates and getDemotionCandidates', () => {
+    it('should return playbooks eligible for promotion', async () => {
+      // High performer not yet promoted
+      await playbooks.add(createSamplePlaybook({
+        name: 'promotion-candidate',
+        confidence: 0.86,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 5,
+          failureCount: 0,
+        },
+      }));
+
+      const candidates = await skillLibrary.getPromotionCandidates();
+      expect(candidates.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return library statistics', async () => {
+      await playbooks.add(createSamplePlaybook({
+        name: 'core-1',
+        confidence: 0.95,
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 10,
+          failureCount: 0,
+        },
+      }));
+
+      await skillLibrary.refreshTiers();
+
+      const stats = skillLibrary.getStats();
+      expect(stats).toHaveProperty('coreSkillCount');
+      expect(stats).toHaveProperty('domainSkillCounts');
+      expect(typeof stats.coreSkillCount).toBe('number');
+    });
+  });
+});

package/tests/types/outcome.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import {
+  OutcomeSchema,
+  successOutcome,
+  failureOutcome,
+  partialOutcome,
+  type Outcome,
+} from '../../src/types/outcome.js';
+
+describe('Outcome', () => {
+  it('should validate a successful outcome', () => {
+    const outcome: Outcome = {
+      success: true,
+      partialScore: 1.0,
+      solution: { result: 42 },
+      verificationDetails: { method: 'exact_match' },
+    };
+    const result = OutcomeSchema.parse(outcome);
+    expect(result.success).toBe(true);
+    expect(result.partialScore).toBe(1.0);
+    expect(result.solution).toEqual({ result: 42 });
+  });
+
+  it('should validate a failed outcome with error', () => {
+    const outcome: Outcome = {
+      success: false,
+      partialScore: 0,
+      errorInfo: 'Timeout exceeded',
+      verificationDetails: {},
+    };
+    const result = OutcomeSchema.parse(outcome);
+    expect(result.success).toBe(false);
+    expect(result.errorInfo).toBe('Timeout exceeded');
+  });
+
+  it('should apply defaults', () => {
+    const outcome = OutcomeSchema.parse({
+      success: true,
+    });
+    expect(outcome.partialScore).toBe(0);
+    expect(outcome.verificationDetails).toEqual({});
+  });
+
+  it('should validate partialScore bounds', () => {
+    // Valid scores
+    expect(OutcomeSchema.parse({ success: false, partialScore: 0 }).partialScore).toBe(0);
+    expect(OutcomeSchema.parse({ success: false, partialScore: 0.5 }).partialScore).toBe(0.5);
+    expect(OutcomeSchema.parse({ success: true, partialScore: 1 }).partialScore).toBe(1);
+  });
+
+  it('should reject partialScore out of bounds', () => {
+    expect(() =>
+      OutcomeSchema.parse({ success: false, partialScore: -0.1 })
+    ).toThrow();
+
+    expect(() =>
+      OutcomeSchema.parse({ success: true, partialScore: 1.5 })
+    ).toThrow();
+  });
+
+  it('should allow various solution types', () => {
+    // String solution
+    expect(
+      OutcomeSchema.parse({ success: true, solution: 'answer' }).solution
+    ).toBe('answer');
+
+    // Number solution
+    expect(
+      OutcomeSchema.parse({ success: true, solution: 42 }).solution
+    ).toBe(42);
+
+    // Array solution
+    expect(
+      OutcomeSchema.parse({ success: true, solution: [1, 2, 3] }).solution
+    ).toEqual([1, 2, 3]);
+
+    // Object solution
+    expect(
+      OutcomeSchema.parse({ success: true, solution: { a: 1 } }).solution
+    ).toEqual({ a: 1 });
+  });
+});
+
+describe('successOutcome', () => {
+  it('should create a successful outcome with solution', () => {
+    const outcome = successOutcome('correct answer');
+    expect(outcome.success).toBe(true);
+    expect(outcome.partialScore).toBe(1.0);
+    expect(outcome.solution).toBe('correct answer');
+    expect(outcome.errorInfo).toBeUndefined();
+  });
+
+  it('should create a successful outcome with details', () => {
+    const outcome = successOutcome(42, { checked: true, time_ms: 100 });
+    expect(outcome.solution).toBe(42);
+    expect(outcome.verificationDetails.checked).toBe(true);
+    expect(outcome.verificationDetails.time_ms).toBe(100);
+  });
+
+  it('should accept complex solutions', () => {
+    const solution = {
+      grid: [[1, 2], [3, 4]],
+      metadata: { transformed: true },
+    };
+    const outcome = successOutcome(solution);
+    expect(outcome.solution).toEqual(solution);
+  });
+});
+
+describe('failureOutcome', () => {
+  it('should create a failed outcome with error', () => {
+    const outcome = failureOutcome('Test failed: assertion error');
+    expect(outcome.success).toBe(false);
+    expect(outcome.partialScore).toBe(0);
+    expect(outcome.errorInfo).toBe('Test failed: assertion error');
+    expect(outcome.solution).toBeUndefined();
+  });
+
+  it('should create a failed outcome with partial score', () => {
+    const outcome = failureOutcome('Incomplete solution', 0.4);
+    expect(outcome.success).toBe(false);
+    expect(outcome.partialScore).toBe(0.4);
+    expect(outcome.errorInfo).toBe('Incomplete solution');
+  });
+
+  it('should create a failed outcome with details', () => {
+    const outcome = failureOutcome('Error', 0.2, { attempts: 3 });
+    expect(outcome.verificationDetails.attempts).toBe(3);
+  });
+});
+
+describe('partialOutcome', () => {
+  it('should create a partial outcome', () => {
+    const outcome = partialOutcome(0.7, 'almost correct');
+    expect(outcome.success).toBe(false);
+    expect(outcome.partialScore).toBe(0.7);
+    expect(outcome.solution).toBe('almost correct');
+    expect(outcome.errorInfo).toBeUndefined();
+  });
+
+  it('should create a partial outcome with details', () => {
+    const outcome = partialOutcome(0.5, [1, 2, 3], { matched: 2, total: 4 });
+    expect(outcome.partialScore).toBe(0.5);
+    expect(outcome.solution).toEqual([1, 2, 3]);
+    expect(outcome.verificationDetails.matched).toBe(2);
+  });
+});

package/tests/types/step.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from 'vitest';
+import { StepSchema, createStep, type Step } from '../../src/types/step.js';
+
+describe('Step', () => {
+  it('should validate a complete step', () => {
+    const step: Step = {
+      thought: 'I need to read the file first',
+      action: 'read_file("main.ts")',
+      observation: 'File contents: export function main() {}',
+      timestamp: new Date(),
+      metadata: { tool: 'read_file' },
+      attributionScore: 0.8,
+    };
+    const result = StepSchema.parse(step);
+    expect(result.thought).toBe('I need to read the file first');
+    expect(result.action).toBe('read_file("main.ts")');
+    expect(result.observation).toBe('File contents: export function main() {}');
+    expect(result.attributionScore).toBe(0.8);
+  });
+
+  it('should validate a step without thought', () => {
+    const step = StepSchema.parse({
+      action: 'run_command("npm test")',
+      observation: 'All tests passed',
+    });
+    expect(step.thought).toBeUndefined();
+    expect(step.action).toBe('run_command("npm test")');
+  });
+
+  it('should apply defaults for optional fields', () => {
+    const step = StepSchema.parse({
+      action: 'search("pattern")',
+      observation: 'Found 3 matches',
+    });
+    expect(step.metadata).toEqual({});
+    expect(step.timestamp).toBeInstanceOf(Date);
+    expect(step.attributionScore).toBeUndefined();
+  });
+
+  it('should validate attribution score bounds', () => {
+    // Valid score
+    const validStep = StepSchema.parse({
+      action: 'test',
+      observation: 'result',
+      attributionScore: 0.5,
+    });
+    expect(validStep.attributionScore).toBe(0.5);
+
+    // Score at minimum
+    const minStep = StepSchema.parse({
+      action: 'test',
+      observation: 'result',
+      attributionScore: 0,
+    });
+    expect(minStep.attributionScore).toBe(0);
+
+    // Score at maximum
+    const maxStep = StepSchema.parse({
+      action: 'test',
+      observation: 'result',
+      attributionScore: 1,
+    });
+    expect(maxStep.attributionScore).toBe(1);
+  });
+
+  it('should reject attribution scores out of bounds', () => {
+    expect(() =>
+      StepSchema.parse({
+        action: 'test',
+        observation: 'result',
+        attributionScore: -0.1,
+      })
+    ).toThrow();
+
+    expect(() =>
+      StepSchema.parse({
+        action: 'test',
+        observation: 'result',
+        attributionScore: 1.1,
+      })
+    ).toThrow();
+  });
+});
+
+describe('createStep', () => {
+  it('should create a step with required fields', () => {
+    const step = createStep({
+      action: 'write_file("output.txt", "data")',
+      observation: 'File written successfully',
+    });
+    expect(step.action).toBe('write_file("output.txt", "data")');
+    expect(step.observation).toBe('File written successfully');
+    expect(step.timestamp).toBeInstanceOf(Date);
+  });
+
+  it('should create a step with thought', () => {
+    const step = createStep({
+      thought: 'First, I should analyze the error message',
+      action: 'analyze_error()',
+      observation: 'Error: undefined variable x',
+    });
+    expect(step.thought).toBe('First, I should analyze the error message');
+  });
+
+  it('should create a step with metadata', () => {
+    const step = createStep({
+      action: 'api_call()',
+      observation: 'Response: 200 OK',
+      metadata: { duration_ms: 150, cached: false },
+    });
+    expect(step.metadata.duration_ms).toBe(150);
+    expect(step.metadata.cached).toBe(false);
+  });
+
+  it('should set timestamp to current time', () => {
+    const before = new Date();
+    const step = createStep({
+      action: 'test_action',
+      observation: 'test_observation',
+    });
+    const after = new Date();
+    expect(step.timestamp.getTime()).toBeGreaterThanOrEqual(before.getTime());
+    expect(step.timestamp.getTime()).toBeLessThanOrEqual(after.getTime());
+  });
+
+  it('should not set attributionScore by default', () => {
+    const step = createStep({
+      action: 'action',
+      observation: 'observation',
+    });
+    expect(step.attributionScore).toBeUndefined();
+  });
+});