@claude-flow/cli 3.5.23 → 3.5.25

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

@@ -3,7 +3,7 @@
  * Provides intelligent hooks functionality via MCP protocol
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -121,7 +121,88 @@ function generateSimpleEmbedding(text, dimension = 384) {
     }
     return embedding;
 }
-// Task patterns used by both native and pure-JS routers
+// ── Runtime routing outcome persistence ──────────────────────────────
+// Closes the learning loop: post-task records outcomes → route loads them.
+const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.claude-flow/routing-outcomes.json');
+const ROUTING_STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+    'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can',
+    'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
+    'before', 'after', 'above', 'below', 'between', 'under', 'again', 'further', 'then', 'once',
+    'it', 'its', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'she', 'they', 'them', 'and', 'but', 'or', 'nor', 'not', 'no', 'so', 'if', 'when', 'than',
+    'very', 'just', 'also', 'only', 'both', 'each', 'all', 'any', 'few', 'more', 'most', 'other',
+    'some', 'such', 'same', 'new', 'now', 'here', 'there', 'where', 'how', 'what', 'which', 'who',
+]);
+function extractKeywords(text) {
+    if (!text)
+        return [];
+    return text.toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !ROUTING_STOPWORDS.has(w));
+}
+function loadRoutingOutcomes() {
+    try {
+        if (existsSync(ROUTING_OUTCOMES_PATH)) {
+            const data = JSON.parse(readFileSync(ROUTING_OUTCOMES_PATH, 'utf-8'));
+            return data.outcomes || [];
+        }
+    }
+    catch { /* corrupt file, start fresh */ }
+    return [];
+}
+function saveRoutingOutcomes(outcomes) {
+    try {
+        const dir = dirname(ROUTING_OUTCOMES_PATH);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        // Cap at 500 entries to bound file size
+        const capped = outcomes.slice(-500);
+        writeFileSync(ROUTING_OUTCOMES_PATH, JSON.stringify({ outcomes: capped }, null, 2));
+    }
+    catch { /* non-critical */ }
+}
+/**
+ * Build learned routing patterns from successful task outcomes.
+ * Returns patterns in the same shape as TASK_PATTERNS so they can be
+ * merged into both the native HNSW and pure-JS semantic routers.
+ */
+function loadLearnedPatterns() {
+    const outcomes = loadRoutingOutcomes();
+    const byAgent = {};
+    for (const o of outcomes) {
+        if (!o.success || !o.agent || !o.keywords?.length)
+            continue;
+        if (!byAgent[o.agent])
+            byAgent[o.agent] = new Set();
+        for (const kw of o.keywords)
+            byAgent[o.agent].add(kw);
+    }
+    const patterns = {};
+    for (const [agent, kwSet] of Object.entries(byAgent)) {
+        patterns[`learned-${agent}`] = {
+            keywords: [...kwSet].slice(0, 50),
+            agents: [agent],
+        };
+    }
+    return patterns;
+}
+/**
+ * Merge static TASK_PATTERNS with runtime-learned patterns.
+ * Static patterns take precedence (learned patterns won't overwrite them).
+ */
+function getMergedTaskPatterns() {
+    const merged = { ...TASK_PATTERNS };
+    const learned = loadLearnedPatterns();
+    for (const [key, pattern] of Object.entries(learned)) {
+        if (!merged[key]) {
+            merged[key] = pattern;
+        }
+    }
+    return merged;
+}
+// ── Static task patterns (used by both native and pure-JS routers) ───
 const TASK_PATTERNS = {
     'security-task': {
         keywords: ['authentication', 'security', 'auth', 'password', 'encryption', 'vulnerability', 'cve', 'audit'],
@@ -198,8 +279,8 @@ async function getSemanticRouter() {
                 hnswEfConstruction: 200,
                 hnswEfSearch: 100,
             });
-            // Initialize with task patterns
-            for (const [patternName, { keywords }] of Object.entries(TASK_PATTERNS)) {
+            // Initialize with static + runtime-learned task patterns
+            for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
                 for (const keyword of keywords) {
                     const embedding = generateSimpleEmbedding(keyword);
                     db.insert(`${patternName}:${keyword}`, embedding);
@@ -220,7 +301,7 @@ async function getSemanticRouter() {
     try {
         const { SemanticRouter } = await import('../ruvector/semantic-router.js');
         semanticRouter = new SemanticRouter({ dimension: 384 });
-        for (const [patternName, { keywords, agents }] of Object.entries(TASK_PATTERNS)) {
+        for (const [patternName, { keywords, agents }] of Object.entries(getMergedTaskPatterns())) {
             const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
             semanticRouter.addIntentWithEmbeddings(patternName, embeddings, { agents, keywords });
             // Cache embeddings for keywords
@@ -414,11 +495,32 @@ function suggestAgentsForFile(filePath) {
 }
 function suggestAgentsForTask(task) {
     const taskLower = task.toLowerCase();
+    // Check static keyword patterns first
     for (const [pattern, result] of Object.entries(KEYWORD_PATTERNS)) {
         if (taskLower.includes(pattern)) {
             return result;
         }
     }
+    // Check runtime-learned patterns from successful task outcomes
+    const taskKeywords = extractKeywords(task);
+    if (taskKeywords.length > 0) {
+        const outcomes = loadRoutingOutcomes();
+        let bestAgent = '';
+        let bestOverlap = 0;
+        for (const outcome of outcomes) {
+            if (!outcome.success || !outcome.agent || !outcome.keywords?.length)
+                continue;
+            const overlap = taskKeywords.filter(kw => outcome.keywords.includes(kw)).length;
+            if (overlap > bestOverlap) {
+                bestOverlap = overlap;
+                bestAgent = outcome.agent;
+            }
+        }
+        // Require at least 2 keyword overlap to prevent false positives
+        if (bestAgent && bestOverlap >= 2) {
+            return { agents: [bestAgent], confidence: Math.min(0.6 + bestOverlap * 0.05, 0.85) };
+        }
+    }
     // Default fallback
     return { agents: ['coder', 'researcher', 'tester'], confidence: 0.7 };
 }
@@ -674,13 +776,16 @@ export const hooksRoute = {
                 routingMethod = 'semantic-native';
                 backendInfo = 'native VectorDb (HNSW)';
                 // Convert results to semantic format
+                const mergedPatterns = getMergedTaskPatterns();
                 semanticResult = results.map((r) => {
                     const [patternName] = r.id.split(':');
-                    const pattern = TASK_PATTERNS[patternName];
+                    const pattern = mergedPatterns[patternName];
                     return {
                         intent: patternName,
                         score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
-                        metadata: { agents: pattern?.agents || ['coder'] },
+                        metadata: {
+                            agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
+                        },
                     };
                 });
             }
@@ -941,6 +1046,8 @@ export const hooksPostTask = {
             success: { type: 'boolean', description: 'Whether task was successful' },
             agent: { type: 'string', description: 'Agent that completed the task' },
             quality: { type: 'number', description: 'Quality score (0-1)' },
+            task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
+            storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
         },
         required: ['taskId'],
     },
@@ -979,6 +1086,41 @@ export const hooksPostTask = {
         catch {
             // Non-fatal
         }
+        // Persist routing outcome for runtime learning (file-based, always reliable)
+        const taskText = params.task || '';
+        const outcomeKeywords = extractKeywords(taskText);
+        let outcomePersisted = false;
+        if (taskText && agent && agent.length <= 100 && /^[a-zA-Z0-9_-]+$/.test(agent)) {
+            try {
+                const outcomes = loadRoutingOutcomes();
+                outcomes.push({
+                    task: taskText,
+                    agent,
+                    success,
+                    quality,
+                    keywords: outcomeKeywords,
+                    timestamp: new Date().toISOString(),
+                });
+                saveRoutingOutcomes(outcomes);
+                outcomePersisted = true;
+            }
+            catch { /* non-critical */ }
+        }
+        // Optionally store in memory DB for cross-session vector retrieval
+        if (params.storeDecisions && taskText && agent) {
+            try {
+                const storeFn = await getRealStoreFunction();
+                if (storeFn) {
+                    await storeFn({
+                        key: `routing-decision:${taskId}`,
+                        namespace: 'patterns',
+                        value: JSON.stringify({ task: taskText, agent, success, quality, keywords: outcomeKeywords }),
+                        tags: ['routing-decision'],
+                    });
+                }
+            }
+            catch { /* non-critical */ }
+        }
         const duration = Date.now() - startTime;
         return {
             taskId,
@@ -989,6 +1131,7 @@ export const hooksPostTask = {
                 newPatterns: success ? 1 : 0,
                 trajectoryId: `traj-${Date.now()}`,
                 controller: feedbackResult?.controller || 'none',
+                outcomePersisted,
             },
             quality,
             feedback: feedbackResult ? {