snow-flow 1.1.0

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

@@ -0,0 +1,703 @@
+#!/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);
+                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() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        this.logger.info('ServiceNow Graph Memory MCP Server started');
+    }
+    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