claude-flow 1.0.10 → 1.0.11

package/bin/claude-flow

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// 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;
+}
+
+// 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));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "postinstall": "node scripts/install.js",
-    "build": "PATH=\"/home/codespace/.deno/bin:$PATH\" deno compile --allow-all --no-check --output=bin/claude-flow src/cli/main.ts",
+    "build": "PATH=\"/home/codespace/.deno/bin:$PATH\" deno compile --allow-all --no-check --output=bin/claude-flow-binary src/cli/main.ts",
     "build:simple": "PATH=\"/home/codespace/.deno/bin:$PATH\" deno compile --allow-all --no-check --output=bin/claude-flow-simple src/cli/simple-cli.ts",
     "test": "deno task test"
   },

package/scripts/install.js

@@ -50,6 +50,55 @@ async function installDeno() {
   });
 }
 
+// Build the binary
+async function buildBinary() {
+  console.log('Building Claude-Flow binary...');
+  
+  // Create bin directory if it doesn't exist
+  const binDir = path.join(__dirname, '..', 'bin');
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+  
+  // Try to find deno in common locations
+  let denoPath = 'deno';
+  const possiblePaths = [
+    path.join(os.homedir(), '.deno', 'bin', 'deno'),
+    '/usr/local/bin/deno',
+    '/usr/bin/deno'
+  ];
+  
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      denoPath = p;
+      break;
+    }
+  }
+  
+  return new Promise((resolve, reject) => {
+    const build = spawn(denoPath, [
+      'compile',
+      '--allow-all',
+      '--no-check',
+      '--output=' + path.join(binDir, 'claude-flow-binary'),
+      path.join(__dirname, '..', 'src', 'cli', 'main.ts')
+    ], { stdio: 'inherit' });
+    
+    build.on('close', (code) => {
+      if (code === 0) {
+        console.log('Binary built successfully!');
+        resolve();
+      } else {
+        reject(new Error('Failed to build binary'));
+      }
+    });
+    
+    build.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
 // Main installation process
 async function main() {
   try {
@@ -59,6 +108,14 @@ async function main() {
       await installDeno();
     }
     
+    // Try to build the binary
+    try {
+      await buildBinary();
+    } catch (buildError) {
+      console.warn('Failed to build binary:', buildError.message);
+      console.log('Falling back to runtime execution mode.');
+    }
+    
     console.log('Claude-Flow installation completed!');
     console.log('You can now use: npx claude-flow or claude-flow (if installed globally)');
     

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.3";
+export const VERSION = "1.0.11";
 
 interface CommandContext {
   args: string[];

package/src/cli/commands/index.ts

@@ -12,6 +12,129 @@ let orchestrator: Orchestrator | null = null;
 let configManager: ConfigManager | null = null;
 let persistence: JsonPersistenceManager | null = null;
 
+async function checkAndInstallDeno(): Promise<boolean> {
+  try {
+    // Check if Deno is already available
+    const checkCommand = new Deno.Command("deno", {
+      args: ["--version"],
+      stdout: "null",
+      stderr: "null",
+    });
+    
+    try {
+      const result = await checkCommand.output();
+      if (result.success) {
+        info("✓ Deno is already installed");
+        return true;
+      }
+    } catch {
+      // Deno not found, continue to installation
+    }
+    
+    warning("Deno not found. Installing Deno automatically...");
+    
+    // Determine OS and install Deno
+    const os = Deno.build.os;
+    const homeDir = Deno.env.get("HOME") || Deno.env.get("USERPROFILE") || "";
+    const denoDir = `${homeDir}/.deno`;
+    
+    if (os === "windows") {
+      error("Please install Deno manually on Windows from https://deno.land/");
+      console.log("Run: irm https://deno.land/install.ps1 | iex");
+      return false;
+    }
+    
+    // Download and install Deno for Unix-like systems
+    info("Downloading Deno installer...");
+    
+    const installScript = await fetch("https://deno.land/x/install/install.sh");
+    if (!installScript.ok) {
+      throw new Error("Failed to download Deno installer");
+    }
+    
+    const scriptContent = await installScript.text();
+    const tempFile = await Deno.makeTempFile({ suffix: ".sh" });
+    await Deno.writeTextFile(tempFile, scriptContent);
+    
+    // Make script executable
+    await Deno.chmod(tempFile, 0o755);
+    
+    // Run the installer
+    const installCommand = new Deno.Command("sh", {
+      args: [tempFile],
+      env: {
+        ...Deno.env.toObject(),
+        DENO_INSTALL: denoDir,
+      },
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    
+    const installResult = await installCommand.output();
+    
+    // Clean up temp file
+    await Deno.remove(tempFile);
+    
+    if (!installResult.success) {
+      throw new Error("Failed to install Deno");
+    }
+    
+    success("✓ Deno installed successfully!");
+    
+    // Export path instructions
+    const denoBinPath = `${denoDir}/bin`;
+    const shellConfig = os === "darwin" ? "~/.zshrc" : "~/.bashrc";
+    
+    info("\nTo use Deno, 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 to make it permanent.`);
+    
+    // Try to add to current session PATH
+    const currentPath = Deno.env.get("PATH") || "";
+    if (!currentPath.includes(denoBinPath)) {
+      Deno.env.set("PATH", `${denoBinPath}:${currentPath}`);
+      info(`\n✓ Temporarily added Deno to PATH for this session`);
+    }
+    
+    // Create a shell script to help users
+    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
+`;
+    
+    await Deno.writeTextFile("setup-deno.sh", setupScript);
+    await Deno.chmod("setup-deno.sh", 0o755);
+    
+    info("\n✓ Created setup-deno.sh script");
+    console.log("  Run: source ./setup-deno.sh");
+    console.log("  to set up Deno in your current shell\n");
+    
+    return true;
+    
+  } catch (err) {
+    error(`Failed to install Deno: ${(err as Error).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/");
+    return false;
+  }
+}
+
 async function getPersistence(): Promise<JsonPersistenceManager> {
   if (!persistence) {
     persistence = new JsonPersistenceManager();
@@ -61,6 +184,9 @@ export function setupCommands(cli: CLI): void {
       try {
         success("Initializing Claude Code integration files...");
         
+        // Check and install Deno first
+        const denoInstalled = await checkAndInstallDeno();
+        
         const force = ctx.flags.force as boolean || ctx.flags.f as boolean;
         const minimal = ctx.flags.minimal as boolean || ctx.flags.m as boolean;
         

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.0";
+const VERSION = "1.0.11";
 
 async function main() {
   const cli = new CLI("claude-flow", "Advanced AI Agent Orchestration System");