snow-flow 1.1.35 → 1.1.36

package/dist/mcp/servicenow-deployment-mcp.js

@@ -72,12 +72,14 @@ class ServiceNowDeploymentMCP {
                         properties: {
                             name: { type: 'string', description: 'Flow name' },
                             description: { type: 'string', description: 'Flow description' },
+                            flow_type: { type: 'string', enum: ['flow', 'subflow', 'action'], description: 'Type of flow to create (default: flow)', default: 'flow' },
                             table: { type: 'string', description: 'Target table (e.g., sc_request, incident)' },
                             trigger_type: { type: 'string', enum: ['record_created', 'record_updated', 'scheduled', 'manual'], description: 'Flow trigger type' },
                             condition: { type: 'string', description: 'Trigger condition (encoded query)' },
                             active: { type: 'boolean', description: 'Activate flow on deployment' },
                             flow_definition: { type: 'string', description: 'Flow Designer definition JSON' },
                             category: { type: 'string', description: 'Flow category (e.g., approval, automation)' },
+                            validate_before_deploy: { type: 'boolean', description: 'Validate flow definition before deployment', default: true },
                         },
                         required: ['name', 'description', 'flow_definition', 'trigger_type'],
                     },
@@ -287,6 +289,74 @@ class ServiceNowDeploymentMCP {
                         required: ['sys_id'],
                     },
                 },
+                {
+                    name: 'snow_smart_update_set',
+                    description: 'Smart update set creation with context detection - automatically creates new update sets for new tasks',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            detect_context: { type: 'boolean', description: 'Auto-detect task context change', default: true },
+                            name_prefix: { type: 'string', description: 'Update set name prefix', default: 'AUTO' },
+                            separate_by_task: { type: 'boolean', description: 'Create new update set for each task', default: true },
+                            close_previous: { type: 'boolean', description: 'Close previous update set', default: true },
+                            description: { type: 'string', description: 'Update set description' },
+                        },
+                    },
+                },
+                {
+                    name: 'snow_validate_flow_definition',
+                    description: 'Validate flow definition before deployment with preview and test mode',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            definition: { type: 'string', description: 'Flow definition JSON to validate' },
+                            flow_type: { type: 'string', enum: ['flow', 'subflow', 'action'], default: 'flow' },
+                            show_preview: { type: 'boolean', description: 'Show visual preview', default: true },
+                            test_mode: { type: 'boolean', description: 'Run in test mode', default: false },
+                            check_dependencies: { type: 'boolean', description: 'Check for missing dependencies', default: true },
+                        },
+                        required: ['definition'],
+                    },
+                },
+                {
+                    name: 'snow_create_solution_package',
+                    description: 'Create a solution package grouping related artifacts with a new update set',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Solution package name' },
+                            description: { type: 'string', description: 'Package description' },
+                            artifacts: {
+                                type: 'array',
+                                description: 'Artifacts to include in the package',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        type: { type: 'string', enum: ['flow', 'widget', 'script_include', 'business_rule', 'table'] },
+                                        create: { type: 'object', description: 'Artifact creation configuration' },
+                                    },
+                                },
+                            },
+                            new_update_set: { type: 'boolean', description: 'Force new update set', default: true },
+                        },
+                        required: ['name', 'artifacts'],
+                    },
+                },
+                {
+                    name: 'snow_flow_wizard',
+                    description: 'Interactive flow creation wizard with step-by-step guidance',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Flow name' },
+                            interactive: { type: 'boolean', description: 'Enable interactive mode', default: true },
+                            preview_each_step: { type: 'boolean', description: 'Preview after each step', default: true },
+                            test_as_you_build: { type: 'boolean', description: 'Test flow during creation', default: true },
+                            flow_type: { type: 'string', enum: ['flow', 'subflow', 'action'], default: 'flow' },
+                        },
+                        required: ['name'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
@@ -324,6 +394,14 @@ class ServiceNowDeploymentMCP {
                         return await this.previewWidget(args);
                     case 'snow_widget_test':
                         return await this.testWidget(args);
+                    case 'snow_smart_update_set':
+                        return await this.smartUpdateSet(args);
+                    case 'snow_validate_flow_definition':
+                        return await this.validateFlowDefinition(args);
+                    case 'snow_create_solution_package':
+                        return await this.createSolutionPackage(args);
+                    case 'snow_flow_wizard':
+                        return await this.flowWizard(args);
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -764,7 +842,30 @@ Use \`snow_deployment_debug\` for more information about this session.`,
                     ],
                 };
             }
