monomind 2.7.5 → 2.7.7

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

@@ -1,333 +0,0 @@
-/**
- * WASM Agent CLI Subcommands
- *
- * Exposes @monoes/rvagent-wasm operations via the `agent` CLI command.
- * Wraps functions from monovector/agent-wasm.ts for CLI usage.
- */
-import { output } from '../output.js';
-const WASM_NOT_AVAILABLE_MSG = '@monoes/rvagent-wasm is not installed.\n' +
-    'Install it with: npm install @monoes/rvagent-wasm';
-async function loadWasm() {
-    const mod = await import('../monovector/agent-wasm.js');
-    return mod;
-}
-// agent wasm-status
-export const wasmStatusCommand = {
-    name: 'wasm-status',
-    description: 'Check rvagent-wasm availability, version, and capabilities',
-    options: [],
-    examples: [
-        { command: 'monomind agent wasm-status', description: 'Check WASM agent runtime status' },
-    ],
-    action: async (ctx) => {
-        try {
-            const wasm = await loadWasm();
-            const available = await wasm.isAgentWasmAvailable();
-            if (!available) {
-                output.writeln();
-                output.printWarning(WASM_NOT_AVAILABLE_MSG);
-                if (ctx.flags.format === 'json') {
-                    output.printJson({ available: false });
-                }
-                return { success: true, data: { available: false } };
-            }
-            // Init to get full status
-            await wasm.initAgentWasm();
-            const agents = wasm.listWasmAgents();
-            let galleryCount = 0;
-            let categories = {};
-            try {
-                galleryCount = await wasm.getGalleryCount();
-                categories = await wasm.getGalleryCategories();
-            }
-            catch {
-                // Gallery may not be available in all builds
-            }
-            const statusData = {
-                available: true,
-                activeAgents: agents.length,
-                gallery: {
-                    templates: galleryCount,
-                    categories,
-                },
-                tools: ['read_file', 'write_file', 'edit_file', 'write_todos', 'list_files'],
-                features: ['sandboxed-execution', 'virtual-filesystem', 'gallery-templates', 'rvf-containers', 'mcp-bridge'],
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(statusData);
-                return { success: true, data: statusData };
-            }
-            output.writeln();
-            output.writeln(output.bold('WASM Agent Runtime'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 40 },
-                ],
-                data: [
-                    { property: 'Available', value: output.success('yes') },
-                    { property: 'Active Agents', value: String(agents.length) },
-                    { property: 'Gallery Templates', value: String(galleryCount) },
-                    { property: 'Sandbox Tools', value: statusData.tools.join(', ') },
-                    { property: 'Features', value: statusData.features.join(', ') },
-                ],
-            });
-            if (Object.keys(categories).length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Gallery Categories'));
-                output.printTable({
-                    columns: [
-                        { key: 'category', header: 'Category', width: 20 },
-                        { key: 'count', header: 'Templates', width: 10, align: 'right' },
-                    ],
-                    data: Object.entries(categories).map(([category, count]) => ({ category, count })),
-                });
-            }
-            return { success: true, data: statusData };
-        }
-        catch (error) {
-            output.printError(`WASM status check failed: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// agent wasm-create
-export const wasmCreateCommand = {
-    name: 'wasm-create',
-    description: 'Create a WASM-sandboxed agent',
-    options: [
-        {
-            name: 'template',
-            short: 't',
-            description: 'Gallery template (coder, researcher, tester, reviewer, security, swarm)',
-            type: 'string',
-        },
-        {
-            name: 'model',
-            short: 'm',
-            description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)',
-            type: 'string',
-        },
-        {
-            name: 'instructions',
-            short: 'i',
-            description: 'System instructions for the agent',
-            type: 'string',
-        },
-        {
-            name: 'max-turns',
-            description: 'Maximum conversation turns (default: 50)',
-            type: 'number',
-            default: 50,
-        },
-    ],
-    examples: [
-        { command: 'monomind agent wasm-create', description: 'Create a default WASM agent' },
-        { command: 'monomind agent wasm-create -t coder', description: 'Create from gallery template' },
-        { command: 'monomind agent wasm-create -m "anthropic:claude-sonnet-4-20250514" -i "You are a security auditor"', description: 'Create with custom config' },
-    ],
-    action: async (ctx) => {
-        try {
-            const wasm = await loadWasm();
-            const available = await wasm.isAgentWasmAvailable();
-            if (!available) {
-                output.printError(WASM_NOT_AVAILABLE_MSG);
-                return { success: false, exitCode: 1 };
-            }
-            const template = ctx.flags.template;
-            let info;
-            if (template) {
-                output.printInfo(`Creating WASM agent from template: ${output.highlight(template)}`);
-                info = await wasm.createAgentFromTemplate(template);
-            }
-            else {
-                output.printInfo('Creating WASM agent...');
-                info = await wasm.createWasmAgent({
-                    model: ctx.flags.model,
-                    instructions: ctx.flags.instructions,
-                    maxTurns: ctx.flags['max-turns'],
-                });
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson({ success: true, agent: info, source: template ? 'gallery' : 'custom' });
-                return { success: true, data: info };
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 45 },
-                ],
-                data: [
-                    { property: 'ID', value: info.id },
-                    { property: 'State', value: info.state },
-                    { property: 'Model', value: info.model },
-                    { property: 'Turn Count', value: String(info.turnCount) },
-                    { property: 'File Count', value: String(info.fileCount) },
-                    { property: 'Created', value: info.createdAt },
-                    ...(template ? [{ property: 'Template', value: template }] : []),
-                ],
-            });
-            output.writeln();
-            output.printSuccess(`WASM agent created: ${info.id}`);
-            return { success: true, data: info };
-        }
-        catch (error) {
-            output.printError(`Failed to create WASM agent: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// agent wasm-prompt
-export const wasmPromptCommand = {
-    name: 'wasm-prompt',
-    description: 'Send a prompt to a WASM agent',
-    options: [
-        {
-            name: 'agent-id',
-            short: 'a',
-            description: 'WASM agent ID (required)',
-            type: 'string',
-        },
-        {
-            name: 'input',
-            short: 'i',
-            description: 'Prompt text to send',
-            type: 'string',
-        },
-    ],
-    examples: [
-        { command: 'monomind agent wasm-prompt -a wasm-agent-1-abc -i "Write a hello world"', description: 'Send prompt to WASM agent' },
-    ],
-    action: async (ctx) => {
-        const agentId = ctx.flags['agent-id'] || ctx.args[0];
-        const promptInput = ctx.flags.input || ctx.args[1];
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --agent-id or -a');
-            return { success: false, exitCode: 1 };
-        }
-        if (!promptInput) {
-            output.printError('Prompt input is required. Use --input or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const wasm = await loadWasm();
-            const available = await wasm.isAgentWasmAvailable();
-            if (!available) {
-                output.printError(WASM_NOT_AVAILABLE_MSG);
-                return { success: false, exitCode: 1 };
-            }
-            output.printInfo(`Sending prompt to ${output.highlight(agentId)}...`);
-            const result = await wasm.promptWasmAgent(agentId, promptInput);
-            if (ctx.flags.format === 'json') {
-                output.printJson({ agentId, response: result });
-                return { success: true, data: { agentId, response: result } };
-            }
-            output.writeln();
-            output.writeln(output.bold('Response'));
-            output.writeln();
-            output.writeln(result);
-            // Show updated agent info
-            const info = wasm.getWasmAgent(agentId);
-            if (info) {
-                output.writeln();
-                output.writeln(output.dim(`[turns: ${info.turnCount}, files: ${info.fileCount}, state: ${info.state}]`));
-            }
-            return { success: true, data: { agentId, response: result } };
-        }
-        catch (error) {
-            output.printError(`Prompt failed: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// agent wasm-gallery
-export const wasmGalleryCommand = {
-    name: 'wasm-gallery',
-    description: 'List available WASM agent gallery templates',
-    options: [
-        {
-            name: 'search',
-            short: 's',
-            description: 'Search templates by query',
-            type: 'string',
-        },
-        {
-            name: 'category',
-            short: 'c',
-            description: 'Filter by category',
-            type: 'string',
-        },
-    ],
-    examples: [
-        { command: 'monomind agent wasm-gallery', description: 'List all gallery templates' },
-        { command: 'monomind agent wasm-gallery -s coder', description: 'Search gallery templates' },
-    ],
-    action: async (ctx) => {
-        try {
-            const wasm = await loadWasm();
-            const available = await wasm.isAgentWasmAvailable();
-            if (!available) {
-                output.printError(WASM_NOT_AVAILABLE_MSG);
-                return { success: false, exitCode: 1 };
-            }
-            const searchQuery = ctx.flags.search;
-            const category = ctx.flags.category;
-            let templates;
-            if (searchQuery) {
-                output.printInfo(`Searching gallery for: ${output.highlight(searchQuery)}`);
-                templates = await wasm.searchGalleryTemplates(searchQuery);
-            }
-            else {
-                templates = await wasm.listGalleryTemplates();
-            }
-            // Filter by category if specified
-            if (category) {
-                templates = templates.filter((t) => t.category.toLowerCase() === category.toLowerCase());
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson({ templates, count: templates.length });
-                return { success: true, data: { templates, count: templates.length } };
-            }
-            output.writeln();
-            output.writeln(output.bold('WASM Agent Gallery'));
-            output.writeln();
-            if (templates.length === 0) {
-                output.printInfo('No templates found matching criteria');
-                return { success: true, data: { templates: [], count: 0 } };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'ID', width: 20 },
-                    { key: 'name', header: 'Name', width: 18 },
-                    { key: 'category', header: 'Category', width: 12 },
-                    { key: 'description', header: 'Description', width: 35 },
-                    { key: 'version', header: 'Version', width: 10 },
-                ],
-                data: templates.map((t) => ({
-                    id: t.id,
-                    name: t.name,
-                    category: t.category,
-                    description: t.description.length > 35 ? t.description.slice(0, 32) + '...' : t.description,
-                    version: t.version,
-                })),
-            });
-            output.writeln();
-            output.printInfo(`${templates.length} template(s) found. Create with: agent wasm-create -t <id>`);
-            return { success: true, data: { templates, count: templates.length } };
-        }
-        catch (error) {
-            output.printError(`Gallery listing failed: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-/** All WASM subcommands for the agent command */
-export const wasmSubcommands = [
-    wasmStatusCommand,
-    wasmCreateCommand,
-    wasmPromptCommand,
-    wasmGalleryCommand,
-];
-//# sourceMappingURL=agent-wasm.js.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-comms.d.ts

@@ -1,11 +0,0 @@
-/**
- * Hive Mind communication subcommands — join, leave, consensus, broadcast, memory, shutdown
- */
-import type { Command } from '../types.js';
-export declare const joinCommand: Command;
-export declare const leaveCommand: Command;
-export declare const consensusCommand: Command;
-export declare const broadcastCommand: Command;
-export declare const memorySubCommand: Command;
-export declare const shutdownCommand: Command;
-//# sourceMappingURL=hive-mind-comms.d.ts.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-comms.js

@@ -1,249 +0,0 @@
-/**
- * Hive Mind communication subcommands — join, leave, consensus, broadcast, memory, shutdown
- */
-import { output } from '../output.js';
-import { confirm } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { MAX_MESSAGE_LEN, MAX_KEY_LEN, MAX_VALUE_LEN, MAX_AGENT_ID_LEN, } from './hive-mind-helpers.js';
-export const joinCommand = {
-    name: 'join',
-    description: 'Join an agent to the hive mind',
-    options: [
-        { name: 'agent-id', short: 'a', description: 'Agent ID to join', type: 'string' },
-        { name: 'role', short: 'r', description: 'Agent role (worker, specialist, scout)', type: 'string', default: 'worker' }
-    ],
-    action: async (ctx) => {
-        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --agent-id or -a flag, or provide as argument.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('hive-mind_join', { agentId, role: ctx.flags.role });
-            if (!result.success) {
-                output.printError(result.error || 'Failed');
-                return { success: false, exitCode: 1 };
-            }
-            output.printSuccess(`Agent ${agentId} joined hive (${result.totalWorkers} workers)`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Join error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const leaveCommand = {
-    name: 'leave',
-    description: 'Remove an agent from the hive mind',
-    options: [
-        { name: 'agent-id', short: 'a', description: 'Agent ID to remove', type: 'string' }
-    ],
-    action: async (ctx) => {
-        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
-        if (!agentId) {
-            output.printError('Agent ID required.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('hive-mind_leave', { agentId });
-            if (!result.success) {
-                output.printError(result.error || 'Failed');
-                return { success: false, exitCode: 1 };
-            }
-            output.printSuccess(`Agent ${agentId} left hive (${result.remainingWorkers} remaining)`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Leave error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const consensusCommand = {
-    name: 'consensus',
-    description: 'Manage consensus proposals and voting',
-    options: [
-        { name: 'action', short: 'a', description: 'Consensus action', type: 'string', choices: ['propose', 'vote', 'status', 'list'], default: 'list' },
-        { name: 'proposal-id', short: 'p', description: 'Proposal ID', type: 'string' },
-        { name: 'type', short: 't', description: 'Proposal type', type: 'string' },
-        { name: 'value', description: 'Proposal value', type: 'string' },
-        { name: 'vote', short: 'v', description: 'Vote (yes/no)', type: 'string' },
-        { name: 'voter-id', description: 'Voter agent ID', type: 'string' },
-        { name: 'strategy', description: 'Consensus strategy override (bft, raft, quorum) — defaults to the strategy chosen at init', type: 'string', choices: ['bft', 'raft', 'quorum'] }
-    ],
-    action: async (ctx) => {
-        const action = ctx.flags.action || 'list';
-        try {
-            // Note: the parser normalizes flag keys to camelCase, so kebab-case
-            // option names ('proposal-id', 'voter-id') never populate ctx.flags —
-            // only 'proposalId'/'voterId' do. Read the camelCase form.
-            const result = await callMCPTool('hive-mind_consensus', {
-                action,
-                proposalId: ctx.flags.proposalId,
-                type: ctx.flags.type,
-                value: ctx.flags.value,
-                vote: ctx.flags.vote === 'yes',
-                voterId: ctx.flags.voterId,
-                strategy: ctx.flags.strategy
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            if (action === 'list') {
-                output.writeln(output.bold('\nPending Proposals'));
-                const pending = result.pending || [];
-                if (pending.length === 0)
-                    output.printInfo('No pending proposals');
-                else
-                    output.printTable({ columns: [{ key: 'proposalId', header: 'ID', width: 30 }, { key: 'type', header: 'Type', width: 12 }], data: pending });
-            }
-            else if (action === 'propose') {
-                output.printSuccess(`Proposal created: ${result.proposalId}`);
-            }
-            else if (action === 'vote') {
-                output.printSuccess(`Vote recorded (For: ${result.votesFor}, Against: ${result.votesAgainst})`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Consensus error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const broadcastCommand = {
-    name: 'broadcast',
-    description: 'Broadcast a message to all workers in the hive',
-    options: [
-        { name: 'message', short: 'm', description: 'Message to broadcast', type: 'string', required: true },
-        { name: 'priority', short: 'p', description: 'Message priority', type: 'string', choices: ['low', 'normal', 'high', 'critical'], default: 'normal' },
-        { name: 'from', short: 'f', description: 'Sender agent ID', type: 'string' }
-    ],
-    action: async (ctx) => {
-        const message = (ctx.args.join(' ') || ctx.flags.message || '').slice(0, MAX_MESSAGE_LEN);
-        if (!message) {
-            output.printError('Message required. Use --message or -m flag.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('hive-mind_broadcast', {
-                message,
-                priority: ctx.flags.priority,
-                fromId: typeof ctx.flags.from === 'string' ? ctx.flags.from.slice(0, MAX_AGENT_ID_LEN) : undefined
-            });
-            if (!result.success) {
-                output.printError(result.error || 'Failed');
-                return { success: false, exitCode: 1 };
-            }
-            output.printSuccess(`Message broadcast to ${result.recipients} workers (ID: ${result.messageId})`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Broadcast error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const memorySubCommand = {
-    name: 'memory',
-    description: 'Access hive shared memory',
-    options: [
-        { name: 'action', short: 'a', description: 'Memory action', type: 'string', choices: ['get', 'set', 'delete', 'list'], default: 'list' },
-        { name: 'key', short: 'k', description: 'Memory key', type: 'string' },
-        { name: 'value', short: 'v', description: 'Value to store', type: 'string' }
-    ],
-    action: async (ctx) => {
-        const action = ctx.flags.action || 'list';
-        const key = typeof ctx.flags.key === 'string' ? ctx.flags.key.slice(0, MAX_KEY_LEN) : undefined;
-        const value = typeof ctx.flags.value === 'string' ? ctx.flags.value.slice(0, MAX_VALUE_LEN) : undefined;
-        if ((action === 'get' || action === 'delete') && !key) {
-            output.printError('Key required for get/delete.');
-            return { success: false, exitCode: 1 };
-        }
-        if (action === 'set' && (!key || value === undefined)) {
-            output.printError('Key and value required for set.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('hive-mind_memory', { action, key, value });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            if (action === 'list') {
-                const keys = result.keys || [];
-                output.writeln(output.bold(`\nShared Memory (${result.count} keys)`));
-                if (keys.length === 0)
-                    output.printInfo('No keys in shared memory');
-                else
-                    output.printList(keys.map(k => output.highlight(k)));
-            }
-            else if (action === 'get') {
-                output.writeln(output.bold(`\nKey: ${key}`));
-                output.writeln(result.exists ? `Value: ${JSON.stringify(result.value, null, 2)}` : 'Key not found');
-            }
-            else if (action === 'set') {
-                output.printSuccess(`Set ${key} in shared memory`);
-            }
-            else if (action === 'delete') {
-                output.printSuccess(result.deleted ? `Deleted ${key}` : `Key ${key} did not exist`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Memory error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const shutdownCommand = {
-    name: 'shutdown',
-    description: 'Shutdown the hive mind',
-    options: [
-        { name: 'force', short: 'f', description: 'Force shutdown', type: 'boolean', default: false },
-        { name: 'save-state', short: 's', description: 'Save state before shutdown', type: 'boolean', default: true }
-    ],
-    action: async (ctx) => {
-        const force = ctx.flags.force;
-        // Note: the parser normalizes flag keys to camelCase — 'save-state' never
-        // populates ctx.flags; only 'saveState' does.
-        const saveState = ctx.flags.saveState;
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: 'Shutdown the hive mind? All agents will be terminated.',
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo('Shutting down hive mind...');
-        const spinner = output.createSpinner({ text: 'Graceful shutdown in progress...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hive-mind_shutdown', { force, saveState });
-            spinner.succeed('Hive mind shutdown complete');
-            output.writeln();
-            output.printList([
-                `Agents terminated: ${result.agentsTerminated}`,
-                `State saved: ${result.stateSaved ? 'Yes' : 'No'}`,
-                `Shutdown time: ${result.shutdownTime}`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Shutdown failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Shutdown error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-//# sourceMappingURL=hive-mind-comms.js.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-helpers.d.ts

@@ -1,35 +0,0 @@
-/**
- * Hive Mind shared types, constants, and format helpers
- */
-export declare const MAX_OBJECTIVE_LEN = 2000;
-export declare const MAX_TASK_DESC_LEN = 4000;
-export declare const MAX_MESSAGE_LEN = 2000;
-export declare const MAX_KEY_LEN = 256;
-export declare const MAX_VALUE_LEN = 65536;
-export declare const MAX_AGENT_ID_LEN = 128;
-export interface HiveWorker {
-    agentId: string;
-    role: string;
-    type?: string;
-    joinedAt?: string;
-}
-export interface WorkerGroups {
-    [key: string]: HiveWorker[];
-}
-export declare const TOPOLOGIES: {
-    value: string;
-    label: string;
-    hint: string;
-}[];
-export declare const CONSENSUS_STRATEGIES: {
-    value: string;
-    label: string;
-    hint: string;
-}[];
-export declare function groupWorkersByType(workers: HiveWorker[]): WorkerGroups;
-export declare function generateHiveMindPrompt(swarmId: string, swarmName: string, objective: string, workers: HiveWorker[], workerGroups: WorkerGroups, flags: Record<string, unknown>): string;
-export declare function formatAgentStatus(status: unknown): string;
-export declare function formatHiveStatus(status: string): string;
-export declare function formatHealth(health: string): string;
-export declare function formatPriority(priority: string): string;
-//# sourceMappingURL=hive-mind-helpers.d.ts.map