snow-flow 4.6.8 → 5.0.0

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

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * snow_detect_code_patterns - Code pattern detection and analysis
+ *
+ * Detect common code patterns, anti-patterns, and best practices
+ * in ServiceNow scripts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_detect_code_patterns',
+    description: 'Detect code patterns, anti-patterns, and best practices in ServiceNow scripts',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            code: {
+                type: 'string',
+                description: 'JavaScript code to analyze'
+            },
+            check_es5: {
+                type: 'boolean',
+                description: 'Check for ES5 compliance',
+                default: true
+            },
+            check_performance: {
+                type: 'boolean',
+                description: 'Check for performance anti-patterns',
+                default: true
+            },
+            check_security: {
+                type: 'boolean',
+                description: 'Check for security issues',
+                default: true
+            },
+            check_best_practices: {
+                type: 'boolean',
+                description: 'Check ServiceNow best practices',
+                default: true
+            }
+        },
+        required: ['code']
+    }
+};
+async function execute(args, context) {
+    const { code, check_es5 = true, check_performance = true, check_security = true, check_best_practices = true } = args;
+    try {
+        const patterns = {
+            es5_violations: [],
+            performance_issues: [],
+            security_issues: [],
+            best_practice_violations: [],
+            good_patterns: []
+        };
+        // ES5 Compliance Check
+        if (check_es5) {
+            const es5Patterns = [
+                { regex: /\bconst\s+/g, type: 'const', message: 'Use var instead of const' },
+                { regex: /\blet\s+/g, type: 'let', message: 'Use var instead of let' },
+                { regex: /=>\s*{|=>\s*\(/g, type: 'arrow_function', message: 'Use function() {} instead of arrow functions' },
+                { regex: /`[^`]*`/g, type: 'template_literal', message: 'Use string concatenation instead of template literals' },
+                { regex: /\.\.\./g, type: 'spread', message: 'Spread operator not supported in ES5' },
+                { regex: /class\s+\w+/g, type: 'class', message: 'Use function constructors instead of classes' }
+            ];
+            es5Patterns.forEach(pattern => {
+                const matches = code.match(pattern.regex);
+                if (matches) {
+                    patterns.es5_violations.push({
+                        type: pattern.type,
+                        count: matches.length,
+                        message: pattern.message,
+                        severity: 'error'
+                    });
+                }
+            });
+        }
+        // Performance Anti-patterns
+        if (check_performance) {
+            const performancePatterns = [
+                {
+                    regex: /while\s*\(\s*gr\.next\(\)/g,
+                    type: 'unbounded_while_loop',
+                    message: 'Use for loop with limit instead of unbounded while(gr.next())',
+                    severity: 'high'
+                },
+                {
+                    regex: /new\s+GlideRecord\([^)]+\)[^}]*\{[^}]*new\s+GlideRecord/g,
+                    type: 'nested_gliderecord',
+                    message: 'Nested GlideRecord queries can cause performance issues',
+                    severity: 'high'
+                },
+                {
+                    regex: /gr\.query\(\)[^}]*while[^}]*gr\.getValue/g,
+                    type: 'getValue_in_loop',
+                    message: 'Repeated getValue() calls in loop - cache values instead',
+                    severity: 'medium'
+                },
+                {
+                    regex: /gs\.getUser\(\)\.getID\(\)/g,
+                    type: 'repeated_getUser',
+                    message: 'Cache gs.getUser() result instead of calling repeatedly',
+                    severity: 'low'
+                }
+            ];
+            performancePatterns.forEach(pattern => {
+                if (pattern.regex.test(code)) {
+                    patterns.performance_issues.push({
+                        type: pattern.type,
+                        message: pattern.message,
+                        severity: pattern.severity
+                    });
+                }
+            });
+        }
+        // Security Issues
+        if (check_security) {
+            const securityPatterns = [
+                {
+                    regex: /eval\s*\(/g,
+                    type: 'eval_usage',
+                    message: 'eval() is a security risk - avoid using it',
+                    severity: 'critical'
+                },
+                {
+                    regex: /gs\.executeNow\s*\(/g,
+                    type: 'executeNow',
+                    message: 'gs.executeNow() can bypass security - use with caution',
+                    severity: 'high'
+                },
+                {
+                    regex: /setWorkflow\s*\(\s*false\s*\)/g,
+                    type: 'workflow_bypass',
+                    message: 'Disabling workflow can bypass business rules',
+                    severity: 'medium'
+                },
+                {
+                    regex: /password|pwd|secret|api[_-]?key/gi,
+                    type: 'hardcoded_credentials',
+                    message: 'Possible hardcoded credentials - use system properties instead',
+                    severity: 'critical'
+                }
+            ];
+            securityPatterns.forEach(pattern => {
+                if (pattern.regex.test(code)) {
+                    patterns.security_issues.push({
+                        type: pattern.type,
+                        message: pattern.message,
+                        severity: pattern.severity
+                    });
+                }
+            });
+        }
+        // ServiceNow Best Practices
+        if (check_best_practices) {
+            const bestPractices = [
+                {
+                    regex: /gr\.query\(\)[^}]*if\s*\(\s*gr\.next/g,
+                    type: 'missing_query_limit',
+                    message: 'Add setLimit() before query() for better performance',
+                    severity: 'medium'
+                },
+                {
+                    regex: /current\./g,
+                    type: 'current_object',
+                    message: 'Using current object - ensure it exists in context',
+                    severity: 'info',
+                    isGood: true
+                },
+                {
+                    regex: /try\s*\{[^}]*\}\s*catch/g,
+                    type: 'error_handling',
+                    message: 'Good: Error handling implemented',
+                    severity: 'info',
+                    isGood: true
+                },
+                {
+                    regex: /gs\.(info|warn|error|debug)\(/g,
+                    type: 'logging',
+                    message: 'Good: Logging statements present',
+                    severity: 'info',
+                    isGood: true
+                }
+            ];
+            bestPractices.forEach(pattern => {
+                if (pattern.regex.test(code)) {
+                    if (pattern.isGood) {
+                        patterns.good_patterns.push({
+                            type: pattern.type,
+                            message: pattern.message
+                        });
+                    }
+                    else {
+                        patterns.best_practice_violations.push({
+                            type: pattern.type,
+                            message: pattern.message,
+                            severity: pattern.severity
+                        });
+                    }
+                }
+            });
+        }
+        // Calculate overall score
+        const criticalIssues = [
+            ...patterns.es5_violations.filter((v) => v.severity === 'error'),
+            ...patterns.security_issues.filter((i) => i.severity === 'critical')
+        ].length;
+        const highIssues = [
+            ...patterns.performance_issues.filter((i) => i.severity === 'high'),
+            ...patterns.security_issues.filter((i) => i.severity === 'high')
+        ].length;
+        const totalIssues = patterns.es5_violations.length +
+            patterns.performance_issues.length +
+            patterns.security_issues.length +
+            patterns.best_practice_violations.length;
+        let codeQuality = 'excellent';
+        if (criticalIssues > 0) {
+            codeQuality = 'critical';
+        }
+        else if (highIssues > 2) {
+            codeQuality = 'poor';
+        }
+        else if (totalIssues > 5) {
+            codeQuality = 'moderate';
+        }
+        else if (totalIssues > 0) {
+            codeQuality = 'good';
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            patterns,
+            summary: {
+                total_issues: totalIssues,
+                critical_issues: criticalIssues,
+                high_priority_issues: highIssues,
+                good_patterns_found: patterns.good_patterns.length,
+                code_quality: codeQuality
+            },
+            recommendations: generateRecommendations(patterns),
+            es5_compliant: patterns.es5_violations.length === 0
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+function generateRecommendations(patterns) {
+    const recommendations = [];
+    if (patterns.es5_violations.length > 0) {
+        recommendations.push('Convert all ES6+ syntax to ES5 for ServiceNow compatibility');
+    }
+    if (patterns.security_issues.some((i) => i.severity === 'critical')) {
+        recommendations.push('Address critical security issues immediately');
+    }
+    if (patterns.performance_issues.length > 0) {
+        recommendations.push('Optimize performance by addressing identified anti-patterns');
+    }
+    if (patterns.best_practice_violations.length > 3) {
+        recommendations.push('Review ServiceNow best practices and update code accordingly');
+    }
+    if (recommendations.length === 0) {
+        recommendations.push('Code follows ServiceNow best practices');
+    }
+    return recommendations;
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_detect_code_patterns.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * snow_discover_data_sources - Data source discovery
+ *
+ * Discover available data sources for integration. Identifies import sets,
+ * REST endpoints, and external databases.
+ */
+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_discover_data_sources.d.ts.map

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

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * snow_discover_data_sources - Data source discovery
+ *
+ * Discover available data sources for integration. Identifies import sets,
+ * REST endpoints, and external databases.
+ */
+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_discover_data_sources',
+    description: 'Discover available data sources for integration including import sets and REST endpoints',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sourceType: {
+                type: 'string',
+                enum: ['all', 'import_set', 'rest', 'jdbc', 'ldap', 'file'],
+                description: 'Filter by source type',
+                default: 'all'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of results per type',
+                default: 50
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { sourceType = 'all', limit = 50 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const dataSources = [];
+        // Discover Import Sets
+        if (sourceType === 'all' || sourceType === 'import_set') {
+            const importSetsResponse = await client.get('/api/now/table/sys_import_set_table_list', {
+                params: { sysparm_limit: limit }
+            });
+            if (importSetsResponse.data.result) {
+                dataSources.push({
+                    type: 'Import Sets',
+                    count: importSetsResponse.data.result.length,
+                    sources: importSetsResponse.data.result.map((is) => ({
+                        name: is.name,
+                        label: is.label,
+                        table: is.name,
+                        sys_id: is.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover REST Messages
+        if (sourceType === 'all' || sourceType === 'rest') {
+            const restResponse = await client.get('/api/now/table/sys_rest_message', {
+                params: { sysparm_limit: limit }
+            });
+            if (restResponse.data.result) {
+                dataSources.push({
+                    type: 'REST Messages',
+                    count: restResponse.data.result.length,
+                    sources: restResponse.data.result.map((rest) => ({
+                        name: rest.name,
+                        endpoint: rest.endpoint,
+                        authentication: rest.authentication_type,
+                        sys_id: rest.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover JDBC Data Sources
+        if (sourceType === 'all' || sourceType === 'jdbc') {
+            const jdbcResponse = await client.get('/api/now/table/sys_data_source', {
+                params: {
+                    sysparm_query: 'type=jdbc',
+                    sysparm_limit: limit
+                }
+            });
+            if (jdbcResponse.data.result) {
+                dataSources.push({
+                    type: 'JDBC Data Sources',
+                    count: jdbcResponse.data.result.length,
+                    sources: jdbcResponse.data.result.map((jdbc) => ({
+                        name: jdbc.name,
+                        database: jdbc.database_name,
+                        server: jdbc.connection_url,
+                        sys_id: jdbc.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover LDAP Servers
+        if (sourceType === 'all' || sourceType === 'ldap') {
+            const ldapResponse = await client.get('/api/now/table/ldap_server_config', {
+                params: { sysparm_limit: limit }
+            });
+            if (ldapResponse.data.result) {
+                dataSources.push({
+                    type: 'LDAP Servers',
+                    count: ldapResponse.data.result.length,
+                    sources: ldapResponse.data.result.map((ldap) => ({
+                        name: ldap.name,
+                        server: ldap.server,
+                        port: ldap.port,
+                        sys_id: ldap.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover Transform Maps
+        const transformResponse = await client.get('/api/now/table/sys_transform_map', {
+            params: { sysparm_limit: limit }
+        });
+        if (transformResponse.data.result) {
+            dataSources.push({
+                type: 'Transform Maps',
+                count: transformResponse.data.result.length,
+                sources: transformResponse.data.result.map((tm) => ({
+                    name: tm.name,
+                    source_table: tm.source_table,
+                    target_table: tm.target_table,
+                    sys_id: tm.sys_id
+                }))
+            });
+        }
+        const totalSources = dataSources.reduce((sum, ds) => sum + ds.count, 0);
+        return (0, error_handler_js_1.createSuccessResult)({
+            discovered: true,
+            data_sources: dataSources,
+            summary: {
+                total_sources: totalSources,
+                types_found: dataSources.length,
+                filter_applied: sourceType
+            },
+            message: `Discovered ${totalSources} data sources across ${dataSources.length} categories`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_discover_data_sources.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * snow_discover_integration_endpoints - Integration endpoint discovery
+ *
+ * Discover existing integration endpoints in the instance.
+ * Filters by type: REST, SOAP, LDAP, or EMAIL.
+ */
+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_discover_integration_endpoints.d.ts.map

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

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * snow_discover_integration_endpoints - Integration endpoint discovery
+ *
+ * Discover existing integration endpoints in the instance.
+ * Filters by type: REST, SOAP, LDAP, or EMAIL.
+ */
+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_discover_integration_endpoints',
+    description: 'Discover existing integration endpoints (REST, SOAP, LDAP, EMAIL)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                enum: ['all', 'REST', 'SOAP', 'LDAP', 'EMAIL'],
+                description: 'Filter by endpoint type',
+                default: 'all'
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum results per type',
+                default: 50
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { type = 'all', limit = 50 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const endpoints = [];
+        // Discover REST Messages
+        if (type === 'all' || type === 'REST') {
+            const restResponse = await client.get('/api/now/table/sys_rest_message', {
+                params: { sysparm_limit: limit }
+            });
+            if (restResponse.data.result) {
+                endpoints.push({
+                    type: 'REST Messages',
+                    count: restResponse.data.result.length,
+                    endpoints: restResponse.data.result.map((msg) => ({
+                        name: msg.name,
+                        endpoint: msg.endpoint,
+                        auth_type: msg.authentication_type,
+                        use_mid_server: msg.use_mid_server,
+                        sys_id: msg.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover Web Services (SOAP)
+        if (type === 'all' || type === 'SOAP') {
+            const soapResponse = await client.get('/api/now/table/sys_web_service', {
+                params: { sysparm_limit: limit }
+            });
+            if (soapResponse.data.result) {
+                endpoints.push({
+                    type: 'Web Services (SOAP)',
+                    count: soapResponse.data.result.length,
+                    endpoints: soapResponse.data.result.map((ws) => ({
+                        name: ws.name,
+                        wsdl_url: ws.wsdl_url,
+                        namespace: ws.namespace,
+                        auth_type: ws.authentication_type,
+                        sys_id: ws.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover LDAP Servers
+        if (type === 'all' || type === 'LDAP') {
+            const ldapResponse = await client.get('/api/now/table/ldap_server_config', {
+                params: { sysparm_limit: limit }
+            });
+            if (ldapResponse.data.result) {
+                endpoints.push({
+                    type: 'LDAP Servers',
+                    count: ldapResponse.data.result.length,
+                    endpoints: ldapResponse.data.result.map((ldap) => ({
+                        name: ldap.name,
+                        server: ldap.server,
+                        port: ldap.port,
+                        ssl_enabled: ldap.use_ssl,
+                        sys_id: ldap.sys_id
+                    }))
+                });
+            }
+        }
+        // Discover Email Accounts
+        if (type === 'all' || type === 'EMAIL') {
+            const emailResponse = await client.get('/api/now/table/sys_email_account', {
+                params: { sysparm_limit: limit }
+            });
+            if (emailResponse.data.result) {
+                endpoints.push({
+                    type: 'Email Accounts',
+                    count: emailResponse.data.result.length,
+                    endpoints: emailResponse.data.result.map((email) => ({
+                        name: email.name,
+                        server: email.server,
+                        port: email.port,
+                        type: email.type,
+                        encryption: email.encryption,
+                        sys_id: email.sys_id
+                    }))
+                });
+            }
+        }
+        const totalEndpoints = endpoints.reduce((sum, ep) => sum + ep.count, 0);
+        return (0, error_handler_js_1.createSuccessResult)({
+            discovered: true,
+            integration_endpoints: endpoints,
+            summary: {
+                total_endpoints: totalEndpoints,
+                types_found: endpoints.length,
+                filter_applied: type
+            },
+            message: `Discovered ${totalEndpoints} integration endpoints across ${endpoints.length} categories`
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_discover_integration_endpoints.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * snow_generate_docs - Automatic documentation generation
+ *
+ * Generate comprehensive documentation for ServiceNow artifacts
+ * with relationships, dependencies, and usage examples.
+ */
+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_generate_docs.d.ts.map