cognitive-core 0.2.4 → 0.3.1

package/tests/learning/playbook-extractor-provenance.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PlaybookExtractor, createPlaybookExtractor } from '../../src/learning/playbook-extractor.js';
-import { createPlaybook } from '../../src/types/playbook.js';
-import { createTrajectory, createStep, createTask, successOutcome } from '../../src/types/index.js';
-import type { AnalysisResult } from '../../src/learning/analyzer.js';
-
-describe('PlaybookExtractor provenance', () => {
-  function makeTrajectory(description: string, domain: string, actions: string[]) {
-    return createTrajectory({
-      task: createTask({ domain, description }),
-      steps: actions.map((action) =>
-        createStep({
-          thought: `Doing: ${action}`,
-          action,
-          observation: 'done',
-        })
-      ),
-      outcome: successOutcome({ result: 'completed' }),
-      agentId: 'test-agent',
-    });
-  }
-
-  function makeAnalysis(trajectory: ReturnType<typeof makeTrajectory>): AnalysisResult {
-    return {
-      success: true,
-      keySteps: trajectory.steps.map((_, i) => i),
-      stepAttribution: trajectory.steps.map(() => 0.8),
-      errorPatterns: [],
-      abstractable: true,
-      trainingExamples: [],
-    };
-  }
-
-  it('should set origin to extracted on newly created playbooks', async () => {
-    const extractor = createPlaybookExtractor({ minTrajectories: 2 });
-
-    // Create 2 similar trajectories so the pattern meets frequency threshold
-    const t1 = makeTrajectory('Fix build error', 'code', ['read file', 'edit file']);
-    const t2 = makeTrajectory('Fix build error again', 'code', ['read file', 'edit file']);
-
-    const result = await extractor.extract(
-      [t1, t2],
-      [makeAnalysis(t1), makeAnalysis(t2)],
-      [],
-    );
-
-    // Should extract at least one playbook
-    expect(result.new.length).toBeGreaterThanOrEqual(1);
-
-    for (const playbook of result.new) {
-      expect(playbook.provenance).toBeDefined();
-      expect(playbook.provenance.origin).toBe('extracted');
-      expect(playbook.provenance.recordedAt).toBeInstanceOf(Date);
-      // Extracted playbooks should not have sourceFile or curatedBy
-      expect(playbook.provenance.sourceFile).toBeUndefined();
-      expect(playbook.provenance.curatedBy).toBeUndefined();
-    }
-  });
-
-  it('should preserve provenance from primary playbook when merging', async () => {
-    const extractor = createPlaybookExtractor({
-      minTrajectories: 1,
-      mergeThreshold: 0.3, // Low threshold to force merging
-    });
-
-    // Two similar trajectories to get one playbook from consolidation
-    const t1 = makeTrajectory('Debug failing test', 'test', ['search', 'run', 'test']);
-    const t2 = makeTrajectory('Debug failing test', 'test', ['search', 'run', 'test']);
-
-    const result = await extractor.extract(
-      [t1, t2],
-      [makeAnalysis(t1), makeAnalysis(t2)],
-      [],
-    );
-
-    // All playbooks should have extracted provenance
-    for (const playbook of result.new) {
-      expect(playbook.provenance.origin).toBe('extracted');
-    }
-  });
-
-  it('should generate updates for existing playbooks without changing provenance', async () => {
-    const extractor = createPlaybookExtractor({ minTrajectories: 2 });
-
-    const existingPlaybook = createPlaybook({
-      name: 'existing-debug',
-      applicability: {
-        situations: ['read file'],
-        triggers: [],
-        antiPatterns: [],
-        domains: ['code'],
-      },
-      guidance: {
-        strategy: 'Read then fix',
-        tactics: ['read', 'fix'],
-      },
-      provenance: { origin: 'curated', sourceFile: 'debug.json', recordedAt: new Date() },
-    });
-
-    const t1 = makeTrajectory('Read file to debug', 'code', ['read file', 'edit file']);
-    const t2 = makeTrajectory('Read file to debug', 'code', ['read file', 'edit file']);
-
-    const result = await extractor.extract(
-      [t1, t2],
-      [makeAnalysis(t1), makeAnalysis(t2)],
-      [existingPlaybook],
-    );
-
-    // Updates to existing playbooks should reference the existing playbook
-    // The existing playbook's provenance should remain unchanged
-    expect(existingPlaybook.provenance.origin).toBe('curated');
-    expect(existingPlaybook.provenance.sourceFile).toBe('debug.json');
-  });
-});

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

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