snow-flow 3.0.8 → 3.0.10

package/dist/memory/snow-memory.js

@@ -1,301 +0,0 @@
-"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

@@ -1,135 +0,0 @@
-/**
- * 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