cognitive-core 0.0.2 → 0.1.2

package/src/learning/pipeline.ts

@@ -0,0 +1,323 @@
+import type {
+  Trajectory,
+  LearningConfig,
+} from '../types/index.js';
+import type { TrajectoryWithAnalysis } from '../types/trajectory-source.js';
+import type { MemorySystem } from '../memory/system.js';
+import {
+  TrajectoryAnalyzer,
+  createAnalyzer,
+  type AnalysisResult,
+} from './analyzer.js';
+import {
+  PlaybookExtractor,
+  createPlaybookExtractor,
+} from './playbook-extractor.js';
+import type { AgenticTaskRunner } from '../workspace/runner.js';
+import { trajectoryAnalysisTemplate } from '../workspace/templates/trajectory-analysis.js';
+import { playbookExtractionTemplate } from '../workspace/templates/playbook-extraction.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;
+
+  // Optional agentic task runner for workspace-based analysis
+  private taskRunner: AgenticTaskRunner | null = null;
+
+  // 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,
+    });
+  }
+
+  /**
+   * Set the agentic task runner for workspace-based analysis.
+   * When set, analysis tasks are delegated to templates (with heuristic fallback).
+   */
+  setTaskRunner(runner: AgenticTaskRunner): void {
+    this.taskRunner = runner;
+  }
+
+  /**
+   * Process a single trajectory
+   */
+  async processTrajectory(trajectory: Trajectory): Promise<ProcessResult> {
+    // Store in experience memory
+    await this.memory.storeTrajectory(trajectory);
+
+    // Analyze: workspace-based when runner available, heuristic otherwise
+    let analysis: AnalysisResult;
+    if (this.taskRunner) {
+      analysis = await this.analyzeWithTemplate(trajectory);
+    } else {
+      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
+    };
+  }
+
+  /**
+   * Run trajectory analysis via the workspace template.
+   * The template's assessComplexity() routes simple cases to heuristicFallback()
+   * (which calls the existing TrajectoryAnalyzer), so this is safe for all inputs.
+   */
+  private async analyzeWithTemplate(trajectory: Trajectory): Promise<AnalysisResult> {
+    try {
+      const result = await this.taskRunner!.run(trajectoryAnalysisTemplate, {
+        trajectory,
+        creditStrategy: this.config.creditStrategy,
+      });
+      return result.output;
+    } catch (error) {
+      // If workspace-based analysis fails, fall back to heuristic
+      console.error(
+        'Workspace-based trajectory analysis failed, falling back to heuristic:',
+        error instanceof Error ? error.message : error
+      );
+      return this.analyzer.analyze(trajectory);
+    }
+  }
+
+  /**
+   * 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: workspace-based when runner available, heuristic otherwise
+    let playbooksAdded = 0;
+    const existingPlaybooks = await this.memory.playbooks.getAll();
+    const playbookExtraction = await this.extractPlaybooks(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,
+    };
+  }
+
+  /**
+   * Run playbook extraction via the workspace template.
+   * Falls back to heuristic extractor on failure.
+   */
+  private async extractPlaybooks(
+    existingPlaybooks: import('../types/index.js').Playbook[]
+  ): Promise<import('./playbook-extractor.js').ExtractedPlaybooks> {
+    if (this.taskRunner) {
+      try {
+        const result = await this.taskRunner.run(playbookExtractionTemplate, {
+          trajectories: this.accumulated,
+          analyses: this.accumulatedAnalyses,
+          existingPlaybooks,
+        });
+        return result.output;
+      } catch (error) {
+        console.error(
+          'Workspace-based playbook extraction failed, falling back to heuristic:',
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+
+    return this.playbookExtractor.extract(
+      this.accumulated,
+      this.accumulatedAnalyses,
+      existingPlaybooks
+    );
+  }
+
+  /**
+   * Get accumulated trajectory count
+   */
+  getAccumulatedCount(): number {
+    return this.accumulated.length;
+  }
+
+  /**
+   * Get accumulated trajectories with their analyses.
+   * Read-only view — does not clear the accumulator.
+   */
+  getAccumulated(): TrajectoryWithAnalysis[] {
+    return this.accumulated.map((trajectory, i) => ({
+      trajectory,
+      analysis: this.accumulatedAnalyses[i],
+    }));
+  }
+
+  /**
+   * 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);
+}