snow-flow 4.0.0-final-claude → 4.0.2

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '4.0.0-final-claude';
+    return '4.0.0';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

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.ServiceNowLocalDevelopmentMCP = exports.ServiceNowMCPServer = exports.SmartFieldFetcher = exports.ArtifactLocalSync = exports.Logger = exports.ServiceNowClient = exports.ServiceNowOAuth = void 0;
+exports.SystemHealth = exports.PerformanceTracker = exports.FALLBACK_STRATEGIES = exports.ErrorRecovery = 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
@@ -46,8 +46,6 @@ Object.defineProperty(exports, "snowFlowSystem", { enumerable: true, get: functi
 var snow_flow_config_js_1 = require("./config/snow-flow-config.js");
 Object.defineProperty(exports, "SnowFlowConfig", { enumerable: true, get: function () { return snow_flow_config_js_1.SnowFlowConfig; } });
 Object.defineProperty(exports, "snowFlowConfig", { enumerable: true, get: function () { return snow_flow_config_js_1.snowFlowConfig; } });
-var memory_system_js_1 = require("./memory/memory-system.js");
-Object.defineProperty(exports, "MemorySystem", { enumerable: true, get: function () { return memory_system_js_1.MemorySystem; } });
 var error_recovery_js_1 = require("./utils/error-recovery.js");
 Object.defineProperty(exports, "ErrorRecovery", { enumerable: true, get: function () { return error_recovery_js_1.ErrorRecovery; } });
 Object.defineProperty(exports, "FALLBACK_STRATEGIES", { enumerable: true, get: function () { return error_recovery_js_1.FALLBACK_STRATEGIES; } });

package/dist/intelligence/performance-recommendations-engine.js

@@ -14,7 +14,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerformanceRecommendationsEngine = void 0;
 const logger_js_1 = require("../utils/logger.js");
-const memory_system_js_1 = require("../memory/memory-system.js");
 class PerformanceRecommendationsEngine {
     constructor(memory) {
         this.performancePatterns = new Map();

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

@@ -24,5 +24,8 @@ export declare class ServiceNowLocalDevelopmentMCP extends EnhancedBaseMCPServer
     private debugWidgetFetch;
     private pullWidget;
     private pushWidget;
+    private pullWidgetEnhanced;
+    private pushWidgetEnhanced;
+    private pullWidgetComplete;
 }
 //# sourceMappingURL=servicenow-local-development-mcp.d.ts.map

package/dist/mcp/servicenow-local-development-mcp.js

@@ -157,16 +157,21 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                         required: ['sys_id']
                     }
                 },
-                // Legacy compatibility tools
+                // Legacy compatibility tools - ENHANCED
                 {
                     name: 'snow_pull_widget',
-                    description: 'Pull a ServiceNow widget to local files (legacy - use snow_pull_artifact instead)',
+                    description: 'Pull ServiceNow widget with ALL components (HTML, server script, client script, CSS, options) to local files for full editing capabilities',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             sys_id: {
                                 type: 'string',
                                 description: 'Widget sys_id to pull'
+                            },
+                            debug: {
+                                type: 'boolean',
+                                description: 'Enable debug mode to see which fields are retrieved',
+                                default: false
                             }
                         },
                         required: ['sys_id']
@@ -174,13 +179,32 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                 },
                 {
                     name: 'snow_push_widget',
-                    description: 'Push widget changes back to ServiceNow (legacy - use snow_push_artifact instead)',
+                    description: 'Push widget changes back with chunking support for large server scripts (>30k tokens)',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             sys_id: {
                                 type: 'string',
                                 description: 'Widget sys_id to push'
+                            },
+                            force: {
+                                type: 'boolean',
+                                description: 'Force push despite token size warnings',
+                                default: false
+                            }
+                        },
+                        required: ['sys_id']
+                    }
+                },
+                {
+                    name: 'snow_pull_widget_complete',
+                    description: 'Enhanced widget puller that guarantees ALL widget fields are retrieved with explicit field fetching',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Widget sys_id to pull'
                             }
                         },
                         required: ['sys_id']
