snow-flow 2.0.3 → 2.0.5

package/dist/memory/swarm-memory.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * Snow-Flow Swarm Memory System
+ * Core SQLite database management for agent coordination
+ *
+ * This module provides the foundation for cross-agent communication,
+ * artifact tracking, and performance monitoring.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwarmMemory = void 0;
+const logger_js_1 = require("../utils/logger.js");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+let Database;
+try {
+    Database = require('better-sqlite3');
+}
+catch (error) {
+    console.error('Failed to load better-sqlite3:', error);
+    throw new Error('better-sqlite3 module is required. Please run: npm install better-sqlite3');
+}
+class SwarmMemory {
+    constructor(config = {}) {
+        this.migrationVersion = 1;
+        this.logger = new logger_js_1.Logger('SwarmMemory');
+        this.config = config;
+        // Ensure memory directory exists
+        if (!config.inMemory && !config.dbPath) {
+            const memoryDir = path.join(process.cwd(), '.snow-flow', 'memory');
+            if (!fs.existsSync(memoryDir)) {
+                fs.mkdirSync(memoryDir, { recursive: true });
+            }
+            config.dbPath = path.join(memoryDir, 'swarm-memory.db');
+        }
+        // Initialize database
+        if (config.inMemory) {
+            this.db = new Database(':memory:');
+            this.logger.info('Initialized in-memory database');
+        }
+        else {
+            this.db = new Database(config.dbPath);
+            this.logger.info('Initialized file-based database', { path: config.dbPath });
+        }
+        // Configure database for performance
+        this.configureDatabase();
+        // Run migrations
+        if (config.autoMigrate !== false) {
+            this.migrate();
+        }
+    }
+    configureDatabase() {
+        // Enable foreign keys for data integrity
+        this.db.pragma('foreign_keys = ON');
+        // Optimize for concurrent reads
+        this.db.pragma('journal_mode = WAL');
+        // Increase cache size for better performance
+        this.db.pragma('cache_size = 10000');
+        // Optimize for fast queries
+        this.db.pragma('synchronous = NORMAL');
+        if (this.config.verbose) {
+            this.logger.info('Database configured for optimal performance');
+        }
+    }
+    migrate() {
+        this.logger.info('Running database migrations');
+        // Check current migration version
+        const userVersion = this.db.pragma('user_version', { simple: true });
+        if (userVersion < this.migrationVersion) {
+            this.logger.info(`Migrating from version ${userVersion} to ${this.migrationVersion}`);
+            try {
+                this.db.transaction(() => {
+                    // Create all tables as specified in MCP_ARCHITECTURE.md
+                    this.createTables();
+                    // Create indexes for performance
+                    this.createIndexes();
+                    // Update migration version
+                    this.db.pragma(`user_version = ${this.migrationVersion}`);
+                })();
+                this.logger.info('Migration completed successfully');
+            }
+            catch (error) {
+                this.logger.error('Migration failed', error);
+                throw new Error(`Database migration failed: ${error.message}`);
+            }
+        }
+    }
+    createTables() {
+        // Agent coordination and communication
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_coordination (
+        session_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        agent_type TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('spawned', 'active', 'blocked', 'completed', 'failed')),
+        assigned_tasks TEXT NOT NULL,
+        progress_percentage INTEGER DEFAULT 0 CHECK (progress_percentage >= 0 AND progress_percentage <= 100),
+        last_activity TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        current_tool TEXT,
+        error_state TEXT,
+        PRIMARY KEY (session_id, agent_id)
+      );
+    `);
+        // ServiceNow artifact tracking
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS servicenow_artifacts (
+        sys_id TEXT PRIMARY KEY,
+        artifact_type TEXT NOT NULL CHECK (artifact_type IN ('widget', 'flow', 'script', 'business_rule', 'table', 'catalog_item')),
+        name TEXT NOT NULL,
+        description TEXT,
+        created_by_agent TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        deployment_status TEXT NOT NULL CHECK (deployment_status IN ('created', 'tested', 'deployed', 'verified', 'failed')),
+        update_set_id TEXT,
+        dependencies TEXT, -- JSON array of dependent artifacts
+        metadata TEXT, -- JSON blob of artifact-specific data
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+        // Inter-agent communication
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_messages (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        from_agent TEXT NOT NULL,
+        to_agent TEXT NOT NULL,
+        message_type TEXT NOT NULL CHECK (message_type IN ('handoff', 'dependency_ready', 'error', 'status_update', 'coordination')),
+        content TEXT NOT NULL,
+        artifact_reference TEXT,
+        timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        processed BOOLEAN DEFAULT FALSE
+      );
+    `);
+        // Shared context between agents
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS shared_context (
+        session_id TEXT NOT NULL,
+        context_key TEXT NOT NULL,
+        context_value TEXT NOT NULL,
+        created_by_agent TEXT NOT NULL,
+        expires_at TIMESTAMP,
+        access_permissions TEXT, -- JSON array of agent types that can access
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (session_id, context_key)
+      );
+    `);
+        // Deployment tracking
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS deployment_history (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        artifact_sys_id TEXT NOT NULL,
+        deployment_type TEXT NOT NULL CHECK (deployment_type IN ('create', 'update', 'test', 'verify', 'rollback')),
+        success BOOLEAN NOT NULL,
+        deployment_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        agent_id TEXT NOT NULL,
+        error_details TEXT,
+        rollback_available BOOLEAN DEFAULT FALSE
+      );
+    `);
+        // Agent dependencies and handoffs
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_dependencies (
+        session_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        depends_on_agent TEXT NOT NULL,
+        dependency_type TEXT NOT NULL CHECK (dependency_type IN ('artifact_ready', 'approval_needed', 'data_available', 'task_complete')),
+        artifact_reference TEXT,
+        status TEXT NOT NULL CHECK (status IN ('pending', 'satisfied', 'blocked', 'failed')),
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        satisfied_at TIMESTAMP,
+        PRIMARY KEY (session_id, agent_id, depends_on_agent)
+      );
+    `);
+        // Performance metrics
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS performance_metrics (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        operation_name TEXT NOT NULL,
+        duration_ms INTEGER NOT NULL CHECK (duration_ms >= 0),
+        success BOOLEAN NOT NULL,
+        error_message TEXT,
+        timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        metadata TEXT -- JSON blob for additional metrics
+      );
+    `);
+    }
+    createIndexes() {
+        // Indexes for agent_coordination
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_agent_coordination_status 
+      ON agent_coordination(status);
+      
+      CREATE INDEX IF NOT EXISTS idx_agent_coordination_session 
+      ON agent_coordination(session_id);
+    `);
+        // Indexes for servicenow_artifacts
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_artifacts_session 
+      ON servicenow_artifacts(session_id);
+      
+      CREATE INDEX IF NOT EXISTS idx_artifacts_type 
+      ON servicenow_artifacts(artifact_type);
+      
+      CREATE INDEX IF NOT EXISTS idx_artifacts_status 
+      ON servicenow_artifacts(deployment_status);
+    `);
+        // Indexes for agent_messages
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_messages_session 
+      ON agent_messages(session_id);
+      
+      CREATE INDEX IF NOT EXISTS idx_messages_to_agent 
+      ON agent_messages(to_agent, processed);
+      
+      CREATE INDEX IF NOT EXISTS idx_messages_timestamp 
+      ON agent_messages(timestamp);
+    `);
+        // Indexes for shared_context
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_context_session 
+      ON shared_context(session_id);
+      
+      CREATE INDEX IF NOT EXISTS idx_context_expires 
+      ON shared_context(expires_at);
+    `);
+        // Indexes for performance_metrics
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_metrics_session 
+      ON performance_metrics(session_id);
+      
+      CREATE INDEX IF NOT EXISTS idx_metrics_agent 
+      ON performance_metrics(agent_id);
+      
+      CREATE INDEX IF NOT EXISTS idx_metrics_timestamp 
+      ON performance_metrics(timestamp);
+    `);
+    }
+    /**
+     * Get the underlying database instance for direct queries
+     */
+    getDatabase() {
+        return this.db;
+    }
+    /**
+     * Prepare a statement for repeated execution
+     */
+    prepare(sql) {
+        return this.db.prepare(sql);
+    }
+    /**
+     * Execute a query and return all results
+     */
+    all(sql, params) {
+        const stmt = this.db.prepare(sql);
+        return params ? stmt.all(...params) : stmt.all();
+    }
+    /**
+     * Execute a query and return the first result
+     */
+    get(sql, params) {
+        const stmt = this.db.prepare(sql);
+        return params ? stmt.get(...params) : stmt.get();
+    }
+    /**
+     * Execute a statement that doesn't return data
+     */
+    run(sql, params) {
+        const stmt = this.db.prepare(sql);
+        return params ? stmt.run(...params) : stmt.run();
+    }
+    /**
+     * Execute multiple statements in a transaction
+     */
+    transaction(fn) {
+        const transaction = this.db.transaction(fn);
+        return transaction();
+    }
+    /**
+     * Clean up expired data
+     */
+    cleanup() {
+        this.logger.info('Running memory cleanup');
+        this.transaction(() => {
+            // Remove expired context
+            this.run(`
+        DELETE FROM shared_context 
+        WHERE expires_at IS NOT NULL AND expires_at < datetime('now')
+      `);
+            // Archive old messages
+            const thirtyDaysAgo = new Date();
+            thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+            this.run(`
+        DELETE FROM agent_messages 
+        WHERE processed = 1 AND timestamp < ?
+      `, [thirtyDaysAgo.toISOString()]);
+            // Archive old performance metrics
+            this.run(`
+        DELETE FROM performance_metrics 
+        WHERE timestamp < ?
+      `, [thirtyDaysAgo.toISOString()]);
+        });
+        // Optimize database
+        this.db.pragma('optimize');
+        this.logger.info('Memory cleanup completed');
+    }
+    /**
+     * Get database statistics
+     */
+    getStats() {
+        const stats = {};
+        const tables = [
+            'agent_coordination',
+            'servicenow_artifacts',
+            'agent_messages',
+            'shared_context',
+            'deployment_history',
+            'agent_dependencies',
+            'performance_metrics'
+        ];
+        for (const table of tables) {
+            const count = this.get(`SELECT COUNT(*) as count FROM ${table}`)?.count || 0;
+            stats[table] = count;
+        }
+        // Add database size
+        const pageCount = this.db.pragma('page_count', { simple: true });
+        const pageSize = this.db.pragma('page_size', { simple: true });
+        if (pageCount && pageSize) {
+            stats.database_size_bytes = pageCount * pageSize;
+        }
+        return stats;
+    }
+    /**
+     * Close the database connection
+     */
+    close() {
+        this.logger.info('Closing database connection');
+        this.db.close();
+    }
+}
+exports.SwarmMemory = SwarmMemory;
+//# sourceMappingURL=swarm-memory.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration. Zero Mock Data, 100% Real API Integration. Natural language interface for ServiceNow operations.",
   "main": "dist/index.js",
   "type": "commonjs",

package/scripts/postinstall.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+console.log('🚀 Setting up Snow-Flow...');
+
+// Check if we're in a global install
+const isGlobalInstall = process.env.npm_config_global === 'true' || 
+                        process.env.npm_config_global === true;
+
+if (isGlobalInstall) {
+  console.log('✅ Snow-Flow installed globally');
+  console.log('📁 Run "snow-flow init" in your project directory to initialize');
+  
+  // Create global config directory
+  const globalConfigDir = path.join(os.homedir(), '.snow-flow');
+  if (!fs.existsSync(globalConfigDir)) {
+    fs.mkdirSync(globalConfigDir, { recursive: true });
+    console.log(`✅ Created global config directory at ${globalConfigDir}`);
+  }
+} else {
+  // Local installation - don't create directories automatically
+  console.log('✅ Snow-Flow installed locally');
+  console.log('🔧 Run "snow-flow init" to initialize your project');
+}
+
+console.log('\n📚 Documentation: https://github.com/groeimetai/snow-flow#readme');
+console.log('🆘 Get help: snow-flow --help');

package/scripts/update-version.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * Update version.ts with the current version from package.json
+ * This script runs automatically after npm version
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read package.json
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = packageJson.version;
+
+// Path to version.ts
+const versionTsPath = path.join(__dirname, '..', 'src', 'version.ts');
+
+// Read current version.ts content
+const versionTsContent = fs.readFileSync(versionTsPath, 'utf8');
+
+// Replace the VERSION constant
+const updatedContent = versionTsContent.replace(
+  /export const VERSION = '[^']+';/,
+  `export const VERSION = '${version}';`
+);
+
+// Write updated content back
+fs.writeFileSync(versionTsPath, updatedContent, 'utf8');
+
+console.log(`✅ Updated version.ts to ${version}`);