@claude-flow/cli 3.5.55 → 3.5.56

package/dist/src/mcp-tools/hooks-tools.js

@@ -2,7 +2,7 @@
  * Hooks MCP Tools
  * Provides intelligent hooks functionality via MCP protocol
  */
-import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { getProjectCwd } from './types.js';
 // Real vector search functions - lazy loaded to avoid circular imports
@@ -878,31 +878,44 @@ export const hooksMetrics = {
     },
     handler: async (params) => {
         const period = params.period || '24h';
+        // Try to read real counts from memory store
+        const store = loadMemoryStore();
+        const entries = Object.values(store.entries);
+        // Count patterns by looking at stored pattern entries
+        const patternEntries = entries.filter(e => e.key.includes('pattern'));
+        const routingEntries = entries.filter(e => e.key.includes('route') || e.key.includes('routing'));
+        const taskEntries = entries.filter(e => e.key.includes('task'));
+        if (entries.length === 0) {
+            return {
+                _stub: true,
+                message: 'No metrics data available. Metrics are collected from hooks_post-task and hooks_route calls.',
+                period,
+                patterns: { total: 0, successful: 0, failed: 0, avgConfidence: null },
+                agents: { routingAccuracy: null, totalRoutes: 0, topAgent: null },
+                commands: { totalExecuted: 0, successRate: null, avgRiskScore: null },
+                lastUpdated: new Date().toISOString(),
+            };
+        }
         return {
             period,
             patterns: {
-                total: 15,
-                successful: 12,
-                failed: 3,
-                avgConfidence: 0.85,
+                total: patternEntries.length,
+                successful: null,
+                failed: null,
+                avgConfidence: null,
             },
             agents: {
-                routingAccuracy: 0.87,
-                totalRoutes: 42,
-                topAgent: 'coder',
+                routingAccuracy: null,
+                totalRoutes: routingEntries.length,
+                topAgent: null,
             },
             commands: {
-                totalExecuted: 128,
-                successRate: 0.94,
-                avgRiskScore: 0.15,
-            },
-            performance: {
-                flashAttention: '2.49x-7.47x speedup',
-                memoryReduction: '50-75% reduction',
-                searchImprovement: '150x-12,500x faster',
-                tokenReduction: '32.3% fewer tokens',
+                totalExecuted: taskEntries.length,
+                successRate: null,
+                avgRiskScore: null,
             },
-            status: 'healthy',
+            dataSource: 'memory-store',
+            entriesFound: entries.length,
             lastUpdated: new Date().toISOString(),
         };
     },
@@ -1172,14 +1185,31 @@ export const hooksExplain = {
                 });
             }
         }
