cognitive-core 0.1.0 → 0.2.0

package/src/learning/pipeline.ts

@@ -1,244 +0,0 @@
-import type {
-  Trajectory,
-  LearningConfig,
-} from '../types/index.js';
-import type { MemorySystem } from '../memory/system.js';
-import {
-  TrajectoryAnalyzer,
-  createAnalyzer,
-  type AnalysisResult,
-} from './analyzer.js';
-import {
-  PlaybookExtractor,
-  createPlaybookExtractor,
-} from './playbook-extractor.js';
-
-/**
- * Result of processing a single trajectory
- */
-export interface ProcessResult {
-  trajectoryId: string;
-  stored: boolean;
-  analysis: AnalysisResult;
-  abstractable: boolean;
-  playbookExtracted: boolean;
-}
-
-/**
- * Result of batch learning
- */
-export interface BatchResult {
-  trajectoriesProcessed: number;
-  playbooksExtracted: number;
-  experiencesPruned: number;
-  successRate: number;
-}
-
-/**
- * Learning Pipeline
- * Orchestrates trajectory analysis, playbook extraction, and memory updates
- */
-export class LearningPipeline {
-  private analyzer: TrajectoryAnalyzer;
-  private playbookExtractor: PlaybookExtractor;
-  private memory: MemorySystem;
-  private config: LearningConfig;
-
-  // Accumulated trajectories for batch learning
-  private accumulated: Trajectory[] = [];
-  private accumulatedAnalyses: AnalysisResult[] = [];
-  private lastBatchTime: Date | null = null;
-
-  constructor(memory: MemorySystem, config?: Partial<LearningConfig>) {
-    this.memory = memory;
-    this.config = {
-      creditStrategy: config?.creditStrategy ?? 'simple',
-      patternExtractor: config?.patternExtractor ?? 'llm',
-      minTrajectories: config?.minTrajectories ?? 10,
-      minHoursSinceLast: config?.minHoursSinceLast,
-      minSuccessRate: config?.minSuccessRate,
-      deduplicationThreshold: config?.deduplicationThreshold ?? 0.9,
-      maxExperiences: config?.maxExperiences ?? 1000,
-    };
-
-    this.analyzer = createAnalyzer(this.config.creditStrategy);
-    this.playbookExtractor = createPlaybookExtractor({
-      minTrajectories: this.config.minTrajectories,
-      mergeThreshold: this.config.deduplicationThreshold,
-      minSuccessRate: this.config.minSuccessRate ?? 0.6,
-    });
-  }
-
-  /**
-   * Process a single trajectory
-   */
-  async processTrajectory(trajectory: Trajectory): Promise<ProcessResult> {
-    // Store in experience memory
-    await this.memory.storeTrajectory(trajectory);
-
-    // Analyze the trajectory
-    const analysis = await this.analyzer.analyze(trajectory);
-
-    // Accumulate for batch learning
-    this.accumulated.push(trajectory);
-    this.accumulatedAnalyses.push(analysis);
-
-    return {
-      trajectoryId: trajectory.id,
-      stored: true,
-      analysis,
-      abstractable: analysis.abstractable,
-      playbookExtracted: false, // Playbooks are extracted in batch
-    };
-  }
-
-  /**
-   * Check if batch learning should run
-   */
-  shouldRunBatch(): boolean {
-    // Check minimum trajectories
-    if (this.accumulated.length < this.config.minTrajectories) {
-      return false;
-    }
-
-    // Check time since last batch
-    if (this.config.minHoursSinceLast && this.lastBatchTime) {
-      const hoursSinceLast =
-        (Date.now() - this.lastBatchTime.getTime()) / (1000 * 60 * 60);
-      if (hoursSinceLast < this.config.minHoursSinceLast) {
-        return false;
-      }
-    }
-
-    // Check success rate
-    if (this.config.minSuccessRate) {
-      const successCount = this.accumulatedAnalyses.filter(
-        (a) => a.success
-      ).length;
-      const successRate = successCount / this.accumulated.length;
-      if (successRate < this.config.minSuccessRate) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Run batch learning on accumulated trajectories
-   */
-  async runBatchLearning(): Promise<BatchResult> {
-    if (this.accumulated.length === 0) {
-      return {
-        trajectoriesProcessed: 0,
-        playbooksExtracted: 0,
-        experiencesPruned: 0,
-        successRate: 0,
-      };
-    }
-
-    // Extract playbooks from trajectories
-    let playbooksAdded = 0;
-    const existingPlaybooks = await this.memory.playbooks.getAll();
-    const playbookExtraction = await this.playbookExtractor.extract(
-      this.accumulated,
-      this.accumulatedAnalyses,
-      existingPlaybooks
-    );
-
-    // Add new playbooks
-    for (const playbook of playbookExtraction.new) {
-      const exists = await this.memory.playbooks.exists(
-        playbook.name,
-        this.config.deduplicationThreshold
-      );
-      if (!exists) {
-        await this.memory.playbooks.add(playbook);
-        playbooksAdded++;
-      }
-    }
-
-    // Apply updates to existing playbooks
-    for (const update of playbookExtraction.updates) {
-      if (update.refinement) {
-        await this.memory.playbooks.addRefinement(
-          update.id,
-          update.refinement.context,
-          update.refinement.addition,
-          update.refinement.source
-        );
-      }
-      if (update.newTrigger) {
-        const playbook = await this.memory.playbooks.get(update.id);
-        if (playbook && !playbook.applicability.triggers.includes(update.newTrigger)) {
-          playbook.applicability.triggers.push(update.newTrigger);
-          await this.memory.playbooks.add(playbook);
-        }
-      }
-      if (update.newAntiPattern) {
-        const playbook = await this.memory.playbooks.get(update.id);
-        if (playbook && !playbook.applicability.antiPatterns.includes(update.newAntiPattern)) {
-          playbook.applicability.antiPatterns.push(update.newAntiPattern);
-          await this.memory.playbooks.add(playbook);
-        }
-      }
-    }
-
-    // Prune experiences if needed
-    const pruned = await this.memory.experiences.prune({
-      maxCount: this.config.maxExperiences,
-    });
-
-    // Calculate success rate
-    const successCount = this.accumulatedAnalyses.filter((a) => a.success).length;
-    const successRate = successCount / this.accumulated.length;
-
-    // Clear accumulated and update time
-    const trajectoriesProcessed = this.accumulated.length;
-    this.accumulated = [];
-    this.accumulatedAnalyses = [];
-    this.lastBatchTime = new Date();
-
-    return {
-      trajectoriesProcessed,
-      playbooksExtracted: playbooksAdded,
-      experiencesPruned: pruned.totalPruned,
-      successRate,
-    };
-  }
-
-  /**
-   * Get accumulated trajectory count
-   */
-  getAccumulatedCount(): number {
-    return this.accumulated.length;
-  }
-
-  /**
-   * Clear accumulated trajectories
-   */
-  clearAccumulated(): void {
-    this.accumulated = [];
-    this.accumulatedAnalyses = [];
-  }
-
-  /**
-   * Update configuration
-   */
-  updateConfig(config: Partial<LearningConfig>): void {
-    this.config = { ...this.config, ...config };
-    if (config.creditStrategy) {
-      this.analyzer.setStrategy(config.creditStrategy);
-    }
-  }
-}
-
-/**
- * Create a learning pipeline
- */
-export function createLearningPipeline(
-  memory: MemorySystem,
-  config?: Partial<LearningConfig>
-): LearningPipeline {
-  return new LearningPipeline(memory, config);
-}

package/tests/learning/pipeline.test.ts

@@ -1,176 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { LearningPipeline, createLearningPipeline } from '../../src/learning/pipeline.js';
-import { MemorySystem } from '../../src/memory/system.js';
-import { createTrajectory, createStep, createTask, successOutcome, failureOutcome } from '../../src/types/index.js';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-
-describe('LearningPipeline', () => {
-  let pipeline: LearningPipeline;
-  let memory: MemorySystem;
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = path.join(process.cwd(), '.test-pipeline-' + Date.now());
-    await fs.mkdir(testDir, { recursive: true });
-    memory = new MemorySystem(testDir);
-    await memory.init();
-    pipeline = createLearningPipeline(memory, {
-      minTrajectories: 3,
-      minSuccessRate: 0.5,
-      maxExperiences: 100,
-    });
-  });
-
-  afterEach(async () => {
-    await memory.close();
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  const createTestTrajectory = (success: boolean, description: string) => {
-    return createTrajectory({
-      task: createTask({ domain: 'test', description }),
-      steps: [
-        createStep({
-          thought: 'Analyzing task',
-          action: 'read file',
-          observation: 'file contents',
-        }),
-        createStep({
-          thought: 'Applying solution',
-          action: 'edit file',
-          observation: success ? 'success' : 'error: failed',
-        }),
-      ],
-      outcome: success
-        ? successOutcome({ result: 'completed' })
-        : failureOutcome('Task failed'),
-      agentId: 'test-agent',
-    });
-  };
-
-  describe('processTrajectory', () => {
-    it('should process and store trajectory', async () => {
-      const trajectory = createTestTrajectory(true, 'Test task 1');
-      const result = await pipeline.processTrajectory(trajectory);
-
-      expect(result.stored).toBe(true);
-      expect(result.trajectoryId).toBe(trajectory.id);
-      expect(result.analysis).toBeDefined();
-      expect(result.analysis.success).toBe(true);
-    });
-
-    it('should accumulate trajectories for batch learning', async () => {
-      expect(pipeline.getAccumulatedCount()).toBe(0);
-
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      expect(pipeline.getAccumulatedCount()).toBe(1);
-
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-      expect(pipeline.getAccumulatedCount()).toBe(2);
-    });
-
-    it('should analyze trajectory for key steps', async () => {
-      const trajectory = createTestTrajectory(true, 'Test analysis');
-      const result = await pipeline.processTrajectory(trajectory);
-
-      expect(result.analysis.keySteps).toBeDefined();
-      expect(Array.isArray(result.analysis.keySteps)).toBe(true);
-      expect(result.analysis.stepAttribution).toBeDefined();
-      expect(result.analysis.stepAttribution.length).toBe(trajectory.steps.length);
-    });
-  });
-
-  describe('shouldRunBatch', () => {
-    it('should return false when below minTrajectories', () => {
-      expect(pipeline.shouldRunBatch()).toBe(false);
-    });
-
-    it('should return true when above minTrajectories with sufficient success rate', async () => {
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-      expect(pipeline.shouldRunBatch()).toBe(false); // Still below 3
-
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 3'));
-      expect(pipeline.shouldRunBatch()).toBe(true); // Now at 3
-    });
-
-    it('should return false when success rate is too low', async () => {
-      await pipeline.processTrajectory(createTestTrajectory(false, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(false, 'Task 2'));
-      await pipeline.processTrajectory(createTestTrajectory(false, 'Task 3'));
-
-      // 0% success rate, below 50% threshold
-      expect(pipeline.shouldRunBatch()).toBe(false);
-    });
-  });
-
-  describe('runBatchLearning', () => {
-    it('should return empty result when no trajectories accumulated', async () => {
-      const result = await pipeline.runBatchLearning();
-
-      expect(result.trajectoriesProcessed).toBe(0);
-      expect(result.playbooksExtracted).toBe(0);
-      expect(result.experiencesPruned).toBe(0);
-      expect(result.successRate).toBe(0);
-    });
-
-    it('should process accumulated trajectories', async () => {
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-      await pipeline.processTrajectory(createTestTrajectory(false, 'Task 3'));
-
-      const result = await pipeline.runBatchLearning();
-
-      expect(result.trajectoriesProcessed).toBe(3);
-      expect(result.successRate).toBeCloseTo(2/3, 2);
-    });
-
-    it('should clear accumulated after batch', async () => {
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-
-      expect(pipeline.getAccumulatedCount()).toBe(2);
-      await pipeline.runBatchLearning();
-      expect(pipeline.getAccumulatedCount()).toBe(0);
-    });
-  });
-
-  describe('clearAccumulated', () => {
-    it('should clear all accumulated trajectories', async () => {
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-
-      expect(pipeline.getAccumulatedCount()).toBe(2);
-      pipeline.clearAccumulated();
-      expect(pipeline.getAccumulatedCount()).toBe(0);
-    });
-  });
-
-  describe('configuration', () => {
-    it('should use configurable maxExperiences for pruning', async () => {
-      // The pipeline was created with maxExperiences: 100
-      // This test verifies the config is passed correctly
-      const configuredPipeline = createLearningPipeline(memory, {
-        maxExperiences: 50,
-      });
-
-      // Process a trajectory to ensure it uses the config
-      const trajectory = createTestTrajectory(true, 'Config test');
-      const result = await configuredPipeline.processTrajectory(trajectory);
-      expect(result.stored).toBe(true);
-    });
-
-    it('should update configuration', async () => {
-      pipeline.updateConfig({ minTrajectories: 5 });
-
-      // Add 3 trajectories (was enough before update)
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 1'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 2'));
-      await pipeline.processTrajectory(createTestTrajectory(true, 'Task 3'));
-
-      // Should not run batch yet (need 5 now)
-      expect(pipeline.shouldRunBatch()).toBe(false);
-    });
-  });
-});