@claude-flow/cli 3.1.0-alpha.9 → 3.5.1

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
@@ -927,13 +915,14 @@ const metricsCommand = {
                 ]
             });
             if (v3Dashboard && result.performance) {
+                const p = result.performance;
                 output.writeln();
                 output.writeln(output.bold('🚀 V3 Performance Gains'));
                 output.printList([
-                    `Flash Attention: ${output.success(result.performance.flashAttention)}`,
-                    `Memory Reduction: ${output.success(result.performance.memoryReduction)}`,
-                    `Search Improvement: ${output.success(result.performance.searchImprovement)}`,
-                    `Token Reduction: ${output.success(result.performance.tokenReduction)}`
+                    `Flash Attention: ${output.success(p.flashAttention ?? 'N/A')}`,
+                    `Memory Reduction: ${output.success(p.memoryReduction ?? 'N/A')}`,
+                    `Search Improvement: ${output.success(p.searchImprovement ?? 'N/A')}`,
+                    `Token Reduction: ${output.success(p.tokenReduction ?? 'N/A')}`
                 ]);
             }
             return { success: true, data: result };
@@ -1305,7 +1294,7 @@ const postTaskCommand = {
             short: 's',
             description: 'Whether the task succeeded',
             type: 'boolean',
-            required: true
+            required: false
         },
         {
             name: 'quality',
@@ -1327,11 +1316,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', {
@@ -1649,19 +1635,20 @@ const intelligenceCommand = {
             // SONA Component
             output.writeln();
             output.writeln(output.bold('🧠 SONA (Sub-0.05ms Learning)'));
-            if (result.components.sona.enabled) {
+            const sona = result.components?.sona;
+            if (sona?.enabled) {
                 output.printTable({
                     columns: [
                         { key: 'metric', header: 'Metric', width: 25 },
                         { key: 'value', header: 'Value', width: 20, align: 'right' }
                     ],
                     data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(result.components.sona.status) },
-                        { metric: 'Learning Time', value: `${result.components.sona.learningTimeMs.toFixed(3)}ms` },
-                        { metric: 'Adaptation Time', value: `${result.components.sona.adaptationTimeMs.toFixed(3)}ms` },
-                        { metric: 'Trajectories', value: result.components.sona.trajectoriesRecorded },
-                        { metric: 'Patterns Learned', value: result.components.sona.patternsLearned },
-                        { metric: 'Avg Quality', value: `${(result.components.sona.avgQuality * 100).toFixed(1)}%` }
+                        { metric: 'Status', value: formatIntelligenceStatus(sona.status) },
+                        { metric: 'Learning Time', value: `${(sona.learningTimeMs ?? 0).toFixed(3)}ms` },
+                        { metric: 'Adaptation Time', value: `${(sona.adaptationTimeMs ?? 0).toFixed(3)}ms` },
+                        { metric: 'Trajectories', value: sona.trajectoriesRecorded ?? 0 },
+                        { metric: 'Patterns Learned', value: sona.patternsLearned ?? 0 },
+                        { metric: 'Avg Quality', value: `${((sona.avgQuality ?? 0) * 100).toFixed(1)}%` }
                     ]
                 });
             }
@@ -1671,17 +1658,18 @@ const intelligenceCommand = {
             // MoE Component
             output.writeln();
             output.writeln(output.bold('🔀 Mixture of Experts (MoE)'));
-            if (result.components.moe.enabled) {
+            const moe = result.components?.moe;
+            if (moe?.enabled) {
                 output.printTable({
                     columns: [
                         { key: 'metric', header: 'Metric', width: 25 },
                         { key: 'value', header: 'Value', width: 20, align: 'right' }
                     ],
                     data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(result.components.moe.status) },
-                        { metric: 'Active Experts', value: result.components.moe.expertsActive },
-                        { metric: 'Routing Accuracy', value: `${(result.components.moe.routingAccuracy * 100).toFixed(1)}%` },
-                        { metric: 'Load Balance', value: `${(result.components.moe.loadBalance * 100).toFixed(1)}%` }
+                        { metric: 'Status', value: formatIntelligenceStatus(moe.status) },
+                        { metric: 'Active Experts', value: moe.expertsActive ?? 0 },
+                        { metric: 'Routing Accuracy', value: `${((moe.routingAccuracy ?? 0) * 100).toFixed(1)}%` },
+                        { metric: 'Load Balance', value: `${((moe.loadBalance ?? 0) * 100).toFixed(1)}%` }
                     ]
                 });
             }
@@ -1691,18 +1679,19 @@ const intelligenceCommand = {
             // HNSW Component
             output.writeln();
             output.writeln(output.bold('🔍 HNSW (150x Faster Search)'));
-            if (result.components.hnsw.enabled) {
+            const hnsw = result.components?.hnsw;
+            if (hnsw?.enabled) {
                 output.printTable({
                     columns: [
                         { key: 'metric', header: 'Metric', width: 25 },
                         { key: 'value', header: 'Value', width: 20, align: 'right' }
                     ],
                     data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(result.components.hnsw.status) },
-                        { metric: 'Index Size', value: result.components.hnsw.indexSize.toLocaleString() },
-                        { metric: 'Search Speedup', value: output.success(result.components.hnsw.searchSpeedup) },
-                        { metric: 'Memory Usage', value: result.components.hnsw.memoryUsage },
-                        { metric: 'Dimension', value: result.components.hnsw.dimension }
+                        { metric: 'Status', value: formatIntelligenceStatus(hnsw.status) },
+                        { metric: 'Index Size', value: (hnsw.indexSize ?? 0).toLocaleString() },
+                        { metric: 'Search Speedup', value: output.success(hnsw.searchSpeedup ?? 'N/A') },
+                        { metric: 'Memory Usage', value: hnsw.memoryUsage ?? 'N/A' },
+                        { metric: 'Dimension', value: hnsw.dimension ?? 384 }
                     ]
                 });
             }
@@ -1712,28 +1701,37 @@ const intelligenceCommand = {
             // Embeddings
             output.writeln();
             output.writeln(output.bold('📦 Embeddings (ONNX)'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Provider', value: result.components.embeddings.provider },
-                    { metric: 'Model', value: result.components.embeddings.model },
-                    { metric: 'Dimension', value: result.components.embeddings.dimension },
-                    { metric: 'Cache Hit Rate', value: `${(result.components.embeddings.cacheHitRate * 100).toFixed(1)}%` }
-                ]
-            });
+            const emb = result.components?.embeddings;
+            if (emb) {
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 25 },
+                        { key: 'value', header: 'Value', width: 20, align: 'right' }
+                    ],
+                    data: [
+                        { metric: 'Provider', value: emb.provider ?? 'N/A' },
+                        { metric: 'Model', value: emb.model ?? 'N/A' },
+                        { metric: 'Dimension', value: emb.dimension ?? 384 },
+                        { metric: 'Cache Hit Rate', value: `${((emb.cacheHitRate ?? 0) * 100).toFixed(1)}%` }
+                    ]
+                });
+            }
+            else {
+                output.writeln(output.dim('  Not initialized'));
+            }
             // V3 Performance
