claude-flow 1.0.11 → 1.0.13

package/bin/claude-flow

@@ -1,77 +1,15 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
 const path = require('path');
-const fs = require('fs');
+const { spawn } = require('child_process');
 
-// Special handling for init command
-if (process.argv[2] === 'init') {
-  // Use the Node.js init script that handles Deno installation
-  const initScript = path.join(__dirname, '..', 'scripts', 'init.js');
-  const child = spawn('node', [initScript, ...process.argv.slice(3)], { 
-    stdio: 'inherit',
-    env: process.env
-  });
-  child.on('exit', (code) => process.exit(code || 0));
-  return;
-}
+// Run the main.js file as a separate process to ensure it's the main module
+const mainPath = path.join(__dirname, '..', 'src', 'cli', 'main.js');
+const child = spawn(process.execPath, [mainPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env
+});
 
-// Check if compiled binary exists
-const binaryPath = __filename + '-binary';
-if (fs.existsSync(binaryPath)) {
-  // Use compiled binary
-  const child = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
-  child.on('exit', (code) => process.exit(code));
-} else {
-  // Fallback to Deno execution
-  const mainPath = path.join(__dirname, '..', 'src', 'cli', 'main.ts');
-  
-  // Try to find deno in common locations
-  let denoPath = 'deno';
-  const os = require('os');
-  const possiblePaths = [
-    path.join(os.homedir(), '.deno', 'bin', 'deno'),
-    '/usr/local/bin/deno',
-    '/usr/bin/deno',
-    'deno' // Try PATH as last resort
-  ];
-  
-  let denoFound = false;
-  for (const p of possiblePaths) {
-    try {
-      if (p === 'deno' || fs.existsSync(p)) {
-        denoPath = p;
-        // Test if it works
-        const testChild = spawn(p, ['--version'], { stdio: 'pipe' });
-        testChild.on('close', (code) => {
-          if (code === 0) denoFound = true;
-        });
-        if (p !== 'deno') {
-          denoFound = true;
-          break;
-        }
-      }
-    } catch (e) {
-      // Continue to next path
-    }
-  }
-  
-  const child = spawn(denoPath, ['run', '--allow-all', mainPath, ...process.argv.slice(2)], { 
-    stdio: 'inherit',
-    env: { ...process.env }
-  });
-  
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      console.error('Error: Deno is not installed. Please install Deno first:');
-      console.error('Visit https://deno.land/ for installation instructions.');
-      console.error('Or run: curl -fsSL https://deno.land/x/install/install.sh | sh');
-      process.exit(1);
-    } else {
-      console.error('Error executing claude-flow:', err.message);
-      process.exit(1);
-    }
-  });
-  
-  child.on('exit', (code) => process.exit(code || 0));
-}
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {
@@ -38,8 +38,9 @@
     "bin/claude-flow",
     "src/",
     "scripts/install.js",
+    "scripts/init.js",
     "README.md",
     "LICENSE",
     "deno.json"
   ]
-}
+}

