agentic-flow 1.7.3 → 1.7.5

package/dist/reasoningbank/index.js

@@ -1,38 +1,40 @@
 /**
- * ReasoningBank Plugin for Agentic-Flow
+ * ReasoningBank - Closed-loop memory system for AI agents
+ * Based on arXiv:2509.25140 (Google DeepMind)
  *
- * Main entry point and public API
- *
- * Paper: https://arxiv.org/html/2509.25140v1
- *
- * This is the Node.js backend using SQLite for persistent storage.
- * For browser environments, use './wasm-adapter.js' instead.
- * For automatic backend selection, use './backend-selector.js'.
+ * @since v1.7.0 - Integrated AgentDB for optimal performance
  */
-// Core algorithms
+// Apply AgentDB runtime patch before any AgentDB imports
+import '../utils/agentdb-runtime-patch.js';
+// 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';
-// Utilities
 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';
-// Import for internal use
-import { 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, consolidate } from './core/consolidate.js';
-// Database
-export { db };
-/**
- * Initialize ReasoningBank
- * Run migrations and check configuration
- */
+import { shouldConsolidate as shouldCons, consolidate as cons } from './core/consolidate.js';
 export async function initialize() {
     const config = loadConfig();
     console.log('[ReasoningBank] Initializing...');
@@ -40,7 +42,6 @@ export async function initialize() {
     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}`);
-    // Run migrations to create database and tables
     try {
         await db.runMigrations();
         console.log(`[ReasoningBank] Database migrated successfully`);
@@ -49,7 +50,6 @@ export async function initialize() {
         console.error('[ReasoningBank] Migration error:', error);
         throw new Error('ReasoningBank initialization failed: could not run migrations');
     }
-    // Check database connection
     try {
         const dbConn = db.getDb();
         const tables = dbConn.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'").all();
@@ -61,48 +61,29 @@ export async function initialize() {
     }
     console.log('[ReasoningBank] Initialization complete');
 }
-/**
- * Full task execution with ReasoningBank
- * Combines retrieve → execute → judge → distill → consolidate
- */
 export async function runTask(options) {
     console.log(`[ReasoningBank] Running task: ${options.taskId}`);
-    // 1. Retrieve memories
     const memories = await retrieveMemories(options.query, {
         domain: options.domain,
         agent: options.agentId
     });
     console.log(`[ReasoningBank] Retrieved ${memories.length} memories`);
-    // 2. Execute task with memories
     const trajectory = await options.executeFn(memories);
-    // 3. Judge trajectory
     const verdict = await judgeTrajectory(trajectory, options.query);
     console.log(`[ReasoningBank] Verdict: ${verdict.label} (${verdict.confidence})`);
-    // 4. Distill new memories
     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`);
-    // 5. Consolidate if needed
     let consolidated = false;
-    if (shouldConsolidate()) {
+    if (shouldCons()) {
         console.log('[ReasoningBank] Running consolidation...');
-        await consolidate();
+        await cons();
         consolidated = true;
     }
-    return {
-        verdict,
-        usedMemories: memories,
-        newMemories,
-        consolidated
-    };
+    return { verdict, usedMemories: memories, newMemories, consolidated };
 }
-// AgentDB Integration
-// Ultra-fast vector database drop-in replacement
-// 150x-12,500x faster than legacy implementation
-export { createAgentDBAdapter, createDefaultAgentDBAdapter, migrateToAgentDB, validateMigration } from './agentdb-adapter.js';
-// Version info
-export const VERSION = '1.0.0';
+export const VERSION = '1.7.1';
 export const PAPER_URL = 'https://arxiv.org/html/2509.25140v1';

package/dist/utils/agentdb-runtime-patch.js

