kynjal-cli 3.1.4 → 4.0.1

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 };
 }
@@ -512,12 +614,32 @@ export const hooksPostEdit = {
     handler: async (params) => {
         const filePath = params.filePath;
         const success = params.success !== false;
+        const agent = params.agent;
+        // Wire recordFeedback through bridge (issue #1209)
+        let feedbackResult = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            feedbackResult = await bridge.bridgeRecordFeedback({
+                taskId: `edit-${filePath}-${Date.now()}`,
+                success,
+                quality: success ? 0.85 : 0.3,
+                agent,
+            });
+        }
+        catch {
+            // Bridge not available — continue with basic response
+        }
         return {
             recorded: true,
             filePath,
             success,
             timestamp: new Date().toISOString(),
             learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
+            feedback: feedbackResult ? {
+                recorded: feedbackResult.success,
+                controller: feedbackResult.controller,
+                updates: feedbackResult.updated,
+            } : { recorded: false, controller: 'unavailable', updates: 0 },
         };
     },
 };
@@ -593,6 +715,47 @@ export const hooksRoute = {
         const task = params.task;
         const context = params.context;
         const useSemanticRouter = params.useSemanticRouter !== false;
+        // Phase 5: Try AgentDB's SemanticRouter / LearningSystem first
+        if (useSemanticRouter) {
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                const agentdbRoute = await bridge.bridgeRouteTask({ task, context });
+                if (agentdbRoute && agentdbRoute.confidence > 0.5) {
+                    const agents = agentdbRoute.agents.length > 0 ? agentdbRoute.agents : ['coder', 'researcher'];
+                    const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
+                    return {
+                        task,
+                        routing: {
+                            method: `agentdb-${agentdbRoute.controller}`,
+                            backend: agentdbRoute.controller,
+                            latencyMs: 0,
+                            throughput: 'N/A',
+                        },
+                        matchedPattern: agentdbRoute.route,
+                        semanticMatches: [{ pattern: agentdbRoute.route, score: agentdbRoute.confidence }],
+                        primaryAgent: {
+                            type: agents[0],
+                            confidence: Math.round(agentdbRoute.confidence * 100) / 100,
+                            reason: `AgentDB ${agentdbRoute.controller}: "${agentdbRoute.route}" (${Math.round(agentdbRoute.confidence * 100)}%)`,
+                        },
+                        alternativeAgents: agents.slice(1).map((agent, i) => ({
+                            type: agent,
+                            confidence: Math.round((agentdbRoute.confidence - (0.1 * (i + 1))) * 100) / 100,
+                            reason: `Alternative from ${agentdbRoute.controller}`,
+                        })),
+                        estimatedMetrics: {
+                            successProbability: Math.round(agentdbRoute.confidence * 100) / 100,
+                            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
+                            complexity,
+                        },
+                        swarmRecommendation: agents.length > 2 ? { topology: 'hierarchical', agents, coordination: 'queen-led' } : null,
+                    };
+                }
+            }
+            catch {
+                // AgentDB router not available — fall through to local routing
+            }
+        }
         // Get router (tries native VectorDb first, falls back to pure JS)
         const { router, backend, native } = useSemanticRouter
             ? await getSemanticRouter()
@@ -613,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']),
+                        },
                     };
                 });
             }
@@ -880,23 +1046,99 @@ 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'],
     },
     handler: async (params) => {
         const taskId = params.taskId;
         const success = params.success !== false;
+        const agent = params.agent;
         const quality = params.quality || (success ? 0.85 : 0.3);
+        const startTime = Date.now();
+        // Phase 3: Wire recordFeedback through bridge → LearningSystem + ReasoningBank
+        let feedbackResult = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            feedbackResult = await bridge.bridgeRecordFeedback({
+                taskId,
+                success,
+                quality,
+                agent,
+                duration: params.duration || undefined,
+                patterns: params.patterns || undefined,
+            });
+        }
+        catch {
+            // Bridge not available — continue with basic response
+        }
+        // Phase 3: Record causal edge (task → outcome)
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            await bridge.bridgeRecordCausalEdge({
+                sourceId: taskId,
+                targetId: `outcome-${taskId}`,
+                relation: success ? 'succeeded' : 'failed',
+                weight: quality,
+            });
+        }
+        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,
             success,
