monomind 1.9.16 → 1.10.0

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

@@ -1,401 +0,0 @@
-/**
- * Transfer MCP Tools
- * Pattern and plugin sharing via IPFS-based decentralized registry
- *
- * @module @monomind/cli/mcp-tools/transfer-tools
- * @version 3.0.0
- */
-/**
- * Helper to create MCP tool result
- */
-function createResult(data, isError = false) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: typeof data === 'string' ? data : JSON.stringify(data, null, 2),
-            },
-        ],
-        isError,
-    };
-}
-/**
- * Cached PatternStore — initialize() may open IPFS connections, sql.js/WASM,
- * or download registry data. Re-creating on every handler call wastes work
- * and risks file-descriptor / socket-pool leaks on rapid invocations.
- */
-let cachedPatternStore = null;
-async function getPatternStore() {
-    if (cachedPatternStore)
-        return cachedPatternStore;
-    const { PatternStore } = await import('../transfer/store/index.js');
-    const store = new PatternStore();
-    await store.initialize();
-    cachedPatternStore = store;
-    return cachedPatternStore;
-}
-/**
- * Transfer MCP tools for pattern export, import, anonymization, and sharing
- */
-export const transferTools = [
-    // ═══════════════════════════════════════════════════════════════
-    // ANONYMIZATION TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_detect-pii',
-        description: 'Detect PII in content without redacting',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                content: {
-                    type: 'string',
-                    description: 'Content to scan for PII',
-                },
-            },
-            required: ['content'],
-        },
-        handler: async (input) => {
-            try {
-                const { detectPII } = await import('../transfer/anonymization/index.js');
-                const result = detectPII(input.content);
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    // ═══════════════════════════════════════════════════════════════
-    // IPFS TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_ipfs-resolve',
-        description: 'Resolve IPNS name to CID',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'IPNS name to resolve',
-                },
-            },
-            required: ['name'],
-        },
-        handler: async (input) => {
-            try {
-                const { resolveIPNS } = await import('../transfer/ipfs/client.js');
-                const result = await resolveIPNS(input.name);
-                return createResult({ success: true, cid: result });
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    // ═══════════════════════════════════════════════════════════════
-    // PATTERN STORE TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_store-search',
-        description: 'Search the pattern store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query',
-                },
-                category: {
-                    type: 'string',
-                    description: 'Filter by category',
-                },
-                minRating: {
-                    type: 'number',
-                    description: 'Minimum rating',
-                },
-                verified: {
-                    type: 'boolean',
-                    description: 'Only show verified patterns',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const results = store.search(input);
-                return createResult(results);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-info',
-        description: 'Get detailed info about a pattern',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: 'Pattern ID',
-                },
-            },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const pattern = store.getPattern(input.id);
-                if (!pattern) {
-                    return createResult({ error: 'Pattern not found' }, true);
-                }
-                return createResult(pattern);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-download',
-        description: 'Download a pattern from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: 'Pattern ID',
-                },
-                verify: {
-                    type: 'boolean',
-                    description: 'Verify pattern integrity',
-                },
-            },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const result = await store.download(input.id, { verify: input.verify });
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-featured',
-        description: 'Get featured patterns from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const featured = store.getFeatured();
-                const limit = input.limit || 10;
-                return createResult(featured.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-trending',
-        description: 'Get trending patterns from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const trending = store.getTrending();
-                const limit = input.limit || 10;
-                return createResult(trending.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    // ═══════════════════════════════════════════════════════════════
-    // PLUGIN STORE TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_plugin-search',
-        description: 'Search the plugin store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query',
-                },
-                category: {
-                    type: 'string',
-                    description: 'Filter by category',
-                },
-                type: {
-                    type: 'string',
-                    description: 'Filter by plugin type',
-                },
-                verified: {
-                    type: 'boolean',
-                    description: 'Only show verified plugins',
-                },
-                minRating: {
-                    type: 'number',
-                    description: 'Minimum rating',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService, searchPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
-                }
-                const opts = input;
-                const searchResult = searchPlugins(result.registry, opts);
-                return createResult(searchResult);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_plugin-info',
-        description: 'Get detailed info about a plugin',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Plugin name or ID',
-                },
-            },
-            required: ['name'],
-        },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
-                }
-                const name = input.name;
-                const plugin = result.registry.plugins.find((p) => p.id === name || p.name === name);
-                if (!plugin) {
-                    return createResult({ error: 'Plugin not found' }, true);
-                }
-                return createResult(plugin);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_plugin-featured',
-        description: 'Get featured plugins from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService, getFeaturedPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
-                }
-                const featured = getFeaturedPlugins(result.registry);
-                const limit = input.limit || 10;
-                return createResult(featured.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_plugin-official',
-        description: 'Get official plugins from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-        handler: async () => {
-            try {
-                const { createPluginDiscoveryService, getOfficialPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
-                }
-                const official = getOfficialPlugins(result.registry);
-                return createResult(official);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-];
-export default transferTools;
-//# sourceMappingURL=transfer-tools.js.map

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

@@ -1,37 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-export interface MCPToolInputSchema {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-}
-export interface MCPToolResult {
-    content: Array<{
-        type: 'text' | 'image' | 'resource';
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }>;
-    isError?: boolean;
-}
-/**
- * Returns the effective project working directory.
- * Prefers MONOMIND_CWD (set by the install script for global/MCP installs
- * where process.cwd() may resolve to '/') over the real process.cwd().
- */
-export declare function getProjectCwd(): string;
-export interface MCPTool {
-    name: string;
-    description: string;
-    inputSchema: MCPToolInputSchema;
-    category?: string;
-    tags?: string[];
-    version?: string;
-    cacheable?: boolean;
-    cacheTTL?: number;
-    handler: (input: Record<string, unknown>, context?: Record<string, unknown>) => Promise<MCPToolResult | unknown>;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,14 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-/**
- * Returns the effective project working directory.
- * Prefers MONOMIND_CWD (set by the install script for global/MCP installs
- * where process.cwd() may resolve to '/') over the real process.cwd().
- */
-export function getProjectCwd() {
-    return process.env.MONOMIND_CWD || process.cwd();
-}
-//# sourceMappingURL=types.js.map

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

@@ -1,9 +0,0 @@
-/**
- * WASM Agent MCP Tools
- *
- * Exposes @ruvector/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

@@ -1,230 +0,0 @@
-/**
- * WASM Agent MCP Tools
- *
- * Exposes @ruvector/rvagent-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-async function loadAgentWasm() {
-    const mod = await import('../ruvector/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