snow-flow 2.6.5 → 2.6.6

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

@@ -1,15 +1,21 @@
 /**
- * ServiceNow Queen Memory System
- * Simple SQLite-based persistent storage for the hive-mind
+ * ServiceNow Queen Memory System - JSON-based implementation
+ * Simple JSON file storage for the hive-mind - no more SQLite permission issues!
  */
 import { DeploymentPattern, ServiceNowArtifact } from './types';
 export declare class QueenMemorySystem {
-    private db;
+    private memoryDir;
     private memory;
-    private dbPath;
+    private storage;
+    private saveDebounceTimer?;
+    private readonly SAVE_DELAY;
     constructor(dbPath?: string);
-    private initializeDatabase;
-    private loadMemory;
+    private getFilePath;
+    private loadStorage;
+    private convertStorageToMemory;
+    private scheduleSave;
+    private saveAll;
+    private saveJSON;
     storePattern(pattern: DeploymentPattern): void;
     getBestPattern(taskType: string): DeploymentPattern | null;
     storeArtifact(artifact: ServiceNowArtifact): void;

package/dist/queen/queen-memory.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
- * ServiceNow Queen Memory System
- * Simple SQLite-based persistent storage for the hive-mind
+ * ServiceNow Queen Memory System - JSON-based implementation
+ * Simple JSON file storage for the hive-mind - no more SQLite permission issues!
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -42,104 +42,167 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 class QueenMemorySystem {
     constructor(dbPath) {
-        const memoryDir = path.join(process.cwd(), '.snow-flow', 'queen');
-        if (!fs.existsSync(memoryDir)) {
-            fs.mkdirSync(memoryDir, { recursive: true });
+        this.SAVE_DELAY = 1000; // Debounce saves by 1 second
+        // Use same directory structure but with JSON files
+        this.memoryDir = path.dirname(dbPath || path.join(process.cwd(), '.snow-flow', 'queen', 'memory'));
+        // Ensure directory exists
+        if (!fs.existsSync(this.memoryDir)) {
+            fs.mkdirSync(this.memoryDir, { recursive: true });
         }
-        this.dbPath = dbPath || path.join(memoryDir, 'queen-memory.db');
-        this.db = new (require('better-sqlite3'))(this.dbPath);
-        this.initializeDatabase();
-        this.memory = this.loadMemory();
-    }
-    initializeDatabase() {
-        // Simple schema - snow-flow philosophy: keep it minimal
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS patterns (
-        id INTEGER PRIMARY KEY,
-        task_type TEXT NOT NULL,
-        success_rate REAL NOT NULL,
-        agent_sequence TEXT NOT NULL,
-        mcp_sequence TEXT NOT NULL,
-        avg_duration INTEGER NOT NULL,
-        last_used TEXT NOT NULL,
-        use_count INTEGER DEFAULT 0
-      );
-
-      CREATE TABLE IF NOT EXISTS artifacts (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        name TEXT NOT NULL,
-        sys_id TEXT,
-        config TEXT NOT NULL,
-        dependencies TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS learnings (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        confidence REAL NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS context (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS task_history (
-        id TEXT PRIMARY KEY,
-        objective TEXT NOT NULL,
-        type TEXT NOT NULL,
-        agents_used TEXT NOT NULL,
-        success BOOLEAN NOT NULL,
-        duration INTEGER NOT NULL,
-        completed_at TEXT NOT NULL
-      );
-    `);
-    }
-    loadMemory() {
-        const patterns = this.db.prepare('SELECT * FROM patterns ORDER BY success_rate DESC, use_count DESC').all()
-            .map((row) => ({
-            taskType: row.task_type,
-            successRate: row.success_rate,
-            agentSequence: JSON.parse(row.agent_sequence),
-            mcpSequence: JSON.parse(row.mcp_sequence),
-            avgDuration: row.avg_duration,
-            lastUsed: new Date(row.last_used)
-        }));
+        // Load or initialize storage
+        this.storage = this.loadStorage();
+        // Convert storage to memory format
+        this.memory = this.convertStorageToMemory();
+    }
+    getFilePath(filename) {
+        return path.join(this.memoryDir, filename);
+    }
+    loadStorage() {
+        const files = {
+            patterns: this.getFilePath('patterns.json'),
+            artifacts: this.getFilePath('artifacts.json'),
+            learnings: this.getFilePath('learnings.json'),
+            context: this.getFilePath('context.json'),
+            taskHistory: this.getFilePath('task-history.json')
+        };
+        const storage = {
+            patterns: [],
+            artifacts: {},
+            learnings: {},
+            context: {},
+            taskHistory: []
+        };
+        // Load patterns
+        if (fs.existsSync(files.patterns)) {
+            try {
+                const data = fs.readFileSync(files.patterns, 'utf-8');
+                storage.patterns = JSON.parse(data);
+                // Convert date strings back to Date objects
+                storage.patterns.forEach(p => {
+                    p.lastUsed = new Date(p.lastUsed);
+                });
+            }
+            catch (error) {
+                console.warn('⚠️ Could not load patterns.json:', error);
+            }
+        }
+        // Load artifacts
+        if (fs.existsSync(files.artifacts)) {
+            try {
+                const data = fs.readFileSync(files.artifacts, 'utf-8');
+                storage.artifacts = JSON.parse(data);
+            }
+            catch (error) {
+                console.warn('⚠️ Could not load artifacts.json:', error);
+            }
+        }
+        // Load learnings
+        if (fs.existsSync(files.learnings)) {
+            try {
+                const data = fs.readFileSync(files.learnings, 'utf-8');
+                storage.learnings = JSON.parse(data);
+            }
+            catch (error) {
+                console.warn('⚠️ Could not load learnings.json:', error);
+            }
+        }
+        // Load context
+        if (fs.existsSync(files.context)) {
+            try {
+                const data = fs.readFileSync(files.context, 'utf-8');
+                storage.context = JSON.parse(data);
+            }
+            catch (error) {
+                console.warn('⚠️ Could not load context.json:', error);
+            }
+        }
+        // Load task history
+        if (fs.existsSync(files.taskHistory)) {
+            try {
+                const data = fs.readFileSync(files.taskHistory, 'utf-8');
+                storage.taskHistory = JSON.parse(data);
+            }
+            catch (error) {
+                console.warn('⚠️ Could not load task-history.json:', error);
+            }
+        }
+        return storage;
+    }
+    convertStorageToMemory() {
         const artifacts = new Map();
-        this.db.prepare('SELECT * FROM artifacts').all()
-            .forEach((row) => {
-            artifacts.set(row.id, {
-                type: row.type,
-                name: row.name,
-                sys_id: row.sys_id,
-                config: JSON.parse(row.config),
-                dependencies: JSON.parse(row.dependencies)
-            });
+        Object.entries(this.storage.artifacts).forEach(([key, value]) => {
+            artifacts.set(key, value);
         });
         const learnings = new Map();
-        this.db.prepare('SELECT * FROM learnings').all()
-            .forEach((row) => {
-            learnings.set(row.key, row.value);
+        Object.entries(this.storage.learnings).forEach(([key, value]) => {
+            learnings.set(key, typeof value === 'string' ? value : JSON.stringify(value));
         });
         return {
-            patterns,
+            patterns: this.storage.patterns,
             artifacts,
             agentHistory: new Map(),
             learnings
         };
     }
+    scheduleSave() {
+        // Debounce saves to avoid excessive file writes
+        if (this.saveDebounceTimer) {
+            clearTimeout(this.saveDebounceTimer);
+        }
+        this.saveDebounceTimer = setTimeout(() => {
+            this.saveAll();
+        }, this.SAVE_DELAY);
+    }
+    saveAll() {
+        // Save patterns
+        this.saveJSON('patterns.json', this.storage.patterns);
+        // Save artifacts
+        this.saveJSON('artifacts.json', this.storage.artifacts);
+        // Save learnings
+        this.saveJSON('learnings.json', this.storage.learnings);
+        // Save context
+        this.saveJSON('context.json', this.storage.context);
+        // Save task history
+        this.saveJSON('task-history.json', this.storage.taskHistory);
+    }
+    saveJSON(filename, data) {
+        const filepath = this.getFilePath(filename);
+        try {
+            // Write to temp file first for atomicity
+            const tempPath = filepath + '.tmp';
+            fs.writeFileSync(tempPath, JSON.stringify(data, null, 2));
+            // Atomic rename
+            fs.renameSync(tempPath, filepath);
+        }
+        catch (error) {
+            console.error(`❌ Failed to save ${filename}:`, error);
+        }
+    }
     // Store successful deployment pattern
     storePattern(pattern) {
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO patterns 
-      (task_type, success_rate, agent_sequence, mcp_sequence, avg_duration, last_used, use_count)
-      VALUES (?, ?, ?, ?, ?, ?, COALESCE((SELECT use_count FROM patterns WHERE task_type = ?) + 1, 1))
-    `);
-        stmt.run(pattern.taskType, pattern.successRate, JSON.stringify(pattern.agentSequence), JSON.stringify(pattern.mcpSequence), pattern.avgDuration, pattern.lastUsed.toISOString(), pattern.taskType);
-        this.memory.patterns.push(pattern);
+        // Update or add pattern
+        const existingIndex = this.storage.patterns.findIndex(p => p.taskType === pattern.taskType);
+        if (existingIndex >= 0) {
+            // Update existing pattern
+            const existing = this.storage.patterns[existingIndex];
+            existing.successRate = pattern.successRate;
+            existing.agentSequence = pattern.agentSequence;
+            existing.mcpSequence = pattern.mcpSequence;
+            existing.avgDuration = pattern.avgDuration;
+            existing.lastUsed = pattern.lastUsed;
+            existing.useCount = (existing.useCount || 0) + 1;
+        }
+        else {
+            // Add new pattern
+            this.storage.patterns.push({
+                ...pattern,
+                useCount: 1
+            });
+        }
+        // Update memory
+        this.memory.patterns = this.storage.patterns;
+        // Schedule save
+        this.scheduleSave();
     }
     // Get best pattern for task type
     getBestPattern(taskType) {
@@ -148,12 +211,11 @@ class QueenMemorySystem {
     // Store artifact information
     storeArtifact(artifact) {
         const id = `${artifact.type}_${artifact.name}`;
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO artifacts (id, type, name, sys_id, config, dependencies, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(id, artifact.type, artifact.name, artifact.sys_id || null, JSON.stringify(artifact.config), JSON.stringify(artifact.dependencies), new Date().toISOString());
+        // Store in both storage and memory
+        this.storage.artifacts[id] = artifact;
         this.memory.artifacts.set(id, artifact);
+        // Schedule save
+        this.scheduleSave();
     }
     // Find similar artifacts
     findSimilarArtifacts(type, namePattern) {
@@ -167,13 +229,17 @@ class QueenMemorySystem {
     }
     // Store learning from task execution
     storeLearning(key, value, confidence = 1.0) {
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO learnings (key, value, confidence, updated_at)
-      VALUES (?, ?, ?, ?)
-    `);
         const valueStr = typeof value === 'string' ? value : JSON.stringify(value);
-        stmt.run(key, valueStr, confidence, new Date().toISOString());
+        // Store with metadata
+        this.storage.learnings[key] = {
+            value: valueStr,
+            confidence,
+            updatedAt: new Date().toISOString()
+        };
+        // Update memory
         this.memory.learnings.set(key, valueStr);
+        // Schedule save
+        this.scheduleSave();
     }
     // Get learning
     getLearning(key) {
@@ -193,74 +259,83 @@ class QueenMemorySystem {
     }
     // Record task completion for learning
     recordTaskCompletion(taskId, objective, type, agentsUsed, success, duration) {
-        const stmt = this.db.prepare(`
-      INSERT INTO task_history (id, objective, type, agents_used, success, duration, completed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(taskId, objective, type, JSON.stringify(agentsUsed), success ? 1 : 0, // Convert boolean to integer for SQLite
-        duration, new Date().toISOString());
+        const entry = {
+            id: taskId,
+            objective,
+            type,
+            agentsUsed,
+            success,
+            duration,
+            completedAt: new Date().toISOString()
+        };
+        // Add to history
+        this.storage.taskHistory.push(entry);
+        // Keep only last 1000 entries to prevent unbounded growth
+        if (this.storage.taskHistory.length > 1000) {
+            this.storage.taskHistory = this.storage.taskHistory.slice(-1000);
+        }
+        // Schedule save
+        this.scheduleSave();
     }
     // Get success rate for task type
     getSuccessRate(taskType) {
-        const result = this.db.prepare(`
-      SELECT 
-        COUNT(CASE WHEN success = 1 THEN 1 END) as successes,
-        COUNT(*) as total
-      FROM task_history 
-      WHERE type = ?
-    `).get(taskType);
-        if (result && result.total > 0) {
-            return result.successes / result.total;
+        const relevantTasks = this.storage.taskHistory.filter(t => t.type === taskType);
+        if (relevantTasks.length === 0) {
+            return 0.5; // Default success rate
         }
-        return 0.5; // Default success rate
+        const successes = relevantTasks.filter(t => t.success).length;
+        return successes / relevantTasks.length;
     }
     // Export memory for backup
     exportMemory() {
         return JSON.stringify({
-            patterns: this.memory.patterns,
-            artifacts: Array.from(this.memory.artifacts.entries()),
-            learnings: Array.from(this.memory.learnings.entries())
-        });
+            patterns: this.storage.patterns,
+            artifacts: Object.entries(this.storage.artifacts),
+            learnings: Object.entries(this.storage.learnings),
+            context: Object.entries(this.storage.context),
+            taskHistory: this.storage.taskHistory
+        }, null, 2);
     }
     // Import memory from backup
     importMemory(memoryData) {
         try {
             const data = JSON.parse(memoryData);
-            // Clear existing data
-            this.clearMemory();
             // Import patterns
             if (data.patterns) {
-                data.patterns.forEach((pattern) => {
-                    const stmt = this.db.prepare(`
-            INSERT OR REPLACE INTO patterns 
-            (task_type, success_rate, agent_sequence, mcp_sequence, avg_duration, last_used, use_count)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-          `);
-                    stmt.run(pattern.taskType, pattern.successRate, JSON.stringify(pattern.agentSequence), JSON.stringify(pattern.mcpSequence), pattern.avgDuration, pattern.lastUsed, 1);
-                });
+                this.storage.patterns = data.patterns.map((p) => ({
+                    ...p,
+                    lastUsed: new Date(p.lastUsed)
+                }));
             }
             // Import artifacts
             if (data.artifacts) {
-                data.artifacts.forEach(([id, artifact]) => {
-                    const stmt = this.db.prepare(`
-            INSERT OR REPLACE INTO artifacts (id, type, name, sys_id, config, dependencies, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-          `);
-                    stmt.run(id, artifact.type, artifact.name, artifact.sys_id || null, JSON.stringify(artifact.config), JSON.stringify(artifact.dependencies), new Date().toISOString());
+                this.storage.artifacts = {};
+                data.artifacts.forEach(([key, value]) => {
+                    this.storage.artifacts[key] = value;
                 });
             }
             // Import learnings
             if (data.learnings) {
+                this.storage.learnings = {};
                 data.learnings.forEach(([key, value]) => {
-                    const stmt = this.db.prepare(`
-            INSERT OR REPLACE INTO learnings (key, value, confidence, updated_at)
-            VALUES (?, ?, ?, ?)
-          `);
-                    stmt.run(key, value, 1.0, new Date().toISOString());
+                    this.storage.learnings[key] = value;
+                });
+            }
+            // Import context
+            if (data.context) {
+                this.storage.context = {};
+                data.context.forEach(([key, value]) => {
+                    this.storage.context[key] = value;
                 });
             }
-            // Reload memory from database
-            this.memory = this.loadMemory();
+            // Import task history
+            if (data.taskHistory) {
+                this.storage.taskHistory = data.taskHistory;
+            }
+            // Update memory from storage
+            this.memory = this.convertStorageToMemory();
+            // Save all
+            this.saveAll();
         }
         catch (error) {
             throw new Error(`Failed to import memory: ${error.message}`);
@@ -268,31 +343,32 @@ class QueenMemorySystem {
     }
     // Clear all memory (reset learning)
     clearMemory() {
-        // Clear database tables
-        this.db.exec(`
-      DELETE FROM patterns;
-      DELETE FROM artifacts;
-      DELETE FROM learnings;
-      DELETE FROM task_history;
-    `);
-        // Reset in-memory storage
+        // Reset storage
+        this.storage = {
+            patterns: [],
+            artifacts: {},
+            learnings: {},
+            context: {},
+            taskHistory: []
+        };
+        // Reset memory
         this.memory = {
             patterns: [],
             artifacts: new Map(),
             agentHistory: new Map(),
             learnings: new Map()
         };
+        // Save empty state
+        this.saveAll();
     }
     // Store data in context (key-value store)
     storeInContext(key, value) {
-        const stmt = this.db.prepare('INSERT OR REPLACE INTO context (key, value) VALUES (?, ?)');
-        stmt.run(key, JSON.stringify(value));
+        this.storage.context[key] = value;
+        this.scheduleSave();
     }
     // Get data from context
     getFromContext(key) {
-        const stmt = this.db.prepare('SELECT value FROM context WHERE key = ?');
-        const row = stmt.get(key);
-        return row ? JSON.parse(row.value) : null;
+        return this.storage.context[key] || null;
     }
     // Store generic data (alias for storeInContext for compatibility)
     store(key, value) {
@@ -302,34 +378,33 @@ class QueenMemorySystem {
     get(key) {
         return this.getFromContext(key);
     }
-    // Get database path
+    // Get database path (for compatibility)
     getDbPath() {
-        return this.dbPath;
+        return this.memoryDir;
     }
-    // Close database connection
+    // Close database connection (no-op for JSON, but kept for compatibility)
     close() {
-        this.db.close();
+        // Save any pending changes
+        if (this.saveDebounceTimer) {
+            clearTimeout(this.saveDebounceTimer);
+            this.saveAll();
+        }
     }
     // Additional methods needed by other components
     /**
      * Find similar patterns for a given task type
      */
     findSimilarPatterns(taskType) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM patterns 
-      WHERE task_type LIKE ? 
-      ORDER BY success_rate DESC, use_count DESC 
-      LIMIT 5
-    `);
-        const rows = stmt.all(`%${taskType}%`);
-        return rows.map(row => ({
-            taskType: row.task_type,
-            successRate: row.success_rate,
-            agentSequence: JSON.parse(row.agent_sequence),
-            mcpSequence: JSON.parse(row.mcp_sequence),
-            avgDuration: row.avg_duration,
-            lastUsed: new Date(row.last_used)
-        }));
+        return this.storage.patterns
+            .filter(p => p.taskType.toLowerCase().includes(taskType.toLowerCase()))
+            .sort((a, b) => {
+            // Sort by success rate first, then by use count
+            if (b.successRate !== a.successRate) {
+                return b.successRate - a.successRate;
+            }
+            return (b.useCount || 0) - (a.useCount || 0);
+        })
+            .slice(0, 5);
     }
     /**
      * Store a decision made by the Queen
@@ -351,17 +426,22 @@ class QueenMemorySystem {
      * Get memory statistics
      */
     getStats() {
-        const patternCount = this.db.prepare('SELECT COUNT(*) as count FROM patterns').get();
-        const artifactCount = this.db.prepare('SELECT COUNT(*) as count FROM artifacts').get();
-        const taskCount = this.db.prepare('SELECT COUNT(*) as count FROM task_history').get();
-        const learningCount = this.db.prepare('SELECT COUNT(*) as count FROM learnings').get();
-        return {
-            patterns: patternCount.count,
-            artifacts: artifactCount.count,
-            tasks: taskCount.count,
-            learnings: learningCount.count,
-            databaseSize: fs.statSync(this.dbPath).size
+        const stats = {
+            patterns: this.storage.patterns.length,
+            artifacts: Object.keys(this.storage.artifacts).length,
+            tasks: this.storage.taskHistory.length,
+            learnings: Object.keys(this.storage.learnings).length,
+            databaseSize: 0
         };
+        // Calculate total file sizes
+        const files = ['patterns.json', 'artifacts.json', 'learnings.json', 'context.json', 'task-history.json'];
+        for (const file of files) {
+            const filepath = this.getFilePath(file);
+            if (fs.existsSync(filepath)) {
+                stats.databaseSize += fs.statSync(filepath).size;
+            }
+        }
+        return stats;
     }
     /**
      * Store progress information
@@ -379,11 +459,8 @@ class QueenMemorySystem {
      * Store failure pattern for learning
      */
     storeFailurePattern(pattern) {
-        const stmt = this.db.prepare(`
-      INSERT INTO learnings (key, value, confidence, updated_at) 
-      VALUES (?, ?, ?, ?)
-    `);
-        stmt.run(`failure_${Date.now()}`, JSON.stringify(pattern), 0.8, new Date().toISOString());
+        const key = `failure_${Date.now()}`;
+        this.storeLearning(key, pattern, 0.8);
     }
 }
 exports.QueenMemorySystem = QueenMemorySystem;

package/dist/queen/types.d.ts

@@ -32,6 +32,7 @@ export interface DeploymentPattern {
     lastUsed: Date;
     decision?: string;
     outcome?: string;
+    useCount?: number;
 }
 export interface QueenMemory {
     patterns: DeploymentPattern[];

package/dist/version.d.ts

@@ -7,6 +7,7 @@ export declare const VERSION_INFO: {
     name: string;
     description: string;
     features: {
+        '2.6.6': string[];
         '1.4.39': string[];
         '1.4.38': string[];
         '1.4.37': string[];

package/dist/version.js

@@ -14,6 +14,15 @@ exports.VERSION_INFO = {
     name: 'Snow-Flow',
     description: 'ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development',
     features: {
+        '2.6.6': [
+            '🚀 JSON-BASED QUEEN MEMORY: Replaced SQLite with simple JSON file storage',
+            '✅ NO MORE PERMISSION ERRORS: Fixed SQLITE_READONLY_DBMOVED database issues permanently',
+            '📁 TRANSPARENT STORAGE: All memory data in readable JSON files (.snow-flow/queen/*.json)',
+            '🔧 ATOMIC SAVES: Safe file writes with temp file + rename for data integrity',
+            '💾 DEBOUNCED PERSISTENCE: 1-second delay prevents excessive file writes',
+            '🧹 CLEANER SYSTEM: Removed better-sqlite3 dependency from Queen memory',
+            '📊 BACKWARDS COMPATIBLE: Same API, just simpler storage backend',
+        ],
         '1.4.39': [
             '🧹 NEO4J REMOVAL: Removed Neo4j graph memory from available tools (implementation preserved)',
             '✅ NEW TOOLS: Implemented neural_status and token_usage in snow-flow-mcp',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Dynamic task categorization using AI. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
   "main": "dist/index.js",
   "type": "commonjs",