snow-flow 3.4.39 → 3.5.1

package/dist/utils/mcp-tool-registry.js

@@ -75,6 +75,115 @@ class MCPToolRegistry {
             actualTool: 'mcp__servicenow-deployment__snow_auth_diagnostics',
             description: 'Authentication and permission diagnostics'
         });
+        // Local Development Sync Tools
+        this.registerTool({
+            canonicalName: 'pull_artifact',
+            aliases: [
+                'mcp__servicenow-local-development__snow_pull_artifact',
+                'snow_pull_artifact',
+                'pull_artifact',
+                'sync_artifact',
+                'local_sync'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_pull_artifact',
+            description: 'Pull any ServiceNow artifact to local files for editing'
+        });
+        this.registerTool({
+            canonicalName: 'push_artifact',
+            aliases: [
+                'mcp__servicenow-local-development__snow_push_artifact',
+                'snow_push_artifact',
+                'push_artifact',
+                'sync_back'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_push_artifact',
+            description: 'Push local artifact changes back to ServiceNow'
+        });
+        this.registerTool({
+            canonicalName: 'validate_artifact_coherence',
+            aliases: [
+                'mcp__servicenow-local-development__snow_validate_artifact_coherence',
+                'snow_validate_artifact_coherence',
+                'validate_coherence',
+                'check_coherence'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_validate_artifact_coherence',
+            description: 'Validate artifact coherence and relationships'
+        });
+        this.registerTool({
+            canonicalName: 'list_supported_artifacts',
+            aliases: [
+                'mcp__servicenow-local-development__snow_list_supported_artifacts',
+                'snow_list_supported_artifacts',
+                'supported_artifacts',
+                'artifact_types'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_list_supported_artifacts',
+            description: 'List all supported artifact types for local sync'
+        });
+        this.registerTool({
+            canonicalName: 'sync_status',
+            aliases: [
+                'mcp__servicenow-local-development__snow_sync_status',
+                'snow_sync_status',
+                'local_status',
+                'sync_check'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_sync_status',
+            description: 'Check sync status of local artifacts'
+        });
+        this.registerTool({
+            canonicalName: 'sync_cleanup',
+            aliases: [
+                'mcp__servicenow-local-development__snow_sync_cleanup',
+                'snow_sync_cleanup',
+                'cleanup_local',
+                'remove_local'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_sync_cleanup',
+            description: 'Clean up local artifact files'
+        });
+        this.registerTool({
+            canonicalName: 'convert_to_es5',
+            aliases: [
+                'mcp__servicenow-local-development__snow_convert_to_es5',
+                'snow_convert_to_es5',
+                'es5_convert',
+                'transpile_es5'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_convert_to_es5',
+            description: 'Convert modern JavaScript to ES5 for ServiceNow'
+        });
+        // Legacy widget/script tools (backward compatibility)
+        this.registerTool({
+            canonicalName: 'pull_widget',
+            aliases: [
+                'mcp__servicenow-local-development__snow_pull_widget',
+                'snow_pull_widget',
+                'pull_widget'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_pull_widget',
+            description: 'Pull widget to local files (legacy - use pull_artifact)'
+        });
+        this.registerTool({
+            canonicalName: 'push_widget',
+            aliases: [
+                'mcp__servicenow-local-development__snow_push_widget',
+                'snow_push_widget',
+                'push_widget'
+            ],
+            provider: 'servicenow-local-development',
+            actualTool: 'mcp__servicenow-local-development__snow_push_widget',
+            description: 'Push widget changes (legacy - use push_artifact)'
+        });
         // Catalog item management
         this.registerTool({
             canonicalName: 'catalog_item_manager',

package/dist/utils/smart-field-fetcher.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Smart Field Fetcher for ServiceNow Artifacts
+ *
+ * Intelligently fetches large artifacts by splitting fields into chunks
+ * while maintaining context relationships between fields.
+ */
+import { ServiceNowClient } from './servicenow-client';
+export interface FetchStrategy {
+    table: string;
+    sys_id: string;
+    primaryFields: string[];
+    contentFields: string[];
+    contextHint?: string;
+}
+export interface FieldGroup {
+    groupName: string;
+    fields: string[];
+    description: string;
+    maxTokens?: number;
+}
+export declare class SmartFieldFetcher {
+    private client;
+    constructor(client: ServiceNowClient);
+    /**
+     * DYNAMIC fetch any artifact using registry configuration
+     */
+    fetchArtifact(table: string, sys_id: string): Promise<any>;
+    /**
+     * Intelligently fetch widget fields with context preservation
+     * (Wrapper for backward compatibility)
+     */
+    fetchWidget(sys_id: string): Promise<any>;
+    /**
+     * Fetch flow with intelligent chunking
+     * (Wrapper for backward compatibility)
+     */
+    fetchFlow(sys_id: string): Promise<any>;
+    /**
+     * Fetch business rule with intelligent chunking
+     * (Wrapper for backward compatibility)
+     */
+    fetchBusinessRule(sys_id: string): Promise<any>;
+    /**
+     * Fetch fields one by one when group is too large
+     */
+    private fetchFieldsIndividually;
+    /**
+     * Generate coherence hints for widget validation
+     */
+    private generateCoherenceHints;
+    /**
+     * Search within fields using GlideRecord queries
+     */
+    searchInField(table: string, field: string, searchTerm: string, additionalQuery?: string): Promise<any[]>;
+    /**
+     * Get smart fetch strategy based on table - NOW USES ARTIFACT REGISTRY!
+     */
+    getFieldGroups(table: string): FieldGroup[];
+    /**
+     * Create field groups from artifact registry configuration
+     */
+    private createFieldGroupsFromRegistry;
+}
+/**
+ * Helper function to create fetch strategy hint for Claude
+ */
+export declare function createFetchStrategyHint(table: string, sys_id: string): string;
+//# sourceMappingURL=smart-field-fetcher.d.ts.map

package/dist/utils/smart-field-fetcher.js

@@ -0,0 +1,395 @@
+"use strict";
+/**
+ * Smart Field Fetcher for ServiceNow Artifacts
+ *
+ * Intelligently fetches large artifacts by splitting fields into chunks
+ * while maintaining context relationships between fields.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartFieldFetcher = void 0;
+exports.createFetchStrategyHint = createFetchStrategyHint;
+const artifact_registry_1 = require("./artifact-sync/artifact-registry");
+// Widget field groups with relationship context - 20K per field for better context
+const WIDGET_FIELD_GROUPS = [
+    {
+        groupName: 'metadata',
+        fields: ['sys_id', 'name', 'title', 'id', 'sys_created_on', 'sys_updated_on', 'sys_scope'],
+        description: 'Basic widget identification and metadata',
+        maxTokens: 2000
+    },
+    {
+        groupName: 'template',
+        fields: ['template'],
+        description: 'HTML template - defines UI structure and Angular bindings (ng-click, {{data.x}})',
+        maxTokens: 20000 // Increased to 20K
+    },
+    {
+        groupName: 'server_script',
+        fields: ['script'], // Note: 'script' is the actual field name, not 'server_script'
+        description: 'Server-side script (ES5 only) - initializes data object and handles input.action requests',
+        maxTokens: 20000 // Increased to 20K
+    },
+    {
+        groupName: 'client_script',
+        fields: ['client_script'],
+        description: 'Client-side AngularJS controller - implements methods called by template ng-click and calls c.server.get()',
+        maxTokens: 20000 // Increased to 20K
+    },
+    {
+        groupName: 'styling',
+        fields: ['css'],
+        description: 'Widget-specific CSS styles - classes used in template',
+        maxTokens: 20000 // Increased to 20K
+    },
+    {
+        groupName: 'configuration',
+        fields: ['option_schema', 'data_table', 'demo_data', 'public', 'roles'],
+        description: 'Widget configuration options, data sources and access control',
+        maxTokens: 10000 // Increased for better config context
+    },
+    {
+        groupName: 'dependencies',
+        fields: ['dependencies', 'link'],
+        description: 'Widget dependencies and Angular providers required',
+        maxTokens: 5000
+    }
+];
+// Flow field groups
+const FLOW_FIELD_GROUPS = [
+    {
+        groupName: 'metadata',
+        fields: ['sys_id', 'name', 'label', 'description', 'active'],
+        description: 'Flow identification and basic info',
+        maxTokens: 1000
+    },
+    {
+        groupName: 'definition',
+        fields: ['definition'],
+        description: 'Complete flow definition JSON - contains all steps, actions, and conditions',
+        maxTokens: 20000
+    },
+    {
+        groupName: 'configuration',
+        fields: ['trigger_type', 'trigger_condition', 'run_as'],
+        description: 'Flow trigger and execution configuration',
+        maxTokens: 2000
+    }
+];
+// Business Rule field groups
+const BUSINESS_RULE_FIELD_GROUPS = [
+    {
+        groupName: 'metadata',
+        fields: ['sys_id', 'name', 'collection', 'active', 'order'],
+        description: 'Business rule identification and table',
+        maxTokens: 1000
+    },
+    {
+        groupName: 'conditions',
+        fields: ['when', 'condition', 'filter_condition'],
+        description: 'When rule runs and filter conditions',
+        maxTokens: 2000
+    },
+    {
+        groupName: 'script',
+        fields: ['script'],
+        description: 'Business rule script (ES5) - current, previous, gs available',
+        maxTokens: 10000
+    },
+    {
+        groupName: 'advanced',
+        fields: ['advanced', 'role_conditions', 'abort_action'],
+        description: 'Advanced configuration and actions',
+        maxTokens: 2000
+    }
+];
+class SmartFieldFetcher {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * DYNAMIC fetch any artifact using registry configuration
+     */
+    async fetchArtifact(table, sys_id) {
+        console.log(`\n🔍 Smart fetching ${table}: ${sys_id}`);
+        const fieldGroups = this.getFieldGroups(table);
+        const config = (0, artifact_registry_1.getArtifactConfig)(table);
+        const results = {
+            _fetch_strategy: 'smart_chunked',
+            _context_hint: config ? `${config.displayName} - fields fetched in groups to respect token limits` : 'Fields fetched separately but are related',
+            _field_groups: {}
+        };
+        // Fetch each field group
+        for (const group of fieldGroups) {
+            console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
+            try {
+                const response = await this.client.query(table, {
+                    query: `sys_id=${sys_id}`,
+                    fields: group.fields,
+                    limit: 1
+                });
+                if (response.result?.[0]) {
+                    results._field_groups[group.groupName] = {
+                        data: response.result[0],
+                        description: group.description,
+                        fields: group.fields
+                    };
+                    // Add to flat structure for easy access
+                    Object.assign(results, response.result[0]);
+                }
+            }
+            catch (error) {
+                console.log(`⚠️ Failed to fetch ${group.groupName}: ${error.message}`);
+                // If group fails due to size, fetch fields individually
+                if (error.message?.includes('exceeds maximum allowed tokens')) {
+                    results._field_groups[group.groupName] = await this.fetchFieldsIndividually(table, sys_id, group.fields, group.description);
+                }
+            }
+        }
+        // Add coherence validation hints if it's a widget
+        if (table === 'sp_widget') {
+            results._coherence_hints = this.generateCoherenceHints(results);
+        }
+        return results;
+    }
+    /**
+     * Intelligently fetch widget fields with context preservation
+     * (Wrapper for backward compatibility)
+     */
+    async fetchWidget(sys_id) {
+        return this.fetchArtifact('sp_widget', sys_id);
+        console.log(`\n🔍 Smart fetching widget: ${sys_id}`);
+        const results = {
+            _fetch_strategy: 'smart_chunked',
+            _context_hint: 'Widget fields fetched separately but are interconnected: template references {{data.x}} from server script, calls methods from client script, and uses CSS classes',
+            _field_groups: {}
+        };
+        // Fetch each field group
+        for (const group of WIDGET_FIELD_GROUPS) {
+            console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
+            try {
+                const response = await this.client.query('sp_widget', {
+                    query: `sys_id=${sys_id}`,
+                    fields: group.fields,
+                    limit: 1
+                });
+                if (response.result?.[0]) {
+                    results._field_groups[group.groupName] = {
+                        data: response.result[0],
+                        description: group.description,
+                        fields: group.fields
+                    };
+                    // Add to flat structure for easy access
+                    Object.assign(results, response.result[0]);
+                }
+            }
+            catch (error) {
+                console.log(`⚠️ Failed to fetch ${group.groupName}: ${error.message}`);
+                // If group fails due to size, fetch fields individually
+                if (error.message?.includes('exceeds maximum allowed tokens')) {
+                    results._field_groups[group.groupName] = await this.fetchFieldsIndividually('sp_widget', sys_id, group.fields, group.description);
+                }
+            }
+        }
+        // Add coherence validation hints
+        results._coherence_hints = this.generateCoherenceHints(results);
+        return results;
+    }
+    /**
+     * Fetch flow with intelligent chunking
+     * (Wrapper for backward compatibility)
+     */
+    async fetchFlow(sys_id) {
+        return this.fetchArtifact('sys_hub_flow', sys_id);
+    }
+    /**
+     * Fetch business rule with intelligent chunking
+     * (Wrapper for backward compatibility)
+     */
+    async fetchBusinessRule(sys_id) {
+        return this.fetchArtifact('sys_script', sys_id);
+    }
+    /**
+     * Fetch fields one by one when group is too large
+     */
+    async fetchFieldsIndividually(table, sys_id, fields, groupDescription) {
+        console.log(`  ↪️ Group too large, fetching fields individually...`);
+        const result = {
+            data: {},
+            description: groupDescription,
+            _fetched_individually: true,
+            _field_status: {}
+        };
+        for (const field of fields) {
+            try {
+                console.log(`    📄 Fetching field: ${field}`);
+                const response = await this.client.query(table, {
+                    query: `sys_id=${sys_id}`,
+                    fields: [field],
+                    limit: 1
+                });
+                if (response.result?.[0]) {
+                    result.data[field] = response.result[0][field];
+                    result._field_status[field] = 'success';
+                }
+            }
+            catch (fieldError) {
+                console.log(`      ⚠️ Field ${field} failed: ${fieldError.message}`);
+                result._field_status[field] = 'failed';
+                result.data[field] = `[Error: Field too large or inaccessible]`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate coherence hints for widget validation
+     */
+    generateCoherenceHints(widget) {
+        const hints = [];
+        // Check template references
+        if (widget.template) {
+            const dataRefs = widget.template.match(/\{\{data\.(\w+)\}\}/g) || [];
+            const methodRefs = widget.template.match(/ng-click="(\w+)\(/g) || [];
+            if (dataRefs.length > 0) {
+                hints.push(`Template references data properties: ${dataRefs.join(', ')}`);
+            }
+            if (methodRefs.length > 0) {
+                hints.push(`Template calls methods: ${methodRefs.join(', ')}`);
+            }
+        }
+        // Check server script data initialization
+        if (widget.script) {
+            const dataInits = widget.script.match(/data\.(\w+)\s*=/g) || [];
+            if (dataInits.length > 0) {
+                hints.push(`Server script initializes: ${dataInits.join(', ')}`);
+            }
+        }
+        // Check client script methods
+        if (widget.client_script) {
+            const scopeMethods = widget.client_script.match(/\$scope\.(\w+)\s*=/g) || [];
+            const serverCalls = widget.client_script.match(/c\.server\.get\(\{action:\s*['"](\w+)['"]/g) || [];
+            if (scopeMethods.length > 0) {
+                hints.push(`Client script implements: ${scopeMethods.join(', ')}`);
+            }
+            if (serverCalls.length > 0) {
+                hints.push(`Client calls server actions: ${serverCalls.join(', ')}`);
+            }
+        }
+        return hints;
+    }
+    /**
+     * Search within fields using GlideRecord queries
+     */
+    async searchInField(table, field, searchTerm, additionalQuery) {
+        console.log(`\n🔎 Searching in ${table}.${field} for: ${searchTerm}`);
+        // Use CONTAINS operator for field search
+        const query = `${field}CONTAINS${searchTerm}${additionalQuery ? '^' + additionalQuery : ''}`;
+        try {
+            const response = await this.client.query(table, {
+                query: query,
+                fields: ['sys_id', 'name', field.substring(0, 50)], // Get preview of field
+                limit: 10
+            });
+            console.log(`  ✅ Found ${response.result?.length || 0} matches`);
+            return response.result || [];
+        }
+        catch (error) {
+            console.log(`  ⚠️ Search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Get smart fetch strategy based on table - NOW USES ARTIFACT REGISTRY!
+     */
+    getFieldGroups(table) {
+        // First check if we have specific groups defined
+        switch (table) {
+            case 'sp_widget':
+                return WIDGET_FIELD_GROUPS;
+            case 'sys_hub_flow':
+                return FLOW_FIELD_GROUPS;
+            case 'sys_script':
+                return BUSINESS_RULE_FIELD_GROUPS;
+        }
+        // Try to get from artifact registry
+        const config = (0, artifact_registry_1.getArtifactConfig)(table);
+        if (config) {
+            return this.createFieldGroupsFromRegistry(config);
+        }
+        // Generic strategy for unknown tables
+        return [
+            {
+                groupName: 'metadata',
+                fields: ['sys_id', 'name', 'sys_created_on', 'sys_updated_on'],
+                description: 'Basic record information',
+                maxTokens: 1000
+            },
+            {
+                groupName: 'content',
+                fields: ['*'], // Fetch all other fields
+                description: 'Record content',
+                maxTokens: 20000
+            }
+        ];
+    }
+    /**
+     * Create field groups from artifact registry configuration
+     */
+    createFieldGroupsFromRegistry(config) {
+        const groups = [];
+        // Group 1: Metadata fields
+        const metadataFields = ['sys_id', 'sys_created_on', 'sys_updated_on', config.identifierField];
+        groups.push({
+            groupName: 'metadata',
+            fields: [...new Set(metadataFields)], // Remove duplicates
+            description: `${config.displayName} metadata`,
+            maxTokens: 2000
+        });
+        // Group 2-N: Each field mapping as its own group if large
+        for (const mapping of config.fieldMappings) {
+            if (mapping.maxTokens > 5000) {
+                // Large field gets its own group
+                groups.push({
+                    groupName: mapping.serviceNowField,
+                    fields: [mapping.serviceNowField],
+                    description: mapping.description,
+                    maxTokens: mapping.maxTokens
+                });
+            }
+        }
+        // Group N+1: Small fields together
+        const smallFields = config.fieldMappings
+            .filter(m => m.maxTokens <= 5000)
+            .map(m => m.serviceNowField);
+        if (smallFields.length > 0) {
+            groups.push({
+                groupName: 'configuration',
+                fields: smallFields,
+                description: `${config.displayName} configuration`,
+                maxTokens: 10000
+            });
+        }
+        return groups;
+    }
+}
+exports.SmartFieldFetcher = SmartFieldFetcher;
+/**
+ * Helper function to create fetch strategy hint for Claude
+ */
+function createFetchStrategyHint(table, sys_id) {
+    return `
+🔍 SMART FETCH STRATEGY for ${table} (${sys_id}):
+
+When the artifact is too large (>25000 tokens), I'll fetch fields in intelligent groups:
+1. First fetch metadata (name, title, sys_id)
+2. Then fetch each content field separately (template, script, client_script, css)
+3. Maintain context: These fields work together!
+   - Template HTML references {{data.x}} from server script
+   - Template ng-click calls methods from client script  
+   - CSS classes are used in template
+   - Server script handles input.action from client script
+
+This ensures you get ALL necessary fields while respecting token limits.
+The fields are fetched separately but represent ONE cohesive widget.
+`;
+}
+//# sourceMappingURL=smart-field-fetcher.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.4.39",
-  "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 17 MCP servers for complete ServiceNow operations including widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
+  "version": "3.5.1",
+  "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 18 MCP servers including local development sync for editing ServiceNow artifacts with Claude Code native tools, widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {

package/website/.dockerignore

@@ -0,0 +1,64 @@
+# Docker ignore file for Snow-Flow Website
+
+# Git
+.git
+.gitignore
+
+# Documentation
+README.md
+*.md
+
+# Node modules (if any)
+node_modules
+npm-debug.log*
+
+# Build artifacts
+.DS_Store
+Thumbs.db
+
+# Editor files
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Dependency directories
+node_modules/
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Docker files (except the one we need)
+Dockerfile.*
+!Dockerfile
+
+# Cloud Build
+cloudbuild.yaml
+
+# Environment files
+.env
+.env.local
+.env.production
+
+# Temporary files
+tmp/
+temp/

package/website/Dockerfile

@@ -0,0 +1,36 @@
+# Snow-Flow Website - Production Docker Image
+FROM nginx:alpine
+
+# Install security updates
+RUN apk update && apk upgrade
+
+# Remove default nginx website
+RUN rm -rf /usr/share/nginx/html/*
+
+# Copy website files
+COPY . /usr/share/nginx/html/
+
+# Copy custom nginx configuration
+COPY nginx.conf /etc/nginx/nginx.conf
+
+# Create directory for logs
+RUN mkdir -p /var/log/nginx
+
+# Set proper permissions
+RUN chown -R nginx:nginx /usr/share/nginx/html && \
+    chmod -R 755 /usr/share/nginx/html
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost/ || exit 1
+
+# Expose port 80
+EXPOSE 80
+
+# Add metadata
+LABEL maintainer="Snow-Flow Team" \
+      description="Snow-Flow Documentation Website" \
+      version="3.4.39"
+
+# Start nginx
+CMD ["nginx", "-g", "daemon off;"]