snow-flow 2.0.4 → 2.0.6

package/memory/update-set-sessions/27718fb983faea102a7ea130ceaad34b.json

@@ -0,0 +1,9 @@
+{
+  "update_set_id": "27718fb983faea102a7ea130ceaad34b",
+  "name": "iPhone 6 Approval Flow",
+  "description": "Flow to require admin approval for iPhone 6 requests. Includes condition checking, approval routing, and notifications for approval/rejection.",
+  "user_story": "FLOW-001",
+  "created_at": "2025-07-18T14:17:25.143Z",
+  "state": "in_progress",
+  "artifacts": []
+}

package/memory/update-set-sessions/412e9bf6833e22502a7ea130ceaad30a.json

@@ -0,0 +1,8 @@
+{
+  "update_set_id": "412e9bf6833e22502a7ea130ceaad30a",
+  "name": "Auto-HTTP request tracking development (2025-07-21 18:56)",
+  "description": "Automatically created Update Set for HTTP request tracking development",
+  "created_at": "2025-07-21 18:56:29",
+  "state": "in progress",
+  "artifacts": []
+}

package/memory/update-set-sessions/66fc5a79837aea102a7ea130ceaad3ab.json

@@ -0,0 +1,9 @@
+{
+  "update_set_id": "66fc5a79837aea102a7ea130ceaad3ab",
+  "name": "iPhone 6 Admin Approval Flow",
+  "description": "Flow to check if a request is for iPhone 6 and route to admin approval if true. Includes flow designer workflow, approval configurations, and notification templates.",
+  "user_story": "REQ-001",
+  "created_at": "2025-07-18T11:37:52.906Z",
+  "state": "in_progress",
+  "artifacts": []
+}

package/memory/update-set-sessions/71a30ff5837eea102a7ea130ceaad37f.json

@@ -0,0 +1,9 @@
+{
+  "update_set_id": "71a30ff5837eea102a7ea130ceaad37f",
+  "name": "iPhone 6 Approval Flow",
+  "description": "Flow to check for iPhone 6 requests and require admin approval. Includes flow design, approval routing, and notifications.",
+  "user_story": "TASK-001",
+  "created_at": "2025-07-18T14:26:50.683Z",
+  "state": "in_progress",
+  "artifacts": []
+}

package/memory/update-set-sessions/74fba27983faea102a7ea130ceaad3bd.json

@@ -0,0 +1,9 @@
+{
+  "update_set_id": "74fba27983faea102a7ea130ceaad3bd",
+  "name": "iPhone 6 Approval Flow",
+  "description": "Implementation of approval flow for iPhone 6 requests. When a request is for an iPhone 6, it requires admin approval before proceeding.",
+  "user_story": "FLOW-001",
+  "created_at": "2025-07-18T12:43:17.671Z",
+  "state": "in_progress",
+  "artifacts": []
+}

package/memory/update-set-sessions/a0b147b5837eea102a7ea130ceaad344.json

