snow-flow 1.1.42 → 1.1.45

package/README.md

@@ -2,6 +2,30 @@
 
 Snow-Flow is a powerful multi-agent AI platform that revolutionizes ServiceNow development through intelligent automation, natural language processing, and autonomous deployment capabilities. Built with 11 specialized MCP (Model Context Protocol) servers, Snow-Flow enables developers to create, manage, and deploy ServiceNow artifacts using simple natural language commands.
 
+## 🆕 What's New in v1.1.45
+
+### 🔍 Enhanced Catalog Discovery
+- **Fuzzy Search**: Find "iPhone 6S" even when searching "iPhone"
+- **Smart Variations**: Automatically searches related terms (laptop → notebook, MacBook)
+- **Category Filtering**: Narrow down results by catalog category
+
+### 🧪 Flow Testing Revolution
+- **Mock Data Creation**: Automatically creates test users and catalog items
+- **Approval Simulation**: Auto-approves during testing for complete flow validation
+- **Execution Monitoring**: Real-time tracking with 60-second timeout protection
+- **Cleanup Support**: Optional removal of all test data after execution
+
+### 🔗 Direct Catalog-Flow Integration
+- **Three Linking Methods**: Modern flow_catalog_process, legacy workflow, or process_engine
+- **Variable Mapping**: Map catalog variables to flow inputs with transformations
+- **Trigger Control**: Configure exactly when flows should execute
+- **Test Integration**: Create test requests to verify the link works
+
+### ⚡ Performance Improvements
+- **Bulk Deployment**: Deploy multiple artifacts in a single transaction
+- **Parallel Processing**: Up to 5x faster with concurrent operations
+- **Smart Rollback**: Automatic rollback on any deployment failure
+
 ## 🌟 Key Features
 
 ### 🤖 11 Specialized MCP Servers
@@ -181,6 +205,79 @@ Recognizes common patterns and applies best practices:
 - Notification systems
 - Integration patterns
 
+## 🔧 New MCP Tools (v1.1.44+)
+
+### Catalog Item Search with Fuzzy Matching
+Find catalog items even when you don't know the exact name:
+```javascript
+// In Claude Code with MCP tools
+snow_catalog_item_search({
+  query: "iPhone",          // Finds iPhone 6S, iPhone 7, etc.
+  fuzzy_match: true,       // Intelligent variations
+  category_filter: "mobile devices",
+  include_variables: true  // Get catalog variables
+});
+```
+
+### Flow Testing with Mock Data
+Test flows without affecting production data:
+```javascript
+snow_test_flow_with_mock({
+  flow_id: "equipment_provisioning_flow",
+  create_test_user: true,      // Auto-creates test user
+  mock_catalog_items: true,    // Creates test items
+  mock_catalog_data: [
+    {
+      name: "Test iPhone 6S",
+      price: "699.00"
+    }
+  ],
+  simulate_approvals: true,    // Auto-approves
+  cleanup_after_test: true     // Removes test data
+});
+```
+
+### Direct Catalog-Flow Linking
+Link catalog items directly to flows for automated fulfillment:
+```javascript
+snow_link_catalog_to_flow({
+  catalog_item_id: "iPhone 6S",
+  flow_id: "mobile_provisioning_flow",
+  link_type: "flow_catalog_process",  // Modern approach
+  variable_mapping: [
+    {
+      catalog_variable: "phone_model",
+      flow_input: "device_type"
+    },
+    {
+      catalog_variable: "user_department",
+      flow_input: "department"
+    }
+  ],
+  trigger_condition: 'current.stage == "request_approved"',
+  execution_options: {
+    run_as: "system",
+    wait_for_completion: true
+  },
+  test_link: true  // Creates test request
+});
+```
+
+### Bulk Deployment
+Deploy multiple artifacts in a single transaction:
+```javascript
+snow_bulk_deploy({
+  artifacts: [
+    { type: "widget", data: widgetData },
+    { type: "flow", data: flowData },
+    { type: "script", data: scriptData }
+  ],
+  transaction_mode: true,  // All-or-nothing deployment
+  parallel: true,         // Deploy simultaneously
+  dry_run: false
+});
+```
+
 ## 📁 Project Structure
 
 ```

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

@@ -368,6 +368,35 @@ class ServiceNowDeploymentMCP {
                         required: ['name'],
                     },
                 },
+                {
+                    name: 'snow_bulk_deploy',
+                    description: 'Deploy multiple artifacts in a single operation with transaction support',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            artifacts: {
+                                type: 'array',
+                                description: 'Array of artifacts to deploy',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        type: { type: 'string', enum: ['widget', 'flow', 'script', 'business_rule', 'table', 'application'] },
+                                        sys_id: { type: 'string', description: 'Existing artifact sys_id (for updates)' },
+                                        config: { type: 'object', description: 'Artifact configuration' },
+                                        action: { type: 'string', enum: ['create', 'update', 'deploy'], default: 'deploy' },
+                                    },
+                                    required: ['type', 'config'],
+                                },
+                            },
+                            transaction_mode: { type: 'boolean', description: 'All or nothing deployment', default: true },
+                            parallel: { type: 'boolean', description: 'Deploy in parallel when possible', default: false },
+                            dry_run: { type: 'boolean', description: 'Validate without deploying', default: false },
+                            update_set_name: { type: 'string', description: 'Custom update set name' },
+                            rollback_on_error: { type: 'boolean', description: 'Rollback all on any failure', default: true },
+                        },
+                        required: ['artifacts'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
@@ -415,6 +444,8 @@ class ServiceNowDeploymentMCP {
                         return await this.createSolutionPackage(args);
                     case 'snow_flow_wizard':
                         return await this.flowWizard(args);
+                    case 'snow_bulk_deploy':
+                        return await this.bulkDeploy(args);
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -2625,6 +2656,327 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
             throw new Error(`Flow wizard failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Bulk Deploy Multiple Artifacts