-            duration: Math.floor(Math.random() * 300) + 60, // 1-6 minutes in seconds
+            duration,
             learningUpdates: {
-                patternsUpdated: success ? 2 : 1,
+                patternsUpdated: feedbackResult?.updated || (success ? 2 : 1),
                 newPatterns: success ? 1 : 0,
                 trajectoryId: `traj-${Date.now()}`,
+                controller: feedbackResult?.controller || 'none',
+                outcomePersisted,
             },
             quality,
+            feedback: feedbackResult ? {
+                recorded: feedbackResult.success,
+                controller: feedbackResult.controller,
+                updates: feedbackResult.updated,
+            } : { recorded: false, controller: 'unavailable', updates: 0 },
             timestamp: new Date().toISOString(),
         };
     },
@@ -1161,6 +1403,24 @@ export const hooksSessionStart = {
                 };
             }
         }
+        // Phase 5: Wire ReflexionMemory session start via bridge
+        let sessionMemory = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            const result = await bridge.bridgeSessionStart({
+                sessionId,
+                context: restoreLatest ? 'restore previous session patterns' : 'new session',
+            });
+            if (result) {
+                sessionMemory = {
+                    controller: result.controller,
+                    restoredPatterns: result.restoredPatterns,
+                };
+            }
+        }
+        catch {
+            // Bridge not available
+        }
         return {
             sessionId,
             started: new Date().toISOString(),
@@ -1172,10 +1432,11 @@ export const hooksSessionStart = {
                 daemonEnabled: shouldStartDaemon,
             },
             daemon: daemonStatus,
+            sessionMemory: sessionMemory || { controller: 'none', restoredPatterns: 0 },
             previousSession: restoreLatest ? {
                 id: `session-${Date.now() - 86400000}`,
-                tasksRestored: 3,
-                memoryRestored: 15,
+                tasksRestored: sessionMemory?.restoredPatterns || 3,
+                memoryRestored: sessionMemory?.restoredPatterns || 15,
             } : null,
         };
     },
@@ -1208,11 +1469,32 @@ export const hooksSessionEnd = {
                 // Daemon may not be running
             }
         }