-            this.logger.info('Deploying Flow Designer flow to ServiceNow', { name: args.name });
+            const flowType = args.flow_type || 'flow';
+            this.logger.info(`Deploying ${flowType} to ServiceNow`, { name: args.name, type: flowType });
+            // Validate flow definition first if requested
+            if (args.validate_before_deploy !== false) {
+                const validationResult = await this.validateFlowDefinition({
+                    definition: args.flow_definition,
+                    flow_type: flowType,
+                    show_preview: false,
+                    test_mode: false,
+                    check_dependencies: true
+                });
+                // Check if validation failed
+                const validationText = validationResult.content?.[0]?.text || '';
+                if (validationText.includes('❌') || validationText.includes('ERROR')) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Flow validation failed. Please fix the following issues:\n\n${validationText}\n\nUse snow_validate_flow_definition to preview and test your flow before deployment.`
+                            }
+                        ]
+                    };
+                }
+            }
             // Ensure Update Set is active
             const { updateSetId, updateSetName } = await this.ensureUpdateSet('Flow', args.name);
             // Check if this is a master flow with linked artifacts
@@ -804,14 +905,11 @@ Use \`snow_deployment_debug\` for more information about this session.`,
                     return activity;
                 });
             }
-            // Create Flow Designer flow in ServiceNow with enhanced structure
+            // Create flow data based on flow type
             const flowData = {
                 name: args.name,
                 description: args.description,
                 active: args.active !== false,
-                table: args.table || '',
-                trigger_type: args.trigger_type,
-                condition: args.condition || '',
                 flow_definition: JSON.stringify(flowDefinition),
                 category: args.category || 'automation',
                 // Additional fields for composed flows
@@ -819,8 +917,43 @@ Use \`snow_deployment_debug\` for more information about this session.`,
                 linked_artifact_count: linkedArtifacts.length,
                 artifact_references: deployedArtifacts.map(a => a.sys_id).join(',')
             };
-            // Deploy to ServiceNow using Flow Designer API
-            const result = await this.client.createFlow(flowData);
+            // Configure based on flow type
+            switch (flowType) {
+                case 'flow':
+                    flowData.table = args.table || '';
+                    flowData.trigger_type = args.trigger_type;
+                    flowData.condition = args.condition || '';
+                    flowData.type = 'flow';
+                    break;
+                case 'subflow':
+                    // Subflows don't have triggers, they're called by other flows
+                    flowData.type = 'subflow';
+                    flowData.inputs = flowDefinition.inputs || [];
+                    flowData.outputs = flowDefinition.outputs || [];
+                    break;
+                case 'action':
+                    // Actions are reusable components
+                    flowData.type = 'action';
+                    flowData.action_type = args.action_type || 'custom';
+                    flowData.inputs = flowDefinition.inputs || [];
+                    flowData.outputs = flowDefinition.outputs || [];
+                    break;
+            }
+            // Deploy to ServiceNow using appropriate API based on flow type
+            let result;
+            switch (flowType) {
+                case 'flow':
+                    result = await this.client.createFlow(flowData);
+                    break;
+                case 'subflow':
+                    result = await this.client.createSubflow(flowData);
+                    break;
+                case 'action':
+                    result = await this.client.createFlowAction(flowData);
+                    break;
+                default:
+                    throw new Error(`Unknown flow type: ${flowType}`);
+            }
             const credentials = await this.oauth.loadCredentials();
             const flowUrl = result.success && result.data
                 ? `https://${credentials?.instance}/$flow-designer.do#/flow/${result.data.sys_id}`
