snow-flow 2.9.9 → 3.0.0

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

@@ -1,728 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Graph Memory MCP Server
- * Neo4j-based intelligent memory system for ServiceNow artifacts
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const logger_js_1 = require("../utils/logger.js");
-const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
-const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
-class ServiceNowGraphMemoryMCP {
-    constructor() {
-        this.driver = null;
-        this.config = null;
-        this.neo4jAvailable = false;
-        this.server = new index_js_1.Server({
-            name: 'servicenow-graph-memory',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.logger = new logger_js_1.Logger('ServiceNowGraphMemoryMCP');
-        const rawConfig = mcp_config_manager_js_1.mcpConfig.getNeo4jConfig();
-        // Validate Neo4j configuration - but don't fail if missing
-        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 {
-            // After validation, we know these are defined
-            this.config = {
-                uri: rawConfig.uri,
-                username: rawConfig.username,
-                password: rawConfig.password,
-                database: rawConfig.database
-            };
-            this.neo4jAvailable = true;
-        }
-        this.setupHandlers();
-    }
-    createFallbackResponse(toolName) {
-        return {
-            success: false,
-            message: `${toolName} requires Neo4j database. Please install and configure Neo4j to use graph memory features.`,
-            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'
-            ]
-        };
-    }
-    async connectToNeo4j() {
-        if (!this.neo4jAvailable || !this.config) {
-            this.logger.warn('Neo4j not available - using fallback mode');
-            return;
-        }
-        if (!this.driver) {
-            try {
-                this.driver = neo4j_driver_1.default.driver(this.config.uri, neo4j_driver_1.default.auth.basic(this.config.username, this.config.password));
-                await this.driver.verifyConnectivity();
-                this.logger.info('Connected to Neo4j');
-                // Create indexes for better performance
-                const session = this.driver.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);
-                this.neo4jAvailable = false;
-                if (this.driver) {
-                    await this.driver.close();
-                    this.driver = null;
-                }
-                throw error;
-            }
-        }
-        return this.driver;
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    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', items: { type: 'string' }, description: 'Specific requirements' },
-                        },
-                        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', description: 'Minimum times pattern must appear', default: 3 },
-                        },
-                    },
-                },
-                {
-                    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' },
-                            include_types: { type: 'array', items: { type: 'string' }, description: 'Artifact types to include' },
-                            max_nodes: { type: 'number', description: 'Maximum nodes to display', default: 50 },
-                        },
-                    },
-                },
-                {
-                    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', description: 'Include full artifact content', default: false },
-                        },
-                    },
-                },
-            ],
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                await this.connectToNeo4j();
-                switch (name) {
-                    case 'snow_graph_index_artifact':
-                        return await this.indexArtifact(args);
-                    case 'snow_graph_find_related':
-                        return await this.findRelatedArtifacts(args);
-                    case 'snow_graph_analyze_impact':
-                        return await this.analyzeImpact(args);
-                    case 'snow_graph_suggest_artifacts':
-                        return await this.suggestArtifacts(args);
-                    case 'snow_graph_pattern__analysis':
-                        return await this.analyzePatterns(args);
-                    case 'snow_graph_visualize':
-                        return await this.generateVisualization(args);
-                    case 'snow_graph_export_knowledge':
-                        return await this.exportKnowledge(args);
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                this.logger.error(`Tool execution failed: ${name}`, error);
-                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error instanceof Error ? error.message : String(error));
-            }
-        });
-    }
-    async indexArtifact(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_index_artifact');
-        }
-        const session = this.driver.session();
-        try {
-            const { artifact, relationships = [] } = args;
-            // 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.indexed_at = datetime()
-        RETURN a
-        `, artifact);
-            // Create relationships
-            for (const rel of relationships) {
-                await session.run(`
-          MATCH (a:Artifact {id: $fromId})
-          MERGE (b:Artifact {id: $toId})
-          MERGE (a)-[r:${rel.type}]->(b)
-          SET r.data_flow = $dataFlow,
-              r.created_at = datetime()
-          `, {
-                    fromId: artifact.id,
-                    toId: rel.to,
-                    dataFlow: rel.data_flow || ''
-                });
-            }
-            // Analyze artifact content for automatic relationship discovery
-            const discoveredRelations = await this.discoverRelationships(artifact);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Artifact indexed successfully!
-
-📊 **Artifact Details:**
-- ID: ${artifact.id}
-- Name: ${artifact.name}
-- Type: ${artifact.type}
-- Relationships: ${relationships.length} explicit, ${discoveredRelations} discovered
-
-🔗 **Graph Impact:**
-- Node created/updated in Neo4j
-- Relationships established
-- Available for pattern analysis
-- Ready for impact assessment
-
-💡 **Next Steps:**
-- Use snow_graph_find_related to explore connections
-- Use snow_graph_analyze_impact before modifications
-- Use snow_graph_pattern__analysis to find similar artifacts`
-                    }]
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    async discoverRelationships(artifact) {
-        // Analyze artifact content to discover implicit relationships
-        const content = artifact.content || '';
-        const discoveries = [];
-        // Find script includes used
-        const scriptIncludeMatches = content.match(/new\s+(\w+)\(/g) || [];
-        for (const match of scriptIncludeMatches) {
-            const className = match.match(/new\s+(\w+)\(/)?.[1];
-            if (className)
-                discoveries.push(className);
-        }
-        // Find table references
-        const tableMatches = content.match(/GlideRecord\(['"](\w+)['"]\)/g) || [];
-        for (const match of tableMatches) {
-            const tableName = match.match(/GlideRecord\(['"](\w+)['"]\)/)?.[1];
-            if (tableName)
-                discoveries.push(tableName);
-        }
-        return discoveries.length;
-    }
-    async findRelatedArtifacts(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_find_related');
-        }
-        const session = this.driver.session();
-        try {
-            const { artifact_id, depth = 2, relationship_types = [] } = args;
-            const relFilter = relationship_types.length > 0
-                ? `WHERE type(r) IN [${relationship_types.map((t) => `'${t}'`).join(', ')}]`
-                : '';
-            const result = await session.run(`
-        MATCH (start:Artifact {id: $artifactId})
-        CALL apoc.path.subgraphAll(start, {
-          maxLevel: $depth,
-          relationshipFilter: "${relFilter}"
-        })
-        YIELD nodes, relationships
-        RETURN nodes, relationships
-        `, { artifactId: artifact_id, depth });
-            const nodes = result.records[0]?.get('nodes') || [];
-            const relationships = result.records[0]?.get('relationships') || [];
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔗 Related Artifacts Found:
-
-📊 **Summary:**
-- Total artifacts: ${nodes.length}
-- Total relationships: ${relationships.length}
-- Search depth: ${depth} levels
-
-🗂️ **Artifacts:**
-${nodes.map((n) => `- ${n.properties.type}: ${n.properties.name} (${n.properties.id})`).join('\n')}
-
-🔀 **Relationships:**
-${relationships.map((r) => `- ${r.type}: ${r.start} → ${r.end}`).join('\n')}
-
-💡 **Insights:**
-- This artifact is part of a ${nodes.length > 10 ? 'complex' : 'simple'} dependency network
-- ${relationships.filter((r) => r.type === 'REQUIRES').length} required dependencies
-- ${relationships.filter((r) => r.type === 'USES').length} usage relationships`
-                    }]
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    async analyzeImpact(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_analyze_impact');
-        }
-        const session = this.driver.session();
-        try {
-            const { artifact_id, change_type = 'modify' } = args;
-            // Find all artifacts that depend on this one
-            const result = await session.run(`
-        MATCH (target:Artifact {id: $artifactId})
-        MATCH (dependent:Artifact)-[:USES|REQUIRES|CALLS]->(target)
-        RETURN dependent, count(*) as impact_count
-        ORDER BY impact_count DESC
-        `, { artifactId: artifact_id });
-            const impactedArtifacts = result.records.map((r) => ({
-                artifact: r.get('dependent').properties,
-                impact: r.get('impact_count').toNumber()
-            }));
-            const riskLevel = impactedArtifacts.length > 5 ? 'HIGH' :
-                impactedArtifacts.length > 2 ? 'MEDIUM' : 'LOW';
-            return {
-                content: [{
-                        type: 'text',
-                        text: `⚠️ Impact Analysis for ${change_type} operation:
-
-🎯 **Target Artifact:** ${artifact_id}
-
-📊 **Impact Summary:**
-- Affected artifacts: ${impactedArtifacts.length}
-- Risk level: ${riskLevel}
-- Change type: ${change_type}
-
-🔗 **Affected Artifacts:**
-${impactedArtifacts.map((a) => `- ${a.artifact.type}: ${a.artifact.name} (Impact: ${a.impact})`).join('\n')}
-
-⚡ **Recommendations:**
-${riskLevel === 'HIGH' ? '- Create comprehensive test plan\n- Consider phased deployment\n- Notify all stakeholders' :
-                            riskLevel === 'MEDIUM' ? '- Test affected components\n- Review integration points' :
-                                '- Safe to proceed with standard testing'}
-
-🛡️ **Safety Measures:**
-- ${change_type === 'delete' ? 'Archive artifact before deletion' : 'Create backup before modification'}
-- Update all dependent artifacts
-- Run integration tests`
-                    }]
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    async suggestArtifacts(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_suggest_artifacts');
-        }
-        const session = this.driver.session();
-        try {
-            const { context, artifact_type, requirements = [] } = args;
-            // Find similar contexts and successful patterns
-            const result = await session.run(`
-        MATCH (a:Artifact)
-        WHERE a.purpose CONTAINS $context
-        ${artifact_type ? 'AND a.type = $artifactType' : ''}
-        WITH a
-        MATCH (a)-[r]-(related:Artifact)
-        RETURN a, collect(related) as related_artifacts
-        ORDER BY a.deployment_count DESC, a.success_rate DESC
-        LIMIT 10
-        `, { context, artifactType: artifact_type });
-            const suggestions = result.records.map((r) => ({
-                artifact: r.get('a').properties,
-                related: r.get('related_artifacts').map((n) => n.properties)
-            }));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🤖 AI-Powered Artifact Suggestions:
-
-📋 **Context:** ${context}
-${artifact_type ? `📦 **Type:** ${artifact_type}` : ''}
-
-✨ **Recommended Artifacts:**
-${suggestions.map((s, i) => `
-${i + 1}. **${s.artifact.name}** (${s.artifact.type})
-   - Purpose: ${s.artifact.purpose || 'General purpose'}
-   - Success rate: ${s.artifact.success_rate || 'Not measured'}%
-   - Used with: ${s.related.map((r) => r.name).join(', ')}
-`).join('\n')}
-
-🎯 **Pattern Analysis:**
-- Most successful pattern: ${suggestions[0]?.artifact.name || 'No patterns found'}
-- Common dependencies: ${this.findCommonDependencies(suggestions)}
-- Recommended architecture: ${this.suggestArchitecture(suggestions)}
-
-💡 **Implementation Tips:**
-- Start with the highest success rate artifact
-- Check compatibility with existing components
-- Consider the related artifacts for complete solution`
-                    }]
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    findCommonDependencies(suggestions) {
-        const deps = new Map();
-        suggestions.forEach((s) => {
-            s.related.forEach((r) => {
-                deps.set(r.name, (deps.get(r.name) || 0) + 1);
-            });
-        });
-        const sorted = Array.from(deps.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 3)
-            .map(([name]) => name);
-        return sorted.join(', ') || 'None identified';
-    }
-    suggestArchitecture(suggestions) {
-        const types = suggestions.map(s => s.artifact.type);
-        if (types.includes('flow') && types.includes('script_include')) {
-            return 'Flow-based with script include utilities';
-        }
-        else if (types.includes('widget') && types.includes('client_script')) {
-            return 'UI-centric with client-side logic';
-        }
-        else if (types.includes('business_rule')) {
-            return 'Event-driven with business rules';
-        }
-        return 'Standard ServiceNow pattern';
-    }
-    async analyzePatterns(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_pattern__analysis');
-        }
-        const session = this.driver.session();
-        try {
-            const { pattern_type = 'architectural', min_occurrences = 3 } = args;
-            // This would be more sophisticated in production
-            const query = pattern_type === 'architectural' ? `
-        MATCH (a:Artifact)-[r]->(b:Artifact)
-        WITH type(r) as relType, a.type as sourceType, b.type as targetType, count(*) as occurrences
-        WHERE occurrences >= $minOccurrences
-        RETURN sourceType, relType, targetType, occurrences
-        ORDER BY occurrences DESC
-      ` : `
-        MATCH (a:Artifact)
-        WHERE a.content IS NOT NULL
-        RETURN a.type, count(*) as count
-        ORDER BY count DESC
-      `;
-            const result = await session.run(query, { minOccurrences: min_occurrences });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Pattern Analysis Results:
-
-📊 **Pattern Type:** ${pattern_type}
-🔢 **Minimum Occurrences:** ${min_occurrences}
-
-📈 **Discovered Patterns:**
-${result.records.map((r) => {
-                            if (pattern_type === 'architectural') {
-                                return `- ${r.get('sourceType')} → ${r.get('relType')} → ${r.get('targetType')} (${r.get('occurrences')} times)`;
-                            }
-                            else {
-                                return `- ${r.get('type')}: ${r.get('count')} artifacts`;
-                            }
-                        }).join('\n')}
-
-💡 **Insights:**
-- Most common pattern: ${result.records[0] ? this.describePattern(result.records[0], pattern_type) : 'No patterns found'}
-- Recommended approach: Follow the established patterns for consistency
-- Optimization opportunity: Reuse common patterns as templates`
-                    }]
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    describePattern(record, patternType) {
-        if (patternType === 'architectural') {
-            return `${record.get('sourceType')} components typically ${record.get('relType').toLowerCase()} ${record.get('targetType')} components`;
-        }
-        return `${record.get('type')} is the most common artifact type`;
-    }
-    async generateVisualization(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_visualize');
-        }
-        const { focus_artifact, include_types = [], max_nodes = 50 } = args;
-        const typeFilter = include_types.length > 0
-            ? `WHERE n.type IN [${include_types.map((t) => `'${t}'`).join(', ')}]`
-            : '';
-        const cypherQuery = focus_artifact ? `
-      MATCH (center:Artifact {id: '${focus_artifact}'})
-      CALL apoc.path.subgraphAll(center, {
-        maxLevel: 3,
-        limit: ${max_nodes}
-      })
-      YIELD nodes, relationships
-      ${typeFilter}
-      RETURN nodes, relationships
-    ` : `
-      MATCH (n:Artifact)
-      ${typeFilter}
-      WITH n LIMIT ${max_nodes}
-      MATCH (n)-[r]-(m:Artifact)
-      RETURN n, r, m
-    `;
-        return {
-            content: [{
-                    type: 'text',
-                    text: `🎨 Graph Visualization Query:
-
-\`\`\`cypher
-${cypherQuery}
-\`\`\`
-
-📊 **Visualization Settings:**
-- Focus: ${focus_artifact || 'All artifacts'}
-- Types: ${include_types.join(', ') || 'All types'}
-- Max nodes: ${max_nodes}
-
-🖥️ **To Visualize:**
-1. Open Neo4j Browser
-2. Paste the query above
-3. Click Run
-4. Use the graph view for interactive exploration
-
-🎯 **Visualization Tips:**
-- Click nodes to see properties
-- Drag nodes to rearrange
-- Double-click to expand connections
-- Use filters to focus on specific relationships`
-                }]
-        };
-    }
-    async exportKnowledge(args) {
-        if (!this.neo4jAvailable || !this.driver) {
-            return this.createFallbackResponse('snow_graph_export_knowledge');
-        }
-        const session = this.driver.session();
-        try {
-            const { format = 'json', include_content = false } = args;
-            if (format === 'cypher') {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📤 Export Script (Cypher):
-
-\`\`\`cypher
-// Create indexes
-CREATE INDEX artifact_id IF NOT EXISTS FOR (a:Artifact) ON (a.id);
-CREATE INDEX artifact_type IF NOT EXISTS FOR (a:Artifact) ON (a.type);
-
-// Export all artifacts
-MATCH (a:Artifact)
-RETURN a.id, a.name, a.type, a.purpose${include_content ? ', a.content' : ''};
-
-// Export all relationships
-MATCH (a:Artifact)-[r]->(b:Artifact)
-RETURN a.id, type(r), b.id, r.data_flow;
-\`\`\`
-
-💾 **Usage:**
-1. Run in target Neo4j instance
-2. Import will recreate the knowledge graph
-3. All patterns and relationships preserved`
-                        }]
-                };
-            }
-            else {
-                const artifacts = await session.run('MATCH (a:Artifact) RETURN a');
-                const relationships = await session.run('MATCH (a:Artifact)-[r]->(b:Artifact) RETURN a.id as from, type(r) as type, b.id as to');
-                const exportData = {
-                    artifacts: artifacts.records.map((r) => r.get('a').properties),
-                    relationships: relationships.records.map((r) => ({
-                        from: r.get('from'),
-                        type: r.get('type'),
-                        to: r.get('to')
-                    })),
-                    metadata: {
-                        exported_at: new Date().toISOString(),
-                        total_artifacts: artifacts.records.length,
-                        total_relationships: relationships.records.length
-                    }
-                };
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📤 Knowledge Export Complete:
-
-\`\`\`json
-${JSON.stringify(exportData, null, 2).substring(0, 1000)}...
-\`\`\`
-
-📊 **Export Summary:**
-- Format: ${format}
-- Artifacts: ${exportData.metadata.total_artifacts}
-- Relationships: ${exportData.metadata.total_relationships}
-- Content included: ${include_content ? 'Yes' : 'No'}
-
-💾 **Next Steps:**
-1. Save the export to a file
-2. Use for backup or migration
-3. Share with team members
-4. Import into another instance`
-                        }]
-                };
-            }
-        }
-        finally {
-            await session.close();
-        }
-    }
-    async start() {
-        try {
-            // Try to connect to Neo4j if configured
-            if (this.neo4jAvailable && this.config) {
-                try {
-                    await this.connectToNeo4j();
-                    this.logger.info('Neo4j connection established');
-                }
-                catch (error) {
-                    this.logger.warn('Neo4j connection failed - running in fallback mode', error);
-                    this.neo4jAvailable = false;
-                }
-            }
-            const transport = new stdio_js_1.StdioServerTransport();
-            await this.server.connect(transport);
-            this.logger.info('ServiceNow Graph Memory MCP Server started');
-            if (!this.neo4jAvailable) {
-                this.logger.info('Running without Neo4j - all operations will return fallback responses');
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to start server', error);
-            throw error;
-        }
-    }
-    async stop() {
-        if (this.driver) {
-            await this.driver.close();
-        }
-    }
-}
-// Start the server
-const server = new ServiceNowGraphMemoryMCP();
-server.start().catch((error) => {
-    console.error('Failed to start ServiceNow Graph Memory MCP:', error);
-    process.exit(1);
-});
-// Graceful shutdown
-process.on('SIGINT', async () => {
-    await server.stop();
-    process.exit(0);
-});
-//# sourceMappingURL=servicenow-graph-memory-mcp.js.map