@claude-flow/cli 3.1.0-alpha.2 → 3.1.0-alpha.21

package/bin/cli.js

@@ -11,8 +11,12 @@
 import { randomUUID } from 'crypto';
 
 // Check if we should run in MCP server mode
-// Conditions: stdin is being piped AND no CLI arguments provided
-const isMCPMode = !process.stdin.isTTY && process.argv.length === 2;
+// Conditions:
+//   1. stdin is being piped AND no CLI arguments provided (auto-detect)
+//   2. stdin is being piped AND args are "mcp start" (explicit, e.g. npx claude-flow@alpha mcp start)
+const cliArgs = process.argv.slice(2);
+const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
+const isMCPMode = !process.stdin.isTTY && (process.argv.length === 2 || isExplicitMCP);
 
 if (isMCPMode) {
   // Run MCP server mode

package/dist/src/commands/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AA4lI1E,eAAO,MAAM,YAAY,EAAE,OAiG1B,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAq0I1E,eAAO,MAAM,YAAY,EAAE,OAyG1B,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/src/commands/hooks.js

@@ -3447,6 +3447,205 @@ const modelStatsCommand = {
         }
     }
 };
+// Teammate Idle command - Agent Teams integration
+const teammateIdleCommand = {
+    name: 'teammate-idle',
+    description: 'Handle idle teammate in Agent Teams - auto-assign tasks or notify lead',
+    options: [
+        {
+            name: 'auto-assign',
+            short: 'a',
+            description: 'Automatically assign pending tasks to idle teammate',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'check-task-list',
+            short: 'c',
+            description: 'Check shared task list for available work',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'teammate-id',
+            short: 't',
+            description: 'ID of the idle teammate',
+            type: 'string'
+        },
+        {
+            name: 'team-name',
+            description: 'Team name for context',
+            type: 'string'
+        }
+    ],
+    examples: [
+        { command: 'claude-flow hooks teammate-idle --auto-assign true', description: 'Auto-assign tasks to idle teammate' },
+        { command: 'claude-flow hooks teammate-idle -t worker-1 --check-task-list', description: 'Check tasks for specific teammate' }
+    ],
+    action: async (ctx) => {
+        const autoAssign = ctx.flags.autoAssign !== false;
+        const checkTaskList = ctx.flags.checkTaskList !== false;
+        const teammateId = ctx.flags.teammateId;
+        const teamName = ctx.flags.teamName;
+        if (ctx.flags.format !== 'json') {
+            output.printInfo(`Teammate idle hook triggered${teammateId ? ` for: ${output.highlight(teammateId)}` : ''}`);
+        }
+        try {
+            const result = await callMCPTool('hooks_teammate-idle', {
+                autoAssign,
+                checkTaskList,
+                teammateId,
+                teamName,
+                timestamp: Date.now(),
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
+            }
+            output.writeln();
+            if (result.action === 'assigned' && result.taskAssigned) {
+                output.printSuccess(`Task assigned: ${result.taskAssigned.subject}`);
+                output.printList([
+                    `Task ID: ${result.taskAssigned.taskId}`,
+                    `Priority: ${result.taskAssigned.priority}`,
+                    `Pending tasks remaining: ${result.pendingTasks}`
+                ]);
+            }
+            else if (result.action === 'waiting') {
+                output.printInfo('No pending tasks available - teammate waiting for work');
+            }
+            else {
+                output.printInfo(`Team lead notified: ${result.message}`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            // Graceful fallback - don't fail hard, just report
+            if (ctx.flags.format === 'json') {
+                output.printJson({ success: true, action: 'waiting', message: 'Teammate idle - no MCP server' });
+            }
+            else {
+                output.printInfo('Teammate idle - awaiting task assignment');
+            }
+            return { success: true };
+        }
+    }
+};
+// Task Completed command - Agent Teams integration
+const taskCompletedCommand = {
+    name: 'task-completed',
+    description: 'Handle task completion in Agent Teams - train patterns and notify lead',
+    options: [
+        {
+            name: 'task-id',
+            short: 'i',
+            description: 'ID of the completed task',
+            type: 'string',
+            required: true
+        },
+        {
+            name: 'train-patterns',
+            short: 'p',
+            description: 'Train neural patterns from successful task',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'notify-lead',
+            short: 'n',
+            description: 'Notify team lead of task completion',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'success',
+            short: 's',
+            description: 'Whether the task succeeded',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'quality',
+            short: 'q',
+            description: 'Quality score (0-1)',
+            type: 'number'
+        },
+        {
+            name: 'teammate-id',
+            short: 't',
+            description: 'ID of the teammate that completed the task',
+            type: 'string'
+        }
+    ],
+    examples: [
+        { command: 'claude-flow hooks task-completed -i task-123 --train-patterns', description: 'Complete task and train patterns' },
+        { command: 'claude-flow hooks task-completed -i task-456 --notify-lead --quality 0.95', description: 'Complete with quality score' }
+    ],
+    action: async (ctx) => {
+        const taskId = ctx.args[0] || ctx.flags.taskId;
+        const trainPatterns = ctx.flags.trainPatterns !== false;
+        const notifyLead = ctx.flags.notifyLead !== false;
+        const success = ctx.flags.success !== false;
+        const quality = ctx.flags.quality;
+        const teammateId = ctx.flags.teammateId;
+        if (!taskId) {
+            output.printError('Task ID is required. Use --task-id or -i flag.');
+            return { success: false, exitCode: 1 };
+        }
+        if (ctx.flags.format !== 'json') {
+            output.printInfo(`Task completed: ${output.highlight(taskId)}`);
+        }
+        try {
+            const result = await callMCPTool('hooks_task-completed', {
+                taskId,
+                trainPatterns,
+                notifyLead,
+                success,
+                quality,
+                teammateId,
+                timestamp: Date.now(),
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
+            }
+            output.writeln();
+            output.printSuccess(`Task ${taskId} marked complete`);
+            output.writeln();
+            output.writeln(output.bold('Completion Metrics'));
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 25 },
+                    { key: 'value', header: 'Value', width: 20, align: 'right' }
+                ],
+                data: [
+                    { metric: 'Patterns Learned', value: result.patternsLearned },
+                    { metric: 'Quality Score', value: quality ? `${(quality * 100).toFixed(0)}%` : 'N/A' },
+                    { metric: 'Lead Notified', value: result.leadNotified ? 'Yes' : 'No' },
+                    { metric: 'Learning Updates', value: result.metrics?.learningUpdates || 0 }
+                ]
+            });
+            if (result.nextTask) {
+                output.writeln();
+                output.printInfo(`Next available task: ${result.nextTask.subject}`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            // Graceful fallback
+            if (ctx.flags.format === 'json') {
+                output.printJson({ success: true, taskId, message: 'Task completed - patterns pending' });
+            }
+            else {
+                output.printSuccess(`Task ${taskId} completed`);
+                if (trainPatterns) {
+                    output.printInfo('Pattern training queued for next sync');
+                }
+            }
+            return { success: true };
+        }
+    }
+};
 // Main hooks command
 export const hooksCommand = {
     name: 'hooks',
@@ -3486,6 +3685,9 @@ export const hooksCommand = {
         sessionStartCommand,
         preBashCommand,
         postBashCommand,
+        // Agent Teams integration
+        teammateIdleCommand,
+        taskCompletedCommand,
     ],
     options: [],
     examples: [
@@ -3528,7 +3730,11 @@ export const hooksCommand = {
             `${output.highlight('token-optimize')} - Token optimization (30-50% savings)`,
             `${output.highlight('model-route')}    - Route to optimal model (haiku/sonnet/opus)`,
             `${output.highlight('model-outcome')}  - Record model routing outcome`,
-            `${output.highlight('model-stats')}    - View model routing statistics`
+            `${output.highlight('model-stats')}    - View model routing statistics`,
+            '',
+            output.bold('Agent Teams:'),
+            `${output.highlight('teammate-idle')}  - Handle idle teammate (auto-assign tasks)`,
+            `${output.highlight('task-completed')} - Handle task completion (train patterns)`
         ]);
         output.writeln();
         output.writeln('Run "claude-flow hooks <subcommand> --help" for subcommand help');
@@ -3540,7 +3746,8 @@ export const hooksCommand = {
             '🔍 AgentDB integration (150x faster search)',
             '📊 84.8% SWE-Bench solve rate',
             '🎯 32.3% token reduction',
-            '🚀 2.8-4.4x speed improvement'
+            '🚀 2.8-4.4x speed improvement',
+            '👥 Agent Teams integration (auto task assignment)'
         ]);
         return { success: true };
     }