agentic-flow 1.7.0 → 1.7.3

package/dist/memory/SharedMemoryPool.js

@@ -1,211 +0,0 @@
-/**
- * Shared Memory Pool for AgentDB
- *
- * Provides a singleton memory pool that multiple agents can share:
- * - Single SQLite database connection (reduces overhead)
- * - Single embedding model instance (saves ~150MB per agent)
- * - Shared query cache (LRU with TTL)
- * - Shared embedding cache (deduplication)
- *
- * Memory savings: ~300-500MB for 4+ concurrent agents
- *
- * @example
- * ```typescript
- * import { SharedMemoryPool } from 'agentic-flow/memory';
- *
- * const pool = SharedMemoryPool.getInstance();
- * const db = pool.getDatabase();
- * const embedder = pool.getEmbedder();
- * ```
- */
-import Database from 'better-sqlite3';
-import { EmbeddingService } from 'agentdb/controllers';
-import * as path from 'path';
-import * as fs from 'fs';
-export class SharedMemoryPool {
-    static instance;
-    db;
-    embedder;
-    queryCache;
-    embeddingCache;
-    config;
-    initialized = false;
-    constructor(config = {}) {
-        this.config = {
-            dbPath: config.dbPath || './agentdb.db',
-            cacheSize: config.cacheSize || 1000,
-            embeddingCacheSize: config.embeddingCacheSize || 10000,
-            embeddingModel: config.embeddingModel || 'Xenova/all-MiniLM-L6-v2',
-            embeddingDimension: config.embeddingDimension || 384
-        };
-        // Initialize SQLite with optimized settings
-        const dbDir = path.dirname(this.config.dbPath);
-        if (!fs.existsSync(dbDir)) {
-            fs.mkdirSync(dbDir, { recursive: true });
-        }
-        this.db = new Database(this.config.dbPath);
-        // Optimize SQLite for performance
-        this.db.pragma('journal_mode = WAL'); // Write-Ahead Logging
-        this.db.pragma('synchronous = NORMAL'); // Balanced safety/performance
-        this.db.pragma('cache_size = -65536'); // 64MB cache
-        this.db.pragma('mmap_size = 268435456'); // 256MB memory-mapped I/O
-        this.db.pragma('page_size = 8192'); // 8KB pages
-        this.db.pragma('temp_store = MEMORY'); // Keep temp tables in memory
-        // Initialize embedding service (will be lazy-loaded)
-        this.embedder = new EmbeddingService({
-            model: this.config.embeddingModel,
-            dimension: this.config.embeddingDimension,
-            provider: 'transformers'
-        });
-        // Initialize caches
-        this.queryCache = new Map();
-        this.embeddingCache = new Map();
-    }
-    /**
-     * Get singleton instance of SharedMemoryPool
-     */
-    static getInstance(config) {
-        if (!SharedMemoryPool.instance) {
-            SharedMemoryPool.instance = new SharedMemoryPool(config);
-        }
-        return SharedMemoryPool.instance;
-    }
-    /**
-     * Reset singleton instance (for testing)
-     */
-    static resetInstance() {
-        if (SharedMemoryPool.instance) {
-            SharedMemoryPool.instance.close();
-            SharedMemoryPool.instance = null;
-        }
-    }
-    /**
-     * Ensure embedding service is initialized
-     */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.embedder.initialize();
-            this.initialized = true;
-        }
-    }
-    /**
-     * Get shared database connection
-     */
-    getDatabase() {
-        return this.db;
-    }
-    /**
-     * Get shared embedding service
-     */
-    getEmbedder() {
-        return this.embedder;
-    }
-    /**
-     * Get or compute embedding with caching
-     *
-     * @param text Text to embed
-     * @returns Cached or newly computed embedding
-     */
-    async getCachedEmbedding(text) {
-        const cached = this.embeddingCache.get(text);
-        if (cached)
-            return cached;
-        await this.ensureInitialized();
-        const embedding = await this.embedder.embed(text);
-        // LRU eviction if cache too large
-        if (this.embeddingCache.size >= this.config.embeddingCacheSize) {
-            const firstKey = this.embeddingCache.keys().next().value;
-            if (firstKey) {
-                this.embeddingCache.delete(firstKey);
-            }
-        }
-        this.embeddingCache.set(text, embedding);
-        return embedding;
-    }
-    /**
-     * Cache query result with TTL
-     *
-     * @param key Cache key
-     * @param result Result to cache
-     * @param ttl Time-to-live in milliseconds (default: 60s)
-     */
-    cacheQuery(key, result, ttl = 60000) {
-        // LRU eviction if cache too large
-        if (this.queryCache.size >= this.config.cacheSize) {
-            const firstKey = this.queryCache.keys().next().value;
-            if (firstKey) {
-                this.queryCache.delete(firstKey);
-            }
-        }
-        this.queryCache.set(key, {
-            result,
-            expires: Date.now() + ttl
-        });
-    }
-    /**
-     * Get cached query result
-     *
-     * @param key Cache key
-     * @returns Cached result or null if expired/missing
-     */
-    getCachedQuery(key) {
-        const cached = this.queryCache.get(key);
-        if (!cached)
-            return null;
-        if (Date.now() > cached.expires) {
-            this.queryCache.delete(key);
-            return null;
-        }
-        return cached.result;
-    }
-    /**
-     * Clear all caches
-     */
-    clearCaches() {
-        this.queryCache.clear();
-        this.embeddingCache.clear();
-    }
-    /**
-     * Get memory pool statistics
-     */
-    getStats() {
-        const dbStats = this.db.prepare(`
-      SELECT
-        (SELECT COUNT(*) FROM sqlite_master WHERE type='table') as tables,
-        (SELECT page_count * page_size FROM pragma_page_count(), pragma_page_size()) as dbSize
-    `).get();
-        return {
-            database: {
-                path: this.config.dbPath,
-                size: dbStats.dbSize,
-                tables: dbStats.tables,
-                walMode: this.db.pragma('journal_mode', { simple: true }),
-            },
-            cache: {
-                queryCacheSize: this.queryCache.size,
-                queryCacheMax: this.config.cacheSize,
-                embeddingCacheSize: this.embeddingCache.size,
-                embeddingCacheMax: this.config.embeddingCacheSize,
-            },
-            embedder: {
-                model: this.config.embeddingModel,
-                dimension: this.config.embeddingDimension,
-                initialized: this.initialized,
-            },
-            memory: {
-                heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
-                external: Math.round(process.memoryUsage().external / 1024 / 1024),
-            }
-        };
-    }
-    /**
-     * Close database connection and cleanup
-     */
-    close() {
-        this.clearCaches();
-        this.db.close();
-        this.initialized = false;
-    }
-}
-// Export singleton getter for convenience
-export const getSharedMemoryPool = SharedMemoryPool.getInstance;

