snow-flow 3.4.39 → 3.5.0

package/README.md

@@ -361,9 +361,9 @@ await snow_query_table({
 
 ### Core Commands
 ```bash
-snow-flow start              # Start orchestration system
-snow-flow status            # System status
-snow-flow monitor           # Real-time monitoring
+snow-flow swarm "<objective>"  # Execute multi-agent swarm
+snow-flow auth login          # Authenticate with ServiceNow
+snow-flow init               # Initialize project
 ```
 
 ### Agent Management
@@ -450,14 +450,16 @@ ServiceNow uses Rhino engine. Always use ES5 syntax:
 # Enable verbose logging
 export DEBUG=snow-flow:*
 
-# Check configuration
-snow-flow config validate
+# Check version and help
+snow-flow --version
+snow-flow --help
 
-# Test ServiceNow connection
-snow-flow test connection
+# Test authentication
+snow-flow auth login
+snow-flow auth status
 
-# View logs
-snow-flow logs --tail 100
+# Re-initialize if needed
+snow-flow init
 ```
 
 ## Project Structure

package/dist/index.d.ts

@@ -6,7 +6,11 @@ export * from './types/index.js';
 export { ServiceNowOAuth } from './utils/snow-oauth.js';
 export { ServiceNowClient } from './utils/servicenow-client.js';
 export { Logger } from './utils/logger.js';
+export { ArtifactLocalSync } from './utils/artifact-local-sync.js';
+export { SmartFieldFetcher } from './utils/smart-field-fetcher.js';
+export * from './utils/artifact-sync/artifact-registry.js';
 export { ServiceNowMCPServer } from './mcp/servicenow-mcp-server.js';
+export { ServiceNowLocalDevelopmentMCP } from './mcp/servicenow-local-development-mcp.js';
 export { SnowFlowSystem, snowFlowSystem } from './snow-flow-system.js';
 export { SnowFlowConfig, snowFlowConfig } from './config/snow-flow-config.js';
 export { MemorySystem } from './memory/memory-system.js';

package/dist/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemHealth = exports.PerformanceTracker = exports.FALLBACK_STRATEGIES = exports.ErrorRecovery = exports.MemorySystem = exports.snowFlowConfig = exports.SnowFlowConfig = exports.snowFlowSystem = exports.SnowFlowSystem = exports.ServiceNowMCPServer = exports.Logger = exports.ServiceNowClient = exports.ServiceNowOAuth = void 0;
+exports.SystemHealth = exports.PerformanceTracker = exports.FALLBACK_STRATEGIES = exports.ErrorRecovery = exports.MemorySystem = exports.snowFlowConfig = exports.SnowFlowConfig = exports.snowFlowSystem = exports.SnowFlowSystem = exports.ServiceNowLocalDevelopmentMCP = exports.ServiceNowMCPServer = exports.SmartFieldFetcher = exports.ArtifactLocalSync = exports.Logger = exports.ServiceNowClient = exports.ServiceNowOAuth = void 0;
 // Export main types
 __exportStar(require("./types/index.js"), exports);
 // Export utilities
@@ -28,9 +28,17 @@ var servicenow_client_js_1 = require("./utils/servicenow-client.js");
 Object.defineProperty(exports, "ServiceNowClient", { enumerable: true, get: function () { return servicenow_client_js_1.ServiceNowClient; } });
 var logger_js_1 = require("./utils/logger.js");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_js_1.Logger; } });
-// Export MCP server
+// Export artifact sync system
+var artifact_local_sync_js_1 = require("./utils/artifact-local-sync.js");
+Object.defineProperty(exports, "ArtifactLocalSync", { enumerable: true, get: function () { return artifact_local_sync_js_1.ArtifactLocalSync; } });
+var smart_field_fetcher_js_1 = require("./utils/smart-field-fetcher.js");
+Object.defineProperty(exports, "SmartFieldFetcher", { enumerable: true, get: function () { return smart_field_fetcher_js_1.SmartFieldFetcher; } });
+__exportStar(require("./utils/artifact-sync/artifact-registry.js"), exports);
+// Export MCP servers
 var servicenow_mcp_server_js_1 = require("./mcp/servicenow-mcp-server.js");
 Object.defineProperty(exports, "ServiceNowMCPServer", { enumerable: true, get: function () { return servicenow_mcp_server_js_1.ServiceNowMCPServer; } });
+var servicenow_local_development_mcp_js_1 = require("./mcp/servicenow-local-development-mcp.js");
+Object.defineProperty(exports, "ServiceNowLocalDevelopmentMCP", { enumerable: true, get: function () { return servicenow_local_development_mcp_js_1.ServiceNowLocalDevelopmentMCP; } });
 // Snow-Flow System Integration (New)
 var snow_flow_system_js_1 = require("./snow-flow-system.js");
 Object.defineProperty(exports, "SnowFlowSystem", { enumerable: true, get: function () { return snow_flow_system_js_1.SnowFlowSystem; } });

package/dist/mcp/enhancements/smart-query-enhancement.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Smart Query Enhancement for MCP Operations
+ *
+ * Automatically handles large artifact queries by intelligent field splitting
+ * while maintaining context relationships for Claude.
+ */
+import { MCPToolResult } from '../shared/mcp-types';
+export declare class SmartQueryEnhancement {
+    private smartFetcher;
+    constructor(serviceNowClient: any);
+    /**
+     * Enhance snow_query_table to handle large artifacts intelligently
+     */
+    enhanceQueryTable(originalArgs: any): Promise<MCPToolResult>;
+    /**
+     * Generate context message for widget fetch
+     */
+    private generateWidgetContextMessage;
+    /**
+     * Generate context message for flow fetch
+     */
+    private generateFlowContextMessage;
+    /**
+     * Generate context message for business rule fetch
+     */
+    private generateBusinessRuleContextMessage;
+    /**
+     * Execute original query when smart fetch not needed
+     */
+    private executeOriginalQuery;
+    /**
+     * Search within specific fields
+     */
+    searchInFields(args: {
+        table: string;
+        field: string;
+        searchTerm: string;
+        additionalQuery?: string;
+    }): Promise<MCPToolResult>;
+}
+/**
+ * Helper to detect if a query will likely exceed token limits
+ */
+export declare function willExceedTokenLimit(fields: string[], table: string): boolean;
+/**
+ * Generate hint for Claude about using smart fetch
+ */
+export declare function generateSmartFetchHint(): string;
+//# sourceMappingURL=smart-query-enhancement.d.ts.map

package/dist/mcp/enhancements/smart-query-enhancement.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Smart Query Enhancement for MCP Operations
+ *
+ * Automatically handles large artifact queries by intelligent field splitting
+ * while maintaining context relationships for Claude.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartQueryEnhancement = void 0;
+exports.willExceedTokenLimit = willExceedTokenLimit;
+exports.generateSmartFetchHint = generateSmartFetchHint;
+const smart_field_fetcher_1 = require("../../utils/smart-field-fetcher");
+class SmartQueryEnhancement {
+    constructor(serviceNowClient) {
+        this.smartFetcher = new smart_field_fetcher_1.SmartFieldFetcher(serviceNowClient);
+    }
+    /**
+     * Enhance snow_query_table to handle large artifacts intelligently
+     */
+    async enhanceQueryTable(originalArgs) {
+        const { table, query, fields, limit } = originalArgs;
+        // Check if this is a single record query with many fields
+        const isSingleRecordQuery = query?.includes('sys_id=') && limit === 1;
+        const hasLargeFields = fields?.some((f) => ['template', 'script', 'client_script', 'css', 'definition', 'data_table'].includes(f));
+        if (isSingleRecordQuery && hasLargeFields) {
+            // Extract sys_id from query
+            const sys_id = query.match(/sys_id=([a-f0-9]{32})/)?.[1];
+            if (sys_id) {
+                console.log(`\n🎯 Detected large artifact query for ${table}. Using smart fetch strategy...`);
+                // Use smart fetcher based on table type
+                let result;
+                let contextMessage = '';
+                switch (table) {
+                    case 'sp_widget':
+                        result = await this.smartFetcher.fetchWidget(sys_id);
+                        contextMessage = this.generateWidgetContextMessage(result);
+                        break;
+                    case 'sys_hub_flow':
+                        result = await this.smartFetcher.fetchFlow(sys_id);
+                        contextMessage = this.generateFlowContextMessage(result);
+                        break;
+                    case 'sys_script':
+                        result = await this.smartFetcher.fetchBusinessRule(sys_id);
+                        contextMessage = this.generateBusinessRuleContextMessage(result);
+                        break;
+                    default:
+                        // Fall back to original query
+                        return this.executeOriginalQuery(originalArgs);
+                }
+                return {
+                    success: true,
+                    result: result,
+                    message: contextMessage,
+                    _meta: {
+                        strategy: 'smart_chunked_fetch',
+                        total_groups: Object.keys(result._field_groups || {}).length,
+                        coherence_hints: result._coherence_hints,
+                        context_preserved: true
+                    }
+                };
+            }
+        }
+        // For non-large queries, use original method
+        return this.executeOriginalQuery(originalArgs);
+    }
+    /**
+     * Generate context message for widget fetch
+     */
+    generateWidgetContextMessage(widget) {
+        const groups = widget._field_groups || {};
+        const fetchedFields = [];
+        const failedFields = [];
+        for (const [groupName, groupData] of Object.entries(groups)) {
+            const data = groupData;
+            if (data._fetched_individually) {
+                for (const [field, status] of Object.entries(data._field_status || {})) {
+                    if (status === 'success') {
+                        fetchedFields.push(field);
+                    }
+                    else {
+                        failedFields.push(field);
+                    }
+                }
+            }
+            else if (data.fields) {
+                fetchedFields.push(...data.fields);
+            }
+        }
+        let message = `
+🧩 **Widget ${widget.name || widget.sys_id} - Smart Fetch Complete**
+
+✅ **Successfully fetched ${fetchedFields.length} fields in chunks to avoid token limits**
+
+📋 **Field Groups Retrieved:**
+${Object.entries(groups).map(([name, data]) => `• **${name}**: ${data.description}`).join('\n')}
+
+🔗 **IMPORTANT Context Relationships:**
+• **Template HTML** (template field) contains:
+  - Angular bindings like {{data.propertyName}} that reference server script data
+  - ng-click directives that call client script methods
+  - CSS classes defined in the css field
+
+• **Server Script** (script field) contains:
+  - ES5-only code that initializes the data object
+  - Handles input.action requests from client script
+  - Sets all data.* properties referenced in template
+
+• **Client Script** (client_script field) contains:
+  - AngularJS controller with \$scope methods
+  - Methods called by template ng-click events
+  - Uses c.server.get({action: 'name'}) to call server script
+
+• **CSS** (css field) contains:
+  - Styles for classes used in template HTML
+
+⚠️ **These fields work together as one cohesive unit!**
+When making changes, ensure:
+1. Every {{data.x}} in template has matching data.x in server script
+2. Every ng-click="method()" in template has matching \$scope.method in client script
+3. Every c.server.get({action: 'x'}) in client has matching if(input.action=='x') in server
+4. CSS classes in template are defined in css field
+`;
+        if (failedFields.length > 0) {
+            message += `\n\n⚠️ **Failed to fetch:** ${failedFields.join(', ')} (too large or restricted)`;
+        }
+        if (widget._coherence_hints?.length > 0) {
+            message += `\n\n🔍 **Detected Coherence Patterns:**\n${widget._coherence_hints.map((h) => `• ${h}`).join('\n')}`;
+        }
+        return message;
+    }
+    /**
+     * Generate context message for flow fetch
+     */
+    generateFlowContextMessage(flow) {
+        return `
+🔄 **Flow ${flow.name || flow.sys_id} - Smart Fetch Complete**
+
+✅ **Successfully fetched flow in chunks**
+
+The 'definition' field contains the complete flow JSON structure with:
+• All steps and their configurations
+• Conditions and triggers
+• Actions and data pills
+• Subflow references
+
+This flow ${flow.active ? 'is ACTIVE' : 'is INACTIVE'} and triggers on: ${flow.trigger_type || 'Unknown'}
+`;
+    }
+    /**
+     * Generate context message for business rule fetch
+     */
+    generateBusinessRuleContextMessage(rule) {
+        return `
+📜 **Business Rule ${rule.name || rule.sys_id} - Smart Fetch Complete**
+
+✅ **Successfully fetched business rule in chunks**
+
+• **Table:** ${rule.collection}
+• **Active:** ${rule.active ? 'Yes' : 'No'}
+• **When:** ${rule.when} 
+• **Order:** ${rule.order}
+
+The 'script' field contains ES5-only code with access to:
+• **current** - The current record being processed
+• **previous** - The previous values (for updates)
+• **gs** - GlideSystem object for server-side APIs
+• **g_scratchpad** - For passing data to client scripts
+`;
+    }
+    /**
+     * Execute original query when smart fetch not needed
+     */
+    async executeOriginalQuery(args) {
+        // This would call the original snow_query_table implementation
+        // For now, return a placeholder
+        return {
+            success: true,
+            result: { message: 'Original query executed' },
+            message: 'Query executed normally without smart chunking'
+        };
+    }
+    /**
+     * Search within specific fields
+     */
+    async searchInFields(args) {
+        const results = await this.smartFetcher.searchInField(args.table, args.field, args.searchTerm, args.additionalQuery);
+        return {
+            success: true,
+            result: results,
+            message: `Found ${results.length} matches for "${args.searchTerm}" in ${args.table}.${args.field}`
+        };
+    }
+}
+exports.SmartQueryEnhancement = SmartQueryEnhancement;
+/**
+ * Helper to detect if a query will likely exceed token limits
+ */
+function willExceedTokenLimit(fields, table) {
+    const LARGE_FIELDS = {
+        'sp_widget': ['template', 'script', 'client_script', 'css', 'data_table'],
+        'sys_hub_flow': ['definition', 'compiled_definition'],
+        'sys_script': ['script', 'condition'],
+        'sys_script_include': ['script'],
+        'sys_ui_page': ['html', 'client_script', 'processing_script']
+    };
+    const tableFields = LARGE_FIELDS[table] || [];
+    const hasMultipleLargeFields = fields.filter(f => tableFields.includes(f)).length >= 2;
+    return hasMultipleLargeFields;
+}
+/**
+ * Generate hint for Claude about using smart fetch
+ */
+function generateSmartFetchHint() {
+    return `
+💡 **Smart Fetch Available for Large Artifacts**
+
+When you encounter "exceeds maximum allowed tokens" errors, I can automatically:
+1. Split the query into intelligent field groups
+2. Fetch each group separately to stay under limits
+3. Maintain full context about field relationships
+4. Provide coherence validation hints
+
+**Supported tables with smart fetch:**
+• sp_widget - Fetches template, scripts, CSS separately but maintains widget coherence
+• sys_hub_flow - Handles large flow definitions
+• sys_script - Manages business rules with large scripts
+• sys_script_include - Script includes with extensive code
+• sys_ui_page - UI pages with HTML, CSS, and scripts
+
+The smart fetch ensures you get ALL necessary data while respecting token limits!
+`;
+}
+//# sourceMappingURL=smart-query-enhancement.js.map

package/dist/mcp/servicenow-local-development-mcp.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ServiceNow Local Development MCP Server
+ *
+ * Bridges ServiceNow artifacts with Claude Code's native file tools
+ * by creating temporary local files that can be edited with full
+ * Claude Code capabilities, then synced back to ServiceNow.
+ *
+ * THIS IS THE KEY TO POWERFUL SERVICENOW DEVELOPMENT!
+ */
+import { BaseMCPServer } from './base-mcp-server';
+export declare class ServiceNowLocalDevelopmentMCP extends BaseMCPServer {
+    private syncManager;
+    constructor();
+    protected initializeTools(): Promise<void>;
+    /**
+     * DYNAMIC pull artifact to local files
+     */
+    private pullArtifact;
+    /**
+     * Push artifact changes back to ServiceNow
+     */
+    private pushArtifact;
+    /**
+     * Get sync status
+     */
+    private getSyncStatus;
+    /**
+     * Cleanup local files
+     */
+    private cleanup;
+    /**
+     * List supported artifact types
+     */
+    private listSupportedArtifacts;
+    /**
+     * Validate artifact coherence
+     */
+    private validateCoherence;
+    /**
+     * Convert modern JS to ES5
+     */
+    private convertToES5;
+    /**
+     * Search in widgets (like Claude Code search)
+     */
+    private searchInWidgets;
+}
+//# sourceMappingURL=servicenow-local-development-mcp.d.ts.map