snow-flow 4.1.2 → 4.2.1

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,34 @@
+/**
+ * Basic Memory System Interface
+ * Minimal implementation to satisfy missing imports
+ */
+export interface MemorySystem {
+    store(key: string, value: any, ttl?: number): 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>;
+    query?(query: string): Promise<any[]>;
+    execute?(sql: string): Promise<any>;
+    insert?(table: string, data: any): Promise<any>;
+    getDatabaseStats?(): Promise<any>;
+    getCacheStats?(): Promise<any>;
+    initialize?(): Promise<void>;
+    close?(): Promise<void>;
+    invalidateCache?(key: string): Promise<void>;
+    createEmergencyBackup?(): Promise<string>;
+}
+export declare class BasicMemorySystem implements MemorySystem {
+    private memory;
+    store(key: string, value: any, ttl?: number): 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, ttl) {
+        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,52 @@
 /**
- * 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 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;
 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;
+    static organize(data: any): any;
+}
+export declare const SNOW_FLOW_AGENT_CAPABILITIES: {
+    RESEARCHER: string;
+    CODER: string;
+    ANALYST: string;
+};
+export interface HierarchicalMemoryEntry {
+    key: string;
+    value: any;
+    namespace: string;
+}
+export interface MemorySearchOptions {
+    pattern?: string;
+    limit?: number;
+    namespace?: string;
 }
 //# sourceMappingURL=snow-flow-memory-patterns.d.ts.map

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

@@ -1,35 +1,56 @@
 "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.SNOW_FLOW_AGENT_CAPABILITIES = exports.SnowFlowMemoryOrganizer = 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);
+}
+// Export stub implementations for compatibility
+class SnowFlowMemoryOrganizer {
+    static organize(data) { return data; }
 }
 exports.SnowFlowMemoryOrganizer = SnowFlowMemoryOrganizer;
+exports.SNOW_FLOW_AGENT_CAPABILITIES = {
+    RESEARCHER: 'researcher',
+    CODER: 'coder',
+    ANALYST: 'analyst'
+};
 //# 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

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/artifact-sync/artifact-registry.js

@@ -33,7 +33,7 @@ exports.ARTIFACT_REGISTRY = {
                 fileExtension: 'html',
                 description: 'HTML template with Angular bindings',
                 wrapperHeader: '<!-- ServiceNow Widget Template: {name} -->\n<!-- Angular bindings: {{data.x}}, ng-click="method()" -->\n\n',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: true
             },
             {
@@ -43,7 +43,7 @@ exports.ARTIFACT_REGISTRY = {
                 description: 'Server-side script (ES5 ONLY)',
                 wrapperHeader: '/**\n * Server Script for Widget: {name}\n * ES5 ONLY - No arrow functions, const/let, template literals\n * Available: data, input, options, gs, $sp\n */\n\n(function() {\n',
                 wrapperFooter: '\n})();',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false,
                 validateES5: true
             },
@@ -54,7 +54,7 @@ exports.ARTIFACT_REGISTRY = {
                 description: 'Client-side AngularJS controller',
                 wrapperHeader: '/**\n * Client Controller for Widget: {name}\n * AngularJS 1.x\n * Available: c (this), c.data, c.server, $scope\n */\n\nfunction(',
                 wrapperFooter: ')',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false
             },
             {
@@ -63,7 +63,7 @@ exports.ARTIFACT_REGISTRY = {
                 fileExtension: 'css',
                 description: 'Widget-specific CSS styles',
                 wrapperHeader: '/* Styles for Widget: {name} */\n/* Prefix classes to avoid conflicts */\n\n',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false
             },
             {
@@ -153,7 +153,7 @@ exports.ARTIFACT_REGISTRY = {
                 localFileName: '{name}.flow',
                 fileExtension: 'json',
                 description: 'Complete flow definition with all steps and actions',
-                maxTokens: 50000, // Flows can be huge
+                maxTokens: 200000, // Claude's context window is 200k tokens // Flows can be huge
                 isRequired: true,
                 preprocessor: (content) => {
                     try {
@@ -243,7 +243,7 @@ exports.ARTIFACT_REGISTRY = {
                 description: 'Business rule script',
                 wrapperHeader: '/**\n * Business Rule: {name}\n * Table: {collection}\n * When: {when}\n * Order: {order}\n * Available: current, previous, gs, g_scratchpad\n */\n\n(function executeRule(current, previous /*null when async*/) {\n',
                 wrapperFooter: '\n})(current, previous);',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: true,
                 validateES5: true
             },
@@ -281,7 +281,7 @@ exports.ARTIFACT_REGISTRY = {
                 localFileName: '{name}.client',
                 fileExtension: 'js',
                 description: 'Client-side JavaScript',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false
             },
             {
@@ -289,7 +289,7 @@ exports.ARTIFACT_REGISTRY = {
                 localFileName: '{name}.server',
                 fileExtension: 'js',
                 description: 'Server-side processing script (ES5)',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false,
                 validateES5: true
             }
@@ -310,7 +310,7 @@ exports.ARTIFACT_REGISTRY = {
                 fileExtension: 'js',
                 description: 'Client-side form script',
                 wrapperHeader: '/**\n * Client Script: {name}\n * Table: {table}\n * Type: {type}\n * Available: g_form, g_user, g_list\n */\n\n',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: true
             }
         ]
@@ -375,7 +375,7 @@ exports.ARTIFACT_REGISTRY = {
                 localFileName: '{name}',
                 fileExtension: 'js',
                 description: 'Transform map script',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: false,
                 validateES5: true
             }
@@ -396,7 +396,7 @@ exports.ARTIFACT_REGISTRY = {
                 fileExtension: 'js',
                 description: 'Scheduled job script (ES5)',
                 wrapperHeader: '/**\n * Scheduled Job: {name}\n * Run as: {run_as}\n * Time zone: {time_zone}\n */\n\n',
-                maxTokens: 20000,
+                maxTokens: 200000, // Claude's context window is 200k tokens
                 isRequired: true,
                 validateES5: true
             }

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