package/scripts/init.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const { spawn, execSync } = require('child_process');
+
+// Colors for console output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m'
+};
+
+const success = (msg) => console.log(`${colors.green}✅ ${msg}${colors.reset}`);
+const error = (msg) => console.log(`${colors.red}❌ ${msg}${colors.reset}`);
+const warning = (msg) => console.log(`${colors.yellow}⚠️  ${msg}${colors.reset}`);
+const info = (msg) => console.log(`${colors.cyan}ℹ️  ${msg}${colors.reset}`);
+
+// Check if Deno is installed
+function checkDeno() {
+  try {
+    execSync('deno --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    // Try common locations
+    const homeDir = os.homedir();
+    const possiblePaths = [
+      path.join(homeDir, '.deno', 'bin', 'deno'),
+      '/usr/local/bin/deno',
+      '/usr/bin/deno'
+    ];
+    
+    for (const denoPath of possiblePaths) {
+      if (fs.existsSync(denoPath)) {
+        try {
+          execSync(`${denoPath} --version`, { stdio: 'ignore' });
+          return true;
+        } catch {
+          // Continue checking
+        }
+      }
+    }
+    
+    return false;
+  }
+}
+
+// Install Deno automatically
+async function installDeno() {
+  return new Promise((resolve, reject) => {
+    warning('Deno not found. Installing Deno automatically...');
+    
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    const denoDir = path.join(homeDir, '.deno');
+    
+    if (platform === 'win32') {
+      error('Please install Deno manually on Windows from https://deno.land/');
+      console.log('Run in PowerShell: irm https://deno.land/install.ps1 | iex');
+      reject(new Error('Manual installation required on Windows'));
+      return;
+    }
+    
+    info('Downloading Deno installer...');
+    
+    // Download the install script
+    https.get('https://deno.land/x/install/install.sh', (res) => {
+      let scriptData = '';
+      
+      res.on('data', (chunk) => {
+        scriptData += chunk;
+      });
+      
+      res.on('end', () => {
+        // Save the script
+        const tempScript = path.join(os.tmpdir(), 'deno-install.sh');
+        fs.writeFileSync(tempScript, scriptData);
+        fs.chmodSync(tempScript, '755');
+        
+        // Run the installer
+        const install = spawn('sh', [tempScript], {
+          env: {
+            ...process.env,
+            DENO_INSTALL: denoDir
+          },
+          stdio: 'inherit'
+        });
+        
+        install.on('close', (code) => {
+          // Clean up
+          try {
+            fs.unlinkSync(tempScript);
+          } catch {}
+          
+          if (code === 0) {
+            success('Deno installed successfully!');
+            
+            // Export path instructions
+            const denoBinPath = path.join(denoDir, 'bin');
+            const shellConfig = platform === 'darwin' ? '~/.zshrc' : '~/.bashrc';
+            
+            info('\nTo use Deno permanently, add it to your PATH:');
+            console.log(`  export DENO_INSTALL="${denoDir}"`);
+            console.log(`  export PATH="$DENO_INSTALL/bin:$PATH"`);
+            console.log(`\nAdd these lines to your ${shellConfig} file.`);
+            
+            // Create setup script
+            const setupScript = `#!/bin/bash
+# Claude-Flow Deno Setup Script
+# This script sets up Deno in your environment
+
+export DENO_INSTALL="${denoDir}"
+export PATH="$DENO_INSTALL/bin:$PATH"
+
+# Check if Deno is accessible
+if command -v deno &> /dev/null; then
+    echo "✓ Deno is now available in your PATH"
+    deno --version
+else
+    echo "❌ Failed to add Deno to PATH"
+    echo "Please manually add the following to your ${shellConfig}:"
+    echo '  export DENO_INSTALL="${denoDir}"'
+    echo '  export PATH="$DENO_INSTALL/bin:$PATH"'
+fi
+
+# Run claude-flow init with Deno
+echo ""
+echo "Running claude-flow init..."
+${path.join(denoDir, 'bin', 'deno')} run --allow-all ${path.join(__dirname, '..', 'src', 'cli', 'main.ts')} init "$@"
+`;
+            
+            fs.writeFileSync('setup-deno.sh', setupScript);
+            fs.chmodSync('setup-deno.sh', '755');
+            
+            info('\n✓ Created setup-deno.sh script');
+            console.log('  Run: source ./setup-deno.sh');
+            console.log('  to set up Deno and continue with initialization\n');
+            
+            // Update PATH for current process
+            process.env.PATH = `${denoBinPath}:${process.env.PATH}`;
+            process.env.DENO_INSTALL = denoDir;
+            
+            resolve(true);
+          } else {
+            reject(new Error('Failed to install Deno'));
+          }
+        });
+        
+        install.on('error', (err) => {
+          reject(err);
+        });
+      });
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+// Main init function
+async function init(args) {
+  try {
+    console.log(`${colors.blue}🧠 Claude-Flow Init - Setting up your project${colors.reset}\n`);
+    
+    // Check if Deno is installed
+    const denoInstalled = checkDeno();
+    
+    if (!denoInstalled) {
+      try {
+        await installDeno();
+      } catch (err) {
+        error(`Failed to install Deno: ${err.message}`);
+        console.log('\nPlease install Deno manually:');
+        console.log('  curl -fsSL https://deno.land/x/install/install.sh | sh');
+        console.log('  or visit: https://deno.land/');
+        process.exit(1);
+      }
+    } else {
+      info('✓ Deno is already installed');
+    }
+    
+    // Now run the actual init command with Deno
+    let denoPath = 'deno';
+    
+    // If Deno wasn't originally installed, use the newly installed path
+    if (!denoInstalled) {
+      denoPath = path.join(os.homedir(), '.deno', 'bin', 'deno');
+    } else {
+      // Try to find Deno in common locations
+      const possiblePaths = [
+        path.join(os.homedir(), '.deno', 'bin', 'deno'),
+        '/usr/local/bin/deno',
+        '/usr/bin/deno',
+        'deno' // Try PATH as last resort
+      ];
+      
+      for (const p of possiblePaths) {
+        try {
+          if (p === 'deno') {
+            execSync('deno --version', { stdio: 'ignore' });
+            denoPath = p;
+            break;
+          } else if (fs.existsSync(p)) {
+            execSync(`${p} --version`, { stdio: 'ignore' });
+            denoPath = p;
+            break;
+          }
+        } catch {
+          // Continue checking
+        }
+      }
+    }
+    
+    const mainPath = path.join(__dirname, '..', 'src', 'cli', 'main.ts');
+    
+    // Pass through all arguments
+    const initArgs = ['run', '--allow-all', mainPath, 'init', ...args];
+    
+    const init = spawn(denoPath, initArgs, {
+      stdio: 'inherit',
+      env: process.env
+    });
+    
+    init.on('close', (code) => {
+      if (code !== 0) {
+        error('Init command failed');
+        process.exit(code);
+      }
+    });
+    
+    init.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        error('Deno not found. Please run: source ./setup-deno.sh');
+        error('Then try again: npx claude-flow init');
+      } else {
+        error(`Failed to run init: ${err.message}`);
+      }
+      process.exit(1);
+    });
+    
+  } catch (err) {
+    error(`Init failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  init(args);
+}

package/src/cli/cli-core.ts

@@ -8,7 +8,7 @@ import { red, green, yellow, blue, bold, cyan } from "https://deno.land/std@0.22
 import { ensureDir } from "https://deno.land/std@0.224.0/fs/mod.ts";
 import { join } from "https://deno.land/std@0.224.0/path/mod.ts";
 
-export const VERSION = "1.0.11";
+export const VERSION = "1.0.13";
 
 interface CommandContext {
   args: string[];

package/src/cli/main.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Claude-Flow CLI - JavaScript entry point for npm distribution
+ * This file is used when running from npm/npx to avoid TypeScript compilation issues
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Version should match package.json
+const VERSION = '1.0.13';
+
+// Colors for console output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m'
+};
+
+function printHelp() {
+  console.log(`
+${colors.blue}${colors.bold}🧠 claude-flow v${VERSION} - Advanced AI Agent Orchestration System${colors.reset}
+
+USAGE:
+  claude-flow [COMMAND] [OPTIONS]
+
+COMMANDS:
+  init                 Initialize Claude Code integration files
+  start                Start the orchestration system
+  task                 Manage tasks
+  agent                Manage agents
+  status               Show system status
+  mcp                  Manage MCP server and tools
+  claude               Spawn Claude instances with specific configurations
+  monitor              Live monitoring dashboard
+  help                 Show help information
+
+GLOBAL OPTIONS:
+  -h, --help                Show help
+  -v, --version             Show version
+  -c, --config              Path to configuration file
+      --verbose             Enable verbose logging
+      --log-level           Set log level (debug, info, warn, error)
+
+EXAMPLES:
+  claude-flow init                                     # Initialize project
+  claude-flow start                                    # Start orchestrator
+  claude-flow agent spawn researcher --name "Bot"     # Spawn research agent
+  claude-flow task create research "Analyze data"     # Create task
+  claude-flow status                                  # Show system status
+
+For more detailed help on specific commands, use:
+  claude-flow [COMMAND] --help
+
+Documentation: https://github.com/ruvnet/claude-code-flow
+Issues: https://github.com/ruvnet/claude-code-flow/issues
+
+Created by rUv - Built with ❤️ for the Claude community
+`);
+}
+
+function checkDeno() {
+  const possiblePaths = [
+    path.join(os.homedir(), '.deno', 'bin', 'deno'),
+    '/usr/local/bin/deno',
+    '/usr/bin/deno'
+  ];
+  
+  // Check PATH first
+  try {
+    const result = require('child_process').execSync('deno --version', { stdio: 'pipe' });
+    return 'deno';
+  } catch {}
+  
+  // Check common locations
+  for (const denoPath of possiblePaths) {
+    if (fs.existsSync(denoPath)) {
+      try {
+        require('child_process').execSync(`${denoPath} --version`, { stdio: 'pipe' });
+        return denoPath;
+      } catch {}
+    }
+  }
+  
+  return null;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  
+  // Handle version flag
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`claude-flow v${VERSION}`);
+    process.exit(0);
+  }
+  
+  // Handle help flag or no args
+  if (args.length === 0 || args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    printHelp();
+    process.exit(0);
+  }
+  
+  // Special handling for init command
+  if (args[0] === 'init') {
+    const initScript = path.join(__dirname, '..', '..', 'scripts', 'init.js');
+    const child = spawn('node', [initScript, ...args.slice(1)], { 
+      stdio: 'inherit',
+      env: process.env
+    });
+    child.on('exit', (code) => process.exit(code || 0));
+    return;
+  }
+  
+  // For other commands, check if Deno is available
+  const denoPath = checkDeno();
+  
+  if (!denoPath) {
+    console.error(`${colors.red}❌ Error: Deno is not installed.${colors.reset}`);
+    console.error(`${colors.yellow}Please run 'claude-flow init' first to set up your environment.${colors.reset}`);
+    console.error('\nAlternatively, install Deno manually:');
+    console.error('  curl -fsSL https://deno.land/x/install/install.sh | sh');
+    console.error('  or visit: https://deno.land/');
+    process.exit(1);
+  }
+  
+  // Try to use the simple CLI with Deno
+  const simplePath = path.join(__dirname, 'simple-cli.js');
+  
+  if (fs.existsSync(simplePath)) {
+    const child = spawn(denoPath, ['run', '--allow-all', simplePath, ...args], {
+      stdio: 'inherit',
+      env: process.env
+    });
+    
+    child.on('error', (err) => {
+      console.error(`${colors.red}❌ Error: Failed to execute command${colors.reset}`);
+      console.error(err.message);
+      process.exit(1);
+    });
+    
+    child.on('exit', (code) => process.exit(code || 0));
+  } else {
+    // If we can't find the files, show a helpful error
+    console.error(`${colors.red}❌ Error: Claude-Flow CLI files not found${colors.reset}`);
+    console.error('This might be a packaging issue. Please try:');
+    console.error('  1. Clone from source: git clone https://github.com/ruvnet/claude-code-flow');
+    console.error('  2. Run: cd claude-code-flow && npm install');
+    process.exit(1);
+  }
+}
+
+// Run the CLI
+if (require.main === module) {
+  main();
+}
+
+module.exports = { VERSION };

package/src/cli/main.ts

@@ -6,7 +6,7 @@
 import { CLI } from "./cli-core.ts";
 import { setupCommands } from "./commands/index.ts";
 
-const VERSION = "1.0.11";
+const VERSION = "1.0.13";
 
 async function main() {
   const cli = new CLI("claude-flow", "Advanced AI Agent Orchestration System");