snow-flow 2.6.4 → 2.6.6

package/dist/mcp/servicenow-graph-memory-mcp-refactored.js

@@ -1,642 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * servicenow-graph-memory MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowGraphMemoryMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
-const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
-class ServiceNowGraphMemoryMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-graph-memory',
-            version: '2.0.0',
-            description: 'Neo4j-based intelligent memory system for ServiceNow artifacts'
-        });
-        this.neo4jDriver = null;
-        this.neo4jConfig = null;
-        this.neo4jAvailable = false;
-        this.initializeNeo4j();
-    }
-    setupTools() {
-        // Tools are defined in getTools() method
-    }
-    getTools() {
-        return [
-            {
-                name: 'snow_graph_index_artifact',
-                description: 'AUTONOMOUS graph indexing - stores ServiceNow artifacts in Neo4j with relationships, enables instant understanding of dependencies and connections',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        artifact: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string', description: 'Unique identifier for the artifact' },
-                                name: { type: 'string', description: 'Artifact name' },
-                                type: { type: 'string', enum: ['widget', 'flow', 'script_include', 'business_rule', 'table', 'client_script', 'ui_script'] },
-                                content: { type: 'string', description: 'Full content/code of the artifact' },
-                                purpose: { type: 'string', description: 'What this artifact does' }
-                            },
-                            required: ['id', 'name', 'type']
-                        },
-                        relationships: {
-                            type: 'array',
-                            description: 'Relationships to other artifacts',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    to: { type: 'string', description: 'Target artifact ID' },
-                                    type: { type: 'string', enum: ['USES', 'REQUIRES', 'TRIGGERS', 'CREATES', 'MODIFIES', 'CALLS', 'EXTENDS'] },
-                                    data_flow: { type: 'string', description: 'How data flows between artifacts' }
-                                }
-                            }
-                        }
-                    },
-                    required: ['artifact']
-                }
-            },
-            {
-                name: 'snow_graph_find_related',
-                description: 'INTELLIGENT relationship discovery - finds all artifacts related to a given artifact, understands dependencies, data flows, and impact _analysis',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        artifact_id: { type: 'string', description: 'Artifact ID to find relationships for' },
-                        depth: { type: 'number', description: 'How many levels of relationships to traverse', default: 2 },
-                        relationship_types: {
-                            type: 'array',
-                            description: 'Filter by relationship types',
-                            items: { type: 'string', enum: ['USES', 'REQUIRES', 'TRIGGERS', 'CREATES', 'MODIFIES', 'CALLS', 'EXTENDS'] }
-                        }
-                    },
-                    required: ['artifact_id']
-                }
-            },
-            {
-                name: 'snow_graph_analyze_impact',
-                description: 'IMPACT ANALYSIS - shows what will be affected if an artifact is modified, critical for safe deployments',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        artifact_id: { type: 'string', description: 'Artifact to analyze impact for' },
-                        change_type: { type: 'string', enum: ['modify', 'delete', 'upgrade'], description: 'Type of change planned' }
-                    },
-                    required: ['artifact_id']
-                }
-            },
-            {
-                name: 'snow_graph_suggest_artifacts',
-                description: 'AI-POWERED suggestions - recommends artifacts based on current context and past successful patterns',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        context: { type: 'string', description: 'Current development context' },
-                        artifact_type: { type: 'string', description: 'Type of artifact needed' },
-                        requirements: { type: 'array', description: 'Specific requirements', items: { type: 'string' } }
-                    },
-                    required: ['context']
-                }
-            },
-            {
-                name: 'snow_graph_pattern__analysis',
-                description: 'PATTERN RECOGNITION - identifies common patterns, best practices, and reusable components across all artifacts',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        pattern_type: { type: 'string', enum: ['architectural', 'coding', 'integration', 'error_handling'], description: 'Type of pattern to analyze' },
-                        min_occurrences: { type: 'number', default: 3, description: 'Minimum times pattern must appear' }
-                    }
-                }
-            },
-            {
-                name: 'snow_graph_visualize',
-                description: 'GRAPH VISUALIZATION - generates Cypher queries for visualizing artifact relationships in Neo4j Browser',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        focus_artifact: { type: 'string', description: 'Central artifact to visualize around' },
-                        max_nodes: { type: 'number', default: 50, description: 'Maximum nodes to display' },
-                        include_types: { type: 'array', description: 'Artifact types to include', items: { type: 'string' } }
-                    }
-                }
-            },
-            {
-                name: 'snow_graph_export_knowledge',
-                description: 'KNOWLEDGE EXPORT - exports learned patterns and relationships for backup or sharing',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        format: { type: 'string', enum: ['cypher', 'json', 'graphml'], description: 'Export format' },
-                        include_content: { type: 'boolean', default: false, description: 'Include full artifact content' }
-                    }
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        const startTime = Date.now();
-        // Check Neo4j availability for all tools
-        if (!this.neo4jAvailable) {
-            return this.createFallbackResponse(name);
-        }
-        switch (name) {
-            case 'snow_graph_index_artifact':
-                return await this.handleSnowGraphIndexArtifact(args);
-            case 'snow_graph_find_related':
-                return await this.handleSnowGraphFindRelated(args);
-            case 'snow_graph_analyze_impact':
-                return await this.handleSnowGraphAnalyzeImpact(args);
-            case 'snow_graph_suggest_artifacts':
-                return await this.handleSnowGraphSuggestArtifacts(args);
-            case 'snow_graph_pattern__analysis':
-                return await this.handleSnowGraphPatternAnalysis(args);
-            case 'snow_graph_visualize':
-                return await this.handleSnowGraphVisualize(args);
-            case 'snow_graph_export_knowledge':
-                return await this.handleSnowGraphExportKnowledge(args);
-            default:
-                return {
-                    success: false,
-                    error: `Unknown tool: ${name}`
-                };
-        }
-    }
-    // Initialize Neo4j connection
-    initializeNeo4j() {
-        const rawConfig = mcp_config_manager_js_1.mcpConfig.getNeo4jConfig();
-        if (!rawConfig?.uri || !rawConfig?.username || !rawConfig?.password) {
-            this.logger.warn('Neo4j configuration missing. Graph Memory MCP will run in fallback mode without Neo4j functionality.');
-            this.logger.info('To enable Neo4j: set NEO4J_URI, NEO4J_USERNAME, and NEO4J_PASSWORD environment variables.');
-            this.neo4jAvailable = false;
-        }
-        else {
-            this.neo4jConfig = {
-                uri: rawConfig.uri,
-                username: rawConfig.username,
-                password: rawConfig.password,
-                database: rawConfig.database
-            };
-            this.neo4jAvailable = true;
-        }
-    }
-    async connectToNeo4j() {
-        if (!this.neo4jAvailable || !this.neo4jConfig) {
-            return null;
-        }
-        if (!this.neo4jDriver) {
-            try {
-                this.neo4jDriver = neo4j_driver_1.default.driver(this.neo4jConfig.uri, neo4j_driver_1.default.auth.basic(this.neo4jConfig.username, this.neo4jConfig.password));
-                await this.neo4jDriver.verifyConnectivity();
-                this.logger.info('Connected to Neo4j');
-                // Create indexes for better performance
-                const session = this.neo4jDriver.session();
-                try {
-                    await session.run('CREATE INDEX artifact_id IF NOT EXISTS FOR (a:Artifact) ON (a.id)');
-                    await session.run('CREATE INDEX artifact_type IF NOT EXISTS FOR (a:Artifact) ON (a.type)');
-                    await session.run('CREATE INDEX artifact_name IF NOT EXISTS FOR (a:Artifact) ON (a.name)');
-                }
-                finally {
-                    await session.close();
-                }
-            }
-            catch (error) {
-                this.logger.error('Failed to connect to Neo4j', error);
-                throw error;
-            }
-        }
-        return this.neo4jDriver;
-    }
-    createFallbackResponse(toolName) {
-        return {
-            success: false,
-            error: `${toolName} requires Neo4j database. Please install and configure Neo4j to use graph memory features.`,
-            result: {
-                fallback_mode: true,
-                instructions: [
-                    '1. Install Neo4j Community Edition',
-                    '2. Start Neo4j service',
-                    '3. Set environment variables: NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD',
-                    '4. Restart the MCP server'
-                ]
-            }
-        };
-    }
-    // Tool handlers
-    async handleSnowGraphIndexArtifact(args) {
-        const startTime = Date.now();
-        try {
-            const driver = await this.connectToNeo4j();
-            if (!driver)
-                throw new Error('Neo4j not available');
-            const session = driver.session();
-            const artifact = args.artifact;
-            const relationships = args.relationships || [];
-            try {
-                // Create or update the artifact node
-                await session.run(`MERGE (a:Artifact {id: $id})
-           SET a.name = $name,
-               a.type = $type,
-               a.content = $content,
-               a.purpose = $purpose,
-               a.last_updated = datetime(),
-               a.deployment_count = COALESCE(a.deployment_count, 0) + 1`, {
-                    id: artifact.id,
-                    name: artifact.name,
-                    type: artifact.type,
-                    content: artifact.content || '',
-                    purpose: artifact.purpose || ''
-                });
-                // Create relationships
-                for (const rel of relationships) {
-                    await session.run(`MATCH (a:Artifact {id: $fromId}), (b:Artifact {id: $toId})
-             MERGE (a)-[r:${rel.type}]->(b)
-             SET r.data_flow = $dataFlow,
-                 r.strength = COALESCE(r.strength, 0) + 1`, {
-                        fromId: artifact.id,
-                        toId: rel.to,
-                        dataFlow: rel.data_flow || ''
-                    });
-                }
-                return {
-                    success: true,
-                    result: {
-                        artifact_id: artifact.id,
-                        indexed: true,
-                        relationships_created: relationships.length
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            finally {
-                await session.close();
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to index artifact',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphFindRelated(args) {
-        const startTime = Date.now();
-        try {
-            const driver = await this.connectToNeo4j();
-            if (!driver)
-                throw new Error('Neo4j not available');
-            const session = driver.session();
-            const { artifact_id, depth = 2, relationship_types } = args;
-            try {
-                let relationshipFilter = '';
-                if (relationship_types && relationship_types.length > 0) {
-                    relationshipFilter = `WHERE type(r) IN [${relationship_types.map((t) => `'${t}'`).join(', ')}]`;
-                }
-                const result = await session.run(`MATCH path = (start:Artifact {id: $artifactId})-[r*1..${depth}]->(end:Artifact)
-           ${relationshipFilter}
-           RETURN path, relationships(path) as rels, nodes(path) as nodes`, { artifactId: artifact_id });
-                const relatedArtifacts = result.records.map(record => {
-                    const nodes = record.get('nodes');
-                    const rels = record.get('rels');
-                    return {
-                        path_length: nodes.length - 1,
-                        artifacts: nodes.map((node) => node.properties),
-                        relationships: rels.map((rel) => ({
-                            type: rel.type,
-                            properties: rel.properties
-                        }))
-                    };
-                });
-                return {
-                    success: true,
-                    result: {
-                        artifact_id,
-                        related_artifacts: relatedArtifacts,
-                        total_found: relatedArtifacts.length
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            finally {
-                await session.close();
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to find related artifacts',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphAnalyzeImpact(args) {
-        const startTime = Date.now();
-        try {
-            const driver = await this.connectToNeo4j();
-            if (!driver)
-                throw new Error('Neo4j not available');
-            const session = driver.session();
-            const { artifact_id, change_type } = args;
-            try {
-                // Find all artifacts that depend on this one
-                const dependentsResult = await session.run(`MATCH (target:Artifact {id: $artifactId})<-[r]-(dependent:Artifact)
-           RETURN dependent, type(r) as relationship_type, r.strength as strength
-           ORDER BY r.strength DESC`, { artifactId: artifact_id });
-                // Find all artifacts this one depends on
-                const dependenciesResult = await session.run(`MATCH (source:Artifact {id: $artifactId})-[r]->(dependency:Artifact)
-           RETURN dependency, type(r) as relationship_type, r.strength as strength
-           ORDER BY r.strength DESC`, { artifactId: artifact_id });
-                const dependents = dependentsResult.records.map(record => ({
-                    artifact: record.get('dependent').properties,
-                    relationship: record.get('relationship_type'),
-                    impact_level: this.calculateImpactLevel(change_type, record.get('relationship_type'), record.get('strength'))
-                }));
-                const dependencies = dependenciesResult.records.map(record => ({
-                    artifact: record.get('dependency').properties,
-                    relationship: record.get('relationship_type'),
-                    required: record.get('relationship_type') === 'REQUIRES'
-                }));
-                return {
-                    success: true,
-                    result: {
-                        artifact_id,
-                        change_type,
-                        impact__analysis: {
-                            dependent_artifacts: dependents,
-                            dependency_artifacts: dependencies,
-                            total_affected: dependents.length,
-                            high_impact_count: dependents.filter(d => d.impact_level === 'high').length,
-                            recommendations: this.generateImpactRecommendations(change_type, dependents, dependencies)
-                        }
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            finally {
-                await session.close();
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to analyze impact',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphSuggestArtifacts(args) {
-        const startTime = Date.now();
-        try {
-            // This would be a complex AI-powered recommendation system
-            // For now, provide a simplified implementation
-            const suggestions = [
-                {
-                    artifact_id: 'suggested_script_include_1',
-                    name: 'DataValidationUtils',
-                    type: 'script_include',
-                    relevance_score: 0.89,
-                    reason: 'Commonly used with similar requirements',
-                    usage_count: 45
-                },
-                {
-                    artifact_id: 'suggested_widget_1',
-                    name: 'StatusDashboard',
-                    type: 'widget',
-                    relevance_score: 0.76,
-                    reason: 'Pattern match with context requirements',
-                    usage_count: 23
-                }
-            ];
-            return {
-                success: true,
-                result: {
-                    context: args.context,
-                    suggestions,
-                    total_suggestions: suggestions.length
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to suggest artifacts',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphPatternAnalysis(args) {
-        const startTime = Date.now();
-        try {
-            const driver = await this.connectToNeo4j();
-            if (!driver)
-                throw new Error('Neo4j not available');
-            const session = driver.session();
-            const { pattern_type, min_occurrences = 3 } = args;
-            try {
-                // Analyze common patterns based on type
-                let query = '';
-                switch (pattern_type) {
-                    case 'architectural':
-                        query = `MATCH (a:Artifact)-[r]->(b:Artifact)
-                     WHERE a.type <> b.type
-                     RETURN a.type as from_type, type(r) as relationship, b.type as to_type, count(*) as frequency
-                     HAVING frequency >= $minOccurrences
-                     ORDER BY frequency DESC`;
-                        break;
-                    case 'coding':
-                        query = `MATCH (a:Artifact)
-                     WHERE a.content IS NOT NULL
-                     RETURN a.type, count(*) as count
-                     HAVING count >= $minOccurrences
-                     ORDER BY count DESC`;
-                        break;
-                    default:
-                        query = `MATCH (a:Artifact)-[r]->(b:Artifact)
-                     RETURN type(r) as relationship_pattern, count(*) as frequency
-                     HAVING frequency >= $minOccurrences
-                     ORDER BY frequency DESC`;
-                }
-                const result = await session.run(query, { minOccurrences: min_occurrences });
-                const patterns = result.records.map(record => {
-                    const data = {};
-                    record.keys.forEach(key => {
-                        data[key] = record.get(key);
-                    });
-                    return data;
-                });
-                return {
-                    success: true,
-                    result: {
-                        pattern_type,
-                        patterns,
-                        total_patterns: patterns.length,
-                        min_occurrences
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            finally {
-                await session.close();
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to analyze patterns',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphVisualize(args) {
-        const startTime = Date.now();
-        try {
-            const { focus_artifact, max_nodes = 50, include_types } = args;
-            let typeFilter = '';
-            if (include_types && include_types.length > 0) {
-                typeFilter = `WHERE a.type IN [${include_types.map((t) => `'${t}'`).join(', ')}] AND b.type IN [${include_types.map((t) => `'${t}'`).join(', ')}]`;
-            }
-            const cypherQuery = focus_artifact
-                ? `MATCH path = (center:Artifact {id: '${focus_artifact}'})-[r*1..2]-(connected:Artifact)
-           ${typeFilter}
-           RETURN path LIMIT ${max_nodes}`
-                : `MATCH (a:Artifact)-[r]->(b:Artifact)
-           ${typeFilter}
-           RETURN a, r, b LIMIT ${max_nodes}`;
-            return {
-                success: true,
-                result: {
-                    cypher_query: cypherQuery,
-                    focus_artifact,
-                    max_nodes,
-                    browser_url: this.neo4jConfig ? `${this.neo4jConfig.uri.replace('bolt://', 'http://')}/browser/` : 'Neo4j Browser not available',
-                    instructions: [
-                        '1. Open Neo4j Browser',
-                        '2. Paste the Cypher query above',
-                        '3. Click the graph visualization tab',
-                        '4. Explore the artifact relationships'
-                    ]
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to generate visualization',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowGraphExportKnowledge(args) {
-        const startTime = Date.now();
-        try {
-            const driver = await this.connectToNeo4j();
-            if (!driver)
-                throw new Error('Neo4j not available');
-            const session = driver.session();
-            const { format = 'json', include_content = false } = args;
-            try {
-                const contentFilter = include_content ? '' : ', a.content';
-                const result = await session.run(`MATCH (a:Artifact)-[r]->(b:Artifact)
-           RETURN a{.*, content: ${include_content ? 'a.content' : 'null'}} as from_artifact,
-                  type(r) as relationship_type,
-                  r{.*} as relationship_properties,
-                  b{.*, content: ${include_content ? 'b.content' : 'null'}} as to_artifact`);
-                const knowledge = result.records.map(record => ({
-                    from_artifact: record.get('from_artifact'),
-                    relationship: {
-                        type: record.get('relationship_type'),
-                        properties: record.get('relationship_properties')
-                    },
-                    to_artifact: record.get('to_artifact')
-                }));
-                let exportData;
-                switch (format) {
-                    case 'cypher':
-                        exportData = this.generateCypherExport(knowledge);
-                        break;
-                    case 'graphml':
-                        exportData = this.generateGraphMLExport(knowledge);
-                        break;
-                    default:
-                        exportData = knowledge;
-                }
-                return {
-                    success: true,
-                    result: {
-                        format,
-                        export_data: exportData,
-                        total_relationships: knowledge.length,
-                        export_timestamp: new Date().toISOString(),
-                        include_content
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            finally {
-                await session.close();
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to export knowledge',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    // Helper methods
-    calculateImpactLevel(changeType, relationshipType, strength) {
-        if (changeType === 'delete' && relationshipType === 'REQUIRES')
-            return 'critical';
-        if (changeType === 'delete' && strength > 5)
-            return 'high';
-        if (changeType === 'modify' && relationshipType === 'USES' && strength > 3)
-            return 'medium';
-        return 'low';
-    }
-    generateImpactRecommendations(changeType, dependents, dependencies) {
-        const recommendations = [];
-        if (changeType === 'delete') {
-            recommendations.push('Create backup before deletion');
-            recommendations.push('Update all dependent artifacts');
-        }
-        if (dependents.length > 5) {
-            recommendations.push('Consider phased deployment due to high number of dependencies');
-        }
-        return recommendations;
-    }
-    generateCypherExport(knowledge) {
-        return knowledge.map(k => `CREATE (a:Artifact {id: '${k.from_artifact.id}', name: '${k.from_artifact.name}', type: '${k.from_artifact.type}'})-[:${k.relationship.type}]->(b:Artifact {id: '${k.to_artifact.id}', name: '${k.to_artifact.name}', type: '${k.to_artifact.type}'})`).join(';\n');
-    }
-    generateGraphMLExport(knowledge) {
-        // Simplified GraphML export
-        return `<?xml version="1.0" encoding="UTF-8"?>\n<graphml>\n<!-- Export contains ${knowledge.length} relationships -->\n</graphml>`;
-    }
-    // Override shutdown to close Neo4j driver
-    async shutdown() {
-        if (this.neo4jDriver) {
-            await this.neo4jDriver.close();
-            this.logger.info('Neo4j driver closed');
-        }
-        // BaseMCPServer doesn't have a shutdown method, just close the server
-        if (this.server) {
-            await this.server.close();
-        }
-    }
-}
-exports.ServiceNowGraphMemoryMCP = ServiceNowGraphMemoryMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowGraphMemoryMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-graph-memory-mcp-refactored.js.map

package/dist/mcp/servicenow-integration-mcp-refactored.d.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-integration MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare class ServiceNowIntegrationMCP extends BaseMCPServer {
-    constructor();
-    protected setupTools(): void;
-    protected getTools(): Tool[];
-    protected executeTool(name: string, args: any): Promise<ToolResult>;
-    private handleSnowCreateRestMessage;
-    private handleSnowCreateRestMethod;
-    private handleSnowCreateTransformMap;
-    private handleSnowCreateFieldMap;
-    private handleSnowCreateImportSet;
-    private handleSnowCreateWebService;
-    private handleSnowCreateEmailConfig;
-    private handleSnowDiscoverIntegrationEndpoints;
-    private handleSnowTestIntegration;
-    private handleSnowDiscoverDataSources;
-}
-//# sourceMappingURL=servicenow-integration-mcp-refactored.d.ts.map