claude-flow 3.5.54 → 3.5.56

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

@@ -157,51 +157,12 @@ export const performanceTools = [
                 deep: { type: 'boolean', description: 'Deep analysis' },
             },
         },
-        handler: async (input) => {
-            const deep = input.deep;
-            const bottlenecks = [
-                {
-                    component: 'memory',
-                    severity: 'medium',
-                    metric: 'heap_usage',
-                    current: 78,
-                    threshold: 80,
-                    impact: 'May cause GC pressure',
-                    suggestion: 'Consider increasing heap size or optimizing memory usage',
-                },
-                {
-                    component: 'neural',
-                    severity: 'low',
-                    metric: 'inference_latency',
-                    current: 45,
-                    threshold: 100,
-                    impact: 'Within acceptable range',
-                    suggestion: 'Enable Flash Attention for further optimization',
-                },
-            ];
-            if (deep) {
-                bottlenecks.push({
-                    component: 'database',
-                    severity: 'low',
-                    metric: 'query_time',
-                    current: 15,
-                    threshold: 50,
-                    impact: 'Queries performing well',
-                    suggestion: 'Consider adding indexes for frequently accessed patterns',
-                });
-            }
-            const criticalCount = bottlenecks.filter(b => b.severity === 'critical').length;
-            const warningCount = bottlenecks.filter(b => b.severity === 'medium').length;
+        handler: async (_input) => {
             return {
-                status: criticalCount > 0 ? 'critical' : warningCount > 0 ? 'warning' : 'healthy',
-                bottlenecks,
-                summary: {
-                    total: bottlenecks.length,
-                    critical: criticalCount,
-                    warning: warningCount,
-                    info: bottlenecks.filter(b => b.severity === 'low').length,
-                },
-                analyzedAt: new Date().toISOString(),
+                success: true,
+                _stub: true,
+                message: 'Bottleneck detection not yet implemented. Use system_metrics for real CPU/memory data.',
+                bottlenecks: [],
             };
         },
     },
@@ -340,32 +301,12 @@ export const performanceTools = [
                 sampleRate: { type: 'number', description: 'Sampling rate' },
             },
         },
-        handler: async (input) => {
-            const target = input.target || 'all';
-            const duration = input.duration || 5;
-            // Simulate profiling
-            await new Promise(resolve => setTimeout(resolve, 100));
+        handler: async (_input) => {
             return {
-                target,
-                duration: `${duration}s`,
-                samples: Math.floor(duration * 100),
-                hotspots: [
-                    { function: 'vectorSearch', time: '35%', calls: 1500 },
-                    { function: 'embedText', time: '25%', calls: 800 },
-                    { function: 'agentCoordinate', time: '15%', calls: 200 },
-                    { function: 'memoryStore', time: '10%', calls: 500 },
-                    { function: 'other', time: '15%', calls: 3000 },
-                ],
-                memory: {
-                    peakHeap: '256MB',
-                    avgHeap: '180MB',
-                    gcPauses: 5,
-                    gcTime: '50ms',
-                },
-                recommendations: [
-                    'vectorSearch: Consider batch processing for bulk operations',
-                    'embedText: Enable caching for repeated queries',
-                ],
+                success: true,
+                _stub: true,
+                message: 'Profiling not yet implemented. Use performance_benchmark for real micro-benchmarks.',
+                hotspots: [],
             };
         },
     },
@@ -380,48 +321,12 @@ export const performanceTools = [
                 aggressive: { type: 'boolean', description: 'Apply aggressive optimizations' },
             },
         },
-        handler: async (input) => {
-            const target = input.target || 'all';
-            const aggressive = input.aggressive;
-            const optimizations = {
-                memory: [
-                    'Enabled Int8 quantization (3.92x compression)',
-                    'Activated gradient checkpointing',
-                    'Configured memory pooling',
-                ],
-                latency: [
-                    'Enabled response caching (95% hit rate)',
-                    'Activated batch processing',
-                    'Configured connection pooling',
-                ],
-                throughput: [
-                    'Enabled parallel processing',
-                    'Configured worker pool (4 workers)',
-                    'Activated request pipelining',
-                ],
-            };
-            const applied = [];
-            if (target === 'all') {
-                Object.values(optimizations).forEach(opts => applied.push(...opts));
-            }
-            else {
-                applied.push(...(optimizations[target] || []));
-            }
-            if (aggressive) {
-                applied.push('Enabled aggressive GC');
-                applied.push('Activated speculative execution');
-            }
+        handler: async (_input) => {
             return {
-                target,
-                aggressive,
-                applied,
-                improvements: {
-                    memory: '-50%',
-                    latency: '-40%',
-                    throughput: '+60%',
-                },
-                status: 'optimized',
-                timestamp: new Date().toISOString(),
+                success: true,
+                _stub: true,
+                message: 'Automatic optimization not yet implemented. No changes were made.',
+                optimizations: [],
             };
         },
     },

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

