snow-flow 4.6.8 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_analyze_query.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * snow_analyze_query - Query optimization and analysis
+ *
+ * Analyze ServiceNow queries for performance bottlenecks, suggest
+ * optimizations, and provide index recommendations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_analyze_query',
+    description: 'Analyze and optimize ServiceNow queries for performance',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table: {
+                type: 'string',
+                description: 'Table name to query'
+            },
+            query: {
+                type: 'string',
+                description: 'Encoded query string to analyze'
+            },
+            analyze_indexes: {
+                type: 'boolean',
+                description: 'Check for index usage and recommendations',
+                default: true
+            },
+            suggest_optimizations: {
+                type: 'boolean',
+                description: 'Provide query optimization suggestions',
+                default: true
+            }
+        },
+        required: ['table', 'query']
+    }
+};
+async function execute(args, context) {
+    const { table, query, analyze_indexes = true, suggest_optimizations = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const analysis = {
+            query,
+            table,
+            issues: [],
+            suggestions: [],
+            index_analysis: null,
+            estimated_performance: 'unknown'
+        };
+        // Parse query conditions
+        const conditions = query.split('^').filter((c) => c.length > 0);
+        analysis.condition_count = conditions.length;
+        // Check for common anti-patterns
+        const antiPatterns = [];
+        // 1. Check for LIKE queries (slow)
+        if (query.includes('LIKE')) {
+            antiPatterns.push({
+                type: 'LIKE_QUERY',
+                severity: 'medium',
+                description: 'LIKE queries can be slow on large tables',
+                suggestion: 'Consider using indexed text search or exact matches where possible'
+            });
+        }
+        // 2. Check for OR conditions (can prevent index usage)
+        const orCount = (query.match(/\^OR/g) || []).length;
+        if (orCount > 2) {
+            antiPatterns.push({
+                type: 'EXCESSIVE_OR',
+                severity: 'high',
+                description: `Query contains ${orCount} OR conditions, which may prevent index usage`,
+                suggestion: 'Consider breaking into multiple queries or restructuring conditions'
+            });
+        }
+        // 3. Check for inequality conditions on multiple fields
+        const inequalities = conditions.filter((c) => c.includes('!=') || c.includes('>') || c.includes('<'));
+        if (inequalities.length > 3) {
+            antiPatterns.push({
+                type: 'MULTIPLE_INEQUALITIES',
+                severity: 'medium',
+                description: 'Multiple inequality conditions can be inefficient',
+                suggestion: 'Consider using equality conditions or range queries where possible'
+            });
+        }
+        // 4. Check for query on reference fields without joins
+        const refFields = conditions.filter((c) => c.includes('.'));
+        if (refFields.length > 0) {
+            analysis.uses_dot_walking = true;
+            antiPatterns.push({
+                type: 'DOT_WALKING',
+                severity: 'high',
+                description: 'Query uses dot-walking which requires table joins',
+                suggestion: 'Minimize dot-walking or ensure reference fields are indexed',
+                affected_conditions: refFields
+            });
+        }
+        analysis.anti_patterns = antiPatterns;
+        // Get table record count for performance estimation
+        const countResponse = await client.get(`/api/now/stats/${table}`, {
+            params: {
+                sysparm_count: 'true',
+                sysparm_query: query
+            }
+        });
+        const totalRecords = parseInt(countResponse.data.result?.stats?.count || '0');
+        analysis.matching_records = totalRecords;
+        // Analyze indexes if requested
+        if (analyze_indexes) {
+            const indexResponse = await client.get('/api/now/table/sys_db_index', {
+                params: {
+                    sysparm_query: `table=${table}^active=true`,
+                    sysparm_fields: 'name,indexed_column,unique',
+                    sysparm_limit: 100
+                }
+            });
+            const indexes = indexResponse.data.result || [];
+            const indexedFields = indexes.map((idx) => idx.indexed_column?.value || idx.indexed_column);
+            // Check which query fields are indexed
+            const queryFields = conditions.map((c) => c.split(/[!=<>]/)[0]);
+            const indexedQueryFields = queryFields.filter((f) => indexedFields.includes(f));
+            const unindexedQueryFields = queryFields.filter((f) => !indexedFields.includes(f));
+            analysis.index_analysis = {
+                total_indexes: indexes.length,
+                indexed_query_fields: indexedQueryFields,
+                unindexed_query_fields: unindexedQueryFields,
+                index_coverage: indexedQueryFields.length / queryFields.length
+            };
+            if (unindexedQueryFields.length > 0) {
+                analysis.suggestions.push({
+                    type: 'INDEX_RECOMMENDATION',
+                    priority: 'high',
+                    description: `Consider adding indexes for: ${unindexedQueryFields.join(', ')}`,
+                    estimated_improvement: totalRecords > 10000 ? 'significant' : 'moderate'
+                });
+            }
+        }
+        // Estimate performance
+        if (totalRecords < 1000 && antiPatterns.length === 0) {
+            analysis.estimated_performance = 'excellent';
+        }
+        else if (totalRecords < 10000 && antiPatterns.length <= 1) {
+            analysis.estimated_performance = 'good';
+        }
+        else if (totalRecords < 100000 && antiPatterns.length <= 2) {
+            analysis.estimated_performance = 'moderate';
+        }
+        else {
+            analysis.estimated_performance = 'poor';
+        }
+        // Optimization suggestions
+        if (suggest_optimizations) {
+            if (analysis.estimated_performance === 'poor') {
+                analysis.suggestions.push({
+                    type: 'QUERY_RESTRUCTURE',
+                    priority: 'critical',
+                    description: 'Query may perform poorly on large datasets',
+                    actions: [
+                        'Add appropriate indexes',
+                        'Reduce number of OR conditions',
+                        'Minimize dot-walking',
+                        'Consider query caching'
+                    ]
+                });
+            }
+            if (conditions.length > 10) {
+                analysis.suggestions.push({
+                    type: 'COMPLEXITY_REDUCTION',
+                    priority: 'medium',
+                    description: 'Query has many conditions which may be simplified',
+                    suggestion: 'Review if all conditions are necessary'
+                });
+            }
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            analysis,
+            performance_rating: analysis.estimated_performance,
+            issues_found: antiPatterns.length + (analysis.index_analysis?.unindexed_query_fields.length || 0),
+            optimization_potential: analysis.suggestions.length > 0,
+            recommendations: analysis.suggestions
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_analyze_query.js.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_batch_api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_batch_api - Batch API operations (80% API reduction)
+ *
+ * Execute multiple API operations in a single request using ServiceNow's
+ * Batch API, dramatically reducing network overhead and improving performance.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_batch_api.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_batch_api.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * snow_batch_api - Batch API operations (80% API reduction)
+ *
+ * Execute multiple API operations in a single request using ServiceNow's
+ * Batch API, dramatically reducing network overhead and improving performance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_batch_api',
+    description: 'Execute multiple API operations in single request (80% API call reduction)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            requests: {
+                type: 'array',
+                description: 'Array of API requests to batch',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Unique identifier for this request' },
+                        method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+                        url: { type: 'string', description: 'API endpoint path' },
+                        headers: { type: 'object', description: 'Request headers' },
+                        body: { type: 'object', description: 'Request body (for POST/PUT/PATCH)' }
+                    },
+                    required: ['id', 'method', 'url']
+                }
+            },
+            batch_execution_order: {
+                type: 'string',
+                enum: ['sequential', 'parallel'],
+                description: 'Execute requests sequentially or in parallel',
+                default: 'parallel'
+            },
+            exclude_reference_link: {
+                type: 'boolean',
+                description: 'Exclude reference links in responses',
+                default: true
+            }
+        },
+        required: ['requests']
+    }
+};
+async function execute(args, context) {
+    const { requests, batch_execution_order = 'parallel', exclude_reference_link = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        if (!requests || requests.length === 0) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'At least one request is required', { details: { message: 'Provide requests array with API operations' } });
+        }
+        if (requests.length > 100) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Maximum 100 requests allowed in batch', { details: { provided: requests.length, maximum: 100 } });
+        }
+        // Build batch request payload
+        const batchPayload = {
+            batch_request_id: `batch_${Date.now()}`,
+            rest_requests: requests.map((req) => ({
+                id: req.id,
+                method: req.method,
+                url: req.url,
+                headers: {
+                    ...req.headers,
+                    'Content-Type': 'application/json'
+                },
+                body: req.body ? JSON.stringify(req.body) : undefined,
+                exclude_reference_link: exclude_reference_link.toString()
+            }))
+        };
+        // Execute batch request
+        const response = await client.post('/api/now/v1/batch', batchPayload, {
+            params: {
+                execution_order: batch_execution_order
+            }
+        });
+        const batchResult = response.data;
+        // Parse responses
+        const responses = (batchResult.serviced_requests || []).map((serviceReq) => ({
+            id: serviceReq.id,
+            status_code: serviceReq.status_code,
+            status_text: serviceReq.status_text,
+            body: serviceReq.body ? JSON.parse(serviceReq.body) : null,
+            headers: serviceReq.headers,
+            execution_time_ms: serviceReq.execution_time_ms
+        }));
+        // Calculate statistics
+        const stats = {
+            total_requests: requests.length,
+            successful: responses.filter((r) => r.status_code >= 200 && r.status_code < 300).length,
+            failed: responses.filter((r) => r.status_code >= 400).length,
+            total_execution_time_ms: responses.reduce((sum, r) => sum + (r.execution_time_ms || 0), 0),
+            average_time_per_request: responses.length > 0
+                ? responses.reduce((sum, r) => sum + (r.execution_time_ms || 0), 0) / responses.length
+                : 0,
+            api_call_reduction: Math.round(((requests.length - 1) / requests.length) * 100)
+        };
+        return (0, error_handler_js_1.createSuccessResult)({
+            batch_id: batchResult.batch_request_id,
+            execution_order: batch_execution_order,
+            responses,
+            statistics: stats,
+            all_successful: stats.failed === 0,
+            performance_gain: `${stats.api_call_reduction}% fewer API calls`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_batch_api.js.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_create_email_config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_create_email_config - Email server configuration
+ *
+ * Create email server configurations for SMTP, POP3, or IMAP.
+ * Configures ports, encryption, and authentication.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_create_email_config.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_create_email_config.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * snow_create_email_config - Email server configuration
+ *
+ * Create email server configurations for SMTP, POP3, or IMAP.
+ * Configures ports, encryption, and authentication.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_create_email_config',
+    description: 'Create email server configuration for SMTP, POP3, or IMAP',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Email configuration name'
+            },
+            serverType: {
+                type: 'string',
+                enum: ['SMTP', 'POP3', 'IMAP', 'SMTPS', 'POP3S', 'IMAPS'],
+                description: 'Email server type'
+            },
+            serverName: {
+                type: 'string',
+                description: 'Email server hostname or IP'
+            },
+            port: {
+                type: 'number',
+                description: 'Server port (default: auto-detect by type)'
+            },
+            encryption: {
+                type: 'string',
+                enum: ['SSL', 'TLS', 'None'],
+                description: 'Encryption type',
+                default: 'None'
+            },
+            username: {
+                type: 'string',
+                description: 'Authentication username'
+            },
+            password: {
+                type: 'string',
+                description: 'Authentication password'
+            },
+            description: {
+                type: 'string',
+                description: 'Configuration description'
+            },
+            active: {
+                type: 'boolean',
+                description: 'Active flag',
+                default: true
+            }
+        },
+        required: ['name', 'serverType', 'serverName']
+    }
+};
+const DEFAULT_PORTS = {
+    'SMTP': 587,
+    'SMTPS': 465,
+    'POP3': 110,
+    'POP3S': 995,
+    'IMAP': 143,
+    'IMAPS': 993
+};
+async function execute(args, context) {
+    const { name, serverType, serverName, port, encryption = 'None', username = '', password = '', description = '', active = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Auto-detect port if not specified
+        const finalPort = port || DEFAULT_PORTS[serverType] || 25;
+        const emailConfigData = {
+            name,
+            type: serverType,
+            server: serverName,
+            port: finalPort,
+            encryption,
+            user_name: username,
+            password,
+            description,
+            active
+        };
+        const response = await client.post('/api/now/table/sys_email_account', emailConfigData);
+        const emailConfig = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            created: true,
+            email_config: {
+                sys_id: emailConfig.sys_id,
+                name: emailConfig.name,
+                type: serverType,
+                server: serverName,
+                port: finalPort,
+                encryption,
+                active
+            },
+            message: `Email configuration '${name}' created successfully for ${serverType} on ${serverName}:${finalPort}`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_create_email_config.js.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_create_event.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_create_event - System event creation
+ *
+ * Create and trigger ServiceNow system events with parameters,
+ * queuing, and notification integration.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_create_event.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_create_event.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * snow_create_event - System event creation
+ *
+ * Create and trigger ServiceNow system events with parameters,
+ * queuing, and notification integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_create_event',
+    description: 'Create and trigger system events with parameters',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Event name'
+            },
+            table: {
+                type: 'string',
+                description: 'Table associated with event'
+            },
+            record_sys_id: {
+                type: 'string',
+                description: 'Record sys_id that triggered the event'
+            },
+            parameters: {
+                type: 'object',
+                description: 'Event parameters (key-value pairs)'
+            },
+            description: {
+                type: 'string',
+                description: 'Event description'
+            },
+            trigger_immediately: {
+                type: 'boolean',
+                description: 'Trigger event immediately vs queue for processing',
+                default: true
+            }
+        },
+        required: ['name']
+    }
+};
+async function execute(args, context) {
+    const { name, table = '', record_sys_id = '', parameters = {}, description = '', trigger_immediately = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        if (trigger_immediately) {
+            // Trigger event immediately using script
+            const paramString = Object.entries(parameters)
+                .map(([key, value]) => `parm${Object.keys(parameters).indexOf(key) + 1}: '${value}'`)
+                .join(', ');
+            const triggerScript = `
+        var eventName = '${name}';
+        var gr = null;
+        ${table && record_sys_id ? `
+        gr = new GlideRecord('${table}');
+        if (gr.get('${record_sys_id}')) {
+          gs.eventQueue(eventName, gr, ${paramString || ''});
+        }
+        ` : `
+        gs.eventQueue(eventName, gr, ${paramString || ''});
+        `}
+        gs.info('Event triggered: ' + eventName);
+      `;
+            await client.post('/api/now/table/sys_script_execution', {
+                script: triggerScript
+            });
+            return (0, error_handler_js_1.createSuccessResult)({
+                triggered: true,
+                event_name: name,
+                table,
+                record_sys_id,
+                parameters,
+                execution_mode: 'immediate',
+                message: 'Event queued for immediate processing'
+            });
+        }
+        else {
+            // Create event queue record
+            const eventData = {
+                event_name: name,
+                table,
+                instance: record_sys_id,
+                param1: parameters.param1 || '',
+                param2: parameters.param2 || '',
+                queue: 'default',
+                state: 'ready'
+            };
+            const response = await client.post('/api/now/table/sysevent', eventData);
+            const eventRecord = response.data.result;
+            return (0, error_handler_js_1.createSuccessResult)({
+                triggered: true,
+                event: {
+                    sys_id: eventRecord.sys_id,
+                    event_name: name,
+                    table,
+                    record_sys_id,
+                    queue: 'default',
+                    state: 'ready'
+                },
+                execution_mode: 'queued',
+                message: 'Event queued for processing'
+            });
+        }
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_create_event.js.map

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_create_field_map.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_create_field_map - Field mapping for transform maps
+ *
+ * Create field mappings within transform maps. Supports data transformation,
+ * coalescing, and default values.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_create_field_map.d.ts.map