snow-flow 4.0.0 → 4.0.2

package/dist/session/store.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionId = createSessionId;
+exports.startSession = startSession;
+exports.readSession = readSession;
+exports.listSessions = listSessions;
+exports.appendMessage = appendMessage;
+exports.appendToolEvent = appendToolEvent;
+exports.endSession = endSession;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function sessionsDir() {
+    const dir = path_1.default.join(os_1.default.homedir(), '.snow-flow', 'sessions');
+    ensureDir(dir);
+    return dir;
+}
+function createSessionId() {
+    return `sess_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function sessionPath(id) {
+    return path_1.default.join(sessionsDir(), `${id}.json`);
+}
+function startSession(rec) {
+    const full = { ...rec, messages: rec.messages ?? [], toolEvents: [] };
+    fs_1.default.writeFileSync(sessionPath(rec.id), JSON.stringify(full, null, 2), 'utf8');
+    return full;
+}
+function readSession(id) {
+    const p = sessionPath(id);
+    if (!fs_1.default.existsSync(p))
+        return undefined;
+    return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+}
+function listSessions() {
+    const dir = sessionsDir();
+    const files = fs_1.default.readdirSync(dir).filter(f => f.endsWith('.json'));
+    return files.map(f => {
+        const rec = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, f), 'utf8'));
+        return { id: rec.id, startedAt: rec.startedAt, objective: rec.objective };
+    }).sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+}
+function appendMessage(id, msg) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    rec.messages.push(msg);
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+function appendToolEvent(id, ev) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    const item = { name: ev.name, when: new Date().toISOString(), argsPreview: ev.argsPreview, resultPreview: ev.resultPreview };
+    (rec.toolEvents = rec.toolEvents || []).push(item);
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+function endSession(id, summary) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    rec.endedAt = new Date().toISOString();
+    if (summary)
+        rec.summary = summary;
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+//# sourceMappingURL=store.js.map

package/dist/snow-flow-system.js

@@ -11,7 +11,6 @@ exports.snowFlowSystem = exports.SnowFlowSystem = void 0;
 const events_1 = require("events");
 const snow_flow_config_1 = require("./config/snow-flow-config");
 const servicenow_queen_1 = require("./queen/servicenow-queen");
-const memory_system_1 = require("./memory/memory-system");
 const mcp_server_manager_1 = require("./utils/mcp-server-manager");
 const performance_tracker_1 = require("./monitoring/performance-tracker");
 const system_health_1 = require("./health/system-health");

package/dist/testing/integration-test-suite.js

@@ -10,7 +10,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntegrationTestSuite = void 0;
 const logger_js_1 = require("../utils/logger.js");
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const memory_system_js_1 = require("../memory/memory-system.js");
 class IntegrationTestSuite {
     constructor() {
         // Flow-related systems removed in v1.4.0

package/dist/utils/artifact-local-sync.js

@@ -47,6 +47,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const smart_field_fetcher_js_1 = require("./smart-field-fetcher.js");
 const mcp_timeout_config_js_1 = require("./mcp-timeout-config.js");
+const chunking_manager_js_1 = require("./chunking-manager.js");
 const artifact_registry_1 = require("./artifact-sync/artifact-registry");
 class ArtifactLocalSync {
     constructor(client, customBaseDir) {
@@ -285,6 +286,22 @@ class ArtifactLocalSync {
                     }
                     // Map back to ServiceNow field
                     if (file.field && file.field !== 'documentation' && file.field !== 'metadata') {
+                        // Check if field needs chunking (large server scripts)
+                        if (chunking_manager_js_1.ChunkingManager.needsChunking(processedContent)) {
+                            console.log(`   ⚠️ Large field detected: ${file.field} (${processedContent.length} chars)`);
+                            // Attempt chunked update
+                            const chunkResult = await chunking_manager_js_1.ChunkingManager.attemptChunkedUpdate(this.client, config.tableName, sys_id, file.field, processedContent);
+                            if (!chunkResult.success) {
+                                // Add to validation results as a manual instruction
+                                validationResults.push({
+                                    valid: false,
+                                    errors: [],
+                                    warnings: [`Large ${file.field} requires manual update`],
+                                    hints: [chunkResult.message]
+                                });
+                                continue; // Skip adding to updates
+                            }
+                        }
                         updates[file.field] = processedContent;
                         console.log(`   📝 Changed: ${file.filename} (${file.field})`);
                         // Validate ES5 if required

package/dist/utils/chunking-manager.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Chunking Manager for Large ServiceNow Artifacts
+ * Handles scripts >30k characters that exceed API token limits
+ */
+export interface ChunkingStrategy {
+    maxChunkSize: number;
+    overlapSize: number;
+    chunkType: 'lines' | 'functions' | 'blocks';
+}
+export interface ScriptChunk {
+    index: number;
+    content: string;
+    startLine: number;
+    endLine: number;
+    type: 'complete' | 'partial_start' | 'partial_middle' | 'partial_end';
+    hasContext: boolean;
+}
+export declare class ChunkingManager {
+    /**
+     * Determine if script needs chunking
+     */
+    static needsChunking(script: string, maxSize?: number): boolean;
+    /**
+     * Split large script into manageable chunks
+     */
+    static chunkScript(script: string, strategy?: ChunkingStrategy): ScriptChunk[];
+    /**
+     * Generate instructions for manual large script handling
+     */
+    static generateManualInstructions(scriptName: string, scriptSize: number, chunks: ScriptChunk[]): string;
+    /**
+     * Attempt smart chunked update for large scripts
+     */
+    static attemptChunkedUpdate(client: any, table: string, sys_id: string, field: string, script: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=chunking-manager.d.ts.map

package/dist/utils/chunking-manager.js

@@ -0,0 +1,142 @@
+"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 = 30000) {
+        return script.length > maxSize;
+    }
+    /**
+     * Split large script into manageable chunks
+     */
+    static chunkScript(script, strategy = {
+        maxChunkSize: 25000,
+        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/smart-field-fetcher.js

@@ -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';
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "KNOWLEDGE BASE VERIFICATION - v3.6.25 adds critical validation to snow_create_knowledge_article. Now throws error when non-existent knowledge base is specified, preventing orphaned articles. Includes helpful suggestions to create or discover valid knowledge bases.",
   "main": "dist/index.js",
   "type": "commonjs",