monomind 1.11.13 → 1.11.14

package/packages/@monomind/cli/dist/src/mcp/deprecation-injector.js

@@ -0,0 +1,48 @@
+/**
+ * Deprecation Injector (Task 31)
+ *
+ * Injects deprecation warnings into MCP tool responses when the
+ * invoked tool has been marked as deprecated in the ToolRegistry.
+ */
+/**
+ * Injects deprecation metadata into MCP responses.
+ */
+export class DeprecationInjector {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * If `toolName` is deprecated, augment the response with a warning.
+     *
+     * Returns the original response unmodified when the tool is not
+     * deprecated. When deprecated, adds `_deprecation` metadata.
+     *
+     * Warning format:
+     *   [DEPRECATED] Tool "<name>" is deprecated. <message>. Use "<successor>" instead.
+     */
+    inject(response, toolName) {
+        const tool = this.registry.getVersion(toolName);
+        if (!tool || !tool.deprecated) {
+            return response;
+        }
+        const parts = [`[DEPRECATED] Tool "${toolName}" is deprecated.`];
+        if (tool.deprecationMessage) {
+            parts.push(tool.deprecationMessage + '.');
+        }
+        if (tool.successor) {
+            parts.push(`Use "${tool.successor}" instead.`);
+        }
+        const warning = parts.join(' ');
+        return {
+            ...response,
+            _deprecation: {
+                warning,
+                deprecated: true,
+                successor: tool.successor ?? null,
+                deprecatedAt: tool.deprecatedAt ?? null,
+            },
+        };
+    }
+}
+//# sourceMappingURL=deprecation-injector.js.map

package/packages/@monomind/cli/dist/src/mcp/tool-registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Tool Registry (Task 31)
+ *
+ * Manages semver versioning for MCP tools with deprecation tracking
+ * and tool-to-agent impact analysis. Uses JSONL file storage.
+ */
+import type { VersionedMCPTool, ToolVersionEntry } from '../../../shared/src/types/tool-version.js';
+/**
+ * Registry for versioned MCP tools.
+ *
+ * Stores tool metadata and version history in a JSONL file.
+ * Supports deprecation marking and agent impact analysis.
+ */
+export declare class ToolRegistry {
+    private tools;
+    private history;
+    private readonly storagePath;
+    constructor(storagePath?: string);
+    /**
+     * Register a new tool or update an existing one.
+     */
+    register(tool: VersionedMCPTool): void;
+    /**
+     * Mark a tool as deprecated with an optional successor.
+     */
+    deprecate(toolName: string, message: string, successor?: string): void;
+    /**
+     * Get the current version info for a tool.
+     * Returns null if the tool is not registered.
+     */
+    getVersion(toolName: string): VersionedMCPTool | null;
+    /**
+     * List all deprecated tools.
+     */
+    listDeprecated(): VersionedMCPTool[];
+    /**
+     * Find agents that reference the given tool.
+     *
+     * Scans agent markdown files under the provided agents directory
+     * and returns slugs of agents whose `tools:` frontmatter or body
+     * mention the tool name.
+     */
+    getImpactedAgents(toolName: string, agentsDir?: string): string[];
+    /**
+     * Get the full version history for a tool, or all tools if no name given.
+     */
+    getHistory(toolName?: string): ToolVersionEntry[];
+    /**
+     * Get all registered tools.
+     */
+    listAll(): VersionedMCPTool[];
+    /**
+     * Load existing entries from the JSONL file on disk.
+     */
+    private loadFromDisk;
+    /**
+     * Append a version history entry and the current tool state to disk.
+     */
+    private appendEntry;
+}
+//# sourceMappingURL=tool-registry.d.ts.map

package/packages/@monomind/cli/dist/src/mcp/tool-registry.js

