monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/mcp-tools/agent-tools.js

@@ -0,0 +1,607 @@
+/**
+ * Agent MCP Tools for CLI
+ *
+ * Tool definitions for agent lifecycle management with file persistence.
+ * Includes model routing integration for intelligent model selection.
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { getProjectCwd } from './types.js';
+// Storage paths
+const STORAGE_DIR = '.monomind';
+const AGENT_DIR = 'agents';
+const AGENT_FILE = 'store.json';
+function getAgentDir() {
+    return join(getProjectCwd(), STORAGE_DIR, AGENT_DIR);
+}
+function getAgentPath() {
+    return join(getAgentDir(), AGENT_FILE);
+}
+function ensureAgentDir() {
+    const dir = getAgentDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+const MAX_AGENT_STORE_BYTES = 50 * 1024 * 1024;
+function loadAgentStore() {
+    try {
+        const path = getAgentPath();
+        if (existsSync(path)) {
+            if (statSync(path).size > MAX_AGENT_STORE_BYTES)
+                return { agents: {}, version: '3.0.0' };
+            const data = readFileSync(path, 'utf-8');
+            const parsed = JSON.parse(data);
+            if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
+                return { agents: {}, version: '3.0.0' };
+            return parsed;
+        }
+    }
+    catch {
+        // Return empty store on error
+    }
+    return { agents: {}, version: '3.0.0' };
+}
+function saveAgentStore(store) {
+    // Cap terminated agents to prevent unbounded growth
+    const MAX_TERMINATED = 500;
+    const terminated = Object.entries(store.agents)
+        .filter(([, a]) => a.status === 'terminated')
+        .sort(([, a], [, b]) => (a.createdAt ?? '').localeCompare(b.createdAt ?? ''));
+    if (terminated.length > MAX_TERMINATED) {
+        for (const [id] of terminated.slice(0, terminated.length - MAX_TERMINATED)) {
+            delete store.agents[id];
+        }
+    }
+    ensureAgentDir();
+    const dest = getAgentPath();
+    const tmp = `${dest}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(store, null, 2), 'utf-8');
+    renameSync(tmp, dest);
+}
+// Default model mappings for agent types (can be overridden)
+const AGENT_TYPE_MODEL_DEFAULTS = {
+    // Complex agents → opus
+    'architect': 'opus',
+    'security-architect': 'opus',
+    'system-architect': 'opus',
+    'core-architect': 'opus',
+    // Medium complexity → sonnet
+    'coder': 'sonnet',
+    'reviewer': 'sonnet',
+    'researcher': 'sonnet',
+    'tester': 'sonnet',
+    'analyst': 'sonnet',
+    // Simple/fast agents → haiku
+    'formatter': 'haiku',
+    'linter': 'haiku',
+    'documenter': 'haiku',
+};
+// Lazy-loaded model router
+let modelRouterInstance = null;
+async function getModelRouter() {
+    if (!modelRouterInstance) {
+        try {
+            const { getModelRouter } = await import('../ruvector/model-router.js');
+            modelRouterInstance = getModelRouter();
+        }
+        catch (e) {
+            // Log but don't fail - model router is optional
+            console.error('[agent-tools] Model router load failed:', e.message);
+        }
+    }
+    return modelRouterInstance;
+}
+/**
+ * Determine model for agent based on (ADR-026 3-tier routing):
+ * 1. Explicit model in config
+ * 2. Enhanced task-based routing with Agent Booster AST (if task provided)
+ * 3. Agent type defaults
+ * 4. Fallback to sonnet
+ */
+async function determineAgentModel(agentType, config, task) {
+    // 1. Explicit model in config
+    if (config.model && ['haiku', 'sonnet', 'opus', 'inherit'].includes(config.model)) {
+        return { model: config.model, routedBy: 'explicit' };
+    }
+    // 2. Enhanced task-based routing with Agent Booster AST
+    if (task) {
+        try {
+            // Try enhanced router first (includes Agent Booster detection)
+            const { getEnhancedModelRouter } = await import('../ruvector/enhanced-model-router.js');
+            const enhancedRouter = getEnhancedModelRouter();
+            const routeResult = await enhancedRouter.route(task, { filePath: config.filePath });
+            if (routeResult.tier === 1 && routeResult.canSkipLLM) {
+                // Agent Booster can handle this task
+                return {
+                    model: 'haiku', // Use haiku as fallback if AB fails
+                    routedBy: 'agent-booster',
+                    canSkipLLM: true,
+                    agentBoosterIntent: routeResult.agentBoosterIntent?.type,
+                    tier: 1,
+                };
+            }
+            return {
+                model: (routeResult.model ?? 'sonnet'),
+                routedBy: 'router',
+                tier: routeResult.tier,
+            };
+        }
+        catch {
+            // Enhanced router not available, try basic router
+            const router = await getModelRouter();
+            if (router) {
+                try {
+                    const result = await router.route(task);
+                    return { model: result.model, routedBy: 'router' };
+                }
+                catch {
+                    // Fall through to defaults on router error
+                }
+            }
+        }
+    }
+    // 3. Agent type defaults
+    const defaultModel = AGENT_TYPE_MODEL_DEFAULTS[agentType];
+    if (defaultModel) {
+        return { model: defaultModel, routedBy: 'default' };
+    }
+    // 4. Fallback to sonnet (balanced)
+    return { model: 'sonnet', routedBy: 'default' };
+}
+export const agentTools = [
+    {
+        name: 'agent_spawn',
+        description: 'Spawn a new agent with intelligent model selection',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentType: { type: 'string', description: 'Type of agent to spawn' },
+                agentId: { type: 'string', description: 'Optional custom agent ID' },
+                config: { type: 'object', description: 'Agent configuration' },
+                domain: { type: 'string', description: 'Agent domain' },
+                model: {
+                    type: 'string',
+                    enum: ['haiku', 'sonnet', 'opus', 'inherit'],
+                    description: 'Claude model to use (haiku=fast/cheap, sonnet=balanced, opus=most capable)'
+                },
+                task: { type: 'string', description: 'Task description for intelligent model routing' },
+            },
+            required: ['agentType'],
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agentId = input.agentId || `agent-${Date.now()}-${randomBytes(4).toString('hex')}`;
+            const agentType = input.agentType;
+            if (['__proto__', 'constructor', 'prototype'].includes(agentId)) {
+                return { success: false, agentId, error: 'Forbidden agent ID' };
+            }
+            if (input.agentId && store.agents[agentId]) {
+                return {
+                    success: false,
+                    agentId,
+                    error: `Agent ${agentId} already exists. Terminate it first or omit agentId to auto-generate.`,
+                };
+            }
+            const config = input.config || {};
+            // Add explicit model to config if provided
+            if (input.model) {
+                config.model = input.model;
+            }
+            // Get task from either top-level or config (CLI passes it in config.task)
+            const task = input.task || config.task || undefined;
+            // Determine model using ADR-026 3-tier routing logic
+            const routingResult = await determineAgentModel(agentType, config, task);
+            const agent = {
+                agentId,
+                agentType,
+                status: 'idle',
+                health: 1.0,
+                taskCount: 0,
+                config,
+                createdAt: new Date().toISOString(),
+                domain: input.domain,
+                model: routingResult.model,
+                modelRoutedBy: routingResult.routedBy,
+            };
+            store.agents[agentId] = agent;
+            saveAgentStore(store);
+            // Task 46: AgentSandboxing — register sandbox for isolated agent execution
+            try {
+                const { WasmSandbox, DockerSandbox, register } = await import('@monomind/security');
+                const sandboxType = config.sandbox?.type ?? 'wasm';
+                const sandboxConfig = config.sandbox ?? {};
+                const sandbox = sandboxType === 'docker'
+                    ? DockerSandbox.create(agentId, sandboxConfig)
+                    : WasmSandbox.create(agentId, sandboxConfig);
+                register(agentId, sandbox);
+            }
+            catch { /* optional — @monomind/security may not be installed */ }
+            // Include Agent Booster routing info if applicable
+            const response = {
+                success: true,
+                agentId,
+                agentType: agent.agentType,
+                model: agent.model,
+                modelRoutedBy: routingResult.routedBy,
+                status: 'spawned',
+                createdAt: agent.createdAt,
+            };
+            // Add Agent Booster info if task can skip LLM
+            if (routingResult.canSkipLLM) {
+                response.canSkipLLM = true;
+                response.agentBoosterIntent = routingResult.agentBoosterIntent;
+                response.tier = routingResult.tier;
+                response.note = `Agent Booster can handle "${routingResult.agentBoosterIntent}" - use agent_booster_edit_file MCP tool`;
+            }
+            else if (routingResult.tier) {
+                response.tier = routingResult.tier;
+            }
+            return response;
+        },
+    },
+    {
+        name: 'agent_terminate',
+        description: 'Terminate an agent',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'ID of agent to terminate' },
+                force: { type: 'boolean', description: 'Force immediate termination' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const agentId = input.agentId;
+            if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
+                return { success: false, agentId, error: 'Invalid agent ID' };
+            }
+            const store = loadAgentStore();
+            if (Object.hasOwn(store.agents, agentId)) {
+                store.agents[agentId].status = 'terminated';
+                saveAgentStore(store);
+                // Task 46: AgentSandboxing — clean up sandbox on termination
+                try {
+                    const { cleanup } = await import('@monomind/security');
+                    cleanup(agentId);
+                }
+                catch { /* optional */ }
+                return {
+                    success: true,
+                    agentId,
+                    terminated: true,
+                    terminatedAt: new Date().toISOString(),
+                };
+            }
+            return {
+                success: false,
+                agentId,
+                error: 'Agent not found',
+            };
+        },
+    },
+    {
+        name: 'agent_status',
+        description: 'Get agent status',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'ID of agent' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const agentId = input.agentId;
+            if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
+                return { agentId, error: 'Invalid agent ID' };
+            }
+            const store = loadAgentStore();
+            const agent = Object.hasOwn(store.agents, agentId) ? store.agents[agentId] : undefined;
+            if (agent) {
+                return {
+                    agentId: agent.agentId,
+                    agentType: agent.agentType,
+                    status: agent.status,
+                    health: agent.health,
+                    taskCount: agent.taskCount,
+                    createdAt: agent.createdAt,
+                    domain: agent.domain,
+                    lastResult: agent.lastResult || null,
+                };
+            }
+            return {
+                agentId,
+                status: 'not_found',
+                error: 'Agent not found',
+            };
+        },
+    },
+    {
+        name: 'agent_list',
+        description: 'List all agents',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', description: 'Filter by status' },
+                domain: { type: 'string', description: 'Filter by domain' },
+                includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            let agents = Object.values(store.agents);
+            // Filter by status
+            if (input.status) {
+                agents = agents.filter(a => a.status === input.status);
+            }
+            else if (!input.includeTerminated) {
+                agents = agents.filter(a => a.status !== 'terminated');
+            }
+            // Filter by domain
+            if (input.domain) {
+                agents = agents.filter(a => a.domain === input.domain);
+            }
+            return {
+                agents: agents.map(a => ({
+                    agentId: a.agentId,
+                    agentType: a.agentType,
+                    status: a.status,
+                    health: a.health,
+                    taskCount: a.taskCount,
+                    createdAt: a.createdAt,
+                    domain: a.domain,
+                })),
+                total: agents.length,
+                filters: {
+                    status: input.status,
+                    domain: input.domain,
+                    includeTerminated: input.includeTerminated,
+                },
+            };
+        },
+    },
+    {
+        name: 'agent_pool',
+        description: 'Manage agent pool',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['status', 'scale', 'drain'], description: 'Pool action' },
+                targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
+                agentType: { type: 'string', description: 'Agent type filter' },
+            },
+            required: ['action'],
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+            const action = input.action || 'status'; // Default to status
+            if (action === 'status') {
+                const byType = {};
+                const byStatus = {};
+                for (const agent of agents) {
+                    byType[agent.agentType] = (byType[agent.agentType] || 0) + 1;
+                    byStatus[agent.status] = (byStatus[agent.status] || 0) + 1;
+                }
+                const idleAgents = agents.filter(a => a.status === 'idle').length;
+                const busyAgents = agents.filter(a => a.status === 'busy').length;
+                const utilization = agents.length > 0 ? busyAgents / agents.length : 0;
+                return {
+                    action,
+                    // CLI expected fields
+                    poolId: 'agent-pool-default',
+                    currentSize: agents.length,
+                    utilization,
+                    agents: agents.map(a => ({
+                        id: a.agentId,
+                        type: a.agentType,
+                        status: a.status,
+                    })),
+                    // Additional fields
+                    id: 'agent-pool-default',
+                    size: agents.length,
+                    totalAgents: agents.length,
+                    byType,
+                    byStatus,
+                    avgHealth: agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 0,
+                };
+            }
+            if (action === 'scale') {
+                const targetSize = Math.min(Math.max(input.targetSize || 5, 1), 50);
+                const agentType = input.agentType || 'worker';
+                const currentSize = agents.filter(a => a.agentType === agentType).length;
+                const delta = targetSize - currentSize;
+                const added = [];
+                const removed = [];
+                if (delta > 0) {
+                    for (let i = 0; i < delta; i++) {
+                        const agentId = `agent-${Date.now()}-${randomBytes(4).toString('hex')}`;
+                        store.agents[agentId] = {
+                            agentId,
+                            agentType,
+                            status: 'idle',
+                            health: 1.0,
+                            taskCount: 0,
+                            config: {},
+                            createdAt: new Date().toISOString(),
+                        };
+                        added.push(agentId);
+                    }
+                }
+                else if (delta < 0) {
+                    const toRemove = agents.filter(a => a.agentType === agentType && a.status === 'idle').slice(0, -delta);
+                    for (const agent of toRemove) {
+                        store.agents[agent.agentId].status = 'terminated';
+                        removed.push(agent.agentId);
+                    }
+                }
+                saveAgentStore(store);
+                return {
+                    action,
+                    agentType,
+                    previousSize: currentSize,
+                    targetSize,
+                    newSize: currentSize + delta,
+                    added,
+                    removed,
+                };
+            }
+            if (action === 'drain') {
+                const agentType = input.agentType;
+                let drained = 0;
+                for (const agent of agents) {
+                    if (!agentType || agent.agentType === agentType) {
+                        if (agent.status === 'idle') {
+                            store.agents[agent.agentId].status = 'terminated';
+                            drained++;
+                        }
+                    }
+                }
+                saveAgentStore(store);
+                return {
+                    action,
+                    agentType: agentType || 'all',
+                    drained,
+                    remaining: agents.length - drained,
+                };
+            }
+            return { action, error: 'Unknown action' };
+        },
+    },
+    {
+        name: 'agent_health',
+        description: 'Check agent health',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Specific agent ID (optional)' },
+                threshold: { type: 'number', description: 'Health threshold (0-1)' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+            const threshold = input.threshold || 0.5;
+            if (input.agentId !== undefined) {
+                const agentId = input.agentId;
+                if (typeof agentId !== 'string' ||
+                    ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
+                    return { agentId, error: 'Invalid agent ID' };
+                }
+                const agent = Object.hasOwn(store.agents, agentId)
+                    ? store.agents[agentId]
+                    : undefined;
+                if (agent) {
+                    return {
+                        agentId: agent.agentId,
+                        health: agent.health,
+                        status: agent.status,
+                        healthy: agent.health >= threshold,
+                        taskCount: agent.taskCount,
+                        uptime: Date.now() - new Date(agent.createdAt).getTime(),
+                    };
+                }
+                return { agentId, error: 'Agent not found' };
+            }
+            const healthyAgents = agents.filter(a => a.health >= threshold);
+            const degradedAgents = agents.filter(a => a.health >= 0.3 && a.health < threshold);
+            const unhealthyAgents = agents.filter(a => a.health < 0.3);
+            const avgHealth = agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 1;
+            return {
+                // CLI expected fields
+                agents: agents.map(a => {
+                    const uptime = Date.now() - new Date(a.createdAt).getTime();
+                    return {
+                        id: a.agentId,
+                        type: a.agentType,
+                        health: a.health >= threshold ? 'healthy' : (a.health >= 0.3 ? 'degraded' : 'unhealthy'),
+                        uptime,
+                        tasks: { active: a.taskCount > 0 ? 1 : 0, queued: 0, completed: a.taskCount, failed: 0 },
+                        _note: 'Per-agent OS metrics not available — use system_metrics for real CPU/memory',
+                    };
+                }),
+                overall: {
+                    healthy: healthyAgents.length,
+                    degraded: degradedAgents.length,
+                    unhealthy: unhealthyAgents.length,
+                    cpu: null,
+                    memory: null,
+                    _note: 'Per-agent CPU/memory not available — use system_metrics for real OS-level stats',
+                    score: Math.round(avgHealth * 100),
+                    issues: unhealthyAgents.length,
+                },
+                // Additional fields
+                total: agents.length,
+                healthyCount: healthyAgents.length,
+                unhealthyCount: unhealthyAgents.length,
+                threshold,
+                avgHealth,
+                unhealthyAgents: unhealthyAgents.map(a => ({
+                    agentId: a.agentId,
+                    health: a.health,
+                    status: a.status,
+                })),
+            };
+        },
+    },
+    {
+        name: 'agent_update',
+        description: 'Update agent status or config',
+        category: 'agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'ID of agent' },
+                status: { type: 'string', description: 'New status' },
+                health: { type: 'number', description: 'Health value (0-1)' },
+                taskCount: { type: 'number', description: 'Task count' },
+                config: { type: 'object', description: 'Config updates' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const agentId = input.agentId;
+            if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
+                return { success: false, agentId, error: 'Invalid agent ID' };
+            }
+            const store = loadAgentStore();
+            const agent = Object.hasOwn(store.agents, agentId) ? store.agents[agentId] : undefined;
+            if (agent) {
+                if (input.status)
+                    agent.status = input.status;
+                if (typeof input.health === 'number')
+                    agent.health = input.health;
+                if (typeof input.taskCount === 'number')
+                    agent.taskCount = input.taskCount;
+                if (input.config) {
+                    agent.config = { ...agent.config, ...input.config };
+                }
+                saveAgentStore(store);
+                return {
+                    success: true,
+                    agentId,
+                    updated: true,
+                    agent: {
+                        agentId: agent.agentId,
+                        status: agent.status,
+                        health: agent.health,
+                        taskCount: agent.taskCount,
+                    },
+                };
+            }
+            return {
+                success: false,
+                agentId,
+                error: 'Agent not found',
+            };
+        },
+    },
+];
+//# sourceMappingURL=agent-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/agentdb-tools.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AgentDB MCP Tools — Phase 6 of ADR-053
+ *
+ * Exposes AgentDB v1 controller operations as MCP tools.
+ * Provides direct access to ReasoningBank, CausalGraph, SkillLibrary,
+ * AttestationLog, and bridge health through the MCP protocol.
+ *
+ * Security: All handlers validate input types, enforce length bounds,
+ * and sanitize error messages before returning to MCP callers.
+ *
+ * @module v1/cli/mcp-tools/agentdb-tools
+ */
+import type { MCPTool } from './types.js';
+export declare const agentdbHealth: MCPTool;
+export declare const agentdbControllers: MCPTool;
+export declare const agentdbPatternStore: MCPTool;
+export declare const agentdbPatternSearch: MCPTool;
+export declare const agentdbFeedback: MCPTool;
+export declare const agentdbCausalEdge: MCPTool;
+export declare const agentdbRoute: MCPTool;
+export declare const agentdbSessionStart: MCPTool;
+export declare const agentdbSessionEnd: MCPTool;
+export declare const agentdbHierarchicalStore: MCPTool;
+export declare const agentdbHierarchicalRecall: MCPTool;
+export declare const agentdbConsolidate: MCPTool;
+export declare const agentdbBatch: MCPTool;
+export declare const agentdbContextSynthesize: MCPTool;
+export declare const agentdbSemanticRoute: MCPTool;
+export declare const agentdbTools: MCPTool[];
+//# sourceMappingURL=agentdb-tools.d.ts.map