claude-flow-novice 2.0.3 → 2.0.4

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

@@ -2,94 +2,75 @@
 /**
  * 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');
-    }
-
-    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;
+ */ async function executeClaudeCommand(prompt, timeout = 20000, useStreamJson = false) {
+    return new Promise((resolve)=>{
+        const args = [
+            '-p'
+        ];
+        if (useStreamJson) {
+            args.push('--output-format', 'stream-json', '--verbose');
         }
-
-        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,
+        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
+            });
         });
-      },
-    );
-  });
+    });
 }
-
 /**
  * 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:
@@ -110,112 +91,88 @@ 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;
+        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) + '...');
+    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 === '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;
+    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);
     }
-
-    return runChain(prompts, flags);
-  }
-
-  console.error(`❌ Unknown subcommand: ${subcommand}`);
-  console.log('Use "stream-chain help" for usage information');
+    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);
+    }
+    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();
-
-  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;
+ */ async function runChain(prompts, flags) {
+    const timeout = (flags.timeout || 20) * 1000;
+    const useMock = flags.mock || !checkClaudeAvailable();
     if (useMock) {
-      result = mockResponse(prompt);
+        console.log('ℹ️  Using mock mode (Claude CLI not available or --mock flag used)');
     } else {
-      result = await executeClaudeCommand(prompt, timeout, false);
+        console.log('ℹ️  Using real Claude CLI execution');
     }
-
-    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(`📝 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)}...`);
+        }
     }
-
-    console.log(`✅ Step ${i + 1} completed (${result.duration}ms)`);
-    if (flags.verbose && result.output) {
-      console.log(`   Output: ${result.output.slice(0, 200)}...`);
+    // 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)`);
     }
-  }
-
-  // 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`);
+    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,89 +1,68 @@
 /**
  * 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);
-    }
-
-    // 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
+ */ 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);
         }
-
-        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;
+        // 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');
         }
-
-        if (flags.verbose && stderr) {
-          console.error('Error output:', stderr);
+        // Add the prompt
+        args.push(prompt);
+        if (flags.verbose) {
+            console.log(`   Debug: Executing: claude ${args.join(' ')}`);
         }
-
-        safeResolve({
-          success: !error || error.code === 0,
-          duration,
-          output: stdout || '',
-          stream: !isLast && stdout ? stdout : null,
-          error: stderr || (error ? error.message : null),
+        // 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)
+            });
         });
-      },
-    );
-  });
+    });
 }