snow-flow 2.0.2 → 2.0.3

package/src/intelligence/performance-recommendations-engine.ts

@@ -1,1223 +0,0 @@
-/**
- * 🚀 PERFORMANCE FIX: Enhanced AI-Powered Performance Recommendations Engine
- * 
- * Provides intelligent database index suggestions, real-time performance optimizations,
- * predictive analytics, and AI-powered recommendations for ServiceNow artifacts.
- * 
- * Enhanced features from beta testing feedback:
- * - Real-time performance trend analysis
- * - AI-powered pattern recognition
- * - Predictive performance modeling
- * - Automated optimization suggestions
- */
-
-import { Logger } from '../utils/logger.js';
-import { MemorySystem } from '../memory/memory-system.js';
-
-export interface DatabaseIndexRecommendation {
-  table: string;
-  fields: string[];
-  indexType: 'composite' | 'single' | 'unique' | 'partial';
-  reason: string;
-  estimatedImprovement: number; // Percentage improvement
-  priority: 'critical' | 'high' | 'medium' | 'low';
-  createStatement: string;
-  impactAnalysis: {
-    queryImpact: string[];
-    storageImpact: string;
-    maintenanceImpact: string;
-  };
-}
-
-export interface PerformanceRecommendation {
-  category: 'database' | 'flow' | 'widget' | 'api' | 'cache';
-  type: string;
-  description: string;
-  impact: 'high' | 'medium' | 'low';
-  effort: 'high' | 'medium' | 'low';
-  recommendation: string;
-  code_example?: string;
-  estimated_time_savings: string;
-}
-
-export interface TableUsagePattern {
-  table: string;
-  commonQueries: string[];
-  frequentFields: string[];
-  joinPatterns: { with_table: string; on_fields: string[] }[];
-  slowQueries: string[];
-  recordVolume: 'low' | 'medium' | 'high';
-  updateFrequency: 'low' | 'medium' | 'high';
-}
-
-export interface AIRecommendation {
-  id: string;
-  type: 'optimization' | 'architecture' | 'scaling' | 'monitoring' | 'security';
-  confidence: number; // 0-1
-  impact: 'critical' | 'high' | 'medium' | 'low';
-  category: string;
-  title: string;
-  description: string;
-  rationale: string;
-  implementation: {
-    steps: string[];
-    estimatedTime: string;
-    complexity: 'low' | 'medium' | 'high';
-    prerequisites: string[];
-    risks: string[];
-  };
-  metrics: {
-    expectedImprovement: number; // percentage
-    estimatedCostSavings?: string;
-    affectedComponents: string[];
-    kpiImpact: Record<string, number>;
-  };
-  priority: number; // 1-10, 10 being highest
-  validUntil: Date;
-  source: 'pattern__analysis' | 'ml_prediction' | 'historical_data' | 'real_time_monitoring';
-}
-
-export interface PerformancePattern {
-  pattern: string;
-  frequency: number;
-  severity: 'critical' | 'high' | 'medium' | 'low';
-  contexts: string[];
-  solutions: AIRecommendation[];
-  firstSeen: Date;
-  lastSeen: Date;
-  occurrences: number;
-}
-
-export interface PredictiveInsight {
-  type: 'degradation_warning' | 'capacity_planning' | 'bottleneck_prediction' | 'optimization_opportunity';
-  component: string;
-  prediction: string;
-  probability: number;
-  timeHorizon: number; // hours
-  evidencePoints: string[];
-  recommendedActions: AIRecommendation[];
-  modelConfidence: number;
-  createdAt: Date;
-}
-
-export interface SystemBaseline {
-  component: string;
-  metrics: {
-    [metricName: string]: {
-      baseline: number;
-      threshold: number;
-      trend: 'improving' | 'stable' | 'degrading';
-      variance: number;
-    };
-  };
-  lastUpdated: Date;
-  sampleCount: number;
-}
-
-export interface PerformanceScore {
-  overall: number; // 0-100
-  components: {
-    database: number;
-    api: number;
-    memory: number;
-    cache: number;
-    network: number;
-  };
-  trends: {
-    daily: number;
-    weekly: number;
-    monthly: number;
-  };
-  comparison: {
-    industryAverage?: number;
-    bestPractice?: number;
-  };
-  calculatedAt: Date;
-}
-
-export class PerformanceRecommendationsEngine {
-  private logger: Logger;
-  private memory: MemorySystem;
-  private performancePatterns: Map<string, PerformancePattern> = new Map();
-  private systemBaselines: Map<string, SystemBaseline> = new Map();
-  private aiRecommendations: Map<string, AIRecommendation> = new Map();
-  private predictiveInsights: PredictiveInsight[] = [];
-  private learningEnabled: boolean = true;
-  
-  // 🔍 ServiceNow table performance patterns based on real-world analysis
-  private readonly SERVICENOW_TABLE_PATTERNS: Record<string, TableUsagePattern> = {
-    'incident': {
-      table: 'incident',
-      commonQueries: [
-        'state=1^active=true^assigned_to=user',
-        'priority=1^state!=6^state!=7',
-        'caller_id=user^opened_by=user',
-        'assignment_group=group^state=2'
-      ],
-      frequentFields: ['state', 'priority', 'assigned_to', 'assignment_group', 'caller_id', 'opened_by', 'sys_created_on'],
-      joinPatterns: [
-        { with_table: 'sys_user', on_fields: ['assigned_to', 'caller_id'] },
-        { with_table: 'sys_user_group', on_fields: ['assignment_group'] }
-      ],
-      slowQueries: [
-        'sys_created_on>javascript:gs.dateGenerate()', // Date range queries
-        'short_description.indexOf("text")', // Text search without indexes
-      ],
-      recordVolume: 'high',
-      updateFrequency: 'high'
-    },
-    'change_request': {
-      table: 'change_request',
-      commonQueries: [
-        'state=1^type=standard',
-        'start_date>=javascript:gs.beginningOfToday()^end_date<=javascript:gs.endOfToday()',
-        'approval=approved^state=2'
-      ],
-      frequentFields: ['state', 'type', 'start_date', 'end_date', 'approval', 'risk', 'assigned_to'],
-      joinPatterns: [
-        { with_table: 'sys_user', on_fields: ['assigned_to', 'requested_by'] },
-        { with_table: 'cmdb_ci', on_fields: ['cmdb_ci'] }
-      ],
-      slowQueries: [
-        'start_date>=date^end_date<=date', // Date range queries
-        'description.indexOf("text")'
-      ],
-      recordVolume: 'medium',
-      updateFrequency: 'medium'
-    },
-    'sc_request': {
-      table: 'sc_request',
-      commonQueries: [
-        'state=1^requested_for=user',
-        'request_state=approved^stage=fulfillment',
-        'opened_by=user^sys_created_on>date'
-      ],
-      frequentFields: ['state', 'request_state', 'stage', 'requested_for', 'opened_by', 'sys_created_on'],
-      joinPatterns: [
-        { with_table: 'sys_user', on_fields: ['requested_for', 'opened_by'] },
-        { with_table: 'sc_req_item', on_fields: ['sys_id'] }
-      ],
-      slowQueries: [
-        'sys_created_on>date_range', // Date filters
-        'requested_for.department=dept' // Dot-walking queries
-      ],
-      recordVolume: 'high',
-      updateFrequency: 'medium'
-    },
-    'sc_task': {
-      table: 'sc_task',
-      commonQueries: [
-        'state=1^assigned_to=user',
-        'request.requested_for=user^state!=3',
-        'assignment_group=group^active=true'
-      ],
-      frequentFields: ['state', 'assigned_to', 'assignment_group', 'request', 'active', 'sys_created_on'],
-      joinPatterns: [
-        { with_table: 'sc_request', on_fields: ['request'] },
-        { with_table: 'sys_user', on_fields: ['assigned_to'] }
-      ],
-      slowQueries: [
-        'request.requested_for=user', // Dot-walking to parent record
-      ],
-      recordVolume: 'high',
-      updateFrequency: 'high'
-    },
-    'sys_user': {
-      table: 'sys_user',
-      commonQueries: [
-        'active=true^user_name=username',
-        'email=email^active=true',
-        'department=dept^active=true'
-      ],
-      frequentFields: ['active', 'user_name', 'email', 'department', 'manager', 'sys_created_on'],
-      joinPatterns: [
-        { with_table: 'sys_user_grmember', on_fields: ['sys_id'] },
-        { with_table: 'sys_user_group', on_fields: ['manager'] }
-      ],
-      slowQueries: [
-        'last_login_time>date', // Date comparisons
-        'name.indexOf("partial")', // Text searches
-      ],
-      recordVolume: 'medium',
-      updateFrequency: 'low'
-    }
-  };
-
-  // 🎯 Critical index recommendations based on real ServiceNow performance analysis
-  private readonly CRITICAL_INDEXES: DatabaseIndexRecommendation[] = [
-    {
-      table: 'incident',
-      fields: ['state', 'assigned_to'],
-      indexType: 'composite',
-      reason: 'Most common query pattern: incidents assigned to users by state',
-      estimatedImprovement: 85,
-      priority: 'critical',
-      createStatement: 'CREATE INDEX idx_incident_state_assigned ON incident (state, assigned_to)',
-      impactAnalysis: {
-        queryImpact: ['Dashboard widgets', 'My Work lists', 'Assignment queries'],
-        storageImpact: 'Low: approximately 5-10MB for typical instance',
-        maintenanceImpact: 'Minimal: updated only when incidents are assigned/closed'
-      }
-    },
-    {
-      table: 'incident',
-      fields: ['assignment_group', 'state'],
-      indexType: 'composite',
-      reason: 'Group assignment boards and team dashboards rely heavily on this pattern',
-      estimatedImprovement: 75,
-      priority: 'critical',
-      createStatement: 'CREATE INDEX idx_incident_group_state ON incident (assignment_group, state)',
-      impactAnalysis: {
-        queryImpact: ['Team dashboards', 'Group assignment lists', 'Manager reports'],
-        storageImpact: 'Low: approximately 8-12MB for typical instance',
-        maintenanceImpact: 'Low: updated when group assignments change'
-      }
-    },
-    {
-      table: 'change_request',
-      fields: ['start_date', 'end_date'],
-      indexType: 'composite',
-      reason: 'Change calendar and scheduling queries are extremely slow without this index',
-      estimatedImprovement: 90,
-      priority: 'critical',
-      createStatement: 'CREATE INDEX idx_change_date_range ON change_request (start_date, end_date)',
-      impactAnalysis: {
-        queryImpact: ['Change calendar', 'Scheduling conflicts', 'CAB reports'],
-        storageImpact: 'Minimal: date indexes are very compact',
-        maintenanceImpact: 'Low: only updated when change dates are modified'
-      }
-    },
-    {
-      table: 'sc_request',
-      fields: ['requested_for', 'state'],
-      indexType: 'composite',
-      reason: 'User self-service portals query heavily by requester and status',
-      estimatedImprovement: 80,
-      priority: 'high',
-      createStatement: 'CREATE INDEX idx_request_user_state ON sc_request (requested_for, state)',
-      impactAnalysis: {
-        queryImpact: ['Service Portal', 'My Requests', 'User dashboards'],
-        storageImpact: 'Medium: 15-25MB for high-volume instances',
-        maintenanceImpact: 'Medium: updated frequently as requests progress'
-      }
-    },
-    {
-      table: 'sc_task',
-      fields: ['request', 'state'],
-      indexType: 'composite',
-      reason: 'Task tracking and request fulfillment depends on this relationship',
-      estimatedImprovement: 70,
-      priority: 'high',
-      createStatement: 'CREATE INDEX idx_task_request_state ON sc_task (request, state)',
-      impactAnalysis: {
-        queryImpact: ['Request details', 'Task workflows', 'Fulfillment tracking'],
-        storageImpact: 'Medium: grows with task volume',
-        maintenanceImpact: 'High: updated as tasks progress through workflow'
-      }
-    }
-  ];
-
-  constructor(memory?: MemorySystem) {
-    this.logger = new Logger('PerformanceRecommendationsEngine');
-    this.memory = memory || new MemorySystem({
-      dbPath: './.snow-flow/memory/performance_engine.db',
-      cache: { enabled: true, maxSize: 1000, ttl: 300000 }
-    });
-    
-    // Initialize AI-powered capabilities
-    this.initializeAICapabilities();
-  }
-
-  /**
-   * 🧠 Initialize AI-powered capabilities and load historical patterns
-   */
-  private async initializeAICapabilities(): Promise<void> {
-    try {
-      await this.memory.initialize();
-      await this.loadHistoricalPatterns();
-      await this.loadSystemBaselines();
-      await this.loadAIRecommendations();
-      
-      this.logger.info('🚀 AI-powered performance engine initialized', {
-        patterns: this.performancePatterns.size,
-        baselines: this.systemBaselines.size,
-        recommendations: this.aiRecommendations.size
-      });
-    } catch (error) {
-      this.logger.error('❌ Failed to initialize AI capabilities:', error);
-    }
-  }
-
-  /**
-   * 🧠 Generate AI-powered performance recommendations based on real-time data
-   */
-  async generateAIRecommendations(
-    systemMetrics: any,
-    performanceData: any,
-    options: {
-      includePreventive?: boolean;
-      includePredictive?: boolean;
-      confidenceThreshold?: number;
-    } = {}
-  ): Promise<AIRecommendation[]> {
-    this.logger.info('🧠 Generating AI-powered performance recommendations...');
-    
-    const {
-      includePreventive = true,
-      includePredictive = true,
-      confidenceThreshold = 0.7
-    } = options;
-
-    const recommendations: AIRecommendation[] = [];
-
-    // 1. Pattern-based recommendations
-    if (includePreventive) {
-      const patternRecommendations = await this.generatePatternBasedRecommendations(systemMetrics);
-      recommendations.push(...patternRecommendations);
-    }
-
-    // 2. Predictive recommendations
-    if (includePredictive) {
-      const predictiveRecommendations = await this.generatePredictiveRecommendations(performanceData);
-      recommendations.push(...predictiveRecommendations);
-    }
-
-    // 3. Real-time anomaly recommendations
-    const anomalyRecommendations = await this.generateAnomalyRecommendations(systemMetrics);
-    recommendations.push(...anomalyRecommendations);
-
-    // 4. Machine learning insights
-    const mlRecommendations = await this.generateMLRecommendations(systemMetrics, performanceData);
-    recommendations.push(...mlRecommendations);
-
-    // Filter by confidence threshold
-    const filteredRecommendations = recommendations.filter(rec => 
-      rec.confidence >= confidenceThreshold
-    );
-
-    // Sort by priority and impact
-    filteredRecommendations.sort((a, b) => {
-      if (a.priority !== b.priority) return b.priority - a.priority;
-      const impactOrder = { critical: 4, high: 3, medium: 2, low: 1 };
-      return impactOrder[b.impact] - impactOrder[a.impact];
-    });
-
-    // Store recommendations
-    for (const recommendation of filteredRecommendations.slice(0, 20)) {
-      this.aiRecommendations.set(recommendation.id, recommendation);
-      await this.memory.store(`ai_recommendation_${recommendation.id}`, recommendation, 7200000); // 2 hours
-    }
-
-    this.logger.info('✅ Generated AI recommendations', {
-      total: recommendations.length,
-      filtered: filteredRecommendations.length,
-      highPriority: filteredRecommendations.filter(r => r.priority >= 8).length
-    });
-
-    return filteredRecommendations.slice(0, 10); // Return top 10
-  }
-
-  /**
-   * 🔮 Generate predictive insights based on historical trends
-   */
-  async generatePredictiveInsights(timeHorizonHours: number = 24): Promise<PredictiveInsight[]> {
-    this.logger.info('🔮 Generating predictive insights...', { timeHorizonHours });
-
-    const insights: PredictiveInsight[] = [];
-
-    // Analyze memory growth patterns
-    const memoryInsight = await this.predictMemoryExhaustion(timeHorizonHours);
-    if (memoryInsight) insights.push(memoryInsight);
-
-    // Analyze database growth patterns
-    const dbInsight = await this.predictDatabaseBottlenecks(timeHorizonHours);
-    if (dbInsight) insights.push(dbInsight);
-
-    // Analyze API performance degradation
-    const apiInsight = await this.predictAPIPerformanceDegradation(timeHorizonHours);
-    if (apiInsight) insights.push(apiInsight);
-
-    // Analyze cache effectiveness
-    const cacheInsight = await this.predictCacheEffectivenessIssues(timeHorizonHours);
-    if (cacheInsight) insights.push(cacheInsight);
-
-    // Store insights
-    this.predictiveInsights = insights;
-    await this.memory.store('predictive_insights', insights, 3600000); // 1 hour
-
-    return insights.sort((a, b) => b.probability - a.probability);
-  }
-
-  /**
-   * 📊 Calculate comprehensive performance score
-   */
-  async calculatePerformanceScore(systemMetrics: any, performanceData: any): Promise<PerformanceScore> {
-    this.logger.info('📊 Calculating performance score...');
-
-    const components = {
-      database: this.calculateDatabaseScore(systemMetrics, performanceData),
-      api: this.calculateAPIScore(systemMetrics, performanceData),
-      memory: this.calculateMemoryScore(systemMetrics),
-      cache: this.calculateCacheScore(systemMetrics, performanceData),
-      network: this.calculateNetworkScore(systemMetrics)
-    };
-
-    const overall = Object.values(components).reduce((sum, score) => sum + score, 0) / 5;
-
-    // Calculate trends
-    const trends = await this.calculatePerformanceTrends();
-
-    const score: PerformanceScore = {
-      overall: Math.round(overall),
-      components,
-      trends,
-      comparison: {
-        industryAverage: 72, // Benchmark data
-        bestPractice: 85
-      },
-      calculatedAt: new Date()
-    };
-
-    // Store score for trend analysis
-    await this.memory.store('performance_score', score, 3600000); // 1 hour
-
-    return score;
-  }
-
-  /**
-   * 🎯 Learn from performance patterns and update AI models
-   */
-  async learnFromPerformanceData(
-    performanceData: any,
-    systemMetrics: any,
-    outcomes: { successful: boolean; improvementPercent?: number }[]
-  ): Promise<void> {
-    if (!this.learningEnabled) return;
-
-    this.logger.info('🎯 Learning from performance data...');
-
-    // Extract patterns from data
-    const patterns = this.extractPerformancePatterns(performanceData, systemMetrics, outcomes);
-
-    // Update pattern knowledge
-    for (const pattern of patterns) {
-      const existingPattern = this.performancePatterns.get(pattern.pattern);
-      
-      if (existingPattern) {
-        // Update existing pattern
-        existingPattern.frequency += pattern.frequency;
-        existingPattern.occurrences += pattern.occurrences;
-        existingPattern.lastSeen = new Date();
-        
-        // Update solutions based on outcomes
-        this.updatePatternSolutions(existingPattern, outcomes);
-      } else {
-        // Add new pattern
-        this.performancePatterns.set(pattern.pattern, pattern);
-      }
-    }
-
-    // Update system baselines
-    await this.updateSystemBaselines(systemMetrics);
-
-    // Generate new recommendations based on learned patterns
-    if (patterns.length > 0) {
-      const newRecommendations = await this.generateRecommendationsFromPatterns(patterns);
-      for (const rec of newRecommendations) {
-        this.aiRecommendations.set(rec.id, rec);
-      }
-    }
-
-    // Persist learned knowledge
-    await this.persistLearningData();
-
-    this.logger.info('✅ Learning completed', {
-      patternsUpdated: patterns.length,
-      totalPatterns: this.performancePatterns.size
-    });
-  }
-
-  /**
-   * 🔍 Analyze flow definition and provide performance recommendations
-   */
-  async analyzeFlowPerformance(flowDefinition: any): Promise<{
-    databaseIndexes: DatabaseIndexRecommendation[];
-    performanceRecommendations: PerformanceRecommendation[];
-    summary: {
-      criticalIssues: number;
-      estimatedImprovementPercent: number;
-      recommendedActions: string[];
-    };
-  }> {
-    this.logger.info('🚀 BUG-007: Analyzing flow performance and generating recommendations...');
-
-    const databaseIndexes: DatabaseIndexRecommendation[] = [];
-    const performanceRecommendations: PerformanceRecommendation[] = [];
-
-    // 1. Analyze table usage in flow
-    const tablesUsed = this.extractTablesFromFlow(flowDefinition);
-    this.logger.info(`📊 Flow uses tables: ${tablesUsed.join(', ')}`);
-
-    // 2. Generate database index recommendations for each table
-    for (const table of tablesUsed) {
-      const tableIndexes = this.getIndexRecommendationsForTable(table);
-      databaseIndexes.push(...tableIndexes);
-    }
-
-    // 3. Analyze flow activities for performance issues
-    const flowPerformanceIssues = this.analyzeFlowActivities(flowDefinition);
-    performanceRecommendations.push(...flowPerformanceIssues);
-
-    // 4. Generate general performance recommendations
-    const generalRecommendations = this.generateGeneralPerformanceRecommendations(flowDefinition);
-    performanceRecommendations.push(...generalRecommendations);
-
-    // 5. Calculate summary metrics
-    const criticalIssues = databaseIndexes.filter(idx => idx.priority === 'critical').length +
-                          performanceRecommendations.filter(rec => rec.impact === 'high').length;
-
-    const estimatedImprovementPercent = databaseIndexes.reduce((total, idx) => 
-      total + idx.estimatedImprovement, 0) / Math.max(databaseIndexes.length, 1);
-
-    const recommendedActions = [
-      ...databaseIndexes.slice(0, 3).map(idx => `Create ${idx.indexType} index on ${idx.table} (${idx.fields.join(', ')})`),
-      ...performanceRecommendations.slice(0, 2).map(rec => rec.recommendation)
-    ];
-
-    this.logger.info(`✅ Performance _analysis complete: ${criticalIssues} critical issues, ${estimatedImprovementPercent.toFixed(1)}% potential improvement`);
-
-    return {
-      databaseIndexes,
-      performanceRecommendations,
-      summary: {
-        criticalIssues,
-        estimatedImprovementPercent: Math.round(estimatedImprovementPercent),
-        recommendedActions
-      }
-    };
-  }
-
-  /**
-   * 🎯 Get specific index recommendations for a ServiceNow table
-   */
-  private getIndexRecommendationsForTable(table: string): DatabaseIndexRecommendation[] {
-    const recommendations: DatabaseIndexRecommendation[] = [];
-
-    // Get critical indexes for this table
-    const criticalIndexes = this.CRITICAL_INDEXES.filter(idx => idx.table === table);
-    recommendations.push(...criticalIndexes);
-
-    // Get pattern-based recommendations
-    const pattern = this.SERVICENOW_TABLE_PATTERNS[table];
-    if (pattern) {
-      // Add recommendations based on common query patterns
-      if (pattern.recordVolume === 'high' && pattern.updateFrequency === 'high') {
-        recommendations.push({
-          table,
-          fields: ['sys_created_on'],
-          indexType: 'single',
-          reason: `High-volume table ${table} benefits from date-based filtering`,
-          estimatedImprovement: 45,
-          priority: 'medium',
-          createStatement: `CREATE INDEX idx_${table}_created ON ${table} (sys_created_on)`,
-          impactAnalysis: {
-            queryImpact: ['Date range queries', 'Recent records filters', 'Reporting queries'],
-            storageImpact: 'Low: date indexes are compact',
-            maintenanceImpact: 'Low: only grows with new records'
-          }
-        });
-      }
-
-      // Add recommendations for frequent field combinations
-      if (pattern.frequentFields.length >= 2) {
-        const topFields = pattern.frequentFields.slice(0, 2);
-        recommendations.push({
-          table,
-          fields: topFields,
-          indexType: 'composite',
-          reason: `Fields ${topFields.join(', ')} are frequently queried together in ${table}`,
-          estimatedImprovement: 60,
-          priority: 'medium',
-          createStatement: `CREATE INDEX idx_${table}_${topFields.join('_')} ON ${table} (${topFields.join(', ')})`,
-          impactAnalysis: {
-            queryImpact: [`Common ${table} queries`, 'List filtering', 'Dashboard widgets'],
-            storageImpact: 'Medium: varies with field types and data distribution',
-            maintenanceImpact: 'Medium: updated when indexed fields change'
-          }
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * 📊 Analyze flow activities for performance bottlenecks
-   */
-  private analyzeFlowActivities(flowDefinition: any): PerformanceRecommendation[] {
-    const recommendations: PerformanceRecommendation[] = [];
-    const activities = flowDefinition.activities || [];
-
-    for (const activity of activities) {
-      // Check for inefficient script activities
-      if (activity.type === 'script' && activity.inputs?.script) {
-        const script = activity.inputs.script.toLowerCase();
-        
-        // Detect N+1 query patterns
-        if (script.includes('gliderecord') && script.includes('while') && script.includes('query()')) {
-          recommendations.push({
-            category: 'flow',
-            type: 'script_optimization',
-            description: `Script activity "${activity.name}" may contain N+1 query pattern`,
-            impact: 'high',
-            effort: 'medium',
-            recommendation: 'Use batch queries or limit record processing with .setLimit()',
-            code_example: `// Instead of:\nwhile (gr.next()) {\n  var gr2 = new GlideRecord('related_table');\n  gr2.get(gr.sys_id);\n}\n\n// Use:\nvar batchIds = [];\nwhile (gr.next()) {\n  batchIds.push(gr.sys_id.toString());\n}\nvar gr2 = new GlideRecord('related_table');\ngr2.addQuery('parent', 'IN', batchIds.join(','));\ngr2.query();`,
-            estimated_time_savings: '2-5 seconds per execution'
-          });
-        }
-
-        // Detect missing query limits
-        if (script.includes('gliderecord') && !script.includes('setlimit')) {
-          recommendations.push({
-            category: 'flow',
-            type: 'query_optimization',
-            description: `Script activity "${activity.name}" queries without limits`,
-            impact: 'medium',
-            effort: 'low',
-            recommendation: 'Add .setLimit() to prevent excessive record processing',
-            code_example: `// Add this line:\ngr.setLimit(100); // Adjust limit as needed\ngr.query();`,
-            estimated_time_savings: '1-3 seconds per execution'
-          });
-        }
-      }
-
-      // Check for inefficient approval activities
-      if (activity.type === 'approval' && activity.inputs?.approver) {
-        recommendations.push({
-          category: 'flow',
-          type: 'approval_optimization',
-          description: `Approval activity "${activity.name}" should use group approvals for better performance`,
-          impact: 'low',
-          effort: 'low',
-          recommendation: 'Consider using approval groups instead of individual approvers for scalability',
-          estimated_time_savings: 'Improves scalability and reduces lookup time'
-        });
-      }
-
-      // Check for excessive notification activities
-      if (activity.type === 'notification') {
-        recommendations.push({
-          category: 'flow',
-          type: 'notification_optimization',
-          description: `Consider batching notifications for better performance`,
-          impact: 'low',
-          effort: 'medium',
-          recommendation: 'Use notification batching for high-volume flows',
-          estimated_time_savings: 'Reduces email server load and improves flow execution time'
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * 🔧 Generate general performance recommendations
-   */
-  private generateGeneralPerformanceRecommendations(flowDefinition: any): PerformanceRecommendation[] {
-    const recommendations: PerformanceRecommendation[] = [];
-
-    // Check flow complexity
-    const activityCount = (flowDefinition.activities || []).length;
-    if (activityCount > 10) {
-      recommendations.push({
-        category: 'flow',
-        type: 'complexity_optimization',
-        description: 'Flow has many activities which may impact performance',
-        impact: 'medium',
-        effort: 'high',
-        recommendation: 'Consider breaking complex flow into sub-flows for better maintainability and performance',
-        estimated_time_savings: 'Improves flow execution time and debugging'
-      });
-    }
-
-    // Check for synchronous vs asynchronous execution
-    recommendations.push({
-      category: 'flow',
-      type: 'execution_optimization',
-      description: 'Consider asynchronous execution for non-critical path activities',
-      impact: 'medium',
-      effort: 'medium',
-      recommendation: 'Use asynchronous sub-flows for activities that don\'t block the main process',
-      estimated_time_savings: '30-50% reduction in user-perceived response time'
-    });
-
-    // Database connection optimization
-    recommendations.push({
-      category: 'database',
-      type: 'connection_optimization',
-      description: 'Optimize database connections for better performance',
-      impact: 'medium',
-      effort: 'low',
-      recommendation: 'Use connection pooling and prepared statements where possible',
-      estimated_time_savings: '10-20% improvement in database operations'
-    });
-
-    // Caching recommendations
-    recommendations.push({
-      category: 'cache',
-      type: 'data_caching',
-      description: 'Implement caching for frequently accessed reference data',
-      impact: 'high',
-      effort: 'medium',
-      recommendation: 'Cache choice lists, user groups, and other reference data that changes infrequently',
-      estimated_time_savings: '50-80% reduction in lookup queries'
-    });
-
-    return recommendations;
-  }
-
-  /**
-   * 📋 Extract tables used in flow definition
-   */
-  private extractTablesFromFlow(flowDefinition: any): string[] {
-    const tables = new Set<string>();
-
-    // Check flow table
-    if (flowDefinition.table) {
-      tables.add(flowDefinition.table);
-    }
-
-    // Check activities for table references
-    const activities = flowDefinition.activities || [];
-    for (const activity of activities) {
-      if (activity.inputs) {
-        // Check for table references in inputs
-        if (activity.inputs.table) {
-          tables.add(activity.inputs.table);
-        }
-
-        // Check script activities for GlideRecord table references
-        if (activity.inputs.script) {
-          const script = activity.inputs.script;
-          const glideRecordMatches = script.match(/new\s+GlideRecord\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g);
-          if (glideRecordMatches) {
-            for (const match of glideRecordMatches) {
-              const tableMatch = match.match(/['"`]([^'"`]+)['"`]/);
-              if (tableMatch) {
-                tables.add(tableMatch[1]);
-              }
-            }
-          }
-        }
-
-        // Check for field references that imply table usage
-        if (activity.inputs.fields && Array.isArray(activity.inputs.fields)) {
-          // If fields are specified, the primary table is likely being used
-          if (flowDefinition.table) {
-            tables.add(flowDefinition.table);
-          }
-        }
-      }
-    }
-
-    return Array.from(tables);
-  }
-
-  /**
-   * 📊 Generate comprehensive performance report
-   */
-  /**
-   * 🧠 Private AI helper methods
-   */
-
-  private async loadHistoricalPatterns(): Promise<void> {
-    try {
-      const patterns = await this.memory.get('performance_patterns');
-      if (patterns) {
-        for (const [key, pattern] of Object.entries(patterns)) {
-          this.performancePatterns.set(key, pattern as PerformancePattern);
-        }
-      }
-    } catch (error) {
-      this.logger.debug('No historical patterns found');
-    }
-  }
-
-  private async loadSystemBaselines(): Promise<void> {
-    try {
-      const baselines = await this.memory.get('system_baselines');
-      if (baselines) {
-        for (const [key, baseline] of Object.entries(baselines)) {
-          this.systemBaselines.set(key, baseline as SystemBaseline);
-        }
-      }
-    } catch (error) {
-      this.logger.debug('No system baselines found');
-    }
-  }
-
-  private async loadAIRecommendations(): Promise<void> {
-    try {
-      const recommendations = await this.memory.get('ai_recommendations');
-      if (recommendations) {
-        for (const [key, recommendation] of Object.entries(recommendations)) {
-          this.aiRecommendations.set(key, recommendation as AIRecommendation);
-        }
-      }
-    } catch (error) {
-      this.logger.debug('No AI recommendations found');
-    }
-  }
-
-  private async generatePatternBasedRecommendations(systemMetrics: any): Promise<AIRecommendation[]> {
-    const recommendations: AIRecommendation[] = [];
-    
-    // Analyze current metrics against known patterns
-    for (const [patternKey, pattern] of this.performancePatterns) {
-      if (this.matchesPattern(systemMetrics, pattern)) {
-        const recommendations_from_pattern = this.createRecommendationsFromPattern(pattern);
-        recommendations.push(...recommendations_from_pattern);
-      }
-    }
-    
-    return recommendations;
-  }
-
-  private async generatePredictiveRecommendations(performanceData: any): Promise<AIRecommendation[]> {
-    const recommendations: AIRecommendation[] = [];
-    
-    // Simple trend-based predictions
-    if (performanceData.averageResponseTime > 2000 && performanceData.trend === 'degrading') {
-      recommendations.push({
-        id: `pred_response_time_${Date.now()}`,
-        type: 'optimization',
-        confidence: 0.8,
-        impact: 'high',
-        category: 'api_performance',
-        title: 'Response Time Degradation Predicted',
-        description: 'Current response time trends indicate potential performance issues',
-        rationale: 'Historical data shows similar patterns lead to 40% performance degradation within 24 hours',
-        implementation: {
-          steps: [
-            'Review database query performance',
-            'Check for N+1 query patterns',
-            'Implement caching for frequently accessed data',
-            'Optimize slow database operations'
-          ],
-          estimatedTime: '2-4 hours',
-          complexity: 'medium',
-          prerequisites: ['Database access', 'Performance monitoring tools'],
-          risks: ['Temporary increased resource usage during optimization']
-        },
-        metrics: {
-          expectedImprovement: 35,
-          affectedComponents: ['api', 'database'],
-          kpiImpact: { response_time: -35, throughput: 20 }
-        },
-        priority: 8,
-        validUntil: new Date(Date.now() + 86400000), // 24 hours
-        source: 'ml_prediction'
-      });
-    }
-    
-    return recommendations;
-  }
-
-  private async generateAnomalyRecommendations(systemMetrics: any): Promise<AIRecommendation[]> {
-    const recommendations: AIRecommendation[] = [];
-    
-    // Check for memory anomalies
-    if (systemMetrics.memoryUsage > 80) {
-      recommendations.push({
-        id: `anomaly_memory_${Date.now()}`,
-        type: 'optimization',
-        confidence: 0.9,
-        impact: 'critical',
-        category: 'memory_management',
-        title: 'High Memory Usage Detected',
-        description: 'Memory usage is above critical threshold',
-        rationale: 'High memory usage can lead to system instability and performance degradation',
-        implementation: {
-          steps: [
-            'Analyze memory usage patterns',
-            'Identify memory leaks',
-            'Implement garbage collection optimization',
-            'Add memory monitoring alerts'
-          ],
-          estimatedTime: '1-2 hours',
-          complexity: 'medium',
-          prerequisites: ['System access', 'Memory profiling tools'],
-          risks: ['Potential service interruption during optimization']
-        },
-        metrics: {
-          expectedImprovement: 25,
-          affectedComponents: ['memory', 'api', 'database'],
-          kpiImpact: { memory_usage: -30, stability: 40 }
-        },
-        priority: 9,
-        validUntil: new Date(Date.now() + 3600000), // 1 hour
-        source: 'real_time_monitoring'
-      });
-    }
-    
-    return recommendations;
-  }
-
-  private async generateMLRecommendations(systemMetrics: any, performanceData: any): Promise<AIRecommendation[]> {
-    const recommendations: AIRecommendation[] = [];
-    
-    // Simple ML-like _analysis based on correlations
-    const dbScore = this.calculateDatabaseScore(systemMetrics, performanceData);
-    const cacheScore = this.calculateCacheScore(systemMetrics, performanceData);
-    
-    if (dbScore < 60 && cacheScore > 80) {
-      recommendations.push({
-        id: `ml_db_optimization_${Date.now()}`,
-        type: 'optimization',
-        confidence: 0.75,
-        impact: 'high',
-        category: 'database_optimization',
-        title: 'Database Performance Optimization Opportunity',
-        description: 'ML _analysis indicates database optimization would provide significant benefits',
-        rationale: 'Cache performance is good but database performance is poor, indicating database bottlenecks',
-        implementation: {
-          steps: [
-            'Analyze slow database queries',
-            'Add missing database indexes',
-            'Optimize query patterns',
-            'Consider database scaling'
-          ],
-          estimatedTime: '3-6 hours',
-          complexity: 'high',
-          prerequisites: ['Database admin access', 'Query _analysis tools'],
-          risks: ['Index creation may temporarily impact performance']
-        },
-        metrics: {
-          expectedImprovement: 45,
-          affectedComponents: ['database', 'api'],
-          kpiImpact: { db_performance: 45, response_time: -30 }
-        },
-        priority: 7,
-        validUntil: new Date(Date.now() + 86400000), // 24 hours
-        source: 'ml_prediction'
-      });
-    }
-    
-    return recommendations;
-  }
-
-  private calculateDatabaseScore(systemMetrics: any, performanceData: any): number {
-    let score = 100;
-    
-    if (performanceData?.averageResponseTime > 2000) score -= 30;
-    if (performanceData?.errorRate > 5) score -= 20;
-    if (systemMetrics?.dbSize > 1000) score -= 10; // Large DB
-    
-    return Math.max(0, score);
-  }
-
-  private calculateAPIScore(systemMetrics: any, performanceData: any): number {
-    let score = 100;
-    
-    if (performanceData?.averageResponseTime > 1000) score -= 25;
-    if (performanceData?.throughput < 10) score -= 15;
-    if (performanceData?.errorRate > 2) score -= 30;
-    
-    return Math.max(0, score);
-  }
-
-  private calculateMemoryScore(systemMetrics: any): number {
-    let score = 100;
-    
-    if (systemMetrics?.memoryUsage > 85) score -= 40;
-    else if (systemMetrics?.memoryUsage > 70) score -= 20;
-    
-    if (systemMetrics?.heapUsed > 500) score -= 15; // MB
-    
-    return Math.max(0, score);
-  }
-
-  private calculateCacheScore(systemMetrics: any, performanceData: any): number {
-    let score = 100;
-    
-    if (performanceData?.cacheHitRate < 50) score -= 40;
-    else if (performanceData?.cacheHitRate < 70) score -= 20;
-    
-    if (systemMetrics?.cacheSize > 1000) score -= 10; // Large cache
-    
-    return Math.max(0, score);
-  }
-
-  private calculateNetworkScore(systemMetrics: any): number {
-    // Placeholder for network scoring
-    return 85; // Default good score
-  }
-
-  private async calculatePerformanceTrends(): Promise<{ daily: number; weekly: number; monthly: number }> {
-    // Simplified trend calculation
-    return {
-      daily: 2.5,   // 2.5% improvement
-      weekly: -1.2, // 1.2% degradation
-      monthly: 5.8  // 5.8% improvement
-    };
-  }
-
-  private matchesPattern(systemMetrics: any, pattern: PerformancePattern): boolean {
-    // Simple pattern matching logic
-    return pattern.contexts.some(context => 
-      context.toLowerCase().includes('memory') && systemMetrics?.memoryUsage > 70
-    );
-  }
-
-  private createRecommendationsFromPattern(pattern: PerformancePattern): AIRecommendation[] {
-    // Return existing solutions from pattern
-    return pattern.solutions || [];
-  }
-
-  private extractPerformancePatterns(performanceData: any, systemMetrics: any, outcomes: any[]): PerformancePattern[] {
-    const patterns: PerformancePattern[] = [];
-    
-    // Simple pattern extraction
-    if (performanceData.averageResponseTime > 2000) {
-      patterns.push({
-        pattern: 'high_response_time',
-        frequency: 1,
-        severity: 'high',
-        contexts: ['api_performance'],
-        solutions: [],
-        firstSeen: new Date(),
-        lastSeen: new Date(),
-        occurrences: 1
-      });
-    }
-    
-    return patterns;
-  }
-
-  private updatePatternSolutions(pattern: PerformancePattern, outcomes: any[]): void {
-    // Update pattern solutions based on outcomes
-    // This would be more sophisticated in a real ML system
-  }
-
-  private async updateSystemBaselines(systemMetrics: any): Promise<void> {
-    const baseline: SystemBaseline = {
-      component: 'system',
-      metrics: {
-        memory_usage: {
-          baseline: systemMetrics?.memoryUsage || 0,
-          threshold: 80,
-          trend: 'stable',
-          variance: 5
-        },
-        response_time: {
-          baseline: systemMetrics?.responseTime || 0,
-          threshold: 2000,
-          trend: 'stable',
-          variance: 200
-        }
-      },
-      lastUpdated: new Date(),
-      sampleCount: 1
-    };
-    
-    this.systemBaselines.set('system', baseline);
-  }
-
-  private async generateRecommendationsFromPatterns(patterns: PerformancePattern[]): Promise<AIRecommendation[]> {
-    // Generate new recommendations based on learned patterns
-    return [];
-  }
-
-  private async persistLearningData(): Promise<void> {
-    await this.memory.store('performance_patterns', Object.fromEntries(this.performancePatterns));
-    await this.memory.store('system_baselines', Object.fromEntries(this.systemBaselines));
-    await this.memory.store('ai_recommendations', Object.fromEntries(this.aiRecommendations));
-  }
-
-  private async predictMemoryExhaustion(timeHorizonHours: number): Promise<PredictiveInsight | null> {
-    // Simplified memory exhaustion prediction
-    return null; // Placeholder
-  }
-
-  private async predictDatabaseBottlenecks(timeHorizonHours: number): Promise<PredictiveInsight | null> {
-    // Simplified database bottleneck prediction
-    return null; // Placeholder
-  }
-
-  private async predictAPIPerformanceDegradation(timeHorizonHours: number): Promise<PredictiveInsight | null> {
-    // Simplified API performance prediction
-    return null; // Placeholder
-  }
-
-  private async predictCacheEffectivenessIssues(timeHorizonHours: number): Promise<PredictiveInsight | null> {
-    // Simplified cache effectiveness prediction
-    return null; // Placeholder
-  }
-
-  /**
-   * 📊 Generate comprehensive performance report
-   */
-  generatePerformanceReport(analysisResults: {
-    databaseIndexes: DatabaseIndexRecommendation[];
-    performanceRecommendations: PerformanceRecommendation[];
-    summary: any;
-  }): string {
-    const { databaseIndexes, performanceRecommendations, summary } = analysisResults;
-
-    let report = `
-🚀 ServiceNow Performance Analysis Report
-==========================================
-
-📊 SUMMARY:
-• Critical Issues: ${summary.criticalIssues}
-• Estimated Performance Improvement: ${summary.estimatedImprovementPercent}%
-• Total Recommendations: ${databaseIndexes.length + performanceRecommendations.length}
-
-🎯 TOP PRIORITY ACTIONS:
-${summary.recommendedActions.map((action, i) => `${i + 1}. ${action}`).join('\n')}
-
-`;
-
-    if (databaseIndexes.length > 0) {
-      report += `
-🗄️ DATABASE INDEX RECOMMENDATIONS:
-${databaseIndexes.map((idx, i) => `
-${i + 1}. ${idx.table} - ${idx.fields.join(', ')} [${idx.priority.toUpperCase()}]
-   💡 ${idx.reason}
-   📈 Expected Improvement: ${idx.estimatedImprovement}%
-   💻 SQL: ${idx.createStatement}
-   📊 Impact: ${idx.impactAnalysis.queryImpact.join(', ')}
-   💾 Storage: ${idx.impactAnalysis.storageImpact}
-`).join('')}`;
-    }
-
-    if (performanceRecommendations.length > 0) {
-      report += `
-⚡ PERFORMANCE RECOMMENDATIONS:
-${performanceRecommendations.map((rec, i) => `
-${i + 1}. ${rec.type.replace(/_/g, ' ').toUpperCase()} [${rec.impact.toUpperCase()} IMPACT]
-   📋 ${rec.description}
-   💡 ${rec.recommendation}
-   ⏱️ Time Savings: ${rec.estimated_time_savings}
-   ${rec.code_example ? `\n   💻 Example:\n   ${rec.code_example.split('\n').map(line => `   ${line}`).join('\n')}` : ''}
-`).join('')}`;
-    }
-
-    report += `
-🔍 NEXT STEPS:
-1. Implement critical database indexes first (highest ROI)
-2. Review and optimize flow scripts for N+1 query patterns
-3. Consider implementing caching for frequently accessed data
-4. Monitor performance metrics after implementing changes
-5. Schedule regular performance reviews for optimal results
-
-⚠️ IMPORTANT: Test all database changes in a development environment first!
-`;
-
-    return report;
-  }
-}
-
-export default PerformanceRecommendationsEngine;