+        // Calculate real historical success rate from routing outcomes file
+        let historicalSuccess = null;
+        let historicalNote = 'No historical data yet';
+        try {
+            const outcomesPath = join(resolve('.'), '.claude-flow/routing-outcomes.json');
+            if (existsSync(outcomesPath)) {
+                const data = JSON.parse(readFileSync(outcomesPath, 'utf-8'));
+                const outcomes = data.outcomes || [];
+                if (outcomes.length > 0) {
+                    historicalSuccess = outcomes.filter(o => o.success).length / outcomes.length;
+                    historicalNote = `Calculated from ${outcomes.length} recorded outcomes`;
+                }
+            }
+        }
+        catch {
+            // File unreadable; leave as null
+        }
         return {
             task,
             explanation: `The routing decision was made based on keyword analysis of the task description. ` +
                 `The task contains keywords that match the "${suggestion.agents[0]}" specialization with ${(suggestion.confidence * 100).toFixed(0)}% confidence.`,
             factors: [
                 { factor: 'Keyword Match', weight: 0.4, value: suggestion.confidence, impact: 'Primary routing signal' },
-                { factor: 'Historical Success', weight: 0.3, value: 0.87, impact: 'Past task success rate' },
-                { factor: 'Agent Availability', weight: 0.2, value: 0.95, impact: 'All suggested agents available' },
+                { factor: 'Historical Success', weight: 0.3, value: historicalSuccess, impact: historicalNote },
+                { factor: 'Agent Availability', weight: 0.2, value: null, impact: 'Agent availability tracking not implemented' },
                 { factor: 'Task Complexity', weight: 0.1, value: task.length > 100 ? 0.8 : 0.3, impact: 'Complexity assessment' },
             ],
             patterns: matchedPatterns.length > 0 ? matchedPatterns : [
@@ -1191,7 +1221,9 @@ export const hooksExplain = {
                 reasoning: [
                     `Task analysis identified ${matchedPatterns.length || 1} relevant patterns`,
                     `"${suggestion.agents[0]}" has highest capability match for this task type`,
-                    `Historical success rate for similar tasks: 87%`,
+                    historicalSuccess !== null
+                        ? `Historical success rate for similar tasks: ${(historicalSuccess * 100).toFixed(0)}%`
+                        : `No historical outcome data available yet`,
                     `Confidence threshold met (${(suggestion.confidence * 100).toFixed(0)}% >= 70%)`,
                 ],
             },
@@ -1211,28 +1243,21 @@ export const hooksPretrain = {
         },
     },
     handler: async (params) => {
-        const path = params.path || '.';
+        const repoPath = params.path || '.';
         const depth = params.depth || 'medium';
-        const startTime = Date.now();
-        // Scale analysis results by depth level
-        const multiplier = depth === 'deep' ? 3 : depth === 'shallow' ? 1 : 2;
         return {
-            path,
+            success: true,
+            _stub: true,
+            message: 'Pre-training requires running the pretrain CLI command. This hook provides status only.',
+            path: repoPath,
             depth,
             stats: {
-                filesAnalyzed: 42 * multiplier,
-                patternsExtracted: 15 * multiplier,
-                strategiesLearned: 8 * multiplier,
-                trajectoriesEvaluated: 23 * multiplier,
-                contradictionsResolved: 3,
-            },
-            pipeline: {
-                retrieve: { status: 'completed', duration: 120 * multiplier },
-                judge: { status: 'completed', duration: 180 * multiplier },
-                distill: { status: 'completed', duration: 90 * multiplier },
-                consolidate: { status: 'completed', duration: 60 * multiplier },
+                filesAnalyzed: null,
+                patternsExtracted: null,
+                strategiesLearned: null,
+                trajectoriesEvaluated: null,
+                contradictionsResolved: null,
             },
-            duration: Date.now() - startTime + (500 * multiplier),
         };
     },
 };
@@ -1335,12 +1360,14 @@ export const hooksTransfer = {
             'command-risk': sourceEntries.filter(e => e.key.includes('command') || e.metadata?.type === 'command-risk').length,
             'agent-success': sourceEntries.filter(e => e.key.includes('agent') || e.metadata?.type === 'agent-success').length,
         };