package/dist/memory/index.js

@@ -1,6 +0,0 @@
-/**
- * Memory Management Exports
- *
- * Provides shared memory pool and optimization utilities
- */
-export { SharedMemoryPool, getSharedMemoryPool } from './SharedMemoryPool.js';

package/dist/reasoningbank/AdvancedMemory.js

@@ -1,67 +0,0 @@
-/**
- * Advanced Memory System (Simplified for v1.7.0)
- *
- * NOTE: This is a simplified version that compiles with agentdb v1.3.9.
- * Full implementation requires additional API alignment work.
- *
- * TODO v1.7.1: Implement full advanced memory features
- */
-import { HybridReasoningBank } from './HybridBackend.js';
-import { NightlyLearner } from 'agentdb/controllers/NightlyLearner';
-import { SharedMemoryPool } from '../memory/SharedMemoryPool.js';
-export class AdvancedMemorySystem {
-    reasoning;
-    learner;
-    pool;
-    constructor(options = {}) {
-        this.reasoning = new HybridReasoningBank(options);
-        this.pool = SharedMemoryPool.getInstance();
-        const db = this.pool.getDatabase();
-        const embedder = this.pool.getEmbedder();
-        this.learner = new NightlyLearner(db, embedder);
-    }
-    /**
-     * Auto-consolidate successful patterns into skills
-     */
-    async autoConsolidate(options = {}) {
-        // Use NightlyLearner.run() for consolidation
-        const report = await this.learner.run();
-        return {
-            skillsCreated: report.edgesDiscovered || 0,
-            causalEdgesCreated: report.edgesPruned || 0,
-            patternsAnalyzed: report.experimentsCompleted || 0
-        };
-    }
-    /**
-     * Learn from past failures
-     */
-    async replayFailures(task, k = 5) {
-        const failures = await this.reasoning.retrievePatterns(task, {
-            k,
-            onlyFailures: true
-        });
-        return failures.map(f => ({
-            critique: f.critique || 'No critique available',
-            whatWentWrong: [f.task || 'Unknown'],
-            howToFix: ['Review similar successful patterns'],
-            similarFailures: failures.length
-        }));
-    }
-    /**
-     * What-if causal analysis
-     */
-    async whatIfAnalysis(action) {
-        return this.reasoning.whatIfAnalysis(action);
-    }
-    /**
-     * Compose multiple skills for a complex task
-     */
-    async composeSkills(task, k = 5) {
-        const skills = await this.reasoning.searchSkills(task, k);
-        return {
-            availableSkills: skills,
-            compositionPlan: skills.map(s => s.name).join(' → '),
-            expectedSuccessRate: skills.length > 0 ? skills[0].successRate || 0 : 0
-        };
-    }
-}