@@ -0,0 +1,246 @@
+/**
+ * Tool Registry (Task 31)
+ *
+ * Manages semver versioning for MCP tools with deprecation tracking
+ * and tool-to-agent impact analysis. Uses JSONL file storage.
+ */
+import { appendFileSync, readFileSync, existsSync, mkdirSync, readdirSync, lstatSync, } from 'fs';
+import { join, dirname, extname, resolve, sep } from 'path';
+/** Default JSONL storage path relative to project root. */
+const DEFAULT_STORAGE_PATH = '.monomind/tool-versions.jsonl';
+/**
+ * Registry for versioned MCP tools.
+ *
+ * Stores tool metadata and version history in a JSONL file.
+ * Supports deprecation marking and agent impact analysis.
+ */
+export class ToolRegistry {
+    tools = new Map();
+    history = [];
+    storagePath;
+    constructor(storagePath = DEFAULT_STORAGE_PATH) {
+        const resolvedPath = resolve(storagePath);
+        const allowedRoot = process.env.MONOMIND_DATA_DIR
+            ? resolve(process.env.MONOMIND_DATA_DIR)
+            : resolve(process.cwd());
+        if (resolvedPath !== allowedRoot && !resolvedPath.startsWith(allowedRoot + sep)) {
+            throw new Error(`Tool registry storagePath escapes allowed root: ${resolvedPath}`);
+        }
+        this.storagePath = resolvedPath;
+        this.loadFromDisk();
+    }
+    /**
+     * Register a new tool or update an existing one.
+     */
+    register(tool) {
+        const existing = this.tools.get(tool.toolName);
+        const changeType = existing
+            ? 'updated'
+            : 'added';
+        this.tools.set(tool.toolName, { ...tool });
+        const entry = {
+            toolName: tool.toolName,
+            version: tool.version,
+            changeType,
+            changedAt: new Date().toISOString(),
+            description: changeType === 'added'
+                ? `Registered tool ${tool.toolName} v${tool.version}`
+                : `Updated tool ${tool.toolName} to v${tool.version}`,
+        };
+        this.history.push(entry);
+        this.appendEntry(entry);
+    }
+    /**
+     * Mark a tool as deprecated with an optional successor.
+     */
+    deprecate(toolName, message, successor) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            throw new Error(`Tool "${toolName}" not found in registry`);
+        }
+        tool.deprecated = true;
+        tool.deprecationMessage = message;
+        tool.deprecatedAt = new Date().toISOString();
+        if (successor) {
+            tool.successor = successor;
+        }
+        const entry = {
+            toolName,
+            version: tool.version,
+            changeType: 'deprecated',
+            changedAt: tool.deprecatedAt,
+            description: message,
+        };
+        this.history.push(entry);
+        this.appendEntry(entry);
+    }
+    /**
+     * Get the current version info for a tool.
+     * Returns null if the tool is not registered.
+     */
+    getVersion(toolName) {
+        return this.tools.get(toolName) ?? null;
+    }
+    /**
+     * List all deprecated tools.
+     */
+    listDeprecated() {
+        const result = [];
+        for (const tool of this.tools.values()) {
+            if (tool.deprecated) {
+                result.push({ ...tool });
+            }
+        }
+        return result;
+    }
+    /**
+     * Find agents that reference the given tool.
+     *
+     * Scans agent markdown files under the provided agents directory
+     * and returns slugs of agents whose `tools:` frontmatter or body
+     * mention the tool name.
+     */
+    getImpactedAgents(toolName, agentsDir = 'agents') {
+        // Reject empty or short tool names — `content.includes('')` returns true
+        // for every file, turning the registry into a directory enumerator.
+        if (typeof toolName !== 'string' || toolName.length < 2 || !/^[a-zA-Z0-9_.-]+$/.test(toolName)) {
+            return [];
+        }
+        const impacted = [];
+        const mdFiles = collectMdFiles(agentsDir);
+        for (const filePath of mdFiles) {
+            let content;
+            try {
+                content = readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            if (content.includes(toolName)) {
+                // Derive slug from filename (strip .md extension)
+                const parts = filePath.split('/');
+                const filename = parts[parts.length - 1];
+                const slug = filename.replace(/\.md$/, '');
+                impacted.push(slug);
+            }
+        }
+        return impacted;
+    }
+    /**
+     * Get the full version history for a tool, or all tools if no name given.
+     */
+    getHistory(toolName) {
+        if (!toolName) {
+            return [...this.history];
+        }
+        return this.history.filter((e) => e.toolName === toolName);
+    }
+    /**
+     * Get all registered tools.
+     */
+    listAll() {
+        return Array.from(this.tools.values()).map((t) => ({ ...t }));
+    }
+    // ---- Private helpers ----
+    /**
+     * Load existing entries from the JSONL file on disk.
+     */
+    loadFromDisk() {
+        if (!existsSync(this.storagePath)) {
+            return;
+        }
+        let raw;
+        try {
+            raw = readFileSync(this.storagePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const NAME_RE = /^[a-zA-Z0-9_.-]{1,128}$/;
+        const STR_MAX = 500;
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const record = JSON.parse(trimmed);
+                if (!record || typeof record !== 'object')
+                    continue;
+                // Validate fields before storage. The JSONL file lives on disk; an
+                // attacker with local write access could otherwise plant attacker-controlled
+                // strings (e.g. malicious deprecationMessage with markup) that reach
+                // downstream renderers (DOT visualizer, deprecation-injector warnings).
+                if (record._type === 'tool') {
+                    if (typeof record.toolName !== 'string' || !NAME_RE.test(record.toolName))
+                        continue;
+                    if (record.successor !== undefined && (typeof record.successor !== 'string' || !NAME_RE.test(record.successor)))
+                        continue;
+                    if (record.deprecationMessage !== undefined && (typeof record.deprecationMessage !== 'string' || record.deprecationMessage.length > STR_MAX))
+                        continue;
+                    this.tools.set(record.toolName, record);
+                }
+                else if (record._type === 'history') {
+                    if (typeof record.toolName !== 'string' || !NAME_RE.test(record.toolName))
+                        continue;
+                    this.history.push(record);
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+    }
+    /**
+     * Append a version history entry and the current tool state to disk.
+     */
+    appendEntry(entry) {
+        const dir = dirname(this.storagePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const tool = this.tools.get(entry.toolName);
+        const lines = [];
+        if (tool) {
+            lines.push(JSON.stringify({ _type: 'tool', ...tool }));
+        }
+        lines.push(JSON.stringify({ _type: 'history', ...entry }));
+        appendFileSync(this.storagePath, lines.join('\n') + '\n', 'utf-8');
+    }
+}
+/**
+ * Recursively collect all `.md` files under a directory.
+ */
+function collectMdFiles(root) {
+    const results = [];
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = join(root, entry);
+        let stat;
+        try {
+            // Use lstatSync so symlinks aren't followed — otherwise a symlink under
+            // `agentsDir` could redirect this scan into arbitrary filesystem
+            // locations, which combined with `getImpactedAgents` becomes a content
+            // oracle that fingerprints arbitrary text files outside the project.
+            stat = lstatSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isSymbolicLink())
+            continue;
+        if (stat.isDirectory()) {
+            results.push(...collectMdFiles(full));
+        }
+        else if (stat.isFile() && extname(entry) === '.md') {
+            results.push(full);
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=tool-registry.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @monoes/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+import type { MCPTool } from './types.js';
+export declare const wasmAgentTools: MCPTool[];
+//# sourceMappingURL=wasm-agent-tools.d.ts.map

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

@@ -0,0 +1,230 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @monoes/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+async function loadAgentWasm() {
+    const mod = await import('../monovector/agent-wasm.js');
+    return mod;
+}
+export const wasmAgentTools = [
+    {
+        name: 'wasm_agent_create',
+        description: 'Create a sandboxed WASM agent with virtual filesystem (no OS access). Optionally use a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Gallery template name (coder, researcher, tester, reviewer, security, swarm)' },
+                model: { type: 'string', description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)' },
+                instructions: { type: 'string', description: 'System instructions for the agent' },
+                maxTurns: { type: 'number', description: 'Max conversation turns (default: 50)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                if (args.template) {
+                    const info = await wasm.createAgentFromTemplate(args.template);
+                    return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, source: 'gallery' }, null, 2) }] };
+                }
+                const info = await wasm.createWasmAgent({
+                    model: args.model,
+                    instructions: args.instructions,
+                    maxTurns: args.maxTurns,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_prompt',
+        description: 'Send a prompt to a WASM agent and get a response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                input: { type: 'string', description: 'User prompt to send' },
+            },
+            required: ['agentId', 'input'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const result = await wasm.promptWasmAgent(args.agentId, args.input);
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_tool',
+        description: 'Execute a tool on a WASM agent sandbox. Tools: read_file, write_file, edit_file, write_todos, list_files. Use flat format: {tool, path, content, ...}.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                toolName: { type: 'string', description: 'Tool name (read_file, write_file, edit_file, write_todos, list_files)' },
+                toolInput: { type: 'object', description: 'Tool parameters (flat: {path, content, old_string, new_string, todos})' },
+            },
+            required: ['agentId', 'toolName'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                // Flat format: {tool: 'write_file', path: '...', content: '...'}
+                const toolCall = {
+                    tool: args.toolName,
+                    ...(args.toolInput ?? {}),
+                };
+                const result = await wasm.executeWasmTool(args.agentId, toolCall);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_list',
+        description: 'List all active WASM agents.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const agents = wasm.listWasmAgents();
+                return { content: [{ type: 'text', text: JSON.stringify({ agents, count: agents.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_terminate',
+        description: 'Terminate a WASM agent and free resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const ok = wasm.terminateWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: ok }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_files',
+        description: 'Get a WASM agent\'s available tools and info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const tools = wasm.getWasmAgentTools(args.agentId);
+                const info = wasm.getWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ tools, fileCount: info?.fileCount ?? 0, turnCount: info?.turnCount ?? 0 }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_export',
+        description: 'Export a WASM agent\'s full state (config, filesystem, conversation) as JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const state = wasm.exportWasmState(args.agentId);
+                return { content: [{ type: 'text', text: state }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_list',
+        description: 'List all available WASM agent gallery templates (Coder, Researcher, Tester, Reviewer, Security, Swarm).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const templates = await wasm.listGalleryTemplates();
+                return { content: [{ type: 'text', text: JSON.stringify({ templates, count: templates.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_search',
+        description: 'Search WASM agent gallery templates by query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const results = await wasm.searchGalleryTemplates(args.query);
+                return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_create',
+        description: 'Create a WASM agent from a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name (coder, researcher, tester, reviewer, security, swarm)' },
+            },
+            required: ['template'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const info = await wasm.createAgentFromTemplate(args.template);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, template: args.template }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+];
+//# sourceMappingURL=wasm-agent-tools.js.map

package/packages/@monomind/cli/dist/src/model/complexity-scorer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Heuristic complexity scorer for task descriptions.
+ *
+ * Returns a score in [0, 100] that drives automatic model-tier selection.
+ * Higher scores indicate tasks that benefit from more capable (and costly)
+ * models.
+ */
+/**
+ * Agent slugs that inherently deal with high-complexity work.
+ * When one of these agents is involved the score gets a +20 bonus.
+ */
+export declare const HIGH_COMPLEXITY_AGENTS: ReadonlySet<string>;
+/**
+ * Score the complexity of a task description.
+ *
+ * @param taskDescription - Free-text description of the task.
+ * @param agentSlug       - Optional agent identifier; certain agents boost the score.
+ * @returns A number in [0, 100].
+ */
+export declare function scoreComplexity(taskDescription: string, agentSlug?: string): number;
+//# sourceMappingURL=complexity-scorer.d.ts.map