@@ -0,0 +1,170 @@
+/**
+ * AgentDB Runtime Patch
+ *
+ * Automatically fixes AgentDB v1.3.9 import resolution issues at runtime.
+ * This patch works in all contexts: npm install, npm install -g, and npx.
+ *
+ * Issue: agentdb v1.3.9 missing .js extensions in ESM exports
+ * Solution: Patch the controller index.js file at runtime before first import
+ */
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+let patched = false;
+let patchAttempted = false;
+/**
+ * Apply AgentDB import fix at runtime
+ * Safe to call multiple times - only patches once
+ */
+export function applyAgentDBPatch() {
+    // Only attempt once per process
+    if (patchAttempted) {
+        return patched;
+    }
+    patchAttempted = true;
+    try {
+        // Find agentdb installation
+        const agentdbPath = findAgentDBPath();
+        if (!agentdbPath) {
+            console.warn('[AgentDB Patch] Could not locate agentdb installation');
+            return false;
+        }
+        const controllerIndexPath = join(agentdbPath, 'dist', 'controllers', 'index.js');
+        if (!existsSync(controllerIndexPath)) {
+            console.warn(`[AgentDB Patch] Controller index not found: ${controllerIndexPath}`);
+            return false;
+        }
+        // Read current content
+        let content = readFileSync(controllerIndexPath, 'utf8');
+        // Check if already patched
+        if (content.includes("from './ReflexionMemory.js'")) {
+            patched = true;
+            return true;
+        }
+        // Apply patches
+        const patches = [
+            { from: "from './ReflexionMemory'", to: "from './ReflexionMemory.js'" },
+            { from: "from './SkillLibrary'", to: "from './SkillLibrary.js'" },
+            { from: "from './EmbeddingService'", to: "from './EmbeddingService.js'" },
+            { from: "from './CausalMemoryGraph'", to: "from './CausalMemoryGraph.js'" },
+            { from: "from './CausalRecall'", to: "from './CausalRecall.js'" },
+            { from: "from './NightlyLearner'", to: "from './NightlyLearner.js'" }
+        ];
+        let modified = false;
+        for (const patch of patches) {
+            if (content.includes(patch.from) && !content.includes(patch.to)) {
+                content = content.replace(new RegExp(patch.from, 'g'), patch.to);
+                modified = true;
+            }
+        }
+        if (modified) {
+            try {
+                writeFileSync(controllerIndexPath, content, 'utf8');
+                patched = true;
+                console.log('[AgentDB Patch] ✅ Successfully patched AgentDB imports');
+                return true;
+            }
+            catch (writeError) {
+                // If we can't write (npx temp dir permissions), that's OK - imports will fail gracefully
+                console.warn('[AgentDB Patch] ⚠️  Could not write patch (read-only):', writeError.message);
+                return false;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        console.warn('[AgentDB Patch] Error applying patch:', error.message);
+        return false;
+    }
+}
+/**
+ * Find AgentDB installation directory
+ * Checks multiple possible locations
+ */
+function findAgentDBPath() {
+    const possiblePaths = [
+        // Local node_modules (most common)
+        join(process.cwd(), 'node_modules', 'agentdb'),
+        // Parent directory node_modules (monorepo)
+        join(process.cwd(), '..', 'node_modules', 'agentdb'),
+        // Global npm installation
+        join(process.execPath, '..', '..', 'lib', 'node_modules', 'agentdb'),
+        // Relative to this file (for bundled installations)
+        ...(typeof __dirname !== 'undefined'
+            ? [
+                join(__dirname, '..', '..', 'node_modules', 'agentdb'),
+                join(__dirname, '..', '..', '..', 'agentdb')
+            ]
+            : []),
+        // Using import.meta.url (ESM)
+        ...(typeof import.meta !== 'undefined' && import.meta.url
+            ? (() => {
+                try {
+                    const currentDir = dirname(fileURLToPath(import.meta.url));
+                    return [
+                        join(currentDir, '..', '..', 'node_modules', 'agentdb'),
+                        join(currentDir, '..', '..', '..', 'agentdb')
+                    ];
+                }
+                catch {
+                    return [];
+                }
+            })()
+            : [])
+    ];
+    // Try each path
+    for (const path of possiblePaths) {
+        if (existsSync(join(path, 'package.json'))) {
+            try {
+                const pkg = JSON.parse(readFileSync(join(path, 'package.json'), 'utf8'));
+                if (pkg.name === 'agentdb') {
+                    return path;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    // Try require.resolve as fallback
+    try {
+        const resolved = require.resolve('agentdb/package.json');
+        return dirname(resolved);
+    }
+    catch {
+        // Not found via require.resolve
+    }
+    return null;
+}
+/**
+ * Check if AgentDB patch is needed
+ */
+export function isAgentDBPatchNeeded() {
+    const agentdbPath = findAgentDBPath();
+    if (!agentdbPath)
+        return false;
+    const controllerIndexPath = join(agentdbPath, 'dist', 'controllers', 'index.js');
+    if (!existsSync(controllerIndexPath))
+        return false;
+    const content = readFileSync(controllerIndexPath, 'utf8');
+    return !content.includes("from './ReflexionMemory.js'");
+}
+/**
+ * Get patch status information
+ */
+export function getAgentDBPatchStatus() {
+    return {
+        needed: isAgentDBPatchNeeded(),
+        applied: patched,
+        attempted: patchAttempted,
+        location: findAgentDBPath()
+    };
+}
+// Auto-apply patch on module load (non-blocking)
+// This ensures the patch is applied before any imports
+if (typeof process !== 'undefined' && !process.env.SKIP_AGENTDB_PATCH) {
+    // Run asynchronously to not block module loading
+    setImmediate(() => {
+        applyAgentDBPatch();
+    });
+}

package/dist/utils/cli.js

@@ -49,16 +49,6 @@ export function parseArgs() {
         options.mode = 'reasoningbank';
         return options;
     }
-    // Check for agentdb command
-    if (args[0] === 'agentdb') {
-        options.mode = 'agentdb';
-        return options;
-    }
-    // Check for skills command
-    if (args[0] === 'skills') {
-        options.mode = 'skills';
-        return options;
-    }
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
@@ -165,7 +155,6 @@ USAGE:
   npx agentic-flow [COMMAND] [OPTIONS]
 
 COMMANDS:
-  skills <command>        Claude Code Skills management (init, create, list)
   reasoningbank <cmd>     Memory system that learns from experience (demo, test, init)
   claude-code [options]   Spawn Claude Code with proxy + Agent Booster (57x faster edits)
   mcp <command> [server]  Manage MCP servers (start, stop, status, list)
@@ -182,12 +171,6 @@ REASONINGBANK COMMANDS:
   npx agentic-flow reasoningbank benchmark    Run performance benchmarks
   npx agentic-flow reasoningbank status       Show memory statistics
 
-SKILLS COMMANDS:
-  npx agentic-flow skills init [location]   Initialize skills directories (personal/project/both)
-  npx agentic-flow skills create            Create example agentic-flow skills
-  npx agentic-flow skills list              List all installed skills
-  npx agentic-flow skills help              Show skills help
-
 MCP COMMANDS:
   npx agentic-flow mcp start [server]    Start MCP server(s)
   npx agentic-flow mcp stop [server]     Stop MCP server(s)
@@ -233,11 +216,6 @@ OPTIONS:
   --help, -h                  Show this help message
 
 EXAMPLES:
-  # Skills (Claude Code integration!)
-  npx agentic-flow skills init              # Initialize skills directories
-  npx agentic-flow skills create            # Create agentdb-quickstart skill
-  npx agentic-flow skills list              # List all installed skills
-
   # ReasoningBank (Learn from agent experience!)
   npx agentic-flow reasoningbank demo       # See 0% → 100% success transformation
   npx agentic-flow reasoningbank test       # Run 27 validation tests