-        // If source has no patterns, provide demo data
+        // If source has no patterns, report honestly instead of substituting demo data
         if (Object.values(byType).every(v => v === 0)) {
-            byType['file-patterns'] = 8;
-            byType['task-routing'] = 12;
-            byType['command-risk'] = 5;
-            byType['agent-success'] = 15;
+            return {
+                success: false,
+                message: 'No patterns found in source project',
+                sourcePath,
+                transferred: 0,
+            };
         }
         if (filter) {
             Object.keys(byType).forEach(key => {
@@ -1350,6 +1377,7 @@ export const hooksTransfer = {
         }
         const total = Object.values(byType).reduce((a, b) => a + b, 0);
         return {
+            success: true,
             sourcePath,
             transferred: {
                 total,
@@ -1364,7 +1392,7 @@ export const hooksTransfer = {
                 avgConfidence: 0.82 + (minConfidence > 0.8 ? 0.1 : 0),
                 avgAge: '3 days',
             },
-            dataSource: Object.values(sourceStore.entries).length > 0 ? 'source-project' : 'demo-data',
+            dataSource: 'source-project',
         };
     },
 };
@@ -1470,6 +1498,25 @@ export const hooksSessionEnd = {
                 // Daemon may not be running
             }
         }
+        // Read actual counts from stores
+        const store = loadMemoryStore();
+        const allEntries = Object.values(store.entries);
+        const taskCount = allEntries.filter(e => e.key.includes('task')).length;
+        const agentCount = allEntries.filter(e => e.key.includes('agent')).length;
+        const patternCount = allEntries.filter(e => e.key.includes('pattern')).length;
+        const trajectoryCount = activeTrajectories.size;
+        // Check for pending-insights.jsonl
+        let insightCount = 0;
+        try {
+            const insightsPath = resolve(join('.claude-flow', 'data', 'pending-insights.jsonl'));
+            if (existsSync(insightsPath)) {
+                const content = readFileSync(insightsPath, 'utf-8').trim();
+                insightCount = content ? content.split('\n').length : 0;
+            }
+        }
+        catch {
+            // File not available
+        }
         // Phase 5: Wire ReflexionMemory session end + NightlyLearner consolidation via bridge
         let sessionPersistence = null;
         try {
@@ -1477,8 +1524,8 @@ export const hooksSessionEnd = {
             const result = await bridge.bridgeSessionEnd({
                 sessionId,
                 summary: saveState ? 'Session ended with state saved' : 'Session ended',
-                tasksCompleted: 12,
-                patternsLearned: 8,
+                tasksCompleted: taskCount,
+                patternsLearned: patternCount,
             });
             if (result) {
                 sessionPersistence = {
@@ -1497,17 +1544,15 @@ export const hooksSessionEnd = {
             daemon: { stopped: daemonStopped },
             sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
             summary: {
-                tasksExecuted: 12,
-                tasksSucceeded: 10,
-                tasksFailed: 2,
-                commandsExecuted: 45,
-                filesModified: 23,
-                agentsSpawned: 5,
+                tasksExecuted: taskCount,
+                filesModified: 0,
+                agentsSpawned: agentCount,
+                pendingInsights: insightCount,
+                memoryEntries: allEntries.length,
             },
             learningUpdates: {
-                patternsLearned: 8,
-                trajectoriesRecorded: 12,
-                confidenceImproved: 0.05,
+                patternsLearned: patternCount,
+                trajectoriesRecorded: trajectoryCount,
             },
         };
     },
@@ -1726,13 +1771,60 @@ export const hooksIntelligenceReset = {
         properties: {},
     },
     handler: async () => {
+        const cwd = getProjectCwd();
+        const cleared = {
+            trajectories: 0,
+            patterns: 0,
+            dataFiles: 0,
+            neuralFiles: 0,
+        };
+        const deletedFiles = [];
+        // Clear intelligence data files if they exist
+        const dataFiles = [
+            join(cwd, '.claude-flow', 'data', 'auto-memory-store.json'),
+            join(cwd, '.claude-flow', 'data', 'graph-state.json'),
+            join(cwd, '.claude-flow', 'data', 'ranked-context.json'),
+        ];
+        for (const filePath of dataFiles) {
+            if (existsSync(filePath)) {
+                try {
+                    unlinkSync(filePath);
+                    cleared.dataFiles++;
+                    deletedFiles.push(filePath);
+                }
+                catch {
+                    // Skip files that cannot be deleted
+                }
+            }
+        }
+        // Clear neural directory if it exists
+        const neuralDir = join(cwd, '.claude-flow', 'neural');
+        if (existsSync(neuralDir)) {
+            try {
+                const files = readdirSync(neuralDir);
+                for (const file of files) {
+                    try {
+                        const filePath = join(neuralDir, file);
+                        unlinkSync(filePath);
+                        cleared.neuralFiles++;
+                        deletedFiles.push(filePath);
+                    }
+                    catch {
+                        // Skip files that cannot be deleted
+                    }
+                }
+            }
+            catch {
+                // Directory read failed
+            }
+        }
+        // Clear in-memory trajectories
+        cleared.trajectories = activeTrajectories.size;
+        activeTrajectories.clear();
         return {
             reset: true,
-            cleared: {
-                trajectories: 156,
-                patterns: 89,
-                hnswIndex: 12500,
-            },
+            cleared,
+            deletedFiles,
             timestamp: new Date().toISOString(),
         };
     },