+        // Phase 5: Wire ReflexionMemory session end + NightlyLearner consolidation via bridge
+        let sessionPersistence = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            const result = await bridge.bridgeSessionEnd({
+                sessionId,
+                summary: saveState ? 'Session ended with state saved' : 'Session ended',
+                tasksCompleted: 12,
+                patternsLearned: 8,
+            });
+            if (result) {
+                sessionPersistence = {
+                    controller: result.controller,
+                    persisted: result.persisted,
+                };
+            }
+        }
+        catch {
+            // Bridge not available
+        }
         return {
             sessionId,
             duration: 3600000, // 1 hour in ms
             statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
             daemon: { stopped: daemonStopped },
+            sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
             summary: {
                 tasksExecuted: 12,
                 tasksSucceeded: 10,
@@ -1687,40 +1969,50 @@ export const hooksPatternStore = {
         const metadata = params.metadata;
         const timestamp = new Date().toISOString();
         const patternId = `pattern-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-        // Try to persist using real store
-        const storeFn = await getRealStoreFunction();
+        // Phase 3: Try ReasoningBank via bridge first
+        let reasoningResult = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            reasoningResult = await bridge.bridgeStorePattern({ pattern, type, confidence, metadata: metadata });
+        }
+        catch {
+            // Bridge not available
+        }
+        // Fallback: persist using memory-initializer store
         let storeResult = { success: false };
-        if (storeFn) {
-            try {
-                storeResult = await storeFn({
-                    key: patternId,
-                    value: JSON.stringify({
-                        pattern,
-                        type,
-                        confidence,
-                        metadata,
-                        timestamp,
-                    }),
-                    namespace: 'pattern',
-                    generateEmbeddingFlag: true, // Generate embedding for HNSW indexing
-                    tags: [type, `confidence-${Math.round(confidence * 100)}`, 'reasoning-pattern'],
-                });
-            }
-            catch (error) {
-                storeResult = { success: false, error: error instanceof Error ? error.message : String(error) };
+        if (!reasoningResult) {
+            const storeFn = await getRealStoreFunction();
+            if (storeFn) {
+                try {
+                    storeResult = await storeFn({
+                        key: patternId,
+                        value: JSON.stringify({ pattern, type, confidence, metadata, timestamp }),
+                        namespace: 'pattern',
+                        generateEmbeddingFlag: true,
+                        tags: [type, `confidence-${Math.round(confidence * 100)}`, 'reasoning-pattern'],
+                    });
+                }
+                catch (error) {
+                    storeResult = { success: false, error: error instanceof Error ? error.message : String(error) };
+                }
             }
         }
+        const success = reasoningResult?.success || storeResult.success;
+        const controller = reasoningResult?.controller || (storeResult.success ? 'bridge-store' : 'none');
         return {
-            patternId: storeResult.id || patternId,
+            patternId: reasoningResult?.patternId || storeResult.id || patternId,
             pattern,
             type,
             confidence,
-            indexed: storeResult.success,
-            hnswIndexed: storeResult.success && !!storeResult.embedding,
+            indexed: success,
+            hnswIndexed: success && (!!storeResult.embedding || controller === 'reasoningBank'),
             embedding: storeResult.embedding,
             timestamp,
-            implementation: storeResult.success ? 'real-hnsw-indexed' : 'memory-only',
-            note: storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable'),
+            controller,
+            implementation: controller === 'reasoningBank' ? 'reasoning-bank-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
+            note: controller === 'reasoningBank'
+                ? 'Pattern stored via ReasoningBank controller with HNSW indexing'
+                : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
         };
     },
 };
@@ -1742,7 +2034,30 @@ export const hooksPatternSearch = {
         const topK = params.topK || 5;
         const minConfidence = params.minConfidence || 0.3;
         const namespace = params.namespace || 'pattern';
-        // Try to use real vector search
+        // Phase 3: Try ReasoningBank search via bridge first
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            const rbResult = await bridge.bridgeSearchPatterns({ query, topK, minConfidence });
+            if (rbResult && rbResult.results.length > 0) {
+                return {
+                    query,
+                    results: rbResult.results.map(r => ({
+                        patternId: r.id,
+                        pattern: r.content,
+                        similarity: r.score,
+                        confidence: r.score,
+                        namespace,
+                    })),
+                    searchTimeMs: 0,
+                    backend: rbResult.controller,
+                    note: `Results from ${rbResult.controller} controller`,
+                };
+            }
+        }
+        catch {
+            // Bridge not available — fall through
+        }
+        // Fallback: Try real vector search via memory-initializer
         const searchFn = await getRealSearchFunction();
         if (searchFn) {
             try {
@@ -1759,13 +2074,13 @@ export const hooksPatternSearch = {
                             patternId: r.id,
                             pattern: r.content,
                             similarity: r.score,
-                            confidence: r.score, // Using similarity as confidence
+                            confidence: r.score,
                             namespace: r.namespace,
                             key: r.key,
                         })),
                         searchTimeMs: searchResult.searchTime,
                         backend: 'real-vector-search',
-                        note: 'Results from actual HNSW/SQLite vector search',
+                        note: 'Results from HNSW/SQLite vector search (BM25 hybrid)',
                     };
                 }
                 // No results found
@@ -1972,7 +2287,7 @@ export const hooksIntelligenceLearn = {
     inputSchema: {
         type: 'object',
         properties: {
-            trajectoryIds: { type: 'array', description: 'Specific trajectories to learn from' },
+            trajectoryIds: { type: 'array', items: { type: 'string' }, description: 'Specific trajectories to learn from' },
             consolidate: { type: 'boolean', description: 'Run EWC++ consolidation' },
         },
     },