snow-flow 4.1.2 → 4.2.1

package/dist/utils/chunking-manager.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Chunking Manager for Large ServiceNow Artifacts
+ * Handles scripts >30k characters that exceed API token limits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkingManager = void 0;
+class ChunkingManager {
+    /**
+     * Determine if script needs chunking
+     */
+    static needsChunking(script, maxSize = 5000000) {
+        // 5MB = ServiceNow's actual response limit
+        return script.length > maxSize;
+    }
+    /**
+     * Split large script into manageable chunks
+     */
+    static chunkScript(script, strategy = {
+        maxChunkSize: 2500000, // 2.5MB chunks
+        overlapSize: 500,
+        chunkType: 'functions'
+    }) {
+        const lines = script.split('\n');
+        const chunks = [];
+        if (!this.needsChunking(script)) {
+            return [{
+                    index: 0,
+                    content: script,
+                    startLine: 1,
+                    endLine: lines.length,
+                    type: 'complete',
+                    hasContext: true
+                }];
+        }
+        let currentChunk = '';
+        let currentStartLine = 1;
+        let chunkIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const potentialChunk = currentChunk + line + '\n';
+            if (potentialChunk.length > strategy.maxChunkSize) {
+                // Current chunk is full, save it
+                if (currentChunk.trim()) {
+                    chunks.push({
+                        index: chunkIndex++,
+                        content: currentChunk.trim(),
+                        startLine: currentStartLine,
+                        endLine: i,
+                        type: chunkIndex === 0 ? 'partial_start' : 'partial_middle',
+                        hasContext: true
+                    });
+                }
+                // Start new chunk with overlap
+                const overlapLines = Math.min(Math.floor(strategy.overlapSize / 50), // Assume ~50 chars per line
+                10 // Max 10 lines overlap
+                );
+                const overlapStart = Math.max(0, i - overlapLines);
+                currentChunk = lines.slice(overlapStart, i + 1).join('\n') + '\n';
+                currentStartLine = overlapStart + 1;
+            }
+            else {
+                currentChunk += line + '\n';
+            }
+        }
+        // Add final chunk
+        if (currentChunk.trim()) {
+            chunks.push({
+                index: chunkIndex,
+                content: currentChunk.trim(),
+                startLine: currentStartLine,
+                endLine: lines.length,
+                type: 'partial_end',
+                hasContext: true
+            });
+        }
+        return chunks;
+    }
+    /**
+     * Generate instructions for manual large script handling
+     */
+    static generateManualInstructions(scriptName, scriptSize, chunks) {
+        return `
+🚨 LARGE SCRIPT DETECTED: ${scriptName} (${scriptSize.toLocaleString()} characters)
+
+⚠️ This script exceeds API token limits and cannot be updated automatically.
+
+🔧 MANUAL UPDATE REQUIRED:
+
+1. **Navigate to ServiceNow**:
+   - Go to Service Portal → Widgets
+   - Find and edit your widget
+   - Click on "Server Script" tab
+
+2. **Copy the updated script**:
+   - Script has been split into ${chunks.length} chunks below
+   - Copy ALL chunks in order and paste into ServiceNow
+
+3. **Chunks to copy**:
+${chunks.map(chunk => `
+   **Chunk ${chunk.index + 1}/${chunks.length}** (Lines ${chunk.startLine}-${chunk.endLine}):
+   \`\`\`javascript
+   ${chunk.content.substring(0, 500)}${chunk.content.length > 500 ? '...\n[truncated for display]' : ''}
+   \`\`\`
+`).join('')}
+
+4. **Validation**:
+   - Ensure no syntax errors after pasting
+   - Test widget functionality
+   - Consider breaking into smaller Script Includes
+
+💡 **Prevention for future**:
+- Keep server scripts under 30,000 characters
+- Use Script Includes for reusable functions
+- Move complex logic to business rules where appropriate
+`;
+    }
+    /**
+     * Attempt smart chunked update for large scripts
+     */
+    static async attemptChunkedUpdate(client, table, sys_id, field, script) {
+        if (!this.needsChunking(script)) {
+            // Not chunked, do normal update
+            try {
+                await client.updateRecord(table, sys_id, { [field]: script });
+                return { success: true, message: 'Script updated successfully' };
+            }
+            catch (error) {
+                return { success: false, message: `Update failed: ${error}` };
+            }
+        }
+        // For large scripts, we can't actually chunk the API call
+        // But we can provide intelligent guidance
+        const chunks = this.chunkScript(script);
+        const instructions = this.generateManualInstructions(field, script.length, chunks);
+        return {
+            success: false,
+            message: `Script too large for automatic update. Manual steps required:\n${instructions}`
+        };
+    }
+}
+exports.ChunkingManager = ChunkingManager;
+//# sourceMappingURL=chunking-manager.js.map

package/dist/utils/memory-pool.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Memory Pool Manager
+ * Optimizes Map/Set allocations and reuses objects for better memory efficiency
+ */
+export declare class MemoryPoolManager {
+    private static mapPool;
+    private static setPool;
+    private static objectPool;
+    private static readonly MAX_POOL_SIZE;
+    /**
+     * Get a reusable Map instance
+     */
+    static getMap<K, V>(): Map<K, V>;
+    /**
+     * Return a Map to the pool for reuse
+     */
+    static releaseMap(map: Map<any, any>): void;
+    /**
+     * Get a reusable Set instance
+     */
+    static getSet<T>(): Set<T>;
+    /**
+     * Return a Set to the pool for reuse
+     */
+    static releaseSet(set: Set<any>): void;
+    /**
+     * Get a reusable object
+     */
+    static getObject(): any;
+    /**
+     * Return an object to the pool
+     */
+    static releaseObject(obj: any): void;
+    /**
+     * Get pool statistics for monitoring
+     */
+    static getStats(): {
+        maps: {
+            available: number;
+            maxSize: number;
+        };
+        sets: {
+            available: number;
+            maxSize: number;
+        };
+        objects: {
+            available: number;
+            maxSize: number;
+        };
+    };
+    /**
+     * Clear all pools (for testing/cleanup)
+     */
+    static clearPools(): void;
+}
+//# sourceMappingURL=memory-pool.d.ts.map

package/dist/utils/memory-pool.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Memory Pool Manager
+ * Optimizes Map/Set allocations and reuses objects for better memory efficiency
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryPoolManager = void 0;
+class MemoryPoolManager {
+    /**
+     * Get a reusable Map instance
+     */
+    static getMap() {
+        if (this.mapPool.length > 0) {
+            const map = this.mapPool.pop();
+            map.clear(); // Ensure it's clean
+            return map;
+        }
+        return new Map();
+    }
+    /**
+     * Return a Map to the pool for reuse
+     */
+    static releaseMap(map) {
+        if (this.mapPool.length < this.MAX_POOL_SIZE) {
+            map.clear();
+            this.mapPool.push(map);
+        }
+    }
+    /**
+     * Get a reusable Set instance
+     */
+    static getSet() {
+        if (this.setPool.length > 0) {
+            const set = this.setPool.pop();
+            set.clear(); // Ensure it's clean
+            return set;
+        }
+        return new Set();
+    }
+    /**
+     * Return a Set to the pool for reuse
+     */
+    static releaseSet(set) {
+        if (this.setPool.length < this.MAX_POOL_SIZE) {
+            set.clear();
+            this.setPool.push(set);
+        }
+    }
+    /**
+     * Get a reusable object
+     */
+    static getObject() {
+        if (this.objectPool.length > 0) {
+            return this.objectPool.pop();
+        }
+        return {};
+    }
+    /**
+     * Return an object to the pool
+     */
+    static releaseObject(obj) {
+        if (this.objectPool.length < this.MAX_POOL_SIZE) {
+            // Clear all properties
+            for (const key in obj) {
+                delete obj[key];
+            }
+            this.objectPool.push(obj);
+        }
+    }
+    /**
+     * Get pool statistics for monitoring
+     */
+    static getStats() {
+        return {
+            maps: {
+                available: this.mapPool.length,
+                maxSize: this.MAX_POOL_SIZE
+            },
+            sets: {
+                available: this.setPool.length,
+                maxSize: this.MAX_POOL_SIZE
+            },
+            objects: {
+                available: this.objectPool.length,
+                maxSize: this.MAX_POOL_SIZE
+            }
+        };
+    }
+    /**
+     * Clear all pools (for testing/cleanup)
+     */
+    static clearPools() {
+        this.mapPool.length = 0;
+        this.setPool.length = 0;
+        this.objectPool.length = 0;
+    }
+}
+exports.MemoryPoolManager = MemoryPoolManager;
+MemoryPoolManager.mapPool = [];
+MemoryPoolManager.setPool = [];
+MemoryPoolManager.objectPool = [];
+MemoryPoolManager.MAX_POOL_SIZE = 50;
+//# sourceMappingURL=memory-pool.js.map

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

@@ -22,25 +22,25 @@ const WIDGET_FIELD_GROUPS = [
         groupName: 'template',
         fields: ['template'],
         description: 'HTML template - defines UI structure and Angular bindings (ng-click, {{data.x}})',
-        maxTokens: 20000 // Increased to 20K
+        maxTokens: 200000 // Claude's full context window
     },
     {
         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
+        maxTokens: 200000 // Claude's full context window
     },
     {
         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
+        maxTokens: 200000 // Claude's full context window
     },
     {
         groupName: 'styling',
         fields: ['css'],
         description: 'Widget-specific CSS styles - classes used in template',
-        maxTokens: 20000 // Increased to 20K
+        maxTokens: 200000 // Claude's full context window
     },
     {
         groupName: 'configuration',
@@ -130,8 +130,8 @@ class SmartFieldFetcher {
                         description: group.description,
                         fields: group.fields
                     };
-                    // Add to flat structure for easy access
-                    Object.assign(results, response.result[0]);
+                    // FIX: getRecord returns direct object, not response.result[0]
+                    Object.assign(results, response);
                 }
             }
             catch (error) {
@@ -232,8 +232,9 @@ class SmartFieldFetcher {
                     // Try using getRecord instead of searchRecords with short timeout
                     const directResponse = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.getRecord('sp_widget', sys_id), 5000, // 5 second timeout for direct fetch
                     `Direct widget fetch ${sys_id}`);
-                    if (directResponse && directResponse.success && directResponse.data && directResponse.data.result) {
-                        const directData = directResponse.data.result;
+                    if (directResponse) {
+                        // FIX: getRecord returns direct object, not nested structure
+                        const directData = directResponse;
                         // Merge any new data we got
                         Object.assign(results, directData);
                         console.log(`📊 Direct API retrieved:`);
@@ -292,6 +293,7 @@ class SmartFieldFetcher {
                 console.log(`    📄 Fetching field: ${field}`);
                 const response = await this.client.getRecord(table, sys_id);
                 if (response) {
+                    // FIX: getRecord returns direct object
                     result.data[field] = response[field];
                     result._field_status[field] = 'success';
                 }
@@ -503,7 +505,7 @@ 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:
+When the artifact is too large (>200000 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!

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "snow-flow",
-  "version": "4.1.2",
-  "description": "ENTERPRISE SCALE - v4.1.0 removes ALL artificial limits! Built on stable v3.6.25 with enterprise-grade support for massive widgets (5MB+ scripts), 200k token fields, and 100k record queries.",
+  "version": "4.2.1",
+  "description": "ENTERPRISE OPTIMIZED - v4.2.1 perfect mobile experience + complete website redesign. Beautiful hero, mobile-optimized, comprehensive MCP reference, and 355+ tools. Professional enterprise presentation.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {
     "snow-flow": "bin/snow-flow"
   },
   "scripts": {
-    "build": "tsc || true",
+    "build": "tsc --noEmitOnError false || true",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "jest",

package/website/Dockerfile

@@ -29,8 +29,9 @@ EXPOSE 80
 
 # Add metadata
 LABEL maintainer="Snow-Flow Team" \
-      description="Snow-Flow Documentation Website" \
-      version="3.4.39"
+      description="Snow-Flow Enterprise Website v4.2.0" \
+      version="4.2.0" \
+      features="23 MCP Servers, 355+ Tools, ITAM, SecOps, Notifications"
 
 # Start nginx
 CMD ["nginx", "-g", "daemon off;"]

package/website/cloudbuild.yaml

@@ -1,15 +1,16 @@
 # Snow-Flow Website - Google Cloud Build Configuration
 steps:
-  # Build the Docker image
+  # Build the Docker image (FIXED PATH)
   - name: 'gcr.io/cloud-builders/docker'
     args: [
       'build',
       '-t', 'gcr.io/$PROJECT_ID/snow-flow-website:$COMMIT_SHA',
       '-t', 'gcr.io/$PROJECT_ID/snow-flow-website:latest',
       '--cache-from', 'gcr.io/$PROJECT_ID/snow-flow-website:latest',
-      '.'
+      '-f', 'website/Dockerfile',  # Specify Dockerfile location from root
+      'website/'  # Build context is website directory
     ]
-    dir: 'website'
+    # Remove dir: 'website' to run from root
 
   # Push the Docker image to Container Registry
   - name: 'gcr.io/cloud-builders/docker'