claude-flow 3.5.54 → 3.5.56

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

@@ -68,30 +68,19 @@ export const githubTools = [
                 name: repo,
                 branch,
                 lastAnalyzed: new Date().toISOString(),
-                metrics: {
-                    commits: Math.floor(Math.random() * 1000) + 100,
-                    branches: Math.floor(Math.random() * 20) + 1,
-                    contributors: Math.floor(Math.random() * 50) + 1,
-                    openIssues: Math.floor(Math.random() * 30),
-                    openPRs: Math.floor(Math.random() * 10),
-                },
             };
             store.repos[repoKey] = repoInfo;
             saveGitHubStore(store);
             return {
-                success: true,
-                repository: repoKey,
-                branch,
-                metrics: repoInfo.metrics,
-                analysis: {
-                    languages: ['TypeScript', 'JavaScript', 'JSON'],
-                    mainLanguage: 'TypeScript',
-                    codeQuality: 'A',
-                    testCoverage: `${Math.floor(Math.random() * 30) + 70}%`,
-                    dependencies: Math.floor(Math.random() * 50) + 20,
-                    securityIssues: Math.floor(Math.random() * 3),
+                success: false,
+                _stub: true,
+                message: 'GitHub tools are local-only stubs. For real GitHub operations, use the gh CLI or GitHub MCP server directly.',
+                localData: {
+                    repository: repoKey,
+                    branch,
+                    lastAnalyzed: repoInfo.lastAnalyzed,
+                    storedRepos: Object.keys(store.repos),
                 },
-                lastAnalyzed: repoInfo.lastAnalyzed,
             };
         },
     },
@@ -147,13 +136,11 @@ export const githubTools = [
             }
             if (action === 'review') {
                 return {
-                    success: true,
-                    action: 'reviewed',
-                    prNumber: input.prNumber,
-                    review: {
-                        status: 'approved',
-                        comments: [],
-                        suggestion: 'LGTM',
+                    success: false,
+                    _stub: true,
+                    message: 'GitHub tools are local-only stubs. PR review requires actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
+                    localData: {
+                        prNumber: input.prNumber,
                     },
                 };
             }
@@ -283,44 +270,16 @@ export const githubTools = [
         },
         handler: async (input) => {
             const action = input.action || 'list';
-            if (action === 'list') {
-                return {
-                    success: true,
-                    workflows: [
-                        { id: 'ci.yml', name: 'CI', status: 'active', lastRun: new Date().toISOString() },
-                        { id: 'release.yml', name: 'Release', status: 'active', lastRun: new Date().toISOString() },
-                        { id: 'test.yml', name: 'Tests', status: 'active', lastRun: new Date().toISOString() },
-                    ],
-                };
-            }
-            if (action === 'trigger') {
-                return {
-                    success: true,
-                    action: 'triggered',
-                    workflowId: input.workflowId,
-                    ref: input.ref || 'main',
-                    runId: `run-${Date.now()}`,
-                    triggeredAt: new Date().toISOString(),
-                };
-            }
-            if (action === 'status') {
-                return {
-                    success: true,
-                    workflowId: input.workflowId,
-                    status: 'completed',
-                    conclusion: 'success',
-                    duration: '2m 35s',
-                };
-            }
-            if (action === 'cancel') {
-                return {
-                    success: true,
-                    action: 'cancelled',
-                    workflowId: input.workflowId,
-                    cancelledAt: new Date().toISOString(),
-                };
-            }
-            return { success: false, error: 'Unknown action' };
+            return {
+                success: false,
+                _stub: true,
+                message: 'GitHub tools are local-only stubs. Workflow operations require actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
+                localData: {
+                    requestedAction: action,
+                    workflowId: input.workflowId || null,
+                    ref: input.ref || null,
+                },
+            };
         },
     },
     {
@@ -337,36 +296,19 @@ export const githubTools = [
             },
         },
         handler: async (input) => {
-            const metric = input.metric || 'all';
-            const metrics = {
-                commits: {
-                    total: Math.floor(Math.random() * 1000) + 500,
-                    lastWeek: Math.floor(Math.random() * 50) + 10,
-                    lastMonth: Math.floor(Math.random() * 200) + 50,
-                },
-                contributors: {
-                    total: Math.floor(Math.random() * 50) + 5,
-                    active: Math.floor(Math.random() * 20) + 3,
-                    new: Math.floor(Math.random() * 5),
-                },
-                traffic: {
-                    views: Math.floor(Math.random() * 5000) + 1000,
-                    uniqueVisitors: Math.floor(Math.random() * 1000) + 200,
-                    clones: Math.floor(Math.random() * 500) + 50,
-                },
-                releases: {
-                    total: Math.floor(Math.random() * 20) + 5,
-                    latest: '3.0.0-alpha.86',
-                    downloads: Math.floor(Math.random() * 10000) + 1000,
-                },
-            };
-            if (metric === 'all') {
-                return { success: true, metrics };
-            }
+            const store = loadGitHubStore();
             return {
-                success: true,
-                metric,
-                data: metrics[metric],
+                success: false,
+                _stub: true,
+                message: 'GitHub tools are local-only stubs. Repository metrics require actual GitHub API access. Use the gh CLI or GitHub MCP server directly.',
+                localData: {
+                    owner: input.owner || 'owner',
+                    repo: input.repo || 'repo',
+                    requestedMetric: input.metric || 'all',
+                    storedRepos: Object.keys(store.repos),
+                    localIssueCount: Object.keys(store.issues).length,
+                    localPrCount: Object.keys(store.prs).length,
+                },
             };
         },
     },