+     */
+    async bulkDeploy(args) {
+        try {
+            const { artifacts, transaction_mode = true, parallel = false, dry_run = false, update_set_name, rollback_on_error = true } = args;
+            this.logger.info(`Starting bulk deployment of ${artifacts.length} artifacts`);
+            // Create or ensure update set
+            if (update_set_name) {
+                await this.client.createUpdateSet({
+                    name: update_set_name,
+                    description: 'Bulk deployment from Snow-Flow',
+                    state: 'in_progress'
+                });
+            }
+            else {
+                await this.client.ensureUpdateSet();
+            }
+            const results = {
+                total: artifacts.length,
+                successful: 0,
+                failed: 0,
+                skipped: 0,
+                details: []
+            };
+            // Track deployed artifacts for rollback
+            const deployedArtifacts = [];
+            try {
+                if (dry_run) {
+                    // Validation only
+                    for (const artifact of artifacts) {
+                        try {
+                            const validation = await this.validateArtifact(artifact);
+                            results.details.push({
+                                type: artifact.type,
+                                name: artifact.config?.name || 'Unknown',
+                                status: validation.valid ? '✅ Valid' : '❌ Invalid',
+                                message: validation.message
+                            });
+                            if (validation.valid) {
+                                results.successful++;
+                            }
+                            else {
+                                results.failed++;
+                            }
+                        }
+                        catch (error) {
+                            results.failed++;
+                            results.details.push({
+                                type: artifact.type,
+                                name: artifact.config?.name || 'Unknown',
+                                status: '❌ Error',
+                                message: error instanceof Error ? error.message : String(error)
+                            });
+                        }
+                    }
+                }
+                else {
+                    // Actual deployment
+                    if (parallel && !transaction_mode) {
+                        // Parallel deployment (no transaction support)
+                        const deploymentPromises = artifacts.map(async (artifact) => {
+                            try {
+                                const result = await this.deployArtifact(artifact);
+                                if (result.success) {
+                                    deployedArtifacts.push({ type: artifact.type, sys_id: result.sys_id });
+                                    results.successful++;
+                                    results.details.push({
+                                        type: artifact.type,
+                                        name: artifact.config?.name || 'Unknown',
+                                        sys_id: result.sys_id,
+                                        status: '✅ Deployed',
+                                        message: result.message
+                                    });
+                                }
+                                else {
+                                    throw new Error(result.message);
+                                }
+                            }
+                            catch (error) {
+                                results.failed++;
+                                results.details.push({
+                                    type: artifact.type,
+                                    name: artifact.config?.name || 'Unknown',
+                                    status: '❌ Failed',
+                                    message: error instanceof Error ? error.message : String(error)
+                                });
+                                if (transaction_mode && rollback_on_error) {
+                                    throw error; // Will trigger rollback
+                                }
+                            }
+                        });
+                        await Promise.all(deploymentPromises);
+                    }
+                    else {
+                        // Sequential deployment (supports transactions)
+                        for (const artifact of artifacts) {
+                            try {
+                                const result = await this.deployArtifact(artifact);
+                                if (result.success) {
+                                    deployedArtifacts.push({ type: artifact.type, sys_id: result.sys_id });
+                                    results.successful++;
+                                    results.details.push({
+                                        type: artifact.type,
+                                        name: artifact.config?.name || 'Unknown',
+                                        sys_id: result.sys_id,
+                                        status: '✅ Deployed',
+                                        message: result.message
+                                    });
+                                }
+                                else {
+                                    throw new Error(result.message);
+                                }
+                            }
+                            catch (error) {
+                                results.failed++;
+                                results.details.push({
+                                    type: artifact.type,
+                                    name: artifact.config?.name || 'Unknown',
+                                    status: '❌ Failed',
+                                    message: error instanceof Error ? error.message : String(error)
+                                });
+                                if (transaction_mode && rollback_on_error) {
+                                    throw error; // Will trigger rollback
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // Rollback if needed
+                if (rollback_on_error && deployedArtifacts.length > 0) {
+                    this.logger.info(`Rolling back ${deployedArtifacts.length} deployed artifacts`);
+                    for (const deployed of deployedArtifacts) {
+                        try {
+                            await this.rollbackArtifact(deployed);
+                            results.details.push({
+                                type: deployed.type,
+                                sys_id: deployed.sys_id,
+                                status: '🔄 Rolled back',
+                                message: 'Artifact rolled back due to deployment failure'
+                            });
+                        }
+                        catch (rollbackError) {
+                            this.logger.error(`Failed to rollback ${deployed.type} ${deployed.sys_id}:`, rollbackError);
+                        }
+                    }
+                }
+                throw error;
+            }
+            // Generate summary
+            let summary = `🚀 Bulk Deployment ${dry_run ? 'Validation' : 'Complete'}\n\n`;
+            summary += `📊 Summary:\n`;
+            summary += `  Total: ${results.total}\n`;
+            summary += `  ✅ Successful: ${results.successful}\n`;
+            summary += `  ❌ Failed: ${results.failed}\n`;
+            if (results.skipped > 0) {
+                summary += `  ⏭️ Skipped: ${results.skipped}\n`;
+            }
+            summary += `\n📋 Details:\n`;
+            for (const detail of results.details) {
+                summary += `\n${detail.status} ${detail.type}: ${detail.name}`;
+                if (detail.sys_id) {
+                    summary += ` (${detail.sys_id})`;
+                }
+                if (detail.message) {
+                    summary += `\n   ${detail.message}`;
+                }
+            }
+            if (transaction_mode && !dry_run) {
+                summary += `\n\n🔒 Transaction Mode: ${results.failed === 0 ? 'All deployed successfully' : 'Rolled back due to failures'}`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary
+                    }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Bulk deployment failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Deploy a single artifact
+     */
+    async deployArtifact(artifact) {
+        const { type, sys_id, config, action = 'deploy' } = artifact;
+        try {
+            switch (type) {
+                case 'widget':
+                    if (action === 'update' && sys_id) {
+                        const result = await this.client.updateRecord('sp_widget', sys_id, config);
+                        return {
+                            success: result.success,
+                            sys_id: sys_id,
+                            message: result.success ? 'Widget updated' : result.error
+                        };
+                    }
+                    else {
+                        const result = await this.deployWidget(config);
+                        return {
+                            success: result.content[0].text.includes('✅'),
+                            sys_id: result.content[0].text.match(/sys_id: ([a-f0-9]+)/)?.[1],
+                            message: 'Widget deployed'
+                        };
+                    }
+                case 'flow':
+                    const flowResult = await this.deployFlow(config);
+                    return {
+                        success: flowResult.content[0].text.includes('✅'),
+                        sys_id: flowResult.content[0].text.match(/sys_id: ([a-f0-9]+)/)?.[1],
+                        message: 'Flow deployed'
+                    };
+                case 'script':
+                case 'script_include':
+                    const scriptResult = await this.client.createRecord('sys_script_include', config);
+                    return {
+                        success: scriptResult.success,
+                        sys_id: scriptResult.data?.sys_id,
+                        message: scriptResult.success ? 'Script deployed' : scriptResult.error
+                    };
+                case 'business_rule':
+                    const ruleResult = await this.client.createRecord('sys_script', config);
+                    return {
+                        success: ruleResult.success,
+                        sys_id: ruleResult.data?.sys_id,
+                        message: ruleResult.success ? 'Business rule deployed' : ruleResult.error
+                    };
+                case 'table':
+                    const tableResult = await this.client.createRecord('sys_db_object', config);
+                    return {
+                        success: tableResult.success,
+                        sys_id: tableResult.data?.sys_id,
+                        message: tableResult.success ? 'Table created' : tableResult.error
+                    };
+                case 'application':
+                    const appResult = await this.deployApplication(config);
+                    return {
+                        success: appResult.content[0].text.includes('✅'),
+                        sys_id: appResult.content[0].text.match(/sys_id: ([a-f0-9]+)/)?.[1],
+                        message: 'Application deployed'
+                    };
+                default:
+                    return {
+                        success: false,
+                        message: `Unknown artifact type: ${type}`
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Validate artifact before deployment
+     */
+    async validateArtifact(artifact) {
+        const { type, config } = artifact;
+        // Basic validation
+        if (!type || !config) {
+            return { valid: false, message: 'Missing type or config' };
+        }
+        // Type-specific validation
+        switch (type) {
+            case 'widget':
+                if (!config.name || !config.template) {
+                    return { valid: false, message: 'Widget requires name and template' };
+                }
+                break;
+            case 'flow':
+                if (!config.name || !config.definition) {
+                    return { valid: false, message: 'Flow requires name and definition' };
+                }
+                break;
+            case 'script':
+            case 'script_include':
+                if (!config.name || !config.script) {
+                    return { valid: false, message: 'Script requires name and script content' };
+                }
+                break;
+            case 'business_rule':
+                if (!config.name || !config.collection || !config.script) {
+                    return { valid: false, message: 'Business rule requires name, collection, and script' };
+                }
+                break;
+            case 'table':
+                if (!config.name || !config.label) {
+                    return { valid: false, message: 'Table requires name and label' };
+                }
+                break;
+            case 'application':
+                if (!config.name || !config.scope) {
+                    return { valid: false, message: 'Application requires name and scope' };
+                }
+                break;
+        }
+        return { valid: true, message: 'Validation passed' };
+    }
+    /**
+     * Rollback deployed artifact
+     */
+    async rollbackArtifact(artifact) {
+        const tableMap = {
+            'widget': 'sp_widget',
+            'flow': 'sys_hub_flow',
+            'script': 'sys_script_include',
+            'script_include': 'sys_script_include',
+            'business_rule': 'sys_script',
+            'table': 'sys_db_object',
+            'application': 'sys_app'
+        };
+        const table = tableMap[artifact.type];
+        if (table) {
+            await this.client.deleteRecord(table, artifact.sys_id);
+        }
+    }
     /**
      * Extract dependencies from flow definition
      */