claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/stream-chain-clean.js

@@ -2,75 +2,94 @@
 /**
  * Stream Chain Command - Connect multiple Claude instances via stream-json
  * Clean implementation focused on real Claude CLI execution
- */ import { exec, execSync } from "child_process";
+ */
+
+import { exec, execSync } from 'child_process';
+
 /**
  * Check if claude CLI is available
- */ function checkClaudeAvailable() {
-    try {
-        execSync('which claude', {
-            stdio: 'ignore'
-        });
-        return true;
-    } catch  {
-        return false;
-    }
+ */
+function checkClaudeAvailable() {
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
 }
+
 /**
  * Mock implementation for fallback
- */ function mockResponse(prompt) {
-    return {
-        success: true,
-        duration: 500,
-        output: `✅ Mock response for: ${prompt.slice(0, 50)}...`,
-        stream: null,
-        error: null
-    };
+ */
+function mockResponse(prompt) {
+  return {
+    success: true,
+    duration: 500,
+    output: `✅ Mock response for: ${prompt.slice(0, 50)}...`,
+    stream: null,
+    error: null,
+  };
 }
+
 /**
  * Execute a single Claude CLI command
- */ async function executeClaudeCommand(prompt, timeout = 20000, useStreamJson = false) {
-    return new Promise((resolve)=>{
-        const args = [
-            '-p'
-        ];
-        if (useStreamJson) {
-            args.push('--output-format', 'stream-json', '--verbose');
+ */
+async function executeClaudeCommand(prompt, timeout = 20000, useStreamJson = false) {
+  return new Promise((resolve) => {
+    const args = ['-p'];
+
+    if (useStreamJson) {
+      args.push('--output-format', 'stream-json', '--verbose');
+    }
+
+    args.push(prompt);
+    const command = `claude ${args.join(' ')}`;
+
+    console.log(`🔄 Executing: ${command}`);
+
+    const startTime = Date.now();
+
+    exec(
+      command,
+      {
+        timeout,
+        maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+      },
+      (error, stdout, stderr) => {
+        const duration = Date.now() - startTime;
+
+        if (error && error.code === 'TIMEOUT') {
+          console.log('⚠️  Claude CLI timed out, using mock response...');
+          resolve(mockResponse(prompt));
+          return;
         }
-        args.push(prompt);
-        const command = `claude ${args.join(' ')}`;
-        console.log(`🔄 Executing: ${command}`);
-        const startTime = Date.now();
-        exec(command, {
-            timeout,
-            maxBuffer: 1024 * 1024 * 10
-        }, (error, stdout, stderr)=>{
-            const duration = Date.now() - startTime;
-            if (error && error.code === 'TIMEOUT') {
-                console.log('⚠️  Claude CLI timed out, using mock response...');
-                resolve(mockResponse(prompt));
-                return;
-            }
-            if (error) {
-                console.error('Claude CLI error:', error.message);
-                resolve(mockResponse(prompt));
-                return;
-            }
-            resolve({
-                success: true,
-                duration,
-                output: stdout.trim(),
-                stream: useStreamJson ? stdout : null,
-                error: stderr ? stderr.trim() : null
-            });
+
+        if (error) {
+          console.error('Claude CLI error:', error.message);
+          resolve(mockResponse(prompt));
+          return;
+        }
+
+        resolve({
+          success: true,
+          duration,
+          output: stdout.trim(),
+          stream: useStreamJson ? stdout : null,
+          error: stderr ? stderr.trim() : null,
         });
-    });
+      },
+    );
+  });
 }
+
 /**
  * Main stream chain command
- */ export async function streamChainCommand(args, flags) {
-    const subcommand = args[0] || 'help';
-    if (subcommand === 'help') {
-        console.log(`
+ */
+export async function streamChainCommand(args, flags) {
+  const subcommand = args[0] || 'help';
+
+  if (subcommand === 'help') {
+    console.log(`
 🔗 Stream Chain Command
 
 USAGE:
@@ -91,88 +110,112 @@ EXAMPLES:
 
 For real execution, Claude CLI must be installed and configured.
     `);
-        return;
-    }
-    if (subcommand === 'test') {
-        console.log('🧪 Testing Claude CLI...');
-        if (!checkClaudeAvailable()) {
-            console.log('❌ Claude CLI not found');
-            return;
-        }
-        const result = await executeClaudeCommand('Hello, test', 10000);
-        console.log('✅ Test result:', result.success ? 'PASSED' : 'FAILED');
-        if (result.output) {
-            console.log('📄 Output:', result.output.slice(0, 100) + '...');
-        }
-        return;
+    return;
+  }
+
+  if (subcommand === 'test') {
+    console.log('🧪 Testing Claude CLI...');
+
+    if (!checkClaudeAvailable()) {
+      console.log('❌ Claude CLI not found');
+      return;
     }
-    if (subcommand === 'demo') {
-        console.log('🎭 Running Stream Chain Demo');
-        console.log('━'.repeat(50));
-        const prompts = [
-            'Analyze requirements for a todo app',
-            'Design the data model',
-            'Create implementation plan'
-        ];
-        return runChain(prompts, flags);
+
+    const result = await executeClaudeCommand('Hello, test', 10000);
+    console.log('✅ Test result:', result.success ? 'PASSED' : 'FAILED');
+    if (result.output) {
+      console.log('📄 Output:', result.output.slice(0, 100) + '...');
     }
-    if (subcommand === 'run') {
-        const prompts = args.slice(1);
-        if (prompts.length < 2) {
-            console.error('❌ Error: Need at least 2 prompts');
-            console.log('Usage: stream-chain run "prompt1" "prompt2" [...]');
-            return;
-        }
-        return runChain(prompts, flags);
+    return;
+  }
+
+  if (subcommand === 'demo') {
+    console.log('🎭 Running Stream Chain Demo');
+    console.log('━'.repeat(50));
+
+    const prompts = [
+      'Analyze requirements for a todo app',
+      'Design the data model',
+      'Create implementation plan',
+    ];
+
+    return runChain(prompts, flags);
+  }
+
+  if (subcommand === 'run') {
+    const prompts = args.slice(1);
+
+    if (prompts.length < 2) {
+      console.error('❌ Error: Need at least 2 prompts');
+      console.log('Usage: stream-chain run "prompt1" "prompt2" [...]');
+      return;
     }
-    console.error(`❌ Unknown subcommand: ${subcommand}`);
-    console.log('Use "stream-chain help" for usage information');
+
+    return runChain(prompts, flags);
+  }
+
+  console.error(`❌ Unknown subcommand: ${subcommand}`);
+  console.log('Use "stream-chain help" for usage information');
 }
+
 /**
  * Execute a chain of prompts
- */ async function runChain(prompts, flags) {
-    const timeout = (flags.timeout || 20) * 1000;
-    const useMock = flags.mock || !checkClaudeAvailable();
+ */
+async function runChain(prompts, flags) {
+  const timeout = (flags.timeout || 20) * 1000;
+  const useMock = flags.mock || !checkClaudeAvailable();
+
+  if (useMock) {
+    console.log('ℹ️  Using mock mode (Claude CLI not available or --mock flag used)');
+  } else {
+    console.log('ℹ️  Using real Claude CLI execution');
+  }
+
+  console.log(`📝 Chain length: ${prompts.length} steps\n`);
+
+  const results = [];
+
+  for (let i = 0; i < prompts.length; i++) {
+    const prompt = prompts[i];
+    console.log(`🔄 Step ${i + 1}/${prompts.length}: ${prompt.slice(0, 50)}...`);
+
+    let result;
     if (useMock) {
-        console.log('ℹ️  Using mock mode (Claude CLI not available or --mock flag used)');
+      result = mockResponse(prompt);
     } else {
-        console.log('ℹ️  Using real Claude CLI execution');
+      result = await executeClaudeCommand(prompt, timeout, false);
     }
-    console.log(`📝 Chain length: ${prompts.length} steps\n`);
-    const results = [];
-    for(let i = 0; i < prompts.length; i++){
-        const prompt = prompts[i];
-        console.log(`🔄 Step ${i + 1}/${prompts.length}: ${prompt.slice(0, 50)}...`);
-        let result;
-        if (useMock) {
-            result = mockResponse(prompt);
-        } else {
-            result = await executeClaudeCommand(prompt, timeout, false);
-        }
-        results.push({
-            step: i + 1,
-            prompt: prompt.slice(0, 50),
-            success: result.success,
-            duration: result.duration
-        });
-        if (!result.success) {
-            console.error(`❌ Step ${i + 1} failed`);
-            break;
-        }
-        console.log(`✅ Step ${i + 1} completed (${result.duration}ms)`);
-        if (flags.verbose && result.output) {
-            console.log(`   Output: ${result.output.slice(0, 200)}...`);
-        }
+
+    results.push({
+      step: i + 1,
+      prompt: prompt.slice(0, 50),
+      success: result.success,
+      duration: result.duration,
+    });
+
+    if (!result.success) {
+      console.error(`❌ Step ${i + 1} failed`);
+      break;
     }
-    // Summary
-    console.log('\n' + '═'.repeat(50));
-    console.log('📊 Chain Summary');
-    console.log('═'.repeat(50));
-    for (const result of results){
-        const status = result.success ? '✅' : '❌';
-        console.log(`${status} Step ${result.step}: ${result.prompt}... (${result.duration}ms)`);
+
+    console.log(`✅ Step ${i + 1} completed (${result.duration}ms)`);
+    if (flags.verbose && result.output) {
+      console.log(`   Output: ${result.output.slice(0, 200)}...`);
     }
-    const totalTime = results.reduce((sum, r)=>sum + r.duration, 0);
-    console.log(`\n⏱️  Total execution time: ${totalTime}ms`);
+  }
+
+  // Summary
+  console.log('\n' + '═'.repeat(50));
+  console.log('📊 Chain Summary');
+  console.log('═'.repeat(50));
+
+  for (const result of results) {
+    const status = result.success ? '✅' : '❌';
+    console.log(`${status} Step ${result.step}: ${result.prompt}... (${result.duration}ms)`);
+  }
+
+  const totalTime = results.reduce((sum, r) => sum + r.duration, 0);
+  console.log(`\n⏱️  Total execution time: ${totalTime}ms`);
 }
+
 export default streamChainCommand;

package/dist/src/cli/simple-commands/stream-chain-fixed.js

@@ -1,68 +1,89 @@
 /**
  * Execute a single step in the stream chain
- */ async function executeStreamStep(prompt, inputStream, isLast, flags = {}) {
-    return new Promise((resolve)=>{
-        const startTime = Date.now();
-        let resolved = false; // Prevent double resolution
-        const safeResolve = (result)=>{
-            if (!resolved) {
-                resolved = true;
-                resolve(result);
-            }
-        };
-        // Check if we should use mock mode
-        const useMock = flags.mock || !checkClaudeAvailable();
-        if (useMock) {
-            // Mock implementation when claude CLI isn't available or mock flag is set
-            return mockStreamStep(prompt, inputStream, isLast, flags, safeResolve, startTime);
+ */
+async function executeStreamStep(prompt, inputStream, isLast, flags = {}) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    let resolved = false; // Prevent double resolution
+
+    const safeResolve = (result) => {
+      if (!resolved) {
+        resolved = true;
+        resolve(result);
+      }
+    };
+
+    // Check if we should use mock mode
+    const useMock = flags.mock || !checkClaudeAvailable();
+
+    if (useMock) {
+      // Mock implementation when claude CLI isn't available or mock flag is set
+      return mockStreamStep(prompt, inputStream, isLast, flags, safeResolve, startTime);
+    }
+
+    // Set a reasonable timeout for real Claude CLI (15 seconds - more realistic)
+    const stepTimeout = flags.timeout ? parseInt(flags.timeout) * 1000 : 15000;
+
+    // Build command arguments
+    const args = ['-p'];
+
+    // For now, avoid stream-json input chaining due to format complexity
+    // Each step runs independently for better reliability
+    if (!isLast || flags.json) {
+      args.push('--output-format', 'stream-json');
+      // stream-json output requires --verbose
+      args.push('--verbose');
+    }
+
+    // Add the prompt
+    args.push(prompt);
+
+    if (flags.verbose) {
+      console.log(`   Debug: Executing: claude ${args.join(' ')}`);
+    }
+
+    // Use exec with built-in timeout for better reliability
+    const command = `claude ${args.join(' ')}`;
+
+    exec(
+      command,
+      {
+        timeout: stepTimeout,
+        maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+      },
+      (error, stdout, stderr) => {
+        if (resolved) {
+          return; // Already resolved
         }
-        // Set a reasonable timeout for real Claude CLI (15 seconds - more realistic)
-        const stepTimeout = flags.timeout ? parseInt(flags.timeout) * 1000 : 15000;
-        // Build command arguments
-        const args = [
-            '-p'
-        ];
-        // For now, avoid stream-json input chaining due to format complexity
-        // Each step runs independently for better reliability
-        if (!isLast || flags.json) {
-            args.push('--output-format', 'stream-json');
-            // stream-json output requires --verbose
-            args.push('--verbose');
+
+        const duration = Date.now() - startTime;
+
+        if (error && error.code === 'TIMEOUT') {
+          // Handle timeout via exec
+          console.log('⚠️  Claude CLI timed out, falling back to mock mode...');
+          mockStreamStep(
+            prompt,
+            inputStream,
+            isLast,
+            { ...flags, mock: true },
+            safeResolve,
+            Date.now(),
+          );
+          return;
         }
-        // Add the prompt
-        args.push(prompt);
-        if (flags.verbose) {
-            console.log(`   Debug: Executing: claude ${args.join(' ')}`);
+
+        if (flags.verbose && stderr) {
+          console.error('Error output:', stderr);
         }
-        // Use exec with built-in timeout for better reliability
-        const command = `claude ${args.join(' ')}`;
-        exec(command, {
-            timeout: stepTimeout,
-            maxBuffer: 1024 * 1024 * 10
-        }, (error, stdout, stderr)=>{
-            if (resolved) {
-                return; // Already resolved
-            }
-            const duration = Date.now() - startTime;
-            if (error && error.code === 'TIMEOUT') {
-                // Handle timeout via exec
-                console.log('⚠️  Claude CLI timed out, falling back to mock mode...');
-                mockStreamStep(prompt, inputStream, isLast, {
-                    ...flags,
-                    mock: true
-                }, safeResolve, Date.now());
-                return;
-            }
-            if (flags.verbose && stderr) {
-                console.error('Error output:', stderr);
-            }
-            safeResolve({
-                success: !error || error.code === 0,
-                duration,
-                output: stdout || '',
-                stream: !isLast && stdout ? stdout : null,
-                error: stderr || (error ? error.message : null)
-            });
+
+        safeResolve({
+          success: !error || error.code === 0,
+          duration,
+          output: stdout || '',
+          stream: !isLast && stdout ? stdout : null,
+          error: stderr || (error ? error.message : null),
         });
-    });
+      },
+    );
+  });
 }