snow-flow 1.1.0

package/dist/orchestrator/subflow-creation-handler.js

@@ -0,0 +1,791 @@
+"use strict";
+/**
+ * ServiceNow Subflow Creation Handler
+ *
+ * This module handles the creation of subflows with proper input/output management,
+ * validation, and integration with the main flow composer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubflowCreationHandler = void 0;
+const logger_js_1 = require("../utils/logger.js");
+const servicenow_client_js_1 = require("../utils/servicenow-client.js");
+const flow_subflow_decision_engine_js_1 = require("./flow-subflow-decision-engine.js");
+/**
+ * Subflow Creation Handler
+ */
+class SubflowCreationHandler {
+    constructor() {
+        this.templates = new Map();
+        this.logger = new logger_js_1.Logger('SubflowCreationHandler');
+        this.client = new servicenow_client_js_1.ServiceNowClient();
+        this.initializeTemplates();
+    }
+    /**
+     * Create a subflow from a candidate
+     */
+    async createSubflow(candidate) {
+        this.logger.info('Creating subflow from candidate', { name: candidate.name });
+        try {
+            // Validate the candidate
+            const validationResult = this.validateCandidate(candidate);
+            if (!validationResult.isValid) {
+                return {
+                    success: false,
+                    validationErrors: validationResult.errors
+                };
+            }
+            // Build the subflow definition
+            const subflowDef = this.buildSubflowDefinition(candidate);
+            // Validate the complete definition
+            const defValidation = this.validateSubflowDefinition(subflowDef);
+            if (!defValidation.isValid) {
+                return {
+                    success: false,
+                    validationErrors: defValidation.errors
+                };
+            }
+            // Deploy to ServiceNow
+            const deployResult = await this.deploySubflow(subflowDef);
+            if (!deployResult.success) {
+                return {
+                    success: false,
+                    validationErrors: [deployResult.error || 'Deployment failed']
+                };
+            }
+            // Generate recommendations
+            const recommendations = this.generateRecommendations(subflowDef);
+            return {
+                success: true,
+                subflow: subflowDef,
+                sys_id: deployResult.sys_id,
+                url: deployResult.url,
+                warnings: defValidation.warnings,
+                recommendations
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create subflow', error);
+            return {
+                success: false,
+                validationErrors: [error instanceof Error ? error.message : String(error)]
+            };
+        }
+    }
+    /**
+     * Create multiple subflows from candidates
+     */
+    async createMultipleSubflows(candidates) {
+        this.logger.info('Creating multiple subflows', { count: candidates.length });
+        const results = [];
+        for (const candidate of candidates) {
+            const result = await this.createSubflow(candidate);
+            results.push(result);
+            // Add delay to avoid overwhelming ServiceNow
+            await this.delay(500);
+        }
+        return results;
+    }
+    /**
+     * Build subflow definition from candidate
+     */
+    buildSubflowDefinition(candidate) {
+        const name = this.sanitizeName(candidate.name);
+        const label = candidate.name;
+        // Get template if available
+        const template = this.findMatchingTemplate(candidate);
+        return {
+            name,
+            label,
+            description: candidate.description,
+            category: this.determineCategory(candidate),
+            inputs: this.buildInputDefinitions(candidate.inputs, template),
+            outputs: this.buildOutputDefinitions(candidate.outputs, template),
+            activities: this.buildActivities(candidate, template),
+            connections: this.buildConnections(candidate, template),
+            errorHandling: this.buildErrorHandling(candidate),
+            metadata: {
+                version: '1.0.0',
+                author: 'ServiceNow Multi-Agent System',
+                created: new Date(),
+                updated: new Date(),
+                tags: this.generateTags(candidate),
+                complexity: candidate.complexity,
+                reusability: candidate.reusability,
+                testCoverage: 0,
+                documentation: this.generateDocumentation(candidate),
+                dependencies: [],
+                compatibleVersions: ['Tokyo', 'Utah', 'Vancouver']
+            }
+        };
+    }
+    /**
+     * Build input definitions with enhanced metadata
+     */
+    buildInputDefinitions(inputs, template) {
+        return inputs.map((input, index) => {
+            const baseInput = template?.baseInputs.find(base => base.name === input.name);
+            return {
+                ...input,
+                label: this.generateInputLabel(input.name),
+                category: this.categorizeInput(input),
+                order: index + 1,
+                tooltip: input.description,
+                placeholder: this.generatePlaceholder(input),
+                options: this.generateInputOptions(input),
+                dependsOn: this.findInputDependencies(input, inputs),
+                conditionalLogic: baseInput?.conditionalLogic
+            };
+        });
+    }
+    /**
+     * Build output definitions with enhanced metadata
+     */
+    buildOutputDefinitions(outputs, template) {
+        return outputs.map((output, index) => {
+            const baseOutput = template?.baseOutputs.find(base => base.name === output.name);
+            return {
+                ...output,
+                label: this.generateOutputLabel(output.name),
+                category: this.categorizeOutput(output),
+                order: index + 1,
+                tooltip: output.description,
+                format: this.generateOutputFormat(output),
+                conditionalLogic: baseOutput?.conditionalLogic
+            };
+        });
+    }
+    /**
+     * Build activities for the subflow
+     */
+    buildActivities(candidate, template) {
+        const activities = [];
+        // Add start activity
+        activities.push({
+            id: 'start',
+            name: 'Start',
+            type: 'start',
+            label: 'Start',
+            description: 'Subflow start point',
+            inputs: {},
+            outputs: {},
+            position: { x: 100, y: 100 },
+            configuration: {},
+            errorHandling: []
+        });
+        // Add main processing activities based on actions
+        candidate.actions.forEach((action, index) => {
+            const activityId = `activity_${index + 1}`;
+            const activity = this.createActivityFromAction(action, activityId, index);
+            activities.push(activity);
+        });
+        // Add end activity
+        activities.push({
+            id: 'end',
+            name: 'End',
+            type: 'end',
+            label: 'End',
+            description: 'Subflow end point',
+            inputs: {},
+            outputs: this.buildEndOutputs(candidate.outputs),
+            position: { x: 100 + (candidate.actions.length + 1) * 200, y: 100 },
+            configuration: {},
+            errorHandling: []
+        });
+        return activities;
+    }
+    /**
+     * Build connections between activities
+     */
+    buildConnections(candidate, template) {
+        const connections = [];
+        // Sequential connections
+        let previousId = 'start';
+        candidate.actions.forEach((action, index) => {
+            const currentId = `activity_${index + 1}`;
+            connections.push({
+                id: `connection_${index + 1}`,
+                from: previousId,
+                to: currentId,
+                label: this.generateConnectionLabel(action)
+            });
+            previousId = currentId;
+        });
+        // Final connection to end
+        connections.push({
+            id: 'connection_end',
+            from: previousId,
+            to: 'end',
+            label: 'Complete'
+        });
+        return connections;
+    }
+    /**
+     * Build error handling for the subflow
+     */
+    buildErrorHandling(candidate) {
+        const errorHandling = [];
+        // Global error handler
+        errorHandling.push({
+            id: 'global_error',
+            condition: 'any_activity_failed',
+            action: 'stop',
+            parameters: {
+                message: `Error in ${candidate.name} subflow`,
+                log_level: 'error'
+            },
+            description: 'Handle any unexpected errors'
+        });
+        // Specific error handlers based on complexity
+        if (candidate.complexity === flow_subflow_decision_engine_js_1.ComplexityLevel.HIGH || candidate.complexity === flow_subflow_decision_engine_js_1.ComplexityLevel.VERY_HIGH) {
+            errorHandling.push({
+                id: 'retry_handler',
+                condition: 'temporary_failure',
+                action: 'retry',
+                parameters: {
+                    max_retries: 3,
+                    delay_seconds: 5
+                },
+                description: 'Retry on temporary failures'
+            });
+        }
+        return errorHandling;
+    }
+    /**
+     * Create activity from action string
+     */
+    createActivityFromAction(action, activityId, index) {
+        const activityType = this.mapActionToActivityType(action);
+        return {
+            id: activityId,
+            name: this.generateActivityName(action),
+            type: activityType,
+            label: this.generateActivityLabel(action),
+            description: this.generateActivityDescription(action),
+            inputs: this.generateActivityInputs(action),
+            outputs: this.generateActivityOutputs(action),
+            position: { x: 100 + (index + 1) * 200, y: 100 },
+            configuration: this.generateActivityConfiguration(action),
+            errorHandling: this.generateActivityErrorHandling(action)
+        };
+    }
+    /**
+     * Validate candidate before processing
+     */
+    validateCandidate(candidate) {
+        const errors = [];
+        if (!candidate.name || candidate.name.trim() === '') {
+            errors.push('Subflow name is required');
+        }
+        if (!candidate.description || candidate.description.trim() === '') {
+            errors.push('Subflow description is required');
+        }
+        if (!candidate.actions || candidate.actions.length === 0) {
+            errors.push('At least one action is required');
+        }
+        if (candidate.inputs.length === 0) {
+            errors.push('At least one input parameter is required');
+        }
+        if (candidate.outputs.length === 0) {
+            errors.push('At least one output parameter is required');
+        }
+        // Validate input parameters
+        candidate.inputs.forEach((input, index) => {
+            if (!input.name || input.name.trim() === '') {
+                errors.push(`Input parameter ${index + 1} name is required`);
+            }
+            if (!input.type || input.type.trim() === '') {
+                errors.push(`Input parameter ${index + 1} type is required`);
+            }
+        });
+        // Validate output parameters
+        candidate.outputs.forEach((output, index) => {
+            if (!output.name || output.name.trim() === '') {
+                errors.push(`Output parameter ${index + 1} name is required`);
+            }
+            if (!output.type || output.type.trim() === '') {
+                errors.push(`Output parameter ${index + 1} type is required`);
+            }
+        });
+        return { isValid: errors.length === 0, errors };
+    }
+    /**
+     * Validate complete subflow definition
+     */
+    validateSubflowDefinition(definition) {
+        const errors = [];
+        const warnings = [];
+        // Validate basic structure
+        if (!definition.name || definition.name.trim() === '') {
+            errors.push('Subflow name is required');
+        }
+        if (definition.activities.length < 3) { // start, at least one activity, end
+            errors.push('Subflow must have at least one processing activity');
+        }
+        if (definition.connections.length < 2) { // start->activity, activity->end
+            errors.push('Subflow must have proper connections');
+        }
+        // Validate connections
+        const activityIds = new Set(definition.activities.map(a => a.id));
+        definition.connections.forEach(conn => {
+            if (!activityIds.has(conn.from)) {
+                errors.push(`Connection references unknown activity: ${conn.from}`);
+            }
+            if (!activityIds.has(conn.to)) {
+                errors.push(`Connection references unknown activity: ${conn.to}`);
+            }
+        });
+        // Warnings for best practices
+        if (definition.inputs.length > 10) {
+            warnings.push('Subflow has many input parameters, consider grouping related parameters');
+        }
+        if (definition.outputs.length > 5) {
+            warnings.push('Subflow has many output parameters, consider consolidating outputs');
+        }
+        if (definition.activities.length > 15) {
+            warnings.push('Subflow is complex, consider breaking into smaller subflows');
+        }
+        return { isValid: errors.length === 0, errors, warnings };
+    }
+    /**
+     * Deploy subflow to ServiceNow
+     */
+    async deploySubflow(definition) {
+        try {
+            // Convert to ServiceNow format
+            const serviceNowFormat = this.convertToServiceNowFormat(definition);
+            // Deploy via ServiceNow client (using createFlow for now until createSubflow is implemented)
+            const result = await this.client.createFlow(serviceNowFormat);
+            if (result.success) {
+                return {
+                    success: true,
+                    sys_id: result.data.sys_id,
+                    url: `https://${process.env.SNOW_INSTANCE}/flow_designer.do#/subflow/${result.data.sys_id}`
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: result.error || 'Unknown deployment error'
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Convert subflow definition to ServiceNow format
+     */
+    convertToServiceNowFormat(definition) {
+        return {
+            name: definition.name,
+            label: definition.label,
+            description: definition.description,
+            category: definition.category,
+            active: true,
+            inputs: definition.inputs.map(input => ({
+                name: input.name,
+                label: input.label,
+                type: input.type,
+                mandatory: input.required,
+                description: input.description,
+                default_value: input.defaultValue,
+                tooltip: input.tooltip,
+                options: input.options,
+                order: input.order
+            })),
+            outputs: definition.outputs.map(output => ({
+                name: output.name,
+                label: output.label,
+                type: output.type,
+                description: output.description,
+                order: output.order
+            })),
+            activities: definition.activities.map(activity => ({
+                id: activity.id,
+                name: activity.name,
+                type: activity.type,
+                label: activity.label,
+                description: activity.description,
+                position: activity.position,
+                inputs: activity.inputs,
+                outputs: activity.outputs,
+                configuration: activity.configuration
+            })),
+            connections: definition.connections.map(conn => ({
+                id: conn.id,
+                from: conn.from,
+                to: conn.to,
+                label: conn.label,
+                condition: conn.condition
+            }))
+        };
+    }
+    /**
+     * Generate recommendations for the subflow
+     */
+    generateRecommendations(definition) {
+        const recommendations = [];
+        // Input recommendations
+        if (definition.inputs.length > 5) {
+            recommendations.push('Consider grouping related input parameters into objects');
+        }
+        // Activity recommendations
+        if (definition.activities.length > 10) {
+            recommendations.push('Consider breaking this subflow into smaller, more focused subflows');
+        }
+        // Error handling recommendations
+        if (definition.errorHandling.length === 0) {
+            recommendations.push('Add error handling for better robustness');
+        }
+        // Documentation recommendations
+        if (!definition.metadata.documentation || definition.metadata.documentation.length < 100) {
+            recommendations.push('Add comprehensive documentation for better maintainability');
+        }
+        // Testing recommendations
+        recommendations.push('Create test cases to verify subflow functionality');
+        recommendations.push('Consider adding validation activities for input parameters');
+        return recommendations;
+    }
+    /**
+     * Initialize subflow templates
+     */
+    initializeTemplates() {
+        // Approval template
+        this.templates.set('approval', {
+            name: 'Approval Process',
+            description: 'Standard approval workflow template',
+            category: 'Approval',
+            complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.MEDIUM,
+            baseInputs: [
+                {
+                    name: 'record',
+                    label: 'Record',
+                    type: 'reference',
+                    required: true,
+                    description: 'Record to approve',
+                    category: 'Data',
+                    order: 1
+                },
+                {
+                    name: 'approvers',
+                    label: 'Approvers',
+                    type: 'string',
+                    required: true,
+                    description: 'List of approvers',
+                    category: 'Configuration',
+                    order: 2
+                }
+            ],
+            baseOutputs: [
+                {
+                    name: 'approval_state',
+                    label: 'Approval State',
+                    type: 'string',
+                    description: 'Final approval state',
+                    category: 'Result',
+                    order: 1
+                }
+            ],
+            baseActivities: [],
+            baseConnections: [],
+            customizationPoints: ['approval_logic', 'notification_template', 'timeout_handling']
+        });
+        // Notification template
+        this.templates.set('notification', {
+            name: 'Notification Sender',
+            description: 'Multi-channel notification template',
+            category: 'Communication',
+            complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.LOW,
+            baseInputs: [
+                {
+                    name: 'recipients',
+                    label: 'Recipients',
+                    type: 'string',
+                    required: true,
+                    description: 'Notification recipients',
+                    category: 'Configuration',
+                    order: 1
+                },
+                {
+                    name: 'message',
+                    label: 'Message',
+                    type: 'string',
+                    required: true,
+                    description: 'Notification message',
+                    category: 'Content',
+                    order: 2
+                }
+            ],
+            baseOutputs: [
+                {
+                    name: 'sent_successfully',
+                    label: 'Sent Successfully',
+                    type: 'boolean',
+                    description: 'Whether notification was sent',
+                    category: 'Result',
+                    order: 1
+                }
+            ],
+            baseActivities: [],
+            baseConnections: [],
+            customizationPoints: ['message_template', 'delivery_method', 'retry_logic']
+        });
+    }
+    // Helper methods
+    sanitizeName(name) {
+        return name.toLowerCase().replace(/[^a-z0-9_]/g, '_').replace(/^_+|_+$/g, '');
+    }
+    determineCategory(candidate) {
+        if (candidate.name.toLowerCase().includes('approval'))
+            return 'Approval';
+        if (candidate.name.toLowerCase().includes('notification'))
+            return 'Communication';
+        if (candidate.name.toLowerCase().includes('data'))
+            return 'Data Processing';
+        if (candidate.name.toLowerCase().includes('integration'))
+            return 'Integration';
+        return 'Utility';
+    }
+    findMatchingTemplate(candidate) {
+        const nameKey = candidate.name.toLowerCase();
+        for (const [key, template] of this.templates) {
+            if (nameKey.includes(key)) {
+                return template;
+            }
+        }
+        return undefined;
+    }
+    generateTags(candidate) {
+        const tags = [];
+        tags.push(candidate.complexity.toLowerCase());
+        tags.push(candidate.reusability.toLowerCase());
+        tags.push('auto-generated');
+        return tags;
+    }
+    generateDocumentation(candidate) {
+        return `
+# ${candidate.name}
+
+## Description
+${candidate.description}
+
+## Reason for Creation
+${candidate.reason}
+
+## Complexity Level
+${candidate.complexity}
+
+## Reusability Level
+${candidate.reusability}
+
+## Actions
+${candidate.actions.map(action => `- ${action}`).join('\n')}
+
+## Usage
+This subflow can be used in any flow that requires ${candidate.name.toLowerCase()} functionality.
+
+## Inputs
+${candidate.inputs.map(input => `- **${input.name}** (${input.type}): ${input.description}`).join('\n')}
+
+## Outputs
+${candidate.outputs.map(output => `- **${output.name}** (${output.type}): ${output.description}`).join('\n')}
+    `.trim();
+    }
+    generateInputLabel(name) {
+        return name.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+    }
+    generateOutputLabel(name) {
+        return name.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+    }
+    categorizeInput(input) {
+        if (input.type === 'reference')
+            return 'Data';
+        if (input.name.includes('config') || input.name.includes('setting'))
+            return 'Configuration';
+        if (input.name.includes('message') || input.name.includes('content'))
+            return 'Content';
+        return 'General';
+    }
+    categorizeOutput(output) {
+        if (output.name.includes('result') || output.name.includes('success'))
+            return 'Result';
+        if (output.name.includes('data') || output.name.includes('record'))
+            return 'Data';
+        if (output.name.includes('status') || output.name.includes('state'))
+            return 'Status';
+        return 'General';
+    }
+    generatePlaceholder(input) {
+        switch (input.type) {
+            case 'string': return `Enter ${input.name}`;
+            case 'number': return '0';
+            case 'boolean': return 'true';
+            default: return '';
+        }
+    }
+    generateInputOptions(input) {
+        if (input.name.includes('priority')) {
+            return ['1 - Critical', '2 - High', '3 - Medium', '4 - Low'];
+        }
+        if (input.name.includes('state')) {
+            return ['New', 'In Progress', 'Completed', 'Cancelled'];
+        }
+        return undefined;
+    }
+    findInputDependencies(input, allInputs) {
+        // Simple dependency detection based on naming patterns
+        const dependencies = [];
+        if (input.name.includes('_type') || input.name.includes('_method')) {
+            const baseNames = allInputs.map(i => i.name).filter(name => name !== input.name && input.name.includes(name.split('_')[0]));
+            dependencies.push(...baseNames);
+        }
+        return dependencies;
+    }
+    generateOutputFormat(output) {
+        switch (output.type) {
+            case 'string': return 'text';
+            case 'number': return 'numeric';
+            case 'boolean': return 'true/false';
+            case 'object': return 'json';
+            default: return 'text';
+        }
+    }
+    buildEndOutputs(outputs) {
+        const endOutputs = {};
+        outputs.forEach(output => {
+            endOutputs[output.name] = `\${subflow.${output.name}}`;
+        });
+        return endOutputs;
+    }
+    generateConnectionLabel(action) {
+        return action.charAt(0).toUpperCase() + action.slice(1);
+    }
+    mapActionToActivityType(action) {
+        const actionMap = {
+            'approve': 'approval',
+            'reject': 'approval',
+            'notify': 'notification',
+            'send': 'notification',
+            'create': 'create_record',
+            'update': 'update_record',
+            'delete': 'delete_record',
+            'validate': 'script',
+            'process': 'script',
+            'transform': 'script',
+            'integrate': 'rest',
+            'schedule': 'timer',
+            'assign': 'assignment',
+            'escalate': 'escalation',
+            'complete': 'script',
+            'cancel': 'script',
+            'retry': 'script',
+            'log': 'log',
+            'track': 'script',
+            'monitor': 'script'
+        };
+        return actionMap[action] || 'script';
+    }
+    generateActivityName(action) {
+        return action.charAt(0).toUpperCase() + action.slice(1);
+    }
+    generateActivityLabel(action) {
+        return action.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+    }
+    generateActivityDescription(action) {
+        return `Execute ${action} operation`;
+    }
+    generateActivityInputs(action) {
+        const inputs = {};
+        // Common inputs for all activities
+        inputs.record = '${subflow.record}';
+        // Action-specific inputs
+        switch (action) {
+            case 'approve':
+            case 'reject':
+                inputs.approvers = '${subflow.approvers}';
+                break;
+            case 'notify':
+            case 'send':
+                inputs.recipients = '${subflow.recipients}';
+                inputs.message = '${subflow.message}';
+                break;
+            case 'create':
+            case 'update':
+                inputs.table = '${subflow.table}';
+                inputs.data = '${subflow.data}';
+                break;
+        }
+        return inputs;
+    }
+    generateActivityOutputs(action) {
+        const outputs = {};
+        // Common outputs
+        outputs.success = '${step.success}';
+        // Action-specific outputs
+        switch (action) {
+            case 'approve':
+            case 'reject':
+                outputs.approval_state = '${step.approval_state}';
+                outputs.approved_by = '${step.approved_by}';
+                break;
+            case 'notify':
+            case 'send':
+                outputs.notification_sent = '${step.notification_sent}';
+                break;
+            case 'create':
+                outputs.created_record = '${step.created_record}';
+                break;
+            case 'update':
+                outputs.updated_record = '${step.updated_record}';
+                break;
+        }
+        return outputs;
+    }
+    generateActivityConfiguration(action) {
+        const config = {};
+        switch (action) {
+            case 'approve':
+                config.approval_type = 'sequential';
+                config.timeout = '24 hours';
+                break;
+            case 'notify':
+                config.notification_type = 'email';
+                break;
+            case 'create':
+                config.insert_mode = 'single';
+                break;
+        }
+        return config;
+    }
+    generateActivityErrorHandling(action) {
+        const errorHandling = [];
+        // Common error handling
+        errorHandling.push({
+            condition: 'step.success === false',
+            action: 'stop',
+            parameters: {
+                message: `Failed to execute ${action}`
+            }
+        });
+        // Action-specific error handling
+        if (action === 'approve') {
+            errorHandling.push({
+                condition: 'step.timeout === true',
+                action: 'escalate',
+                parameters: {
+                    escalation_group: 'managers'
+                }
+            });
+        }
+        return errorHandling;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.SubflowCreationHandler = SubflowCreationHandler;
+//# sourceMappingURL=subflow-creation-handler.js.map