claude-flow 2.7.0-alpha.1 → 2.7.0-alpha.11

package/dist/src/reasoningbank/reasoningbank-adapter.js

@@ -1,144 +1,283 @@
-import { db, initialize, retrieveMemories, computeEmbedding, loadConfig } from 'agentic-flow/dist/reasoningbank/index.js';
+import * as ReasoningBank from 'agentic-flow/reasoningbank';
 import { v4 as uuidv4 } from 'uuid';
+let backendInitialized = false;
+let initPromise = null;
+const queryCache = new Map();
+const CACHE_SIZE = 100;
+const CACHE_TTL = 60000;
+async function ensureInitialized() {
+    if (backendInitialized) {
+        return true;
+    }
+    if (initPromise) {
+        return initPromise;
+    }
+    initPromise = (async ()=>{
+        try {
+            await ReasoningBank.initialize();
+            backendInitialized = true;
+            console.log('[ReasoningBank] Node.js backend initialized successfully');
+            return true;
+        } catch (error) {
+            console.error('[ReasoningBank] Backend initialization failed:', error);
+            throw new Error(`Failed to initialize ReasoningBank: ${error.message}`);
+        }
+    })();
+    return initPromise;
+}
 export async function initializeReasoningBank() {
-    process.env.CLAUDE_FLOW_DB_PATH = '.swarm/memory.db';
-    await initialize();
+    await ensureInitialized();
     return true;
 }
 export async function storeMemory(key, value, options = {}) {
-    const memoryId = `mem_${uuidv4()}`;
-    const memory = {
-        id: memoryId,
-        type: options.type || 'fact',
-        pattern_data: JSON.stringify({
-            key,
-            value,
-            namespace: options.namespace || 'default',
-            agent: options.agent || 'memory-agent',
-            domain: options.domain || 'general'
-        }),
-        confidence: options.confidence || 0.8,
-        usage_count: 0,
-        created_at: new Date().toISOString()
-    };
-    db.upsertMemory(memory);
+    await ensureInitialized();
     try {
-        const config = loadConfig();
-        const embeddingModel = config.embeddings.provider || 'claude';
-        const embedding = await computeEmbedding(`${key}: ${value}`);
-        const vectorArray = new Float32Array(embedding);
-        db.upsertEmbedding({
-            memory_id: memoryId,
-            vector: vectorArray,
-            model: embeddingModel,
-            dims: vectorArray.length,
-            created_at: new Date().toISOString()
-        });
+        const memoryId = options.id || uuidv4();
+        const memory = {
+            id: memoryId,
+            type: 'reasoning_memory',
+            pattern_data: {
+                title: key,
+                content: value,
+                domain: options.namespace || 'default',
+                agent: options.agent || 'memory-agent',
+                task_type: options.type || 'fact',
+                original_key: key,
+                original_value: value,
+                namespace: options.namespace || 'default'
+            },
+            confidence: options.confidence || 0.8,
+            usage_count: 0
+        };
+        ReasoningBank.db.upsertMemory(memory);
+        try {
+            const embedding = await ReasoningBank.computeEmbedding(value);
+            ReasoningBank.db.upsertEmbedding({
+                id: memoryId,
+                model: 'text-embedding-3-small',
+                dims: embedding.length,
+                vector: embedding
+            });
+        } catch (embeddingError) {
+            console.warn('[ReasoningBank] Failed to generate embedding:', embeddingError.message);
+        }
+        queryCache.clear();
+        return memoryId;
     } catch (error) {
-        console.warn('[ReasoningBank] Warning: Could not compute embedding:', error.message);
+        console.error('[ReasoningBank] storeMemory failed:', error);
+        throw new Error(`Failed to store memory: ${error.message}`);
     }
-    return memoryId;
 }
 export async function queryMemories(searchQuery, options = {}) {
+    const cached = getCachedQuery(searchQuery, options);
+    if (cached) {
+        return cached;
+    }
+    await ensureInitialized();
+    const limit = options.limit || 10;
+    const namespace = options.namespace || options.domain || 'default';
     try {
-        const memories = await retrieveMemories(searchQuery, {
-            domain: options.domain || 'general',
-            agent: options.agent || 'memory-agent',
-            k: options.limit || 10
+        const results = await ReasoningBank.retrieveMemories(searchQuery, {
+            domain: namespace,
+            agent: options.agent || 'query-agent',
+            k: limit,
+            minConfidence: options.minConfidence || 0.3
         });
-        return memories.map((mem)=>{
-            try {
-                const data = JSON.parse(mem.pattern_data);
-                return {
-                    id: mem.id,
-                    key: data.key,
-                    value: data.value,
-                    namespace: data.namespace,
-                    confidence: mem.confidence,
-                    usage_count: mem.usage_count,
-                    created_at: mem.created_at,
-                    score: mem.score || 0
-                };
-            } catch  {
-                return null;
-            }
-        }).filter(Boolean);
+        const memories = results.map((memory)=>({
+                id: memory.id,
+                key: memory.title || 'unknown',
+                value: memory.content || memory.description || '',
+                namespace: namespace,
+                confidence: memory.components?.reliability || 0.8,
+                usage_count: memory.usage_count || 0,
+                created_at: memory.created_at || new Date().toISOString(),
+                score: memory.score || 0,
+                _pattern: memory
+            }));
+        if (memories.length === 0) {
+            console.warn('[ReasoningBank] Semantic search returned 0 results, trying database fallback');
+            const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({
+                domain: namespace,
+                minConfidence: options.minConfidence || 0.3
+            });
+            const fallbackMemories = fallbackResults.slice(0, limit).map((memory)=>({
+                    id: memory.id,
+                    key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',
+                    value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',
+                    namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',
+                    confidence: memory.confidence || 0.8,
+                    usage_count: memory.usage_count || 0,
+                    created_at: memory.created_at || new Date().toISOString()
+                }));
+            setCachedQuery(searchQuery, options, fallbackMemories);
+            return fallbackMemories;
+        }
+        setCachedQuery(searchQuery, options, memories);
+        return memories;
     } catch (error) {
-        console.warn('[ReasoningBank] Semantic search failed, using simple query:', error.message);
-        const dbInstance = db.getDb();
-        const rows = dbInstance.prepare(`
-      SELECT * FROM patterns
-      WHERE pattern_data LIKE ?
-      ORDER BY confidence DESC, usage_count DESC
-      LIMIT ?
-    `).all(`%${searchQuery}%`, options.limit || 10);
-        return rows.map((row)=>{
-            try {
-                const data = JSON.parse(row.pattern_data);
-                return {
-                    id: row.id,
-                    key: data.key,
-                    value: data.value,
-                    namespace: data.namespace,
-                    confidence: row.confidence,
-                    usage_count: row.usage_count,
-                    created_at: row.created_at
-                };
-            } catch  {
-                return null;
-            }
-        }).filter(Boolean);
+        console.warn('[ReasoningBank] Query failed, trying database fallback:', error.message);
+        try {
+            const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({
+                domain: namespace,
+                minConfidence: options.minConfidence || 0.3
+            });
+            const fallbackMemories = fallbackResults.slice(0, limit).map((memory)=>({
+                    id: memory.id,
+                    key: memory.pattern_data?.title || 'unknown',
+                    value: memory.pattern_data?.content || '',
+                    namespace: memory.pattern_data?.domain || 'default',
+                    confidence: memory.confidence || 0.8,
+                    usage_count: memory.usage_count || 0,
+                    created_at: memory.created_at || new Date().toISOString()
+                }));
+            setCachedQuery(searchQuery, options, fallbackMemories);
+            return fallbackMemories;
+        } catch (fallbackError) {
+            console.error('[ReasoningBank] All query methods failed:', fallbackError);
+            return [];
+        }
     }
 }
 export async function listMemories(options = {}) {
-    const dbInstance = db.getDb();
+    await ensureInitialized();
     const limit = options.limit || 10;
-    const sortBy = options.sort || 'created_at';
-    const sortOrder = options.order || 'DESC';
-    const rows = dbInstance.prepare(`
-    SELECT * FROM patterns
-    ORDER BY ${sortBy} ${sortOrder}
-    LIMIT ?
-  `).all(limit);
-    return rows.map((row)=>{
-        try {
-            const data = JSON.parse(row.pattern_data);
-            return {
-                id: row.id,
-                key: data.key,
-                value: data.value,
-                namespace: data.namespace,
-                confidence: row.confidence,
-                usage_count: row.usage_count,
-                created_at: row.created_at
-            };
-        } catch  {
-            return null;
+    const namespace = options.namespace;
+    try {
+        let memories;
+        if (namespace && namespace !== 'default') {
+            const allMemories = ReasoningBank.db.getAllActiveMemories();
+            memories = allMemories.filter((m)=>m.pattern_data?.domain === namespace).slice(0, limit);
+        } else {
+            memories = ReasoningBank.db.getAllActiveMemories().slice(0, limit);
         }
-    }).filter(Boolean);
+        return memories.map((memory)=>({
+                id: memory.id,
+                key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',
+                value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',
+                namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',
+                confidence: memory.confidence || 0.8,
+                usage_count: memory.usage_count || 0,
+                created_at: memory.created_at || new Date().toISOString()
+            }));
+    } catch (error) {
+        console.error('[ReasoningBank] listMemories failed:', error);
+        return [];
+    }
 }
 export async function getStatus() {
-    const dbInstance = db.getDb();
-    const stats = dbInstance.prepare(`
-    SELECT
-      COUNT(*) as total_memories,
-      AVG(confidence) as avg_confidence,
-      SUM(usage_count) as total_usage
-    FROM patterns
-  `).get();
-    const embeddingCount = dbInstance.prepare(`
-    SELECT COUNT(*) as count FROM pattern_embeddings
-  `).get();
-    const trajectoryCount = dbInstance.prepare(`
-    SELECT COUNT(*) as count FROM task_trajectories
-  `).get();
-    return {
-        total_memories: stats.total_memories || 0,
-        avg_confidence: stats.avg_confidence || 0,
-        total_usage: stats.total_usage || 0,
-        total_embeddings: embeddingCount.count || 0,
-        total_trajectories: trajectoryCount.count || 0
-    };
+    await ensureInitialized();
+    try {
+        const db = ReasoningBank.db.getDb();
+        const patterns = db.prepare("SELECT COUNT(*) as count FROM patterns WHERE type = 'reasoning_memory'").get();
+        const embeddings = db.prepare("SELECT COUNT(*) as count FROM pattern_embeddings").get();
+        const trajectories = db.prepare("SELECT COUNT(*) as count FROM task_trajectories").get();
+        const links = db.prepare("SELECT COUNT(*) as count FROM pattern_links").get();
+        const avgConf = db.prepare("SELECT AVG(confidence) as avg FROM patterns WHERE type = 'reasoning_memory'").get();
+        const domains = db.prepare("SELECT COUNT(DISTINCT json_extract(pattern_data, '$.domain')) as count FROM patterns WHERE type = 'reasoning_memory'").get();
+        return {
+            total_memories: patterns.count || 0,
+            total_categories: domains.count || 0,
+            storage_backend: 'SQLite (Node.js)',
+            database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db',
+            performance: 'SQLite with persistent storage',
+            avg_confidence: avgConf.avg || 0.8,
+            total_embeddings: embeddings.count || 0,
+            total_trajectories: trajectories.count || 0,
+            total_links: links.count || 0
+        };
+    } catch (error) {
+        console.error('[ReasoningBank] getStatus failed:', error);
+        return {
+            total_memories: 0,
+            error: error.message
+        };
+    }
+}
+export async function checkReasoningBankTables() {
+    try {
+        await ensureInitialized();
+        const db = ReasoningBank.db.getDb();
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'").all();
+        const tableNames = tables.map((t)=>t.name);
+        const requiredTables = [
+            'patterns',
+            'pattern_embeddings',
+            'pattern_links',
+            'task_trajectories'
+        ];
+        const missingTables = requiredTables.filter((t)=>!tableNames.includes(t));
+        return {
+            exists: true,
+            existingTables: tableNames,
+            missingTables: missingTables,
+            requiredTables: requiredTables,
+            backend: 'SQLite (Node.js)',
+            note: missingTables.length > 0 ? 'Some tables are missing - run migrations' : 'All tables present'
+        };
+    } catch (error) {
+        return {
+            exists: false,
+            existingTables: [],
+            missingTables: [],
+            requiredTables: [],
+            error: error.message
+        };
+    }
+}
+export async function migrateReasoningBank() {
+    try {
+        await ReasoningBank.db.runMigrations();
+        return {
+            success: true,
+            message: 'Database migrations completed successfully',
+            migrated: true,
+            database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db'
+        };
+    } catch (error) {
+        return {
+            success: false,
+            message: `Migration failed: ${error.message}`,
+            error: error.message
+        };
+    }
+}
+function getCachedQuery(searchQuery, options) {
+    const cacheKey = JSON.stringify({
+        searchQuery,
+        options
+    });
+    const cached = queryCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        return cached.results;
+    }
+    return null;
+}
+function setCachedQuery(searchQuery, options, results) {
+    const cacheKey = JSON.stringify({
+        searchQuery,
+        options
+    });
+    if (queryCache.size >= CACHE_SIZE) {
+        const firstKey = queryCache.keys().next().value;
+        queryCache.delete(firstKey);
+    }
+    queryCache.set(cacheKey, {
+        results,
+        timestamp: Date.now()
+    });
+}
+export function cleanup() {
+    try {
+        if (backendInitialized) {
+            ReasoningBank.clearEmbeddingCache();
+            ReasoningBank.db.closeDb();
+            backendInitialized = false;
+            initPromise = null;
+            console.log('[ReasoningBank] Database connection closed');
+        }
+    } catch (error) {
+        console.error('[ReasoningBank] Cleanup failed:', error.message);
+    }
 }
 
 //# sourceMappingURL=reasoningbank-adapter.js.map

package/dist/src/reasoningbank/reasoningbank-adapter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/reasoningbank/reasoningbank-adapter.js"],"sourcesContent":["/**\n * ReasoningBank Adapter for Claude-Flow\n *\n * Wraps agentic-flow's ReasoningBank SDK for use in claude-flow memory commands\n */\n\nimport {  db, initialize, retrieveMemories, computeEmbedding, loadConfig } from 'agentic-flow/dist/reasoningbank/index.js';\nimport { v4 as uuidv4 } from 'uuid';\n\n/**\n * Initialize ReasoningBank database\n */\nexport async function initializeReasoningBank() {\n  // Set database path\n  process.env.CLAUDE_FLOW_DB_PATH = '.swarm/memory.db';\n\n  await initialize();\n  return true;\n}\n\n/**\n * Store a memory in ReasoningBank\n */\nexport async function storeMemory(key, value, options = {}) {\n  const memoryId = `mem_${uuidv4()}`;\n\n  const memory = {\n    id: memoryId,\n    type: options.type || 'fact',\n    pattern_data: JSON.stringify({\n      key,\n      value,\n      namespace: options.namespace || 'default',\n      agent: options.agent || 'memory-agent',\n      domain: options.domain || 'general',\n    }),\n    confidence: options.confidence || 0.8,\n    usage_count: 0,\n    created_at: new Date().toISOString(),\n  };\n\n  // Store memory\n  db.upsertMemory(memory);\n\n  // Compute and store embedding for semantic search\n  try {\n    const config = loadConfig();\n    const embeddingModel = config.embeddings.provider || 'claude';\n\n    const embedding = await computeEmbedding(`${key}: ${value}`);\n    const vectorArray = new Float32Array(embedding);\n\n    db.upsertEmbedding({\n      memory_id: memoryId,\n      vector: vectorArray,\n      model: embeddingModel,  // Dynamic model from config\n      dims: vectorArray.length,  // Required: embedding dimensions\n      created_at: new Date().toISOString(),\n    });\n  } catch (error) {\n    console.warn('[ReasoningBank] Warning: Could not compute embedding:', error.message);\n    // Continue without embedding - memory is still stored\n  }\n\n  return memoryId;\n}\n\n/**\n * Query memories from ReasoningBank\n */\nexport async function queryMemories(searchQuery, options = {}) {\n  try {\n    // Use ReasoningBank's semantic retrieval\n    const memories = await retrieveMemories(searchQuery, {\n      domain: options.domain || 'general',\n      agent: options.agent || 'memory-agent',\n      k: options.limit || 10,\n    });\n\n    return memories.map(mem => {\n      try {\n        const data = JSON.parse(mem.pattern_data);\n        return {\n          id: mem.id,\n          key: data.key,\n          value: data.value,\n          namespace: data.namespace,\n          confidence: mem.confidence,\n          usage_count: mem.usage_count,\n          created_at: mem.created_at,\n          score: mem.score || 0,\n        };\n      } catch {\n        return null;\n      }\n    }).filter(Boolean);\n  } catch (error) {\n    // Fallback to simple query if semantic search fails\n    console.warn('[ReasoningBank] Semantic search failed, using simple query:', error.message);\n\n    const dbInstance = db.getDb();\n    const rows = dbInstance.prepare(`\n      SELECT * FROM patterns\n      WHERE pattern_data LIKE ?\n      ORDER BY confidence DESC, usage_count DESC\n      LIMIT ?\n    `).all(`%${searchQuery}%`, options.limit || 10);\n\n    return rows.map(row => {\n      try {\n        const data = JSON.parse(row.pattern_data);\n        return {\n          id: row.id,\n          key: data.key,\n          value: data.value,\n          namespace: data.namespace,\n          confidence: row.confidence,\n          usage_count: row.usage_count,\n          created_at: row.created_at,\n        };\n      } catch {\n        return null;\n      }\n    }).filter(Boolean);\n  }\n}\n\n/**\n * List all memories\n */\nexport async function listMemories(options = {}) {\n  const dbInstance = db.getDb();\n\n  const limit = options.limit || 10;\n  const sortBy = options.sort || 'created_at';\n  const sortOrder = options.order || 'DESC';\n\n  const rows = dbInstance.prepare(`\n    SELECT * FROM patterns\n    ORDER BY ${sortBy} ${sortOrder}\n    LIMIT ?\n  `).all(limit);\n\n  return rows.map(row => {\n    try {\n      const data = JSON.parse(row.pattern_data);\n      return {\n        id: row.id,\n        key: data.key,\n        value: data.value,\n        namespace: data.namespace,\n        confidence: row.confidence,\n        usage_count: row.usage_count,\n        created_at: row.created_at,\n      };\n    } catch {\n      return null;\n    }\n  }).filter(Boolean);\n}\n\n/**\n * Get ReasoningBank statistics\n */\nexport async function getStatus() {\n  const dbInstance = db.getDb();\n\n  const stats = dbInstance.prepare(`\n    SELECT\n      COUNT(*) as total_memories,\n      AVG(confidence) as avg_confidence,\n      SUM(usage_count) as total_usage\n    FROM patterns\n  `).get();\n\n  const embeddingCount = dbInstance.prepare(`\n    SELECT COUNT(*) as count FROM pattern_embeddings\n  `).get();\n\n  const trajectoryCount = dbInstance.prepare(`\n    SELECT COUNT(*) as count FROM task_trajectories\n  `).get();\n\n  return {\n    total_memories: stats.total_memories || 0,\n    avg_confidence: stats.avg_confidence || 0,\n    total_usage: stats.total_usage || 0,\n    total_embeddings: embeddingCount.count || 0,\n    total_trajectories: trajectoryCount.count || 0,\n  };\n}\n"],"names":["db","initialize","retrieveMemories","computeEmbedding","loadConfig","v4","uuidv4","initializeReasoningBank","process","env","CLAUDE_FLOW_DB_PATH","storeMemory","key","value","options","memoryId","memory","id","type","pattern_data","JSON","stringify","namespace","agent","domain","confidence","usage_count","created_at","Date","toISOString","upsertMemory","config","embeddingModel","embeddings","provider","embedding","vectorArray","Float32Array","upsertEmbedding","memory_id","vector","model","dims","length","error","console","warn","message","queryMemories","searchQuery","memories","k","limit","map","mem","data","parse","score","filter","Boolean","dbInstance","getDb","rows","prepare","all","row","listMemories","sortBy","sort","sortOrder","order","getStatus","stats","get","embeddingCount","trajectoryCount","total_memories","avg_confidence","total_usage","total_embeddings","count","total_trajectories"],"mappings":"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"}
+{"version":3,"sources":["../../../src/reasoningbank/reasoningbank-adapter.js"],"sourcesContent":["/**\n * ReasoningBank Adapter for Claude-Flow (Node.js Backend)\n *\n * Uses agentic-flow@1.5.13 Node.js backend with SQLite for persistent storage\n * Provides semantic search via embeddings and MMR ranking\n *\n * Backend: SQLite with better-sqlite3\n * Features: Persistent storage, semantic search, memory consolidation\n */\n\nimport * as ReasoningBank from 'agentic-flow/reasoningbank';\nimport { v4 as uuidv4 } from 'uuid';\n\n// Backend instance (singleton)\nlet backendInitialized = false;\nlet initPromise = null;\n\n// Query result cache (LRU)\nconst queryCache = new Map();\nconst CACHE_SIZE = 100;\nconst CACHE_TTL = 60000; // 60 seconds\n\n/**\n * Initialize ReasoningBank Node.js backend\n * @returns {Promise<boolean>}\n */\nasync function ensureInitialized() {\n  if (backendInitialized) {\n    return true;\n  }\n\n  if (initPromise) {\n    return initPromise;\n  }\n\n  initPromise = (async () => {\n    try {\n      // Initialize Node.js backend with SQLite database\n      await ReasoningBank.initialize();\n      backendInitialized = true;\n      console.log('[ReasoningBank] Node.js backend initialized successfully');\n      return true;\n    } catch (error) {\n      console.error('[ReasoningBank] Backend initialization failed:', error);\n      throw new Error(`Failed to initialize ReasoningBank: ${error.message}`);\n    }\n  })();\n\n  return initPromise;\n}\n\n/**\n * Initialize ReasoningBank database (Node.js version)\n */\nexport async function initializeReasoningBank() {\n  // Initialize the Node.js backend\n  await ensureInitialized();\n  return true;\n}\n\n/**\n * Store a memory in ReasoningBank (Node.js backend with SQLite)\n *\n * Maps claude-flow memory model to ReasoningBank pattern model:\n * - key -> title\n * - value -> content (searchable text)\n * - namespace -> domain\n * - confidence -> confidence score\n */\nexport async function storeMemory(key, value, options = {}) {\n  await ensureInitialized();\n\n  try {\n    const memoryId = options.id || uuidv4();\n\n    // Map our memory model to ReasoningBank pattern model\n    const memory = {\n      id: memoryId,\n      type: 'reasoning_memory',\n      pattern_data: {\n        title: key,\n        content: value,\n        domain: options.namespace || 'default',\n        agent: options.agent || 'memory-agent',\n        task_type: options.type || 'fact',\n        // Store original values for compatibility\n        original_key: key,\n        original_value: value,\n        namespace: options.namespace || 'default'\n      },\n      confidence: options.confidence || 0.8,\n      usage_count: 0\n    };\n\n    // Store memory using Node.js backend\n    ReasoningBank.db.upsertMemory(memory);\n\n    // Generate and store embedding for semantic search\n    try {\n      const embedding = await ReasoningBank.computeEmbedding(value);\n      ReasoningBank.db.upsertEmbedding({\n        id: memoryId,\n        model: 'text-embedding-3-small', // Default model\n        dims: embedding.length,\n        vector: embedding\n      });\n    } catch (embeddingError) {\n      console.warn('[ReasoningBank] Failed to generate embedding:', embeddingError.message);\n      // Continue without embedding - memory is still stored\n    }\n\n    // Invalidate query cache when new memory is added\n    queryCache.clear();\n\n    return memoryId;\n  } catch (error) {\n    console.error('[ReasoningBank] storeMemory failed:', error);\n    throw new Error(`Failed to store memory: ${error.message}`);\n  }\n}\n\n/**\n * Query memories from ReasoningBank (Node.js backend with semantic search)\n *\n * Uses retrieveMemories for semantic search via embeddings and MMR ranking\n * Fallback to database query if semantic search fails\n */\nexport async function queryMemories(searchQuery, options = {}) {\n  // Check cache first\n  const cached = getCachedQuery(searchQuery, options);\n  if (cached) {\n    return cached;\n  }\n\n  await ensureInitialized();\n  const limit = options.limit || 10;\n  // Accept both 'namespace' and 'domain' for compatibility\n  const namespace = options.namespace || options.domain || 'default';\n\n  try {\n    // Try semantic search first using retrieveMemories\n    const results = await ReasoningBank.retrieveMemories(searchQuery, {\n      domain: namespace,\n      agent: options.agent || 'query-agent',\n      k: limit,\n      minConfidence: options.minConfidence || 0.3\n    });\n\n    // Map backend results to our memory format\n    // retrieveMemories returns: { id, title, content, description, score, components }\n    const memories = results.map(memory => ({\n      id: memory.id,\n      key: memory.title || 'unknown',\n      value: memory.content || memory.description || '',\n      namespace: namespace, // Use the namespace from our query\n      confidence: memory.components?.reliability || 0.8,\n      usage_count: memory.usage_count || 0,\n      created_at: memory.created_at || new Date().toISOString(),\n      score: memory.score || 0,\n      // Include original pattern for debugging\n      _pattern: memory\n    }));\n\n    // If no results, try direct database query as fallback\n    if (memories.length === 0) {\n      console.warn('[ReasoningBank] Semantic search returned 0 results, trying database fallback');\n      const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({\n        domain: namespace,\n        minConfidence: options.minConfidence || 0.3\n      });\n\n      const fallbackMemories = fallbackResults.slice(0, limit).map(memory => ({\n        id: memory.id,\n        key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',\n        value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',\n        namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',\n        confidence: memory.confidence || 0.8,\n        usage_count: memory.usage_count || 0,\n        created_at: memory.created_at || new Date().toISOString()\n      }));\n\n      // Cache and return fallback results\n      setCachedQuery(searchQuery, options, fallbackMemories);\n      return fallbackMemories;\n    }\n\n    // Cache successful results\n    setCachedQuery(searchQuery, options, memories);\n    return memories;\n  } catch (error) {\n    console.warn('[ReasoningBank] Query failed, trying database fallback:', error.message);\n\n    try {\n      // Final fallback: direct database query\n      const fallbackResults = ReasoningBank.db.fetchMemoryCandidates({\n        domain: namespace,\n        minConfidence: options.minConfidence || 0.3\n      });\n\n      const fallbackMemories = fallbackResults.slice(0, limit).map(memory => ({\n        id: memory.id,\n        key: memory.pattern_data?.title || 'unknown',\n        value: memory.pattern_data?.content || '',\n        namespace: memory.pattern_data?.domain || 'default',\n        confidence: memory.confidence || 0.8,\n        usage_count: memory.usage_count || 0,\n        created_at: memory.created_at || new Date().toISOString()\n      }));\n\n      setCachedQuery(searchQuery, options, fallbackMemories);\n      return fallbackMemories;\n    } catch (fallbackError) {\n      console.error('[ReasoningBank] All query methods failed:', fallbackError);\n      return [];\n    }\n  }\n}\n\n/**\n * List all memories (using Node.js backend database query)\n */\nexport async function listMemories(options = {}) {\n  await ensureInitialized();\n  const limit = options.limit || 10;\n  const namespace = options.namespace;\n\n  try {\n    let memories;\n\n    if (namespace && namespace !== 'default') {\n      // Filter by namespace/domain\n      const allMemories = ReasoningBank.db.getAllActiveMemories();\n      memories = allMemories\n        .filter(m => m.pattern_data?.domain === namespace)\n        .slice(0, limit);\n    } else {\n      // Get all active memories\n      memories = ReasoningBank.db.getAllActiveMemories().slice(0, limit);\n    }\n\n    return memories.map(memory => ({\n      id: memory.id,\n      key: memory.pattern_data?.title || memory.pattern_data?.original_key || 'unknown',\n      value: memory.pattern_data?.content || memory.pattern_data?.original_value || '',\n      namespace: memory.pattern_data?.domain || memory.pattern_data?.namespace || 'default',\n      confidence: memory.confidence || 0.8,\n      usage_count: memory.usage_count || 0,\n      created_at: memory.created_at || new Date().toISOString()\n    }));\n  } catch (error) {\n    console.error('[ReasoningBank] listMemories failed:', error);\n    return [];\n  }\n}\n\n/**\n * Get ReasoningBank statistics (Node.js backend)\n */\nexport async function getStatus() {\n  await ensureInitialized();\n\n  try {\n    const db = ReasoningBank.db.getDb();\n\n    // Count patterns\n    const patterns = db.prepare(\"SELECT COUNT(*) as count FROM patterns WHERE type = 'reasoning_memory'\").get();\n    const embeddings = db.prepare(\"SELECT COUNT(*) as count FROM pattern_embeddings\").get();\n    const trajectories = db.prepare(\"SELECT COUNT(*) as count FROM task_trajectories\").get();\n    const links = db.prepare(\"SELECT COUNT(*) as count FROM pattern_links\").get();\n\n    // Get average confidence\n    const avgConf = db.prepare(\"SELECT AVG(confidence) as avg FROM patterns WHERE type = 'reasoning_memory'\").get();\n\n    // Count unique domains\n    const domains = db.prepare(\"SELECT COUNT(DISTINCT json_extract(pattern_data, '$.domain')) as count FROM patterns WHERE type = 'reasoning_memory'\").get();\n\n    return {\n      total_memories: patterns.count || 0,\n      total_categories: domains.count || 0,\n      storage_backend: 'SQLite (Node.js)',\n      database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db',\n      performance: 'SQLite with persistent storage',\n      avg_confidence: avgConf.avg || 0.8,\n      total_embeddings: embeddings.count || 0,\n      total_trajectories: trajectories.count || 0,\n      total_links: links.count || 0\n    };\n  } catch (error) {\n    console.error('[ReasoningBank] getStatus failed:', error);\n    return {\n      total_memories: 0,\n      error: error.message\n    };\n  }\n}\n\n/**\n * Check which ReasoningBank tables are present (Node.js backend)\n */\nexport async function checkReasoningBankTables() {\n  try {\n    await ensureInitialized();\n    const db = ReasoningBank.db.getDb();\n\n    const tables = db.prepare(\"SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'pattern%'\").all();\n    const tableNames = tables.map(t => t.name);\n\n    const requiredTables = ['patterns', 'pattern_embeddings', 'pattern_links', 'task_trajectories'];\n    const missingTables = requiredTables.filter(t => !tableNames.includes(t));\n\n    return {\n      exists: true,\n      existingTables: tableNames,\n      missingTables: missingTables,\n      requiredTables: requiredTables,\n      backend: 'SQLite (Node.js)',\n      note: missingTables.length > 0 ? 'Some tables are missing - run migrations' : 'All tables present'\n    };\n  } catch (error) {\n    return {\n      exists: false,\n      existingTables: [],\n      missingTables: [],\n      requiredTables: [],\n      error: error.message\n    };\n  }\n}\n\n/**\n * Migrate existing database (Node.js backend - run migrations)\n */\nexport async function migrateReasoningBank() {\n  try {\n    await ReasoningBank.db.runMigrations();\n\n    return {\n      success: true,\n      message: 'Database migrations completed successfully',\n      migrated: true,\n      database_path: process.env.CLAUDE_FLOW_DB_PATH || '.swarm/memory.db'\n    };\n  } catch (error) {\n    return {\n      success: false,\n      message: `Migration failed: ${error.message}`,\n      error: error.message\n    };\n  }\n}\n\n/**\n * Get cached query results\n */\nfunction getCachedQuery(searchQuery, options) {\n  const cacheKey = JSON.stringify({ searchQuery, options });\n  const cached = queryCache.get(cacheKey);\n\n  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {\n    return cached.results;\n  }\n\n  return null;\n}\n\n/**\n * Set cached query results (LRU eviction)\n */\nfunction setCachedQuery(searchQuery, options, results) {\n  const cacheKey = JSON.stringify({ searchQuery, options });\n\n  // LRU eviction\n  if (queryCache.size >= CACHE_SIZE) {\n    const firstKey = queryCache.keys().next().value;\n    queryCache.delete(firstKey);\n  }\n\n  queryCache.set(cacheKey, {\n    results,\n    timestamp: Date.now()\n  });\n}\n\n/**\n * Close database connection and cleanup resources\n * Should be called when done with ReasoningBank operations\n */\nexport function cleanup() {\n  try {\n    if (backendInitialized) {\n      // Clear embedding cache (prevents memory leaks)\n      ReasoningBank.clearEmbeddingCache();\n\n      // Close database connection\n      ReasoningBank.db.closeDb();\n      backendInitialized = false;\n      initPromise = null;\n      console.log('[ReasoningBank] Database connection closed');\n    }\n  } catch (error) {\n    console.error('[ReasoningBank] Cleanup failed:', error.message);\n  }\n}\n"],"names":["ReasoningBank","v4","uuidv4","backendInitialized","initPromise","queryCache","Map","CACHE_SIZE","CACHE_TTL","ensureInitialized","initialize","console","log","error","Error","message","initializeReasoningBank","storeMemory","key","value","options","memoryId","id","memory","type","pattern_data","title","content","domain","namespace","agent","task_type","original_key","original_value","confidence","usage_count","db","upsertMemory","embedding","computeEmbedding","upsertEmbedding","model","dims","length","vector","embeddingError","warn","clear","queryMemories","searchQuery","cached","getCachedQuery","limit","results","retrieveMemories","k","minConfidence","memories","map","description","components","reliability","created_at","Date","toISOString","score","_pattern","fallbackResults","fetchMemoryCandidates","fallbackMemories","slice","setCachedQuery","fallbackError","listMemories","allMemories","getAllActiveMemories","filter","m","getStatus","getDb","patterns","prepare","get","embeddings","trajectories","links","avgConf","domains","total_memories","count","total_categories","storage_backend","database_path","process","env","CLAUDE_FLOW_DB_PATH","performance","avg_confidence","avg","total_embeddings","total_trajectories","total_links","checkReasoningBankTables","tables","all","tableNames","t","name","requiredTables","missingTables","includes","exists","existingTables","backend","note","migrateReasoningBank","runMigrations","success","migrated","cacheKey","JSON","stringify","now","timestamp","size","firstKey","keys","next","delete","set","cleanup","clearEmbeddingCache","closeDb"],"mappings":"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"}

package/dist/src/utils/key-redactor.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/key-redactor.ts"],"sourcesContent":["/**\n * API Key Redaction Utility\n * Prevents sensitive data from leaking into logs, memory, or git commits\n */\n\nexport interface RedactionConfig {\n  patterns: RegExp[];\n  replacement: string;\n  maskLength: number;\n}\n\nexport class KeyRedactor {\n  private static readonly API_KEY_PATTERNS = [\n    // Anthropic API keys\n    /sk-ant-[a-zA-Z0-9_-]{95,}/gi,\n\n    // OpenRouter API keys\n    /sk-or-[a-zA-Z0-9_-]{32,}/gi,\n\n    // Google/Gemini API keys\n    /AIza[a-zA-Z0-9_-]{35}/gi,\n\n    // Generic API keys\n    /[a-zA-Z0-9_-]{20,}API[a-zA-Z0-9_-]{20,}/gi,\n\n    // Bearer tokens\n    /Bearer\\s+[a-zA-Z0-9_\\-\\.]{20,}/gi,\n\n    // Environment variable format\n    /([A-Z_]+_API_KEY|[A-Z_]+_TOKEN|[A-Z_]+_SECRET)=[\"']?([^\"'\\s]+)[\"']?/gi,\n\n    // Supabase keys\n    /eyJ[a-zA-Z0-9_-]*\\.eyJ[a-zA-Z0-9_-]*\\.[a-zA-Z0-9_-]*/gi,\n  ];\n\n  private static readonly SENSITIVE_FIELDS = [\n    'apiKey',\n    'api_key',\n    'token',\n    'secret',\n    'password',\n    'private_key',\n    'privateKey',\n    'accessToken',\n    'access_token',\n    'refreshToken',\n    'refresh_token',\n  ];\n\n  /**\n   * Redact API keys and sensitive data from text\n   */\n  static redact(text: string, showPrefix = true): string {\n    if (!text) return text;\n\n    let redacted = text;\n\n    // Redact using patterns\n    this.API_KEY_PATTERNS.forEach(pattern => {\n      redacted = redacted.replace(pattern, (match) => {\n        if (showPrefix && match.length > 8) {\n          const prefix = match.substring(0, 8);\n          return `${prefix}...[REDACTED]`;\n        }\n        return '[REDACTED_API_KEY]';\n      });\n    });\n\n    return redacted;\n  }\n\n  /**\n   * Redact sensitive fields in objects\n   */\n  static redactObject<T extends Record<string, any>>(obj: T, deep = true): T {\n    if (!obj || typeof obj !== 'object') return obj;\n\n    const redacted = { ...obj };\n\n    Object.keys(redacted).forEach(key => {\n      const lowerKey = key.toLowerCase();\n\n      // Check if field name is sensitive\n      const isSensitive = this.SENSITIVE_FIELDS.some(field =>\n        lowerKey.includes(field)\n      );\n\n      if (isSensitive && typeof redacted[key] === 'string') {\n        const value = redacted[key] as string;\n        if (value && value.length > 8) {\n          redacted[key] = `${value.substring(0, 4)}...[REDACTED]` as any;\n        } else {\n          redacted[key] = '[REDACTED]' as any;\n        }\n      } else if (deep && typeof redacted[key] === 'object' && redacted[key] !== null) {\n        redacted[key] = this.redactObject(redacted[key], deep);\n      } else if (typeof redacted[key] === 'string') {\n        // Redact any API keys in string values\n        redacted[key] = this.redact(redacted[key]) as any;\n      }\n    });\n\n    return redacted;\n  }\n\n  /**\n   * Sanitize text for safe logging\n   */\n  static sanitize(text: string): string {\n    return this.redact(text, true);\n  }\n\n  /**\n   * Sanitize command arguments\n   */\n  static sanitizeArgs(args: string[]): string[] {\n    return args.map(arg => {\n      // Check if arg is a flag value pair\n      if (arg.includes('key') || arg.includes('token') || arg.includes('secret')) {\n        return this.redact(arg);\n      }\n      return arg;\n    });\n  }\n\n  /**\n   * Check if text contains unredacted sensitive data\n   */\n  static containsSensitiveData(text: string): boolean {\n    return this.API_KEY_PATTERNS.some(pattern => pattern.test(text));\n  }\n\n  /**\n   * Validate that text is safe for logging/storage\n   */\n  static validate(text: string): { safe: boolean; warnings: string[] } {\n    const warnings: string[] = [];\n\n    this.API_KEY_PATTERNS.forEach((pattern, index) => {\n      if (pattern.test(text)) {\n        warnings.push(`Potential API key detected (pattern ${index + 1})`);\n      }\n    });\n\n    return {\n      safe: warnings.length === 0,\n      warnings,\n    };\n  }\n\n  /**\n   * Redact environment variables\n   */\n  static redactEnv(env: Record<string, string | undefined>): Record<string, string> {\n    const redacted: Record<string, string> = {};\n\n    Object.keys(env).forEach(key => {\n      const value = env[key];\n      if (!value) {\n        redacted[key] = '';\n        return;\n      }\n\n      const lowerKey = key.toLowerCase();\n      const isSensitive = lowerKey.includes('key') ||\n                         lowerKey.includes('token') ||\n                         lowerKey.includes('secret') ||\n                         lowerKey.includes('password');\n\n      if (isSensitive) {\n        redacted[key] = value.length > 8\n          ? `${value.substring(0, 4)}...[REDACTED]`\n          : '[REDACTED]';\n      } else {\n        redacted[key] = value;\n      }\n    });\n\n    return redacted;\n  }\n}\n\n// Export singleton instance\nexport const redactor = KeyRedactor;\n"],"names":["KeyRedactor","API_KEY_PATTERNS","SENSITIVE_FIELDS","redact","text","showPrefix","redacted","forEach","pattern","replace","match","length","prefix","substring","redactObject","obj","deep","Object","keys","key","lowerKey","toLowerCase","isSensitive","some","field","includes","value","sanitize","sanitizeArgs","args","map","arg","containsSensitiveData","test","validate","warnings","index","push","safe","redactEnv","env","redactor"],"mappings":"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"}
+{"version":3,"sources":["../../../src/utils/key-redactor.js"],"sourcesContent":["/**\n * API Key Redaction Utility\n * Prevents sensitive data from leaking into logs, memory, or git commits\n */\n\nexport class KeyRedactor {\n  static API_KEY_PATTERNS = [\n    // Anthropic API keys\n    /sk-ant-[a-zA-Z0-9_-]{95,}/gi,\n\n    // OpenRouter API keys\n    /sk-or-[a-zA-Z0-9_-]{32,}/gi,\n\n    // Google/Gemini API keys\n    /AIza[a-zA-Z0-9_-]{35}/gi,\n\n    // Generic API keys\n    /[a-zA-Z0-9_-]{20,}API[a-zA-Z0-9_-]{20,}/gi,\n\n    // Bearer tokens\n    /Bearer\\s+[a-zA-Z0-9_\\-\\.]{20,}/gi,\n\n    // Environment variable format\n    /([A-Z_]+_API_KEY|[A-Z_]+_TOKEN|[A-Z_]+_SECRET)=[\"']?([^\"'\\s]+)[\"']?/gi,\n\n    // Supabase keys\n    /eyJ[a-zA-Z0-9_-]*\\.eyJ[a-zA-Z0-9_-]*\\.[a-zA-Z0-9_-]*/gi,\n  ];\n\n  static SENSITIVE_FIELDS = [\n    'apiKey',\n    'api_key',\n    'token',\n    'secret',\n    'password',\n    'private_key',\n    'privateKey',\n    'accessToken',\n    'access_token',\n    'refreshToken',\n    'refresh_token',\n  ];\n\n  /**\n   * Redact API keys and sensitive data from text\n   */\n  static redact(text, showPrefix = true) {\n    if (!text) return text;\n\n    let redacted = text;\n\n    // Redact using patterns\n    this.API_KEY_PATTERNS.forEach(pattern => {\n      redacted = redacted.replace(pattern, (match) => {\n        if (showPrefix && match.length > 8) {\n          const prefix = match.substring(0, 8);\n          return `${prefix}...[REDACTED]`;\n        }\n        return '[REDACTED_API_KEY]';\n      });\n    });\n\n    return redacted;\n  }\n\n  /**\n   * Redact sensitive fields in objects\n   */\n  static redactObject(obj, deep = true) {\n    if (!obj || typeof obj !== 'object') return obj;\n\n    const redacted = { ...obj };\n\n    Object.keys(redacted).forEach(key => {\n      const lowerKey = key.toLowerCase();\n\n      // Check if field name is sensitive\n      const isSensitive = this.SENSITIVE_FIELDS.some(field =>\n        lowerKey.includes(field)\n      );\n\n      if (isSensitive && typeof redacted[key] === 'string') {\n        const value = redacted[key];\n        if (value && value.length > 8) {\n          redacted[key] = `${value.substring(0, 4)}...[REDACTED]`;\n        } else {\n          redacted[key] = '[REDACTED]';\n        }\n      } else if (deep && typeof redacted[key] === 'object' && redacted[key] !== null) {\n        redacted[key] = this.redactObject(redacted[key], deep);\n      } else if (typeof redacted[key] === 'string') {\n        // Redact any API keys in string values\n        redacted[key] = this.redact(redacted[key]);\n      }\n    });\n\n    return redacted;\n  }\n\n  /**\n   * Sanitize text for safe logging\n   */\n  static sanitize(text) {\n    return this.redact(text, true);\n  }\n\n  /**\n   * Sanitize command arguments\n   */\n  static sanitizeArgs(args) {\n    return args.map(arg => {\n      // Check if arg is a flag value pair\n      if (arg.includes('key') || arg.includes('token') || arg.includes('secret')) {\n        return this.redact(arg);\n      }\n      return arg;\n    });\n  }\n\n  /**\n   * Check if text contains unredacted sensitive data\n   */\n  static containsSensitiveData(text) {\n    return this.API_KEY_PATTERNS.some(pattern => pattern.test(text));\n  }\n\n  /**\n   * Validate that text is safe for logging/storage\n   */\n  static validate(text) {\n    const warnings = [];\n\n    this.API_KEY_PATTERNS.forEach((pattern, index) => {\n      if (pattern.test(text)) {\n        warnings.push(`Potential API key detected (pattern ${index + 1})`);\n      }\n    });\n\n    return {\n      safe: warnings.length === 0,\n      warnings,\n    };\n  }\n\n  /**\n   * Redact environment variables\n   */\n  static redactEnv(env) {\n    const redacted = {};\n\n    Object.keys(env).forEach(key => {\n      const value = env[key];\n      if (!value) {\n        redacted[key] = '';\n        return;\n      }\n\n      const lowerKey = key.toLowerCase();\n      const isSensitive = lowerKey.includes('key') ||\n                         lowerKey.includes('token') ||\n                         lowerKey.includes('secret') ||\n                         lowerKey.includes('password');\n\n      if (isSensitive) {\n        redacted[key] = value.length > 8\n          ? `${value.substring(0, 4)}...[REDACTED]`\n          : '[REDACTED]';\n      } else {\n        redacted[key] = value;\n      }\n    });\n\n    return redacted;\n  }\n}\n\n// Export singleton instance\nexport const redactor = KeyRedactor;\n"],"names":["KeyRedactor","API_KEY_PATTERNS","SENSITIVE_FIELDS","redact","text","showPrefix","redacted","forEach","pattern","replace","match","length","prefix","substring","redactObject","obj","deep","Object","keys","key","lowerKey","toLowerCase","isSensitive","some","field","includes","value","sanitize","sanitizeArgs","args","map","arg","containsSensitiveData","test","validate","warnings","index","push","safe","redactEnv","env","redactor"],"mappings":"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"}

package/dist/src/utils/metrics-reader.js

@@ -1,13 +1,11 @@
-import { promises as fs } from 'fs';
-import path from 'path';
+import * as fs from 'fs/promises';
+import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
-let MetricsReader = class MetricsReader {
-    constructor(){
-        this.metricsDir = '.claude-flow/metrics';
-        this.sessionsDir = '.claude-flow/sessions';
-    }
+export class MetricsReader {
+    metricsDir = '.claude-flow/metrics';
+    sessionsDir = '.claude-flow/sessions';
     async getSystemMetrics() {
         try {
             const filePath = path.join(this.metricsDir, 'system-metrics.json');
@@ -18,15 +16,6 @@ let MetricsReader = class MetricsReader {
             return null;
         }
     }
-    async getTaskQueue() {
-        try {
-            const queueFile = '.claude-flow/tasks/queue.json';
-            const content = await fs.readFile(queueFile, 'utf8');
-            return JSON.parse(content);
-        } catch (error) {
-            return [];
-        }
-    }
     async getTaskMetrics() {
         try {
             const filePath = path.join(this.metricsDir, 'task-metrics.json');
@@ -47,30 +36,30 @@ let MetricsReader = class MetricsReader {
     }
     async getActiveAgents() {
         try {
+            const perfMetrics = await this.getPerformanceMetrics();
+            const sessionFiles = await this.getSessionFiles();
             const agents = [];
-            const agentsDir = '.claude-flow/agents';
-            try {
-                const agentFiles = await fs.readdir(agentsDir);
-                for (const file of agentFiles){
-                    if (file.endsWith('.json')) {
-                        try {
-                            const content = await fs.readFile(path.join(agentsDir, file), 'utf8');
-                            const agent = JSON.parse(content);
-                            agents.push(agent);
-                        } catch  {}
+            for (const file of sessionFiles){
+                try {
+                    const content = await fs.readFile(path.join(this.sessionsDir, 'pair', file), 'utf8');
+                    const sessionData = JSON.parse(content);
+                    if (sessionData.agents && Array.isArray(sessionData.agents)) {
+                        agents.push(...sessionData.agents);
                     }
-                }
-            } catch  {}
-            if (agents.length === 0) {
-                const sessionFiles = await this.getSessionFiles();
-                for (const file of sessionFiles){
-                    try {
-                        const content = await fs.readFile(path.join(this.sessionsDir, 'pair', file), 'utf8');
-                        const sessionData = JSON.parse(content);
-                        if (sessionData.agents && Array.isArray(sessionData.agents)) {
-                            agents.push(...sessionData.agents);
-                        }
-                    } catch  {}
+                } catch  {}
+            }
+            if (agents.length === 0 && perfMetrics) {
+                const activeCount = perfMetrics.activeAgents || 0;
+                const totalCount = perfMetrics.totalAgents || 0;
+                for(let i = 0; i < totalCount; i++){
+                    agents.push({
+                        id: `agent-${i + 1}`,
+                        name: `Agent ${i + 1}`,
+                        type: i === 0 ? 'orchestrator' : 'worker',
+                        status: i < activeCount ? 'active' : 'idle',
+                        activeTasks: i < activeCount ? 1 : 0,
+                        lastActivity: Date.now() - i * 1000
+                    });
                 }
             }
             return agents;
@@ -146,7 +135,7 @@ let MetricsReader = class MetricsReader {
     }
     async getMCPServerStatus() {
         try {
-            const { stdout } = await execAsync('ps aux | grep -E "mcp" | grep -v grep | wc -l');
+            const { stdout } = await execAsync('ps aux | grep -E "mcp-server\\.js|claude-flow mcp start" | grep -v grep | wc -l');
             const processCount = parseInt(stdout.trim(), 10);
             const { stdout: orchestratorOut } = await execAsync('ps aux | grep -E "claude-flow start" | grep -v grep | wc -l');
             const orchestratorRunning = parseInt(orchestratorOut.trim(), 10) > 0;
@@ -175,7 +164,6 @@ let MetricsReader = class MetricsReader {
             };
         }
     }
-};
-export { MetricsReader };
+}
 
 //# sourceMappingURL=metrics-reader.js.map