@monoes/monomindcli 2.9.22 → 2.9.24

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

@@ -1,17 +1,18 @@
 /**
  * Hooks Routing MCP Tools
  * MCP tool implementations for pre/post edit/command, route, explain, pretrain,
- * build-agents, transfer, session, list, metrics, pre-task, post-task, intelligence.
+ * transfer, session, list, metrics, pre-task, post-task, intelligence.
  * Extracted from hooks-tools.ts.
  */
-import { mkdirSync, writeFileSync, renameSync, existsSync, readFileSync, } from 'fs';
-import { join, resolve, sep } from 'path';
-import { getProjectCwd } from './types.js';
-import { validateMcpString } from '../utils/input-guards.js';
 import { randomUUID } from 'node:crypto';
-import { recordRoute, joinOutcome, joinLatestUnresolved } from '../monovector/route-outcomes.js';
-import { recordCommand, deriveRecentSuccess } from '../monovector/command-outcomes.js';
-import { extractKeywords, loadRoutingOutcomes, saveRoutingOutcomes, loadMemoryStore, getIntelligenceStatsFromMemory, suggestAgentsForFile, suggestAgentsForTask, suggestAgentsFromIntelligence, assessCommandRisk, activeTrajectories, getMemoryPath, getRouteOutcomesBaseDir, getRoutingOutcomesPath, getRealSearchFunction, getRealStoreFunction, getSONAOptimizer, getFileExtension, TASK_PATTERNS, MEMORY_DIR, MEMORY_FILE, } from './hooks-embedding.js';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { deriveRecentSuccess, recordCommand } from '../monovector/command-outcomes.js';
+import { joinLatestUnresolved, joinOutcome, recordRoute } from '../monovector/route-outcomes.js';
+import { validateMcpString } from '../utils/input-guards.js';
+import { mergeRecordsById } from '../utils/json-file.js';
+import { activeTrajectories, assessCommandRisk, extractKeywords, getFileExtension, getIntelligenceStatsFromMemory, getMemoryPath, getRealSearchFunction, getRealStoreFunction, getRouteOutcomesBaseDir, getRoutingOutcomesPath, getSONAOptimizer, loadMemoryStore, loadRoutingOutcomes, MEMORY_DIR, saveRoutingOutcomes, suggestAgentsForFile, suggestAgentsForTask, suggestAgentsFromIntelligence, TASK_PATTERNS, } from './hooks-embedding.js';
+import { getProjectCwd } from './types.js';
 // MCP Tool implementations - return raw data for direct CLI use
 export const hooksPreEdit = {
     name: 'hooks_pre-edit',
@@ -218,7 +219,7 @@ export const hooksPostCommand = {
                 if (!existsSync(memDir))
                     mkdirSync(memDir, { recursive: true });
                 const _mp = getMemoryPath();
-                const _mptmp = _mp + '.tmp';
+                const _mptmp = `${_mp}.tmp`;
                 writeFileSync(_mptmp, JSON.stringify(store, null, 2), 'utf-8');
                 renameSync(_mptmp, _mp);
                 _storedIn = 'json-store';
@@ -262,14 +263,14 @@ export const hooksRoute = {
         if (!task) {
             return { error: 'task is required (non-empty string, no control chars, max 16KB)' };
         }
-        const context = validateMcpString(params.context, 'context', MAX_ROUTE_CTX_LEN) ?? undefined;
+        const _context = validateMcpString(params.context, 'context', MAX_ROUTE_CTX_LEN) ?? undefined;
         const useSemanticRouter = params.useSemanticRouter !== false;
         // Phase 5: Try memory backend SemanticRouter / LearningSystem first
         if (useSemanticRouter) {
             try {
                 const bridge = await import('../memory/memory-bridge.js');
                 const memoryRoute = await bridge.bridgeRouteTask({ task });
-                if (memoryRoute && memoryRoute.routes && memoryRoute.routes.length > 0) {
+                if (memoryRoute?.routes && memoryRoute.routes.length > 0) {
                     const topRoute = memoryRoute.routes[0];
                     const routeConfidence = topRoute.confidence ?? 0;
                     if (routeConfidence > 0.5) {
@@ -549,7 +550,6 @@ export const hooksList = {
             { name: 'session-restore', type: 'SessionStart', status: 'active' },
             // Learning hooks
             { name: 'pretrain', type: 'intelligence', status: 'active' },
-            { name: 'build-agents', type: 'intelligence', status: 'active' },
             { name: 'transfer', type: 'intelligence', status: 'active' },
             { name: 'metrics', type: 'analytics', status: 'active' },
             // System hooks
@@ -564,7 +564,6 @@ export const hooksList = {
             { name: 'intelligence_pattern-search', type: 'intelligence', status: 'active' },
             { name: 'intelligence_stats', type: 'analytics', status: 'active' },
             { name: 'intelligence_learn', type: 'intelligence', status: 'active' },
-            { name: 'intelligence_attention', type: 'intelligence', status: 'active' },
         ];
         return {
             _note: 'Static registry — update this list when hooks are added or removed.',
@@ -603,7 +602,7 @@ export const hooksPreTask = {
         if (!description) {
             return { error: 'description is required (non-empty string, no control chars, max 16KB)' };
         }
-        const filePath = validateMcpString(params.filePath, 'filePath', 4 * 1024) ?? undefined;
+        const _filePath = validateMcpString(params.filePath, 'filePath', 4 * 1024) ?? undefined;
         const suggestion = suggestAgentsForTask(description);
         // Determine complexity
         const descLower = description.toLowerCase();
@@ -673,7 +672,7 @@ export const hooksPreTask = {
             if (typeof fn === 'function') {
                 const cwd = process.cwd();
                 const reflections = await fn(cwd, description, 3);
-                reflexionWarnings = reflections.map(r => `⚠ Past failure: ${r.reflection.slice(0, 200)}`);
+                reflexionWarnings = reflections.map((r) => `⚠ Past failure: ${r.reflection.slice(0, 200)}`);
             }
         }
         catch {
@@ -809,14 +808,22 @@ export const hooksPostTask = {
             if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
                 console.error('[hooks-post-task] memory bridge feedback failed:', e);
         }
-        // Phase 3: Record causal edge (task → outcome)
+        // Phase 3: Record causal edge (task → outcome) as a real, traversable
+        // knowledge-graph edge (via memory_kg_ingest — same path as the
+        // memory_causal-edge MCP tool), not the opaque write-only `causal:` bridge namespace.
         try {
-            const bridge = await import('../memory/memory-bridge.js');
-            await bridge.bridgeRecordCausalEdge({
-                sourceId: taskId,
-                targetId: `outcome-${taskId}`,
-                relation: success ? 'succeeded' : 'failed',
-                strength: quality,
+            const kg = await import('../memory/memory-kg.js');
+            const outcomeId = `outcome-${taskId}`;
+            await kg.kgIngest({
+                nodes: [{ name: taskId }, { name: outcomeId }],
+                edges: [
+                    {
+                        source: taskId,
+                        target: outcomeId,
+                        relation: success ? 'succeeded' : 'failed',
+                    },
+                ],
+                originRef: 'hooks-post-task',
             });
         }
         catch (e) {
@@ -1259,112 +1266,6 @@ export const hooksPretrain = {
         };
     },
 };
-// Build agents hook - generate optimized agent configs
-export const hooksBuildAgents = {
-    name: 'hooks_build-agents',
-    description: 'Generate optimized agent configurations from pretrain data',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            outputDir: { type: 'string', description: 'Output directory for configs' },
-            focus: {
-                type: 'string',
-                description: 'Focus area (v1-implementation, security, performance, all)',
-            },
-            format: { type: 'string', description: 'Config format (yaml, json)' },
-            persist: { type: 'boolean', description: 'Write configs to disk' },
-        },
-    },
-    handler: async (params) => {
-        const rawOutputDir = resolve(validateMcpString(params.outputDir, 'outputDir', 4 * 1024) ?? './agents');
-        const outputDir = rawOutputDir;
-        if (!outputDir.startsWith(getProjectCwd() + sep) && outputDir !== getProjectCwd()) {
-            return { error: 'Invalid outputDir: must be within the project directory.' };
-        }
-        const focus = validateMcpString(params.focus, 'focus', 64) ?? 'all';
-        // Strict allowlist on `format` — without this, `format = "yaml/../../../etc/cron.d/x"`
-        // collapses through `join` and lets writes escape the validated outputDir.
-        const ALLOWED_FORMATS = new Set(['yaml', 'json']);
-        const format = validateMcpString(params.format, 'format', 16) ?? 'yaml';
-        if (!ALLOWED_FORMATS.has(format)) {
-            return { error: 'Invalid format: must be yaml or json' };
-        }
-        const persist = params.persist !== false; // Default to true
-        const agents = [
-            {
-                type: 'coder',
-                configFile: join(outputDir, `coder.${format}`),
-                capabilities: ['code-generation', 'refactoring', 'debugging'],
-                optimizations: ['token-reduction', 'context-caching'],
-            },
-            {
-                type: 'architect',
-                configFile: join(outputDir, `architect.${format}`),
-                capabilities: ['system-design', 'api-design', 'documentation'],
-                optimizations: ['context-caching', 'memory-persistence'],
-            },
-            {
-                type: 'tester',
-                configFile: join(outputDir, `tester.${format}`),
-                capabilities: ['unit-testing', 'integration-testing', 'coverage'],
-                optimizations: ['parallel-execution'],
-            },
-            {
-                type: 'security-architect',
-                configFile: join(outputDir, `security-architect.${format}`),
-                capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'],
-                optimizations: ['pattern-matching'],
-            },
-            {
-                type: 'reviewer',
-                configFile: join(outputDir, `reviewer.${format}`),
-                capabilities: ['code-review', 'quality-analysis', 'best-practices'],
-                optimizations: ['incremental-analysis'],
-            },
-        ];
-        const filteredAgents = focus === 'all'
-            ? agents
-            : focus === 'security'
-                ? agents.filter((a) => a.type.includes('security') || a.type === 'reviewer')
-                : focus === 'performance'
-                    ? agents.filter((a) => ['coder', 'tester'].includes(a.type))
-                    : agents;
-        // Persist configs to disk if requested
-        if (persist) {
-            // Ensure output directory exists
-            if (!existsSync(outputDir)) {
-                mkdirSync(outputDir, { recursive: true });
-            }
-            // Write each agent config
-            for (const agent of filteredAgents) {
-                const config = {
-                    type: agent.type,
-                    capabilities: agent.capabilities,
-                    optimizations: agent.optimizations,
-                    version: '3.0.0',
-                    createdAt: new Date().toISOString(),
-                };
-                const content = format === 'json'
-                    ? JSON.stringify(config, null, 2)
-                    : `# ${agent.type} agent configuration\ntype: ${agent.type}\nversion: "3.0.0"\ncapabilities:\n${agent.capabilities.map((c) => `  - ${c}`).join('\n')}\noptimizations:\n${agent.optimizations.map((o) => `  - ${o}`).join('\n')}\ncreatedAt: "${config.createdAt}"\n`;
-                const _cftmp = agent.configFile + '.tmp';
-                writeFileSync(_cftmp, content, 'utf-8');
-                renameSync(_cftmp, agent.configFile);
-            }
-        }
-        return {
-            outputDir,
-            focus,
-            persisted: persist,
-            agents: filteredAgents,
-            stats: {
-                configsGenerated: filteredAgents.length,
-                patternsApplied: filteredAgents.length * 3,
-                optimizationsIncluded: filteredAgents.reduce((acc, a) => acc + a.optimizations.length, 0),
-            },
-        };
-    },
-};
 // Transfer hook - transfer patterns from another project
 export const hooksTransfer = {
     name: 'hooks_transfer',
@@ -1389,8 +1290,8 @@ export const hooksTransfer = {
         const filter = validateMcpString(params.filter, 'filter', 64) ?? undefined;
         // Validate sourcePath is an existing directory before reading from it
         const resolvedSource = resolve(sourcePath);
-        const { statSync } = await import('fs');
-        const { homedir } = await import('os');
+        const { statSync } = await import('node:fs');
+        const { homedir } = await import('node:os');
         const home = homedir();
         if (resolvedSource !== home && !resolvedSource.startsWith(home + sep)) {
             return { error: 'sourcePath must be within the home directory.' };
@@ -1404,50 +1305,83 @@ export const hooksTransfer = {
         catch {
             return { error: 'sourcePath does not exist' };
         }
-        // Try to load patterns from source project's memory store
-        const sourceMemoryPath = join(resolvedSource, MEMORY_DIR, MEMORY_FILE);
-        let sourceStore = { entries: {}, version: '3.0.0' };
-        const MAX_SOURCE_STORE_BYTES = 50 * 1024 * 1024; // 50 MB — matches other store readers
+        // Load learned patterns from the source project's neural pattern store —
+        // the same `.monomind/neural/patterns.json` file `hooks intelligence
+        // import` writes to and intelligence.ts reads from (src/memory/intelligence.ts
+        // getPatternsPath()).
+        const sourcePatternsPath = join(resolvedSource, '.monomind', 'neural', 'patterns.json');
+        let sourcePatterns = [];
+        const MAX_SOURCE_PATTERNS_BYTES = 50 * 1024 * 1024; // 50 MB — matches other store readers
         try {
-            if (existsSync(sourceMemoryPath) &&
-                statSync(sourceMemoryPath).size <= MAX_SOURCE_STORE_BYTES) {
-                sourceStore = JSON.parse(readFileSync(sourceMemoryPath, 'utf-8'));
+            if (existsSync(sourcePatternsPath) &&
+                statSync(sourcePatternsPath).size <= MAX_SOURCE_PATTERNS_BYTES) {
+                const parsed = JSON.parse(readFileSync(sourcePatternsPath, 'utf-8'));
+                if (Array.isArray(parsed))
+                    sourcePatterns = parsed;
             }
         }
         catch (e) {
-            // Fall back to empty store
+            // Fall back to empty list
             if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error('[hooks-transfer] source memory store read/parse failed:', e);
+                console.error('[hooks-transfer] source patterns.json read/parse failed:', e);
         }
-        const sourceEntries = Object.values(sourceStore.entries);
-        // Count patterns by type from source
-        const byType = {
-            'file-patterns': sourceEntries.filter((e) => e.key.includes('file') || e.metadata?.type === 'file-pattern').length,
-            'task-routing': sourceEntries.filter((e) => e.key.includes('routing') || e.metadata?.type === 'routing').length,
-            '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, report honestly instead of substituting demo data
-        if (Object.values(byType).every((v) => v === 0)) {
+        if (sourcePatterns.length === 0) {
             return {
                 success: false,
                 message: 'No patterns found in source project',
                 sourcePath,
-                transferred: 0,
+                transferred: { total: 0, byType: {} },
             };
         }
-        if (filter) {
-            Object.keys(byType).forEach((key) => {
-                if (!key.includes(filter))
-                    delete byType[key];
-            });
+        // Qualifying patterns: confidence at/above threshold, and (if given) type
+        // matches the filter.
+        const qualifying = sourcePatterns.filter((p) => typeof p.id === 'string' &&
+            p.id.length > 0 &&
+            (typeof p.confidence !== 'number' || p.confidence >= minConfidence) &&
+            (!filter || (typeof p.type === 'string' && p.type.includes(filter))));
+        if (qualifying.length === 0) {
+            return {
+                success: false,
+                message: 'No patterns in source project meet the filter/confidence threshold',
+                sourcePath,
+                transferred: { total: 0, byType: {} },
+            };
+        }
+        // Merge into this project's pattern store, reusing the same by-id dedupe
+        // logic as `hooks intelligence import` (neural-registry.ts's importCommand).
+        const destDir = join(getProjectCwd(), '.monomind', 'neural');
+        const destPatternsPath = join(destDir, 'patterns.json');
+        let destPatterns = [];
+        try {
+            if (existsSync(destPatternsPath) &&
+                statSync(destPatternsPath).size <= MAX_SOURCE_PATTERNS_BYTES) {
+                const parsed = JSON.parse(readFileSync(destPatternsPath, 'utf-8'));
+                if (Array.isArray(parsed))
+                    destPatterns = parsed;
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-transfer] destination patterns.json read/parse failed:', e);
+        }
+        const { merged, added } = mergeRecordsById(destPatterns, qualifying);
+        if (!existsSync(destDir))
+            mkdirSync(destDir, { recursive: true });
+        const tmpDest = `${destPatternsPath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmpDest, JSON.stringify(merged, null, 2), 'utf-8');
+        renameSync(tmpDest, destPatternsPath);
+        // Real counts of what was actually transferred, grouped by each pattern's
+        // own `type` field (falling back to 'unknown' when absent).
+        const byType = {};
+        for (const p of added) {
+            const type = typeof p.type === 'string' && p.type.length > 0 ? p.type : 'unknown';
+            byType[type] = (byType[type] || 0) + 1;
         }
-        const total = Object.values(byType).reduce((a, b) => a + b, 0);
         return {
             success: true,
             sourcePath,
             transferred: {
-                total,
+                total: added.length,
                 byType,
             },
             dataSource: 'source-project',
@@ -1703,29 +1637,22 @@ export const hooksIntelligence = {
     inputSchema: {
         type: 'object',
         properties: {
-            mode: { type: 'string', description: 'Intelligence mode' },
-            enableSona: { type: 'boolean', description: 'Enable SONA learning' },
-            enableMoe: { type: 'boolean', description: 'Enable MoE routing' },
             enableHnsw: { type: 'boolean', description: 'Enable HNSW search' },
             forceTraining: { type: 'boolean', description: 'Force training cycle' },
             showStatus: { type: 'boolean', description: 'Show status only' },
         },
     },
     handler: async (params) => {
-        const mode = validateMcpString(params.mode, 'mode', 32) ?? 'balanced';
-        const enableSona = params.enableSona !== false;
-        const enableMoe = params.enableMoe !== false;
         const enableHnsw = params.enableHnsw !== false;
         // Get REAL statistics from memory store
         const realStats = getIntelligenceStatsFromMemory();
         // Check actual implementation availability
         const sonaAvailable = (await getSONAOptimizer()) !== null;
         return {
-            mode,
             status: 'active',
             components: {
                 sona: {
-                    enabled: enableSona,
+                    enabled: sonaAvailable,
                     status: sonaAvailable ? 'active' : 'idle',
                     implemented: true,
                     trajectoriesRecorded: realStats.trajectories.total,