monomind 2.7.12 → 2.7.13

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

@@ -1,30 +0,0 @@
-/**
- * Agent MCP Tools for CLI
- *
- * Tool definitions for agent lifecycle management with file persistence.
- * Includes model routing integration for intelligent model selection.
- */
-import { type MCPTool } from './types.js';
-type ClaudeModel = 'haiku' | 'sonnet' | 'opus' | 'inherit';
-interface AgentRecord {
-    agentId: string;
-    agentType: string;
-    status: 'idle' | 'busy' | 'terminated';
-    health: number;
-    taskCount: number;
-    config: Record<string, unknown>;
-    createdAt: string;
-    domain?: string;
-    model?: ClaudeModel;
-    modelRoutedBy?: 'explicit' | 'router' | 'agent-booster' | 'default';
-    lastResult?: Record<string, unknown>;
-}
-interface AgentStore {
-    agents: Record<string, AgentRecord>;
-    version: string;
-}
-export declare function loadAgentStore(): AgentStore;
-export declare function loadAgentStoreOrNull(): AgentStore | null;
-export declare const agentTools: MCPTool[];
-export {};
-//# sourceMappingURL=agent-tools.d.ts.map

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

@@ -1,603 +0,0 @@
-/**
- * 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 { getMonomindDataRoot, migrateLegacyStoreFile } from './types.js';
-// Storage paths — relative to the git-safe data root (see getMonomindDataRoot()).
-// Canonical location matches task-tools.ts/session-tools.ts/hive-mind-tools.ts/
-// swarm-tools.ts so the agent store is a single physical file across all tools.
-const AGENT_DIR = 'agents';
-const AGENT_FILE = 'store.json';
-function getAgentDir() {
-    return join(getMonomindDataRoot(), 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;
-// Exported so other tool modules reading the same physical store file
-// (e.g. hive-mind-tools.ts) can reuse this hardened loader instead of
-// maintaining their own weaker copy (missing the size cap / __proto__ guard).
-export function loadAgentStore() {
-    return loadAgentStoreOrNull() ?? { agents: {}, version: '3.0.0' };
-}
-// Like loadAgentStore(), but distinguishes "file doesn't exist yet" (returns
-// the empty default store — safe to build on and save) from "file exists but
-// failed to read/parse, or is corrupt/oversized" (returns null). Handlers
-// that are about to mutate-and-save MUST use this instead of loadAgentStore()
-// and bail out on null, or a transient read failure silently wipes every
-// previously-spawned agent on the next save (the exact bug found and fixed
-// in task-tools.ts's task_assign earlier this session — same pattern here).
-// Exported for other tool modules with their own mutate-and-save paths
-// against the same agent store file — see hive-mind-tools.ts.
-export function loadAgentStoreOrNull() {
-    try {
-        const path = getAgentPath();
-        migrateLegacyStoreFile(path, join(AGENT_DIR, AGENT_FILE));
-        if (existsSync(path)) {
-            if (statSync(path).size > MAX_AGENT_STORE_BYTES)
-                return null;
-            const data = readFileSync(path, 'utf-8');
-            const parsed = JSON.parse(data);
-            if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
-                return null;
-            return parsed;
-        }
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[loadAgentStore] failed to read/parse agent store — refusing to proceed to avoid overwriting it with an empty one:', e);
-        return null;
-    }
-    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',
-};
-/**
- * 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. Task-based model router modules were never shipped — fall through to agent-type defaults.
-    // 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: 'Register a new agent record (type, model preference, status) in the persistent agent store. This creates a database entry, not a running agent — use Claude Code\'s Task tool to actually execute work.',
-        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 = loadAgentStoreOrNull();
-            if (!store) {
-                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to spawn to avoid overwriting real agent data. Retry, or check the store file if this persists.' };
-            }
-            // Cap agentId: used as the JSON object key in store.agents[agentId].
-            // An oversized key inflates the on-disk store for every spawned agent.
-            // Cap agentType/domain: persisted as AgentRecord field values.
-            const MAX_AGENT_ID_LEN = 256;
-            const MAX_AGENT_TYPE_LEN = 128;
-            const MAX_AGENT_DOMAIN_LEN = 256;
-            const rawAgentId = input.agentId || `agent-${Date.now()}-${randomBytes(4).toString('hex')}`;
-            const agentId = typeof rawAgentId === 'string' && rawAgentId.length > MAX_AGENT_ID_LEN
-                ? rawAgentId.slice(0, MAX_AGENT_ID_LEN) : rawAgentId;
-            const rawAgentType = input.agentType;
-            const agentType = typeof rawAgentType === 'string' && rawAgentType.length > MAX_AGENT_TYPE_LEN
-                ? rawAgentType.slice(0, MAX_AGENT_TYPE_LEN) : rawAgentType;
-            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;
-            const rawDomain = input.domain;
-            const domain = typeof rawDomain === 'string' && rawDomain.length > MAX_AGENT_DOMAIN_LEN
-                ? rawDomain.slice(0, MAX_AGENT_DOMAIN_LEN) : rawDomain;
-            // 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,
-                model: routingResult.model,
-                modelRoutedBy: routingResult.routedBy,
-            };
-            store.agents[agentId] = agent;
-            saveAgentStore(store);
-            // 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 = loadAgentStoreOrNull();
-            if (!store) {
-                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to terminate to avoid overwriting real agent data.' };
-            }
-            if (Object.hasOwn(store.agents, agentId)) {
-                store.agents[agentId].status = 'terminated';
-                saveAgentStore(store);
-                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 (pass "all" or omit to include every status)' },
-                domain: { type: 'string', description: 'Filter by domain' },
-                agentType: { type: 'string', description: 'Filter by agent type' },
-                includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadAgentStore();
-            let agents = Object.values(store.agents);
-            // Filter by status. 'all' (the CLI's `--all` flag sends this literal
-            // string) means "no status filter" — it used to be treated as a real
-            // status value to match against, which no agent ever has, so `--all`
-            // silently returned zero agents instead of every agent.
-            if (input.status && input.status !== 'all') {
-                agents = agents.filter(a => a.status === input.status);
-            }
-            else if (input.status !== 'all' && !input.includeTerminated) {
-                agents = agents.filter(a => a.status !== 'terminated');
-            }
-            // Filter by domain
-            if (input.domain) {
-                agents = agents.filter(a => a.domain === input.domain);
-            }
-            // Filter by agent type — the CLI's `--type` flag has sent this since
-            // it was added, but this handler never read it, so `--type` was a
-            // silent no-op that returned every agent regardless of the filter.
-            if (input.agentType) {
-                agents = agents.filter(a => a.agentType === input.agentType);
-            }
-            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,
-                    agentType: input.agentType,
-                    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 (default: status)' },
-                targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
-                agentType: { type: 'string', description: 'Agent type filter' },
-            },
-            // `action` is deliberately NOT required: the handler defaults it to
-            // 'status', and the CLI `agent pool` command relies on that default.
-            // It was previously declared required, which nothing enforced — once
-            // required params became enforced, that false contract broke the CLI.
-        },
-        handler: async (input) => {
-            const action = input.action || 'status'; // Default to status
-            const store = loadAgentStoreOrNull();
-            if (!store) {
-                // 'scale'/'drain' would otherwise build on an empty store and save it,
-                // wiping every real agent; 'status' reporting all-zeros on a corrupt
-                // store would also be misleading, so all three branches bail here.
-                return { action, error: 'Agent store is unreadable/corrupt — refusing to proceed to avoid overwriting real agent data.' };
-            }
-            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
-            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;
-                // Scope "remaining" to the same population drain operated over — when
-                // filtered by agentType, agents.length (all non-terminated agents,
-                // any type) minus drained (only that type's count) mixed two
-                // different populations and produced a meaningless total.
-                const scoped = agentType ? agents.filter(a => a.agentType === agentType) : agents;
-                let drained = 0;
-                for (const agent of scoped) {
-                    if (agent.status === 'idle') {
-                        store.agents[agent.agentId].status = 'terminated';
-                        drained++;
-                    }
-                }
-                saveAgentStore(store);
-                return {
-                    action,
-                    agentType: agentType || 'all',
-                    drained,
-                    remaining: scoped.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 = loadAgentStoreOrNull();
-            if (!store) {
-                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to update to avoid overwriting real agent data.' };
-            }
-            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/analyze-tools.d.ts

@@ -1,38 +0,0 @@
-/**
- * Analyze MCP Tools
- * Provides diff analysis and classification via MCP protocol
- */
-import type { MCPTool } from './types.js';
-/**
- * Diff Analysis Tool
- * Analyzes git diffs for change risk assessment and classification
- */
-export declare const analyzeDiffTool: MCPTool;
-/**
- * Diff Risk Assessment Tool
- * Focused risk assessment without full analysis
- */
-export declare const diffRiskTool: MCPTool;
-/**
- * Diff Classification Tool
- * Classify change type without full analysis
- */
-export declare const diffClassifyTool: MCPTool;
-/**
- * Diff Reviewers Tool
- * Suggest reviewers for changes
- */
-export declare const diffReviewersTool: MCPTool;
-/**
- * File Risk Tool
- * Assess risk for a specific file path
- */
-export declare const fileRiskTool: MCPTool;
-/**
- * Diff Stats Tool
- * Get quick diff statistics
- */
-export declare const diffStatsTool: MCPTool;
-export declare const analyzeTools: MCPTool[];
-export default analyzeTools;
-//# sourceMappingURL=analyze-tools.d.ts.map