snow-flow 2.0.2 → 2.0.3

package/src/intelligence/multi-pass-requirements-analyzer.ts

@@ -1,603 +0,0 @@
-/**
- * 🚀 BUG-006 FIX: Multi-Pass Requirements Analyzer
- * 
- * Advanced requirements _analysis with multiple passes to ensure
- * comprehensive coverage and no missed dependencies.
- */
-
-import { Logger } from '../utils/logger.js';
-import { ServiceNowRequirement, RequirementType, RequirementCategory, ObjectiveAnalysis } from './requirements-analyzer.js';
-
-export interface MultiPassAnalysisResult extends ObjectiveAnalysis {
-  analysisPassesData: {
-    pass1_initial: PassAnalysisResult;
-    pass2_dependencies: PassAnalysisResult;
-    pass3_context: PassAnalysisResult;
-    pass4_validation: PassAnalysisResult;
-  };
-  completenessScore: number;
-  confidenceLevel: 'low' | 'medium' | 'high' | 'very_high';
-  missingRequirementsDetected: ServiceNowRequirement[];
-  implicitDependencies: string[];
-  crossDomainImpacts: string[];
-}
-
-export interface PassAnalysisResult {
-  passNumber: number;
-  passName: string;
-  requirementsFound: number;
-  newRequirementsAdded: number;
-  analysisMethod: string;
-  keyFindings: string[];
-  confidence: number;
-  processingTime: number;
-}
-
-export class MultiPassRequirementsAnalyzer {
-  private logger: Logger;
-
-  // 🎯 Enhanced pattern matching with context awareness
-  private readonly CONTEXT_PATTERNS = {
-    // Security Context Implications
-    security_implications: {
-      triggers: ['authentication', 'login', 'secure', 'role', 'permission', 'access'],
-      additional_requirements: ['audit_rule', 'security_policy', 'acl_rule', 'encryption_context', 'session_management']
-    },
-    
-    // Data Integration Context
-    data_integration_context: {
-      triggers: ['import', 'export', 'sync', 'api', 'external', 'integration'],
-      additional_requirements: ['error_handling', 'data_validation', 'logging', 'monitoring', 'backup_recovery']
-    },
-    
-    // User Experience Context
-    user_experience_context: {
-      triggers: ['dashboard', 'portal', 'mobile', 'user interface', 'ui'],
-      additional_requirements: ['responsive_design', 'accessibility', 'performance_optimization', 'user_training']
-    },
-    
-    // Process Automation Context
-    process_automation_context: {
-      triggers: ['workflow', 'approval', 'automation', 'flow', 'process'],
-      additional_requirements: ['error_recovery', 'monitoring', 'audit_trail', 'performance_tracking']
-    },
-    
-    // Compliance Context
-    compliance_context: {
-      triggers: ['audit', 'compliance', 'gdpr', 'sox', 'hipaa', 'regulation'],
-      additional_requirements: ['data_retention', 'audit_logging', 'data_encryption', 'access_logging', 'compliance_reporting']
-    }
-  };
-
-  // 🔍 Dependency mapping for implicit requirements
-  private readonly DEPENDENCY_MATRIX: Record<RequirementType, RequirementType[]> = {
-    // When you create a widget, you typically also need...
-    widget: ['css_include', 'client_script', 'data_source', 'ui_policy'],
-    
-    // When you create a flow, you typically also need...
-    flow: ['business_rule', 'notification', 'error_handling', 'audit_rule'],
-    
-    // When you create user management, you typically also need...
-    user_role: ['acl_rule', 'group_membership', 'audit_rule', 'security_policy'],
-    
-    // When you create API integration, you typically also need...
-    rest_message: ['oauth_provider', 'error_handling', 'logging', 'monitoring'],
-    
-    // When you create approval process, you typically also need...
-    approval_rule: ['notification', 'email_template', 'escalation_rule', 'sla_definition'],
-    
-    // When you create reporting, you typically also need...
-    report: ['data_source', 'scheduled_report', 'dashboard', 'performance_analytics'],
-    
-    // Additional dependencies
-    table: ['dictionary_entry', 'acl_rule', 'ui_policy', 'client_script'],
-    import_set: ['transform_map', 'field_map', 'error_handling', 'data_validation'],
-    workflow: ['notification', 'approval_rule', 'audit_rule', 'error_recovery'],
-    dashboard: ['widget', 'data_source', 'performance_analytics', 'scheduled_refresh']
-  } as any;
-
-  // 🎯 Cross-domain impact analysis
-  private readonly CROSS_DOMAIN_IMPACTS = {
-    security_changes: {
-      affects: ['user_interface', 'data_integration', 'process_automation'],
-      considerations: ['Role updates', 'Permission cascades', 'Authentication flows']
-    },
-    data_structure_changes: {
-      affects: ['reporting_analytics', 'user_interface', 'process_automation'],
-      considerations: ['Report updates', 'Form modifications', 'Workflow adjustments']
-    },
-    process_changes: {
-      affects: ['user_interface', 'reporting_analytics', 'security_compliance'],
-      considerations: ['UI updates', 'Metrics tracking', 'Audit requirements']
-    },
-    integration_changes: {
-      affects: ['security_compliance', 'monitoring_operations', 'data_integration'],
-      considerations: ['Security protocols', 'Error monitoring', 'Data validation']
-    }
-  };
-
-  constructor() {
-    this.logger = new Logger('MultiPassRequirementsAnalyzer');
-  }
-
-  /**
-   * 🔍 Run comprehensive multi-pass analysis
-   */
-  async analyzeRequirements(objective: string): Promise<MultiPassAnalysisResult> {
-    this.logger.info('🚀 BUG-006: Starting multi-pass requirements _analysis', { objective });
-    
-    const startTime = Date.now();
-    const allRequirements: ServiceNowRequirement[] = [];
-
-    // PASS 1: Initial Pattern Matching
-    const pass1Start = Date.now();
-    const pass1Result = await this.pass1_InitialAnalysis(objective);
-    allRequirements.push(...pass1Result.requirements);
-    
-    // PASS 2: Dependency Analysis  
-    const pass2Start = Date.now();
-    const pass2Result = await this.pass2_DependencyAnalysis(objective, allRequirements);
-    allRequirements.push(...pass2Result.newRequirements);
-    
-    // PASS 3: Context & Implication Analysis
-    const pass3Start = Date.now();
-    const pass3Result = await this.pass3_ContextAnalysis(objective, allRequirements);
-    allRequirements.push(...pass3Result.newRequirements);
-    
-    // PASS 4: Validation & Completeness Check
-    const pass4Start = Date.now();
-    const pass4Result = await this.pass4_ValidationAnalysis(objective, allRequirements);
-    allRequirements.push(...pass4Result.newRequirements);
-
-    // Remove duplicates and finalize
-    const finalRequirements = this.deduplicateRequirements(allRequirements);
-    
-    // Calculate metrics
-    const mcpCoveredCount = finalRequirements.filter(req => req.mcpCoverage).length;
-    const gapCount = finalRequirements.length - mcpCoveredCount;
-    const mcpCoveragePercentage = Math.round((mcpCoveredCount / finalRequirements.length) * 100);
-    
-    // Calculate completeness score based on multi-pass findings
-    const completenessScore = this.calculateCompletenessScore(
-      pass1Result, pass2Result, pass3Result, pass4Result
-    );
-    
-    const confidenceLevel = this.determineConfidenceLevel(completenessScore);
-    
-    // Detect cross-domain impacts
-    const crossDomainImpacts = this.analyzeCrossDomainImpacts(finalRequirements);
-    
-    const totalTime = Date.now() - startTime;
-    this.logger.info(`✅ Multi-pass _analysis complete in ${totalTime}ms`, {
-      totalRequirements: finalRequirements.length,
-      mcpCoverage: mcpCoveragePercentage,
-      completenessScore,
-      confidenceLevel
-    });
-
-    return {
-      objective,
-      requirements: finalRequirements,
-      totalRequirements: finalRequirements.length,
-      mcpCoveredCount,
-      gapCount,
-      mcpCoveragePercentage,
-      estimatedComplexity: this.calculateComplexity(finalRequirements),
-      riskAssessment: this.calculateRiskAssessment(finalRequirements),
-      categories: this.extractCategories(finalRequirements),
-      criticalPath: this.identifyCriticalPath(finalRequirements),
-      estimatedDuration: this.estimateDuration(finalRequirements),
-      
-      // Multi-pass specific data
-      analysisPassesData: {
-        pass1_initial: {
-          passNumber: 1,
-          passName: 'Initial Pattern Matching',
-          requirementsFound: pass1Result.requirements.length,
-          newRequirementsAdded: pass1Result.requirements.length,
-          analysisMethod: 'Pattern matching and keyword _analysis',
-          keyFindings: pass1Result.keyFindings,
-          confidence: pass1Result.confidence,
-          processingTime: pass2Start - pass1Start
-        },
-        pass2_dependencies: {
-          passNumber: 2,
-          passName: 'Dependency Analysis',
-          requirementsFound: pass2Result.newRequirements.length,
-          newRequirementsAdded: pass2Result.newRequirements.length,
-          analysisMethod: 'Dependency matrix and prerequisite _analysis',
-          keyFindings: pass2Result.keyFindings,
-          confidence: pass2Result.confidence,
-          processingTime: pass3Start - pass2Start
-        },
-        pass3_context: {
-          passNumber: 3,
-          passName: 'Context & Implications',
-          requirementsFound: pass3Result.newRequirements.length,
-          newRequirementsAdded: pass3Result.newRequirements.length,
-          analysisMethod: 'Context pattern matching and implication _analysis',
-          keyFindings: pass3Result.keyFindings,
-          confidence: pass3Result.confidence,
-          processingTime: pass4Start - pass3Start
-        },
-        pass4_validation: {
-          passNumber: 4,
-          passName: 'Validation & Completeness',
-          requirementsFound: finalRequirements.length,
-          newRequirementsAdded: pass4Result.newRequirements.length,
-          analysisMethod: 'Gap _analysis and completeness validation',
-          keyFindings: pass4Result.keyFindings,
-          confidence: pass4Result.confidence,
-          processingTime: Date.now() - pass4Start
-        }
-      },
-      completenessScore,
-      confidenceLevel,
-      missingRequirementsDetected: pass4Result.newRequirements,
-      implicitDependencies: this.extractImplicitDependencies(finalRequirements),
-      crossDomainImpacts
-    };
-  }
-
-  /**
-   * 🎯 PASS 1: Initial Pattern Matching Analysis
-   */
-  private async pass1_InitialAnalysis(objective: string): Promise<{
-    requirements: ServiceNowRequirement[];
-    keyFindings: string[];
-    confidence: number;
-  }> {
-    this.logger.info('🔍 Pass 1: Initial pattern matching _analysis');
-    
-    const requirements: ServiceNowRequirement[] = [];
-    const keyFindings: string[] = [];
-    const objectiveLower = objective.toLowerCase();
-    
-    // Basic keyword matching (existing logic enhanced)
-    const patterns = [
-      // Core Development
-      { keywords: ['widget', 'portal', 'service portal'], type: 'widget' as RequirementType },
-      { keywords: ['flow', 'workflow', 'process', 'automation'], type: 'flow' as RequirementType },
-      { keywords: ['business rule', 'validation', 'server logic'], type: 'business_rule' as RequirementType },
-      { keywords: ['script include', 'utility', 'function', 'library'], type: 'script_include' as RequirementType },
-      { keywords: ['table', 'record', 'data structure'], type: 'table' as RequirementType },
-      
-      // User Interface
-      { keywords: ['dashboard', 'overview', 'summary'], type: 'dashboard' as RequirementType },
-      { keywords: ['form', 'ui', 'interface'], type: 'ui_policy' as RequirementType },
-      { keywords: ['navigation', 'menu', 'module'], type: 'navigator_module' as RequirementType },
-      
-      // Security & Access
-      { keywords: ['role', 'permission', 'access control'], type: 'user_role' as RequirementType },
-      { keywords: ['security', 'acl', 'access list'], type: 'acl_rule' as RequirementType },
-      { keywords: ['authentication', 'login', 'oauth'], type: 'oauth_provider' as RequirementType },
-      
-      // Integration
-      { keywords: ['api', 'rest', 'web service'], type: 'rest_message' as RequirementType },
-      { keywords: ['import', 'csv', 'excel', 'data load'], type: 'import_set' as RequirementType },
-      { keywords: ['email', 'notification', 'alert'], type: 'notification' as RequirementType },
-      
-      // Process & Automation
-      { keywords: ['approval', 'review', 'authorize'], type: 'approval_rule' as RequirementType },
-      { keywords: ['schedule', 'cron', 'batch'], type: 'scheduled_job' as RequirementType },
-      { keywords: ['sla', 'service level', 'performance'], type: 'sla_definition' as RequirementType },
-      
-      // Reporting
-      { keywords: ['report', 'analytics', 'metrics'], type: 'report' as RequirementType },
-      { keywords: ['kpi', 'performance indicator'], type: 'kpi' as RequirementType },
-      { keywords: ['chart', 'graph', 'visualization'], type: 'chart_configuration' as RequirementType }
-    ];
-    
-    for (const pattern of patterns) {
-      if (pattern.keywords.some(keyword => objectiveLower.includes(keyword))) {
-        const requirement = this.createRequirement(pattern.type, objective);
-        requirements.push(requirement);
-        keyFindings.push(`Detected ${pattern.type} requirement from keywords: ${pattern.keywords.join(', ')}`);
-      }
-    }
-    
-    // Advanced pattern detection for complex scenarios
-    const complexPatterns = this.detectComplexPatterns(objective);
-    requirements.push(...complexPatterns.requirements);
-    keyFindings.push(...complexPatterns.findings);
-    
-    const confidence = Math.min(0.9, 0.3 + (requirements.length * 0.1));
-    
-    this.logger.info(`Pass 1 complete: ${requirements.length} requirements found`);
-    return { requirements, keyFindings, confidence };
-  }
-
-  /**
-   * 🔗 PASS 2: Dependency Analysis
-   */
-  private async pass2_DependencyAnalysis(objective: string, existingRequirements: ServiceNowRequirement[]): Promise<{
-    newRequirements: ServiceNowRequirement[];
-    keyFindings: string[];
-    confidence: number;
-  }> {
-    this.logger.info('🔍 Pass 2: Dependency _analysis');
-    
-    const newRequirements: ServiceNowRequirement[] = [];
-    const keyFindings: string[] = [];
-    const existingTypes = new Set(existingRequirements.map(req => req.type));
-    
-    // Analyze dependencies for each existing requirement
-    for (const requirement of existingRequirements) {
-      const dependencies = this.DEPENDENCY_MATRIX[requirement.type] || [];
-      
-      for (const depType of dependencies) {
-        if (!existingTypes.has(depType)) {
-          const depRequirement = this.createRequirement(depType, objective);
-          depRequirement.dependencies = [requirement.id];
-          depRequirement.description += ` (Required by ${requirement.name})`;
-          
-          newRequirements.push(depRequirement);
-          existingTypes.add(depType);
-          keyFindings.push(`Added ${depType} as dependency of ${requirement.type}`);
-        }
-      }
-    }
-    
-    // Analyze prerequisite chains
-    const prerequisiteAnalysis = this.analyzePrerequisiteChains(existingRequirements);
-    newRequirements.push(...prerequisiteAnalysis.requirements);
-    keyFindings.push(...prerequisiteAnalysis.findings);
-    
-    // Analyze common co-requirements
-    const coRequirementAnalysis = this.analyzeCoRequirements(objective, existingRequirements);
-    newRequirements.push(...coRequirementAnalysis.requirements);
-    keyFindings.push(...coRequirementAnalysis.findings);
-    
-    const confidence = newRequirements.length > 0 ? 0.8 : 0.6;
-    
-    this.logger.info(`Pass 2 complete: ${newRequirements.length} new requirements found`);
-    return { newRequirements, keyFindings, confidence };
-  }
-
-  /**
-   * 🌐 PASS 3: Context & Implication Analysis  
-   */
-  private async pass3_ContextAnalysis(objective: string, existingRequirements: ServiceNowRequirement[]): Promise<{
-    newRequirements: ServiceNowRequirement[];
-    keyFindings: string[];
-    confidence: number;
-  }> {
-    this.logger.info('🔍 Pass 3: Context and implication _analysis');
-    
-    const newRequirements: ServiceNowRequirement[] = [];
-    const keyFindings: string[] = [];
-    const objectiveLower = objective.toLowerCase();
-    
-    // Analyze context patterns
-    for (const [contextName, contextData] of Object.entries(this.CONTEXT_PATTERNS)) {
-      const hasContextTrigger = contextData.triggers.some(trigger => 
-        objectiveLower.includes(trigger)
-      );
-      
-      if (hasContextTrigger) {
-        keyFindings.push(`Detected ${contextName} context`);
-        
-        for (const additionalReq of contextData.additional_requirements) {
-          if (!existingRequirements.some(req => req.type === additionalReq)) {
-            const requirement = this.createRequirement(additionalReq as RequirementType, objective);
-            requirement.description += ` (Context implication: ${contextName})`;
-            newRequirements.push(requirement);
-            keyFindings.push(`Added ${additionalReq} from ${contextName} context`);
-          }
-        }
-      }
-    }
-    
-    // Analyze enterprise vs department scope implications
-    const scopeAnalysis = this.analyzeScopeImplications(objective, existingRequirements);
-    newRequirements.push(...scopeAnalysis.requirements);
-    keyFindings.push(...scopeAnalysis.findings);
-    
-    // Analyze compliance and regulatory implications
-    const complianceAnalysis = this.analyzeComplianceImplications(objective);
-    newRequirements.push(...complianceAnalysis.requirements);
-    keyFindings.push(...complianceAnalysis.findings);
-    
-    const confidence = 0.7;
-    
-    this.logger.info(`Pass 3 complete: ${newRequirements.length} contextual requirements found`);
-    return { newRequirements, keyFindings, confidence };
-  }
-
-  /**
-   * ✅ PASS 4: Validation & Completeness Check
-   */
-  private async pass4_ValidationAnalysis(objective: string, existingRequirements: ServiceNowRequirement[]): Promise<{
-    newRequirements: ServiceNowRequirement[];
-    keyFindings: string[];
-    confidence: number;
-  }> {
-    this.logger.info('🔍 Pass 4: Validation and completeness check');
-    
-    const newRequirements: ServiceNowRequirement[] = [];
-    const keyFindings: string[] = [];
-    
-    // Gap _analysis - check for common missing pieces
-    const gapAnalysis = this.performGapAnalysis(objective, existingRequirements);
-    newRequirements.push(...gapAnalysis.requirements);
-    keyFindings.push(...gapAnalysis.findings);
-    
-    // Validation of requirement completeness
-    const completenessCheck = this.validateRequirementCompleteness(existingRequirements);
-    keyFindings.push(...completenessCheck.findings);
-    
-    // Final quality check
-    const qualityCheck = this.performQualityCheck(existingRequirements);
-    keyFindings.push(...qualityCheck.findings);
-    
-    const confidence = 0.95;
-    
-    this.logger.info(`Pass 4 complete: ${newRequirements.length} validation requirements added`);
-    return { newRequirements, keyFindings, confidence };
-  }
-
-  // Helper methods (implementations would follow similar patterns)
-  private createRequirement(type: RequirementType, objective: string): ServiceNowRequirement {
-    return {
-      id: `req_${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      type,
-      name: `${type.replace(/_/g, ' ').toUpperCase()} for ${objective.substring(0, 50)}...`,
-      description: `ServiceNow ${type} component required for: ${objective}`,
-      priority: 'medium',
-      dependencies: [],
-      estimatedEffort: 'medium',
-      automatable: true,
-      mcpCoverage: ['widget', 'flow', 'business_rule', 'script_include', 'table', 'application'].includes(type),
-      category: this.getCategoryForType(type),
-      riskLevel: 'medium'
-    };
-  }
-
-  private getCategoryForType(type: RequirementType): RequirementCategory {
-    // Mapping logic for requirement categories
-    const categoryMap: Record<string, RequirementCategory> = {
-      widget: 'core_development',
-      flow: 'core_development', 
-      user_role: 'security_compliance',
-      dashboard: 'reporting_analytics',
-      // ... more mappings
-    };
-    return categoryMap[type] || 'core_development';
-  }
-
-  // Additional helper methods would be implemented here...
-  private detectComplexPatterns(objective: string): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for complex pattern detection
-    return { requirements: [], findings: [] };
-  }
-
-  private analyzePrerequisiteChains(requirements: ServiceNowRequirement[]): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for prerequisite analysis
-    return { requirements: [], findings: [] };
-  }
-
-  private analyzeCoRequirements(objective: string, requirements: ServiceNowRequirement[]): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for co-requirement analysis
-    return { requirements: [], findings: [] };
-  }
-
-  private analyzeScopeImplications(objective: string, requirements: ServiceNowRequirement[]): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for scope analysis
-    return { requirements: [], findings: [] };
-  }
-
-  private analyzeComplianceImplications(objective: string): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for compliance analysis
-    return { requirements: [], findings: [] };
-  }
-
-  private performGapAnalysis(objective: string, requirements: ServiceNowRequirement[]): { requirements: ServiceNowRequirement[]; findings: string[] } {
-    // Implementation for gap analysis
-    return { requirements: [], findings: [] };
-  }
-
-  private validateRequirementCompleteness(requirements: ServiceNowRequirement[]): { findings: string[] } {
-    // Implementation for completeness validation
-    return { findings: [] };
-  }
-
-  private performQualityCheck(requirements: ServiceNowRequirement[]): { findings: string[] } {
-    // Implementation for quality check
-    return { findings: [] };
-  }
-
-  private deduplicateRequirements(requirements: ServiceNowRequirement[]): ServiceNowRequirement[] {
-    const seen = new Set<string>();
-    return requirements.filter(req => {
-      const key = `${req.type}_${req.name}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-
-  private calculateCompletenessScore(pass1: any, pass2: any, pass3: any, pass4: any): number {
-    // Calculate completeness based on multiple passes
-    const baseScore = 40;
-    const pass2Bonus = Math.min(30, pass2.newRequirements.length * 5);
-    const pass3Bonus = Math.min(20, pass3.newRequirements.length * 3);
-    const pass4Bonus = Math.min(10, pass4.newRequirements.length * 2);
-    
-    return Math.min(100, baseScore + pass2Bonus + pass3Bonus + pass4Bonus);
-  }
-
-  private determineConfidenceLevel(completenessScore: number): 'low' | 'medium' | 'high' | 'very_high' {
-    if (completenessScore >= 90) return 'very_high';
-    if (completenessScore >= 75) return 'high';
-    if (completenessScore >= 60) return 'medium';
-    return 'low';
-  }
-
-  private analyzeCrossDomainImpacts(requirements: ServiceNowRequirement[]): string[] {
-    const impacts: string[] = [];
-    const categories = new Set(requirements.map(req => req.category));
-    
-    if (categories.has('security_compliance') && categories.has('user_interface')) {
-      impacts.push('Security changes will require UI permission updates');
-    }
-    
-    if (categories.has('data_integration') && categories.has('reporting_analytics')) {
-      impacts.push('Data changes will impact existing reports and dashboards');
-    }
-    
-    return impacts;
-  }
-
-  private extractImplicitDependencies(requirements: ServiceNowRequirement[]): string[] {
-    return requirements
-      .filter(req => req.dependencies.length > 0)
-      .map(req => `${req.name} depends on ${req.dependencies.join(', ')}`)
-      .slice(0, 10); // Limit to top 10
-  }
-
-  private calculateComplexity(requirements: ServiceNowRequirement[]): 'low' | 'medium' | 'high' | 'enterprise' {
-    const totalEffort = requirements.reduce((sum, req) => {
-      const effortMap = { low: 1, medium: 3, high: 5 };
-      return sum + effortMap[req.estimatedEffort];
-    }, 0);
-    
-    if (totalEffort > 50) return 'enterprise';
-    if (totalEffort > 30) return 'high';
-    if (totalEffort > 15) return 'medium';
-    return 'low';
-  }
-
-  private calculateRiskAssessment(requirements: ServiceNowRequirement[]): 'low' | 'medium' | 'high' {
-    const highRiskCount = requirements.filter(req => req.riskLevel === 'high').length;
-    const totalCount = requirements.length;
-    
-    if (highRiskCount / totalCount > 0.3) return 'high';
-    if (highRiskCount / totalCount > 0.1) return 'medium';  
-    return 'low';
-  }
-
-  private extractCategories(requirements: ServiceNowRequirement[]): RequirementCategory[] {
-    return Array.from(new Set(requirements.map(req => req.category)));
-  }
-
-  private identifyCriticalPath(requirements: ServiceNowRequirement[]): string[] {
-    return requirements
-      .filter(req => req.priority === 'high')
-      .map(req => req.name)
-      .slice(0, 5);
-  }
-
-  private estimateDuration(requirements: ServiceNowRequirement[]): string {
-    const totalDays = requirements.reduce((sum, req) => {
-      const effortDays = { low: 1, medium: 3, high: 7 };
-      return sum + effortDays[req.estimatedEffort];
-    }, 0);
-    
-    if (totalDays > 90) return '3+ months';
-    if (totalDays > 30) return '1-3 months';
-    if (totalDays > 7) return '1-4 weeks';
-    return '1-7 days';
-  }
-}
-
-export default MultiPassRequirementsAnalyzer;