snow-flow 4.0.0 → 4.0.2

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/llm/keys.d.ts

@@ -0,0 +1,5 @@
+export declare function setApiKey(provider: string, value: string): void;
+export declare function getApiKey(provider: string): string | undefined;
+export declare function clearApiKey(provider: string): void;
+export declare function listKeys(): Record<string, string | undefined>;
+//# sourceMappingURL=keys.d.ts.map

package/dist/llm/keys.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApiKey = setApiKey;
+exports.getApiKey = getApiKey;
+exports.clearApiKey = clearApiKey;
+exports.listKeys = listKeys;
+const conf_1 = __importDefault(require("conf"));
+// Avoid generic type for broader compatibility with shimmed types
+const store = new conf_1.default({ projectName: 'snow-flow' });
+function setApiKey(provider, value) {
+    store.set(`keys.${provider}`, value);
+}
+function getApiKey(provider) {
+    return store.get(`keys.${provider}`);
+}
+function clearApiKey(provider) {
+    store.delete(`keys.${provider}`);
+}
+function listKeys() {
+    const providers = ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'];
+    const out = {};
+    for (const p of providers)
+        out[p] = getApiKey(p);
+    return out;
+}
+//# sourceMappingURL=keys.js.map

package/dist/llm/providers.d.ts

@@ -0,0 +1,11 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+export type ProviderId = SnowFlowConfig['llm']['provider'];
+export interface ProviderOptions {
+    provider: ProviderId;
+    model: string;
+    baseURL?: string;
+    apiKeyEnv?: string;
+    extraBody?: Record<string, unknown>;
+}
+export declare function getModel(opts: ProviderOptions): unknown;
+//# sourceMappingURL=providers.d.ts.map

package/dist/llm/providers.js

@@ -0,0 +1,77 @@
+"use strict";
+// Compile-safe placeholder registry. Real providers will be wired via AI SDK in a follow-up step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const keys_js_1 = require("./keys.js");
+function getModel(opts) {
+    const { provider, model, baseURL, apiKeyEnv, extraBody } = opts;
+    const requireOrThrow = (name) => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            return require(name);
+        }
+        catch (err) {
+            const hint = `Missing dependency ${name}. Run: npm i ai @ai-sdk/openai @ai-sdk/google @openrouter/ai-sdk-provider`;
+            throw new Error(hint);
+        }
+    };
+    switch (provider) {
+        case 'anthropic': {
+            // Prefer AI SDK anthropic provider if installed; otherwise instruct
+            try {
+                // Dynamic require to avoid hard dep
+                const anthropic = require('@ai-sdk/anthropic');
+                const key = process.env[apiKeyEnv || 'ANTHROPIC_API_KEY'] || (0, keys_js_1.getApiKey)('anthropic');
+                if (!key)
+                    throw new Error('Missing ANTHROPIC_API_KEY');
+                return anthropic.anthropic({ apiKey: key, baseURL }).languageModel(model);
+            }
+            catch (e) {
+                throw new Error('Anthropic provider not available. Install @ai-sdk/anthropic or use OpenRouter with an Anthropic model.');
+            }
+        }
+        case 'openai': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const apiKey = process.env[apiKeyEnv || 'OPENAI_API_KEY'] || (0, keys_js_1.getApiKey)('openai');
+            if (!apiKey)
+                throw new Error('Missing OPENAI_API_KEY');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'google': {
+            const { google } = requireOrThrow('@ai-sdk/google');
+            const apiKey = process.env[apiKeyEnv || 'GOOGLE_API_KEY']
+                || process.env['GOOGLE_GENERATIVE_AI_API_KEY']
+                || (0, keys_js_1.getApiKey)('google');
+            if (!apiKey)
+                throw new Error('Missing GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY');
+            return google({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'openrouter': {
+            const { createOpenRouter } = requireOrThrow('@openrouter/ai-sdk-provider');
+            const apiKey = process.env[apiKeyEnv || 'OPENROUTER_API_KEY'] || (0, keys_js_1.getApiKey)('openrouter');
+            if (!apiKey)
+                throw new Error('Missing OPENROUTER_API_KEY');
+            const or = createOpenRouter({ apiKey, baseURL, extraBody });
+            return or(model);
+        }
+        case 'openai-compatible': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OPENAI_COMPAT_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('openai-compatible');
+            if (!baseURL)
+                throw new Error('openai-compatible requires baseURL');
+            if (!apiKey)
+                throw new Error(`Missing ${keyName}`);
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'ollama': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OLLAMA_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('ollama');
+            if (!baseURL)
+                throw new Error('ollama requires baseURL (e.g., http://localhost:11434/v1)');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+    }
+}
+//# sourceMappingURL=providers.js.map

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,10 @@
+export interface MCPStartup {
+    cmd: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare function loadMCPTools(start: MCPStartup): Promise<{
+    tools: any[];
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/mcp/bridge.js

@@ -0,0 +1,31 @@
+"use strict";
+// Minimal MCP bridge placeholder. We will hook this into AI SDK tools in a next step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMCPTools = loadMCPTools;
+async function loadMCPTools(start) {
+    // Prefer using AI SDK's experimental MCP client to yield ready-to-use Tool[]
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { experimental_createMCPClient } = require('ai');
+        // Use SDK-provided stdio transport
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio');
+        const client = await experimental_createMCPClient({
+            name: 'snow-flow',
+            transport: new StdioClientTransport({
+                command: start.cmd,
+                args: start.args ?? [],
+                env: start.env ?? {},
+            }),
+        });
+        const tools = await client.tools();
+        return { tools, close: client.close };
+    }
+    catch (err) {
+        // Fallback: no AI SDK available, return empty tools and noop close but with a hint.
+        const hint = 'AI SDK MCP bridge not available. Install "ai" or verify version to enable MCP tools.';
+        console.warn(`[snow-flow] ${hint}`);
+        return { tools: [], close: async () => { } };
+    }
+}
+//# sourceMappingURL=bridge.js.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/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/session/store.d.ts

@@ -0,0 +1,47 @@
+export interface SessionMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    timestamp: string;
+    meta?: Record<string, unknown>;
+}
+export interface SessionRecord {
+    id: string;
+    startedAt: string;
+    endedAt?: string;
+    objective: string;
+    provider: {
+        id: string;
+        model: string;
+        baseURL?: string;
+    };
+    mcp: {
+        cmd: string;
+        args?: string[];
+    };
+    messages: SessionMessage[];
+    toolEvents?: {
+        name: string;
+        when: string;
+        argsPreview?: string;
+        resultPreview?: string;
+    }[];
+    summary?: string;
+}
+export declare function createSessionId(): string;
+export declare function startSession(rec: Omit<SessionRecord, 'messages' | 'toolEvents'> & {
+    messages?: SessionMessage[];
+}): SessionRecord;
+export declare function readSession(id: string): SessionRecord | undefined;
+export declare function listSessions(): {
+    id: string;
+    startedAt: string;
+    objective: string;
+}[];
+export declare function appendMessage(id: string, msg: SessionMessage): void;
+export declare function appendToolEvent(id: string, ev: {
+    name: string;
+    argsPreview?: string;
+    resultPreview?: string;
+}): void;
+export declare function endSession(id: string, summary?: string): void;
+//# sourceMappingURL=store.d.ts.map