claude-flow 2.0.0-alpha.84 → 2.0.0-alpha.86

package/src/cli/simple-commands/memory.js

@@ -1,11 +1,15 @@
 // memory.js - Memory management commands
-import { printSuccess, printError, printWarning } from '../utils.js';
+import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
 import { promises as fs } from 'fs';
 import { cwd, exit, existsSync } from '../node-compat.js';
+import { getUnifiedMemory } from '../../memory/unified-memory-manager.js';
 
 export async function memoryCommand(subArgs, flags) {
   const memorySubcommand = subArgs[0];
   const memoryStore = './memory/memory-store.json';
+  
+  // Extract namespace from flags or subArgs
+  const namespace = flags?.namespace || flags?.ns || getNamespaceFromArgs(subArgs) || 'default';
 
   // Helper to load memory data
   async function loadMemory() {
@@ -25,11 +29,11 @@ export async function memoryCommand(subArgs, flags) {
 
   switch (memorySubcommand) {
     case 'store':
-      await storeMemory(subArgs, loadMemory, saveMemory);
+      await storeMemory(subArgs, loadMemory, saveMemory, namespace);
       break;
 
     case 'query':
-      await queryMemory(subArgs, loadMemory);
+      await queryMemory(subArgs, loadMemory, namespace);
       break;
 
     case 'stats':
@@ -37,15 +41,15 @@ export async function memoryCommand(subArgs, flags) {
       break;
 
     case 'export':
-      await exportMemory(subArgs, loadMemory);
+      await exportMemory(subArgs, loadMemory, namespace);
       break;
 
     case 'import':
-      await importMemory(subArgs, saveMemory);
+      await importMemory(subArgs, saveMemory, loadMemory);
       break;
 
     case 'clear':
-      await clearMemory(subArgs, saveMemory);
+      await clearMemory(subArgs, saveMemory, namespace);
       break;
 
     case 'list':
@@ -57,18 +61,17 @@ export async function memoryCommand(subArgs, flags) {
   }
 }
 
-async function storeMemory(subArgs, loadMemory, saveMemory) {
+async function storeMemory(subArgs, loadMemory, saveMemory, namespace) {
   const key = subArgs[1];
   const value = subArgs.slice(2).join(' ');
 
   if (!key || !value) {
-    printError('Usage: memory store <key> <value>');
+    printError('Usage: memory store <key> <value> [--namespace <ns>]');
     return;
   }
 
   try {
     const data = await loadMemory();
-    const namespace = getNamespaceFromArgs(subArgs) || 'default';
 
     if (!data[namespace]) {
       data[namespace] = [];
@@ -95,17 +98,16 @@ async function storeMemory(subArgs, loadMemory, saveMemory) {
   }
 }
 
-async function queryMemory(subArgs, loadMemory) {
+async function queryMemory(subArgs, loadMemory, namespace) {
   const search = subArgs.slice(1).join(' ');
 
   if (!search) {
-    printError('Usage: memory query <search>');
+    printError('Usage: memory query <search> [--namespace <ns>]');
     return;
   }
 
   try {
     const data = await loadMemory();
-    const namespace = getNamespaceFromArgs(subArgs);
     const results = [];
 
     for (const [ns, entries] of Object.entries(data)) {
@@ -174,12 +176,11 @@ async function showMemoryStats(loadMemory) {
   }
 }
 
-async function exportMemory(subArgs, loadMemory) {
+async function exportMemory(subArgs, loadMemory, namespace) {
   const filename = subArgs[1] || `memory-export-${Date.now()}.json`;
 
   try {
     const data = await loadMemory();
-    const namespace = getNamespaceFromArgs(subArgs);
 
     let exportData = data;
     if (namespace) {
@@ -201,7 +202,7 @@ async function exportMemory(subArgs, loadMemory) {
   }
 }
 
-async function importMemory(subArgs, saveMemory) {
+async function importMemory(subArgs, saveMemory, loadMemory) {
   const filename = subArgs[1];
 
   if (!filename) {
@@ -238,16 +239,28 @@ async function importMemory(subArgs, saveMemory) {
   }
 }
 
-async function clearMemory(subArgs, saveMemory) {
-  const namespace = getNamespaceFromArgs(subArgs);
-
-  if (!namespace) {
-    printError('Usage: memory clear --namespace <namespace>');
-    printWarning('This will clear all entries in the specified namespace');
-    return;
+async function clearMemory(subArgs, saveMemory, namespace) {
+  if (!namespace || namespace === 'default') {
+    const nsFromArgs = getNamespaceFromArgs(subArgs);
+    if (!nsFromArgs) {
+      printError('Usage: memory clear --namespace <namespace>');
+      printWarning('This will clear all entries in the specified namespace');
+      return;
+    }
+    namespace = nsFromArgs;
   }
 
   try {
+    // Helper to load memory data
+    async function loadMemory() {
+      try {
+        const content = await fs.readFile('./memory/memory-store.json', 'utf8');
+        return JSON.parse(content);
+      } catch {
+        return {};
+      }
+    }
+    
     const data = await loadMemory();
 
     if (!data[namespace]) {

package/src/cli/simple-commands/stream-processor.js

@@ -0,0 +1,327 @@
+/**
+ * Stream processor for Claude stream-json output
+ * Provides real-time status updates and progress tracking
+ */
+
+import { Transform } from 'stream';
+
+export class StreamJsonProcessor extends Transform {
+  constructor(options = {}) {
+    super({ objectMode: false });
+    this.buffer = '';
+    this.agentId = options.agentId;
+    this.agentName = options.agentName || 'Agent';
+    this.agentIcon = options.agentIcon || '🤖';
+    this.taskId = options.taskId || 'unknown';
+    this.startTime = Date.now();
+    this.eventCount = 0;
+    this.lastUpdate = Date.now();
+    this.options = options;
+    this.display = options.display; // Reference to concurrent display
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.buffer += chunk.toString();
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const event = JSON.parse(line);
+          this.processEvent(event);
+        } catch (e) {
+          // Not JSON, pass through if in verbose mode
+          if (this.options.verbose) {
+            console.log(`[${this.agentName}] ${line}`);
+          }
+        }
+      }
+    }
+
+    // Update progress display periodically
+    if (Date.now() - this.lastUpdate > 1000) {
+      this.updateProgress();
+      this.lastUpdate = Date.now();
+    }
+
+    callback();
+  }
+
+  _flush(callback) {
+    if (this.buffer.trim()) {
+      try {
+        const event = JSON.parse(this.buffer);
+        this.processEvent(event);
+      } catch (e) {
+        // Ignore
+      }
+    }
+    this.showFinalStatus();
+    callback();
+  }
+
+  processEvent(event) {
+    this.eventCount++;
+    
+    // If we have a concurrent display, update it instead of console logging
+    if (this.display) {
+      this.updateDisplay(event);
+      return;
+    }
+    
+    // Handle quiet mode - show important actions and commands
+    if (this.options.verbose === false && this.options.logLevel === 'quiet') {
+      switch (event.type) {
+        case 'system':
+          if (event.subtype === 'init') {
+            console.log(`🤖 ${this.agentName} - Started`);
+          }
+          break;
+        case 'assistant':
+          // In quiet mode, still show bash commands and key actions
+          if (event.message?.content?.length > 0) {
+            const content = event.message.content[0];
+            if (content.type === 'tool_use' && content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 60) {
+                console.log(`  🔧 ${command.substring(0, 57)}...`);
+              } else {
+                console.log(`  🔧 ${command}`);
+              }
+            } else if (content.type === 'tool_use' && ['WebSearch', 'Read', 'Write'].includes(content.name)) {
+              const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+              if (content.input) {
+                const firstKey = Object.keys(content.input)[0];
+                const firstValue = content.input[firstKey];
+                if (typeof firstValue === 'string' && firstValue.length < 40) {
+                  console.log(`  🔧 ${toolName}: ${firstValue}`);
+                } else {
+                  console.log(`  🔧 ${toolName}`);
+                }
+              }
+            }
+          }
+          break;
+        case 'result':
+          if (event.subtype === 'success') {
+            console.log(`✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`);
+          } else if (event.is_error) {
+            console.log(`❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+          }
+          break;
+      }
+      return;
+    }
+    
+    // Use clean, concise formatting for non-interactive mode
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          console.log(`\n🤖 ${this.agentName} - Started (Session: ${event.session_id?.substring(0, 8) || 'unknown'})`);
+        }
+        break;
+        
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            // Show only the first meaningful line, skip verbose details
+            const lines = content.text.split('\n').filter(line => line.trim());
+            if (lines.length > 0) {
+              const firstLine = lines[0].trim();
+              if (firstLine.length > 100) {
+                console.log(`💭 ${firstLine.substring(0, 97)}...`);
+              } else {
+                console.log(`💭 ${firstLine}`);
+              }
+            }
+          } else if (content.type === 'tool_use') {
+            // Show tool use with actual command/input when available
+            const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+            
+            // For Bash tool, show the actual command
+            if (content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 80) {
+                console.log(`🔧 Bash: ${command.substring(0, 77)}...`);
+              } else {
+                console.log(`🔧 Bash: ${command}`);
+              }
+            }
+            // For other tools, show key parameters
+            else if (content.input && Object.keys(content.input).length > 0) {
+              const firstKey = Object.keys(content.input)[0];
+              const firstValue = content.input[firstKey];
+              
+              if (typeof firstValue === 'string' && firstValue.length < 60) {
+                console.log(`🔧 ${toolName}: ${firstValue}`);
+              } else if (typeof firstValue === 'string') {
+                console.log(`🔧 ${toolName}: ${firstValue.substring(0, 57)}...`);
+              } else {
+                console.log(`🔧 ${toolName}`);
+              }
+            } else {
+              console.log(`🔧 ${toolName}`);
+            }
+          }
+        }
+        break;
+        
+      case 'user':
+        // Tool results - show only success/failure
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            console.log(`  ✅ Tool completed`);
+          } else {
+            console.log(`  ❌ Tool failed: ${result.error || 'Unknown error'}`);
+          }
+        }
+        break;
+        
+      case 'result':
+        if (event.subtype === 'success') {
+          console.log(`\n✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`);
+          if (event.total_cost_usd) {
+            console.log(`   💰 Cost: $${event.total_cost_usd.toFixed(4)}`);
+          }
+        } else if (event.is_error) {
+          console.log(`\n❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+        
+      default:
+        // Only show important events in verbose mode
+        if (this.options.verbose && ['tool_call', 'error', 'warning'].includes(event.type)) {
+          console.log(`ℹ️  [${event.type}] ${event.message || JSON.stringify(event).substring(0, 80)}...`);
+        }
+    }
+  }
+  
+  /**
+   * Update the concurrent display instead of console
+   */
+  updateDisplay(event) {
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          this.display.updateAgent(this.agentId, { status: 'active' });
+          this.display.addActivity(this.agentId, 'Initialized');
+        }
+        break;
+        
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            const preview = content.text.substring(0, 80);
+            this.display.addActivity(this.agentId, preview);
+          } else if (content.type === 'tool_use') {
+            this.display.addActivity(this.agentId, `Using ${content.name}`, content.name);
+          }
+        }
+        break;
+        
+      case 'user':
+        // Tool results
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            this.display.addActivity(this.agentId, 'Tool completed', null);
+          }
+        }
+        break;
+        
+      case 'result':
+        if (event.subtype === 'success') {
+          this.display.updateAgent(this.agentId, { 
+            status: 'completed',
+            progress: 100
+          });
+          this.display.addActivity(this.agentId, 'Task completed successfully');
+        } else if (event.is_error) {
+          this.display.updateAgent(this.agentId, { 
+            status: 'failed'
+          });
+          this.display.addActivity(this.agentId, `Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+    }
+  }
+
+  updateProgress() {
+    // Don't show progress updates in interactive-style mode - events handle the display
+  }
+
+  showFinalStatus() {
+    const elapsed = this.formatDuration(Date.now() - this.startTime);
+    if (this.eventCount > 0) {
+      console.log(`\n📊 ${this.agentName} - Processed ${this.eventCount} events in ${elapsed}`);
+    }
+  }
+
+  getSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    return frames[Math.floor(Date.now() / 100) % frames.length];
+  }
+
+  getProgressBar(elapsed, expected) {
+    const progress = Math.min(elapsed / expected, 1);
+    const filled = Math.floor(progress * 10);
+    const empty = 10 - filled;
+    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  }
+
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  formatToolParams(input) {
+    if (!input || typeof input !== 'object' || Object.keys(input).length === 0) {
+      return '';
+    }
+    
+    // Format key parameters for display
+    const keys = Object.keys(input);
+    if (keys.length === 1) {
+      const key = keys[0];
+      const value = input[key];
+      if (typeof value === 'string' && value.length < 30) {
+        return `(${key}: "${value}")`;
+      } else if (typeof value === 'number' || typeof value === 'boolean') {
+        return `(${key}: ${value})`;
+      }
+    } else if (keys.length <= 3) {
+      const params = keys.map(key => {
+        const value = input[key];
+        if (typeof value === 'string' && value.length < 20) {
+          return `${key}: "${value}"`;
+        } else if (typeof value === 'number' || typeof value === 'boolean') {
+          return `${key}: ${value}`;
+        } else {
+          return `${key}: ...`;
+        }
+      }).join(', ');
+      return `(${params})`;
+    }
+    
+    return '(...)';
+  }
+}
+
+/**
+ * Create a stream processor for an agent
+ */
+export function createStreamProcessor(agentName, agentIcon, options = {}) {
+  return new StreamJsonProcessor({
+    agentName,
+    agentIcon,
+    ...options
+  });
+}