cognitive-core 0.1.2 → 0.2.1

package/tests/learning/reflexion-generator.test.ts

@@ -0,0 +1,411 @@
+import { describe, it, expect } from 'vitest';
+import { ReflexionGenerator } from '../../src/learning/reflexion-generator.js';
+import { createTrajectory } from '../../src/types/trajectory.js';
+import { createTask } from '../../src/types/task.js';
+import { createStep } from '../../src/types/step.js';
+import { successOutcome, failureOutcome, partialOutcome } from '../../src/types/outcome.js';
+import type { PlaybookMatch } from '../../src/memory/playbook.js';
+import { createPlaybook } from '../../src/types/playbook.js';
+
+function makePlaybookMatch(name: string, score: number): PlaybookMatch {
+  return {
+    playbook: createPlaybook({
+      name,
+      applicability: {
+        situations: ['General task'],
+        triggers: [],
+        antiPatterns: [],
+        domains: ['typescript'],
+      },
+      guidance: {
+        strategy: `Strategy for ${name}`,
+        tactics: [],
+        steps: [],
+      },
+    }),
+    score,
+    matchType: 'situation',
+  };
+}
+
+describe('ReflexionGenerator', () => {
+  const generator = new ReflexionGenerator();
+
+  describe('heuristic mode — successful trajectory', () => {
+    it('should produce a valid reflexion episode', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix the typescript import error in src/index.ts',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            thought: 'Let me check the imports',
+            action: 'ReadFile src/index.ts',
+            observation: 'File content: import { foo } from "./bar"',
+          }),
+          createStep({
+            thought: 'The import path is wrong',
+            action: 'EditFile src/index.ts',
+            observation: 'File updated successfully',
+          }),
+        ],
+        outcome: successOutcome('Fixed import path'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      expect(episode.id).toBeDefined();
+      expect(episode.trajectoryId).toBe(trajectory.id);
+      expect(episode.outcome).toBe('success');
+      expect(episode.taskSummary).toContain('Fix the typescript import error');
+      expect(episode.domain).toBe('typescript');
+      expect(episode.selfCritique).toContain('Completed efficiently');
+      expect(episode.createdAt).toBeInstanceOf(Date);
+    });
+
+    it('should extract tool names as key insights', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Debug the application',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/app.ts',
+            observation: 'Source code',
+          }),
+          createStep({
+            action: 'SearchGlob *.test.ts',
+            observation: 'Found test files',
+          }),
+          createStep({
+            action: 'EditFile src/app.ts',
+            observation: 'Updated',
+          }),
+        ],
+        outcome: successOutcome('Debugged'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      const toolInsight = episode.keyInsights.find((i) => i.startsWith('Tools used:'));
+      expect(toolInsight).toBeDefined();
+      expect(toolInsight).toContain('ReadFile');
+      expect(toolInsight).toContain('SearchGlob');
+      expect(toolInsight).toContain('EditFile');
+    });
+
+    it('should extract file paths as key insights', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix a bug',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile',
+            observation: 'Contents of /src/utils/helper.ts',
+          }),
+        ],
+        outcome: successOutcome('Fixed'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      const fileInsight = episode.keyInsights.find((i) => i.startsWith('Key files:'));
+      expect(fileInsight).toBeDefined();
+      expect(fileInsight).toContain('/src/utils/helper.ts');
+    });
+  });
+
+  describe('heuristic mode — failed trajectory', () => {
+    it('should produce a valid episode with failure critique', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix broken deployment',
+          domain: 'devops',
+        }),
+        steps: [
+          createStep({
+            action: 'RunCommand deploy',
+            observation: 'Deployment failed with error',
+          }),
+        ],
+        outcome: failureOutcome('Connection timeout to remote server'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      expect(episode.outcome).toBe('failure');
+      expect(episode.selfCritique).toContain('Failed with');
+      expect(episode.selfCritique).toContain('Connection timeout');
+    });
+
+    it('should classify error patterns in key insights', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix type error',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/index.ts',
+            observation: 'TS2322: Type error',
+          }),
+        ],
+        outcome: failureOutcome('Type error: string is not assignable to number'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      const errorInsight = episode.keyInsights.find((i) => i.startsWith('Error pattern:'));
+      expect(errorInsight).toBeDefined();
+      expect(errorInsight).toContain('type-error');
+    });
+
+    it('should suggest playbook updates when failed with matching playbooks', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix module import issue',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/index.ts',
+            observation: 'File not found',
+          }),
+        ],
+        outcome: failureOutcome('Module not found: ./missing-module'),
+        agentId: 'test-agent',
+      });
+
+      const matchedPlaybooks = [makePlaybookMatch('fix-imports', 0.85)];
+
+      const episode = await generator.generate(trajectory, matchedPlaybooks);
+
+      expect(episode.suggestedPlaybookUpdates.length).toBeGreaterThan(0);
+      expect(
+        episode.suggestedPlaybookUpdates.some((s) => s.includes('fix-imports'))
+      ).toBe(true);
+    });
+
+    it('should suggest new playbook when failed without matches', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix import resolution',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/index.ts',
+            observation: 'Error',
+          }),
+        ],
+        outcome: failureOutcome('Module not found'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory, []);
+
+      expect(
+        episode.suggestedPlaybookUpdates.some(
+          (s) => s.includes('Create') && s.includes('import-error')
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe('heuristic mode — partial outcome', () => {
+    it('should map partial score > 0 to partial outcome', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Partially fix something',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'EditFile src/index.ts',
+            observation: 'Updated',
+          }),
+        ],
+        outcome: partialOutcome(0.5, 'Half done'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      expect(episode.outcome).toBe('partial');
+    });
+  });
+
+  describe('strategy assessment', () => {
+    it('should note success with playbook match', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix import',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'EditFile src/index.ts',
+            observation: 'Updated',
+          }),
+        ],
+        outcome: successOutcome('Fixed'),
+        agentId: 'test-agent',
+      });
+
+      const matches = [makePlaybookMatch('import-fixer', 0.9)];
+      const episode = await generator.generate(trajectory, matches);
+
+      expect(episode.strategyAssessment).toContain('import-fixer');
+      expect(episode.strategyAssessment).toContain('Succeeded');
+      expect(episode.strategyAssessment).toContain('confirmed');
+    });
+
+    it('should note failure with playbook match', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix error',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/index.ts',
+            observation: 'Error',
+          }),
+        ],
+        outcome: failureOutcome('Still broken'),
+        agentId: 'test-agent',
+      });
+
+      const matches = [makePlaybookMatch('error-fixer', 0.7)];
+      const episode = await generator.generate(trajectory, matches);
+
+      expect(episode.strategyAssessment).toContain('error-fixer');
+      expect(episode.strategyAssessment).toContain('Failed');
+      expect(episode.strategyAssessment).toContain('refinement');
+    });
+
+    it('should note success without playbook as new playbook candidate', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Novel task',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile src/index.ts',
+            observation: 'Source',
+          }),
+        ],
+        outcome: successOutcome('Solved'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory, []);
+
+      expect(episode.strategyAssessment).toContain('new playbook candidate');
+    });
+  });
+
+  describe('self-critique', () => {
+    it('should detect repeated actions (thrashing)', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Fix issue with retries',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({ action: 'ReadFile src/index.ts', observation: 'Error' }),
+          createStep({ action: 'ReadFile src/index.ts', observation: 'Error' }),
+          createStep({ action: 'ReadFile src/index.ts', observation: 'Error' }),
+          createStep({ action: 'EditFile src/index.ts', observation: 'Updated' }),
+        ],
+        outcome: successOutcome('Fixed'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      expect(episode.selfCritique).toContain('Repeated actions');
+    });
+
+    it('should note inefficiency for many steps', async () => {
+      const steps = Array.from({ length: 15 }, (_, i) =>
+        createStep({
+          action: `Step${i} something`,
+          observation: `Done ${i}`,
+        })
+      );
+
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Complex task',
+          domain: 'typescript',
+        }),
+        steps,
+        outcome: successOutcome('Eventually fixed'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await generator.generate(trajectory);
+
+      expect(episode.selfCritique).toContain('15 steps');
+      expect(episode.selfCritique).toContain('overcomplicating');
+    });
+  });
+
+  describe('configuration', () => {
+    it('should respect maxSummaryLength', async () => {
+      const gen = new ReflexionGenerator({ maxSummaryLength: 20 });
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'This is a very long task description that should be truncated',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({ action: 'DoSomething', observation: 'Done' }),
+        ],
+        outcome: successOutcome('Done'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await gen.generate(trajectory);
+
+      expect(episode.taskSummary.length).toBeLessThanOrEqual(20);
+    });
+
+    it('should respect maxInsights', async () => {
+      const gen = new ReflexionGenerator({ maxInsights: 1 });
+      const trajectory = createTrajectory({
+        task: createTask({
+          description: 'Task with many insights',
+          domain: 'typescript',
+        }),
+        steps: [
+          createStep({
+            action: 'ReadFile /src/a.ts',
+            observation: 'contents of /src/a.ts and /src/b.ts',
+          }),
+          createStep({
+            action: 'EditFile /src/c.ts',
+            observation: 'updated /src/c.ts',
+          }),
+        ],
+        outcome: successOutcome('Done'),
+        agentId: 'test-agent',
+      });
+
+      const episode = await gen.generate(trajectory);
+
+      expect(episode.keyInsights.length).toBeLessThanOrEqual(1);
+    });
+  });
+});