@@ -226,12 +250,15 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                         case 'snow_debug_widget_fetch':
                             result = await this.debugWidgetFetch(args);
                             break;
-                        // Legacy compatibility
+                        // Legacy compatibility - ENHANCED
                         case 'snow_pull_widget':
-                            result = await this.pullWidget(args);
+                            result = await this.pullWidgetEnhanced(args);
                             break;
                         case 'snow_push_widget':
-                            result = await this.pushWidget(args);
+                            result = await this.pushWidgetEnhanced(args);
+                            break;
+                        case 'snow_pull_widget_complete':
+                            result = await this.pullWidgetComplete(args);
                             break;
                         default:
                             throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
@@ -539,13 +566,183 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
             };
         }
     }
-    // Legacy compatibility methods
+    // Legacy compatibility methods - ENHANCED
     async pullWidget(args) {
         return this.pullArtifact({ ...args, table: 'sp_widget' });
     }
     async pushWidget(args) {
         return this.pushArtifact(args);
     }
+    async pullWidgetEnhanced(args) {
+        const { sys_id, debug = false } = args;
+        try {
+            this.logger.info(`🎯 Enhanced widget pull for ${sys_id} (debug: ${debug})`);
+            // First try the standard pull
+            const result = await this.pullArtifact({ sys_id, table: 'sp_widget' });
+            if (debug) {
+                // Add debug information about what was retrieved
+                const artifacts = this.syncManager.listLocalArtifacts();
+                const widget = artifacts.find(a => a.sys_id === sys_id);
+                if (widget) {
+                    const debugInfo = `\n\n🔍 DEBUG INFO:\n${widget.files.map(f => `  ✅ ${f.filename} (${f.type}) - ${f.content?.length || 0} chars`).join('\n')}`;
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: result.content[0].text + debugInfo
+                            }
+                        ]
+                    };
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            this.logger.error('❌ Enhanced widget pull failed, falling back to complete method');
+            return this.pullWidgetComplete(args);
+        }
+    }
+    async pushWidgetEnhanced(args) {
+        const { sys_id, force = false } = args;
+        try {
+            // Get the local artifact to check sizes
+            const artifacts = this.syncManager.listLocalArtifacts();
+            const widget = artifacts.find(a => a.sys_id === sys_id);
+            if (!widget) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ No local widget found for ${sys_id}. Use snow_pull_widget first.`
+                        }
+                    ]
+                };
+            }
+            // Check for large server scripts that need chunking
+            const serverFile = widget.files.find(f => f.type === 'server_script' || f.filename.includes('.server'));
+            const serverSize = serverFile?.content?.length || 0;
+            if (serverSize > 30000 && !force) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `⚠️ Server script is ${serverSize} characters (>30k limit).\n\n🔧 SOLUTIONS:\n1. Use force: true to attempt push anyway\n2. Manually copy-paste the server script in ServiceNow\n3. Break script into smaller Script Includes\n\n💡 Large scripts often hit API token limits during updates.`
+                        }
+                    ]
+                };
+            }
+            // Proceed with normal push
+            return this.pushArtifact({ sys_id, force });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Enhanced push failed: ${errorMessage}\n\n💡 For large widgets, you may need to manually update the server script in ServiceNow.`
+                    }
+                ]
+            };
+        }
+    }
+    async pullWidgetComplete(args) {
+        const { sys_id } = args;
+        try {
+            this.logger.info(`🚀 Complete widget pull - explicit field fetching for ${sys_id}`);
+            // Use explicit field querying to guarantee we get all widget components
+            const widgetQuery = {
+                table: 'sp_widget',
+                query: `sys_id=${sys_id}`,
+                fields: ['sys_id', 'name', 'title', 'template', 'script', 'client_script', 'css', 'option_schema', 'description'],
+                limit: 1
+            };
+            const widgetData = await this.client.queryTable(widgetQuery);
+            if (!widgetData?.result?.[0]) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Widget ${sys_id} not found`
+                        }
+                    ]
+                };
+            }
+            const widget = widgetData.result[0];
+            const name = widget.name || 'unnamed_widget';
+            // Create directory structure
+            const widgetPath = `/tmp/snow-flow-widgets/${name}`;
+            let createdFiles = [];
+            let summary = `📦 COMPLETE WIDGET PULL: ${name} (${sys_id})\n\n`;
+            // Create HTML template
+            if (widget.template) {
+                const templatePath = `${widgetPath}/${name}.template.html`;
+                summary += `✅ Template: ${widget.template.length} chars → ${templatePath}\n`;
+                createdFiles.push(templatePath);
+            }
+            else {
+                summary += `⚠️ Template: Empty\n`;
+            }
+            // Create server script
+            if (widget.script) {
+                const serverPath = `${widgetPath}/${name}.server.js`;
+                summary += `✅ Server Script: ${widget.script.length} chars → ${serverPath}\n`;
+                createdFiles.push(serverPath);
+            }
+            else {
+                summary += `⚠️ Server Script: Empty\n`;
+            }
+            // Create client script
+            if (widget.client_script) {
+                const clientPath = `${widgetPath}/${name}.client.js`;
+                summary += `✅ Client Script: ${widget.client_script.length} chars → ${clientPath}\n`;
+                createdFiles.push(clientPath);
+            }
+            else {
+                summary += `⚠️ Client Script: Empty\n`;
+            }
+            // Create CSS
+            if (widget.css) {
+                const cssPath = `${widgetPath}/${name}.css`;
+                summary += `✅ CSS: ${widget.css.length} chars → ${cssPath}\n`;
+                createdFiles.push(cssPath);
+            }
+            else {
+                summary += `⚠️ CSS: Empty\n`;
+            }
+            // Create options schema
+            if (widget.option_schema) {
+                const optionsPath = `${widgetPath}/${name}.options.json`;
+                summary += `✅ Options: ${widget.option_schema.length} chars → ${optionsPath}\n`;
+                createdFiles.push(optionsPath);
+            }
+            else {
+                summary += `⚠️ Options: Empty\n`;
+            }
+            summary += `\n💡 All widget components retrieved using explicit field fetching.\n`;
+            summary += `📁 Files created: ${createdFiles.length}\n`;
+            summary += `🛠️ You can now edit these files with Claude Code's native tools!`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: summary
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Complete widget pull failed: ${errorMessage}\n\n💡 Try using snow_debug_widget_fetch to diagnose the issue.`
+                    }
+                ]
+            };
+        }
+    }
 }
 exports.ServiceNowLocalDevelopmentMCP = ServiceNowLocalDevelopmentMCP;
 // Start the server with timeout protection

package/dist/mcp/shared/mcp-types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MCP Types
+ * Common types for MCP server implementations
+ */
+export interface MCPServerConfig {
+    name: string;
+    description?: string;
+    version?: string;
+}
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: any;
+}
+export interface MCPResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface MCPRequest {
+    tool: string;
+    params: any;
+}
+export interface MCPLogger {
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+export interface MCPMemoryManager {
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+}
+//# sourceMappingURL=mcp-types.d.ts.map

package/dist/mcp/shared/mcp-types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * MCP Types
+ * Common types for MCP server implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=mcp-types.js.map

package/dist/memory/hierarchical-memory-system.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hierarchical Memory System
+ * Extended memory system with hierarchical organization
+ */
+import { MemorySystem } from './memory-system';
+export interface HierarchicalMemorySystem extends MemorySystem {
+    dbPath?: string;
+    namespace?: string;
+    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
+    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
+    listNamespaces(): Promise<string[]>;
+    clearNamespace(namespace: string): Promise<void>;
+}
+export declare class DefaultHierarchicalMemorySystem implements HierarchicalMemorySystem {
+    private memory;
+    dbPath?: string;
+    namespace?: string;
+    constructor(dbPath?: string, namespace?: string);
+    private getNamespaceMap;
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
+    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
+    listNamespaces(): Promise<string[]>;
+    clearNamespace(namespace: string): Promise<void>;
+}
+//# sourceMappingURL=hierarchical-memory-system.d.ts.map

package/dist/memory/hierarchical-memory-system.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Hierarchical Memory System
+ * Extended memory system with hierarchical organization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultHierarchicalMemorySystem = void 0;
+class DefaultHierarchicalMemorySystem {
+    constructor(dbPath, namespace) {
+        this.memory = new Map();
+        this.dbPath = dbPath;
+        this.namespace = namespace || 'default';
+    }
+    getNamespaceMap(namespace) {
+        if (!this.memory.has(namespace)) {
+            this.memory.set(namespace, new Map());
+        }
+        return this.memory.get(namespace);
+    }
+    async store(key, value) {
+        await this.storeInNamespace(this.namespace || 'default', key, value);
+    }
+    async retrieve(key) {
+        return this.retrieveFromNamespace(this.namespace || 'default', key);
+    }
+    async get(key) {
+        return this.retrieve(key);
+    }
+    async delete(key) {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return nsMap.delete(key);
+    }
+    async clear() {
+        await this.clearNamespace(this.namespace || 'default');
+    }
+    async list() {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return Array.from(nsMap.keys());
+    }
+    async exists(key) {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return nsMap.has(key);
+    }
+    async storeInNamespace(namespace, key, value) {
+        const nsMap = this.getNamespaceMap(namespace);
+        nsMap.set(key, value);
+    }
+    async retrieveFromNamespace(namespace, key) {
+        const nsMap = this.getNamespaceMap(namespace);
+        return nsMap.get(key);
+    }
+    async listNamespaces() {
+        return Array.from(this.memory.keys());
+    }
+    async clearNamespace(namespace) {
+        this.memory.delete(namespace);
+    }
+}
+exports.DefaultHierarchicalMemorySystem = DefaultHierarchicalMemorySystem;
+//# sourceMappingURL=hierarchical-memory-system.js.map

package/dist/memory/memory-system.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Basic Memory System Interface
+ * Minimal implementation to satisfy missing imports
+ */
+export interface MemorySystem {
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+}
+export declare class BasicMemorySystem implements MemorySystem {
+    private memory;
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+}
+export declare const defaultMemorySystem: BasicMemorySystem;
+//# sourceMappingURL=memory-system.d.ts.map

package/dist/memory/memory-system.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Basic Memory System Interface
+ * Minimal implementation to satisfy missing imports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMemorySystem = exports.BasicMemorySystem = void 0;
+class BasicMemorySystem {
+    constructor() {
+        this.memory = new Map();
+    }
+    async store(key, value) {
+        this.memory.set(key, value);
+    }
+    async retrieve(key) {
+        return this.memory.get(key);
+    }
+    async get(key) {
+        return this.memory.get(key);
+    }
+    async delete(key) {
+        return this.memory.delete(key);
+    }
+    async clear() {
+        this.memory.clear();
+    }
+    async list() {
+        return Array.from(this.memory.keys());
+    }
+    async exists(key) {
+        return this.memory.has(key);
+    }
+}
+exports.BasicMemorySystem = BasicMemorySystem;
+exports.defaultMemorySystem = new BasicMemorySystem();
+//# sourceMappingURL=memory-system.js.map

package/dist/memory/snow-flow-memory-patterns.d.ts

@@ -1,33 +1,34 @@
 /**
- * Snow-Flow Memory Patterns - Stub Implementation
- * Minimal implementation to support Queen Memory System
+ * Snow-Flow Memory Patterns
+ * Common memory patterns and utilities for Snow-Flow
  */
-export declare class SnowFlowMemoryOrganizer {
-    static getWidgetMemoryStructure(name: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-        };
-    };
-    static getFlowMemoryStructure(name: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-        };
-    };
-    static getScriptMemoryStructure(name: string, scriptType?: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-            scriptType: string;
-        };
-    };
-    static generateKey(category: string, type: string, name: string): string;
+export interface MemoryPattern {
+    pattern: string;
+    namespace: string;
+    type: string;
 }
+export declare const MEMORY_PATTERNS: {
+    readonly AGENT: "agent/*";
+    readonly TASK: "task/*";
+    readonly SESSION: "session/*";
+    readonly ARTIFACT: "artifact/*";
+    readonly CONFIG: "config/*";
+    readonly TEMP: "temp/*";
+};
+export declare const MEMORY_NAMESPACES: {
+    readonly QUEEN: "queen";
+    readonly AGENTS: "agents";
+    readonly TASKS: "tasks";
+    readonly SESSIONS: "sessions";
+    readonly ARTIFACTS: "artifacts";
+    readonly CONFIG: "config";
+    readonly TEMP: "temp";
+};
+export declare function createMemoryKey(namespace: string, type: string, id: string): string;
+export declare function parseMemoryKey(key: string): {
+    namespace: string;
+    type: string;
+    id: string;
+} | null;
+export declare function matchesPattern(key: string, pattern: string): boolean;
 //# sourceMappingURL=snow-flow-memory-patterns.d.ts.map

package/dist/memory/snow-flow-memory-patterns.js

@@ -1,35 +1,46 @@
 "use strict";
 /**
- * Snow-Flow Memory Patterns - Stub Implementation
- * Minimal implementation to support Queen Memory System
+ * Snow-Flow Memory Patterns
+ * Common memory patterns and utilities for Snow-Flow
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnowFlowMemoryOrganizer = void 0;
-class SnowFlowMemoryOrganizer {
-    static getWidgetMemoryStructure(name) {
-        return {
-            key: this.generateKey('artifacts', 'widget', name),
-            patterns: ['template', 'script', 'client_script'],
-            context: { type: 'widget', name }
-        };
-    }
-    static getFlowMemoryStructure(name) {
-        return {
-            key: this.generateKey('artifacts', 'flow', name),
-            patterns: ['actions', 'conditions', 'variables'],
-            context: { type: 'flow', name }
-        };
-    }
-    static getScriptMemoryStructure(name, scriptType = 'server') {
+exports.MEMORY_NAMESPACES = exports.MEMORY_PATTERNS = void 0;
+exports.createMemoryKey = createMemoryKey;
+exports.parseMemoryKey = parseMemoryKey;
+exports.matchesPattern = matchesPattern;
+exports.MEMORY_PATTERNS = {
+    AGENT: 'agent/*',
+    TASK: 'task/*',
+    SESSION: 'session/*',
+    ARTIFACT: 'artifact/*',
+    CONFIG: 'config/*',
+    TEMP: 'temp/*'
+};
+exports.MEMORY_NAMESPACES = {
+    QUEEN: 'queen',
+    AGENTS: 'agents',
+    TASKS: 'tasks',
+    SESSIONS: 'sessions',
+    ARTIFACTS: 'artifacts',
+    CONFIG: 'config',
+    TEMP: 'temp'
+};
+function createMemoryKey(namespace, type, id) {
+    return `${namespace}/${type}/${id}`;
+}
+function parseMemoryKey(key) {
+    const parts = key.split('/');
+    if (parts.length >= 3) {
         return {
-            key: this.generateKey('artifacts', 'script', name),
-            patterns: ['functions', 'variables', 'dependencies'],
-            context: { type: 'script', name, scriptType }
+            namespace: parts[0],
+            type: parts[1],
+            id: parts.slice(2).join('/')
         };
     }
-    static generateKey(category, type, name) {
-        return `${category}:${type}:${name}`;
-    }
+    return null;
+}
+function matchesPattern(key, pattern) {
+    const regex = new RegExp(pattern.replace('*', '.*'));
+    return regex.test(key);
 }
-exports.SnowFlowMemoryOrganizer = SnowFlowMemoryOrganizer;
 //# sourceMappingURL=snow-flow-memory-patterns.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