snow-flow 3.0.8 → 3.0.10

package/dist/orchestrator/flow-pattern-templates.js

@@ -1,908 +0,0 @@
-"use strict";
-/**
- * ServiceNow Flow Pattern Templates
- *
- * This module provides a comprehensive collection of flow pattern templates
- * for common ServiceNow scenarios, helping users create consistent and
- * well-structured flows and subflows.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowPatternTemplates = void 0;
-const logger_js_1 = require("../utils/logger.js");
-const flow_subflow_decision_engine_js_1 = require("./flow-subflow-decision-engine.js");
-/**
- * Flow Pattern Templates Manager
- */
-class FlowPatternTemplates {
-    constructor() {
-        this.templates = new Map();
-        this.subflowTemplates = new Map();
-        this.patterns = [];
-        this.logger = new logger_js_1.Logger('FlowPatternTemplates');
-        this.initializeTemplates();
-        this.initializePatterns();
-    }
-    /**
-     * Find matching templates based on natural language instruction
-     */
-    findMatchingTemplates(instruction) {
-        this.logger.info('Finding matching templates', { instruction });
-        const results = [];
-        const lowerInstruction = instruction.toLowerCase();
-        for (const [id, template] of this.templates) {
-            const matchResult = this.matchTemplate(template, lowerInstruction, instruction);
-            if (matchResult.confidence > 0.3) {
-                results.push(matchResult);
-            }
-        }
-        // Sort by confidence score
-        results.sort((a, b) => b.confidence - a.confidence);
-        this.logger.info('Found matching templates', { count: results.length });
-        return results;
-    }
-    /**
-     * Get template by ID
-     */
-    getTemplate(id) {
-        return this.templates.get(id);
-    }
-    /**
-     * Get all templates by category
-     */
-    getTemplatesByCategory(category) {
-        return Array.from(this.templates.values()).filter(template => template.category === category);
-    }
-    /**
-     * Get all templates by context
-     */
-    getTemplatesByContext(context) {
-        return Array.from(this.templates.values()).filter(template => template.context === context);
-    }
-    /**
-     * Get recommended templates for a specific complexity level
-     */
-    getTemplatesByComplexity(complexity) {
-        return Array.from(this.templates.values()).filter(template => template.complexity === complexity);
-    }
-    /**
-     * Get all available templates
-     */
-    getAllTemplates() {
-        return Array.from(this.templates.values());
-    }
-    /**
-     * Get subflow candidates from a template
-     */
-    getSubflowCandidates(template) {
-        return template.activities.filter(activity => activity.isSubflowCandidate);
-    }
-    /**
-     * Generate flow from template
-     */
-    generateFlowFromTemplate(template, customizations = {}) {
-        this.logger.info('Generating flow from template', {
-            templateId: template.id,
-            customizations: Object.keys(customizations)
-        });
-        const flowDefinition = {
-            name: customizations.name || template.name,
-            description: customizations.description || template.description,
-            category: template.category,
-            type: 'flow', // Explicitly set as flow, not subflow
-            flow_type: 'flow',
-            active: true,
-            // Apply trigger template
-            trigger: this.applyTriggerTemplate(template.triggers[0], customizations),
-            // Apply activity templates
-            activities: template.activities.map(activityTemplate => this.applyActivityTemplate(activityTemplate, customizations)),
-            // Apply connection templates
-            connections: template.connections.map(connectionTemplate => this.applyConnectionTemplate(connectionTemplate, customizations)),
-            // Apply variable templates
-            variables: template.variables.map(variableTemplate => this.applyVariableTemplate(variableTemplate, customizations)),
-            // Metadata
-            metadata: {
-                templateId: template.id,
-                templateVersion: template.version,
-                customizations: customizations,
-                generatedAt: new Date().toISOString()
-            }
-        };
-        return flowDefinition;
-    }
-    /**
-     * Match template against instruction
-     */
-    matchTemplate(template, lowerInstruction, originalInstruction) {
-        let confidence = 0;
-        const matchingReasons = [];
-        const customizationSuggestions = [];
-        const subflowRecommendations = [];
-        // Keywords matching
-        const keywordMatches = template.tags.filter(tag => lowerInstruction.includes(tag.toLowerCase()));
-        if (keywordMatches.length > 0) {
-            confidence += 0.3 * (keywordMatches.length / template.tags.length);
-            matchingReasons.push(`Keywords match: ${keywordMatches.join(', ')}`);
-        }
-        // Context matching
-        const contextKeywords = this.getContextKeywords(template.context);
-        const contextMatches = contextKeywords.filter(keyword => lowerInstruction.includes(keyword));
-        if (contextMatches.length > 0) {
-            confidence += 0.4;
-            matchingReasons.push(`Context match: ${template.context}`);
-        }
-        // Use case matching
-        const useCaseMatches = template.useCases.filter(useCase => lowerInstruction.includes(useCase.toLowerCase()));
-        if (useCaseMatches.length > 0) {
-            confidence += 0.2;
-            matchingReasons.push(`Use case match: ${useCaseMatches.join(', ')}`);
-        }
-        // Activity type matching
-        const activityMatches = template.activities.filter(activity => lowerInstruction.includes(activity.type.toLowerCase()) ||
-            lowerInstruction.includes(activity.name.toLowerCase()));
-        if (activityMatches.length > 0) {
-            confidence += 0.1;
-            matchingReasons.push(`Activity match: ${activityMatches.map(a => a.name).join(', ')}`);
-        }
-        // Generate customization suggestions
-        if (confidence > 0.5) {
-            customizationSuggestions.push(...this.generateCustomizationSuggestions(template, originalInstruction));
-        }
-        // Generate subflow recommendations
-        const subflowCandidates = this.getSubflowCandidates(template);
-        if (subflowCandidates.length > 0) {
-            subflowRecommendations.push(...subflowCandidates.map(candidate => `Consider creating ${candidate.name} as a reusable subflow`));
-        }
-        return {
-            template,
-            confidence: Math.min(confidence, 1.0),
-            matchingReasons,
-            customizationSuggestions,
-            subflowRecommendations
-        };
-    }
-    /**
-     * Get context keywords for matching
-     */
-    getContextKeywords(context) {
-        const keywords = {
-            [flow_subflow_decision_engine_js_1.FlowContext.APPROVAL_WORKFLOW]: ['approval', 'approve', 'reject', 'escalate'],
-            [flow_subflow_decision_engine_js_1.FlowContext.FULFILLMENT_WORKFLOW]: ['fulfillment', 'order', 'catalog', 'request'],
-            [flow_subflow_decision_engine_js_1.FlowContext.NOTIFICATION_WORKFLOW]: ['notification', 'email', 'alert', 'message'],
-            [flow_subflow_decision_engine_js_1.FlowContext.INTEGRATION_WORKFLOW]: ['integration', 'api', 'external', 'sync'],
-            [flow_subflow_decision_engine_js_1.FlowContext.UTILITY_WORKFLOW]: ['utility', 'helper', 'common', 'shared'],
-            [flow_subflow_decision_engine_js_1.FlowContext.BUSINESS_LOGIC]: ['business', 'rule', 'policy', 'validation']
-        };
-        return keywords[context] || [];
-    }
-    /**
-     * Generate customization suggestions
-     */
-    generateCustomizationSuggestions(template, instruction) {
-        const suggestions = [];
-        // Check for specific entities mentioned in instruction
-        if (instruction.includes('iPhone')) {
-            suggestions.push('Customize for iPhone-specific catalog items');
-        }
-        if (instruction.includes('admin')) {
-            suggestions.push('Configure admin-specific assignment rules');
-        }
-        if (instruction.includes('manager')) {
-            suggestions.push('Set up manager approval hierarchy');
-        }
-        // Check customization points
-        for (const point of template.customizationPoints) {
-            if (point.impact === 'high') {
-                suggestions.push(`Configure ${point.name}: ${point.description}`);
-            }
-        }
-        return suggestions;
-    }
-    /**
-     * Apply trigger template
-     */
-    applyTriggerTemplate(triggerTemplate, customizations) {
-        return {
-            type: customizations.triggerType || triggerTemplate.type,
-            table: customizations.table || triggerTemplate.table,
-            condition: customizations.condition || triggerTemplate.condition,
-            schedule: customizations.schedule || triggerTemplate.schedule,
-            configuration: {
-                ...triggerTemplate.configuration,
-                ...customizations.triggerConfiguration
-            }
-        };
-    }
-    /**
-     * Apply activity template
-     */
-    applyActivityTemplate(activityTemplate, customizations) {
-        const activityCustomizations = customizations.activities?.[activityTemplate.id] || {};
-        return {
-            id: activityTemplate.id,
-            name: activityCustomizations.name || activityTemplate.name,
-            type: activityCustomizations.type || activityTemplate.type,
-            label: activityCustomizations.label || activityTemplate.label,
-            description: activityCustomizations.description || activityTemplate.description,
-            inputs: activityTemplate.inputs.map(input => ({
-                name: input.name,
-                type: input.type,
-                required: input.required,
-                value: activityCustomizations.inputs?.[input.name] ||
-                    this.resolveInputValue(input, customizations)
-            })),
-            outputs: activityTemplate.outputs.map(output => ({
-                name: output.name,
-                type: output.type,
-                description: output.description
-            })),
-            configuration: {
-                ...activityTemplate.configuration,
-                ...activityCustomizations.configuration
-            },
-            position: activityTemplate.position,
-            errorHandling: activityTemplate.errorHandling
-        };
-    }
-    /**
-     * Apply connection template
-     */
-    applyConnectionTemplate(connectionTemplate, customizations) {
-        const connectionCustomizations = customizations.connections?.[connectionTemplate.id] || {};
-        return {
-            id: connectionTemplate.id,
-            from: connectionTemplate.from,
-            to: connectionTemplate.to,
-            label: connectionCustomizations.label || connectionTemplate.label,
-            condition: connectionCustomizations.condition || connectionTemplate.condition,
-            conditionType: connectionTemplate.conditionType
-        };
-    }
-    /**
-     * Apply variable template
-     */
-    applyVariableTemplate(variableTemplate, customizations) {
-        const variableCustomizations = customizations.variables?.[variableTemplate.name] || {};
-        return {
-            name: variableTemplate.name,
-            type: variableTemplate.type,
-            description: variableTemplate.description,
-            defaultValue: variableCustomizations.defaultValue || variableTemplate.defaultValue,
-            scope: variableTemplate.scope,
-            category: variableTemplate.category
-        };
-    }
-    /**
-     * Resolve input value based on source type
-     */
-    resolveInputValue(input, customizations) {
-        switch (input.sourceType) {
-            case 'trigger':
-                return `\${trigger.${input.sourceReference || input.name}}`;
-            case 'variable':
-                return `\${flow.${input.sourceReference || input.name}}`;
-            case 'previous_activity':
-                return `\${${input.sourceReference}.${input.name}}`;
-            case 'constant':
-                return customizations.constants?.[input.name] || input.defaultValue;
-            default:
-                return input.defaultValue;
-        }
-    }
-    /**
-     * Initialize flow templates
-     */
-    initializeTemplates() {
-        // iPhone 6 Approval and Fulfillment Template
-        this.templates.set('iphone-approval-fulfillment', {
-            id: 'iphone-approval-fulfillment',
-            name: 'iPhone 6 Approval and Fulfillment',
-            description: 'Complete workflow for iPhone 6 catalog requests with approval and fulfillment',
-            category: 'Catalog Management',
-            context: flow_subflow_decision_engine_js_1.FlowContext.FULFILLMENT_WORKFLOW,
-            recommendedType: flow_subflow_decision_engine_js_1.FlowType.MAIN_FLOW,
-            complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.HIGH,
-            reusability: flow_subflow_decision_engine_js_1.ReusabilityLevel.MEDIUM,
-            triggers: [{
-                    id: 'catalog_request_trigger',
-                    type: 'record_created',
-                    table: 'sc_req_item',
-                    condition: 'cat_item.name=iPhone 6',
-                    description: 'Trigger when iPhone 6 catalog item is requested',
-                    configuration: {
-                        filter: 'cat_item.name=iPhone 6',
-                        active: true
-                    }
-                }],
-            activities: [
-                {
-                    id: 'approval_check',
-                    name: 'Manager Approval',
-                    type: 'approval',
-                    label: 'Manager Approval',
-                    description: 'Get manager approval for iPhone 6 request',
-                    category: 'Approval',
-                    isSubflowCandidate: true,
-                    reusabilityScore: 8,
-                    inputs: [
-                        {
-                            name: 'record',
-                            type: 'reference',
-                            required: true,
-                            description: 'Catalog request record',
-                            sourceType: 'trigger',
-                            sourceReference: 'current'
-                        },
-                        {
-                            name: 'approver',
-                            type: 'reference',
-                            required: true,
-                            description: 'Manager to approve request',
-                            sourceType: 'trigger',
-                            sourceReference: 'current.requested_for.manager'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'approval_state',
-                            type: 'string',
-                            description: 'Approval result (approved/rejected)',
-                            usedByActivities: ['fulfillment_check'],
-                            isFlowOutput: false
-                        }
-                    ],
-                    configuration: {
-                        approval_type: 'manager',
-                        timeout: '48 hours'
-                    },
-                    errorHandling: [{
-                            condition: 'timeout',
-                            action: 'notify',
-                            parameters: { escalation_group: 'catalog_admins' },
-                            description: 'Notify admins on approval timeout'
-                        }],
-                    position: { x: 200, y: 100 },
-                    dependencies: [],
-                    prerequisites: []
-                },
-                {
-                    id: 'fulfillment_check',
-                    name: 'Fulfillment Decision',
-                    type: 'condition',
-                    label: 'Check Approval',
-                    description: 'Check if request was approved',
-                    category: 'Decision',
-                    isSubflowCandidate: false,
-                    reusabilityScore: 3,
-                    inputs: [
-                        {
-                            name: 'approval_state',
-                            type: 'string',
-                            required: true,
-                            description: 'Approval state from previous step',
-                            sourceType: 'previous_activity',
-                            sourceReference: 'approval_check'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'proceed_to_fulfillment',
-                            type: 'boolean',
-                            description: 'Whether to proceed with fulfillment',
-                            usedByActivities: ['admin_task', 'user_task'],
-                            isFlowOutput: false
-                        }
-                    ],
-                    configuration: {
-                        condition: 'approval_state=approved'
-                    },
-                    errorHandling: [],
-                    position: { x: 400, y: 100 },
-                    dependencies: ['approval_check'],
-                    prerequisites: []
-                },
-                {
-                    id: 'admin_task',
-                    name: 'Create Admin Task',
-                    type: 'create_task',
-                    label: 'Admin Preparation',
-                    description: 'Create task for admin to prepare iPhone 6',
-                    category: 'Task Management',
-                    isSubflowCandidate: true,
-                    reusabilityScore: 7,
-                    inputs: [
-                        {
-                            name: 'parent_record',
-                            type: 'reference',
-                            required: true,
-                            description: 'Parent catalog request',
-                            sourceType: 'trigger',
-                            sourceReference: 'current'
-                        },
-                        {
-                            name: 'assigned_to',
-                            type: 'reference',
-                            required: true,
-                            description: 'Admin to assign task to',
-                            sourceType: 'constant',
-                            defaultValue: 'admin_group'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'admin_task_id',
-                            type: 'string',
-                            description: 'Created admin task ID',
-                            usedByActivities: ['user_task'],
-                            isFlowOutput: false
-                        }
-                    ],
-                    configuration: {
-                        task_type: 'admin_pickup',
-                        priority: 'medium',
-                        short_description: 'Prepare iPhone 6 for user pickup'
-                    },
-                    errorHandling: [{
-                            condition: 'creation_failed',
-                            action: 'retry',
-                            parameters: { max_retries: 3 },
-                            description: 'Retry task creation on failure'
-                        }],
-                    position: { x: 600, y: 50 },
-                    dependencies: ['fulfillment_check'],
-                    prerequisites: ['approval_check']
-                },
-                {
-                    id: 'user_task',
-                    name: 'Create User Task',
-                    type: 'create_task',
-                    label: 'User Pickup',
-                    description: 'Create task for user to pick up iPhone 6',
-                    category: 'Task Management',
-                    isSubflowCandidate: true,
-                    reusabilityScore: 6,
-                    inputs: [
-                        {
-                            name: 'parent_record',
-                            type: 'reference',
-                            required: true,
-                            description: 'Parent catalog request',
-                            sourceType: 'trigger',
-                            sourceReference: 'current'
-                        },
-                        {
-                            name: 'assigned_to',
-                            type: 'reference',
-                            required: true,
-                            description: 'User to assign task to',
-                            sourceType: 'trigger',
-                            sourceReference: 'current.requested_for'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'user_task_id',
-                            type: 'string',
-                            description: 'Created user task ID',
-                            usedByActivities: ['notification'],
-                            isFlowOutput: false
-                        }
-                    ],
-                    configuration: {
-                        task_type: 'user_pickup',
-                        priority: 'medium',
-                        short_description: 'Pick up your iPhone 6 from admin desk'
-                    },
-                    errorHandling: [{
-                            condition: 'creation_failed',
-                            action: 'retry',
-                            parameters: { max_retries: 3 },
-                            description: 'Retry task creation on failure'
-                        }],
-                    position: { x: 600, y: 150 },
-                    dependencies: ['fulfillment_check'],
-                    prerequisites: ['approval_check']
-                },
-                {
-                    id: 'notification',
-                    name: 'Send Notification',
-                    type: 'notification',
-                    label: 'Notify User',
-                    description: 'Send notification to user about iPhone 6 availability',
-                    category: 'Communication',
-                    isSubflowCandidate: true,
-                    reusabilityScore: 9,
-                    inputs: [
-                        {
-                            name: 'recipient',
-                            type: 'reference',
-                            required: true,
-                            description: 'User to notify',
-                            sourceType: 'trigger',
-                            sourceReference: 'current.requested_for'
-                        },
-                        {
-                            name: 'message',
-                            type: 'string',
-                            required: true,
-                            description: 'Notification message',
-                            sourceType: 'constant',
-                            defaultValue: 'Your iPhone 6 is ready for pickup at the admin desk'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'notification_sent',
-                            type: 'boolean',
-                            description: 'Whether notification was sent successfully',
-                            usedByActivities: [],
-                            isFlowOutput: true
-                        }
-                    ],
-                    configuration: {
-                        notification_type: 'email',
-                        template: 'catalog_item_ready'
-                    },
-                    errorHandling: [{
-                            condition: 'send_failed',
-                            action: 'retry',
-                            parameters: { max_retries: 2 },
-                            description: 'Retry notification sending on failure'
-                        }],
-                    position: { x: 800, y: 100 },
-                    dependencies: ['admin_task', 'user_task'],
-                    prerequisites: ['fulfillment_check']
-                }
-            ],
-            connections: [
-                {
-                    id: 'trigger_to_approval',
-                    from: 'trigger',
-                    to: 'approval_check',
-                    label: 'Start Approval',
-                    condition: '',
-                    conditionType: 'always',
-                    description: 'Start approval process'
-                },
-                {
-                    id: 'approval_to_decision',
-                    from: 'approval_check',
-                    to: 'fulfillment_check',
-                    label: 'Check Result',
-                    condition: '',
-                    conditionType: 'always',
-                    description: 'Check approval result'
-                },
-                {
-                    id: 'decision_to_admin',
-                    from: 'fulfillment_check',
-                    to: 'admin_task',
-                    label: 'Approved',
-                    condition: 'approval_state=approved',
-                    conditionType: 'conditional',
-                    description: 'Proceed if approved'
-                },
-                {
-                    id: 'decision_to_user',
-                    from: 'fulfillment_check',
-                    to: 'user_task',
-                    label: 'Approved',
-                    condition: 'approval_state=approved',
-                    conditionType: 'conditional',
-                    description: 'Proceed if approved'
-                },
-                {
-                    id: 'admin_to_notification',
-                    from: 'admin_task',
-                    to: 'notification',
-                    label: 'Task Created',
-                    condition: '',
-                    conditionType: 'success',
-                    description: 'Notify after admin task creation'
-                },
-                {
-                    id: 'user_to_notification',
-                    from: 'user_task',
-                    to: 'notification',
-                    label: 'Task Created',
-                    condition: '',
-                    conditionType: 'success',
-                    description: 'Notify after user task creation'
-                }
-            ],
-            variables: [
-                {
-                    name: 'catalog_item',
-                    type: 'reference',
-                    description: 'iPhone 6 catalog item reference',
-                    defaultValue: null,
-                    scope: 'flow',
-                    category: 'Data'
-                },
-                {
-                    name: 'approval_timeout',
-                    type: 'integer',
-                    description: 'Approval timeout in hours',
-                    defaultValue: 48,
-                    scope: 'flow',
-                    category: 'Configuration'
-                }
-            ],
-            tags: ['iphone', 'catalog', 'approval', 'fulfillment', 'task', 'notification'],
-            version: '1.0.0',
-            author: 'ServiceNow Multi-Agent System',
-            documentation: 'Complete workflow for iPhone 6 catalog requests with approval and fulfillment tasks',
-            useCases: [
-                'iPhone 6 catalog item requests',
-                'Hardware catalog fulfillment',
-                'Manager approval workflows',
-                'User pickup coordination'
-            ],
-            prerequisites: [
-                'iPhone 6 catalog item configured',
-                'Manager hierarchy defined',
-                'Admin group configured',
-                'Notification templates available'
-            ],
-            bestPractices: [
-                'Set appropriate approval timeouts',
-                'Configure escalation for timeouts',
-                'Use descriptive task names',
-                'Test notification delivery'
-            ],
-            customizationPoints: [
-                {
-                    id: 'approval_hierarchy',
-                    name: 'Approval Hierarchy',
-                    description: 'Configure approval hierarchy and rules',
-                    type: 'configuration',
-                    location: 'approval_check',
-                    options: [
-                        {
-                            value: 'manager',
-                            label: 'Manager Only',
-                            description: 'Require only manager approval',
-                            implications: ['Faster approval process']
-                        },
-                        {
-                            value: 'manager_and_admin',
-                            label: 'Manager and Admin',
-                            description: 'Require both manager and admin approval',
-                            implications: ['Longer approval process', 'Higher security']
-                        }
-                    ],
-                    impact: 'high'
-                },
-                {
-                    id: 'notification_channels',
-                    name: 'Notification Channels',
-                    description: 'Configure notification delivery methods',
-                    type: 'activity',
-                    location: 'notification',
-                    options: [
-                        {
-                            value: 'email',
-                            label: 'Email Only',
-                            description: 'Send notifications via email',
-                            implications: ['Standard delivery']
-                        },
-                        {
-                            value: 'email_and_sms',
-                            label: 'Email and SMS',
-                            description: 'Send notifications via email and SMS',
-                            implications: ['Faster delivery', 'Higher visibility']
-                        }
-                    ],
-                    impact: 'medium'
-                }
-            ],
-            variations: [
-                {
-                    id: 'no_approval',
-                    name: 'No Approval Required',
-                    description: 'Skip approval process for low-cost items',
-                    differences: ['Remove approval_check activity', 'Connect trigger directly to fulfillment'],
-                    applicableScenarios: ['Low-cost items', 'Auto-approved requests'],
-                    complexityChange: 'decrease'
-                },
-                {
-                    id: 'multi_level_approval',
-                    name: 'Multi-Level Approval',
-                    description: 'Add additional approval levels',
-                    differences: ['Add senior manager approval', 'Add budget approval'],
-                    applicableScenarios: ['High-cost items', 'Executive requests'],
-                    complexityChange: 'increase'
-                }
-            ]
-        });
-        // Simple Notification Template
-        this.templates.set('simple-notification', {
-            id: 'simple-notification',
-            name: 'Simple Notification',
-            description: 'Basic notification workflow for sending alerts',
-            category: 'Communication',
-            context: flow_subflow_decision_engine_js_1.FlowContext.NOTIFICATION_WORKFLOW,
-            recommendedType: flow_subflow_decision_engine_js_1.FlowType.SUBFLOW,
-            complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.LOW,
-            reusability: flow_subflow_decision_engine_js_1.ReusabilityLevel.HIGH,
-            triggers: [{
-                    id: 'notification_trigger',
-                    type: 'manual',
-                    table: 'any',
-                    description: 'Manual trigger for notification',
-                    configuration: {
-                        manual_execution: true
-                    }
-                }],
-            activities: [
-                {
-                    id: 'send_notification',
-                    name: 'Send Notification',
-                    type: 'notification',
-                    label: 'Send Alert',
-                    description: 'Send notification to specified recipients',
-                    category: 'Communication',
-                    isSubflowCandidate: false,
-                    reusabilityScore: 10,
-                    inputs: [
-                        {
-                            name: 'recipients',
-                            type: 'string',
-                            required: true,
-                            description: 'Comma-separated list of recipients',
-                            sourceType: 'trigger'
-                        },
-                        {
-                            name: 'subject',
-                            type: 'string',
-                            required: true,
-                            description: 'Email subject line',
-                            sourceType: 'trigger'
-                        },
-                        {
-                            name: 'message',
-                            type: 'string',
-                            required: true,
-                            description: 'Notification message',
-                            sourceType: 'trigger'
-                        }
-                    ],
-                    outputs: [
-                        {
-                            name: 'sent_successfully',
-                            type: 'boolean',
-                            description: 'Whether notification was sent',
-                            usedByActivities: [],
-                            isFlowOutput: true
-                        }
-                    ],
-                    configuration: {
-                        notification_type: 'email'
-                    },
-                    errorHandling: [{
-                            condition: 'send_failed',
-                            action: 'retry',
-                            parameters: { max_retries: 3 },
-                            description: 'Retry sending on failure'
-                        }],
-                    position: { x: 200, y: 100 },
-                    dependencies: [],
-                    prerequisites: []
-                }
-            ],
-            connections: [
-                {
-                    id: 'trigger_to_send',
-                    from: 'trigger',
-                    to: 'send_notification',
-                    label: 'Send',
-                    condition: '',
-                    conditionType: 'always',
-                    description: 'Send notification'
-                }
-            ],
-            variables: [
-                {
-                    name: 'delivery_method',
-                    type: 'string',
-                    description: 'Notification delivery method',
-                    defaultValue: 'email',
-                    scope: 'flow',
-                    category: 'Configuration'
-                }
-            ],
-            tags: ['notification', 'email', 'alert', 'communication', 'simple'],
-            version: '1.0.0',
-            author: 'ServiceNow Multi-Agent System',
-            documentation: 'Simple notification workflow for sending alerts via email',
-            useCases: [
-                'Basic email notifications',
-                'Alert sending',
-                'Status updates',
-                'Simple communications'
-            ],
-            prerequisites: [
-                'Email configuration',
-                'Notification templates'
-            ],
-            bestPractices: [
-                'Use clear subject lines',
-                'Keep messages concise',
-                'Test delivery before production'
-            ],
-            customizationPoints: [
-                {
-                    id: 'delivery_channels',
-                    name: 'Delivery Channels',
-                    description: 'Configure notification delivery channels',
-                    type: 'configuration',
-                    location: 'send_notification',
-                    options: [
-                        {
-                            value: 'email',
-                            label: 'Email',
-                            description: 'Send via email',
-                            implications: ['Standard delivery']
-                        },
-                        {
-                            value: 'sms',
-                            label: 'SMS',
-                            description: 'Send via SMS',
-                            implications: ['Faster delivery']
-                        }
-                    ],
-                    impact: 'medium'
-                }
-            ],
-            variations: [
-                {
-                    id: 'rich_notification',
-                    name: 'Rich Notification',
-                    description: 'Add HTML formatting and attachments',
-                    differences: ['Add HTML formatting', 'Add attachment support'],
-                    applicableScenarios: ['Rich content', 'Reports', 'Branded communications'],
-                    complexityChange: 'increase'
-                }
-            ]
-        });
-        // Additional templates would be added here...
-    }
-    /**
-     * Initialize flow patterns
-     */
-    initializePatterns() {
-        this.patterns = [
-            {
-                name: 'Approval Pattern',
-                description: 'Standard approval workflow with escalation',
-                context: flow_subflow_decision_engine_js_1.FlowContext.APPROVAL_WORKFLOW,
-                recommendedType: flow_subflow_decision_engine_js_1.FlowType.SUBFLOW,
-                commonActions: ['approve', 'reject', 'escalate'],
-                inputPatterns: ['record', 'approver', 'timeout'],
-                outputPatterns: ['approval_state', 'approved_by'],
-                complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.MEDIUM
-            },
-            {
-                name: 'Fulfillment Pattern',
-                description: 'Complete fulfillment workflow with tasks',
-                context: flow_subflow_decision_engine_js_1.FlowContext.FULFILLMENT_WORKFLOW,
-                recommendedType: flow_subflow_decision_engine_js_1.FlowType.MAIN_FLOW,
-                commonActions: ['validate', 'create_task', 'notify'],
-                inputPatterns: ['catalog_item', 'requestor', 'approver'],
-                outputPatterns: ['fulfillment_status', 'task_ids'],
-                complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.HIGH
-            },
-            {
-                name: 'Notification Pattern',
-                description: 'Multi-channel notification system',
-                context: flow_subflow_decision_engine_js_1.FlowContext.NOTIFICATION_WORKFLOW,
-                recommendedType: flow_subflow_decision_engine_js_1.FlowType.SUBFLOW,
-                commonActions: ['format_message', 'send_notification'],
-                inputPatterns: ['recipients', 'message', 'channel'],
-                outputPatterns: ['sent_successfully', 'delivery_status'],
-                complexity: flow_subflow_decision_engine_js_1.ComplexityLevel.LOW
-            }
-        ];
-    }
-}
-exports.FlowPatternTemplates = FlowPatternTemplates;
-//# sourceMappingURL=flow-pattern-templates.js.map