snow-flow 1.1.99 → 1.2.1

package/dist/cli.js

@@ -430,12 +430,11 @@ The Queen Agent will automatically discover and validate table schemas based on
 **THIS MUST BE YOUR VERY FIRST ACTION - Initialize the swarm memory session:**
 \`\`\`javascript
 // 🚨 EXECUTE THIS IMMEDIATELY - DO NOT SKIP OR DELAY!
-mcp__claude-flow__memory_usage({
-  action: "store",
+mcp__servicenow-memory__memory_store({
   key: "swarm_session_${sessionId}",
   value: JSON.stringify({
     objective: "${objective}",
-    status: "initializing",
+    status: "initializing", 
     started_at: new Date().toISOString(),
     queen_agent_id: "queen_${sessionId}",
     task_analysis: ${JSON.stringify(taskAnalysis, null, 2)},
@@ -451,11 +450,7 @@ mcp__claude-flow__memory_usage({
   namespace: "swarm_${sessionId}"
 });
 
-// Initialize agent coordination memory namespace
-mcp__claude-flow__memory_namespace({
-  action: "create",
-  namespace: "agents_${sessionId}"
-});
+// Agent coordination namespace handled automatically by ServiceNow memory system
 \`\`\`
 
 ### 2. MANDATORY MCP-FIRST Workflow Steps
@@ -479,8 +474,7 @@ const existingArtifacts = await mcp__servicenow-intelligent__snow_comprehensive_
 });
 
 // Store discovery results in memory for agents
-await mcp__claude-flow__memory_usage({
-  action: "store",
+await mcp__servicenow-memory__memory_store({
   key: "existing_artifacts_${sessionId}",
   value: JSON.stringify(existingArtifacts),
   namespace: "swarm_${sessionId}"
@@ -495,8 +489,7 @@ const updateSet = await mcp__servicenow-update-set__snow_update_set_create({
 });
 
 // Store Update Set info in memory
-await mcp__claude-flow__memory_usage({
-  action: "store", 
+await mcp__servicenow-memory__memory_store({
   key: "update_set_${sessionId}",
   value: JSON.stringify(updateSet),
   namespace: "swarm_${sessionId}"
@@ -572,8 +565,7 @@ for (const tableName of detectedTables) {
 }
 
 // Store discovered table schemas in memory
-await mcp__claude-flow__memory_usage({
-  action: "store",
+await mcp__servicenow-memory__memory_store({
   key: "table_schemas_${sessionId}",
   value: JSON.stringify({
     discovered_at: new Date().toISOString(),
@@ -637,10 +629,10 @@ Task("${taskAnalysis.primaryAgent}", \`
   
   Instructions:
   1. FIRST: Read ALL shared context from memory:
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
   
   2. 🔍 CRITICAL: Use discovered table schemas:
      - The table_schemas contain actual field names, types, and relationships
@@ -651,7 +643,7 @@ Task("${taskAnalysis.primaryAgent}", \`
   3. Check existing_artifacts to avoid duplication - reuse or extend existing ones
   4. ALL deployments MUST use the Update Set stored in memory
   5. Begin implementing the core ${taskAnalysis.taskType} requirements
-  6. Store all work progress with: mcp__claude-flow__memory_usage({action: "store", key: "agent_${taskAnalysis.primaryAgent}_progress", value: "...", namespace: "agents_${sessionId}"})
+  6. Store all work progress with: mcp__servicenow-memory__memory_store({key: "agent_${taskAnalysis.primaryAgent}_progress", value: "...", namespace: "agents_${sessionId}"})
   7. Update TodoWrite items as you complete tasks
   8. Read other agents' progress from namespace "agents_${sessionId}"
   
@@ -675,10 +667,10 @@ Task("${agent}", \`
   
   Instructions:
   1. FIRST: Read ALL shared context from memory (same as primary agent):
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__claude-flow__memory_usage({action: "retrieve", key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__servicenow-memory__memory_get({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
   
   2. 🔍 CRITICAL: Use discovered table schemas:
      - The table_schemas contain actual field names, types, and relationships
@@ -686,10 +678,10 @@ Task("${agent}", \`
      - Check key_fields for primary keys and references
      - If you need a table that wasn't discovered, use snow_table_schema_discovery first
   
-  3. Monitor primary agent's progress: mcp__claude-flow__memory_search({pattern: "agent_${taskAnalysis.primaryAgent}_*", namespace: "agents_${sessionId}"})
+  3. Monitor primary agent's progress: mcp__servicenow-memory__memory_search({pattern: "agent_${taskAnalysis.primaryAgent}_*", namespace: "agents_${sessionId}"})
   4. Wait for primary agent to establish base structure before major changes
   5. Enhance/support with your ${agent} expertise  
-  6. Store your progress: mcp__claude-flow__memory_usage({action: "store", key: "agent_${agent}_progress", value: "...", namespace: "agents_${sessionId}"})
+  6. Store your progress: mcp__servicenow-memory__memory_store({key: "agent_${agent}_progress", value: "...", namespace: "agents_${sessionId}"})
   7. Update relevant TodoWrite items
   
   🔐 AUTHENTICATION: Already validated by Queen. Use MCP tools directly.
@@ -883,15 +875,14 @@ Implement continuous memory synchronization for real-time coordination:
 // Initialize coordination heartbeat (Claude-Flow pattern)
 const coordinationInterval = setInterval(async () => {
   // Sync agent states across namespace
-  const agentStates = await mcp__claude-flow__memory_search({
+  const agentStates = await mcp__servicenow-memory__memory_search({
     pattern: "agent_*_progress",
     namespace: "agents_${sessionId}",
     limit: 50
   });
   
   // Update swarm coordination state with TTL for freshness
-  await mcp__claude-flow__memory_usage({
-    action: "store",
+  await mcp__servicenow-memory__memory_store({
     key: "swarm_coordination_${sessionId}",
     value: JSON.stringify({
       timestamp: new Date().toISOString(),
@@ -906,8 +897,7 @@ const coordinationInterval = setInterval(async () => {
   
   // Detect and resolve conflicts between agents
   if (agentStates.some(s => s.includes("conflict") || s.includes("duplicate"))) {
-    await mcp__claude-flow__memory_usage({
-      action: "store",
+    await mcp__servicenow-memory__memory_store({
       key: "conflict_resolution_needed",
       value: JSON.stringify({
         agents: agentStates.filter(s => s.includes("conflict")),
@@ -942,8 +932,7 @@ const coordinationInterval = setInterval(async () => {
     
     // Mark as tracked
     artifact.tracked_in_update_set = true;
-    await mcp__claude-flow__memory_usage({
-      action: "store",
+    await mcp__servicenow-memory__memory_store({
       key: \`agent_\${artifact.agent}_deployed_\${artifact.sys_id}\`,
       value: JSON.stringify(artifact),
       namespace: "agents_${sessionId}"
@@ -959,8 +948,7 @@ const coordinationInterval = setInterval(async () => {
 }, 10000); // Every 10 seconds
 
 // Also update main session state
-await mcp__claude-flow__memory_usage({
-  action: "store",
+await mcp__servicenow-memory__memory_store({
   key: "swarm_session_${sessionId}",
   value: JSON.stringify({
     status: "agents_working",
@@ -3335,6 +3323,31 @@ SNOW_FLOW_TIMEOUT_MINUTES=0
         await fs_1.promises.writeFile(envFilePath, envContent);
     }
 }
+async function appendToEnvFile(targetDir, content) {
+    const envFilePath = (0, path_1.join)(targetDir, '.env');
+    await fs_1.promises.appendFile(envFilePath, content);
+}
+async function checkNeo4jAvailability() {
+    const { execSync } = require('child_process');
+    try {
+        // Check if Neo4j is installed
+        execSync('which neo4j', { stdio: 'pipe' });
+        // Check if Neo4j is running
+        try {
+            execSync('neo4j status', { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            // Neo4j is installed but not running
+            console.log('ℹ️  Neo4j is installed but not running. Start with: neo4j start');
+            return false;
+        }
+    }
+    catch {
+        // Neo4j is not installed
+        return false;
+    }
+}
 async function createMCPConfig(targetDir) {
     // Create the correct .mcp.json file for Claude Code discovery
     const mcpConfig = {
@@ -4032,6 +4045,42 @@ program
         console.log('🔐 Creating environment configuration...');
         await createEnvFile(targetDir);
         console.log('✅ Environment file created\n');
+        // Phase 4.5: Check for Neo4j and offer graph memory setup
+        console.log('🧠 Checking for Neo4j Graph Memory support...');
+        const neo4jAvailable = await checkNeo4jAvailability();
+        let enableGraphMemory = false;
+        if (neo4jAvailable) {
+            console.log('✅ Neo4j detected! Graph memory features available.');
+            console.log('\n📊 Graph Memory provides:');
+            console.log('   - Intelligent artifact relationship tracking');
+            console.log('   - Impact analysis for changes');
+            console.log('   - Dependency visualization');
+            console.log('   - Pattern recognition across projects\n');
+            const readline = require('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question('Enable graph memory features? (Y/n): ', resolve);
+            });
+            rl.close();
+            enableGraphMemory = answer.toLowerCase() !== 'n';
+            if (enableGraphMemory) {
+                console.log('✅ Graph memory enabled\n');
+                // Add Neo4j config to .env
+                await appendToEnvFile(targetDir, `
+# Neo4j Graph Memory Configuration
+NEO4J_URI=bolt://localhost:7687
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=password
+`);
+            }
+        }
+        else {
+            console.log('ℹ️  Neo4j not detected. Graph memory features will be disabled.');
+            console.log('   To enable later: brew install neo4j && neo4j start\n');
+        }
         // Phase 5: Create MCP configuration and Claude Code settings
         console.log('🌐 MCP server configuration will be generated after build...');
         console.log('⚙️  Claude Code settings configured with:\n');
@@ -4096,122 +4145,139 @@ program
                 });
             }
             // Generate .mcp.json with correct paths
-            mcpConfig = {
-                mcpServers: {
-                    "servicenow-deployment": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-deployment-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-flow-composer": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-flow-composer-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-update-set": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-update-set-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-intelligent": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-intelligent-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-graph-memory": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-graph-memory-mcp.js")],
-                        env: {
-                            NEO4J_URI: envVars.NEO4J_URI || "bolt://localhost:7687",
-                            NEO4J_USER: envVars.NEO4J_USER || "neo4j",
-                            NEO4J_PASSWORD: envVars.NEO4J_PASSWORD || "password",
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-operations": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-operations-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-platform-development": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-platform-development-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-integration": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-integration-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-automation": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-automation-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-security-compliance": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-security-compliance-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "servicenow-reporting-analytics": {
-                        command: "node",
-                        args: [(0, path_1.join)(mcpBasePath, "servicenow-reporting-analytics-mcp.js")],
-                        env: {
-                            SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
-                            SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
-                            SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
-                        }
-                    },
-                    "snow-flow": {
-                        command: "npx",
-                        args: ["claude-flow@alpha", "mcp"],
-                        env: {}
-                    },
-                    "ruv-swarm": {
-                        command: "npx",
-                        args: ["claude-flow@alpha", "swarm", "--mode", "mcp"],
-                        env: {}
+            const mcpServers = {
+                "servicenow-deployment": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-deployment-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-flow-composer": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-flow-composer-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-update-set": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-update-set-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-intelligent": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-intelligent-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
                     }
                 }
             };
+            // Only add graph memory if Neo4j is enabled
+            if (enableGraphMemory) {
+                mcpServers["servicenow-graph-memory"] = {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-graph-memory-mcp.js")],
+                    env: {
+                        NEO4J_URI: envVars.NEO4J_URI || "bolt://localhost:7687",
+                        NEO4J_USER: envVars.NEO4J_USER || "neo4j",
+                        NEO4J_PASSWORD: envVars.NEO4J_PASSWORD || "password",
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                };
+            }
+            // Add remaining servers
+            Object.assign(mcpServers, {
+                "servicenow-operations": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-operations-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-platform-development": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-platform-development-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-integration": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-integration-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-automation": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-automation-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-security-compliance": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-security-compliance-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-reporting-analytics": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-reporting-analytics-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "servicenow-memory": {
+                    command: "node",
+                    args: [(0, path_1.join)(mcpBasePath, "servicenow-memory-mcp.js")],
+                    env: {
+                        SNOW_INSTANCE: envVars.SNOW_INSTANCE || "your-instance.service-now.com",
+                        SNOW_CLIENT_ID: envVars.SNOW_CLIENT_ID || "your-oauth-client-id",
+                        SNOW_CLIENT_SECRET: envVars.SNOW_CLIENT_SECRET || "your-oauth-client-secret"
+                    }
+                },
+                "snow-flow": {
+                    command: "npx",
+                    args: ["claude-flow@alpha", "mcp"],
+                    env: {}
+                },
+                "ruv-swarm": {
+                    command: "npx",
+                    args: ["claude-flow@alpha", "swarm", "--mode", "mcp"],
+                    env: {}
+                }
+            });
+            // Create the final mcpConfig
+            mcpConfig = {
+                mcpServers: mcpServers
+            };
             // Now initialize and start MCP servers
             const { MCPServerManager } = await Promise.resolve().then(() => __importStar(require('./utils/mcp-server-manager.js')));
             const manager = new MCPServerManager();

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

@@ -83,6 +83,11 @@ class ServiceNowGraphMemoryMCP {
             }
             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;
             }
         }
@@ -679,9 +684,29 @@ ${JSON.stringify(exportData, null, 2).substring(0, 1000)}...
         }
     }
     async start() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Graph Memory MCP Server started');
+        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) {

package/dist/version.js

@@ -7,12 +7,29 @@ exports.VERSION_INFO = exports.VERSION = void 0;
 exports.getVersionString = getVersionString;
 exports.getLatestFeatures = getLatestFeatures;
 exports.isLatestVersion = isLatestVersion;
-exports.VERSION = '1.1.99';
+exports.VERSION = '1.2.1';
 exports.VERSION_INFO = {
     version: exports.VERSION,
     name: 'Snow-Flow',
     description: 'ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development',
     features: {
+        '1.2.1': [
+            '🧠 NEO4J SMART INTEGRATION: Auto-detects Neo4j during init and offers optional graph memory setup',
+            '⚡ GRACEFUL FALLBACK: Graph memory server now starts without Neo4j, provides helpful fallback responses',
+            '🎯 CONDITIONAL CONFIGURATION: Graph memory only added to .mcp.json when Neo4j is enabled',
+            '🔧 IMPROVED ERROR HANDLING: No more crashes when Neo4j is unavailable - smooth degradation',
+            '📋 INIT ENHANCEMENT: Interactive prompt during init asks about graph memory features',
+            '💾 ADDED SERVICENOW-MEMORY: Memory MCP server now properly included in init configuration'
+        ],
+        '1.2.0': [
+            '🔄 ARCHITECTURE CHANGE: Switched from claude-flow memory tools to native ServiceNow memory system',
+            '🎯 MEMORY SYSTEM FIX: All CLI memory references now use mcp__servicenow-memory__ tools instead of mcp__claude-flow__memory_usage',
+            '✅ CRITICAL BUG RESOLVED: Fixed "memory tool is not available" error by using correct memory tool references',
+            '🚀 IMPROVED RELIABILITY: Queen Agent and swarm coordination now use dedicated ServiceNow memory infrastructure',
+            '💾 SEAMLESS MIGRATION: Automatic transition from claude-flow memory to ServiceNow memory without data loss',
+            '🔧 TOOL ALIGNMENT: All memory operations (store, get, search) now consistently use ServiceNow MCP server',
+            '📊 ENHANCED COORDINATION: Better multi-agent memory sharing through native ServiceNow memory system'
+        ],
         '1.1.91': [
             '🔧 MEMORY TOOLS FIX: Added memory_store, memory_get, memory_list tools directly to Intelligent MCP server',
             '📝 TODO TOOLS: Added todo_write and todo_read tools for task coordination across agents',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.1.99",
+  "version": "1.2.1",
   "description": "ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development inspired by claude-flow. Transform complex workflows into elegant one-command orchestration.",
   "main": "dist/index.js",
   "type": "commonjs",