moflo 4.8.61 → 4.8.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.61",
+  "version": "4.8.64",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",
@@ -93,6 +93,7 @@
   },
   "dependencies": {
     "js-yaml": "^4.1.1",
+    "lru-cache": "^11.3.5",
     "semver": "^7.7.4",
     "sql.js": "^1.14.1",
     "valibot": "^1.3.1"
@@ -111,7 +112,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.19.37",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.60",
+    "moflo": "^4.8.63",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"

package/src/modules/cli/dist/src/mcp-tools/aidefence-agentdb-store.js

@@ -0,0 +1,79 @@
+/**
+ * AgentDB-backed VectorStore adapter for AIDefence.
+ *
+ * Wraps the CLI memory-bridge (AgentDB v3 + HNSW + embeddings) so the
+ * 6 aidefence_* MCP tools persist learned threat patterns and mitigation
+ * strategies across process restarts with 150x-12,500x faster search.
+ *
+ * @moflo/aidefence stays pure-lib: this adapter lives in the CLI package
+ * where the bridge is already available. Arbitrary values are JSON-serialised
+ * into the bridge's `content` field; namespaces are prefixed with
+ * `aidefence:` to isolate from general memory entries.
+ */
+import { bridgeStoreEntry, bridgeSearchEntries, bridgeGetEntry, bridgeDeleteEntry, isBridgeAvailable, } from '../memory/memory-bridge.js';
+// Structural duck-typed shape of @moflo/aidefence's VectorStore interface.
+// Declared locally to avoid cross-package type resolution fragility; TypeScript
+// verifies compatibility structurally when passed to createAIDefence().
+const NS_PREFIX = 'aidefence:';
+function prefixNs(namespace) {
+    return `${NS_PREFIX}${namespace}`;
+}
+function safeParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export class AgentDBAIDefenceStore {
+    async store(params) {
+        await bridgeStoreEntry({
+            namespace: prefixNs(params.namespace),
+            key: params.key,
+            value: JSON.stringify(params.value),
+            ttl: params.ttl,
+            upsert: true,
+        });
+    }
+    async search(params) {
+        const queryStr = typeof params.query === 'string' ? params.query : JSON.stringify(params.query);
+        const result = await bridgeSearchEntries({
+            namespace: prefixNs(params.namespace),
+            query: queryStr,
+            limit: params.k ?? 10,
+            threshold: params.minSimilarity ?? 0,
+        });
+        if (!result?.results)
+            return [];
+        return result.results.map(r => ({
+            key: r.key,
+            value: safeParse(r.content),
+            similarity: r.score,
+        }));
+    }
+    async get(namespace, key) {
+        const result = await bridgeGetEntry({
+            namespace: prefixNs(namespace),
+            key,
+        });
+        if (!result?.found || !result.entry)
+            return null;
+        return safeParse(result.entry.content);
+    }
+    async delete(namespace, key) {
+        await bridgeDeleteEntry({
+            namespace: prefixNs(namespace),
+            key,
+        });
+    }
+}
+/**
+ * Return an AgentDB-backed store if the memory bridge is available,
+ * otherwise null so the caller can fall back to the default in-memory store.
+ */
+export async function tryCreateAgentDBStore() {
+    const available = await isBridgeAvailable();
+    return available ? new AgentDBAIDefenceStore() : null;
+}
+//# sourceMappingURL=aidefence-agentdb-store.js.map

package/src/modules/cli/dist/src/mcp-tools/security-tools.js

@@ -10,6 +10,7 @@
  * Created with ❤️ by motailz.com
  */
 import { autoInstallPackage } from './auto-install.js';
+import { tryCreateAgentDBStore } from './aidefence-agentdb-store.js';
 import { createRequire } from 'module';
 // Create require for resolving module paths
 const require = createRequire(import.meta.url);
@@ -17,6 +18,20 @@ const require = createRequire(import.meta.url);
 let aidefenceInstance = null;
 // Track if we've attempted install this session
 let installAttempted = false;
+/**
+ * Build createAIDefence config, attaching an AgentDB-backed vector store
+ * when the memory bridge is available. Falls back to the package default
+ * (InMemoryVectorStore) otherwise so the MCP tools still function standalone.
+ */
+async function buildAIDefenceConfig() {
+    const store = await tryCreateAgentDBStore();
+    if (store) {
+        console.error('[claude-flow] aidefence: using AgentDB-backed vector store (HNSW)');
+        return { enableLearning: true, vectorStore: store };
+    }
+    console.error('[claude-flow] aidefence: AgentDB bridge unavailable, using in-memory store');
+    return { enableLearning: true };
+}
 /**
  * Get or create AIDefence instance (throws if unavailable)
  */
@@ -28,7 +43,8 @@ async function getAIDefence() {
     // First attempt - try to load via dynamic import (ESM)
     try {
         const aidefence = await import(packageName);
-        const instance = aidefence.createAIDefence({ enableLearning: true });
+        const config = await buildAIDefenceConfig();
+        const instance = aidefence.createAIDefence(config);
         if (!instance) {
             throw new Error('createAIDefence returned null');
         }
@@ -60,7 +76,8 @@ async function getAIDefence() {
         const modulePath = require.resolve(packageName);
         const cacheBust = `?t=${Date.now()}`;
         const aidefence = await import(pathToFileURL(modulePath).href + cacheBust);
-        const instance = aidefence.createAIDefence({ enableLearning: true });
+        const config = await buildAIDefenceConfig();
+        const instance = aidefence.createAIDefence(config);
         if (!instance) {
             throw new Error('createAIDefence returned null after install');
         }

package/src/modules/cli/dist/src/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.8.61';
+export const VERSION = '4.8.64';
 //# sourceMappingURL=version.js.map

package/src/modules/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.8.61",
+  "version": "4.8.64",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/modules/memory/dist/cache-manager.js

@@ -24,6 +24,9 @@ export class CacheManager extends EventEmitter {
     head = null;
     tail = null;
     currentMemory = 0;
+    // Cache size estimates to avoid repeated JSON.stringify
+    sizeCache = new Map();
+    maxSizeCacheEntries = 10000;
     // Statistics
     stats = {
         hits: 0,
@@ -75,17 +78,21 @@ export class CacheManager extends EventEmitter {
         // Check if key already exists
         const existingNode = this.cache.get(key);
         if (existingNode) {
-            // Update existing entry
+            // Update existing entry - recalculate size if data changed
+            const oldSize = existingNode.estimatedSize;
+            const newSize = this.estimateSizeCached(key, data);
             existingNode.value.data = data;
             existingNode.value.cachedAt = now;
             existingNode.value.expiresAt = now + entryTtl;
             existingNode.value.lastAccessedAt = now;
+            existingNode.estimatedSize = newSize;
+            this.currentMemory = this.currentMemory - oldSize + newSize;
             this.moveToFront(existingNode);
             this.stats.writes++;
             return;
         }
-        // Calculate memory for new entry
-        const entryMemory = this.estimateSize(data);
+        // Calculate memory for new entry (with caching)
+        const entryMemory = this.estimateSizeCached(key, data);
         // Evict entries if needed for memory pressure
         if (this.config.maxMemory) {
             while (this.currentMemory + entryMemory > this.config.maxMemory &&
@@ -110,6 +117,7 @@ export class CacheManager extends EventEmitter {
             value: cachedEntry,
             prev: null,
             next: null,
+            estimatedSize: entryMemory, // Store computed size
         };
         // Add to cache
         this.cache.set(key, node);
@@ -128,7 +136,8 @@ export class CacheManager extends EventEmitter {
         }
         this.removeNode(node);
         this.cache.delete(key);
-        this.currentMemory -= this.estimateSize(node.value.data);
+        this.currentMemory -= node.estimatedSize; // Use cached size
+        this.sizeCache.delete(key); // Clean up size cache
         this.emit('cache:delete', { key });
         return true;
     }
@@ -149,11 +158,13 @@ export class CacheManager extends EventEmitter {
      * Clear all entries from the cache
      */
     clear() {
+        const previousSize = this.cache.size;
         this.cache.clear();
+        this.sizeCache.clear();
         this.head = null;
         this.tail = null;
         this.currentMemory = 0;
-        this.emit('cache:cleared', { previousSize: this.cache.size });
+        this.emit('cache:cleared', { previousSize });
     }
     /**
      * Get cache statistics
@@ -255,8 +266,37 @@ export class CacheManager extends EventEmitter {
     isExpired(entry) {
         return Date.now() > entry.expiresAt;
     }
+    /**
+     * OPTIMIZED: Cache size estimates to avoid repeated JSON.stringify
+     * This is called on every cache set and eviction, so caching saves significant CPU
+     */
+    estimateSizeCached(key, data) {
+        // Check if we have a cached size estimate
+        const cached = this.sizeCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Compute size
+        const size = this.estimateSize(data);
+        // Cache the result (with LRU eviction)
+        if (this.sizeCache.size >= this.maxSizeCacheEntries) {
+            const firstKey = this.sizeCache.keys().next().value;
+            if (firstKey !== undefined)
+                this.sizeCache.delete(firstKey);
+        }
+        this.sizeCache.set(key, size);
+        return size;
+    }
     estimateSize(data) {
         try {
+            // For primitive types, use fast path
+            if (typeof data === 'string') {
+                return data.length * 2;
+            }
+            if (typeof data === 'number' || typeof data === 'boolean') {
+                return 8;
+            }
+            // For objects, use JSON.stringify (but only once due to caching)
             return JSON.stringify(data).length * 2; // Rough UTF-16 estimate
         }
         catch {
@@ -298,9 +338,10 @@ export class CacheManager extends EventEmitter {
         if (!this.tail)
             return;
         const evictedKey = this.tail.key;
-        const evictedSize = this.estimateSize(this.tail.value.data);
+        const evictedSize = this.tail.estimatedSize; // Use cached size
         this.removeNode(this.tail);
         this.cache.delete(evictedKey);
+        this.sizeCache.delete(evictedKey); // Clean up size cache
         this.currentMemory -= evictedSize;
         this.stats.evictions++;
         this.emit('cache:eviction', { key: evictedKey });