package/dist/reasoningbank/HybridBackend.js

@@ -1,91 +0,0 @@
-/**
- * Hybrid ReasoningBank Backend (Simplified for v1.7.0)
- *
- * NOTE: This is a simplified version that compiles with agentdb v1.3.9.
- * Full implementation with WASM acceleration and causal reasoning requires
- * additional API alignment work.
- *
- * TODO v1.7.1: Implement full hybrid backend with:
- * - WASM-accelerated similarity computation
- * - CausalRecall integration
- * - Skill consolidation
- * - What-if analysis
- */
-import { SharedMemoryPool } from '../memory/SharedMemoryPool.js';
-import { ReflexionMemory } from 'agentdb/controllers/ReflexionMemory';
-import { SkillLibrary } from 'agentdb/controllers/SkillLibrary';
-export class HybridReasoningBank {
-    memory;
-    reflexion;
-    skills;
-    constructor(options = {}) {
-        this.memory = SharedMemoryPool.getInstance();
-        const db = this.memory.getDatabase();
-        const embedder = this.memory.getEmbedder();
-        this.reflexion = new ReflexionMemory(db, embedder);
-        this.skills = new SkillLibrary(db, embedder);
-    }
-    /**
-     * Store a reasoning pattern
-     */
-    async storePattern(pattern) {
-        return this.reflexion.storeEpisode(pattern);
-    }
-    /**
-     * Retrieve similar patterns
-     */
-    async retrievePatterns(query, options = {}) {
-        return this.reflexion.retrieveRelevant({
-            task: query,
-            k: options.k || 5,
-            onlySuccesses: options.onlySuccesses,
-            onlyFailures: options.onlyFailures
-        });
-    }
-    /**
-     * Learn optimal strategy (simplified version)
-     */
-    async learnStrategy(task) {
-        const patterns = await this.retrievePatterns(task, { k: 10, onlySuccesses: true });
-        return {
-            patterns,
-            causality: {
-                action: task,
-                avgReward: patterns.length > 0 ? patterns[0].reward || 0 : 0,
-                avgUplift: 0,
-                confidence: patterns.length > 0 ? 0.8 : 0.3,
-                evidenceCount: patterns.length,
-                recommendation: patterns.length > 0 ? 'DO_IT' : 'NEUTRAL'
-            },
-            confidence: patterns.length > 0 ? 0.8 : 0.3,
-            recommendation: patterns.length > 0 ? `Found ${patterns.length} similar patterns` : 'No patterns found'
-        };
-    }
-    /**
-     * Auto-consolidate patterns into skills (stub)
-     */
-    async autoConsolidate(options = {}) {
-        // TODO: Implement using NightlyLearner.run()
-        return { skillsCreated: 0 };
-    }
-    /**
-     * What-if causal analysis (stub)
-     */
-    async whatIfAnalysis(action) {
-        // TODO: Implement using CausalRecall
-        return {
-            action,
-            avgReward: 0,
-            avgUplift: 0,
-            confidence: 0,
-            evidenceCount: 0,
-            recommendation: 'NEUTRAL'
-        };
-    }
-    /**
-     * Search for relevant skills
-     */
-    async searchSkills(taskType, k = 5) {
-        return this.skills.searchSkills({ task: taskType, k });
-    }
-}

package/dist/reasoningbank/index-new.js

