cognitive-core 0.1.0 → 0.2.0

package/tests/learning/energy-evaluator.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  EnergyEvaluator,
+  createEnergyEvaluator,
+} from '../../src/learning/energy-evaluator.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 } from '../../src/types/outcome.js';
+import type { InstantLoopResult } from '../../src/learning/instant-loop.js';
+
+function makeTrajectory(overrides?: {
+  success?: boolean;
+  domain?: string;
+}) {
+  return createTrajectory({
+    task: createTask({
+      description: 'Test task',
+      domain: overrides?.domain ?? 'typescript',
+    }),
+    steps: [
+      createStep({
+        thought: 'thinking',
+        action: 'ReadFile foo.ts',
+        observation: 'content',
+      }),
+    ],
+    outcome: (overrides?.success ?? true)
+      ? successOutcome('done')
+      : failureOutcome('error'),
+    agentId: 'test',
+  });
+}
+
+const dummyInstantResult: InstantLoopResult = {
+  experienceId: 'exp-1',
+  matchedPlaybooks: [],
+  knowledgeNotesExtracted: 0,
+  causalEdgesExtracted: 0,
+  durationMs: 10,
+};
+
+describe('EnergyEvaluator', () => {
+  let evaluator: EnergyEvaluator;
+
+  beforeEach(() => {
+    evaluator = createEnergyEvaluator({ countThreshold: 3 });
+  });
+
+  describe('count-based trigger', () => {
+    it('should not trigger batch before count threshold', () => {
+      const t = makeTrajectory();
+      const r1 = evaluator.evaluate(t, dummyInstantResult);
+      expect(r1.shouldTriggerBatch).toBe(false);
+      const r2 = evaluator.evaluate(t, dummyInstantResult);
+      expect(r2.shouldTriggerBatch).toBe(false);
+    });
+
+    it('should trigger batch at count threshold', () => {
+      const t = makeTrajectory();
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.evaluate(t, dummyInstantResult);
+      const r3 = evaluator.evaluate(t, dummyInstantResult);
+      expect(r3.shouldTriggerBatch).toBe(true);
+      expect(r3.reasons).toContain('count_threshold');
+    });
+
+    it('should reset pending count after batch', () => {
+      const t = makeTrajectory();
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.resetAfterBatch();
+      expect(evaluator.getPendingCount()).toBe(0);
+
+      const r = evaluator.evaluate(t, dummyInstantResult);
+      expect(r.shouldTriggerBatch).toBe(false);
+    });
+  });
+
+  describe('energy-based trigger', () => {
+    it('should trigger batch on contradiction signal before count threshold', () => {
+      const evaluator = createEnergyEvaluator({
+        countThreshold: 100,
+        energyThreshold: 0.3,
+      });
+      const t = makeTrajectory();
+      const r = evaluator.evaluate(t, dummyInstantResult, {
+        contradictionDetected: true,
+      });
+      expect(r.shouldTriggerBatch).toBe(true);
+      expect(r.reasons).toContain('contradiction_detected');
+      expect(r.energy).toBeGreaterThan(0);
+    });
+
+    it('should trigger on novel domain', () => {
+      const evaluator = createEnergyEvaluator({
+        countThreshold: 100,
+        energyThreshold: 0.2,
+      });
+      const t = makeTrajectory({ domain: 'brand-new-domain' });
+      const r = evaluator.evaluate(t, dummyInstantResult);
+      expect(r.shouldTriggerBatch).toBe(true);
+      expect(r.reasons).toContain('novel_domain');
+    });
+
+    it('should not trigger on known domain', () => {
+      const evaluator = createEnergyEvaluator({
+        countThreshold: 100,
+        energyThreshold: 0.5,
+      });
+      evaluator.seedKnownDomains(['typescript']);
+      const t = makeTrajectory({ domain: 'typescript' });
+      const r = evaluator.evaluate(t, dummyInstantResult);
+      expect(r.shouldTriggerBatch).toBe(false);
+    });
+
+    it('should trigger on high error rate', () => {
+      const evaluator = createEnergyEvaluator({
+        countThreshold: 100,
+        energyThreshold: 0.15,
+        recentWindowSize: 3,
+        errorRateThreshold: 0.5,
+      });
+      // Seed known domain so novel domain doesn't interfere
+      evaluator.seedKnownDomains(['typescript']);
+
+      const fail = makeTrajectory({ success: false });
+      evaluator.evaluate(fail, dummyInstantResult);
+      evaluator.evaluate(fail, dummyInstantResult);
+      const r = evaluator.evaluate(fail, dummyInstantResult);
+      expect(r.shouldTriggerBatch).toBe(true);
+      expect(r.reasons).toContain('high_error_rate');
+    });
+  });
+
+  describe('debounce', () => {
+    it('should respect minimum interval between batches', () => {
+      const evaluator = createEnergyEvaluator({
+        countThreshold: 1,
+        minIntervalMs: 60_000, // 1 minute
+      });
+      evaluator.seedKnownDomains(['typescript']);
+      const t = makeTrajectory();
+
+      // First should trigger
+      const r1 = evaluator.evaluate(t, dummyInstantResult);
+      expect(r1.shouldTriggerBatch).toBe(true);
+
+      // Reset and try again immediately — should be debounced
+      evaluator.resetAfterBatch();
+      const r2 = evaluator.evaluate(t, dummyInstantResult);
+      expect(r2.shouldTriggerBatch).toBe(false);
+    });
+  });
+
+  describe('transition log', () => {
+    it('should record transitions when batch is triggered', () => {
+      const t = makeTrajectory();
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.evaluate(t, dummyInstantResult);
+      evaluator.evaluate(t, dummyInstantResult);
+
+      const log = evaluator.getTransitionLog();
+      expect(log.length).toBe(1);
+      expect(log[0].fromPhase).toBe('immediate');
+      expect(log[0].toPhase).toBe('batch');
+      expect(log[0].reasons).toContain('count_threshold');
+    });
+  });
+
+  describe('forceEvaluate', () => {
+    it('should return manual override with max energy', () => {
+      const r = evaluator.forceEvaluate();
+      expect(r.shouldTriggerBatch).toBe(true);
+      expect(r.energy).toBe(1.0);
+      expect(r.reasons).toContain('manual_override');
+    });
+  });
+});