@@ -0,0 +1,58 @@
+{
+  "update_set_id": "a0b147b5837eea102a7ea130ceaad344",
+  "name": "iPhone 6 Testing - Flow Validation",
+  "description": "Testing and validation of iPhone 6 approval flow functionality including detection logic, approval routing, notifications, and edge cases",
+  "user_story": "TEST-001",
+  "created_at": "2025-07-18T14:18:18.118Z",
+  "state": "complete",
+  "artifacts": [
+    {
+      "type": "business_rule",
+      "sys_id": "07e18bb5837eea102a7ea130ceaad330",
+      "name": "iPhone 6 Test Request Creator",
+      "created_at": "2025-07-18T14:19:22.675Z"
+    },
+    {
+      "type": "script_include",
+      "sys_id": "89128fb5837eea102a7ea130ceaad312",
+      "name": "iPhone6ApprovalFlowTester",
+      "created_at": "2025-07-18T14:20:04.704Z"
+    },
+    {
+      "type": "ui_action",
+      "sys_id": "6b228fb5837eea102a7ea130ceaad31a",
+      "name": "Run iPhone 6 Flow Tests",
+      "created_at": "2025-07-18T14:20:27.725Z"
+    },
+    {
+      "type": "business_rule",
+      "sys_id": "ba3243f5837eea102a7ea130ceaad39d",
+      "name": "iPhone 6 Approval Routing Test",
+      "created_at": "2025-07-18T14:20:58.345Z"
+    },
+    {
+      "type": "notification",
+      "sys_id": "c94243f5837eea102a7ea130ceaad3a5",
+      "name": "iPhone 6 Approval Required",
+      "created_at": "2025-07-18T14:21:02.112Z"
+    },
+    {
+      "type": "notification",
+      "sys_id": "3a4283f5837eea102a7ea130ceaad342",
+      "name": "iPhone 6 Request Submitted",
+      "created_at": "2025-07-18T14:21:06.169Z"
+    },
+    {
+      "type": "script_include",
+      "sys_id": "117247b5837eea102a7ea130ceaad3a6",
+      "name": "iPhone6EdgeCaseTester",
+      "created_at": "2025-07-18T14:22:54.361Z"
+    },
+    {
+      "type": "script_include",
+      "sys_id": "86b283f5837eea102a7ea130ceaad33a",
+      "name": "iPhone6TestReportGenerator",
+      "created_at": "2025-07-18T14:22:57.448Z"
+    }
+  ]
+}

package/memory/update-set-sessions/b13f5eb983baea102a7ea130ceaad33e.json

