snow-flow 3.0.8 → 3.0.10

package/dist/orchestrator/flow-subflow-decision-engine.js

@@ -1,769 +0,0 @@
-"use strict";
-/**
- * ServiceNow Flow vs Subflow Decision Engine
- *
- * This module implements intelligent decision logic to determine when to create
- * flows versus subflows in ServiceNow. It analyzes natural language requirements
- * and provides recommendations based on complexity, reusability, and best practices.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowSubflowDecisionEngine = exports.FlowContext = exports.ReusabilityLevel = exports.ComplexityLevel = exports.FlowType = void 0;
-const logger_js_1 = require("../utils/logger.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-/**
- * Enumeration of flow types
- */
-var FlowType;
-(function (FlowType) {
-    FlowType["MAIN_FLOW"] = "main_flow";
-    FlowType["SUBFLOW"] = "subflow";
-})(FlowType || (exports.FlowType = FlowType = {}));
-/**
- * Complexity levels for flow analysis
- */
-var ComplexityLevel;
-(function (ComplexityLevel) {
-    ComplexityLevel["LOW"] = "low";
-    ComplexityLevel["MEDIUM"] = "medium";
-    ComplexityLevel["HIGH"] = "high";
-    ComplexityLevel["VERY_HIGH"] = "very_high";
-})(ComplexityLevel || (exports.ComplexityLevel = ComplexityLevel = {}));
-/**
- * Reusability assessment
- */
-var ReusabilityLevel;
-(function (ReusabilityLevel) {
-    ReusabilityLevel["NONE"] = "none";
-    ReusabilityLevel["LOW"] = "low";
-    ReusabilityLevel["MEDIUM"] = "medium";
-    ReusabilityLevel["HIGH"] = "high";
-})(ReusabilityLevel || (exports.ReusabilityLevel = ReusabilityLevel = {}));
-/**
- * Flow context types
- */
-var FlowContext;
-(function (FlowContext) {
-    FlowContext["APPROVAL_WORKFLOW"] = "approval_workflow";
-    FlowContext["FULFILLMENT_WORKFLOW"] = "fulfillment_workflow";
-    FlowContext["NOTIFICATION_WORKFLOW"] = "notification_workflow";
-    FlowContext["INTEGRATION_WORKFLOW"] = "integration_workflow";
-    FlowContext["UTILITY_WORKFLOW"] = "utility_workflow";
-    FlowContext["BUSINESS_LOGIC"] = "business_logic";
-})(FlowContext || (exports.FlowContext = FlowContext = {}));
-/**
- * Flow vs Subflow Decision Engine
- */
-class FlowSubflowDecisionEngine {
-    constructor() {
-        this.patterns = [];
-        this.logger = new logger_js_1.Logger('FlowSubflowDecisionEngine');
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.initializePatterns();
-    }
-    /**
-     * Main decision method - analyzes requirements and recommends flow type
-     */
-    async analyzeAndRecommend(instruction) {
-        this.logger.info('Analyzing instruction for flow vs subflow decision', { instruction });
-        // Parse the instruction to extract requirements
-        const parsedRequirements = this.parseRequirements(instruction);
-        // Analyze complexity
-        const complexity = this.analyzeComplexity(parsedRequirements);
-        // Analyze reusability
-        const reusability = this.analyzeReusability(parsedRequirements);
-        // Determine context
-        const context = this.determineContext(parsedRequirements);
-        // Build decision criteria
-        const criteria = this.buildDecisionCriteria(parsedRequirements, complexity, reusability, context);
-        // Make the decision
-        const decision = this.makeDecision(criteria);
-        // Identify subflow candidates
-        const subflowCandidates = this.identifySubflowCandidates(parsedRequirements);
-        // Match patterns
-        const patterns = this.matchPatterns(parsedRequirements, context);
-        // Generate alternatives
-        const alternatives = this.generateAlternatives(criteria);
-        const result = {
-            recommendedType: decision.type,
-            confidence: decision.confidence,
-            rationale: [decision.rationale],
-            criteria,
-            alternatives,
-            patterns,
-            subflowCandidates
-        };
-        this.logger.info('Flow analysis complete', {
-            recommendedType: result.recommendedType,
-            confidence: result.confidence,
-            subflowCandidates: result.subflowCandidates.length
-        });
-        return result;
-    }
-    /**
-     * Parse natural language requirements into structured data
-     */
-    parseRequirements(instruction) {
-        const lowerInstruction = instruction.toLowerCase();
-        return {
-            originalInstruction: instruction,
-            // Action analysis
-            actions: this.extractActions(lowerInstruction),
-            // Logical flow analysis
-            hasConditionalLogic: this.hasConditionalLogic(lowerInstruction),
-            hasLoops: this.hasLoops(lowerInstruction),
-            hasParallelActions: this.hasParallelActions(lowerInstruction),
-            // Integration analysis
-            hasExternalIntegrations: this.hasExternalIntegrations(lowerInstruction),
-            hasDataTransformation: this.hasDataTransformation(lowerInstruction),
-            // Business logic analysis
-            hasBusinessRules: this.hasBusinessRules(lowerInstruction),
-            hasApprovalLogic: this.hasApprovalLogic(lowerInstruction),
-            // Reusability indicators
-            hasReusableComponents: this.hasReusableComponents(lowerInstruction),
-            isUtilityFunction: this.isUtilityFunction(lowerInstruction),
-            // Error handling
-            hasErrorHandling: this.hasErrorHandling(lowerInstruction),
-            // Input/Output analysis
-            inputParameters: this.extractInputParameters(lowerInstruction),
-            outputParameters: this.extractOutputParameters(lowerInstruction),
-            // Context indicators
-            contextIndicators: this.extractContextIndicators(lowerInstruction)
-        };
-    }
-    /**
-     * Analyze complexity based on parsed requirements
-     */
-    analyzeComplexity(requirements) {
-        let complexityScore = 0;
-        // Base complexity from action count
-        complexityScore += Math.min(requirements.actions.length * 0.5, 5);
-        // Logical complexity
-        if (requirements.hasConditionalLogic)
-            complexityScore += 2;
-        if (requirements.hasLoops)
-            complexityScore += 3;
-        if (requirements.hasParallelActions)
-            complexityScore += 2;
-        // Integration complexity
-        if (requirements.hasExternalIntegrations)
-            complexityScore += 3;
-        if (requirements.hasDataTransformation)
-            complexityScore += 2;
-        // Business logic complexity
-        if (requirements.hasBusinessRules)
-            complexityScore += 2;
-        if (requirements.hasApprovalLogic)
-            complexityScore += 3;
-        // Error handling complexity
-        if (requirements.hasErrorHandling)
-            complexityScore += 1;
-        // Parameter complexity
-        complexityScore += Math.min(requirements.inputParameters.length * 0.3, 3);
-        complexityScore += Math.min(requirements.outputParameters.length * 0.3, 3);
-        // Determine complexity level
-        if (complexityScore >= 15)
-            return ComplexityLevel.VERY_HIGH;
-        if (complexityScore >= 10)
-            return ComplexityLevel.HIGH;
-        if (complexityScore >= 5)
-            return ComplexityLevel.MEDIUM;
-        return ComplexityLevel.LOW;
-    }
-    /**
-     * Analyze reusability potential
-     */
-    analyzeReusability(requirements) {
-        let reusabilityScore = 0;
-        // Utility function indicators
-        if (requirements.isUtilityFunction)
-            reusabilityScore += 5;
-        // Reusable component indicators
-        if (requirements.hasReusableComponents)
-            reusabilityScore += 3;
-        // Generic patterns
-        if (this.isGenericPattern(requirements))
-            reusabilityScore += 4;
-        // Common business logic
-        if (requirements.hasBusinessRules && this.isCommonBusinessLogic(requirements))
-            reusabilityScore += 3;
-        // Data transformation utilities
-        if (requirements.hasDataTransformation)
-            reusabilityScore += 2;
-        // Multiple context applicability
-        if (requirements.contextIndicators.length > 1)
-            reusabilityScore += 2;
-        // Determine reusability level
-        if (reusabilityScore >= 12)
-            return ReusabilityLevel.HIGH;
-        if (reusabilityScore >= 8)
-            return ReusabilityLevel.MEDIUM;
-        if (reusabilityScore >= 4)
-            return ReusabilityLevel.LOW;
-        return ReusabilityLevel.NONE;
-    }
-    /**
-     * Determine the flow context
-     */
-    determineContext(requirements) {
-        const contextIndicators = requirements.contextIndicators;
-        if (contextIndicators.includes('approval') || requirements.hasApprovalLogic) {
-            return FlowContext.APPROVAL_WORKFLOW;
-        }
-        if (contextIndicators.includes('fulfillment') || contextIndicators.includes('order')) {
-            return FlowContext.FULFILLMENT_WORKFLOW;
-        }
-        if (contextIndicators.includes('notification') || contextIndicators.includes('email')) {
-            return FlowContext.NOTIFICATION_WORKFLOW;
-        }
-        if (requirements.hasExternalIntegrations) {
-            return FlowContext.INTEGRATION_WORKFLOW;
-        }
-        if (requirements.isUtilityFunction || requirements.hasReusableComponents) {
-            return FlowContext.UTILITY_WORKFLOW;
-        }
-        if (requirements.hasBusinessRules) {
-            return FlowContext.BUSINESS_LOGIC;
-        }
-        return FlowContext.UTILITY_WORKFLOW;
-    }
-    /**
-     * Build comprehensive decision criteria
-     */
-    buildDecisionCriteria(requirements, complexity, reusability, context) {
-        return {
-            complexity,
-            reusability,
-            context,
-            actionCount: requirements.actions.length,
-            inputParameters: requirements.inputParameters.length,
-            outputParameters: requirements.outputParameters.length,
-            businessLogicComplexity: this.calculateBusinessLogicComplexity(requirements),
-            integrationPoints: this.calculateIntegrationPoints(requirements),
-            errorHandlingComplexity: this.calculateErrorHandlingComplexity(requirements),
-            testabilityScore: this.calculateTestabilityScore(requirements),
-            maintainabilityScore: this.calculateMaintainabilityScore(requirements)
-        };
-    }
-    /**
-     * Make the main decision based on criteria
-     */
-    makeDecision(criteria) {
-        const rationale = [];
-        let score = 0;
-        // Complexity scoring (favors subflows for high complexity reusable components)
-        if (criteria.complexity === ComplexityLevel.HIGH || criteria.complexity === ComplexityLevel.VERY_HIGH) {
-            if (criteria.reusability === ReusabilityLevel.HIGH || criteria.reusability === ReusabilityLevel.MEDIUM) {
-                score += 30;
-                rationale.push('High complexity with high reusability favors subflow creation');
-            }
-            else {
-                score -= 10;
-                rationale.push('High complexity with low reusability favors main flow');
-            }
-        }
-        // Reusability scoring
-        if (criteria.reusability === ReusabilityLevel.HIGH) {
-            score += 25;
-            rationale.push('High reusability strongly favors subflow');
-        }
-        else if (criteria.reusability === ReusabilityLevel.MEDIUM) {
-            score += 15;
-            rationale.push('Medium reusability moderately favors subflow');
-        }
-        // Context scoring
-        if (criteria.context === FlowContext.UTILITY_WORKFLOW) {
-            score += 20;
-            rationale.push('Utility workflow context favors subflow');
-        }
-        else if (criteria.context === FlowContext.BUSINESS_LOGIC) {
-            score += 15;
-            rationale.push('Business logic context favors subflow for reusability');
-        }
-        // Action count scoring
-        if (criteria.actionCount >= 10) {
-            score += 10;
-            rationale.push('High action count favors subflow for maintainability');
-        }
-        else if (criteria.actionCount <= 3) {
-            score -= 5;
-            rationale.push('Low action count favors main flow');
-        }
-        // Input/Output parameter scoring
-        if (criteria.inputParameters >= 5 || criteria.outputParameters >= 3) {
-            score += 10;
-            rationale.push('High parameter count favors subflow for clarity');
-        }
-        // Business logic complexity
-        if (criteria.businessLogicComplexity >= 8) {
-            score += 15;
-            rationale.push('Complex business logic favors subflow for separation of concerns');
-        }
-        // Integration points
-        if (criteria.integrationPoints >= 3) {
-            score += 10;
-            rationale.push('Multiple integration points favor subflow for modularity');
-        }
-        // Testability score
-        if (criteria.testabilityScore >= 8) {
-            score += 10;
-            rationale.push('High testability requirements favor subflow');
-        }
-        // Maintainability score
-        if (criteria.maintainabilityScore >= 8) {
-            score += 10;
-            rationale.push('High maintainability requirements favor subflow');
-        }
-        // Determine recommendation based on score
-        const confidence = Math.min(Math.abs(score) / 100, 0.95);
-        if (score >= 30) {
-            return {
-                type: FlowType.SUBFLOW,
-                confidence: confidence,
-                rationale: rationale.join('; '),
-                pros: [
-                    'Improved reusability across multiple flows',
-                    'Better maintainability and testability',
-                    'Clear separation of concerns',
-                    'Reduced code duplication'
-                ],
-                cons: [
-                    'Additional complexity in flow design',
-                    'Potential performance overhead',
-                    'More artifacts to manage'
-                ]
-            };
-        }
-        else {
-            return {
-                type: FlowType.MAIN_FLOW,
-                confidence: confidence,
-                rationale: rationale.join('; ') || 'Simple workflow without complex reusability requirements',
-                pros: [
-                    'Simpler flow design',
-                    'Fewer artifacts to manage',
-                    'Direct execution path',
-                    'Easier debugging'
-                ],
-                cons: [
-                    'Potential code duplication',
-                    'Limited reusability',
-                    'May become complex over time'
-                ]
-            };
-        }
-    }
-    /**
-     * Identify potential subflow candidates within the requirements
-     */
-    identifySubflowCandidates(requirements) {
-        const candidates = [];
-        // Approval logic candidate
-        if (requirements.hasApprovalLogic) {
-            candidates.push({
-                name: 'Approval Process',
-                description: 'Reusable approval workflow with configurable approvers',
-                reason: 'Approval logic is commonly reused across different workflows',
-                complexity: ComplexityLevel.MEDIUM,
-                reusability: ReusabilityLevel.HIGH,
-                inputs: [
-                    {
-                        name: 'record',
-                        type: 'reference',
-                        required: true,
-                        description: 'Record requiring approval'
-                    },
-                    {
-                        name: 'approvers',
-                        type: 'string',
-                        required: true,
-                        description: 'Comma-separated list of approvers'
-                    },
-                    {
-                        name: 'timeout_hours',
-                        type: 'integer',
-                        required: false,
-                        description: 'Approval timeout in hours',
-                        defaultValue: 48
-                    }
-                ],
-                outputs: [
-                    {
-                        name: 'approval_state',
-                        type: 'string',
-                        description: 'Final approval state (approved/rejected/timeout)'
-                    },
-                    {
-                        name: 'approved_by',
-                        type: 'string',
-                        description: 'User who approved the request'
-                    },
-                    {
-                        name: 'approval_comments',
-                        type: 'string',
-                        description: 'Comments from the approver'
-                    }
-                ],
-                actions: ['request_approval', 'check_timeout', 'process_response']
-            });
-        }
-        // Notification candidate
-        if (requirements.contextIndicators.includes('notification') || requirements.contextIndicators.includes('email')) {
-            candidates.push({
-                name: 'Notification Handler',
-                description: 'Reusable notification system with multiple delivery methods',
-                reason: 'Notification logic is commonly reused across different workflows',
-                complexity: ComplexityLevel.LOW,
-                reusability: ReusabilityLevel.HIGH,
-                inputs: [
-                    {
-                        name: 'recipients',
-                        type: 'string',
-                        required: true,
-                        description: 'Recipients for the notification'
-                    },
-                    {
-                        name: 'message_template',
-                        type: 'string',
-                        required: true,
-                        description: 'Message template to use'
-                    },
-                    {
-                        name: 'notification_type',
-                        type: 'string',
-                        required: false,
-                        description: 'Type of notification (email, sms, push)',
-                        defaultValue: 'email'
-                    }
-                ],
-                outputs: [
-                    {
-                        name: 'notification_sent',
-                        type: 'boolean',
-                        description: 'Whether notification was sent successfully'
-                    },
-                    {
-                        name: 'delivery_status',
-                        type: 'string',
-                        description: 'Delivery status details'
-                    }
-                ],
-                actions: ['format_message', 'send_notification', 'track_delivery']
-            });
-        }
-        // Data transformation candidate
-        if (requirements.hasDataTransformation) {
-            candidates.push({
-                name: 'Data Transformer',
-                description: 'Reusable data transformation utility',
-                reason: 'Data transformation logic can be reused across multiple contexts',
-                complexity: ComplexityLevel.MEDIUM,
-                reusability: ReusabilityLevel.MEDIUM,
-                inputs: [
-                    {
-                        name: 'source_data',
-                        type: 'object',
-                        required: true,
-                        description: 'Source data to transform'
-                    },
-                    {
-                        name: 'transformation_rules',
-                        type: 'object',
-                        required: true,
-                        description: 'Rules for data transformation'
-                    }
-                ],
-                outputs: [
-                    {
-                        name: 'transformed_data',
-                        type: 'object',
-                        description: 'Transformed data result'
-                    },
-                    {
-                        name: 'transformation_success',
-                        type: 'boolean',
-                        description: 'Whether transformation was successful'
-                    }
-                ],
-                actions: ['validate_input', 'apply_transformation', 'validate_output']
-            });
-        }
-        // Business rule candidate
-        if (requirements.hasBusinessRules) {
-            candidates.push({
-                name: 'Business Rule Processor',
-                description: 'Reusable business rule evaluation engine',
-                reason: 'Business rules are often reused across different business processes',
-                complexity: ComplexityLevel.HIGH,
-                reusability: ReusabilityLevel.HIGH,
-                inputs: [
-                    {
-                        name: 'business_object',
-                        type: 'object',
-                        required: true,
-                        description: 'Business object to evaluate'
-                    },
-                    {
-                        name: 'rule_set',
-                        type: 'string',
-                        required: true,
-                        description: 'Rule set identifier'
-                    }
-                ],
-                outputs: [
-                    {
-                        name: 'rule_result',
-                        type: 'object',
-                        description: 'Result of rule evaluation'
-                    },
-                    {
-                        name: 'violated_rules',
-                        type: 'array',
-                        description: 'List of violated rules'
-                    }
-                ],
-                actions: ['load_rules', 'evaluate_rules', 'format_results']
-            });
-        }
-        return candidates;
-    }
-    /**
-     * Match known patterns to the requirements
-     */
-    matchPatterns(requirements, context) {
-        return this.patterns.filter(pattern => {
-            // Match by context
-            if (pattern.context === context)
-                return true;
-            // Match by actions
-            const actionMatch = pattern.commonActions.some(action => requirements.actions.some((reqAction) => reqAction.includes(action)));
-            return actionMatch;
-        });
-    }
-    /**
-     * Generate alternative recommendations
-     */
-    generateAlternatives(criteria) {
-        const alternatives = [];
-        // Always provide the opposite recommendation as an alternative
-        if (criteria.reusability === ReusabilityLevel.HIGH) {
-            alternatives.push({
-                type: FlowType.MAIN_FLOW,
-                confidence: 0.3,
-                rationale: 'Direct implementation without subflow abstraction',
-                pros: ['Simpler initial implementation', 'Fewer dependencies'],
-                cons: ['Limited reusability', 'Potential duplication']
-            });
-        }
-        else {
-            alternatives.push({
-                type: FlowType.SUBFLOW,
-                confidence: 0.4,
-                rationale: 'Create subflow for future reusability',
-                pros: ['Future-proof design', 'Easier to test'],
-                cons: ['Over-engineering for current needs', 'Additional complexity']
-            });
-        }
-        return alternatives;
-    }
-    /**
-     * Initialize common flow patterns
-     */
-    initializePatterns() {
-        this.patterns = [
-            {
-                name: 'Approval Workflow',
-                description: 'Standard approval process with configurable approvers',
-                context: FlowContext.APPROVAL_WORKFLOW,
-                recommendedType: FlowType.SUBFLOW,
-                commonActions: ['approve', 'reject', 'timeout'],
-                inputPatterns: ['approvers', 'record', 'timeout'],
-                outputPatterns: ['approval_state', 'approved_by'],
-                complexity: ComplexityLevel.MEDIUM
-            },
-            {
-                name: 'Notification Dispatcher',
-                description: 'Multi-channel notification system',
-                context: FlowContext.NOTIFICATION_WORKFLOW,
-                recommendedType: FlowType.SUBFLOW,
-                commonActions: ['send_email', 'send_sms', 'track_delivery'],
-                inputPatterns: ['recipients', 'message', 'channel'],
-                outputPatterns: ['delivery_status', 'sent_count'],
-                complexity: ComplexityLevel.LOW
-            },
-            {
-                name: 'Order Fulfillment',
-                description: 'Complete order processing workflow',
-                context: FlowContext.FULFILLMENT_WORKFLOW,
-                recommendedType: FlowType.MAIN_FLOW,
-                commonActions: ['validate_order', 'process_payment', 'ship_order'],
-                inputPatterns: ['order', 'customer', 'payment_method'],
-                outputPatterns: ['order_status', 'tracking_number'],
-                complexity: ComplexityLevel.HIGH
-            },
-            {
-                name: 'Data Validation',
-                description: 'Reusable data validation utility',
-                context: FlowContext.UTILITY_WORKFLOW,
-                recommendedType: FlowType.SUBFLOW,
-                commonActions: ['validate_format', 'check_constraints', 'sanitize'],
-                inputPatterns: ['data', 'validation_rules'],
-                outputPatterns: ['is_valid', 'errors'],
-                complexity: ComplexityLevel.LOW
-            },
-            {
-                name: 'Integration Connector',
-                description: 'External system integration pattern',
-                context: FlowContext.INTEGRATION_WORKFLOW,
-                recommendedType: FlowType.SUBFLOW,
-                commonActions: ['authenticate', 'transform_data', 'call_api'],
-                inputPatterns: ['endpoint', 'credentials', 'payload'],
-                outputPatterns: ['response', 'status'],
-                complexity: ComplexityLevel.MEDIUM
-            }
-        ];
-    }
-    // Helper methods for requirement analysis
-    extractActions(instruction) {
-        const actions = [];
-        const actionKeywords = [
-            'approve', 'reject', 'notify', 'send', 'create', 'update', 'delete',
-            'validate', 'process', 'transform', 'integrate', 'schedule', 'assign',
-            'escalate', 'complete', 'cancel', 'retry', 'log', 'track', 'monitor'
-        ];
-        actionKeywords.forEach(keyword => {
-            if (instruction.includes(keyword)) {
-                actions.push(keyword);
-            }
-        });
-        return actions;
-    }
-    hasConditionalLogic(instruction) {
-        return /\b(if|when|unless|condition|check|validate|approve|reject)\b/.test(instruction);
-    }
-    hasLoops(instruction) {
-        return /\b(loop|repeat|iterate|foreach|while|until|retry)\b/.test(instruction);
-    }
-    hasParallelActions(instruction) {
-        return /\b(parallel|concurrent|simultaneously|at the same time)\b/.test(instruction);
-    }
-    hasExternalIntegrations(instruction) {
-        return /\b(api|integration|external|third-party|webhook|service)\b/.test(instruction);
-    }
-    hasDataTransformation(instruction) {
-        return /\b(transform|convert|map|format|parse|serialize)\b/.test(instruction);
-    }
-    hasBusinessRules(instruction) {
-        return /\b(business rule|policy|constraint|validation|compliance)\b/.test(instruction);
-    }
-    hasApprovalLogic(instruction) {
-        return /\b(approval|approve|reject|escalate|manager|supervisor)\b/.test(instruction);
-    }
-    hasReusableComponents(instruction) {
-        return /\b(reuse|common|shared|utility|helper|generic)\b/.test(instruction);
-    }
-    isUtilityFunction(instruction) {
-        return /\b(utility|helper|common|shared|library|function)\b/.test(instruction);
-    }
-    hasErrorHandling(instruction) {
-        return /\b(error|exception|fail|retry|fallback|recovery)\b/.test(instruction);
-    }
-    extractInputParameters(instruction) {
-        const parameters = [];
-        const parameterPatterns = [
-            /with\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
-            /using\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
-            /input\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
-        ];
-        parameterPatterns.forEach(pattern => {
-            let match;
-            while ((match = pattern.exec(instruction)) !== null) {
-                parameters.push(match[1]);
-            }
-        });
-        return parameters;
-    }
-    extractOutputParameters(instruction) {
-        const parameters = [];
-        const parameterPatterns = [
-            /returns?\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
-            /output\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
-            /result\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
-        ];
-        parameterPatterns.forEach(pattern => {
-            let match;
-            while ((match = pattern.exec(instruction)) !== null) {
-                parameters.push(match[1]);
-            }
-        });
-        return parameters;
-    }
-    extractContextIndicators(instruction) {
-        const indicators = [];
-        const contextKeywords = [
-            'approval', 'fulfillment', 'notification', 'integration', 'utility',
-            'business', 'order', 'catalog', 'incident', 'problem', 'change'
-        ];
-        contextKeywords.forEach(keyword => {
-            if (instruction.includes(keyword)) {
-                indicators.push(keyword);
-            }
-        });
-        return indicators;
-    }
-    isGenericPattern(requirements) {
-        return requirements.isUtilityFunction ||
-            requirements.hasReusableComponents ||
-            requirements.contextIndicators.length > 2;
-    }
-    isCommonBusinessLogic(requirements) {
-        const commonLogicPatterns = ['approval', 'validation', 'notification', 'assignment'];
-        return commonLogicPatterns.some(pattern => requirements.contextIndicators.includes(pattern));
-    }
-    calculateBusinessLogicComplexity(requirements) {
-        let complexity = 0;
-        if (requirements.hasBusinessRules)
-            complexity += 3;
-        if (requirements.hasApprovalLogic)
-            complexity += 2;
-        if (requirements.hasConditionalLogic)
-            complexity += 2;
-        if (requirements.hasLoops)
-            complexity += 3;
-        return complexity;
-    }
-    calculateIntegrationPoints(requirements) {
-        let points = 0;
-        if (requirements.hasExternalIntegrations)
-            points += 2;
-        if (requirements.hasDataTransformation)
-            points += 1;
-        return points;
-    }
-    calculateErrorHandlingComplexity(requirements) {
-        return requirements.hasErrorHandling ? 3 : 0;
-    }
-    calculateTestabilityScore(requirements) {
-        let score = 5; // Base score
-        if (requirements.inputParameters.length > 0)
-            score += 2;
-        if (requirements.outputParameters.length > 0)
-            score += 2;
-        if (requirements.hasBusinessRules)
-            score += 1;
-        return Math.min(score, 10);
-    }
-    calculateMaintainabilityScore(requirements) {
-        let score = 5; // Base score
-        if (requirements.actions.length > 5)
-            score += 2;
-        if (requirements.hasBusinessRules)
-            score += 1;
-        if (requirements.hasErrorHandling)
-            score += 1;
-        if (requirements.hasReusableComponents)
-            score += 1;
-        return Math.min(score, 10);
-    }
-}
-exports.FlowSubflowDecisionEngine = FlowSubflowDecisionEngine;
-//# sourceMappingURL=flow-subflow-decision-engine.js.map