claude-flow 3.5.19 → 3.5.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.19",
+  "version": "3.5.20",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/agent.js

@@ -420,26 +420,86 @@ const metricsCommand = {
     action: async (ctx) => {
         const agentId = ctx.args[0];
         const period = ctx.flags.period;
-        // Default metrics (updated by MCP agent/metrics when available)
+        // Collect real metrics from .swarm/ state
+        const { existsSync, readFileSync, readdirSync, statSync } = await import('fs');
+        const { join } = await import('path');
+        let totalAgents = 0;
+        let activeAgents = 0;
+        let tasksCompleted = 0;
+        const typeCounts = {};
+        // Read swarm agent state
+        const swarmDir = join(process.cwd(), '.swarm');
+        const agentsDir = join(swarmDir, 'agents');
+        if (existsSync(agentsDir)) {
+            try {
+                const files = readdirSync(agentsDir).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    try {
+                        const data = JSON.parse(readFileSync(join(agentsDir, file), 'utf-8'));
+                        totalAgents++;
+                        const agType = data.type || 'unknown';
+                        if (!typeCounts[agType])
+                            typeCounts[agType] = { count: 0, tasks: 0, success: 0 };
+                        typeCounts[agType].count++;
+                        if (data.status === 'active' || data.status === 'running')
+                            activeAgents++;
+                        if (data.tasksCompleted) {
+                            typeCounts[agType].tasks += data.tasksCompleted;
+                            tasksCompleted += data.tasksCompleted;
+                        }
+                        if (data.successCount)
+                            typeCounts[agType].success += data.successCount;
+                    }
+                    catch { /* skip malformed */ }
+                }
+            }
+            catch { /* no agents dir */ }
+        }
+        // Read swarm activity for additional state
+        const activityFile = join(swarmDir, 'swarm-activity.json');
+        if (existsSync(activityFile)) {
+            try {
+                const activity = JSON.parse(readFileSync(activityFile, 'utf-8'));
+                if (activity.totalAgents && totalAgents === 0)
+                    totalAgents = activity.totalAgents;
+                if (activity.activeAgents && activeAgents === 0)
+                    activeAgents = activity.activeAgents;
+            }
+            catch { /* ignore */ }
+        }
+        // Read memory.db stats
+        let vectorCount = 0;
+        const dbPath = join(swarmDir, 'memory.db');
+        if (existsSync(dbPath)) {
+            try {
+                const dbSize = statSync(dbPath).size;
+                vectorCount = Math.floor(dbSize / 2048);
+            }
+            catch { /* ignore */ }
+        }
+        const byType = Object.entries(typeCounts).map(([type, data]) => ({
+            type,
+            count: data.count,
+            tasks: data.tasks,
+            successRate: data.tasks > 0 ? `${Math.round((data.success / data.tasks) * 100)}%` : 'N/A'
+        }));
+        const avgSuccessRate = tasksCompleted > 0
+            ? `${Math.round(Object.values(typeCounts).reduce((a, d) => a + d.success, 0) / tasksCompleted * 100)}%`
+            : 'N/A';
         const metrics = {
             period,
             summary: {
-                totalAgents: 4,
-                activeAgents: 3,
-                tasksCompleted: 127,
-                avgSuccessRate: '96.2%',
-                totalTokens: 1234567,
-                avgResponseTime: '1.45s'
+                totalAgents,
+                activeAgents,
+                tasksCompleted,
+                avgSuccessRate,
+                vectorCount,
+                note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined
             },
-            byType: [
-                { type: 'coder', count: 2, tasks: 45, successRate: '97%' },
-                { type: 'researcher', count: 1, tasks: 32, successRate: '95%' },
-                { type: 'tester', count: 1, tasks: 50, successRate: '98%' }
-            ],
+            byType,
             performance: {
-                flashAttention: '2.8x speedup',
-                memoryReduction: '52%',
-                searchImprovement: '150x faster'
+                memoryVectors: `${vectorCount} vectors`,
+                searchBackend: vectorCount > 0 ? 'HNSW-indexed' : 'none'
             }
         };
         if (ctx.flags.format === 'json') {
@@ -459,8 +519,7 @@ const metricsCommand = {
                 { metric: 'Active Agents', value: metrics.summary.activeAgents },
                 { metric: 'Tasks Completed', value: metrics.summary.tasksCompleted },
                 { metric: 'Success Rate', value: metrics.summary.avgSuccessRate },
-                { metric: 'Total Tokens', value: metrics.summary.totalTokens.toLocaleString() },
-                { metric: 'Avg Response Time', value: metrics.summary.avgResponseTime }
+                { metric: 'Memory Vectors', value: metrics.summary.vectorCount }
             ]
         });
         output.writeln();