@@ -0,0 +1,9 @@
+{
+  "update_set_id": "b13f5eb983baea102a7ea130ceaad33e",
+  "name": "iPhone 6 Admin Approval Flow",
+  "description": "Implements a flow that checks if a service catalog request is for an iPhone 6. If it is, the request requires admin approval before proceeding.",
+  "user_story": "REQ-001",
+  "created_at": "2025-07-18T11:47:39.398Z",
+  "state": "in_progress",
+  "artifacts": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "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",

package/reports/swarm-auto-centralized-1752649029776.json

@@ -0,0 +1,13 @@
+{
+  "objective": "create a multi agent implementation of claude-flow for a servicenow instance. As in the way that we do exactly the same as what claude-flow already does, multi agent orchestration of claude-code, but then for SerivceNow, for example I want that this cmd: [snow-flow swarm 'create a widget for X'] a multi agent orchestration spawns with multiple agents that would create a widget in servicenow, or anything ofcourse. We should look at claude-flows github and should duplicate as best as we could to get this product: https://github.com/ruvnet/claude-flow - this would be called snow-flow as a reference to servicenow that everyone calls snow wrongly and flow as in claude-flow. Just like claude-flow this snow-flow would live in the cli, orchestrating claude-code how to build, but then it would be always pointed towards servicenow. The user should give their OAuth or basic authentication and should be able to, kist like claude-flow, use their claude-code subscription to save on token costs. Claude-flow only orchestrates, claude-code creates so its important that we keep that aspect of the tool",
+  "strategy": "auto",
+  "mode": "centralized",
+  "maxAgents": 5,
+  "timeout": 60,
+  "parallel": false,
+  "monitor": false,
+  "output": "json",
+  "outputDir": "./reports",
+  "timestamp": "2025-07-16T06:57:09.774Z",
+  "id": "swarm-auto-centralized-1752649029776"
+}

package/scripts/postinstall.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+console.log('🚀 Setting up Snow-Flow...');
+
+// Check if we're in a global install
+const isGlobalInstall = process.env.npm_config_global === 'true' || 
+                        process.env.npm_config_global === true;
+
+if (isGlobalInstall) {
+  console.log('✅ Snow-Flow installed globally');
+  console.log('📁 Run "snow-flow init" in your project directory to initialize');
+  
+  // Create global config directory
+  const globalConfigDir = path.join(os.homedir(), '.snow-flow');
+  if (!fs.existsSync(globalConfigDir)) {
+    fs.mkdirSync(globalConfigDir, { recursive: true });
+    console.log(`✅ Created global config directory at ${globalConfigDir}`);
+  }
+} else {
+  // Local installation - don't create directories automatically
+  console.log('✅ Snow-Flow installed locally');
+  console.log('🔧 Run "snow-flow init" to initialize your project');
+}
+
+console.log('\n📚 Documentation: https://github.com/groeimetai/snow-flow#readme');
+console.log('🆘 Get help: snow-flow --help');

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/servicenow/widgets/openai_incident_classifier/client_controller.js

@@ -0,0 +1,284 @@
+function OpenAIIncidentClassifierController($scope, $http, spUtil) {
+  var c = this;
+  
+  // Initialize variables
+  c.incidents = [];
+  c.statistics = {
+    totalIncidents: 0,
+    classifiedIncidents: 0,
+    averageConfidence: 0,
+    processingTime: 0
+  };
+  c.isLoading = false;
+  c.error = null;
+  c.charts = {};
+  
+  // Date range and filtering
+  c.dateRange = {
+    start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
+    end: new Date().toISOString().split('T')[0]
+  };
+  c.selectedPriority = '';
+  
+  // Pagination
+  c.pagination = {
+    currentPage: 1,
+    pageSize: 10,
+    totalPages: 1,
+    totalRecords: 0,
+    pages: []
+  };
+  
+  // Initialize widget
+  c.initialize = function() {
+    c.loadData();
+  };
+  
+  // Load data from server
+  c.loadData = function() {
+    c.isLoading = true;
+    c.error = null;
+    
+    var params = {
+      start_date: c.dateRange.start,
+      end_date: c.dateRange.end,
+      priority: c.selectedPriority,
+      page: c.pagination.currentPage,
+      page_size: c.pagination.pageSize
+    };
+    
+    $http.post('/api/now/sp/widget/' + c.widget.id, {
+      action: 'get_incidents',
+      params: params
+    }).then(function(response) {
+      if (response.data.result.success) {
+        c.incidents = response.data.result.incidents;
+        c.statistics = response.data.result.statistics;
+        c.pagination.totalRecords = response.data.result.total_records;
+        c.pagination.totalPages = Math.ceil(c.pagination.totalRecords / c.pagination.pageSize);
+        c.updatePaginationPages();
+        c.updateCharts();
+      } else {
+        c.error = response.data.result.error || 'Failed to load incidents';
+      }
+    }).catch(function(error) {
+      c.error = 'Error loading data: ' + (error.data && error.data.error ? error.data.error : error.message);
+    }).finally(function() {
+      c.isLoading = false;
+    });
+  };
+  
+  // Update pagination pages array
+  c.updatePaginationPages = function() {
+    c.pagination.pages = [];
+    var startPage = Math.max(1, c.pagination.currentPage - 2);
+    var endPage = Math.min(c.pagination.totalPages, c.pagination.currentPage + 2);
+    
+    for (var i = startPage; i <= endPage; i++) {
+      c.pagination.pages.push(i);
+    }
+  };
+  
+  // Go to specific page
+  c.goToPage = function(page) {
+    if (page >= 1 && page <= c.pagination.totalPages && page !== c.pagination.currentPage) {
+      c.pagination.currentPage = page;
+      c.loadData();
+    }
+  };
+  
+  // Date range change handler
+  c.onDateRangeChange = function() {
+    c.pagination.currentPage = 1;
+    c.loadData();
+  };
+  
+  // Priority change handler
+  c.onPriorityChange = function() {
+    c.pagination.currentPage = 1;
+    c.loadData();
+  };
+  
+  // Refresh data
+  c.refreshData = function() {
+    c.loadData();
+  };
+  
+  // Reclassify incident
+  c.reclassifyIncident = function(incident) {
+    c.isLoading = true;
+    
+    $http.post('/api/now/sp/widget/' + c.widget.id, {
+      action: 'reclassify_incident',
+      incident_id: incident.sys_id
+    }).then(function(response) {
+      if (response.data.result.success) {
+        spUtil.addInfoMessage('Incident reclassified successfully');
+        c.loadData();
+      } else {
+        c.error = response.data.result.error || 'Failed to reclassify incident';
+      }
+    }).catch(function(error) {
+      c.error = 'Error reclassifying incident: ' + (error.data && error.data.error ? error.data.error : error.message);
+    }).finally(function() {
+      c.isLoading = false;
+    });
+  };
+  
+  // Update charts
+  c.updateCharts = function() {
+    c.createClassificationChart();
+    c.createPriorityChart();
+    c.createTrendChart();
+  };
+  
+  // Create classification distribution chart
+  c.createClassificationChart = function() {
+    var ctx = document.getElementById('classificationChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.classification) {
+      c.charts.classification.destroy();
+    }
+    
+    // Aggregate classification data
+    var classificationData = {};
+    c.incidents.forEach(function(incident) {
+      var classification = incident.ai_classification || 'Unclassified';
+      classificationData[classification] = (classificationData[classification] || 0) + 1;
+    });
+    
+    var labels = Object.keys(classificationData);
+    var data = Object.values(classificationData);
+    var colors = ['#dc3545', '#007bff', '#28a745', '#fd7e14', '#6f42c1', '#6c757d'];
+    
+    c.charts.classification = new Chart(ctx, {
+      type: 'doughnut',
+      data: {
+        labels: labels,
+        datasets: [{
+          data: data,
+          backgroundColor: colors.slice(0, labels.length),
+          borderWidth: 2,
+          borderColor: '#fff'
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+          legend: {
+            position: 'bottom'
+          }
+        }
+      }
+    });
+  };
+  
+  // Create priority distribution chart
+  c.createPriorityChart = function() {
+    var ctx = document.getElementById('priorityChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.priority) {
+      c.charts.priority.destroy();
+    }
+    
+    // Aggregate priority data
+    var priorityData = {};
+    var priorityLabels = {'1': 'Critical', '2': 'High', '3': 'Moderate', '4': 'Low'};
+    
+    c.incidents.forEach(function(incident) {
+      var priority = incident.priority || '4';
+      var label = priorityLabels[priority] || 'Unknown';
+      priorityData[label] = (priorityData[label] || 0) + 1;
+    });
+    
+    var labels = Object.keys(priorityData);
+    var data = Object.values(priorityData);
+    var colors = ['#dc3545', '#fd7e14', '#ffc107', '#28a745'];
+    
+    c.charts.priority = new Chart(ctx, {
+      type: 'bar',
+      data: {
+        labels: labels,
+        datasets: [{
+          label: 'Number of Incidents',
+          data: data,
+          backgroundColor: colors.slice(0, labels.length),
+          borderWidth: 1
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        scales: {
+          y: {
+            beginAtZero: true
+          }
+        }
+      }
+    });
+  };
+  
+  // Create trend chart
+  c.createTrendChart = function() {
+    var ctx = document.getElementById('trendChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.trend) {
+      c.charts.trend.destroy();
+    }
+    
+    // Aggregate trend data by date
+    var trendData = {};
+    c.incidents.forEach(function(incident) {
+      var date = new Date(incident.created_date).toISOString().split('T')[0];
+      trendData[date] = (trendData[date] || 0) + 1;
+    });
+    
+    var labels = Object.keys(trendData).sort();
+    var data = labels.map(function(date) {
+      return trendData[date];
+    });
+    
+    c.charts.trend = new Chart(ctx, {
+      type: 'line',
+      data: {
+        labels: labels,
+        datasets: [{
+          label: 'Incidents per Day',
+          data: data,
+          borderColor: '#007bff',
+          backgroundColor: 'rgba(0, 123, 255, 0.1)',
+          borderWidth: 2,
+          fill: true
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        scales: {
+          y: {
+            beginAtZero: true
+          }
+        }
+      }
+    });
+  };
+  
+  // Cleanup function
+  c.$onDestroy = function() {
+    Object.values(c.charts).forEach(function(chart) {
+      if (chart) {
+        chart.destroy();
+      }
+    });
+  };
+  
+  // Initialize widget when loaded
+  c.initialize();
+}