@claude-flow/cli 3.1.0-alpha.4 → 3.1.0-alpha.41

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;AAizI1E,eAAO,MAAM,YAAY,EAAE,OAyG1B,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/src/commands/hooks.js

@@ -32,7 +32,7 @@ const preEditCommand = {
             short: 'f',
             description: 'File path to edit',
             type: 'string',
-            required: true
+            required: false
         },
         {
             name: 'operation',
@@ -53,12 +53,9 @@ const preEditCommand = {
         { command: 'claude-flow hooks pre-edit -f src/api.ts -o refactor', description: 'Pre-edit with operation type' }
     ],
     action: async (ctx) => {
-        const filePath = ctx.args[0] || ctx.flags.file;
+        // Default file to 'unknown' for backward compatibility (env var may be empty)
+        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
         const operation = ctx.flags.operation || 'update';
-        if (!filePath) {
-            output.printError('File path is required. Use --file or -f flag.');
-            return { success: false, exitCode: 1 };
-        }
         output.printInfo(`Analyzing context for: ${output.highlight(filePath)}`);
         try {
             // Call MCP tool for pre-edit hook
@@ -134,14 +131,14 @@ const postEditCommand = {
             short: 'f',
             description: 'File path that was edited',
             type: 'string',
-            required: true
+            required: false
         },
         {
             name: 'success',
             short: 's',
             description: 'Whether the edit was successful',
             type: 'boolean',
-            required: true
+            required: false
         },
         {
             name: 'outcome',
@@ -161,16 +158,10 @@ const postEditCommand = {
         { command: 'claude-flow hooks post-edit -f src/api.ts --success false -o "Type error"', description: 'Record failed edit' }
     ],
     action: async (ctx) => {
-        const filePath = ctx.args[0] || ctx.flags.file;
-        const success = ctx.flags.success;
-        if (!filePath) {
-            output.printError('File path is required. Use --file or -f flag.');
-            return { success: false, exitCode: 1 };
-        }
-        if (success === undefined) {
-            output.printError('Success flag is required. Use --success true/false.');
-            return { success: false, exitCode: 1 };
-        }
+        // Default file to 'unknown' for backward compatibility (env var may be empty)
+        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
+        // Default success to true for backward compatibility (PostToolUse = success, PostToolUseFailure = failure)
+        const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         output.printInfo(`Recording outcome for: ${output.highlight(filePath)}`);
         try {
             // Parse metrics if provided
@@ -339,7 +330,7 @@ const postCommandCommand = {
             short: 's',
             description: 'Whether the command succeeded',
             type: 'boolean',
-            required: true
+            required: false
         },
         {
             name: 'exit-code',
@@ -361,15 +352,12 @@ const postCommandCommand = {
     ],
     action: async (ctx) => {
         const command = ctx.args[0] || ctx.flags.command;
-        const success = ctx.flags.success;
+        // Default success to true for backward compatibility
+        const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         if (!command) {
             output.printError('Command is required. Use --command or -c flag.');
             return { success: false, exitCode: 1 };
         }
-        if (success === undefined) {
-            output.printError('Success flag is required. Use --success true/false.');
-            return { success: false, exitCode: 1 };
-        }
         output.printInfo(`Recording command outcome: ${output.highlight(command)}`);
         try {
             // Call MCP tool for post-command hook
@@ -1305,7 +1293,7 @@ const postTaskCommand = {
             short: 's',
             description: 'Whether the task succeeded',
             type: 'boolean',
-            required: true
+            required: false
         },
         {
             name: 'quality',
@@ -1327,11 +1315,8 @@ const postTaskCommand = {
     action: async (ctx) => {
         // Auto-generate task ID if not provided
         const taskId = ctx.flags.taskId || `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const success = ctx.flags.success;
-        if (success === undefined) {
-            output.printError('Success flag is required. Use --success true/false.');
-            return { success: false, exitCode: 1 };
-        }
+        // Default success to true for backward compatibility
+        const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         output.printInfo(`Recording outcome for task: ${output.highlight(taskId)}`);
         try {
             const result = await callMCPTool('hooks_post-task', {
@@ -3447,6 +3432,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 +3670,9 @@ export const hooksCommand = {
         sessionStartCommand,
         preBashCommand,
         postBashCommand,
+        // Agent Teams integration
+        teammateIdleCommand,
+        taskCompletedCommand,
     ],
     options: [],
     examples: [
@@ -3528,7 +3715,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 +3731,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 };
     }