snow-flow 2.0.4 → 2.0.6

package/dist/memory/snow-memory.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowMemory = void 0;
+const sqlite3_1 = require("sqlite3");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const nanoid_1 = require("nanoid");
+class SnowMemory {
+    constructor(options = {}) {
+        this.namespace = options.namespace || 'default';
+        this.dbPath = options.dbPath || path_1.default.join(process.cwd(), 'memory', 'snow-memory.db');
+        this.options = options;
+    }
+    async initialize() {
+        // Ensure memory directory exists
+        const memoryDir = path_1.default.dirname(this.dbPath);
+        await promises_1.default.mkdir(memoryDir, { recursive: true });
+        // Open database connection
+        this.db = new sqlite3_1.Database(this.dbPath);
+        // Promisify database methods
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        // Create tables if not exists
+        await run(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        namespace TEXT NOT NULL,
+        ttl INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        accessed_at INTEGER NOT NULL,
+        access_count INTEGER DEFAULT 1,
+        metadata TEXT,
+        UNIQUE(key, namespace)
+      )
+    `);
+        await run(`
+      CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);
+    `);
+        await run(`
+      CREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);
+    `);
+        await run(`
+      CREATE INDEX IF NOT EXISTS idx_memory_ttl ON memory_entries(ttl);
+    `);
+        // Start cleanup timer
+        if (this.options.cleanupInterval) {
+            this.cleanupTimer = setInterval(() => this.cleanup(), this.options.cleanupInterval);
+        }
+        else {
+            // Default cleanup every 5 minutes
+            this.cleanupTimer = setInterval(() => this.cleanup(), 300000);
+        }
+    }
+    async store(key, value, options = {}) {
+        const namespace = options.namespace || this.namespace;
+        const ttl = options.ttl;
+        const metadata = options.metadata || {};
+        const now = Date.now();
+        const expiresAt = ttl ? now + ttl : null;
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        const id = (0, nanoid_1.nanoid)();
+        const serializedValue = JSON.stringify(value);
+        const serializedMetadata = JSON.stringify(metadata);
+        await run(`
+      INSERT OR REPLACE INTO memory_entries 
+      (id, key, value, namespace, ttl, created_at, updated_at, accessed_at, access_count, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 
+        COALESCE((SELECT access_count FROM memory_entries WHERE key = ? AND namespace = ?), 0) + 1,
+        ?)
+    `, [
+            id,
+            key,
+            serializedValue,
+            namespace,
+            expiresAt,
+            now,
+            now,
+            now,
+            key,
+            namespace,
+            serializedMetadata
+        ]);
+        // Check max entries limit
+        if (this.options.maxEntries) {
+            await this.enforceMaxEntries();
+        }
+    }
+    async retrieve(key, namespace) {
+        const ns = namespace || this.namespace;
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        const now = Date.now();
+        // Get entry and check TTL
+        const entry = await get(`
+      SELECT * FROM memory_entries 
+      WHERE key = ? AND namespace = ? AND (ttl IS NULL OR ttl > ?)
+    `, [key, ns, now]);
+        if (!entry) {
+            return null;
+        }
+        // Update access time and count
+        await run(`
+      UPDATE memory_entries 
+      SET accessed_at = ?, access_count = access_count + 1
+      WHERE key = ? AND namespace = ?
+    `, [now, key, ns]);
+        return JSON.parse(entry.value);
+    }
+    async delete(key, namespace) {
+        const ns = namespace || this.namespace;
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        await run(`
+      DELETE FROM memory_entries 
+      WHERE key = ? AND namespace = ?
+    `, [key, ns]);
+    }
+    async search(options = {}) {
+        const all = (0, util_1.promisify)(this.db.all.bind(this.db));
+        let query = `SELECT * FROM memory_entries WHERE 1=1`;
+        const params = [];
+        if (options.namespace) {
+            query += ` AND namespace = ?`;
+            params.push(options.namespace);
+        }
+        if (options.pattern) {
+            query += ` AND key LIKE ?`;
+            params.push(`%${options.pattern}%`);
+        }
+        // Filter out expired entries
+        query += ` AND (ttl IS NULL OR ttl > ?)`;
+        params.push(Date.now());
+        // Ordering
+        const orderBy = options.orderBy || 'updated';
+        const order = options.order || 'desc';
+        const orderColumn = {
+            'created': 'created_at',
+            'updated': 'updated_at',
+            'accessed': 'accessed_at'
+        }[orderBy] || 'updated_at';
+        query += ` ORDER BY ${orderColumn} ${order.toUpperCase()}`;
+        // Pagination
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        query += ` LIMIT ? OFFSET ?`;
+        params.push(limit, offset);
+        const rows = await all(query, params);
+        return rows.map(row => ({
+            key: row.key,
+            value: JSON.parse(row.value),
+            namespace: row.namespace,
+            ttl: row.ttl ? row.ttl - Date.now() : undefined,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            accessCount: row.access_count,
+            metadata: JSON.parse(row.metadata || '{}')
+        }));
+    }
+    async list(namespace) {
+        const ns = namespace || this.namespace;
+        const all = (0, util_1.promisify)(this.db.all.bind(this.db));
+        const rows = await all(`
+      SELECT key FROM memory_entries 
+      WHERE namespace = ? AND (ttl IS NULL OR ttl > ?)
+      ORDER BY updated_at DESC
+    `, [ns, Date.now()]);
+        return rows.map(row => row.key);
+    }
+    async exists(key, namespace) {
+        const ns = namespace || this.namespace;
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        const result = await get(`
+      SELECT 1 FROM memory_entries 
+      WHERE key = ? AND namespace = ? AND (ttl IS NULL OR ttl > ?)
+    `, [key, ns, Date.now()]);
+        return !!result;
+    }
+    async clear(namespace) {
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        if (namespace) {
+            await run(`DELETE FROM memory_entries WHERE namespace = ?`, [namespace]);
+        }
+        else {
+            await run(`DELETE FROM memory_entries`);
+        }
+    }
+    async cleanup() {
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        // Count expired entries before deletion
+        const countResult = await get(`
+      SELECT COUNT(*) as count FROM memory_entries 
+      WHERE ttl IS NOT NULL AND ttl <= ?
+    `, [Date.now()]);
+        // Delete expired entries
+        await run(`
+      DELETE FROM memory_entries 
+      WHERE ttl IS NOT NULL AND ttl <= ?
+    `, [Date.now()]);
+        return countResult?.count || 0;
+    }
+    async enforceMaxEntries() {
+        if (!this.options.maxEntries)
+            return;
+        const run = (0, util_1.promisify)(this.db.run.bind(this.db));
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        // Get current count
+        const countResult = await get(`SELECT COUNT(*) as count FROM memory_entries`);
+        const count = countResult?.count || 0;
+        if (count > this.options.maxEntries) {
+            const toDelete = count - this.options.maxEntries;
+            // Delete oldest entries based on access time
+            await run(`
+        DELETE FROM memory_entries 
+        WHERE id IN (
+          SELECT id FROM memory_entries 
+          ORDER BY accessed_at ASC 
+          LIMIT ?
+        )
+      `, [toDelete]);
+        }
+    }
+    async getStats() {
+        const get = (0, util_1.promisify)(this.db.get.bind(this.db));
+        const all = (0, util_1.promisify)(this.db.all.bind(this.db));
+        const stats = await get(`
+      SELECT 
+        COUNT(*) as total_entries,
+        SUM(LENGTH(value)) as total_size,
+        MIN(created_at) as oldest,
+        MAX(created_at) as newest
+      FROM memory_entries
+      WHERE ttl IS NULL OR ttl > ?
+    `, [Date.now()]);
+        const namespaces = await all(`
+      SELECT DISTINCT namespace FROM memory_entries
+    `);
+        const mostAccessed = await get(`
+      SELECT key, access_count 
+      FROM memory_entries 
+      WHERE ttl IS NULL OR ttl > ?
+      ORDER BY access_count DESC 
+      LIMIT 1
+    `, [Date.now()]);
+        return {
+            totalEntries: stats?.total_entries || 0,
+            namespaces: namespaces.map(row => row.namespace),
+            totalSize: stats?.total_size || 0,
+            oldestEntry: stats?.oldest ? new Date(stats.oldest) : null,
+            newestEntry: stats?.newest ? new Date(stats.newest) : null,
+            mostAccessed: mostAccessed ? {
+                key: mostAccessed.key,
+                count: mostAccessed.access_count
+            } : null
+        };
+    }
+    async export(filePath, namespace) {
+        const entries = await this.search({ namespace, limit: Number.MAX_SAFE_INTEGER });
+        const data = {
+            exported: new Date(),
+            namespace: namespace || 'all',
+            entries: entries
+        };
+        await promises_1.default.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    async import(filePath) {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        let imported = 0;
+        for (const entry of data.entries) {
+            await this.store(entry.key, entry.value, {
+                namespace: entry.namespace,
+                ttl: entry.ttl,
+                metadata: entry.metadata
+            });
+            imported++;
+        }
+        return imported;
+    }
+    async close() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        return new Promise((resolve) => {
+            this.db.close((err) => {
+                if (err) {
+                    console.error('Error closing database:', err);
+                }
+                resolve();
+            });
+        });
+    }
+}
+exports.SnowMemory = SnowMemory;
+//# sourceMappingURL=snow-memory.js.map

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

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+export interface SwarmMemoryConfig {
+    dbPath?: string;
+    inMemory?: boolean;
+    autoMigrate?: boolean;
+    verbose?: boolean;
+}
+export interface AgentCoordination {
+    session_id: string;
+    agent_id: string;
+    agent_type: string;
+    status: 'spawned' | 'active' | 'blocked' | 'completed' | 'failed';
+    assigned_tasks: string;
+    progress_percentage: number;
+    last_activity: Date;
+    current_tool?: string;
+    error_state?: string;
+}
+export interface ServiceNowArtifactRecord {
+    sys_id: string;
+    artifact_type: 'widget' | 'flow' | 'script' | 'business_rule' | 'table' | 'catalog_item';
+    name: string;
+    description?: string;
+    created_by_agent: string;
+    session_id: string;
+    deployment_status: 'created' | 'tested' | 'deployed' | 'verified' | 'failed';
+    update_set_id?: string;
+    dependencies?: string;
+    metadata?: string;
+}
+export interface AgentMessage {
+    id: string;
+    session_id: string;
+    from_agent: string;
+    to_agent: string;
+    message_type: 'handoff' | 'dependency_ready' | 'error' | 'status_update' | 'coordination';
+    content: string;
+    artifact_reference?: string;
+    timestamp: Date;
+    processed: boolean;
+}
+export interface SharedContext {
+    session_id: string;
+    context_key: string;
+    context_value: string;
+    created_by_agent: string;
+    expires_at?: Date;
+    access_permissions?: string;
+}
+export interface DeploymentHistory {
+    id: string;
+    session_id: string;
+    artifact_sys_id: string;
+    deployment_type: 'create' | 'update' | 'test' | 'verify' | 'rollback';
+    success: boolean;
+    deployment_time: Date;
+    agent_id: string;
+    error_details?: string;
+    rollback_available: boolean;
+}
+export interface AgentDependency {
+    session_id: string;
+    agent_id: string;
+    depends_on_agent: string;
+    dependency_type: 'artifact_ready' | 'approval_needed' | 'data_available' | 'task_complete';
+    artifact_reference?: string;
+    status: 'pending' | 'satisfied' | 'blocked' | 'failed';
+    created_at: Date;
+    satisfied_at?: Date;
+}
+export interface PerformanceMetric {
+    id: string;
+    session_id: string;
+    agent_id: string;
+    operation_name: string;
+    duration_ms: number;
+    success: boolean;
+    error_message?: string;
+    timestamp: Date;
+    metadata?: string;
+}
+export declare class SwarmMemory {
+    private db;
+    private logger;
+    private config;
+    private migrationVersion;
+    constructor(config?: SwarmMemoryConfig);
+    private configureDatabase;
+    private migrate;
+    private createTables;
+    private createIndexes;
+    /**
+     * Get the underlying database instance for direct queries
+     */
+    getDatabase(): any;
+    /**
+     * Prepare a statement for repeated execution
+     */
+    prepare(sql: string): any;
+    /**
+     * Execute a query and return all results
+     */
+    all(sql: string, params?: any[]): any[];
+    /**
+     * Execute a query and return the first result
+     */
+    get(sql: string, params?: any[]): any;
+    /**
+     * Execute a statement that doesn't return data
+     */
+    run(sql: string, params?: any[]): any;
+    /**
+     * Execute multiple statements in a transaction
+     */
+    transaction<T>(fn: () => T): T;
+    /**
+     * Clean up expired data
+     */
+    cleanup(): void;
+    /**
+     * Get database statistics
+     */
+    getStats(): Record<string, any>;
+    /**
+     * Close the database connection
+     */
+    close(): void;
+}
+//# sourceMappingURL=swarm-memory.d.ts.map