snow-flow 1.4.49 → 2.0.0

package/manual-register-mcp.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * Manual MCP Registration Script for Snow-Flow
+ * Run this to register Snow-Flow MCP servers with Claude Desktop
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Claude Desktop config path on macOS
+const CLAUDE_CONFIG_PATH = path.join(
+  os.homedir(),
+  'Library',
+  'Application Support',
+  'Claude',
+  'claude_desktop_config.json'
+);
+
+// Determine Snow-Flow installation path
+const SNOW_FLOW_PATH = '/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow';
+
+// Snow-Flow MCP servers configuration
+const SNOW_FLOW_SERVERS = {
+  "snow-flow-operations": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-operations-mcp.js`]
+  },
+  "snow-flow-automation": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-automation-mcp.js`]
+  },
+  "snow-flow-integration": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-integration-mcp.js`]
+  },
+  "snow-flow-deployment": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-deployment-mcp.js`]
+  },
+  "snow-flow-platform-development": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-platform-development-mcp.js`]
+  },
+  "snow-flow-reporting-analytics": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-reporting-analytics-mcp.js`]
+  },
+  "snow-flow-security-compliance": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-security-compliance-mcp.js`]
+  },
+  "snow-flow-update-set": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-update-set-mcp.js`]
+  },
+  "snow-flow-intelligent": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-intelligent-mcp.js`]
+  },
+  "snow-flow-graph-memory": {
+    "command": "node",
+    "args": [`${SNOW_FLOW_PATH}/dist/mcp/servicenow-graph-memory-mcp.js`]
+  }
+};
+
+// Add environment variables if .env exists
+const envPath = path.join(SNOW_FLOW_PATH, '.env');
+if (fs.existsSync(envPath)) {
+  const envContent = fs.readFileSync(envPath, 'utf8');
+  const envVars = {};
+  
+  envContent.split('\n').forEach(line => {
+    const [key, value] = line.split('=');
+    if (key && value) {
+      envVars[key.trim()] = value.trim().replace(/^["']|["']$/g, '');
+    }
+  });
+  
+  // Add env vars to each server
+  Object.keys(SNOW_FLOW_SERVERS).forEach(serverKey => {
+    SNOW_FLOW_SERVERS[serverKey].env = envVars;
+  });
+}
+
+console.log('📋 Registering Snow-Flow MCP servers with Claude Desktop...\n');
+
+try {
+  // Read existing config
+  let config = { mcpServers: {} };
+  if (fs.existsSync(CLAUDE_CONFIG_PATH)) {
+    config = JSON.parse(fs.readFileSync(CLAUDE_CONFIG_PATH, 'utf8'));
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+  }
+  
+  // Add Snow-Flow servers
+  let addedCount = 0;
+  Object.keys(SNOW_FLOW_SERVERS).forEach(key => {
+    if (!config.mcpServers[key]) {
+      config.mcpServers[key] = SNOW_FLOW_SERVERS[key];
+      addedCount++;
+      console.log(`✅ Added ${key}`);
+    } else {
+      console.log(`⏭️  ${key} already exists`);
+    }
+  });
+  
+  // Write updated config
+  fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
+  
+  console.log(`\n📝 Updated Claude Desktop configuration`);
+  console.log(`   Added ${addedCount} new servers`);
+  console.log(`   Path: ${CLAUDE_CONFIG_PATH}`);
+  
+  console.log('\n🔄 Please restart Claude Desktop to load the MCP servers');
+  console.log('💡 Use /mcp in Claude to verify the servers are available');
+  
+  // Also create a proper .env file in Snow-Flow directory if needed
+  if (!fs.existsSync(envPath)) {
+    console.log('\n⚠️  No .env file found in Snow-Flow installation');
+    console.log('   Create one at: ' + envPath);
+    console.log('   With your ServiceNow credentials:');
+    console.log('   SNOW_INSTANCE=your-instance.service-now.com');
+    console.log('   SNOW_CLIENT_ID=your-client-id');
+    console.log('   SNOW_CLIENT_SECRET=your-client-secret');
+  }
+  
+} catch (error) {
+  console.error('❌ Error registering MCP servers:', error.message);
+  process.exit(1);
+}

package/mcp-wrapper.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# MCP Server Wrapper for Claude Code compatibility
+# This wrapper ensures proper execution of Node.js MCP servers
+
+# Get the script to run from first argument
+SCRIPT="$1"
+
+# Shift arguments to pass remaining to the script
+shift
+
+# Execute with Node.js
+exec node "$SCRIPT" "$@"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "1.4.49",
-  "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 50+ real MCP tools with AI-powered swarm orchestration. Zero Mock Data, 100% Real API Integration. Natural language interface for ServiceNow operations.",
+  "version": "2.0.0",
+  "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration. Zero Mock Data, 100% Real API Integration. Natural language interface for ServiceNow operations.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {

package/scripts/create-env.js

@@ -36,7 +36,7 @@ async function createEnvFile() {
   const neo4jPassword = await question('Neo4j password (default: password): ') || 'password';
   
   // Create .env content
-  const envContent = `# ServiceNow OAuth Configuration
+  const envContent = `# ServiceNow OAuth Configuration (recommended)
 SNOW_INSTANCE=${instance}
 SNOW_CLIENT_ID=${clientId}
 SNOW_CLIENT_SECRET=${clientSecret}
@@ -45,6 +45,11 @@ SNOW_CLIENT_SECRET=${clientSecret}
 OAUTH_TOKEN_URL=https://${instance}/oauth_token.do
 OAUTH_REDIRECT_URI=http://localhost:3000/callback
 
+# Basic Auth Configuration (deprecated - use OAuth instead)
+# Uncomment these lines ONLY if you need to use basic auth:
+# SNOW_USERNAME=your_username
+# SNOW_PASSWORD=your_password
+
 # Neo4j Configuration (optional - for Graph Memory MCP)
 NEO4J_URI=${neo4jUri}
 NEO4J_USER=${neo4jUser}

package/scripts/reset-mcp-servers.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Reset MCP Servers Script
+ * Kills all running MCP processes and optionally restarts them
+ */
+
+const { exec, spawn } = require('child_process');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+// Colors for console output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function logStep(step, message) {
+  console.log(`${colors.cyan}[${step}]${colors.reset} ${message}`);
+}
+
+// Get platform-specific commands
+function getKillCommand() {
+  const platform = os.platform();
+  if (platform === 'win32') {
+    return {
+      list: 'wmic process where "commandline like \'%servicenow-%mcp%\'" get processid,commandline',
+      kill: (pid) => `taskkill /F /PID ${pid}`
+    };
+  } else {
+    return {
+      list: "ps aux | grep -E 'servicenow-.*-mcp' | grep -v grep",
+      kill: (pid) => `kill -9 ${pid}`
+    };
+  }
+}
+
+// Kill all MCP processes
+async function killMCPProcesses() {
+  return new Promise((resolve) => {
+    logStep('1/4', 'Finding running MCP processes...');
+    
+    const commands = getKillCommand();
+    
+    exec(commands.list, (error, stdout, stderr) => {
+      if (error && !stderr) {
+        log('No MCP processes found running.', 'green');
+        resolve(0);
+        return;
+      }
+      
+      const lines = stdout.split('\n').filter(line => line.trim());
+      let killed = 0;
+      
+      if (os.platform() === 'win32') {
+        // Windows: Extract PIDs from wmic output
+        lines.forEach(line => {
+          const match = line.match(/(\d+)\s*$/);
+          if (match) {
+            const pid = match[1];
+            exec(commands.kill(pid), (err) => {
+              if (!err) {
+                log(`  ✓ Killed process ${pid}`, 'yellow');
+                killed++;
+              }
+            });
+          }
+        });
+      } else {
+        // Unix-like: Extract PIDs from ps output
+        lines.forEach(line => {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length > 1) {
+            const pid = parts[1];
+            exec(commands.kill(pid), (err) => {
+              if (!err) {
+                log(`  ✓ Killed process ${pid}`, 'yellow');
+                killed++;
+              }
+            });
+          }
+        });
+      }
+      
+      setTimeout(() => {
+        if (killed > 0) {
+          log(`Killed ${killed} MCP processes.`, 'green');
+        }
+        resolve(killed);
+      }, 1000);
+    });
+  });
+}
+
+// Clear temporary files and cache
+async function clearCache() {
+  logStep('2/4', 'Clearing MCP cache and temporary files...');
+  
+  const cacheLocations = [
+    path.join(os.homedir(), '.snow-flow', 'mcp-cache'),
+    path.join(os.homedir(), '.snow-flow', 'memory', '*.lock'),
+    path.join(process.cwd(), '.mcp-temp'),
+    path.join(process.cwd(), 'dist', 'mcp', '*.lock')
+  ];
+  
+  let cleared = 0;
+  
+  cacheLocations.forEach(location => {
+    try {
+      if (location.includes('*')) {
+        // Handle glob patterns
+        const dir = path.dirname(location);
+        const pattern = path.basename(location);
+        if (fs.existsSync(dir)) {
+          const files = fs.readdirSync(dir);
+          files.forEach(file => {
+            if (file.match(pattern.replace('*', '.*'))) {
+              fs.unlinkSync(path.join(dir, file));
+              cleared++;
+            }
+          });
+        }
+      } else if (fs.existsSync(location)) {
+        // Handle directories
+        fs.rmSync(location, { recursive: true, force: true });
+        cleared++;
+      }
+    } catch (error) {
+      // Ignore errors for non-existent files
+    }
+  });
+  
+  if (cleared > 0) {
+    log(`  ✓ Cleared ${cleared} cache locations`, 'green');
+  } else {
+    log('  ✓ No cache files found to clear', 'green');
+  }
+}
+
+// Verify no processes are running
+async function verifyClean() {
+  return new Promise((resolve) => {
+    logStep('3/4', 'Verifying all MCP processes are stopped...');
+    
+    const commands = getKillCommand();
+    
+    exec(commands.list, (error, stdout) => {
+      if (error || !stdout.trim()) {
+        log('  ✓ All MCP processes successfully stopped', 'green');
+        resolve(true);
+      } else {
+        log('  ⚠ Some MCP processes may still be running', 'yellow');
+        resolve(false);
+      }
+    });
+  });
+}
+
+// Restart MCP servers if requested
+async function restartServers() {
+  logStep('4/4', 'Restarting MCP servers...');
+  
+  const serverPath = path.join(__dirname, '..', 'dist', 'mcp', 'start-all-mcp-servers.js');
+  
+  if (!fs.existsSync(serverPath)) {
+    log('  ⚠ MCP server starter not found. Run "npm run build" first.', 'yellow');
+    return;
+  }
+  
+  log('  Starting MCP servers in background...', 'cyan');
+  
+  const child = spawn('node', [serverPath], {
+    detached: true,
+    stdio: 'ignore'
+  });
+  
+  child.unref();
+  
+  log('  ✓ MCP servers starting...', 'green');
+  log('\n  To view logs, check ~/.snow-flow/logs/', 'cyan');
+}
+
+// Main execution
+async function main() {
+  console.log('\n' + colors.magenta + '🔄 Snow-Flow MCP Server Reset' + colors.reset + '\n');
+  
+  const args = process.argv.slice(2);
+  const shouldRestart = args.includes('--restart') || args.includes('-r');
+  
+  try {
+    // Kill processes
+    await killMCPProcesses();
+    
+    // Clear cache
+    await clearCache();
+    
+    // Verify clean
+    await verifyClean();
+    
+    // Restart if requested
+    if (shouldRestart) {
+      await restartServers();
+    } else {
+      log('\n✅ MCP servers reset complete!', 'green');
+      log('To restart servers, run: npm run reset-mcp -- --restart', 'cyan');
+    }
+    
+  } catch (error) {
+    log(`\n❌ Error resetting MCP servers: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+// Help text
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+${colors.cyan}Snow-Flow MCP Server Reset${colors.reset}
+
+Usage: node reset-mcp-servers.js [options]
+
+Options:
+  -r, --restart    Restart MCP servers after reset
+  -h, --help       Show this help message
+
+Examples:
+  node reset-mcp-servers.js              # Reset only
+  node reset-mcp-servers.js --restart    # Reset and restart
+`);
+  process.exit(0);
+}
+
+// Run the script
+main().catch(error => {
+  log(`Fatal error: ${error.message}`, 'red');
+  process.exit(1);
+});

package/scripts/update-version.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * Update version.ts with the current version from package.json
+ * This script runs automatically after npm version
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read package.json
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = packageJson.version;
+
+// Path to version.ts
+const versionTsPath = path.join(__dirname, '..', 'src', 'version.ts');
+
+// Read current version.ts content
+const versionTsContent = fs.readFileSync(versionTsPath, 'utf8');
+
+// Replace the VERSION constant
+const updatedContent = versionTsContent.replace(
+  /export const VERSION = '[^']+';/,
+  `export const VERSION = '${version}';`
+);
+
+// Write updated content back
+fs.writeFileSync(versionTsPath, updatedContent, 'utf8');
+
+console.log(`✅ Updated version.ts to ${version}`);

package/src/agents/README.md

@@ -0,0 +1,192 @@
+# ServiceNow Specialist Agents
+
+This directory contains the implementation of ServiceNow specialist agents that work together through Claude Code to build, deploy, and maintain ServiceNow solutions.
+
+## ⚠️ IMPORTANT: Flow Builder Agent Removed in v1.4.0 ⚠️
+
+**Note**: The Flow Builder Agent and all flow-related functionality have been removed in v1.4.0 due to critical bugs. The agent file may still exist but is no longer functional. Please use ServiceNow's native Flow Designer interface directly for flow creation.
+
+## 🤖 Available Agents
+
+### 1. Widget Creator Agent (`widget-creator-agent.ts`)
+Specializes in creating ServiceNow Service Portal widgets.
+
+**Capabilities:**
+- HTML template creation
+- CSS styling and responsive design
+- Client-side JavaScript development
+- Server-side data processing
+- Chart.js integration
+- Demo data generation
+
+**MCP Tools Used:**
+- `snow_deploy` - Deploy widgets to ServiceNow
+- `snow_preview_widget` - Preview widget rendering
+- `snow_widget_test` - Test widget functionality
+
+### 2. Flow Builder Agent (`flow-builder-agent.ts`)
+Specializes in creating ServiceNow Flow Designer workflows.
+
+**Capabilities:**
+- Business process design
+- Flow trigger configuration
+- Approval workflow creation
+- Integration flow building
+- Error handling design
+
+**MCP Tools Used:**
+- `snow_create_flow` - Create flows from natural language
+- `snow_test_flow_with_mock` - Test flows with mock data
+- `snow_link_catalog_to_flow` - Link flows to catalog items
+
+### 3. Script Writer Agent (`script-writer-agent.ts`)
+Specializes in creating ServiceNow scripts.
+
+**Capabilities:**
+- Business rule creation
+- Script include development
+- Client script implementation
+- Scheduled job scripts
+- Performance optimization
+
+**MCP Tools Used:**
+- `snow_create_script_include` - Create script includes
+- `snow_create_business_rule` - Create business rules
+- `snow_create_client_script` - Create client scripts
+
+### 4. Test Agent (`test-agent.ts`)
+Specializes in testing ServiceNow artifacts.
+
+**Capabilities:**
+- Test scenario creation
+- Mock data generation
+- Integration testing
+- Performance validation
+- Quality assurance
+
+**MCP Tools Used:**
+- `snow_test_flow_with_mock` - Test flows
+- `snow_widget_test` - Test widgets
+- `snow_comprehensive_flow_test` - Comprehensive testing
+- `snow_cleanup_test_artifacts` - Clean up test data
+
+### 5. Security Agent (`security-agent.ts`)
+Specializes in ServiceNow security and compliance.
+
+**Capabilities:**
+- Security policy enforcement
+- Vulnerability scanning
+- Access control validation
+- Compliance checking (SOX, GDPR, HIPAA)
+- Security best practices
+
+**MCP Tools Used:**
+- `snow_create_access_control` - Create ACLs
+- `snow_security_scan` - Security scanning
+- `snow_run_compliance_scan` - Compliance validation
+
+## 🏗️ Architecture
+
+### Base Agent Class (`base-agent.ts`)
+All agents extend the `BaseAgent` class which provides:
+- Shared memory integration via SQLite
+- Progress reporting to Queen Agent
+- Inter-agent communication
+- Error handling and logging
+- Lifecycle management
+
+### Agent Communication Pattern
+```typescript
+// Agents communicate through shared memory
+await agent.storeArtifact(artifact);
+await agent.reportProgress('Task completed', 100);
+await agent.sendMessage(otherAgentId, 'coordination', data);
+```
+
+### Integration with Queen Agent
+The Queen Agent uses `AgentFactory` to spawn these specialized agents:
+```typescript
+const agent = await agentFactory.createSpecializedAgent('widget-creator');
+const result = await agent.execute(instruction, context);
+```
+
+## 🚀 Usage Examples
+
+### Creating a Widget
+```typescript
+const widgetAgent = new WidgetCreatorAgent({ debugMode: true });
+const result = await widgetAgent.execute(
+  'Create an incident dashboard widget with real-time charts'
+);
+```
+
+### Building a Flow
+```typescript
+const flowAgent = new FlowBuilderAgent({ debugMode: true });
+const result = await flowAgent.execute(
+  'Create an approval flow for catalog requests with manager approval'
+);
+```
+
+### Writing a Script
+```typescript
+const scriptAgent = new ScriptWriterAgent({ debugMode: true });
+const result = await scriptAgent.execute(
+  'Create a business rule to calculate incident priority'
+);
+```
+
+### Testing Artifacts
+```typescript
+const testAgent = new TestAgent({ debugMode: true });
+const result = await testAgent.execute(
+  'Test the incident dashboard widget with comprehensive scenarios'
+);
+```
+
+### Security Scanning
+```typescript
+const securityAgent = new SecurityAgent({ debugMode: true });
+const result = await securityAgent.execute(
+  'Perform security scan on all recent artifacts'
+);
+```
+
+## 🧪 Testing
+
+Run the agent test suite:
+```bash
+npm test src/agents/test-agents.ts
+```
+
+## 📝 Best Practices
+
+1. **Always use shared memory** for coordination between agents
+2. **Report progress regularly** for long-running tasks
+3. **Handle errors gracefully** and provide meaningful error messages
+4. **Store artifacts** in shared memory for other agents to use
+5. **Clean up resources** when agent tasks complete
+
+## 🔄 Agent Lifecycle
+
+1. **Initialization**: Agent is created with configuration
+2. **Execution**: Agent performs its specialized task
+3. **Coordination**: Agent communicates with other agents
+4. **Completion**: Agent reports results and stores artifacts
+5. **Cleanup**: Agent releases resources
+
+## 🔗 MCP Tool Integration
+
+Each agent knows which MCP tools to recommend for its tasks. The actual MCP tool execution happens through Claude Code, not directly by the agents. Agents provide:
+- Tool recommendations
+- Parameter preparation
+- Result interpretation
+- Error handling
+
+## 🎯 Future Enhancements
+
+- [ ] Add more specialized agents (Catalog Manager, Integration Specialist)
+- [ ] Implement agent learning from past executions
+- [ ] Add performance metrics collection
+- [ ] Enhance inter-agent coordination protocols
+- [ ] Add agent health monitoring