@@ -171,12 +171,34 @@ export const sessionTools = [
                 }
             }
             if (session) {
-                // Restore data to respective stores
+                // Restore data to respective stores (legacy JSON for backward compat)
                 if (session.data?.memory) {
                     const memoryDir = join(getProjectCwd(), STORAGE_DIR, 'memory');
                     if (!existsSync(memoryDir))
                         mkdirSync(memoryDir, { recursive: true });
                     writeFileSync(join(memoryDir, 'store.json'), JSON.stringify(session.data.memory, null, 2), 'utf-8');
+                    // Also populate active sql.js SQLite database so memory-tools can find entries
+                    try {
+                        const { storeEntry } = await import('../memory/memory-initializer.js');
+                        const memoryData = session.data.memory;
+                        if (memoryData.entries) {
+                            for (const entry of Object.values(memoryData.entries)) {
+                                const key = entry.key || entry.id || '';
+                                const value = entry.value || entry.content || '';
+                                if (key && value) {
+                                    await storeEntry({
+                                        key,
+                                        value,
+                                        namespace: entry.namespace || 'restored',
+                                        upsert: true,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Legacy JSON restore is the fallback -- sql.js import may not be available
+                    }
                 }
                 if (session.data?.tasks) {
                     const taskDir = join(getProjectCwd(), STORAGE_DIR, 'tasks');

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

@@ -92,9 +92,9 @@ export const systemTools = [
                 version: PKG_VERSION,
                 components: {
                     swarm: { status: 'running', health: metrics.health },
-                    memory: { status: 'running', health: 0.95 },
-                    neural: { status: 'running', health: 0.90 },
-                    mcp: { status: 'running', health: 1.0 },
+                    memory: { status: 'unknown', _note: 'Health not measured — use system_health for real checks' },
+                    neural: { status: 'unknown', _note: 'Health not measured — use system_health for real checks' },
+                    mcp: { status: 'unknown', _note: 'Health not measured — use system_health for real checks' },
                 },
                 lastCheck: new Date().toISOString(),
             };
@@ -194,43 +194,89 @@ export const systemTools = [
         handler: async (input) => {
             const metrics = loadMetrics();
             const checks = [];
-            // Core checks
+            const projectCwd = getProjectCwd();
+            // Memory DB check — verify the store file exists
+            {
+                const t0 = performance.now();
+                const memoryDbPath = join(projectCwd, '.claude-flow', 'memory', 'store.json');
+                const memoryExists = existsSync(memoryDbPath);
+                const elapsed = performance.now() - t0;
+                checks.push({
+                    name: 'memory',
+                    status: memoryExists ? 'healthy' : 'degraded',
+                    latency: Math.round(elapsed * 100) / 100,
+                    message: memoryExists ? undefined : 'Memory store not found — run memory init',
+                });
+            }
+            // Config check — verify config file exists
+            {
+                const t0 = performance.now();
+                const configPath = join(projectCwd, '.claude-flow', 'config.json');
+                const altConfigPath = join(projectCwd, 'claude-flow.config.json');
+                const configExists = existsSync(configPath) || existsSync(altConfigPath);
+                const elapsed = performance.now() - t0;
+                checks.push({
+                    name: 'config',
+                    status: configExists ? 'healthy' : 'degraded',
+                    latency: Math.round(elapsed * 100) / 100,
+                    message: configExists ? undefined : 'Config file not found — run init',
+                });
+            }
+            // MCP check — this process is the MCP server if stdin is piped
+            {
+                const isStdio = !process.stdin.isTTY;
+                checks.push({
+                    name: 'mcp',
+                    status: isStdio ? 'healthy' : 'unknown',
+                    message: isStdio ? 'MCP stdio server running (this process)' : 'Not running as MCP server',
+                });
+            }
+            // Swarm — cannot verify real connectivity, report unknown
             checks.push({
                 name: 'swarm',
-                status: 'healthy',
-                latency: 5 + Math.random() * 10,
-            });
-            checks.push({
-                name: 'memory',
-                status: 'healthy',
-                latency: 2 + Math.random() * 5,
-            });
-            checks.push({
-                name: 'mcp',
-                status: 'healthy',
-                latency: 1 + Math.random() * 3,
+                status: 'unknown',
+                message: 'Swarm connectivity not monitored — check coordination store manually',
             });
+            // Neural — cannot verify, report unknown
             checks.push({
                 name: 'neural',
-                status: metrics.health >= 0.7 ? 'healthy' : 'degraded',
-                latency: 10 + Math.random() * 20,
+                status: 'unknown',
+                message: 'Neural network health not monitored',
             });
             if (input.deep) {
-                checks.push({
-                    name: 'disk',
-                    status: 'healthy',
-                    latency: 50 + Math.random() * 100,
-                });
+                // Disk check — real free space check via os module
+                {
+                    const t0 = performance.now();
+                    const freeMem = os.freemem();
+                    const totalMem = os.totalmem();
+                    const elapsed = performance.now() - t0;
+                    // Use memory as a proxy; real disk check would need statvfs
+                    checks.push({
+                        name: 'disk',
+                        status: 'unknown',
+                        latency: Math.round(elapsed * 100) / 100,
+                        message: 'Disk space check not implemented — use os-level tools',
+                    });
+                }
+                // Network — cannot verify without making a request
                 checks.push({
                     name: 'network',
-                    status: 'healthy',
-                    latency: 20 + Math.random() * 30,
-                });
-                checks.push({
-                    name: 'database',
-                    status: 'healthy',
-                    latency: 15 + Math.random() * 25,
+                    status: 'unknown',
+                    message: 'Network connectivity not monitored',
                 });
+                // Database — check if coordination store exists
+                {
+                    const t0 = performance.now();
+                    const coordPath = join(projectCwd, '.claude-flow', 'coordination', 'store.json');
+                    const dbExists = existsSync(coordPath);
+                    const elapsed = performance.now() - t0;
+                    checks.push({
+                        name: 'database',
+                        status: dbExists ? 'healthy' : 'unknown',
+                        latency: Math.round(elapsed * 100) / 100,
+                        message: dbExists ? undefined : 'Coordination store not found',
+                    });
+                }
             }
             const healthy = checks.filter(c => c.status === 'healthy').length;
             const total = checks.length;

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

@@ -205,7 +205,7 @@ export const taskTools = [
                 saveTaskStore(store);
                 // Sync assigned agents back to idle and increment taskCount
                 if (task.assignedTo.length > 0) {
-                    const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents.json');
+                    const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
                     try {
                         let agentStore = { agents: {} };
                         if (existsSync(agentStorePath)) {
@@ -309,7 +309,7 @@ export const taskTools = [
             }
             const previouslyAssigned = [...task.assignedTo];
             // Load agent store to sync worker state
-            const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents.json');
+            const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
             let agentStore = { agents: {} };
             try {
                 if (existsSync(agentStorePath)) {
@@ -354,7 +354,7 @@ export const taskTools = [
             }
             saveTaskStore(store);
             // Save agent store
-            const agentDir = join(getProjectCwd(), STORAGE_DIR);
+            const agentDir = join(getProjectCwd(), STORAGE_DIR, 'agents');
             if (!existsSync(agentDir)) {
                 mkdirSync(agentDir, { recursive: true });
             }

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

@@ -217,30 +217,25 @@ export const workflowTools = [
             workflow.status = 'running';
             workflow.startedAt = new Date().toISOString();
             workflow.currentStep = input.startFromStep || 0;
-            // Execute steps (in real implementation, this would be async/event-driven)
+            // Set steps to pending — actual execution requires agent assignment via task tools
             const results = [];
             for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
                 const step = workflow.steps[i];
-                step.status = 'running';
-                step.startedAt = new Date().toISOString();
-                // For now, mark as completed (real implementation would execute actual tasks)
-                step.status = 'completed';
-                step.completedAt = new Date().toISOString();
-                step.result = { executed: true, stepType: step.type };
-                results.push({ stepId: step.stepId, status: step.status });
-                workflow.currentStep = i + 1;
+                step.status = 'pending';
+                results.push({
+                    stepId: step.stepId,
+                    status: step.status,
+                    _note: 'Workflow execution tracks state. Actual step execution requires agent assignment via task tools.',
+                });
             }
-            workflow.status = 'completed';
-            workflow.completedAt = new Date().toISOString();
             saveWorkflowStore(store);
             return {
                 workflowId,
                 status: workflow.status,
-                stepsExecuted: results.length,
+                totalSteps: results.length,
                 results,
                 startedAt: workflow.startedAt,
-                completedAt: workflow.completedAt,
-                duration: new Date(workflow.completedAt).getTime() - new Date(workflow.startedAt).getTime(),
+                _note: 'Workflow is now running. Steps are in pending state and must be executed via task tools.',
             };
         },
     },
@@ -387,27 +382,21 @@ export const workflowTools = [
             }
             workflow.status = 'running';
             saveWorkflowStore(store);
-            // Continue execution from current step
-            const results = [];
-            for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
-                const step = workflow.steps[i];
-                step.status = 'running';
-                step.startedAt = new Date().toISOString();
-                step.status = 'completed';
-                step.completedAt = new Date().toISOString();
-                step.result = { executed: true };
-                results.push({ stepId: step.stepId, status: step.status });
-                workflow.currentStep = i + 1;
-            }
-            workflow.status = 'completed';
-            workflow.completedAt = new Date().toISOString();
-            saveWorkflowStore(store);
+            // Report current step states — do not auto-complete them
+            const stepStates = workflow.steps.map(step => ({
+                stepId: step.stepId,
+                name: step.name,
+                status: step.status,
+            }));
+            const remainingSteps = workflow.steps.length - workflow.currentStep;
             return {
                 workflowId,
                 status: workflow.status,
                 resumed: true,
-                stepsExecuted: results.length,
-                completedAt: workflow.completedAt,
+                currentStep: workflow.currentStep,
+                remainingSteps,
+                steps: stepStates,
+                _note: 'Workflow resumed. Steps remain in their current state and must be executed via task tools.',
             };
         },
     },

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.54",
+  "version": "3.5.56",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",