snow-flow 3.0.8 → 3.0.10

package/dist/agents/workflow-designer.agent.js

@@ -1,583 +0,0 @@
-"use strict";
-/**
- * Workflow Designer Agent for Flow Designer workflows
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowDesignerAgent = void 0;
-const base_agent_js_1 = require("../core/base-agent.js");
-class WorkflowDesignerAgent extends base_agent_js_1.BaseServiceNowAgent {
-    constructor(config) {
-        super('workflow-designer', servicenow_types_js_1.AgentType.WORKFLOW_DESIGNER, [
-            'create_workflow',
-            'add_trigger',
-            'add_action',
-            'add_condition',
-            'validate_workflow',
-            'generate_flow_json',
-            'create_subflow'
-        ], config);
-    }
-    async execute(task) {
-        this.logger.info(`Executing workflow design task: ${task.description}`);
-        try {
-            switch (task.type) {
-                case 'create_workflow':
-                    return await this.createWorkflow(task);
-                case 'add_workflow_components':
-                    return await this.addWorkflowComponents(task);
-                case 'generate_flow_from_requirements':
-                    return await this.generateFlowFromRequirements(task);
-                case 'optimize_workflow':
-                    return await this.optimizeWorkflow(task);
-                default:
-                    throw new Error(`Unknown task type: ${task.type}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Workflow design task failed: ${error.message}`);
-            return {
-                taskId: task.id,
-                success: false,
-                error: error.message
-            };
-        }
-    }
-    async createWorkflow(task) {
-        const { name, description, triggers, initialActions } = task.payload;
-        const workflow = {
-            name,
-            description: description || `Automated workflow: ${name}`,
-            triggers: triggers || [this.createDefaultTrigger()],
-            actions: initialActions || [],
-            conditions: []
-        };
-        // Generate Flow Designer JSON
-        const flowJson = this.generateFlowDesignerJSON(workflow);
-        // Generate orchestration commands
-        const commands = [
-            this.generateCommand('Bash', 'create', {
-                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(name)}`,
-                description: `Create workflow directory for ${name}`
-            }, 'Create workflow directory'),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(name)}/flow.json`,
-                content: JSON.stringify(flowJson, null, 2)
-            }, `Create Flow Designer JSON for ${name}`),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(name)}/README.md`,
-                content: this.generateWorkflowDocumentation(workflow)
-            }, `Create workflow documentation`)
-        ];
-        // Store workflow in memory
-        await this.storeInMemory(`workflows:${this.sanitizeName(name)}`, workflow);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                workflow,
-                flowJson
-            },
-            artifacts: [
-                this.createArtifact('flow_designer_workflow', name, flowJson, {
-                    triggers: workflow.triggers.length,
-                    actions: workflow.actions.length,
-                    conditions: workflow.conditions?.length || 0
-                })
-            ],
-            commands
-        };
-    }
-    async addWorkflowComponents(task) {
-        const { workflowName, components } = task.payload;
-        // Retrieve existing workflow
-        const workflow = await this.retrieveFromMemory(`workflows:${this.sanitizeName(workflowName)}`);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowName} not found`);
-        }
-        // Add components
-        if (components.triggers) {
-            workflow.triggers.push(...components.triggers);
-        }
-        if (components.actions) {
-            workflow.actions.push(...components.actions.map((action) => this.createWorkflowAction(action)));
-        }
-        if (components.conditions) {
-            workflow.conditions = workflow.conditions || [];
-            workflow.conditions.push(...components.conditions.map((condition) => this.createWorkflowCondition(condition)));
-        }
-        // Update stored workflow
-        await this.storeInMemory(`workflows:${this.sanitizeName(workflowName)}`, workflow);
-        // Regenerate Flow Designer JSON
-        const flowJson = this.generateFlowDesignerJSON(workflow);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                workflow,
-                flowJson,
-                componentsAdded: {
-                    triggers: components.triggers?.length || 0,
-                    actions: components.actions?.length || 0,
-                    conditions: components.conditions?.length || 0
-                }
-            },
-            artifacts: [
-                this.createArtifact('flow_designer_workflow', workflowName, flowJson)
-            ]
-        };
-    }
-    async generateFlowFromRequirements(task) {
-        const { requirements, name, businessProcess } = task.payload;
-        // Analyze requirements to determine workflow components
-        const analyzedFlow = this.analyzeRequirements(requirements, businessProcess);
-        // Create workflow based on analysis
-        const workflow = {
-            name: name || 'Generated Workflow',
-            description: `Automated workflow generated from requirements: ${requirements.substring(0, 100)}...`,
-            triggers: analyzedFlow.triggers,
-            actions: analyzedFlow.actions,
-            conditions: analyzedFlow.conditions
-        };
-        // Generate comprehensive workflow package
-        const flowJson = this.generateFlowDesignerJSON(workflow);
-        const testScenarios = this.generateTestScenarios(workflow);
-        const documentation = this.generateDetailedDocumentation(workflow, requirements);
-        const commands = [
-            // Create workflow directory structure
-            this.generateCommand('Bash', 'create', {
-                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(workflow.name)}/{tests,docs,scripts}`,
-                description: 'Create workflow directory structure'
-            }, 'Create directories'),
-            // Main workflow file
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(workflow.name)}/flow.json`,
-                content: JSON.stringify(flowJson, null, 2)
-            }, 'Create Flow Designer JSON'),
-            // Test scenarios
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(workflow.name)}/tests/test-scenarios.json`,
-                content: JSON.stringify(testScenarios, null, 2)
-            }, 'Create test scenarios'),
-            // Documentation
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/workflows/${this.sanitizeName(workflow.name)}/docs/workflow-guide.md`,
-                content: documentation
-            }, 'Create workflow documentation')
-        ];
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                workflow,
-                flowJson,
-                testScenarios,
-                analysis: analyzedFlow
-            },
-            artifacts: [
-                this.createArtifact('flow_designer_workflow', workflow.name, flowJson),
-                this.createArtifact('test_scenarios', 'test-scenarios.json', testScenarios),
-                this.createArtifact('documentation', 'workflow-guide.md', documentation)
-            ],
-            commands
-        };
-    }
-    async optimizeWorkflow(task) {
-        const { workflowName, optimizationGoals } = task.payload;
-        const workflow = await this.retrieveFromMemory(`workflows:${this.sanitizeName(workflowName)}`);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowName} not found`);
-        }
-        // Perform optimization
-        const optimizationResults = this.performOptimization(workflow, optimizationGoals);
-        // Apply optimizations
-        const optimizedWorkflow = this.applyOptimizations(workflow, optimizationResults);
-        // Update stored workflow
-        await this.storeInMemory(`workflows:${this.sanitizeName(workflowName)}`, optimizedWorkflow);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                originalWorkflow: workflow,
-                optimizedWorkflow,
-                optimizationResults
-            },
-            artifacts: [
-                this.createArtifact('optimization_report', 'optimization-report.json', optimizationResults)
-            ]
-        };
-    }
-    // Helper methods
-    createDefaultTrigger() {
-        return {
-            type: 'record',
-            table: 'incident',
-            conditions: 'active=true^priority=1'
-        };
-    }
-    createWorkflowAction(actionSpec) {
-        return {
-            name: actionSpec.name || 'Unnamed Action',
-            type: actionSpec.type || 'script',
-            configuration: actionSpec.configuration || {}
-        };
-    }
-    createWorkflowCondition(conditionSpec) {
-        return {
-            name: conditionSpec.name || 'Unnamed Condition',
-            type: conditionSpec.type || 'if',
-            expression: conditionSpec.expression || 'true'
-        };
-    }
-    generateFlowDesignerJSON(workflow) {
-        return {
-            name: workflow.name,
-            description: workflow.description,
-            definition: {
-                version: '1.0',
-                triggers: workflow.triggers.map((trigger, index) => ({
-                    id: `trigger_${index}`,
-                    type: trigger.type,
-                    configuration: this.getTriggerConfiguration(trigger)
-                })),
-                stages: this.generateStages(workflow),
-                connections: this.generateConnections(workflow)
-            },
-            metadata: {
-                created: new Date().toISOString(),
-                createdBy: this.name,
-                version: '1.0.0'
-            }
-        };
-    }
-    getTriggerConfiguration(trigger) {
-        const config = {
-            type: trigger.type
-        };
-        switch (trigger.type) {
-            case 'record':
-                config.table = trigger.table;
-                config.conditions = trigger.conditions;
-                break;
-            case 'schedule':
-                config.schedule = trigger.schedule;
-                break;
-            case 'rest':
-                config.endpoint = '/api/workflow/trigger';
-                break;
-        }
-        return config;
-    }
-    generateStages(workflow) {
-        const stages = [];
-        // Add action stages
-        workflow.actions.forEach((action, index) => {
-            stages.push({
-                id: `action_${index}`,
-                type: 'action',
-                name: action.name,
-                action: action.type,
-                configuration: action.configuration
-            });
-        });
-        // Add condition stages
-        if (workflow.conditions) {
-            workflow.conditions.forEach((condition, index) => {
-                stages.push({
-                    id: `condition_${index}`,
-                    type: 'condition',
-                    name: condition.name,
-                    conditionType: condition.type,
-                    expression: condition.expression
-                });
-            });
-        }
-        return stages;
-    }
-    generateConnections(workflow) {
-        const connections = [];
-        // Connect triggers to first action
-        if (workflow.actions.length > 0) {
-            workflow.triggers.forEach((trigger, triggerIndex) => {
-                connections.push({
-                    from: `trigger_${triggerIndex}`,
-                    to: 'action_0'
-                });
-            });
-        }
-        // Connect actions sequentially (simplified)
-        for (let i = 0; i < workflow.actions.length - 1; i++) {
-            connections.push({
-                from: `action_${i}`,
-                to: `action_${i + 1}`
-            });
-        }
-        return connections;
-    }
-    generateWorkflowDocumentation(workflow) {
-        return `# ${workflow.name}
-
-## Description
-${workflow.description}
-
-## Triggers
-${workflow.triggers.map(trigger => `- **${trigger.type}**: ${this.describeTrigger(trigger)}`).join('\n')}
-
-## Actions
-${workflow.actions.map((action, index) => `${index + 1}. **${action.name}** (${action.type})`).join('\n')}
-
-## Conditions
-${workflow.conditions?.map(condition => `- **${condition.name}**: ${condition.expression}`).join('\n') || 'No conditions defined'}
-
-## Usage
-This workflow is automatically triggered based on the configured triggers and will execute the defined actions in sequence.
-
-## Testing
-Test scenarios are available in the tests directory.
-
-Generated by ServiceNow Multi-Agent Framework
-`;
-    }
-    describeTrigger(trigger) {
-        switch (trigger.type) {
-            case 'record':
-                return `When records in ${trigger.table} match: ${trigger.conditions}`;
-            case 'schedule':
-                return `Scheduled: ${trigger.schedule}`;
-            case 'rest':
-                return 'REST API trigger';
-            case 'inbound_email':
-                return 'Inbound email trigger';
-            default:
-                return 'Custom trigger';
-        }
-    }
-    analyzeRequirements(requirements, businessProcess) {
-        // Simplified requirement analysis
-        const triggers = [];
-        const actions = [];
-        const conditions = [];
-        // Detect trigger patterns
-        if (requirements.toLowerCase().includes('when incident')) {
-            triggers.push({
-                type: 'record',
-                table: 'incident',
-                conditions: this.extractConditions(requirements, 'incident')
-            });
-        }
-        if (requirements.toLowerCase().includes('scheduled') || requirements.toLowerCase().includes('daily')) {
-            triggers.push({
-                type: 'schedule',
-                schedule: '0 0 * * *' // Daily at midnight
-            });
-        }
-        // Detect action patterns
-        if (requirements.toLowerCase().includes('create')) {
-            actions.push({
-                name: 'Create Record',
-                type: 'create_record',
-                configuration: {
-                    table: this.extractTable(requirements, 'create')
-                }
-            });
-        }
-        if (requirements.toLowerCase().includes('send email') || requirements.toLowerCase().includes('notify')) {
-            actions.push({
-                name: 'Send Notification',
-                type: 'send_email',
-                configuration: {
-                    template: 'notification_template'
-                }
-            });
-        }
-        if (requirements.toLowerCase().includes('update')) {
-            actions.push({
-                name: 'Update Record',
-                type: 'update_record',
-                configuration: {
-                    table: this.extractTable(requirements, 'update')
-                }
-            });
-        }
-        // Add script action for complex logic
-        if (businessProcess && businessProcess.length > 50) {
-            actions.push({
-                name: 'Execute Business Logic',
-                type: 'script',
-                configuration: {
-                    script: '// Business logic implementation'
-                }
-            });
-        }
-        // Detect condition patterns
-        if (requirements.toLowerCase().includes('if') || requirements.toLowerCase().includes('when')) {
-            conditions.push({
-                name: 'Check Condition',
-                type: 'if',
-                expression: 'current.state == "new"'
-            });
-        }
-        return { triggers, actions, conditions };
-    }
-    extractConditions(text, table) {
-        // Simplified condition extraction
-        if (text.toLowerCase().includes('high priority')) {
-            return 'priority=1';
-        }
-        if (text.toLowerCase().includes('new')) {
-            return 'state=1';
-        }
-        return 'active=true';
-    }
-    extractTable(text, action) {
-        // Simplified table extraction
-        const tables = ['incident', 'change_request', 'problem', 'task'];
-        for (const table of tables) {
-            if (text.toLowerCase().includes(table)) {
-                return table;
-            }
-        }
-        return 'task';
-    }
-    generateTestScenarios(workflow) {
-        return {
-            scenarios: [
-                {
-                    name: 'Happy Path',
-                    description: 'Test successful workflow execution',
-                    inputs: {
-                        trigger: workflow.triggers[0],
-                        data: {
-                            priority: '1',
-                            state: 'new'
-                        }
-                    },
-                    expectedOutcomes: workflow.actions.map(action => ({
-                        action: action.name,
-                        result: 'success'
-                    }))
-                },
-                {
-                    name: 'Error Handling',
-                    description: 'Test workflow error handling',
-                    inputs: {
-                        trigger: workflow.triggers[0],
-                        data: {
-                            invalid: true
-                        }
-                    },
-                    expectedOutcomes: [
-                        {
-                            action: 'Error Handler',
-                            result: 'handled'
-                        }
-                    ]
-                }
-            ]
-        };
-    }
-    generateDetailedDocumentation(workflow, requirements) {
-        return `# ${workflow.name} - Detailed Documentation
-
-## Overview
-${workflow.description}
-
-## Business Requirements
-${requirements}
-
-## Workflow Components
-
-### Triggers
-${workflow.triggers.map((trigger, index) => `
-#### Trigger ${index + 1}: ${trigger.type}
-${this.describeTrigger(trigger)}
-- Configuration: ${JSON.stringify(this.getTriggerConfiguration(trigger), null, 2)}
-`).join('\n')}
-
-### Actions
-${workflow.actions.map((action, index) => `
-#### Action ${index + 1}: ${action.name}
-- Type: ${action.type}
-- Configuration: ${JSON.stringify(action.configuration, null, 2)}
-`).join('\n')}
-
-### Conditions
-${workflow.conditions?.map((condition, index) => `
-#### Condition ${index + 1}: ${condition.name}
-- Type: ${condition.type}
-- Expression: ${condition.expression}
-`).join('\n') || 'No conditions defined'}
-
-## Implementation Notes
-- This workflow was automatically generated based on the provided requirements
-- Review and adjust the configuration as needed
-- Test thoroughly before deploying to production
-
-## Testing
-See test-scenarios.json for comprehensive test cases
-
-Generated on: ${new Date().toISOString()}
-Generated by: ServiceNow Multi-Agent Framework
-`;
-    }
-    performOptimization(workflow, goals) {
-        const results = {
-            optimizations: [],
-            improvements: []
-        };
-        // Check for optimization opportunities
-        if (goals.includes('performance')) {
-            // Check for sequential actions that could be parallelized
-            if (workflow.actions.length > 3) {
-                results.optimizations.push({
-                    type: 'parallelization',
-                    description: 'Some actions can be executed in parallel',
-                    impact: 'high'
-                });
-            }
-        }
-        if (goals.includes('reliability')) {
-            // Add error handling
-            results.optimizations.push({
-                type: 'error_handling',
-                description: 'Add error handling stages',
-                impact: 'medium'
-            });
-        }
-        if (goals.includes('maintainability')) {
-            // Suggest subflow extraction
-            if (workflow.actions.length > 5) {
-                results.optimizations.push({
-                    type: 'subflow_extraction',
-                    description: 'Extract common patterns into subflows',
-                    impact: 'medium'
-                });
-            }
-        }
-        return results;
-    }
-    applyOptimizations(workflow, optimizationResults) {
-        const optimized = { ...workflow };
-        // Apply optimizations based on results
-        optimizationResults.optimizations.forEach((opt) => {
-            switch (opt.type) {
-                case 'error_handling':
-                    // Add error handling action
-                    optimized.actions.push({
-                        name: 'Error Handler',
-                        type: 'script',
-                        configuration: {
-                            script: 'gs.error("Workflow error: " + error.message);'
-                        }
-                    });
-                    break;
-                // Add more optimization applications as needed
-            }
-        });
-        return optimized;
-    }
-    sanitizeName(name) {
-        return name.toLowerCase().replace(/[^a-z0-9]/g, '_');
-    }
-}
-exports.WorkflowDesignerAgent = WorkflowDesignerAgent;
-//# sourceMappingURL=workflow-designer.agent.js.map