@baselineos/autonomy 0.1.0

package/src/integration.ts

@@ -0,0 +1,600 @@
+import { EventEmitter } from 'events';
+
+// ---------------------------------------------------------------------------
+// Types & Interfaces
+// ---------------------------------------------------------------------------
+
+export type MigrationMode = 'parallel' | 'progressive' | 'full';
+
+export interface IntegrationPoint {
+  layer: string;
+  purpose: string;
+  integration: string;
+  status: string;
+}
+
+export interface MigrationComponentStatus {
+  component: string;
+  currentStatus: string;
+  targetStatus: string;
+  migrationProgress: number;
+  dependencies: string[];
+  estimatedCompletion: string;
+}
+
+export interface ComparisonResult {
+  timestamp: Date;
+  legacyResult: string;
+  newResult: string;
+  quality: Record<string, unknown>;
+  performance: Record<string, unknown>;
+  recommendation: string | null;
+}
+
+export interface IntegrationStatus {
+  migrationMode: MigrationMode;
+  integrationPoints: IntegrationPoint[];
+  migrationStatus: MigrationComponentStatus[];
+  comparisonHistory: ComparisonResult[];
+  statistics: {
+    totalComparisons: number;
+    averageQualityImprovement: number;
+    averagePerformanceImprovement: number;
+    recommendationsForNew: number;
+    recommendationsForLegacy: number;
+  };
+}
+
+export interface MigrationRecommendation {
+  component: string;
+  currentStatus: string;
+  recommendation: string;
+  priority: number;
+  reason: string;
+}
+
+// ---------------------------------------------------------------------------
+// BaselineAutonomyIntegration
+// ---------------------------------------------------------------------------
+
+export class BaselineAutonomyIntegration extends EventEmitter {
+  private migrationMode: MigrationMode;
+  private integrationPoints: Map<string, IntegrationPoint>;
+  private migrationStatus: Map<string, MigrationComponentStatus>;
+  private comparisonHistory: ComparisonResult[];
+  private autonomySystem: unknown;
+
+  constructor(autonomySystem: unknown) {
+    super();
+    this.autonomySystem = autonomySystem;
+    this.migrationMode = 'parallel';
+    this.integrationPoints = new Map();
+    this.migrationStatus = new Map();
+    this.comparisonHistory = [];
+  }
+
+  // -----------------------------------------------------------------------
+  // Initialization
+  // -----------------------------------------------------------------------
+
+  async initialize(): Promise<void> {
+    console.log('[BaselineAutonomyIntegration] Initializing integration layer...');
+
+    this.initializeIntegrationPoints();
+    this.initializeMigrationStatus();
+
+    console.log('[BaselineAutonomyIntegration] Integration layer initialized');
+    console.log(`[BaselineAutonomyIntegration]   Integration points: ${this.integrationPoints.size}`);
+    console.log(`[BaselineAutonomyIntegration]   Migration components: ${this.migrationStatus.size}`);
+    console.log(`[BaselineAutonomyIntegration]   Migration mode: ${this.migrationMode}`);
+
+    this.emit('initialized', {
+      integrationPoints: this.integrationPoints.size,
+      migrationComponents: this.migrationStatus.size,
+      mode: this.migrationMode,
+    });
+  }
+
+  // -----------------------------------------------------------------------
+  // Integration Points (6 - one per layer)
+  // -----------------------------------------------------------------------
+
+  private initializeIntegrationPoints(): void {
+    const points: IntegrationPoint[] = [
+      {
+        layer: 'protocol-core',
+        purpose: 'Core protocol definitions and token management',
+        integration: 'Mastra AI tool integration for protocol validation and token operations',
+        status: 'active',
+      },
+      {
+        layer: 'lang',
+        purpose: 'Natural language understanding and command parsing',
+        integration: 'LangChain NLP pipeline with Mastra agent orchestration',
+        status: 'active',
+      },
+      {
+        layer: 'frame',
+        purpose: 'UI component framework and rendering',
+        integration: 'AI-assisted component generation and layout optimization',
+        status: 'planned',
+      },
+      {
+        layer: 'studio',
+        purpose: 'Development environment and workspace management',
+        integration: 'Autonomous code generation and project scaffolding via Mastra agents',
+        status: 'active',
+      },
+      {
+        layer: 'govern',
+        purpose: 'Governance, permissions, and policy enforcement',
+        integration: 'AI-driven policy evaluation and compliance monitoring',
+        status: 'active',
+      },
+      {
+        layer: 'experience',
+        purpose: 'User experience personalization and adaptive interfaces',
+        integration: 'LangChain memory for user preference learning and Mastra agent personalization',
+        status: 'planned',
+      },
+    ];
+
+    for (const point of points) {
+      this.integrationPoints.set(point.layer, point);
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // Migration Status (4 components)
+  // -----------------------------------------------------------------------
+
+  private initializeMigrationStatus(): void {
+    const components: MigrationComponentStatus[] = [
+      {
+        component: 'nlp-pipeline',
+        currentStatus: 'legacy',
+        targetStatus: 'langchain',
+        migrationProgress: 35,
+        dependencies: ['lang', 'protocol-core'],
+        estimatedCompletion: '2026-Q2',
+      },
+      {
+        component: 'agent-orchestration',
+        currentStatus: 'hybrid',
+        targetStatus: 'mastra',
+        migrationProgress: 60,
+        dependencies: ['protocol-core', 'govern'],
+        estimatedCompletion: '2026-Q1',
+      },
+      {
+        component: 'memory-management',
+        currentStatus: 'legacy',
+        targetStatus: 'langchain-memory',
+        migrationProgress: 20,
+        dependencies: ['experience', 'lang'],
+        estimatedCompletion: '2026-Q3',
+      },
+      {
+        component: 'governance-engine',
+        currentStatus: 'hybrid',
+        targetStatus: 'mastra-governance',
+        migrationProgress: 45,
+        dependencies: ['govern', 'protocol-core'],
+        estimatedCompletion: '2026-Q2',
+      },
+    ];
+
+    for (const component of components) {
+      this.migrationStatus.set(component.component, component);
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // Command Execution
+  // -----------------------------------------------------------------------
+
+  async executeCommand(
+    command: string,
+    context: Record<string, unknown> = {}
+  ): Promise<Record<string, unknown>> {
+    console.log(`[BaselineAutonomyIntegration] Executing command: ${command} (mode: ${this.migrationMode})`);
+
+    switch (this.migrationMode) {
+      case 'parallel':
+        return this.executeParallel(command, context);
+      case 'progressive':
+        return this.executeProgressive(command, context);
+      case 'full':
+        return this.executeNew(command, context);
+      default:
+        return this.executeParallel(command, context);
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // Execution modes
+  // -----------------------------------------------------------------------
+
+  private async executeParallel(
+    command: string,
+    context: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
+    console.log('[BaselineAutonomyIntegration] [Parallel] Executing in both legacy and new systems...');
+
+    const startTimeLegacy = Date.now();
+    const legacyResult = await this.executeLegacy(command, context);
+    const legacyDuration = Date.now() - startTimeLegacy;
+
+    const startTimeNew = Date.now();
+    const newResult = await this.executeNew(command, context);
+    const newDuration = Date.now() - startTimeNew;
+
+    const comparison = this.compareResults(legacyResult, newResult, legacyDuration, newDuration);
+    this.comparisonHistory.push(comparison);
+
+    console.log('[BaselineAutonomyIntegration] [Parallel] Comparison complete');
+    console.log(`[BaselineAutonomyIntegration]   Legacy duration: ${legacyDuration}ms`);
+    console.log(`[BaselineAutonomyIntegration]   New duration: ${newDuration}ms`);
+    console.log(`[BaselineAutonomyIntegration]   Recommendation: ${comparison.recommendation}`);
+
+    this.emit('parallel-execution', {
+      command,
+      legacyDuration,
+      newDuration,
+      comparison,
+    });
+
+    return {
+      mode: 'parallel',
+      legacyResult,
+      newResult,
+      comparison,
+      selectedResult: comparison.recommendation === 'use-new' ? newResult : legacyResult,
+    };
+  }
+
+  private async executeProgressive(
+    command: string,
+    context: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
+    console.log('[BaselineAutonomyIntegration] [Progressive] Evaluating best execution path...');
+
+    // Check migration progress for the relevant component
+    const relevantComponent = this.findRelevantComponent(command);
+    const componentStatus = relevantComponent
+      ? this.migrationStatus.get(relevantComponent)
+      : null;
+
+    if (componentStatus && componentStatus.migrationProgress >= 70) {
+      console.log(
+        `[BaselineAutonomyIntegration] [Progressive] Component ${relevantComponent} is ${componentStatus.migrationProgress}% migrated - using new system`
+      );
+      const result = await this.executeNew(command, context);
+      return { mode: 'progressive', system: 'new', result };
+    }
+
+    if (componentStatus && componentStatus.migrationProgress >= 40) {
+      console.log(
+        `[BaselineAutonomyIntegration] [Progressive] Component ${relevantComponent} is ${componentStatus.migrationProgress}% migrated - using parallel execution`
+      );
+      return this.executeParallel(command, context);
+    }
+
+    console.log(
+      '[BaselineAutonomyIntegration] [Progressive] Migration progress too low - using legacy system'
+    );
+    const result = await this.executeLegacy(command, context);
+    return { mode: 'progressive', system: 'legacy', result };
+  }
+
+  private async executeNew(
+    command: string,
+    context: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
+    console.log('[BaselineAutonomyIntegration] [New] Executing via Mastra/LangChain pipeline...');
+
+    // Simulate new system execution
+    await this.delay(50 + Math.random() * 100);
+
+    const result: Record<string, unknown> = {
+      system: 'mastra-langchain',
+      command,
+      context,
+      timestamp: new Date().toISOString(),
+      output: `Processed "${command}" via Mastra/LangChain autonomy engine`,
+      confidence: 0.85 + Math.random() * 0.15,
+      tokens: Math.floor(Math.random() * 500) + 100,
+    };
+
+    const validation = this.validateResult(result);
+    result.validation = validation;
+
+    this.emit('new-execution', { command, result });
+
+    return result;
+  }
+
+  private async executeLegacy(
+    command: string,
+    context: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
+    console.log('[BaselineAutonomyIntegration] [Legacy] Executing via legacy Baseline pipeline...');
+
+    // Simulate legacy system execution
+    await this.delay(100 + Math.random() * 200);
+
+    const result: Record<string, unknown> = {
+      system: 'legacy-baseline',
+      command,
+      context,
+      timestamp: new Date().toISOString(),
+      output: `Processed "${command}" via legacy Baseline pipeline`,
+      confidence: 0.7 + Math.random() * 0.2,
+      tokens: Math.floor(Math.random() * 300) + 50,
+    };
+
+    const validation = this.validateResult(result);
+    result.validation = validation;
+
+    this.emit('legacy-execution', { command, result });
+
+    return result;
+  }
+
+  // -----------------------------------------------------------------------
+  // Comparison & Quality
+  // -----------------------------------------------------------------------
+
+  private compareResults(
+    legacyResult: Record<string, unknown>,
+    newResult: Record<string, unknown>,
+    legacyDuration: number,
+    newDuration: number
+  ): ComparisonResult {
+    const quality = this.assessQuality(legacyResult, newResult);
+    const performance: Record<string, unknown> = {
+      legacyDuration,
+      newDuration,
+      speedImprovement: this.calculateImprovement(legacyDuration, newDuration),
+      fasterSystem: newDuration < legacyDuration ? 'new' : 'legacy',
+    };
+
+    const recommendation = this.generateRecommendation(quality, performance);
+
+    return {
+      timestamp: new Date(),
+      legacyResult: JSON.stringify(legacyResult),
+      newResult: JSON.stringify(newResult),
+      quality,
+      performance,
+      recommendation,
+    };
+  }
+
+  private assessQuality(
+    legacyResult: Record<string, unknown>,
+    newResult: Record<string, unknown>
+  ): Record<string, unknown> {
+    const legacyConfidence = (legacyResult.confidence as number) ?? 0;
+    const newConfidence = (newResult.confidence as number) ?? 0;
+
+    const confidenceImprovement = this.calculateImprovement(
+      legacyConfidence,
+      newConfidence
+    );
+
+    const legacyValid = legacyResult.validation
+      ? (legacyResult.validation as Record<string, unknown>).valid
+      : false;
+    const newValid = newResult.validation
+      ? (newResult.validation as Record<string, unknown>).valid
+      : false;
+
+    return {
+      legacyConfidence,
+      newConfidence,
+      confidenceImprovement,
+      legacyValid,
+      newValid,
+      qualityScore: (newConfidence + (newValid ? 0.1 : 0)) - (legacyConfidence + (legacyValid ? 0.1 : 0)),
+    };
+  }
+
+  private calculateImprovement(oldValue: number, newValue: number): number {
+    if (oldValue === 0) return 0;
+    return ((newValue - oldValue) / oldValue) * 100;
+  }
+
+  private generateRecommendation(
+    quality: Record<string, unknown>,
+    performance: Record<string, unknown>
+  ): string | null {
+    const qualityScore = (quality.qualityScore as number) ?? 0;
+    const speedImprovement = (performance.speedImprovement as number) ?? 0;
+    const newValid = quality.newValid as boolean;
+
+    // If the new system is both faster and higher quality, recommend it
+    if (qualityScore > 0 && speedImprovement > 0 && newValid) {
+      return 'use-new';
+    }
+
+    // If quality is significantly better even if slower
+    if (qualityScore > 0.1 && newValid) {
+      return 'use-new';
+    }
+
+    // If the new system is much faster but quality is similar
+    if (speedImprovement > 30 && qualityScore >= -0.05 && newValid) {
+      return 'use-new';
+    }
+
+    // If legacy is better overall
+    if (qualityScore < -0.1) {
+      return 'use-legacy';
+    }
+
+    // Insufficient evidence
+    return null;
+  }
+
+  private validateResult(result: Record<string, unknown>): Record<string, unknown> {
+    const valid =
+      result.output !== undefined &&
+      result.output !== null &&
+      typeof result.output === 'string' &&
+      (result.output as string).length > 0;
+
+    const hasConfidence =
+      typeof result.confidence === 'number' &&
+      (result.confidence as number) >= 0 &&
+      (result.confidence as number) <= 1;
+
+    return {
+      valid,
+      hasConfidence,
+      hasTimestamp: typeof result.timestamp === 'string',
+      hasSystem: typeof result.system === 'string',
+      score: (valid ? 0.4 : 0) + (hasConfidence ? 0.3 : 0) + (result.timestamp ? 0.15 : 0) + (result.system ? 0.15 : 0),
+    };
+  }
+
+  // -----------------------------------------------------------------------
+  // Status & Configuration
+  // -----------------------------------------------------------------------
+
+  getIntegrationStatus(): IntegrationStatus {
+    const comparisons = this.comparisonHistory;
+    const totalComparisons = comparisons.length;
+
+    let totalQualityImprovement = 0;
+    let totalPerformanceImprovement = 0;
+    let recommendationsForNew = 0;
+    let recommendationsForLegacy = 0;
+
+    for (const comparison of comparisons) {
+      const qualityScore = (comparison.quality.qualityScore as number) ?? 0;
+      totalQualityImprovement += qualityScore;
+
+      const speedImprovement = (comparison.performance.speedImprovement as number) ?? 0;
+      totalPerformanceImprovement += speedImprovement;
+
+      if (comparison.recommendation === 'use-new') {
+        recommendationsForNew += 1;
+      } else if (comparison.recommendation === 'use-legacy') {
+        recommendationsForLegacy += 1;
+      }
+    }
+
+    return {
+      migrationMode: this.migrationMode,
+      integrationPoints: Array.from(this.integrationPoints.values()),
+      migrationStatus: Array.from(this.migrationStatus.values()),
+      comparisonHistory: comparisons,
+      statistics: {
+        totalComparisons,
+        averageQualityImprovement: totalComparisons > 0 ? totalQualityImprovement / totalComparisons : 0,
+        averagePerformanceImprovement: totalComparisons > 0 ? totalPerformanceImprovement / totalComparisons : 0,
+        recommendationsForNew,
+        recommendationsForLegacy,
+      },
+    };
+  }
+
+  setMigrationMode(mode: MigrationMode): void {
+    const previousMode = this.migrationMode;
+    this.migrationMode = mode;
+
+    console.log(
+      `[BaselineAutonomyIntegration] Migration mode changed: ${previousMode} -> ${mode}`
+    );
+
+    this.emit('migration-mode-changed', { previousMode, newMode: mode });
+  }
+
+  getMigrationRecommendations(): MigrationRecommendation[] {
+    const recommendations: MigrationRecommendation[] = [];
+
+    for (const [, component] of this.migrationStatus) {
+      let recommendation: string;
+      let reason: string;
+
+      if (component.migrationProgress >= 80) {
+        recommendation = 'Complete migration to new system';
+        reason = `Migration is ${component.migrationProgress}% complete - finalize transition`;
+      } else if (component.migrationProgress >= 50) {
+        recommendation = 'Continue progressive migration';
+        reason = `Migration is ${component.migrationProgress}% complete - maintain parallel execution`;
+      } else if (component.migrationProgress >= 20) {
+        recommendation = 'Accelerate migration efforts';
+        reason = `Migration is only ${component.migrationProgress}% complete - increase resources`;
+      } else {
+        recommendation = 'Begin migration planning';
+        reason = `Migration is ${component.migrationProgress}% complete - start planning phase`;
+      }
+
+      const priority = this.calculatePriority(component);
+
+      recommendations.push({
+        component: component.component,
+        currentStatus: component.currentStatus,
+        recommendation,
+        priority,
+        reason,
+      });
+    }
+
+    // Sort by priority descending
+    recommendations.sort((a, b) => b.priority - a.priority);
+
+    return recommendations;
+  }
+
+  private calculatePriority(component: MigrationComponentStatus): number {
+    let priority = 0;
+
+    // Higher progress = higher priority to complete
+    priority += component.migrationProgress * 0.3;
+
+    // Fewer dependencies = easier to migrate = higher priority
+    priority += (10 - component.dependencies.length * 2) * 0.2;
+
+    // Hybrid status means already partially migrated = higher priority
+    if (component.currentStatus === 'hybrid') {
+      priority += 20;
+    }
+
+    // Legacy status with low progress = lower priority
+    if (component.currentStatus === 'legacy' && component.migrationProgress < 30) {
+      priority -= 10;
+    }
+
+    return Math.max(0, Math.min(100, priority));
+  }
+
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+
+  private findRelevantComponent(command: string): string | null {
+    const commandLower = command.toLowerCase();
+
+    if (commandLower.includes('nlp') || commandLower.includes('parse') || commandLower.includes('language')) {
+      return 'nlp-pipeline';
+    }
+    if (commandLower.includes('agent') || commandLower.includes('orchestrat')) {
+      return 'agent-orchestration';
+    }
+    if (commandLower.includes('memory') || commandLower.includes('remember') || commandLower.includes('context')) {
+      return 'memory-management';
+    }
+    if (commandLower.includes('govern') || commandLower.includes('policy') || commandLower.includes('permission')) {
+      return 'governance-engine';
+    }
+
+    return null;
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}