package/tests/learning/entire-trajectory-source.test.ts

@@ -0,0 +1,380 @@
+import { describe, it, expect } from 'vitest';
+import { SessionTrajectorySource } from '../../src/learning/trajectory-sources/entire.js';
+import { TrajectorySchema } from '../../src/types/trajectory.js';
+import type { SessionRecord } from '../../src/session-bank/types.js';
+
+function makeSession(overrides?: Partial<SessionRecord>): SessionRecord {
+  return {
+    sessionId: '2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
+    checkpointId: 'a3b2c4d5e6f7',
+    metadata: {
+      cliVersion: '0.3.0',
+      strategy: 'manual-commit',
+      createdAt: new Date('2026-01-08T10:30:00Z'),
+      branch: 'main',
+      agent: 'Claude Code',
+      filesTouched: ['src/auth.ts', 'src/middleware.ts'],
+      isTask: false,
+      checkpointTranscriptStart: 0,
+    },
+    transcript: [
+      {
+        role: 'user',
+        uuid: 'msg-001',
+        content: [
+          {
+            type: 'text',
+            text: 'Fix the bug in auth.ts where token refresh fails',
+          },
+        ],
+        lineIndex: 0,
+      },
+      {
+        role: 'assistant',
+        uuid: 'msg-002',
+        content: [
+          {
+            type: 'text',
+            text: "I'll read the file to understand the issue.",
+          },
+          {
+            type: 'tool_use',
+            id: 'tool-001',
+            name: 'Read',
+            input: { file_path: '/src/auth.ts' },
+          },
+        ],
+        lineIndex: 1,
+      },
+      {
+        role: 'user',
+        uuid: 'msg-003',
+        content: [
+          {
+            type: 'tool_result',
+            toolUseId: 'tool-001',
+            content: 'export async function refreshToken() { ... }',
+          },
+        ],
+        lineIndex: 2,
+      },
+      {
+        role: 'assistant',
+        uuid: 'msg-004',
+        content: [
+          {
+            type: 'text',
+            text: 'Found the issue — missing await. Let me fix it.',
+          },
+          {
+            type: 'tool_use',
+            id: 'tool-002',
+            name: 'Edit',
+            input: {
+              file_path: '/src/auth.ts',
+              old_string: 'fetchNewToken(token);',
+              new_string: 'await fetchNewToken(token);',
+            },
+          },
+        ],
+        lineIndex: 3,
+      },
+      {
+        role: 'user',
+        uuid: 'msg-005',
+        content: [
+          {
+            type: 'tool_result',
+            toolUseId: 'tool-002',
+            content: 'File edited successfully',
+          },
+        ],
+        lineIndex: 4,
+      },
+      {
+        role: 'assistant',
+        uuid: 'msg-006',
+        content: [
+          {
+            type: 'text',
+            text: 'The fix is applied.',
+          },
+        ],
+        lineIndex: 5,
+      },
+    ],
+    summary: {
+      intent: 'Fix the authentication token refresh bug in the middleware',
+      outcome:
+        'Successfully fixed the token refresh logic and added retry handling',
+      learnings: {
+        repoPatterns: ['Auth middleware uses a singleton token cache'],
+        codeFindings: ['Token refresh was not awaiting the async call'],
+        workflowPractices: ['Run auth tests before committing'],
+      },
+      frictionPoints: ['Initial confusion about which file to edit'],
+      openItems: ['Add integration test for token expiry'],
+    },
+    tokenUsage: {
+      inputTokens: 15000,
+      cacheCreationTokens: 2000,
+      cacheReadTokens: 5000,
+      outputTokens: 3000,
+      apiCallCount: 8,
+      total: 25000,
+    },
+    attribution: {
+      agentLinesAdded: 25,
+      humanAdditions: 2,
+      humanModifications: 1,
+      humanRemovals: 0,
+      totalCommittedLines: 28,
+      agentContribution: 0.89,
+    },
+    source: {
+      branch: 'entire/checkpoints/v1',
+      checkpointPath: 'a3/b2c4d5e6f7',
+      sessionIndex: '0',
+    },
+    ...overrides,
+  };
+}
+
+describe('SessionTrajectorySource', () => {
+  describe('synthesize', () => {
+    it('should produce a valid Trajectory', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      // Should pass schema validation
+      const parsed = TrajectorySchema.safeParse(trajectory);
+      expect(parsed.success).toBe(true);
+    });
+
+    it('should set correct trajectory ID', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.id).toBe(
+        'sessionlog-a3b2c4d5e6f7-2026-01-08-abc123de-f456-7890-abcd-ef1234567890',
+      );
+    });
+
+    it('should use summary.intent as task description', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.description).toBe(
+        'Fix the authentication token refresh bug in the middleware',
+      );
+    });
+
+    it('should fall back to first user message when no summary', () => {
+      const session = makeSession({ summary: undefined });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.description).toBe(
+        'Fix the bug in auth.ts where token refresh fails',
+      );
+    });
+
+    it('should fall back to "Unknown task" when no transcript', () => {
+      const session = makeSession({
+        summary: undefined,
+        transcript: [],
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.description).toBe('Unknown task');
+    });
+
+    it('should infer domain from filesTouched (.ts → typescript)', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('typescript');
+    });
+
+    it('should infer testing domain from .test.ts files', () => {
+      const session = makeSession({
+        metadata: {
+          ...makeSession().metadata,
+          filesTouched: ['tests/auth.test.ts'],
+        },
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('testing');
+    });
+
+    it('should infer python domain', () => {
+      const session = makeSession({
+        metadata: {
+          ...makeSession().metadata,
+          filesTouched: ['src/main.py'],
+        },
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('python');
+    });
+
+    it('should infer go domain', () => {
+      const session = makeSession({
+        metadata: {
+          ...makeSession().metadata,
+          filesTouched: ['cmd/main.go'],
+        },
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('go');
+    });
+
+    it('should infer rust domain', () => {
+      const session = makeSession({
+        metadata: {
+          ...makeSession().metadata,
+          filesTouched: ['src/main.rs'],
+        },
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('rust');
+    });
+
+    it('should use configured domain override', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any, {
+        domain: 'custom-domain',
+      });
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.task.domain).toBe('custom-domain');
+    });
+
+    it('should extract steps from tool_use blocks', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      // 2 tool_use blocks + 1 pure reasoning step
+      expect(trajectory.steps.length).toBe(3);
+
+      // First tool step: Read
+      expect(trajectory.steps[0].action).toContain('Read');
+      expect(trajectory.steps[0].observation).toContain('refreshToken');
+      expect(trajectory.steps[0].metadata?.toolName).toBe('Read');
+
+      // Second tool step: Edit
+      expect(trajectory.steps[1].action).toContain('Edit');
+      expect(trajectory.steps[1].observation).toBe(
+        'File edited successfully',
+      );
+      expect(trajectory.steps[1].metadata?.toolName).toBe('Edit');
+
+      // Third step: pure reasoning
+      expect(trajectory.steps[2].thought).toBe('The fix is applied.');
+      expect(trajectory.steps[2].action).toBe('');
+    });
+
+    it('should infer success from summary.outcome', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.outcome.success).toBe(true);
+      expect(trajectory.outcome.partialScore).toBe(1.0);
+    });
+
+    it('should infer failure from summary.outcome with failure keywords', () => {
+      const session = makeSession({
+        summary: {
+          ...makeSession().summary!,
+          outcome: 'Failed to fix the bug due to missing dependencies',
+        },
+      });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.outcome.success).toBe(false);
+      expect(trajectory.outcome.partialScore).toBe(0.0);
+    });
+
+    it('should use heuristic when outcomeStrategy is heuristic', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any, {
+        outcomeStrategy: 'heuristic',
+      });
+      const trajectory = source.synthesize(session);
+
+      // Has files → success
+      expect(trajectory.outcome.success).toBe(true);
+      expect(trajectory.outcome.partialScore).toBe(0.7);
+      expect(trajectory.outcome.verificationDetails).toEqual({
+        strategy: 'heuristic',
+      });
+    });
+
+    it('should use heuristic fallback when no summary', () => {
+      const session = makeSession({ summary: undefined });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.outcome.success).toBe(true); // has filesTouched
+      expect(trajectory.outcome.partialScore).toBe(0.7);
+    });
+
+    it('should carry token usage through', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.totalTokens).toBe(25000);
+      expect(trajectory.llmCalls).toBe(8);
+    });
+
+    it('should preserve session metadata', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.metadata.source).toBe('sessionlog');
+      expect(trajectory.metadata.checkpointId).toBe('a3b2c4d5e6f7');
+      expect(trajectory.metadata.sessionId).toContain('2026-01-08');
+      expect(trajectory.metadata.branch).toBe('main');
+      expect(trajectory.metadata.filesTouched).toEqual([
+        'src/auth.ts',
+        'src/middleware.ts',
+      ]);
+      expect(trajectory.metadata.strategy).toBe('manual-commit');
+      expect(trajectory.metadata.attribution).toBeDefined();
+    });
+
+    it('should set agentId from session metadata', () => {
+      const session = makeSession();
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.agentId).toBe('Claude Code');
+    });
+
+    it('should handle session with empty transcript', () => {
+      const session = makeSession({ transcript: [] });
+      const source = new SessionTrajectorySource(null as any);
+      const trajectory = source.synthesize(session);
+
+      expect(trajectory.steps).toEqual([]);
+    });
+  });
+});