package/tests/learning/trajectory-sources.test.ts

@@ -5,8 +5,9 @@ import { join } from 'node:path';
 import { InMemoryTrajectorySource } from '../../src/learning/trajectory-sources/in-memory.js';
 import { FileTrajectorySource } from '../../src/learning/trajectory-sources/file.js';
 import { PipelineTrajectorySource } from '../../src/learning/trajectory-sources/pipeline.js';
-import { LearningPipeline } from '../../src/learning/pipeline.js';
+import { UnifiedLearningPipeline } from '../../src/learning/unified-pipeline.js';
 import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import {
   createTrajectory,
   createTask,
@@ -255,16 +256,23 @@ describe('FileTrajectorySource', () => {
 describe('PipelineTrajectorySource', () => {
   let tmpDir: string;
   let memory: MemorySystem;
-  let pipeline: LearningPipeline;
+  let pipeline: UnifiedLearningPipeline;
+  let persistence: any;
 
   beforeEach(async () => {
     tmpDir = await mkdtemp(join(tmpdir(), 'pipeline-source-test-'));
-    memory = createMemorySystem(tmpDir);
+    persistence = createSqlitePersistence({ baseDir: tmpDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tmpDir);
     await memory.init();
-    pipeline = new LearningPipeline(memory, { minTrajectories: 100 });
+    pipeline = new UnifiedLearningPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: {} },
+    }, persistence);
+    await pipeline.init();
   });
 
   afterEach(async () => {
+    persistence.close();
     await rm(tmpDir, { recursive: true, force: true });
   });
 

package/tests/learning/unified-pipeline-efficacy.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { UnifiedLearningPipeline, createUnifiedPipeline } from '../../src/learning/unified-pipeline.js';
+import { MemorySystem } from '../../src/memory/system.js';
+import { createTrajectory, type Trajectory } from '../../src/types/trajectory.js';
+import { createTask } from '../../src/types/task.js';
+import { createStep } from '../../src/types/step.js';
+import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
+import { createPlaybook } from '../../src/types/playbook.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';
+import type { SqlitePersistence } from '../../src/persistence/index.js';
+import type { Playbook } from '../../src/types/playbook.js';
+
+function makeTrajectory(overrides?: {
+  success?: boolean;
+  domain?: string;
+  description?: string;
+}): Trajectory {
+  const success = overrides?.success ?? true;
+  return createTrajectory({
+    task: createTask({
+      description: overrides?.description ?? 'Fix the typescript import error',
+      domain: overrides?.domain ?? 'typescript',
+    }),
+    steps: [
+      createStep({
+        thought: 'Let me check the imports',
+        action: 'ReadFile src/index.ts',
+        observation: 'File content: import { foo } from "./bar"',
+      }),
+      createStep({
+        thought: 'The import path is wrong',
+        action: 'EditFile src/index.ts',
+        observation: 'File updated successfully',
+      }),
+    ],
+    outcome: success
+      ? successOutcome('Fixed import path')
+      : failureOutcome('Could not resolve import'),
+    agentId: 'test-agent',
+  });
+}
+
+function makePlaybook(overrides?: Partial<{
+  name: string;
+  domain: string;
+  successCount: number;
+  failureCount: number;
+  confidence: number;
+}>): Playbook {
+  return createPlaybook({
+    name: overrides?.name ?? 'test-playbook',
+    applicability: {
+      situations: ['fix import'],
+      domains: [overrides?.domain ?? 'typescript'],
+      triggers: ['import error'],
+      antiPatterns: [],
+    },
+    guidance: {
+      strategy: 'Check and fix import paths',
+      tactics: ['Read the file', 'Fix the path'],
+      verification: [],
+      commonPitfalls: [],
+    },
+    successCount: overrides?.successCount ?? 5,
+    failureCount: overrides?.failureCount ?? 1,
+    confidence: overrides?.confidence ?? 0.8,
+  });
+}
+
+describe('UnifiedLearningPipeline — efficacy maintenance', () => {
+  let tempDir: string;
+  let memory: MemorySystem;
+  let pipeline: UnifiedLearningPipeline;
+  let persistence: SqlitePersistence;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-efficacy-test-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = new MemorySystem(persistence, tempDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should register efficacy tasks by default', async () => {
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+    }, persistence);
+    await pipeline.init();
+
+    const stats = pipeline.getStats();
+    expect(stats.maintenanceTasks).toContain('playbook-decay-detection');
+    expect(stats.maintenanceTasks).toContain('playbook-efficacy-audit');
+    expect(stats.maintenanceTasks).toContain('playbook-lifecycle-review');
+  });
+
+  it('should NOT register efficacy tasks when feature is disabled', async () => {
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false, efficacy: false },
+    }, persistence);
+    await pipeline.init();
+
+    const stats = pipeline.getStats();
+    expect(stats.maintenanceTasks).not.toContain('playbook-decay-detection');
+    expect(stats.maintenanceTasks).not.toContain('playbook-efficacy-audit');
+    expect(stats.maintenanceTasks).not.toContain('playbook-lifecycle-review');
+  });
+
+  it('decay detection should skip when no playbooks exist', async () => {
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+    }, persistence);
+    await pipeline.init();
+
+    const result = await pipeline.runMaintenance({ force: true });
+
+    expect(result.ran).toBe(true);
+    const decayTask = result.taskResults.find(t => t.taskName === 'playbook-decay-detection');
+    expect(decayTask).toBeDefined();
+    expect(decayTask!.success).toBe(true);
+    expect((decayTask!.details as Record<string, unknown>).skipped).toBe(true);
+  });
+
+  it('decay detection should run with playbooks and annotations', async () => {
+    // Add playbooks
+    const pb = makePlaybook({ name: 'import-fixer', successCount: 10, failureCount: 5 });
+    await memory.playbooks.add(pb);
+
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 3 },
+    }, persistence);
+    await pipeline.init();
+
+    const result = await pipeline.runMaintenance({ force: true });
+
+    const decayTask = result.taskResults.find(t => t.taskName === 'playbook-decay-detection');
+    expect(decayTask).toBeDefined();
+    expect(decayTask!.success).toBe(true);
+    const details = decayTask!.details as Record<string, unknown>;
+    expect(details.skipped).toBeUndefined();
+    expect(typeof details.healthyCount).toBe('number');
+  });
+
+  it('efficacy audit should skip when no decay results found flagged playbooks', async () => {
+    const pb = makePlaybook({ name: 'stable-playbook', confidence: 0.9 });
+    await memory.playbooks.add(pb);
+
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 3 },
+    }, persistence);
+    await pipeline.init();
+
+    const result = await pipeline.runMaintenance({ force: true });
+
+    const auditTask = result.taskResults.find(t => t.taskName === 'playbook-efficacy-audit');
+    expect(auditTask).toBeDefined();
+    expect(auditTask!.success).toBe(true);
+    const details = auditTask!.details as Record<string, unknown>;
+    // Should be skipped because decay detection found no flagged playbooks
+    expect(details.skipped).toBe(true);
+  });
+
+  it('lifecycle review should respect frequency setting', async () => {
+    const pb = makePlaybook({ name: 'lifecycle-test' });
+    await memory.playbooks.add(pb);
+
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 2 },
+    }, persistence);
+    await pipeline.init();
+
+    // First maintenance (cycle 0) — should run (0 % 2 === 0)
+    const result1 = await pipeline.runMaintenance({ force: true });
+    const lifecycleTask1 = result1.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
+    expect(lifecycleTask1).toBeDefined();
+    const details1 = lifecycleTask1!.details as Record<string, unknown>;
+    expect(details1.totalPlaybooks).toBeDefined();
+
+    // Second maintenance (cycle 1) — should skip (1 % 2 !== 0)
+    const result2 = await pipeline.runMaintenance({ force: true });
+    const lifecycleTask2 = result2.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
+    expect(lifecycleTask2).toBeDefined();
+    const details2 = lifecycleTask2!.details as Record<string, unknown>;
+    expect(details2.skipped).toBe(true);
+
+    // Third maintenance (cycle 2) — should run again (2 % 2 === 0)
+    const result3 = await pipeline.runMaintenance({ force: true });
+    const lifecycleTask3 = result3.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
+    expect(lifecycleTask3).toBeDefined();
+    const details3 = lifecycleTask3!.details as Record<string, unknown>;
+    expect(details3.totalPlaybooks).toBeDefined();
+  });
+
+  it('lifecycle review returns portfolio snapshot data', async () => {
+    await memory.playbooks.add(makePlaybook({ name: 'pb-1', confidence: 0.9 }));
+    await memory.playbooks.add(makePlaybook({ name: 'pb-2', confidence: 0.4, domain: 'python' }));
+
+    pipeline = createUnifiedPipeline(memory, {
+      batch: { learning: { minTrajectories: 100 }, energy: { countThreshold: 100 } },
+      features: { healing: false },
+      efficacy: { minPlaybooks: 1, minAnnotations: 0, lifecycleReviewFrequency: 1 },
+    }, persistence);
+    await pipeline.init();
+
+    const result = await pipeline.runMaintenance({ force: true });
+
+    const lifecycleTask = result.taskResults.find(t => t.taskName === 'playbook-lifecycle-review');
+    expect(lifecycleTask).toBeDefined();
+    const details = lifecycleTask!.details as Record<string, unknown>;
+    expect(details.totalPlaybooks).toBe(2);
+    expect(details.snapshot).toBeDefined();
+    const snapshot = details.snapshot as Record<string, unknown>;
+    expect(snapshot.confidenceBands).toBeDefined();
+  });
+});