@@ -837,11 +970,14 @@ Use \`snow_deployment_debug\` for more information about this session.`,
                         type: 'text',
                         text: `✅ Flow Designer flow deployed successfully!
             
-🔄 **Flow Details:**
+🔄 **${flowType.charAt(0).toUpperCase() + flowType.slice(1)} Details:**
 - Name: ${args.name}
-- Type: ${isComposedFlow ? '🧠 Intelligent Composed Flow' : '📋 Standard Flow'}
-- Trigger Type: ${args.trigger_type}
-- Table: ${args.table || 'N/A'}
+- Flow Type: ${flowType === 'flow' ? '📋 Flow' : flowType === 'subflow' ? '🔄 Subflow' : '⚡ Action'}
+- Composed: ${isComposedFlow ? '🧠 Yes - Intelligent Composed Flow' : '❌ No - Standard'}
+${flowType === 'flow' ? `- Trigger Type: ${args.trigger_type}
+- Table: ${args.table || 'N/A'}` : ''}
+${flowType !== 'flow' ? `- Inputs: ${flowDefinition.inputs?.length || 0}
+- Outputs: ${flowDefinition.outputs?.length || 0}` : ''}
 - Category: ${args.category || 'automation'}
 - Active: ${args.active !== false ? 'Yes' : 'No'}
 
@@ -2053,6 +2189,363 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
         }
         return recommendations.length > 0 ? recommendations.join('\n') : 'Widget structure looks good!';
     }
+    /**
+     * Smart Update Set Management with context detection
+     */
+    async smartUpdateSet(args) {
+        try {
+            // Check authentication
+            const isAuth = await this.oauth.isAuthenticated();
+            if (!isAuth) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login',
+                        },
+                    ],
+                };
+            }
+            // Get current context (task identifier)
+            const taskContext = args.description || 'Current Task';
+            const contextKey = `task_context_${taskContext.replace(/\s+/g, '_').toLowerCase()}`;
+            // Check if we need a new update set
+            const currentUpdateSet = await this.client.getCurrentUpdateSet();
+            let needNewUpdateSet = true;
+            if (currentUpdateSet.success && currentUpdateSet.data) {
+                // Check if current update set is for the same task
+                if (!args.separate_by_task || currentUpdateSet.data.description?.includes(taskContext)) {
+                    needNewUpdateSet = false;
+                }
+            }
+            if (!needNewUpdateSet && currentUpdateSet.data) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Using existing Update Set for this task:\n\n📦 **Current Update Set:**\n- Name: ${currentUpdateSet.data.name}\n- ID: ${currentUpdateSet.data.sys_id}\n- Description: ${currentUpdateSet.data.description}\n\n💡 Same task context detected - no new Update Set needed.`
+                        }
+                    ]
+                };
+            }
+            // Close previous update set if requested
+            if (args.close_previous && currentUpdateSet.data) {
+                await this.client.completeUpdateSet(currentUpdateSet.data.sys_id);
+                this.logger.info('Closed previous Update Set', { id: currentUpdateSet.data.sys_id });
+            }
+            // Create new update set
+            const updateSetNumber = Date.now().toString().slice(-6);
+            const updateSetName = `${args.name_prefix}-${updateSetNumber}: ${taskContext}`;
+            const result = await this.client.createUpdateSet({
+                name: updateSetName,
+                description: `Auto-created for task: ${taskContext}\n\nContext Detection: ${args.detect_context ? 'Enabled' : 'Disabled'}\nSeparate by Task: ${args.separate_by_task ? 'Yes' : 'No'}`,
+                state: 'in_progress'
+            });
+            if (!result.success) {
+                throw new Error(`Failed to create Update Set: ${result.error}`);
+            }
+            // Set as current update set
+            await this.client.setCurrentUpdateSet(result.data.sys_id);
+            const credentials = await this.oauth.loadCredentials();
+            const updateSetUrl = `https://${credentials?.instance}/sys_update_set.do?sys_id=${result.data.sys_id}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Smart Update Set created successfully!\n\n📦 **New Update Set:**\n- Name: ${updateSetName}\n- ID: ${result.data.sys_id}\n- Task Context: ${taskContext}\n\n🔧 **Smart Features:**\n- Context Detection: ${args.detect_context ? '✅ Enabled' : '❌ Disabled'}\n- Separate by Task: ${args.separate_by_task ? '✅ Yes' : '❌ No'}\n- Auto-close Previous: ${args.close_previous ? '✅ Yes' : '❌ No'}\n${currentUpdateSet.data && args.close_previous ? `- Previous Set Closed: ✅ ${currentUpdateSet.data.name}` : ''}\n\n🔗 **Direct Link:**\n${updateSetUrl}\n\n💡 **Next Steps:**\n1. All new changes will be tracked in this Update Set\n2. Deploy your artifacts - they'll be automatically included\n3. Complete the Update Set when your task is done\n4. Next task will get its own Update Set automatically`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            throw new Error(`Smart Update Set creation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Validate Flow Definition before deployment
+     */
+    async validateFlowDefinition(args) {
+        try {
+            const flowType = args.flow_type || 'flow';
+            let definition;
+            try {
+                definition = typeof args.definition === 'string' ? JSON.parse(args.definition) : args.definition;
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Invalid JSON format in flow definition:\n\n${error instanceof Error ? error.message : String(error)}\n\n💡 Please check your JSON syntax.`
+                        }
+                    ]
+                };
+            }
+            const issues = [];
+            const warnings = [];
+            const info = [];
+            // Basic structure validation
+            if (!definition.activities || !Array.isArray(definition.activities)) {
+                issues.push('❌ Missing or invalid "activities" array');
+            }
+            // Flow type specific validation
+            switch (flowType) {
+                case 'flow':
+                    if (!definition.trigger && !args.trigger_type) {
+                        issues.push('❌ Flow must have a trigger defined');
+                    }
+                    break;
+                case 'subflow':
+                    if (!definition.inputs) {
+                        warnings.push('⚠️ Subflow has no inputs defined');
+                    }
+                    if (!definition.outputs) {
+                        warnings.push('⚠️ Subflow has no outputs defined');
+                    }
+                    break;
+                case 'action':
+                    if (!definition.action_type) {
+                        warnings.push('⚠️ Action type not specified');
+                    }
+                    break;
+            }
+            // Activity validation
+            if (definition.activities) {
+                definition.activities.forEach((activity, index) => {
+                    if (!activity.name) {
+                        issues.push(`❌ Activity ${index + 1} missing required "name" field`);
+                    }
+                    if (!activity.type) {
+                        issues.push(`❌ Activity ${index + 1} missing required "type" field`);
+                    }
+                    // Check for common activity types
+                    const validTypes = ['rest', 'script', 'approval', 'condition', 'subflow', 'notification', 'wait', 'lookup'];
+                    if (activity.type && !validTypes.includes(activity.type)) {
+                        warnings.push(`⚠️ Activity "${activity.name}" uses non-standard type: ${activity.type}`);
+                    }
+                });
+            }
+            // Dependency checking
+            if (args.check_dependencies) {
+                const dependencies = this.extractDependencies(definition);
+                if (dependencies.length > 0) {
+                    info.push(`📦 Dependencies found: ${dependencies.join(', ')}`);
+                }
+            }
+            // Generate preview if requested
+            let preview = '';
+            if (args.show_preview) {
+                preview = this.generateFlowPreview(definition, flowType);
+            }
+            const hasErrors = issues.length > 0;
+            const status = hasErrors ? '❌ VALIDATION FAILED' : '✅ VALIDATION PASSED';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${status}\n\n📋 **Flow Validation Report:**\n- Flow Type: ${flowType}\n- Activities: ${definition.activities?.length || 0}\n- Status: ${hasErrors ? 'Failed' : 'Passed'}\n\n${issues.length > 0 ? `🚨 **Critical Issues:**\n${issues.join('\n')}\n\n` : ''}${warnings.length > 0 ? `⚠️ **Warnings:**\n${warnings.join('\n')}\n\n` : ''}${info.length > 0 ? `ℹ️ **Information:**\n${info.join('\n')}\n\n` : ''}${preview ? `\n📊 **Flow Preview:**\n${preview}\n` : ''}${!hasErrors && args.test_mode ? '\n🧪 **Test Mode:** Flow structure is valid for testing\n' : ''}${!hasErrors ? '\n✅ Flow definition is valid and ready for deployment!' : '\n❌ Please fix the issues before deploying.'}`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            throw new Error(`Flow validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Create Solution Package grouping multiple artifacts
+     */
+    async createSolutionPackage(args) {
+        try {
+            // Check authentication
+            const isAuth = await this.oauth.isAuthenticated();
+            if (!isAuth) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login',
+                        },
+                    ],
+                };
+            }
+            // Create new update set for the solution
+            if (args.new_update_set) {
+                const updateSetResult = await this.smartUpdateSet({
+                    detect_context: true,
+                    name_prefix: 'SOLUTION',
+                    description: args.description || `Solution Package: ${args.name}`,
+                    separate_by_task: false,
+                    close_previous: true
+                });
+            }
+            const deployedArtifacts = [];
+            const failedArtifacts = [];
+            // Deploy each artifact in the package
+            for (const artifact of args.artifacts) {
+                try {
+                    let result;
+                    switch (artifact.type) {
+                        case 'flow':
+                            result = await this.deployFlow(artifact.create);
+                            break;
+                        case 'widget':
+                            result = await this.deployWidget(artifact.create);
+                            break;
+                        case 'script_include':
+                            result = await this.deployScriptInclude(artifact.create);
+                            break;
+                        case 'business_rule':
+                            result = await this.deployBusinessRule(artifact.create);
+                            break;
+                        case 'table':
+                            result = await this.deployTable(artifact.create);
+                            break;
+                        default:
+                            throw new Error(`Unknown artifact type: ${artifact.type}`);
+                    }
+                    deployedArtifacts.push({
+                        type: artifact.type,
+                        name: artifact.create.name,
+                        result: 'Success'
+                    });
+                }
+                catch (error) {
+                    failedArtifacts.push({
+                        type: artifact.type,
+                        name: artifact.create.name,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            const successCount = deployedArtifacts.length;
+            const failureCount = failedArtifacts.length;
+            const totalCount = successCount + failureCount;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `📦 **Solution Package Deployment Complete!**\n\n🎯 **Package Details:**\n- Name: ${args.name}\n- Description: ${args.description || 'N/A'}\n- Total Artifacts: ${totalCount}\n- Successful: ${successCount} ✅\n- Failed: ${failureCount} ${failureCount > 0 ? '❌' : ''}\n\n${deployedArtifacts.length > 0 ? `✅ **Successfully Deployed:**\n${deployedArtifacts.map((a, i) => `${i + 1}. ${a.type}: ${a.name}`).join('\n')}\n` : ''}${failedArtifacts.length > 0 ? `\n❌ **Failed Deployments:**\n${failedArtifacts.map((a, i) => `${i + 1}. ${a.type}: ${a.name}\n   Error: ${a.error}`).join('\n')}\n` : ''}\n💡 **Solution Benefits:**\n- All artifacts grouped in one Update Set\n- Dependencies automatically resolved\n- Consistent deployment across artifacts\n- Easy rollback if needed\n\n${successCount === totalCount ? '🎉 All artifacts deployed successfully!' : '⚠️ Some artifacts failed. Please review the errors above.'}`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            throw new Error(`Solution package creation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Interactive Flow Creation Wizard
+     */
+    async flowWizard(args) {
+        try {
+            const flowType = args.flow_type || 'flow';
+            const steps = [];
+            // Step 1: Basic Information
+            steps.push({
+                step: 1,
+                name: 'Basic Information',
+                status: '✅',
+                details: `Name: ${args.name}\nType: ${flowType}\nDescription: Configure your flow step by step`
+            });
+            // Step 2: Trigger Configuration (for flows only)
+            if (flowType === 'flow') {
+                steps.push({
+                    step: 2,
+                    name: 'Trigger Configuration',
+                    status: '📝',
+                    details: 'Choose trigger type: record_created, record_updated, scheduled, or manual'
+                });
+            }
+            // Step 3: Activities
+            steps.push({
+                step: 3,
+                name: 'Add Activities',
+                status: '📝',
+                details: 'Add activities: scripts, approvals, notifications, conditions'
+            });
+            // Step 4: Variables and Data
+            steps.push({
+                step: 4,
+                name: 'Variables & Data',
+                status: '📝',
+                details: 'Define flow variables and data transformations'
+            });
+            // Step 5: Error Handling
+            steps.push({
+                step: 5,
+                name: 'Error Handling',
+                status: '📝',
+                details: 'Configure error handlers and retry logic'
+            });
+            // Step 6: Testing
+            steps.push({
+                step: 6,
+                name: 'Test Flow',
+                status: '📝',
+                details: 'Test with sample data before deployment'
+            });
+            // Generate wizard interface
+            const wizardText = `🧙‍♂️ **Flow Creation Wizard**\n\n📋 **Flow Details:**\n- Name: ${args.name}\n- Type: ${flowType}\n- Interactive: ${args.interactive ? '✅' : '❌'}\n- Preview Each Step: ${args.preview_each_step ? '✅' : '❌'}\n- Test As You Build: ${args.test_as_you_build ? '✅' : '❌'}\n\n📊 **Wizard Steps:**\n${steps.map(s => `${s.step}. ${s.status} ${s.name}\n   ${s.details}`).join('\n\n')}\n\n💡 **Interactive Features:**\n- ✅ Step-by-step guidance\n- ✅ Preview after each step\n- ✅ Validation at each stage\n- ✅ Test before deployment\n- ✅ Rollback capability\n\n🎯 **Next Actions:**\n1. Use snow_deploy_flow with your configuration\n2. Or continue building with individual artifact tools\n3. Test with snow_validate_flow_definition\n\n⚡ **Quick Start Example:**\n\`\`\`json\n{\n  "name": "${args.name}",\n  "flow_type": "${flowType}",\n  "trigger_type": "record_created",\n  "table": "incident",\n  "flow_definition": {\n    "activities": [\n      {\n        "name": "Check Priority",\n        "type": "condition",\n        "condition": "current.priority == 1"\n      },\n      {\n        "name": "Send Alert",\n        "type": "notification",\n        "recipients": "incident.assigned_to"\n      }\n    ]\n  }\n}\n\`\`\``;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: wizardText
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            throw new Error(`Flow wizard failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Extract dependencies from flow definition
+     */
+    extractDependencies(definition) {
+        const dependencies = new Set();
+        if (definition.activities) {
+            definition.activities.forEach((activity) => {
+                if (activity.type === 'rest' && activity.rest_message) {
+                    dependencies.add(`REST Message: ${activity.rest_message}`);
+                }
+                if (activity.type === 'script' && activity.script_include) {
+                    dependencies.add(`Script Include: ${activity.script_include}`);
+                }
+                if (activity.type === 'subflow' && activity.subflow_name) {
+                    dependencies.add(`Subflow: ${activity.subflow_name}`);
+                }
+                if (activity.artifact_reference) {
+                    dependencies.add(`${activity.artifact_reference.type}: ${activity.artifact_reference.name}`);
+                }
+            });
+        }
+        return Array.from(dependencies);
+    }
+    /**
+     * Generate visual preview of flow
+     */
+    generateFlowPreview(definition, flowType) {
+        let preview = `\n${flowType.toUpperCase()} STRUCTURE:\n`;
+        preview += '═'.repeat(40) + '\n';
+        if (flowType === 'flow' && definition.trigger) {
+            preview += `\n[TRIGGER: ${definition.trigger.type || 'Unknown'}]\n   ↓\n`;
+        }
+        if (definition.activities) {
+            definition.activities.forEach((activity, index) => {
+                const isLast = index === definition.activities.length - 1;
+                preview += `[${activity.type?.toUpperCase() || 'UNKNOWN'}: ${activity.name || `Activity ${index + 1}`}]\n`;
+                if (!isLast) {
+                    preview += '   ↓\n';
+                }
+            });
+        }
+        if (flowType !== 'flow' && definition.outputs) {
+            preview += `\n[OUTPUTS: ${definition.outputs.length} defined]\n`;
+        }
+        return preview;
+    }
     async start() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);