claude-flow 3.5.58 → 3.5.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.58",
+  "version": "3.5.60",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -62,8 +62,8 @@
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@ruvector/attention": "^0.1.3",
     "@ruvector/core": "^0.1.30",
-    "@ruvector/router": "^0.1.27",
-    "@ruvector/router-linux-x64-gnu": "^0.1.27",
+    "@ruvector/router": "^0.1.30",
+    "@ruvector/router-linux-x64-gnu": "^0.1.30",
     "@ruvector/sona": "^0.1.5",
     "agentdb": "^3.0.0-alpha.9",
     "agentic-flow": "^2.0.7"

package/v3/@claude-flow/cli/dist/src/init/statusline-generator.js

@@ -198,30 +198,59 @@ function getModelName() {
   return 'Claude Code';
 }
 
-// Get learning stats from memory database (pure stat calls)
+// Get learning stats from real data sources (no heuristics)
 function getLearningStats() {
-  const memoryPaths = [
-    path.join(CWD, '.swarm', 'memory.db'),
-    path.join(CWD, '.claude-flow', 'memory.db'),
-    path.join(CWD, '.claude', 'memory.db'),
-    path.join(CWD, 'data', 'memory.db'),
-    path.join(CWD, '.agentdb', 'memory.db'),
-  ];
+  let patterns = 0;
+  let sessions = 0;
 
-  for (const dbPath of memoryPaths) {
-    const stat = safeStat(dbPath);
-    if (stat) {
-      const sizeKB = stat.size / 1024;
-      const patterns = Math.floor(sizeKB / 2);
-      return {
-        patterns,
-        sessions: Math.max(1, Math.floor(patterns / 10)),
-      };
+  // 1. Count real patterns from intelligence pattern store
+  const patternStorePath = path.join(CWD, '.claude-flow', 'data', 'patterns.json');
+  try {
+    if (fs.existsSync(patternStorePath)) {
+      const data = JSON.parse(fs.readFileSync(patternStorePath, 'utf-8'));
+      if (Array.isArray(data)) patterns = data.length;
+      else if (data && data.patterns) patterns = Array.isArray(data.patterns) ? data.patterns.length : Object.keys(data.patterns).length;
+    }
+  } catch { /* ignore */ }
+
+  // 2. Count patterns from auto-memory-store (real entries, not file size)
+  if (patterns === 0) {
+    const autoStorePath = path.join(CWD, '.claude-flow', 'data', 'auto-memory-store.json');
+    try {
+      if (fs.existsSync(autoStorePath)) {
+        const data = JSON.parse(fs.readFileSync(autoStorePath, 'utf-8'));
+        if (Array.isArray(data)) patterns = data.length;
+        else if (data && data.entries) patterns = data.entries.length;
+      }
+    } catch { /* ignore */ }
+  }
+
+  // 3. Count patterns from memory.db using row count (sqlite header bytes 28-31)
+  if (patterns === 0) {
+    const memoryPaths = [
+      path.join(CWD, '.claude-flow', 'memory.db'),
+      path.join(CWD, 'data', 'memory.db'),
+      path.join(CWD, '.swarm', 'memory.db'),
+    ];
+    for (const dbPath of memoryPaths) {
+      try {
+        if (fs.existsSync(dbPath)) {
+          // Read SQLite header: page count at offset 28 (4 bytes big-endian)
+          const fd = fs.openSync(dbPath, 'r');
+          const buf = Buffer.alloc(4);
+          fs.readSync(fd, buf, 0, 4, 28);
+          fs.closeSync(fd);
+          const pageCount = buf.readUInt32BE(0);
+          // Each page typically holds ~10-50 rows; use page count as conservative estimate
+          // But report 0 if DB exists but has only schema pages (< 3)
+          patterns = pageCount > 2 ? pageCount - 2 : 0;
+          break;
+        }
+      } catch { /* ignore */ }
     }
   }
 
-  // Check session files count
-  let sessions = 0;
+  // 4. Count real session files
   try {
     const sessDir = path.join(CWD, '.claude', 'sessions');
     if (fs.existsSync(sessDir)) {
@@ -229,7 +258,17 @@ function getLearningStats() {
     }
   } catch { /* ignore */ }
 
-  return { patterns: 0, sessions };
+  // 5. Count session files from claude-flow
+  if (sessions === 0) {
+    try {
+      const cfSessDir = path.join(CWD, '.claude-flow', 'sessions');
+      if (fs.existsSync(cfSessDir)) {
+        sessions = fs.readdirSync(cfSessDir).filter(f => f.endsWith('.json')).length;
+      }
+    } catch { /* ignore */ }
+  }
+
+  return { patterns, sessions };
 }
 
 // V3 progress from metrics files (pure file reads)
@@ -241,12 +280,12 @@ function getV3Progress() {
   let dddProgress = dddData ? (dddData.progress || 0) : 0;
   let domainsCompleted = Math.min(5, Math.floor(dddProgress / 20));
 
+  // Only derive DDD progress from real ddd-progress.json or real pattern data
+  // Don't inflate domains from pattern count — 0 means no DDD work tracked
   if (dddProgress === 0 && learning.patterns > 0) {
-    if (learning.patterns >= 500) domainsCompleted = 5;
-    else if (learning.patterns >= 200) domainsCompleted = 4;
-    else if (learning.patterns >= 100) domainsCompleted = 3;
-    else if (learning.patterns >= 50) domainsCompleted = 2;
-    else if (learning.patterns >= 10) domainsCompleted = 1;
+    // Conservative: only count domains if we have substantial real pattern data
+    // Each domain requires ~100 real stored patterns to claim completion
+    domainsCompleted = Math.min(5, Math.floor(learning.patterns / 100));
     dddProgress = Math.floor((domainsCompleted / totalDomains) * 100);
   }
 
@@ -338,28 +377,18 @@ function getSystemMetrics() {
   if (learningData && learningData.intelligence && learningData.intelligence.score !== undefined) {
     intelligencePct = Math.min(100, Math.floor(learningData.intelligence.score));
   } else {
+    // Use real data only — patterns from actual store, vectors from actual DB
     const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 20)) : 0;
     const fromVectors = agentdb.vectorCount > 0 ? Math.min(100, Math.floor(agentdb.vectorCount / 20)) : 0;
     intelligencePct = Math.max(fromPatterns, fromVectors);
   }
-
-  // Maturity fallback (pure fs checks, no git exec)
-  if (intelligencePct === 0) {
-    let score = 0;
-    if (fs.existsSync(path.join(CWD, '.claude'))) score += 15;
-    const srcDirs = ['src', 'lib', 'app', 'packages', 'v3'];
-    for (const d of srcDirs) { if (fs.existsSync(path.join(CWD, d))) { score += 15; break; } }
-    const testDirs = ['tests', 'test', '__tests__', 'spec'];
-    for (const d of testDirs) { if (fs.existsSync(path.join(CWD, d))) { score += 10; break; } }
-    const cfgFiles = ['package.json', 'tsconfig.json', 'pyproject.toml', 'Cargo.toml', 'go.mod'];
-    for (const f of cfgFiles) { if (fs.existsSync(path.join(CWD, f))) { score += 5; break; } }
-    intelligencePct = Math.min(100, score);
-  }
+  // No fake fallback — 0% means no real learning data exists
 
   if (learningData && learningData.sessions && learningData.sessions.total !== undefined) {
     contextPct = Math.min(100, learningData.sessions.total * 5);
   } else {
-    contextPct = Math.min(100, Math.floor(learning.sessions * 5));
+    // Real session count only — no heuristic derivation from patterns
+    contextPct = learning.sessions > 0 ? Math.min(100, learning.sessions * 5) : 0;
   }
 
   // Sub-agents from file metrics (no ps aux)

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -23,6 +23,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { trackRequest } from './mcp-tools/request-tracker.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -389,6 +390,7 @@ export class MCPServerManager extends EventEmitter {
                     }
                     try {
                         const result = await callMCPTool(toolName, toolParams, { sessionId });
+                        trackRequest(toolName, true);
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
@@ -396,6 +398,7 @@ export class MCPServerManager extends EventEmitter {
                         };
                     }
                     catch (error) {
+                        trackRequest(toolName, false);
                         return {
                             jsonrpc: '2.0',
                             id: message.id,

package/v3/@claude-flow/cli/dist/src/mcp-tools/daa-tools.js

@@ -83,6 +83,17 @@ export const daaTools = [
             };
             store.agents[id] = agent;
             saveDAAStore(store);
+            // Store agent in AgentDB for searchable agent registry
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `daa-agent-${id}`,
+                    value: JSON.stringify({ id: agent.id, name: agent.name, type: agent.type, cognitivePattern: agent.cognitivePattern }),
+                    namespace: 'daa-agents',
+                    tags: [agent.type, agent.cognitivePattern],
+                });
+            }
+            catch { /* AgentDB not available */ }
             return {
                 success: true,
                 agent: {
@@ -215,6 +226,20 @@ export const daaTools = [
             }
             workflow.status = 'running';
             saveDAAStore(store);
+            // Store workflow state in AgentDB for tracking
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `workflow-${workflowId}`,
+                    value: JSON.stringify({
+                        id: workflowId, status: 'running',
+                        steps: workflow.steps.length, strategy: workflow.strategy,
+                        startedAt: new Date().toISOString(),
+                    }),
+                    namespace: 'daa-workflows',
+                });
+            }
+            catch { /* AgentDB not available */ }
             return {
                 success: true,
                 workflowId,

package/v3/@claude-flow/cli/dist/src/mcp-tools/github-tools.d.ts

@@ -1,12 +1,8 @@
 /**
  * GitHub MCP Tools for CLI
  *
- * V2 Compatibility - GitHub integration tools
- *
- * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT only.
- * - NO actual GitHub API calls are made
- * - Data is stored locally for workflow coordination
- * - For real GitHub operations, use `gh` CLI or GitHub MCP server
+ * Real GitHub integration via `gh` CLI and `git` commands.
+ * Falls back to local state management when CLI tools are unavailable.
  */
 import { type MCPTool } from './types.js';
 export declare const githubTools: MCPTool[];