package/v3/@claude-flow/cli/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(),
         };
     },
@@ -1167,19 +1180,36 @@ export const hooksExplain = {
             if (taskLower.includes(pattern)) {
                 matchedPatterns.push({
                     pattern,
-                    matchScore: 0.85 + Math.random() * 0.1,
-                    examples: [`Previous ${pattern} task completed successfully`, `${pattern} patterns from repository analysis`],
+                    matchScore: pattern.length / Math.max(taskLower.length, 1), // real ratio: pattern length vs task length
+                    examples: [`Keyword "${pattern}" matched in task description`],
                 });
             }
         }
+        // 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(),
         };
     },

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

@@ -4,10 +4,10 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @claude-flow/embeddings for REAL embeddings when available
- * - Falls back to simulated embeddings when @claude-flow/embeddings not installed
- * - Pattern storage and search with cosine similarity
- * - Training progress tracked (actual model training requires external tools)
+ * - Uses @claude-flow/embeddings for REAL ML embeddings when available
+ * - Falls back to deterministic hash-based embeddings when ML model not installed
+ * - Pattern storage and search with cosine similarity (real math in all tiers)
+ * - Training stores patterns as searchable embeddings (not simulated)
  *
  * Note: For production neural features, use @claude-flow/neural module
  */

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

@@ -4,10 +4,10 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @claude-flow/embeddings for REAL embeddings when available
- * - Falls back to simulated embeddings when @claude-flow/embeddings not installed
- * - Pattern storage and search with cosine similarity
- * - Training progress tracked (actual model training requires external tools)
+ * - Uses @claude-flow/embeddings for REAL ML embeddings when available
+ * - Falls back to deterministic hash-based embeddings when ML model not installed
+ * - Pattern storage and search with cosine similarity (real math in all tiers)
+ * - Training stores patterns as searchable embeddings (not simulated)
  *
  * Note: For production neural features, use @claude-flow/neural module
  */
@@ -87,7 +87,7 @@ function saveNeuralStore(store) {
     ensureNeuralDir();
     writeFileSync(getNeuralPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-// Generate embedding - uses real embeddings if available, falls back to hash-based
+// Generate embedding - uses real ML embeddings if available, falls back to deterministic hash
 async function generateEmbedding(text, dims = 384) {
     // If real embeddings available and text provided, use them
     if (realEmbeddings && text) {
@@ -113,8 +113,8 @@ async function generateEmbedding(text, dims = 384) {
         }
         return embedding;
     }
-    // Pure random fallback
-    return Array.from({ length: dims }, () => Math.random() * 2 - 1);
+    // No text provided — return zero vector (callers should always provide text)
+    return new Array(dims).fill(0);
 }
 // Cosine similarity for pattern search
 function cosineSimilarity(a, b) {
@@ -385,23 +385,12 @@ export const neuralTools = [
             },
         },
         handler: async (input) => {
-            const method = input.method || 'quantize';
-            const targetSize = input.targetSize || 0.25;
-            const compressionResults = {
-                quantize: { ratio: 3.92, method: 'Int8', memory: '75% reduction' },
-                prune: { ratio: 2.5, method: 'Magnitude pruning', memory: '60% reduction' },
-                distill: { ratio: 4.0, method: 'Knowledge distillation', memory: '75% reduction' },
-            };
-            const result = compressionResults[method] || compressionResults.quantize;
+            const method = input.method || 'quantization';
             return {
                 success: true,
+                _stub: true,
+                message: 'Compression not yet implemented. No data was modified.',
                 method,
-                originalSize: '1536 dims',
-                compressedSize: `${Math.floor(1536 * targetSize)} dims`,
-                compressionRatio: result.ratio,
-                memoryReduction: result.memory,
-                qualityRetention: 0.98,
-                latencyImprovement: '2.5x faster',
             };
         },
     },
@@ -467,33 +456,12 @@ export const neuralTools = [
             },
         },
         handler: async (input) => {
-            const target = input.target || 'balanced';
-            const optimizations = {
-                speed: {
-                    applied: ['Flash Attention', 'Batch processing', 'SIMD vectorization'],
-                    improvement: '2.49x-7.47x faster inference',
-                },
-                memory: {
-                    applied: ['Int8 quantization', 'Gradient checkpointing', 'Memory pooling'],
-                    improvement: '50-75% memory reduction',
-                },
-                accuracy: {
-                    applied: ['EWC++ regularization', 'Ensemble averaging', 'Data augmentation'],
-                    improvement: '3-5% accuracy boost',
-                },
-                balanced: {
-                    applied: ['HNSW indexing', 'Smart caching', 'Adaptive batch size'],
-                    improvement: 'Balanced 30% improvement across metrics',
-                },
-            };
-            const result = optimizations[target] || optimizations.balanced;
+            const target = input.target || 'general';
             return {
                 success: true,
+                _stub: true,
+                message: 'Optimization not yet implemented. No data was modified.',
                 target,
-                optimizations: result.applied,
-                improvement: result.improvement,
-                status: 'applied',
-                timestamp: new Date().toISOString(),
             };
         },
     },