@@ -1,87 +0,0 @@
-/**
- * ReasoningBank - Closed-loop memory system for AI agents
- * Based on arXiv:2509.25140 (Google DeepMind)
- *
- * @since v1.7.0 - Integrated AgentDB for optimal performance
- */
-// New hybrid backend (recommended for new code)
-export { HybridReasoningBank } from './HybridBackend.js';
-export { AdvancedMemorySystem } from './AdvancedMemory.js';
-// Re-export AgentDB controllers for advanced usage
-export { ReflexionMemory } from 'agentdb/controllers/ReflexionMemory';
-export { SkillLibrary } from 'agentdb/controllers/SkillLibrary';
-export { CausalMemoryGraph } from 'agentdb/controllers/CausalMemoryGraph';
-export { CausalRecall } from 'agentdb/controllers/CausalRecall';
-export { NightlyLearner } from 'agentdb/controllers/NightlyLearner';
-export { EmbeddingService } from 'agentdb/controllers/EmbeddingService';
-// Original ReasoningBank implementations (backwards compatibility)
-export { retrieveMemories, formatMemoriesForPrompt } from './core/retrieve.js';
-export { judgeTrajectory } from './core/judge.js';
-export { distillMemories } from './core/distill.js';
-export { consolidate, shouldConsolidate } from './core/consolidate.js';
-export { mattsParallel, mattsSequential } from './core/matts.js';
-export { computeEmbedding, clearEmbeddingCache } from './utils/embeddings.js';
-export { mmrSelection, cosineSimilarity } from './utils/mmr.js';
-export { scrubPII, containsPII, scrubMemory } from './utils/pii-scrubber.js';
-export { loadConfig } from './utils/config.js';
-// Re-export database utilities
-import * as db from './db/queries.js';
-export { db };
-// Original functions (backwards compatibility)
-import { loadConfig } from './utils/config.js';
-import { retrieveMemories } from './core/retrieve.js';
-import { judgeTrajectory } from './core/judge.js';
-import { distillMemories } from './core/distill.js';
-import { shouldConsolidate as shouldCons, consolidate as cons } from './core/consolidate.js';
-export async function initialize() {
-    const config = loadConfig();
-    console.log('[ReasoningBank] Initializing...');
-    console.log(`[ReasoningBank] Enabled: ${!!process.env.REASONINGBANK_ENABLED}`);
-    console.log(`[ReasoningBank] Database: ${process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db'}`);
-    console.log(`[ReasoningBank] Embeddings: ${config.embeddings.provider}`);
-    console.log(`[ReasoningBank] Retrieval k: ${config.retrieve.k}`);
-    try {
-        await db.runMigrations();
-        console.log(`[ReasoningBank] Database migrated successfully`);
-    }
-    catch (error) {
-        console.error('[ReasoningBank] Migration error:', error);
-        throw new Error('ReasoningBank initialization failed: could not run migrations');
-    }
-    try {
-        const dbConn = db.getDb();
-        const tables = dbConn.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'").all();
-        console.log(`[ReasoningBank] Database OK: ${tables.length} tables found`);
-    }
-    catch (error) {
-        console.error('[ReasoningBank] Database error:', error);
-        throw new Error('ReasoningBank initialization failed: database not accessible');
-    }
-    console.log('[ReasoningBank] Initialization complete');
-}
-export async function runTask(options) {
-    console.log(`[ReasoningBank] Running task: ${options.taskId}`);
-    const memories = await retrieveMemories(options.query, {
-        domain: options.domain,
-        agent: options.agentId
-    });
-    console.log(`[ReasoningBank] Retrieved ${memories.length} memories`);
-    const trajectory = await options.executeFn(memories);
-    const verdict = await judgeTrajectory(trajectory, options.query);
-    console.log(`[ReasoningBank] Verdict: ${verdict.label} (${verdict.confidence})`);
-    const newMemories = await distillMemories(trajectory, verdict, options.query, {
-        taskId: options.taskId,
-        agentId: options.agentId,
-        domain: options.domain
-    });
-    console.log(`[ReasoningBank] Distilled ${newMemories.length} new memories`);
-    let consolidated = false;
-    if (shouldCons()) {
-        console.log('[ReasoningBank] Running consolidation...');
-        await cons();
-        consolidated = true;
-    }
-    return { verdict, usedMemories: memories, newMemories, consolidated };
-}
-export const VERSION = '1.7.0';
-export const PAPER_URL = 'https://arxiv.org/html/2509.25140v1';