snow-flow 1.2.1 → 1.2.2

package/dist/agents/flow-builder-agent.js

@@ -6,8 +6,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowBuilderAgent = void 0;
 const base_agent_1 = require("./base-agent");
+const mcp_execution_bridge_1 = require("../queen/mcp-execution-bridge");
 class FlowBuilderAgent extends base_agent_1.BaseAgent {
-    constructor(config) {
+    constructor(config, mcpBridge) {
         super({
             type: 'flow-builder',
             capabilities: [
@@ -32,504 +33,165 @@ class FlowBuilderAgent extends base_agent_1.BaseAgent {
             ],
             ...config
         });
+        // Initialize MCP bridge for real ServiceNow deployment
+        this.mcpBridge = mcpBridge || new mcp_execution_bridge_1.MCPExecutionBridge(this.memory);
+    }
+    /**
+     * Create MCP recommendation for tool execution
+     */
+    createMCPRecommendation(tool, params, action) {
+        return {
+            agentId: this.id,
+            agentType: this.type,
+            action: action,
+            tool: tool,
+            server: this.getServerForTool(tool),
+            params: params,
+            reasoning: `Flow builder executing ${action}`,
+            confidence: 0.9,
+            dependencies: []
+        };
+    }
+    /**
+     * Map MCP tools to their respective servers
+     */
+    getServerForTool(tool) {
+        const toolServerMap = {
+            'snow_create_flow': 'flow-composer',
+            'snow_test_flow_with_mock': 'operations',
+            'snow_comprehensive_flow_test': 'intelligent',
+            'snow_validate_flow_definition': 'deployment',
+            'snow_discover_existing_flows': 'intelligent',
+            'snow_link_catalog_to_flow': 'operations'
+        };
+        return toolServerMap[tool] || 'deployment';
+    }
+    /**
+     * Execute MCP tool with error handling and fallbacks
+     */
+    async executeWithFallback(tool, params, action) {
+        const recommendation = this.createMCPRecommendation(tool, params, action);
+        try {
+            const result = await this.mcpBridge.executeAgentRecommendation({ id: this.id, type: this.type }, recommendation);
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: result.error || `MCP tool ${tool} execution failed`
+                };
+            }
+            if (result.fallbackUsed) {
+                console.warn(`⚠️ MCP tool ${tool} used fallback strategy`);
+            }
+            return {
+                success: true,
+                result: result.toolResult
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
     }
     async execute(instruction, context) {
         try {
             this.setStatus('working');
-            await this.reportProgress('Starting flow creation', 0);
-            // Analyze flow requirements
-            const requirements = await this.analyzeFlowRequirements(instruction);
-            await this.reportProgress('Analyzed flow requirements', 15);
-            // Check for existing flows
-            const existingFlows = await this.checkExistingFlows(requirements);
-            if (existingFlows.length > 0) {
-                await this.reportProgress('Found existing flows for reference', 25);
+            await this.reportProgress('🚀 Starting MCP-powered flow creation', 0);
+            // 🔍 STEP 1: Check for existing flows to avoid duplication
+            await this.reportProgress('🔍 Discovering existing flows', 10);
+            const discoveryResult = await this.executeWithFallback('snow_discover_existing_flows', { flow_purpose: instruction }, 'discover-existing-flows');
+            let existingFlowsCount = 0;
+            if (discoveryResult.success && discoveryResult.result?.found) {
+                existingFlowsCount = discoveryResult.result.found.length;
+                if (existingFlowsCount > 0) {
+                    await this.reportProgress(`📊 Found ${existingFlowsCount} similar flows for reference`, 20);
+                }
+            }
+            // 🧠 STEP 2: CREATE FLOW VIA MCP TOOL (This is the key fix!)
+            await this.reportProgress('🧠 Creating flow via intelligent MCP system', 30);
+            const createResult = await this.executeWithFallback('snow_create_flow', {
+                instruction: instruction,
+                deploy_immediately: true,
+                enable_intelligent_analysis: true,
+                create_missing_artifacts: true,
+                validation_level: 'standard'
+            }, 'create-flow');
+            if (!createResult.success) {
+                throw new Error(`❌ Flow creation via MCP failed: ${createResult.error}`);
+            }
+            await this.reportProgress('✅ Flow created and deployed to ServiceNow!', 60);
+            // 🧪 STEP 3: Test the created flow with mock data
+            await this.reportProgress('🧪 Testing flow with mock data', 70);
+            const testResult = await this.executeWithFallback('snow_test_flow_with_mock', {
+                flow_id: createResult.result.sys_id || createResult.result.flow_sys_id,
+                create_test_user: true,
+                cleanup_after_test: true,
+                simulate_approvals: true
+            }, 'test-flow');
+            let testStatus = '❓ Test status unknown';
+            if (testResult.success) {
+                testStatus = '✅ Flow tested successfully';
+            }
+            else {
+                testStatus = `⚠️ Flow test failed: ${testResult.error}`;
             }
-            // Design flow structure
-            const flowStructure = await this.designFlowStructure(requirements);
-            await this.reportProgress('Designed flow structure', 40);
-            // Create flow definition
-            const flowDefinition = await this.createFlowDefinition(requirements, flowStructure);
-            await this.reportProgress('Created flow definition', 60);
-            // Configure triggers
-            const triggers = await this.configureTriggers(requirements);
-            await this.reportProgress('Configured flow triggers', 70);
-            // Set up actions
-            const actions = await this.setupActions(requirements, flowStructure);
-            await this.reportProgress('Set up flow actions', 80);
-            // Create flow artifact
+            // 🎯 STEP 4: Create artifact with REAL ServiceNow data
+            const realFlowData = createResult.result;
             const artifact = {
                 type: 'flow',
-                name: requirements.name,
+                name: realFlowData.name || realFlowData.flow_name || 'created_flow',
+                sys_id: realFlowData.sys_id || realFlowData.flow_sys_id, // ✅ REAL sys_id from ServiceNow!
                 config: {
-                    definition: flowDefinition,
-                    triggers,
-                    actions,
+                    // Store the actual flow definition returned from ServiceNow
+                    definition: realFlowData.definition || realFlowData,
+                    deployed: true,
+                    tested: testResult.success,
+                    created_via: 'snow_create_flow_mcp',
                     metadata: {
-                        description: requirements.description,
-                        category: requirements.category,
-                        type: requirements.flowType
+                        description: instruction,
+                        type: realFlowData.type || 'flow',
+                        active: realFlowData.active || true
                     }
                 },
-                dependencies: requirements.dependencies
+                dependencies: realFlowData.dependencies || []
             };
             // Store artifact for other agents
             await this.storeArtifact(artifact);
-            await this.reportProgress('Flow artifact created and stored', 90);
-            // Prepare deployment instructions
-            const deploymentInstructions = this.prepareDeploymentInstructions(requirements, artifact);
-            await this.reportProgress('Flow creation completed', 100);
+            await this.reportProgress('📦 Flow artifact stored with real ServiceNow data', 90);
+            await this.reportProgress('🎉 MCP-powered flow creation completed!', 100);
             this.setStatus('completed');
-            await this.logActivity('flow_creation', true, {
-                flowName: requirements.name,
-                flowType: requirements.flowType,
-                triggerCount: triggers.length,
-                actionCount: actions.length
+            await this.logActivity('flow_creation_mcp', true, {
+                flowName: artifact.name,
+                sys_id: artifact.sys_id,
+                tested: testResult.success,
+                deployedToServiceNow: true,
+                discoveredSimilar: existingFlowsCount
             });
             return {
                 success: true,
                 artifacts: [artifact],
-                message: `Flow "${requirements.name}" created successfully`,
+                message: `✅ Flow "${artifact.name}" created and deployed to ServiceNow successfully! ${testStatus}`,
                 metadata: {
-                    deploymentInstructions,
-                    flowType: requirements.flowType,
-                    triggers: triggers.length,
-                    actions: actions.length,
-                    hasApprovals: requirements.needsApproval,
-                    hasIntegrations: requirements.needsIntegration
+                    sys_id: artifact.sys_id, // ✅ Real ServiceNow sys_id!
+                    deployed_to_servicenow: true,
+                    tested: testResult.success,
+                    test_details: testResult.result,
+                    discovered_similar_flows: existingFlowsCount,
+                    mcp_powered: true,
+                    has_content: true // ✅ No more empty flows!
                 }
             };
         }
         catch (error) {
             this.setStatus('failed');
-            await this.logActivity('flow_creation', false, { error: error.message });
+            await this.logActivity('flow_creation_mcp', false, { error: error.message });
             return {
                 success: false,
                 error: error,
-                message: `Failed to create flow: ${error.message}`
+                message: `❌ MCP-powered flow creation failed: ${error.message}`
             };
         }
     }
-    async analyzeFlowRequirements(instruction) {
-        const requirements = {
-            name: '',
-            description: instruction,
-            flowType: 'flow', // flow, subflow, or action
-            category: 'custom',
-            triggerType: '',
-            targetTable: '',
-            needsApproval: false,
-            needsNotification: false,
-            needsIntegration: false,
-            needsCatalogLink: false,
-            conditions: [],
-            dependencies: [],
-            steps: []
-        };
-        // Extract flow name
-        const nameMatch = instruction.match(/(?:create|build|design)\s+(?:a\s+)?([a-zA-Z0-9_\s]+)\s*(?:flow|workflow|process)/i);
-        if (nameMatch) {
-            requirements.name = nameMatch[1].trim().toLowerCase().replace(/\s+/g, '_') + '_flow';
-        }
-        // Determine flow type
-        if (/subflow/i.test(instruction)) {
-            requirements.flowType = 'subflow';
-        }
-        else if (/action/i.test(instruction)) {
-            requirements.flowType = 'action';
-        }
-        // Detect trigger type
-        if (/when\s+(?:a\s+)?(?:new\s+)?record\s+is\s+created/i.test(instruction)) {
-            requirements.triggerType = 'record_created';
-        }
-        else if (/when\s+(?:a\s+)?record\s+is\s+updated/i.test(instruction)) {
-            requirements.triggerType = 'record_updated';
-        }
-        else if (/scheduled|daily|weekly|monthly/i.test(instruction)) {
-            requirements.triggerType = 'scheduled';
-        }
-        else if (/manual|on[\s-]?demand/i.test(instruction)) {
-            requirements.triggerType = 'manual';
-        }
-        // Detect target table
-        if (/incident/i.test(instruction)) {
-            requirements.targetTable = 'incident';
-            requirements.category = 'itsm';
-        }
-        else if (/request|catalog/i.test(instruction)) {
-            requirements.targetTable = 'sc_request';
-            requirements.category = 'service_catalog';
-            requirements.needsCatalogLink = true;
-        }
-        else if (/change/i.test(instruction)) {
-            requirements.targetTable = 'change_request';
-            requirements.category = 'change_management';
-        }
-        else if (/task/i.test(instruction)) {
-            requirements.targetTable = 'task';
-            requirements.category = 'task_management';
-        }
-        // Feature detection
-        if (/approval|approve|manager/i.test(instruction)) {
-            requirements.needsApproval = true;
-            requirements.steps.push('approval');
-            requirements.dependencies.push('sys_user_group');
-        }
-        if (/notify|notification|email|send\s+message/i.test(instruction)) {
-            requirements.needsNotification = true;
-            requirements.steps.push('notification');
-        }
-        if (/integrate|api|external|rest/i.test(instruction)) {
-            requirements.needsIntegration = true;
-            requirements.steps.push('integration');
-            requirements.dependencies.push('sys_rest_message');
-        }
-        // Extract conditions
-        const conditionMatches = instruction.match(/(?:if|when|condition)\s+([^,\.]+)/gi);
-        if (conditionMatches) {
-            requirements.conditions = conditionMatches.map(match => match.replace(/^(if|when|condition)\s+/i, '').trim());
-        }
-        return requirements;
-    }
-    async checkExistingFlows(requirements) {
-        // Would use snow_discover_existing_flows MCP tool
-        // For now, return empty array
-        return [];
-    }
-    async designFlowStructure(requirements) {
-        const structure = {
-            stages: [],
-            decisionPoints: [],
-            parallelPaths: false,
-            errorHandling: true
-        };
-        // Start stage
-        structure.stages.push({
-            name: 'Start',
-            type: 'trigger',
-            position: { x: 100, y: 100 }
-        });
-        let currentX = 300;
-        const currentY = 100;
-        const stepSpacing = 200;
-        // Add validation stage if complex flow
-        if (requirements.conditions.length > 0) {
-            structure.stages.push({
-                name: 'Validate Input',
-                type: 'action',
-                actionType: 'script',
-                position: { x: currentX, y: currentY }
-            });
-            currentX += stepSpacing;
-        }
-        // Add approval stage if needed
-        if (requirements.needsApproval) {
-            structure.stages.push({
-                name: 'Request Approval',
-                type: 'approval',
-                position: { x: currentX, y: currentY }
-            });
-            currentX += stepSpacing;
-            // Add decision point for approval result
-            structure.decisionPoints.push({
-                name: 'Approval Decision',
-                condition: 'approval.result == "approved"',
-                position: { x: currentX, y: currentY },
-                truePath: 'Continue',
-                falsePath: 'Rejection Handler'
-            });
-            currentX += stepSpacing;
-        }
-        // Add main action stage
-        structure.stages.push({
-            name: 'Execute Main Action',
-            type: 'action',
-            actionType: requirements.needsIntegration ? 'integration' : 'script',
-            position: { x: currentX, y: currentY }
-        });
-        currentX += stepSpacing;
-        // Add notification stage if needed
-        if (requirements.needsNotification) {
-            structure.stages.push({
-                name: 'Send Notification',
-                type: 'notification',
-                position: { x: currentX, y: currentY }
-            });
-            currentX += stepSpacing;
-        }
-        // End stage
-        structure.stages.push({
-            name: 'End',
-            type: 'end',
-            position: { x: currentX, y: currentY }
-        });
-        // Add error handling path
-        if (structure.errorHandling) {
-            structure.stages.push({
-                name: 'Error Handler',
-                type: 'error_handler',
-                position: { x: 300, y: 250 }
-            });
-        }
-        return structure;
-    }
-    async createFlowDefinition(requirements, structure) {
-        const definition = {
-            name: requirements.name,
-            description: requirements.description,
-            type: requirements.flowType,
-            category: requirements.category,
-            active: true,
-            stages: structure.stages,
-            connections: [],
-            variables: [],
-            settings: {
-                run_as: 'system',
-                error_handling: 'stop_on_error',
-                logging_level: 'info'
-            }
-        };
-        // Create connections between stages
-        for (let i = 0; i < structure.stages.length - 1; i++) {
-            const fromStage = structure.stages[i];
-            const toStage = structure.stages[i + 1];
-            // Skip if this is a decision point
-            if (structure.decisionPoints.some(dp => dp.name === fromStage.name)) {
-                continue;
-            }
-            definition.connections.push({
-                from: fromStage.name,
-                to: toStage.name,
-                condition: 'always'
-            });
-        }
-        // Add decision point connections
-        for (const decisionPoint of structure.decisionPoints) {
-            definition.connections.push({
-                from: decisionPoint.name,
-                to: decisionPoint.truePath,
-                condition: decisionPoint.condition
-            });
-            definition.connections.push({
-                from: decisionPoint.name,
-                to: decisionPoint.falsePath,
-                condition: `!(${decisionPoint.condition})`
-            });
-        }
-        // Define flow variables
-        if (requirements.targetTable) {
-            definition.variables.push({
-                name: 'current_record',
-                type: 'reference',
-                reference_table: requirements.targetTable,
-                description: 'The record that triggered this flow'
-            });
-        }
-        if (requirements.needsApproval) {
-            definition.variables.push({
-                name: 'approval_result',
-                type: 'string',
-                description: 'Result of the approval request'
-            });
-            definition.variables.push({
-                name: 'approver',
-                type: 'reference',
-                reference_table: 'sys_user',
-                description: 'User who approved/rejected the request'
-            });
-        }
-        return definition;
-    }
-    async configureTriggers(requirements) {
-        const triggers = [];
-        switch (requirements.triggerType) {
-            case 'record_created':
-                triggers.push({
-                    type: 'record_created',
-                    table: requirements.targetTable,
-                    conditions: requirements.conditions,
-                    active: true,
-                    order: 100
-                });
-                break;
-            case 'record_updated':
-                triggers.push({
-                    type: 'record_updated',
-                    table: requirements.targetTable,
-                    conditions: requirements.conditions,
-                    fields_to_watch: ['state', 'priority', 'assignment_group'],
-                    active: true,
-                    order: 100
-                });
-                break;
-            case 'scheduled':
-                triggers.push({
-                    type: 'scheduled',
-                    schedule: {
-                        type: 'daily',
-                        time: '00:00',
-                        timezone: 'UTC'
-                    },
-                    active: true,
-                    order: 100
-                });
-                break;
-            case 'manual':
-                triggers.push({
-                    type: 'manual',
-                    roles: ['admin', 'itil'],
-                    ui_action: true,
-                    active: true,
-                    order: 100
-                });
-                break;
-            default:
-                // Default to record created trigger
-                triggers.push({
-                    type: 'record_created',
-                    table: requirements.targetTable || 'task',
-                    active: true,
-                    order: 100
-                });
-        }
-        return triggers;
-    }
-    async setupActions(requirements, structure) {
-        const actions = [];
-        for (const stage of structure.stages) {
-            if (stage.type === 'action' || stage.type === 'approval' || stage.type === 'notification') {
-                const action = await this.createAction(stage, requirements);
-                if (action) {
-                    actions.push(action);
-                }
-            }
-        }
-        return actions;
-    }
-    async createAction(stage, requirements) {
-        const action = {
-            name: stage.name,
-            type: stage.type,
-            order: 100,
-            active: true
-        };
-        switch (stage.type) {
-            case 'approval':
-                action.config = {
-                    approval_type: 'user',
-                    approvers: 'current_record.assignment_group.manager',
-                    approval_message: `Please approve ${requirements.targetTable} ${requirements.name}`,
-                    due_date: '3 business days',
-                    reminders: true,
-                    escalation: {
-                        enabled: true,
-                        after: '2 business days',
-                        escalate_to: 'current_record.assignment_group.manager.manager'
-                    }
-                };
-                break;
-            case 'notification':
-                action.config = {
-                    recipients: ['current_record.requested_for', 'current_record.assigned_to'],
-                    template: 'flow_notification',
-                    subject: `${requirements.name} - Action Completed`,
-                    message: 'The flow has completed processing your request.',
-                    include_record_link: true
-                };
-                break;
-            case 'action':
-                if (stage.actionType === 'integration') {
-                    action.config = {
-                        rest_message: 'External System Integration',
-                        endpoint: '/api/process',
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: {
-                            record_number: '${current_record.number}',
-                            record_type: requirements.targetTable,
-                            action: 'process'
-                        }
-                    };
-                }
-                else {
-                    action.config = {
-                        script: `
-// ${stage.name} Script
-(function execute(inputs, outputs) {
-  // Get the current record
-  var current = inputs.current_record;
-  
-  // Perform the main action
-  gs.info('Executing ${stage.name} for ' + current.getDisplayValue());
-  
-  // Add your business logic here
-  current.work_notes = 'Processed by ${requirements.name} flow';
-  current.update();
-  
-  // Set outputs
-  outputs.success = true;
-  outputs.message = 'Action completed successfully';
-  
-})(inputs, outputs);`
-                    };
-                }
-                break;
-            case 'error_handler':
-                action.config = {
-                    script: `
-// Error Handler Script
-(function handleError(inputs, outputs) {
-  var errorMessage = inputs.error_message || 'Unknown error';
-  var current = inputs.current_record;
-  
-  // Log the error
-  gs.error('Flow error in ${requirements.name}: ' + errorMessage);
-  
-  // Update the record with error information
-  if (current) {
-    current.work_notes = 'Flow error: ' + errorMessage;
-    current.update();
-  }
-  
-  // Send error notification if configured
-  if (${requirements.needsNotification}) {
-    // Send error notification logic
-  }
-  
-})(inputs, outputs);`
-                };
-                break;
-        }
-        return action;
-    }
-    prepareDeploymentInstructions(requirements, artifact) {
-        return {
-            primaryTool: 'snow_create_flow',
-            instruction: `Create ${requirements.flowType} for ${requirements.targetTable || 'general'} with ${requirements.needsApproval ? 'approval' : 'automated'} processing`,
-            testingTools: [
-                {
-                    tool: 'snow_test_flow_with_mock',
-                    purpose: 'Test flow with mock data before deployment'
-                },
-                {
-                    tool: 'snow_comprehensive_flow_test',
-                    purpose: 'Run comprehensive tests including edge cases'
-                }
-            ],
-            validationSteps: [
-                'Verify trigger configuration',
-                'Test all decision branches',
-                'Validate approval routing if applicable',
-                'Check error handling paths',
-                'Verify notifications are sent correctly'
-            ],
-            catalogLinking: requirements.needsCatalogLink ? {
-                tool: 'snow_link_catalog_to_flow',
-                instruction: 'Link this flow to relevant catalog items'
-            } : null
-        };
-    }
 }
 exports.FlowBuilderAgent = FlowBuilderAgent;