@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.7

package/src/commands/hive-mind.ts

@@ -125,13 +125,13 @@ const initCommand: Command = {
       output.writeln();
       output.printBox(
         [
-          `Hive ID: ${result.hiveId}`,
-          `Queen ID: ${result.queenId}`,
-          `Topology: ${result.topology}`,
-          `Consensus: ${result.consensus}`,
+          `Hive ID: ${result.hiveId ?? 'default'}`,
+          `Queen ID: ${result.queenId ?? 'N/A'}`,
+          `Topology: ${result.topology ?? config.topology}`,
+          `Consensus: ${result.consensus ?? config.consensus}`,
           `Max Agents: ${config.maxAgents}`,
           `Memory: ${config.memoryBackend}`,
-          `Status: ${output.success(result.status)}`
+          `Status: ${output.success(result.status ?? 'initialized')}`
         ].join('\n'),
         'Hive Mind Configuration'
       );
@@ -276,37 +276,42 @@ const statusCommand: Command = {
 
     try {
       const result = await callMCPTool<{
-        hiveId: string;
-        status: 'active' | 'idle' | 'degraded' | 'offline';
-        topology: string;
-        consensus: string;
-        queen: {
-          id: string;
-          status: string;
-          load: number;
-          tasksQueued: number;
+        hiveId?: string;
+        id?: string;
+        initialized?: boolean;
+        status?: 'active' | 'idle' | 'degraded' | 'offline' | 'running' | 'stopped';
+        topology?: string;
+        consensus?: string;
+        queen?: {
+          id?: string;
+          agentId?: string;
+          status?: string;
+          load?: number;
+          tasksQueued?: number;
         };
-        workers: Array<{
-          id: string;
-          type: string;
-          status: string;
+        workers?: Array<{
+          id?: string;
+          agentId?: string;
+          type?: string;
+          agentType?: string;
+          status?: string;
           currentTask?: string;
-          tasksCompleted: number;
-        }>;
-        metrics: {
-          totalTasks: number;
-          completedTasks: number;
-          failedTasks: number;
-          avgTaskTime: number;
-          consensusRounds: number;
-          memoryUsage: string;
+          tasksCompleted?: number;
+        } | string>;
+        metrics?: {
+          totalTasks?: number;
+          completedTasks?: number;
+          failedTasks?: number;
+          avgTaskTime?: number;
+          consensusRounds?: number;
+          memoryUsage?: string;
         };
-        health: {
-          overall: string;
-          queen: string;
-          workers: string;
-          consensus: string;
-          memory: string;
+        health?: {
+          overall?: string;
+          queen?: string;
+          workers?: string;
+          consensus?: string;
+          memory?: string;
         };
       }>('hive-mind/status', {
         includeMetrics: detailed,
@@ -318,36 +323,68 @@ const statusCommand: Command = {
         return { success: true, data: result };
       }
 
+      // Handle both simple and complex response formats - cast to flexible type
+      const flexResult = result as Record<string, unknown>;
+      const hiveId = result.hiveId ?? (flexResult.id as string) ?? 'default';
+      const status = result.status ?? ((flexResult.initialized as boolean) ? 'running' : 'stopped');
+      const queen = result.queen ?? { id: 'N/A', status: 'unknown', load: 0, tasksQueued: 0 };
+      const flexQueen = queen as Record<string, unknown>;
+      const queenId = typeof queen === 'object' ? (queen.id ?? (flexQueen.agentId as string) ?? 'N/A') : String(queen);
+      const queenLoad = typeof queen === 'object' ? (queen.load ?? 0) : 0;
+      const queenTasks = typeof queen === 'object' ? (queen.tasksQueued ?? 0) : 0;
+      const queenStatus = typeof queen === 'object' ? (queen.status ?? 'active') : 'active';
+
       output.writeln();
       output.printBox(
         [
-          `Hive ID: ${result.hiveId}`,
-          `Status: ${formatHiveStatus(result.status)}`,
-          `Topology: ${result.topology}`,
-          `Consensus: ${result.consensus}`,
+          `Hive ID: ${hiveId}`,
+          `Status: ${formatHiveStatus(String(status))}`,
+          `Topology: ${result.topology ?? 'mesh'}`,
+          `Consensus: ${result.consensus ?? 'byzantine'}`,
           '',
-          `Queen: ${result.queen.id}`,
-          `  Status: ${formatAgentStatus(result.queen.status)}`,
-          `  Load: ${(result.queen.load * 100).toFixed(1)}%`,
-          `  Queued Tasks: ${result.queen.tasksQueued}`
+          `Queen: ${queenId}`,
+          `  Status: ${formatAgentStatus(queenStatus)}`,
+          `  Load: ${(queenLoad * 100).toFixed(1)}%`,
+          `  Queued Tasks: ${queenTasks}`
         ].join('\n'),
         'Hive Mind Status'
       );
 
+      // Handle workers array - could be worker objects or just IDs
+      const workers = result.workers ?? [];
+      const workerData = Array.isArray(workers) ? workers.map(w => {
+        if (typeof w === 'string') {
+          return { id: w, type: 'worker', status: 'idle', currentTask: '-', tasksCompleted: 0 };
+        }
+        const flexWorker = w as Record<string, unknown>;
+        return {
+          id: w.id ?? (flexWorker.agentId as string) ?? 'unknown',
+          type: w.type ?? (flexWorker.agentType as string) ?? 'worker',
+          status: w.status ?? 'idle',
+          currentTask: w.currentTask ?? '-',
+          tasksCompleted: w.tasksCompleted ?? 0
+        };
+      }) : [];
+
       output.writeln();
       output.writeln(output.bold('Worker Agents'));
-      output.printTable({
-        columns: [
-          { key: 'id', header: 'ID', width: 20 },
-          { key: 'type', header: 'Type', width: 12 },
-          { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
-          { key: 'currentTask', header: 'Current Task', width: 20, format: (v: unknown) => String(v || '-') },
-          { key: 'tasksCompleted', header: 'Completed', width: 10, align: 'right' }
-        ],
-        data: result.workers
-      });
+      if (workerData.length === 0) {
+        output.printInfo('No workers in hive. Use "claude-flow hive-mind spawn" to add workers.');
+      } else {
+        output.printTable({
+          columns: [
+            { key: 'id', header: 'ID', width: 20 },
+            { key: 'type', header: 'Type', width: 12 },
+            { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
+            { key: 'currentTask', header: 'Current Task', width: 20, format: (v: unknown) => String(v || '-') },
+            { key: 'tasksCompleted', header: 'Completed', width: 10, align: 'right' }
+          ],
+          data: workerData
+        });
+      }
 
       if (detailed) {
+        const metrics = result.metrics ?? { totalTasks: 0, completedTasks: 0, failedTasks: 0, avgTaskTime: 0, consensusRounds: 0, memoryUsage: '0 MB' };
         output.writeln();
         output.writeln(output.bold('Metrics'));
         output.printTable({
@@ -356,23 +393,24 @@ const statusCommand: Command = {
             { key: 'value', header: 'Value', width: 15, align: 'right' }
           ],
           data: [
-            { metric: 'Total Tasks', value: result.metrics.totalTasks },
-            { metric: 'Completed', value: result.metrics.completedTasks },
-            { metric: 'Failed', value: result.metrics.failedTasks },
-            { metric: 'Avg Task Time', value: `${result.metrics.avgTaskTime.toFixed(1)}ms` },
-            { metric: 'Consensus Rounds', value: result.metrics.consensusRounds },
-            { metric: 'Memory Usage', value: result.metrics.memoryUsage }
+            { metric: 'Total Tasks', value: metrics.totalTasks ?? 0 },
+            { metric: 'Completed', value: metrics.completedTasks ?? 0 },
+            { metric: 'Failed', value: metrics.failedTasks ?? 0 },
+            { metric: 'Avg Task Time', value: `${(metrics.avgTaskTime ?? 0).toFixed(1)}ms` },
+            { metric: 'Consensus Rounds', value: metrics.consensusRounds ?? 0 },
+            { metric: 'Memory Usage', value: metrics.memoryUsage ?? '0 MB' }
           ]
         });
 
+        const health = result.health ?? { overall: 'healthy', queen: 'healthy', workers: 'healthy', consensus: 'healthy', memory: 'healthy' };
         output.writeln();
         output.writeln(output.bold('Health'));
         output.printList([
-          `Overall: ${formatHealth(result.health.overall)}`,
-          `Queen: ${formatHealth(result.health.queen)}`,
-          `Workers: ${formatHealth(result.health.workers)}`,
-          `Consensus: ${formatHealth(result.health.consensus)}`,
-          `Memory: ${formatHealth(result.health.memory)}`
+          `Overall: ${formatHealth(health.overall ?? 'healthy')}`,
+          `Queen: ${formatHealth(health.queen ?? 'healthy')}`,
+          `Workers: ${formatHealth(health.workers ?? 'healthy')}`,
+          `Consensus: ${formatHealth(health.consensus ?? 'healthy')}`,
+          `Memory: ${formatHealth(health.memory ?? 'healthy')}`
         ]);
       }
 
@@ -577,6 +615,129 @@ const optimizeMemoryCommand: Command = {
   }
 };
 
+// Join subcommand
+const joinCommand: Command = {
+  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: CommandContext): Promise<CommandResult> => {
+    const agentId = ctx.args[0] || ctx.flags['agent-id'] as string || ctx.flags.agentId as string;
+    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<{ success: boolean; agentId: string; totalWorkers: number; error?: string }>('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 }; }
+  }
+};
+
+// Leave subcommand
+const leaveCommand: Command = {
+  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: CommandContext): Promise<CommandResult> => {
+    const agentId = ctx.args[0] || ctx.flags['agent-id'] as string || ctx.flags.agentId as string;
+    if (!agentId) { output.printError('Agent ID required.'); return { success: false, exitCode: 1 }; }
+    try {
+      const result = await callMCPTool<{ success: boolean; agentId: string; remainingWorkers: number; error?: string }>('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 }; }
+  }
+};
+
+// Consensus subcommand
+const consensusCommand: Command = {
+  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' }
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const action = ctx.flags.action as string || 'list';
+    try {
+      const result = await callMCPTool<Record<string, unknown>>('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 });
+      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 as Array<Record<string, unknown>>) || [];
+        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 }; }
+  }
+};
+
+// Broadcast subcommand
+const broadcastCommand: Command = {
+  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: CommandContext): Promise<CommandResult> => {
+    const message = ctx.args.join(' ') || ctx.flags.message as string;
+    if (!message) { output.printError('Message required. Use --message or -m flag.'); return { success: false, exitCode: 1 }; }
+    try {
+      const result = await callMCPTool<{ success: boolean; messageId: string; recipients: number; error?: string }>('hive-mind/broadcast', { message, priority: ctx.flags.priority, fromId: ctx.flags.from });
+      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 }; }
+  }
+};
+
+// Memory subcommand
+const memorySubCommand: Command = {
+  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: CommandContext): Promise<CommandResult> => {
+    const action = ctx.flags.action as string || 'list';
+    const key = ctx.flags.key as string;
+    const value = ctx.flags.value as string;
+    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<Record<string, unknown>>('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 as string[]) || [];
+        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 }; }
+  }
+};
+
 // Shutdown subcommand
 const shutdownCommand: Command = {
   name: 'shutdown',
@@ -656,7 +817,7 @@ export const hiveMindCommand: Command = {
   name: 'hive-mind',
   aliases: ['hive'],
   description: 'Queen-led consensus-based multi-agent coordination',
-  subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, optimizeMemoryCommand, shutdownCommand],
+  subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
   options: [],
   examples: [
     { command: 'claude-flow hive-mind init -t hierarchical-mesh', description: 'Initialize hive' },
@@ -675,6 +836,11 @@ export const hiveMindCommand: Command = {
       `${output.highlight('spawn')}           - Spawn worker agents`,
       `${output.highlight('status')}          - Show hive status`,
       `${output.highlight('task')}            - Submit task to hive`,
+      `${output.highlight('join')}            - Join an agent to the hive`,
+      `${output.highlight('leave')}           - Remove an agent from the hive`,
+      `${output.highlight('consensus')}       - Manage consensus proposals`,
+      `${output.highlight('broadcast')}       - Broadcast message to workers`,
+      `${output.highlight('memory')}          - Access shared memory`,
       `${output.highlight('optimize-memory')} - Optimize patterns and memory`,
       `${output.highlight('shutdown')}        - Shutdown the hive`
     ]);

package/src/commands/hooks.ts

@@ -784,7 +784,7 @@ const pretrainCommand: Command = {
     try {
       spinner.start();
 
-      // Simulate multi-step process
+      // Display progress for each step
       for (const step of steps) {
         spinner.setText(`${step.name}: ${step.desc}`);
         await new Promise(resolve => setTimeout(resolve, 800));

package/src/commands/index.ts

@@ -20,6 +20,7 @@ import { startCommand } from './start.js';
 import { statusCommand } from './status.js';
 import { taskCommand } from './task.js';
 import { sessionCommand } from './session.js';
+import { daemonCommand } from './daemon.js';
 
 // Export all commands
 export { agentCommand } from './agent.js';
@@ -38,6 +39,7 @@ export { startCommand } from './start.js';
 export { statusCommand } from './status.js';
 export { taskCommand } from './task.js';
 export { sessionCommand } from './session.js';
+export { daemonCommand } from './daemon.js';
 
 /**
  * All available commands
@@ -59,7 +61,8 @@ export const commands: Command[] = [
   hooksCommand,
   workflowCommand,
   hiveMindCommand,
-  processCommand
+  processCommand,
+  daemonCommand
 ];
 
 /**

package/src/commands/mcp.ts

@@ -636,7 +636,7 @@ const logsCommand: Command = {
   action: async (ctx: CommandContext): Promise<CommandResult> => {
     const lines = ctx.flags.lines as number;
 
-    // Simulated logs for now - would read from actual log file
+    // Default logs (loaded from actual log file when available)
     const logs = [
       { time: new Date().toISOString(), level: 'info', message: 'MCP Server started on stdio' },
       { time: new Date().toISOString(), level: 'info', message: 'Registered 27 tools' },