@@ -474,12 +533,15 @@ const metricsCommand = {
             ],
             data: metrics.byType
         });
+        if (metrics.summary.note) {
+            output.writeln();
+            output.writeln(output.dim(metrics.summary.note));
+        }
         output.writeln();
-        output.writeln(output.bold('V3 Performance Gains'));
+        output.writeln(output.bold('Memory'));
         output.printList([
-            `Flash Attention: ${output.success(metrics.performance.flashAttention)}`,
-            `Memory Reduction: ${output.success(metrics.performance.memoryReduction)}`,
-            `Search: ${output.success(metrics.performance.searchImprovement)}`
+            `Vectors: ${output.success(metrics.performance.memoryVectors)}`,
+            `Backend: ${output.success(metrics.performance.searchBackend)}`
         ]);
         return { success: true, data: metrics };
     }

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -1146,9 +1146,8 @@ const preTaskCommand = {
         {
             name: 'task-id',
             short: 'i',
-            description: 'Unique task identifier',
-            type: 'string',
-            required: true
+            description: 'Unique task identifier (auto-generated if omitted)',
+            type: 'string'
         },
         {
             name: 'description',
@@ -1170,10 +1169,10 @@ const preTaskCommand = {
         { command: 'claude-flow hooks pre-task -i task-456 -d "Implement feature" --auto-spawn', description: 'With auto-spawn' }
     ],
     action: async (ctx) => {
-        const taskId = ctx.flags.taskId;
+        const taskId = ctx.flags.taskId || `task-${Date.now().toString(36)}`;
         const description = ctx.args[0] || ctx.flags.description;
-        if (!taskId || !description) {
-            output.printError('Task ID and description are required.');
+        if (!description) {
+            output.printError('Description is required: --description "your task"');
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Starting task: ${output.highlight(taskId)}`);
@@ -3649,6 +3648,45 @@ const taskCompletedCommand = {
         }
     }
 };
+// Notify subcommand
+const notifyCommand = {
+    name: 'notify',
+    description: 'Send a notification message (logged to session)',
+    options: [
+        { name: 'message', short: 'm', type: 'string', description: 'Notification message', required: true },
+        { name: 'level', short: 'l', type: 'string', description: 'Level: info, warn, error', default: 'info' },
+        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel', default: 'console' },
+    ],
+    examples: [
+        { command: 'claude-flow hooks notify -m "Build complete"', description: 'Send info notification' },
+        { command: 'claude-flow hooks notify -m "Test failed" -l error', description: 'Send error notification' },
+    ],
+    action: async (ctx) => {
+        const message = ctx.args[0] || ctx.flags.message;
+        const level = ctx.flags.level || 'info';
+        if (!message) {
+            output.printError('Message is required: --message "your message"');
+            return { success: false, exitCode: 1 };
+        }
+        const timestamp = new Date().toISOString();
+        if (level === 'error') {
+            output.printError(`[${timestamp}] ${message}`);
+        }
+        else if (level === 'warn') {
+            output.writeln(output.warning(`[${timestamp}] ${message}`));
+        }
+        else {
+            output.printInfo(`[${timestamp}] ${message}`);
+        }
+        // Store notification in memory if available
+        try {
+            const { storeEntry } = await import('../memory/memory-initializer.js');
+            await storeEntry({ key: `notify-${Date.now()}`, value: `[${level}] ${message}`, namespace: 'notifications' });
+        }
+        catch { /* memory not available */ }
+        return { success: true, data: { timestamp, level, message } };
+    }
+};
 // Main hooks command
 export const hooksCommand = {
     name: 'hooks',
@@ -3670,6 +3708,7 @@ export const hooksCommand = {
         transferCommand,
         listCommand,
         intelligenceCommand,
+        notifyCommand,
         workerCommand,
         progressHookCommand,
         statuslineCommand,

package/v3/@claude-flow/cli/dist/src/commands/neural.js

@@ -30,7 +30,7 @@ const trainCommand = {
         { command: 'claude-flow neural train -p security --wasm --contrastive', description: 'Security patterns with contrastive learning' },
     ],
     action: async (ctx) => {
-        const patternType = ctx.flags.pattern || 'coordination';
+        const patternType = (ctx.flags.pattern || ctx.flags.patternType || ctx.flags['pattern-type']) || 'coordination';
         const epochs = parseInt(ctx.flags.epochs || '50', 10);
         const learningRate = parseFloat(ctx.flags['learning-rate'] || '0.01');
         const batchSize = parseInt(ctx.flags['batch-size'] || '32', 10);

package/v3/@claude-flow/cli/dist/src/commands/security.js

@@ -340,21 +340,52 @@ const auditCommand = {
         output.writeln();
         output.writeln(output.bold('Security Audit Log'));
         output.writeln(output.dim('─'.repeat(60)));
-        output.printTable({
-            columns: [
-                { key: 'timestamp', header: 'Timestamp', width: 22 },
-                { key: 'event', header: 'Event', width: 20 },
-                { key: 'user', header: 'User', width: 15 },
-                { key: 'status', header: 'Status', width: 12 },
-            ],
-            data: [
-                { timestamp: '2024-01-15 14:32:01', event: 'AUTH_LOGIN', user: 'admin', status: output.success('Success') },
-                { timestamp: '2024-01-15 14:30:45', event: 'CONFIG_CHANGE', user: 'system', status: output.success('Success') },
-                { timestamp: '2024-01-15 14:28:12', event: 'AUTH_FAILED', user: 'unknown', status: output.error('Failed') },
-                { timestamp: '2024-01-15 14:25:33', event: 'SCAN_COMPLETE', user: 'ci-bot', status: output.success('Success') },
-                { timestamp: '2024-01-15 14:20:00', event: 'KEY_ROTATE', user: 'admin', status: output.success('Success') },
-            ],
-        });
+        // Generate real audit entries from .swarm/ state and session history
+        const { existsSync, readFileSync, readdirSync, statSync } = await import('fs');
+        const { join } = await import('path');
+        const auditEntries = [];
+        const swarmDir = join(process.cwd(), '.swarm');
+        // Check session files for real audit events
+        if (existsSync(swarmDir)) {
+            try {
+                const files = readdirSync(swarmDir).filter(f => f.endsWith('.json'));
+                for (const file of files.slice(-10)) {
+                    try {
+                        const stat = statSync(join(swarmDir, file));
+                        const ts = stat.mtime.toISOString().replace('T', ' ').substring(0, 19);
+                        auditEntries.push({
+                            timestamp: ts,
+                            event: file.includes('session') ? 'SESSION_UPDATE' :
+                                file.includes('swarm') ? 'SWARM_ACTIVITY' :
+                                    file.includes('memory') ? 'MEMORY_WRITE' : 'CONFIG_CHANGE',
+                            user: 'system',
+                            status: output.success('Success')
+                        });
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            catch { /* ignore */ }
+        }
+        // Add current session entry
+        const now = new Date().toISOString().replace('T', ' ').substring(0, 19);
+        auditEntries.push({ timestamp: now, event: 'AUDIT_RUN', user: 'cli', status: output.success('Success') });
+        // Sort by timestamp desc
+        auditEntries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        if (auditEntries.length === 0) {
+            output.writeln(output.dim('No audit events found. Initialize a project first: claude-flow init'));
+        }
+        else {
+            output.printTable({
+                columns: [
+                    { key: 'timestamp', header: 'Timestamp', width: 22 },
+                    { key: 'event', header: 'Event', width: 20 },
+                    { key: 'user', header: 'User', width: 15 },
+                    { key: 'status', header: 'Status', width: 12 },
+                ],
+                data: auditEntries.slice(0, parseInt(ctx.flags.limit || '20', 10)),
+            });
+        }
         return { success: true };
     },
 };

package/v3/@claude-flow/cli/dist/src/memory/intelligence.js

@@ -545,9 +545,13 @@ export async function findSimilarPatterns(query, options) {
             const queryResult = await generateEmbedding(query);
             queryEmbedding = queryResult.embedding;
         }
+        // Hash-fallback embeddings (128-dim) produce lower cosine similarities
+        // than ONNX/transformer embeddings, so use a lower default threshold
+        const isHashFallback = queryEmbedding.length === 128;
+        const defaultThreshold = isHashFallback ? 0.1 : 0.5;
         const results = reasoningBank.findSimilar(queryEmbedding, {
             k: options?.k ?? 5,
-            threshold: options?.threshold ?? 0.5,
+            threshold: options?.threshold ?? defaultThreshold,
             type: options?.type
         });
         return results.map((r) => ({

package/v3/@claude-flow/cli/dist/src/parser.d.ts

@@ -32,6 +32,16 @@ export declare class CommandParser {
     private parseValue;
     private normalizeKey;
     private buildAliases;
+    /**
+     * Build aliases scoped to a specific command/subcommand.
+     * The resolved command's short flags take priority over global ones,
+     * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
+     */
+    private buildScopedAliases;
+    /**
+     * Get boolean flags scoped to a specific command/subcommand.
+     */
+    private getScopedBooleanFlags;
     private getBooleanFlags;
     private applyDefaults;
     validateFlags(flags: ParsedFlags, command?: Command): string[];

package/v3/@claude-flow/cli/dist/src/parser.js

@@ -101,9 +101,23 @@ export class CommandParser {
             positional: [],
             raw: [...args]
         };
-        // Build flag configuration from global options
-        const aliases = this.buildAliases();
-        const booleanFlags = this.getBooleanFlags();
+        // Pass 1: Identify command and subcommand (skip flags)
+        let resolvedCmd;
+        let resolvedSub;
+        for (const arg of args) {
+            if (arg.startsWith('-'))
+                continue;
+            if (!resolvedCmd && this.commands.has(arg)) {
+                resolvedCmd = this.commands.get(arg);
+            }
+            else if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
+                resolvedSub = resolvedCmd.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+            }
+        }
+        // Pass 2: Build aliases scoped to the resolved subcommand
+        // Subcommand-specific aliases take priority over global ones
+        const aliases = this.buildScopedAliases(resolvedSub || resolvedCmd);
+        const booleanFlags = this.getScopedBooleanFlags(resolvedSub || resolvedCmd);
         let i = 0;
         let parsingFlags = true;
         while (i < args.length) {
@@ -275,6 +289,38 @@ export class CommandParser {
         }
         return { ...aliases, ...this.options.aliases };
     }
+    /**
+     * Build aliases scoped to a specific command/subcommand.
+     * The resolved command's short flags take priority over global ones,
+     * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
+     */
+    buildScopedAliases(resolvedCmd) {
+        // Start with global aliases as base
+        const aliases = this.buildAliases();
+        // Override with the resolved command's own options (these take priority)
+        if (resolvedCmd?.options) {
+            for (const opt of resolvedCmd.options) {
+                if (opt.short) {
+                    aliases[opt.short] = opt.name;
+                }
+            }
+        }
+        return aliases;
+    }
+    /**
+     * Get boolean flags scoped to a specific command/subcommand.
+     */
+    getScopedBooleanFlags(resolvedCmd) {
+        const flags = this.getBooleanFlags();
+        if (resolvedCmd?.options) {
+            for (const opt of resolvedCmd.options) {
+                if (opt.type === 'boolean') {
+                    flags.add(this.normalizeKey(opt.name));
+                }
+            }
+        }
+        return flags;
+    }
     getBooleanFlags() {
         const flags = new Set();
         for (const opt of this.globalOptions) {

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.19",
+  "version": "3.5.20",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",