-            output.writeln();
-            output.writeln(output.bold('🚀 V3 Performance Gains'));
-            output.printList([
-                `Flash Attention: ${output.success(result.performance.flashAttention)}`,
-                `Memory Reduction: ${output.success(result.performance.memoryReduction)}`,
-                `Search Improvement: ${output.success(result.performance.searchImprovement)}`,
-                `Token Reduction: ${output.success(result.performance.tokenReduction)}`,
-                `SWE-Bench Score: ${output.success(result.performance.sweBenchScore)}`
-            ]);
+            const perf = result.performance;
+            if (perf) {
+                output.writeln();
+                output.writeln(output.bold('🚀 V3 Performance Gains'));
+                output.printList([
+                    `Flash Attention: ${output.success(perf.flashAttention ?? 'N/A')}`,
+                    `Memory Reduction: ${output.success(perf.memoryReduction ?? 'N/A')}`,
+                    `Search Improvement: ${output.success(perf.searchImprovement ?? 'N/A')}`,
+                    `Token Reduction: ${output.success(perf.tokenReduction ?? 'N/A')}`,
+                    `SWE-Bench Score: ${output.success(perf.sweBenchScore ?? 'N/A')}`
+                ]);
+            }
             return { success: true, data: result };
         }
         catch (error) {
@@ -3154,17 +3152,22 @@ const tokenOptimizeCommand = {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let reasoningBank = null;
         try {
-            // Check if agentic-flow is available
-            const af = await import('agentic-flow').catch(() => null);
-            if (af) {
+            // Check if agentic-flow v3 is available
+            const rb = await import('agentic-flow/reasoningbank').catch(() => null);
+            if (rb) {
                 agenticFlowAvailable = true;
-                // Try to load ReasoningBank
-                const rb = await import('agentic-flow/reasoningbank').catch(() => null);
-                if (rb && typeof rb.retrieveMemories === 'function') {
+                if (typeof rb.retrieveMemories === 'function') {
                     reasoningBank = rb;
                 }
             }
-            spinner.succeed(agenticFlowAvailable ? 'agentic-flow detected' : 'agentic-flow not available (using fallbacks)');
+            else {
+                // Legacy check for older agentic-flow
+                const af = await import('agentic-flow').catch(() => null);
+                if (af)
+                    agenticFlowAvailable = true;
+            }
+            const versionLabel = agenticFlowAvailable ? `agentic-flow v3 detected (ReasoningBank: ${reasoningBank ? 'active' : 'unavailable'})` : 'agentic-flow not available (using fallbacks)';
+            spinner.succeed(versionLabel);
             output.writeln();
             // Anti-drift config (hardcoded optimal values from research)
             const config = {
@@ -3447,6 +3450,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 +3688,9 @@ export const hooksCommand = {
         sessionStartCommand,
         preBashCommand,
         postBashCommand,
+        // Agent Teams integration
+        teammateIdleCommand,
+        taskCompletedCommand,
     ],
     options: [],
     examples: [
@@ -3528,7 +3733,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 +3749,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 };
     }