cognitive-core 0.0.2 → 0.1.2

package/tests/memory/team-experience.test.ts

@@ -0,0 +1,411 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  TeamExperienceMemory,
+  createTeamExperienceMemory,
+} from '../../src/memory/team-experience.js';
+import { buildTeamTrajectory } from '../../src/types/team-trajectory.js';
+import type { TeamTrajectory, TeamTrajectoryInput } from '../../src/types/team-trajectory.js';
+import { createTask, createStep, successOutcome, createTrajectory } from '../../src/types/index.js';
+import { createTeamPlaybook } from '../../src/types/team-playbook.js';
+import { createRolePlaybook } from '../../src/types/team-playbook.js';
+import { createTeamMetaObservation } from '../../src/types/team-meta.js';
+import { createTeamMetaStrategy } from '../../src/types/team-meta.js';
+
+function createTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'team-exp-test-'));
+}
+
+function makeSampleTrajectory(overrides?: Partial<TeamTrajectoryInput>): TeamTrajectory {
+  return buildTeamTrajectory({
+    objective: 'Implement user authentication',
+    domain: 'web',
+    complexity: 'moderate',
+    teamName: 'test-team',
+    templateName: 'wave',
+    topologyType: 'wave',
+    enforcement: 'permissive',
+    memberTrajectories: [
+      {
+        agentId: 'planner-1',
+        role: 'planner',
+        trajectory: createTrajectory({
+          task: createTask({ domain: 'web', description: 'plan auth' }),
+          steps: [createStep({ action: 'plan', observation: 'done' })],
+          outcome: successOutcome('planned'),
+          agentId: 'planner-1',
+          totalTokens: 10000,
+        }),
+      },
+      {
+        agentId: 'executor-1',
+        role: 'executor',
+        trajectory: createTrajectory({
+          task: createTask({ domain: 'web', description: 'execute auth' }),
+          steps: [createStep({ action: 'execute', observation: 'done' })],
+          outcome: successOutcome('executed'),
+          agentId: 'executor-1',
+          totalTokens: 10000,
+        }),
+      },
+    ],
+    outcome: {
+      success: true,
+      partialScore: 0.9,
+      quality: 'good',
+      totalLlmCalls: 10,
+      totalTokens: 20000,
+      totalWallTimeSeconds: 60,
+    },
+    ...overrides,
+  });
+}
+
+describe('TeamExperienceMemory', () => {
+  let tmpDir: string;
+  let memory: TeamExperienceMemory;
+
+  beforeEach(async () => {
+    tmpDir = createTmpDir();
+    memory = createTeamExperienceMemory(tmpDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // === TEAM EXPERIENCES ===
+
+  describe('team experiences', () => {
+    it('should store and retrieve a team experience', async () => {
+      const trajectory = makeSampleTrajectory();
+      const experience = await memory.storeTeamExperience({ teamTrajectory: trajectory });
+
+      expect(experience.id).toBe(trajectory.id);
+      expect(experience.teamTrajectory.objective).toBe('Implement user authentication');
+      expect(experience.usageCount).toBe(0);
+
+      const retrieved = await memory.getTeamExperience(trajectory.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.teamTrajectory.teamName).toBe('test-team');
+    });
+
+    it('should find similar experiences by objective', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Implement OAuth2 authentication' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Build CI/CD pipeline' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Add user login with authentication' }),
+      });
+
+      const results = await memory.findSimilarTeamExperiences('authentication login');
+      expect(results.length).toBeGreaterThan(0);
+      // Authentication-related should score higher
+      const objectives = results.map((r) => r.experience.teamTrajectory.objective);
+      expect(objectives[0]).toContain('authentication');
+    });
+
+    it('should filter by domain', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ domain: 'web' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ domain: 'infra' }),
+      });
+
+      const webResults = await memory.findSimilarTeamExperiences('test', { domain: 'web' });
+      expect(webResults.length).toBe(1);
+      expect(webResults[0].experience.teamTrajectory.domain).toBe('web');
+    });
+
+    it('should filter by success', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory(),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({
+          outcome: {
+            success: false,
+            partialScore: 0.2,
+            quality: 'poor',
+            totalLlmCalls: 5,
+            totalTokens: 10000,
+            totalWallTimeSeconds: 30,
+          },
+        }),
+      });
+
+      const successOnly = await memory.findSimilarTeamExperiences('test', { successOnly: true });
+      expect(successOnly.length).toBe(1);
+      expect(successOnly[0].experience.teamTrajectory.outcome.success).toBe(true);
+    });
+
+    it('should track usage count', async () => {
+      const trajectory = makeSampleTrajectory();
+      await memory.storeTeamExperience({ teamTrajectory: trajectory });
+
+      await memory.recordTeamExperienceUsage(trajectory.id);
+      await memory.recordTeamExperienceUsage(trajectory.id);
+
+      const exp = await memory.getTeamExperience(trajectory.id);
+      expect(exp!.usageCount).toBe(2);
+      expect(exp!.lastAccessedAt).toBeDefined();
+    });
+
+    it('should count experiences', async () => {
+      expect(await memory.countTeamExperiences()).toBe(0);
+
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+
+      expect(await memory.countTeamExperiences()).toBe(2);
+    });
+  });
+
+  // === TEAM PLAYBOOKS ===
+
+  describe('team playbooks', () => {
+    it('should store and retrieve team playbooks', async () => {
+      const playbook = createTeamPlaybook({
+        name: 'wave-feature',
+        applicability: {
+          taskTypes: ['full-stack feature'],
+          teamSizeRange: { min: 3, max: 6 },
+          complexityLevels: ['moderate', 'complex'],
+          domains: ['web'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'wave',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'permissive',
+        },
+        coordination: {
+          executionModel: 'wave-parallel',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: 'vertical-slice',
+        },
+      });
+
+      await memory.storeTeamPlaybook(playbook);
+
+      const all = await memory.getTeamPlaybooks();
+      expect(all).toHaveLength(1);
+      expect(all[0].name).toBe('wave-feature');
+    });
+
+    it('should find matching playbooks by domain', async () => {
+      const webPlaybook = createTeamPlaybook({
+        name: 'web-playbook',
+        applicability: {
+          taskTypes: ['feature'],
+          teamSizeRange: { min: 2, max: 4 },
+          complexityLevels: ['moderate'],
+          domains: ['web'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'wave',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'permissive',
+        },
+        coordination: {
+          executionModel: 'wave-parallel',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: '',
+        },
+      });
+
+      const infraPlaybook = createTeamPlaybook({
+        name: 'infra-playbook',
+        applicability: {
+          taskTypes: ['deployment'],
+          teamSizeRange: { min: 2, max: 4 },
+          complexityLevels: ['complex'],
+          domains: ['infra'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'hierarchical',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'strict',
+        },
+        coordination: {
+          executionModel: 'sequential',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: '',
+        },
+      });
+
+      await memory.storeTeamPlaybook(webPlaybook);
+      await memory.storeTeamPlaybook(infraPlaybook);
+
+      const matches = await memory.findMatchingTeamPlaybooks({ domain: 'web' });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].playbook.name).toBe('web-playbook');
+    });
+  });
+
+  // === ROLE PLAYBOOKS ===
+
+  describe('role playbooks', () => {
+    it('should store and find role playbooks by role', async () => {
+      const executorPlaybook = createRolePlaybook({
+        name: 'wave-executor',
+        role: 'executor',
+        teamContext: {
+          topologies: ['wave'],
+          teamSizeRange: { min: 3, max: 6 },
+          taskTypes: ['feature'],
+          domains: ['web'],
+        },
+        guidance: {
+          responsibilities: ['Implement slice'],
+          interactionGuidance: [],
+          decisionFrameworks: [],
+          antiPatterns: [],
+        },
+      });
+
+      const plannerPlaybook = createRolePlaybook({
+        name: 'wave-planner',
+        role: 'planner',
+        teamContext: {
+          topologies: ['wave'],
+          teamSizeRange: { min: 3, max: 6 },
+          taskTypes: ['feature'],
+          domains: ['web'],
+        },
+        guidance: {
+          responsibilities: ['Decompose task'],
+          interactionGuidance: [],
+          decisionFrameworks: [],
+          antiPatterns: [],
+        },
+      });
+
+      await memory.storeRolePlaybook(executorPlaybook);
+      await memory.storeRolePlaybook(plannerPlaybook);
+
+      const executorMatches = await memory.findMatchingRolePlaybooks({ role: 'executor' });
+      expect(executorMatches).toHaveLength(1);
+      expect(executorMatches[0].playbook.name).toBe('wave-executor');
+
+      const plannerMatches = await memory.findMatchingRolePlaybooks({ role: 'planner' });
+      expect(plannerMatches).toHaveLength(1);
+      expect(plannerMatches[0].playbook.name).toBe('wave-planner');
+    });
+  });
+
+  // === META-OBSERVATIONS ===
+
+  describe('meta-observations', () => {
+    it('should record and retrieve meta-observations', async () => {
+      const obs = createTeamMetaObservation({
+        teamTrajectoryId: 'tt-001',
+        formation: {
+          formationMethod: 'playbook',
+          confidence: 0.8,
+          reasoning: 'Matched wave pattern',
+        },
+        compositionEffectiveness: {
+          roleUtilization: { planner: 0.9 },
+          missingRoles: [],
+          redundantRoles: [],
+          teamSizeAssessment: 'right-sized',
+          topologyAssessment: 'effective',
+        },
+        coordinationEffectiveness: {
+          enforcementAssessment: 'appropriate',
+          channelEffectiveness: 'helpful',
+          bottlenecks: [],
+          coordinationOverhead: 0.2,
+        },
+        outcome: {
+          success: true,
+          quality: 'good',
+          speedupEstimate: 1.5,
+          costEfficiency: 0.8,
+        },
+        lessons: {
+          whatWorked: ['Wave topology'],
+          whatFailed: [],
+          formationSuggestions: [],
+          coordinationSuggestions: [],
+        },
+      });
+
+      await memory.recordMetaObservation(obs);
+
+      const all = await memory.getMetaObservations();
+      expect(all).toHaveLength(1);
+      expect(all[0].teamTrajectoryId).toBe('tt-001');
+    });
+  });
+
+  // === META-STRATEGIES ===
+
+  describe('meta-strategies', () => {
+    it('should store and find matching meta-strategies', async () => {
+      const strategy = createTeamMetaStrategy({
+        name: 'prefer-wave-for-web',
+        condition: {
+          taskCharacteristics: ['multi-component'],
+          resourceConstraints: [],
+          domains: ['web'],
+        },
+        adjustment: {
+          topologyBias: { wave: 0.8 },
+          teamSizeAdjustment: 'maintain',
+          roleAdjustments: [],
+          coordinationHints: [],
+        },
+      });
+
+      await memory.storeMetaStrategy(strategy);
+
+      const matches = await memory.getMatchingMetaStrategies({ domains: ['web'] });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].name).toBe('prefer-wave-for-web');
+
+      const noMatches = await memory.getMatchingMetaStrategies({ domains: ['infra'] });
+      expect(noMatches).toHaveLength(0);
+    });
+  });
+
+  // === AGGREGATE STATS ===
+
+  describe('stats', () => {
+    it('should return correct stats', async () => {
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+
+      const playbook = createTeamPlaybook({
+        name: 'test',
+        applicability: { taskTypes: [], teamSizeRange: { min: 1, max: 1 }, complexityLevels: [], domains: [], antiPatterns: [] },
+        composition: { topology: 'flat', roles: [], spawnRules: {}, enforcement: 'permissive' },
+        coordination: { executionModel: 'sequential', channels: [], interactionPatterns: [], delegationStrategy: '' },
+      });
+      await memory.storeTeamPlaybook(playbook);
+
+      const stats = await memory.getStats();
+      expect(stats.teamExperienceCount).toBe(1);
+      expect(stats.teamPlaybookCount).toBe(1);
+      expect(stats.rolePlaybookCount).toBe(0);
+      expect(stats.metaObservationCount).toBe(0);
+      expect(stats.metaStrategyCount).toBe(0);
+    });
+  });
+});