claude-flow 1.0.9 → 1.0.11

package/bin/claude-flow

@@ -2,15 +2,76 @@
 
 const { spawn } = require('child_process');
 const path = require('path');
+const fs = require('fs');
 
-// First try to use the Node.js version
-const nodeCliPath = path.join(__dirname, 'claude-flow-node.js');
+// 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;
+}
 
-// Execute the Node.js CLI directly
-try {
-  require(nodeCliPath);
-} catch (error) {
-  // If Node.js version fails, log the error
-  console.error('Failed to execute Node.js CLI:', error.message);
-  process.exit(1);
+// 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.9",
+  "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"
   },
@@ -35,7 +35,7 @@
     "node": ">=16.0.0"
   },
   "files": [
-    "bin/",
+    "bin/claude-flow",
     "src/",
     "scripts/install.js",
     "README.md",

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");

package/bin/claude-flow-node.js

@@ -1,709 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pure Node.js CLI for Claude-Flow
- * This version works without Deno dependency
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { spawn } = require('child_process');
-const os = require('os');
-
-const VERSION = '1.0.0';
-
-// ANSI color codes
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-};
-
-function success(msg) {
-  console.log(`${colors.green}✅ ${msg}${colors.reset}`);
-}
-
-function error(msg) {
-  console.log(`${colors.red}❌ ${msg}${colors.reset}`);
-}
-
-function warning(msg) {
-  console.log(`${colors.yellow}⚠️  ${msg}${colors.reset}`);
-}
-
-function info(msg) {
-  console.log(`${colors.blue}ℹ️  ${msg}${colors.reset}`);
-}
-
-// Check if Deno is available
-function checkDeno() {
-  return new Promise((resolve) => {
-    const deno = spawn('deno', ['--version'], { stdio: 'pipe' });
-    deno.on('close', (code) => {
-      resolve(code === 0);
-    });
-    deno.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-// Install Deno if not available
-async function installDeno() {
-  console.log('Deno not found. Installing Deno...');
-  
-  const platform = os.platform();
-  
-  if (platform === 'win32') {
-    console.log('Please install Deno manually from https://deno.land/');
-    process.exit(1);
-  }
-  
-  return new Promise((resolve, reject) => {
-    const installScript = spawn('curl', ['-fsSL', 'https://deno.land/x/install/install.sh'], { stdio: 'pipe' });
-    const sh = spawn('sh', [], { stdio: ['pipe', 'inherit', 'inherit'] });
-    
-    installScript.stdout.pipe(sh.stdin);
-    
-    sh.on('close', (code) => {
-      if (code === 0) {
-        success('Deno installed successfully!');
-        console.log('Please restart your terminal or run: export PATH="$HOME/.deno/bin:$PATH"');
-        resolve();
-      } else {
-        reject(new Error('Failed to install Deno'));
-      }
-    });
-  });
-}
-
-// Handle commands that require Deno
-async function handleDenoCommand(command, args) {
-  try {
-    const denoAvailable = await checkDeno();
-    
-    if (!denoAvailable) {
-      const readline = require('readline');
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      
-      warning(`The '${command}' command requires Deno to be installed.`);
-      console.log('Would you like to install Deno automatically? (y/n)');
-      
-      const answer = await new Promise((resolve) => {
-        rl.question('', (answer) => {
-          rl.close();
-          resolve(answer.toLowerCase());
-        });
-      });
-      
-      if (answer === 'y' || answer === 'yes') {
-        await installDeno();
-        console.log('\nNow you can run the command again after restarting your terminal or running:');
-        console.log('export PATH="$HOME/.deno/bin:$PATH"');
-        console.log(`\nThen: npx claude-flow ${command} ${args.join(' ')}`);
-      } else {
-        console.log('Please install Deno manually from https://deno.land/ and run:');
-        console.log(`  deno run --allow-all src/cli/index.ts ${command} ${args.join(' ')}`);
-      }
-    } else {
-      console.log(`Running: deno run --allow-all src/cli/index.ts ${command} ${args.join(' ')}`);
-      console.log('Note: Make sure you\'re in the claude-flow project directory');
-    }
-  } catch (error) {
-    error(`Failed to handle Deno command: ${error.message}`);
-  }
-}
-
-function printHelp() {
-  console.log(`
-${colors.blue}🧠 Claude-Flow v${VERSION}${colors.reset} - Advanced AI Agent Orchestration System
-
-USAGE:
-  claude-flow [COMMAND] [OPTIONS]
-
-COMMANDS:
-  ${colors.cyan}init${colors.reset}                  Initialize Claude Code integration files (includes Deno check)
-  ${colors.cyan}start${colors.reset}                 Start the orchestration system
-  ${colors.cyan}agent${colors.reset}                 Manage agents (spawn, list, terminate, info)
-  ${colors.cyan}task${colors.reset}                  Manage tasks (create, list, status, cancel, workflow)
-  ${colors.cyan}memory${colors.reset}                Manage memory (query, export, import, stats, cleanup)
-  ${colors.cyan}config${colors.reset}                Manage configuration (show, get, set, init, validate)
-  ${colors.cyan}status${colors.reset}                Show system status
-  ${colors.cyan}monitor${colors.reset}               Monitor system in real-time
-  ${colors.cyan}mcp${colors.reset}                   MCP server management (status, tools, config, logs)
-  ${colors.cyan}claude${colors.reset}                Spawn Claude instances with specific configurations
-  ${colors.cyan}session${colors.reset}               Manage terminal sessions
-  ${colors.cyan}workflow${colors.reset}              Execute workflow files
-  ${colors.cyan}version${colors.reset}               Show version information
-  ${colors.cyan}help${colors.reset}                  Show this help message
-
-GLOBAL OPTIONS:
-  -c, --config <path>   Path to configuration file
-  -v, --verbose         Enable verbose logging
-  --log-level <level>   Set log level (debug, info, warn, error)
-  --help               Show help for specific command
-
-EXAMPLES:
-  claude-flow init                                    # Initialize project (checks/installs Deno)
-  claude-flow init --skip-deno                        # Initialize without Deno check
-  claude-flow start                                   # Start orchestrator (auto-installs Deno)
-  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
-
-NOTE: Commands requiring Deno will offer automatic installation
-
-Documentation: https://github.com/ruvnet/claude-code-flow
-`);
-}
-
-async function executeInit(args) {
-  const force = args.includes('-f') || args.includes('--force');
-  const minimal = args.includes('-m') || args.includes('--minimal');
-  const skipDeno = args.includes('--skip-deno');
-  
-  success('Initializing Claude Code integration files...');
-  
-  // Check and optionally install Deno first
-  if (!skipDeno) {
-    try {
-      const denoAvailable = await checkDeno();
-      
-      if (!denoAvailable) {
-        const readline = require('readline');
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        
-        warning('Deno is not installed. Claude-Flow requires Deno for full functionality.');
-        console.log('Would you like to install Deno now? (y/n)');
-        
-        const answer = await new Promise((resolve) => {
-          rl.question('', (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase());
-          });
-        });
-        
-        if (answer === 'y' || answer === 'yes') {
-          await installDeno();
-          console.log('');
-        } else {
-          info('You can install Deno later from https://deno.land/');
-          console.log('');
-        }
-      } else {
-        success('Deno is already installed ✓');
-      }
-    } catch (error) {
-      warning(`Could not check Deno installation: ${error.message}`);
-    }
-  }
-  
-  try {
-    // Check if files already exist
-    const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
-    const existingFiles = [];
-    
-    for (const file of files) {
-      try {
-        await fs.access(file);
-        existingFiles.push(file);
-      } catch {
-        // File doesn't exist, which is fine
-      }
-    }
-    
-    if (existingFiles.length > 0 && !force) {
-      warning(`The following files already exist: ${existingFiles.join(', ')}`);
-      console.log('Use --force to overwrite existing files');
-      return;
-    }
-    
-    // Create CLAUDE.md
-    const claudeMd = minimal ? createMinimalClaudeMd() : createFullClaudeMd();
-    await fs.writeFile('CLAUDE.md', claudeMd);
-    console.log('  ✓ Created CLAUDE.md');
-    
-    // Create memory-bank.md
-    const memoryBankMd = minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
-    await fs.writeFile('memory-bank.md', memoryBankMd);
-    console.log('  ✓ Created memory-bank.md');
-    
-    // Create coordination.md
-    const coordinationMd = minimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
-    await fs.writeFile('coordination.md', coordinationMd);
-    console.log('  ✓ Created coordination.md');
-    
-    // Create directory structure
-    const directories = [
-      'memory',
-      'memory/agents',
-      'memory/sessions',
-      'coordination',
-      'coordination/memory_bank',
-      'coordination/subtasks',
-      'coordination/orchestration'
-    ];
-    
-    for (const dir of directories) {
-      try {
-        await fs.mkdir(dir, { recursive: true });
-        console.log(`  ✓ Created ${dir}/ directory`);
-      } catch (err) {
-        if (err.code !== 'EEXIST') {
-          throw err;
-        }
-      }
-    }
-    
-    // Create placeholder files
-    const agentsReadme = createAgentsReadme();
-    await fs.writeFile('memory/agents/README.md', agentsReadme);
-    console.log('  ✓ Created memory/agents/README.md');
-    
-    const sessionsReadme = createSessionsReadme();
-    await fs.writeFile('memory/sessions/README.md', sessionsReadme);
-    console.log('  ✓ Created memory/sessions/README.md');
-    
-    // Initialize persistence database
-    const initialData = {
-      agents: [],
-      tasks: [],
-      lastUpdated: Date.now()
-    };
-    await fs.writeFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
-    console.log('  ✓ Created memory/claude-flow-data.json (persistence database)');
-    
-    success('Claude Code integration files initialized successfully!');
-    console.log('\nNext steps:');
-    console.log('1. Review and customize the generated files for your project');
-    console.log('2. Run \'npx claude-flow start\' to begin the orchestration system');
-    console.log('3. Use \'claude --dangerously-skip-permissions\' for unattended operation');
-    
-  } catch (err) {
-    error(`Failed to initialize files: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-async function executeStatus() {
-  try {
-    // Check if persistence file exists
-    let data;
-    try {
-      const content = await fs.readFile('memory/claude-flow-data.json', 'utf8');
-      data = JSON.parse(content);
-    } catch {
-      data = { agents: [], tasks: [] };
-    }
-    
-    // Check if orchestrator is running (simplified check)
-    let isRunning = false;
-    try {
-      await fs.access('orchestrator.log');
-      isRunning = true;
-    } catch {
-      // Log file doesn't exist, orchestrator not running
-    }
-    
-    const activeAgents = data.agents.filter(a => a.status === 'active').length;
-    const totalAgents = data.agents.length;
-    const pendingTasks = data.tasks.filter(t => t.status === 'pending' || t.status === 'assigned').length;
-    const totalTasks = data.tasks.length;
-    const completedTasks = data.tasks.filter(t => t.status === 'completed').length;
-    
-    success('Claude-Flow System Status:');
-    console.log(`🟢 Status: ${isRunning ? 'Running' : 'Stopped'}`);
-    console.log(`🤖 Agents: ${activeAgents} active (${totalAgents} total)`);
-    console.log(`📋 Tasks: ${pendingTasks} in queue (${totalTasks} total)`);
-    console.log(`✅ Completed: ${completedTasks} tasks`);
-    console.log(`💾 Memory: Ready`);
-    console.log(`🖥️  Terminal Pool: Ready`);
-    console.log(`🌐 MCP Server: ${isRunning ? 'Running' : 'Stopped'}`);
-    
-  } catch (err) {
-    error(`Failed to get status: ${err.message}`);
-  }
-}
-
-// Template functions
-function createMinimalClaudeMd() {
-  return `# Claude Code Configuration
-
-## Build Commands
-- \`npm run build\`: Build the project
-- \`npm run test\`: Run tests
-- \`npm run lint\`: Run linter
-
-## Code Style
-- Use TypeScript/ES modules
-- Follow project conventions
-- Run typecheck before committing
-
-## Project Info
-This is a Claude-Flow AI agent orchestration system.
-`;
-}
-
-function createFullClaudeMd() {
-  return `# Claude Code Configuration
-
-## Build Commands
-- \`npm run build\`: Build the project using Deno compile
-- \`npm run test\`: Run the full test suite
-- \`npm run lint\`: Run ESLint and format checks
-- \`npm run typecheck\`: Run TypeScript type checking
-- \`npx claude-flow start\`: Start the orchestration system
-- \`npx claude-flow --help\`: Show all available commands
-
-## Code Style Preferences
-- Use ES modules (import/export) syntax, not CommonJS (require)
-- Destructure imports when possible (e.g., \`import { foo } from 'bar'\`)
-- Use TypeScript for all new code
-- Follow existing naming conventions (camelCase for variables, PascalCase for classes)
-- Add JSDoc comments for public APIs
-- Use async/await instead of Promise chains
-- Prefer const/let over var
-
-## Workflow Guidelines
-- Always run typecheck after making code changes
-- Run tests before committing changes
-- Use meaningful commit messages following conventional commits
-- Create feature branches for new functionality
-- Ensure all tests pass before merging
-
-## Project Architecture
-This is a Claude-Flow AI agent orchestration system with the following components:
-- **CLI Interface**: Command-line tools for managing the system
-- **Orchestrator**: Core engine for coordinating agents and tasks
-- **Memory System**: Persistent storage and retrieval of information
-- **Terminal Management**: Automated terminal session handling
-- **MCP Integration**: Model Context Protocol server for Claude integration
-- **Agent Coordination**: Multi-agent task distribution and management
-
-## Important Notes
-- Use \`claude --dangerously-skip-permissions\` for unattended operation
-- The system supports both daemon and interactive modes
-- Memory persistence is handled automatically
-- All components are event-driven for scalability
-
-## Debugging
-- Check logs in \`./claude-flow.log\`
-- Use \`npx claude-flow status\` to check system health
-- Monitor with \`npx claude-flow monitor\` for real-time updates
-- Verbose output available with \`--verbose\` flag on most commands
-`;
-}
-
-function createMinimalMemoryBankMd() {
-  return `# Memory Bank
-
-## Quick Reference
-- Project uses JSON for memory persistence
-- Memory is organized by namespaces
-- Query with \`npx claude-flow memory query <search>\`
-
-## Storage Location
-- Database: \`./memory/claude-flow-data.json\`
-- Sessions: \`./memory/sessions/\`
-`;
-}
-
-function createFullMemoryBankMd() {
-  return `# Memory Bank Configuration
-
-## Overview
-The Claude-Flow memory system provides persistent storage and intelligent retrieval of information across agent sessions. It uses a hybrid approach combining JSON databases with semantic search capabilities.
-
-## Storage Backends
-- **Primary**: JSON database (\`./memory/claude-flow-data.json\`)
-- **Sessions**: File-based storage in \`./memory/sessions/\`
-- **Cache**: In-memory cache for frequently accessed data
-
-## Memory Organization
-- **Namespaces**: Logical groupings of related information
-- **Sessions**: Time-bound conversation contexts
-- **Indexing**: Automatic content indexing for fast retrieval
-- **Replication**: Optional distributed storage support
-
-## Commands
-- \`npx claude-flow memory query <search>\`: Search stored information
-- \`npx claude-flow memory stats\`: Show memory usage statistics
-- \`npx claude-flow memory export <file>\`: Export memory to file
-- \`npx claude-flow memory import <file>\`: Import memory from file
-
-## Configuration
-Memory settings are configured in \`claude-flow.config.json\`:
-\`\`\`json
-{
-  "memory": {
-    "backend": "json",
-    "path": "./memory/claude-flow-data.json",
-    "cacheSize": 1000,
-    "indexing": true,
-    "namespaces": ["default", "agents", "tasks", "sessions"],
-    "retentionPolicy": {
-      "sessions": "30d",
-      "tasks": "90d",
-      "agents": "permanent"
-    }
-  }
-}
-\`\`\`
-
-## Best Practices
-- Use descriptive namespaces for different data types
-- Regular memory exports for backup purposes
-- Monitor memory usage with stats command
-- Clean up old sessions periodically
-
-## Memory Types
-- **Episodic**: Conversation and interaction history
-- **Semantic**: Factual knowledge and relationships
-- **Procedural**: Task patterns and workflows
-- **Meta**: System configuration and preferences
-
-## Integration Notes
-- Memory is automatically synchronized across agents
-- Search supports both exact match and semantic similarity
-- Memory contents are private to your local instance
-- No data is sent to external services without explicit commands
-`;
-}
-
-function createMinimalCoordinationMd() {
-  return `# Agent Coordination
-
-## Quick Commands
-- \`npx claude-flow agent spawn <type>\`: Create new agent
-- \`npx claude-flow agent list\`: Show active agents
-- \`npx claude-flow task create <type> <description>\`: Create task
-
-## Agent Types
-- researcher, coder, analyst, coordinator, general
-`;
-}
-
-function createFullCoordinationMd() {
-  return `# Agent Coordination System
-
-## Overview
-The Claude-Flow coordination system manages multiple AI agents working together on complex tasks. It provides intelligent task distribution, resource management, and inter-agent communication.
-
-## Agent Types and Capabilities
-- **Researcher**: Web search, information gathering, knowledge synthesis
-- **Coder**: Code analysis, development, debugging, testing
-- **Analyst**: Data processing, pattern recognition, insights generation
-- **Coordinator**: Task planning, resource allocation, workflow management
-- **General**: Multi-purpose agent with balanced capabilities
-
-## Task Management
-- **Priority Levels**: 1 (lowest) to 10 (highest)
-- **Dependencies**: Tasks can depend on completion of other tasks
-- **Parallel Execution**: Independent tasks run concurrently
-- **Load Balancing**: Automatic distribution based on agent capacity
-
-## Coordination Commands
-\`\`\`bash
-# Agent Management
-npx claude-flow agent spawn <type> --name <name> --priority <1-10>
-npx claude-flow agent list
-npx claude-flow agent info <agent-id>
-npx claude-flow agent terminate <agent-id>
-
-# Task Management  
-npx claude-flow task create <type> <description> --priority <1-10> --deps <task-ids>
-npx claude-flow task list --verbose
-npx claude-flow task status <task-id>
-npx claude-flow task cancel <task-id>
-
-# System Monitoring
-npx claude-flow status --verbose
-npx claude-flow monitor --interval 5000
-\`\`\`
-
-## Workflow Execution
-Workflows are defined in JSON format and can orchestrate complex multi-agent operations:
-\`\`\`bash
-npx claude-flow workflow examples/research-workflow.json
-npx claude-flow workflow examples/development-config.json --async
-\`\`\`
-
-## Advanced Features
-- **Circuit Breakers**: Automatic failure handling and recovery
-- **Work Stealing**: Dynamic load redistribution for efficiency
-- **Resource Limits**: Memory and CPU usage constraints
-- **Metrics Collection**: Performance monitoring and optimization
-
-## Configuration
-Coordination settings in \`claude-flow.config.json\`:
-\`\`\`json
-{
-  "orchestrator": {
-    "maxConcurrentTasks": 10,
-    "taskTimeout": 300000,
-    "defaultPriority": 5
-  },
-  "agents": {
-    "maxAgents": 20,
-    "defaultCapabilities": ["research", "code", "terminal"],
-    "resourceLimits": {
-      "memory": "1GB",
-      "cpu": "50%"
-    }
-  }
-}
-\`\`\`
-
-## Communication Patterns
-- **Direct Messaging**: Agent-to-agent communication
-- **Event Broadcasting**: System-wide notifications
-- **Shared Memory**: Common information access
-- **Task Handoff**: Seamless work transfer between agents
-
-## Best Practices
-- Start with general agents and specialize as needed
-- Use descriptive task names and clear requirements
-- Monitor system resources during heavy workloads
-- Implement proper error handling in workflows
-- Regular cleanup of completed tasks and inactive agents
-
-## Troubleshooting
-- Check agent health with \`npx claude-flow status\`
-- View detailed logs with \`npx claude-flow monitor\`
-- Restart stuck agents with terminate/spawn cycle
-- Use \`--verbose\` flags for detailed diagnostic information
-`;
-}
-
-function createAgentsReadme() {
-  return `# Agent Memory Storage
-
-## Purpose
-This directory stores agent-specific memory data, configurations, and persistent state information for individual Claude agents in the orchestration system.
-
-## Structure
-Each agent gets its own subdirectory for isolated memory storage:
-
-\`\`\`
-memory/agents/
-├── agent_001/
-│   ├── state.json           # Agent state and configuration
-│   ├── knowledge.md         # Agent-specific knowledge base
-│   ├── tasks.json          # Completed and active tasks
-│   └── calibration.json    # Agent-specific calibrations
-├── agent_002/
-│   └── ...
-└── shared/
-    ├── common_knowledge.md  # Shared knowledge across agents
-    └── global_config.json  # Global agent configurations
-\`\`\`
-
-## Usage Guidelines
-1. **Agent Isolation**: Each agent should only read/write to its own directory
-2. **Shared Resources**: Use the \`shared/\` directory for cross-agent information
-3. **State Persistence**: Update state.json whenever agent status changes
-4. **Knowledge Sharing**: Document discoveries in knowledge.md files
-5. **Cleanup**: Remove directories for terminated agents periodically
-
-## Last Updated
-${new Date().toISOString()}
-`;
-}
-
-function createSessionsReadme() {
-  return `# Session Memory Storage
-
-## Purpose
-This directory stores session-based memory data, conversation history, and contextual information for development sessions using the Claude-Flow orchestration system.
-
-## Structure
-Sessions are organized by date and session ID for easy retrieval:
-
-\`\`\`
-memory/sessions/
-├── 2024-01-10/
-│   ├── session_001/
-│   │   ├── metadata.json        # Session metadata and configuration
-│   │   ├── conversation.md      # Full conversation history
-│   │   ├── decisions.md         # Key decisions and rationale
-│   │   ├── artifacts/           # Generated files and outputs
-│   │   └── coordination_state/  # Coordination system snapshots
-│   └── ...
-└── shared/
-    ├── patterns.md              # Common session patterns
-    └── templates/               # Session template files
-\`\`\`
-
-## Usage Guidelines
-1. **Session Isolation**: Each session gets its own directory
-2. **Metadata Completeness**: Always fill out session metadata
-3. **Conversation Logging**: Document all significant interactions
-4. **Artifact Organization**: Structure generated files clearly
-5. **State Preservation**: Snapshot coordination state regularly
-
-## Last Updated
-${new Date().toISOString()}
-`;
-}
-
-// Main CLI handler
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-  
-  if (!command || command === 'help' || command === '--help') {
-    printHelp();
-    return;
-  }
-  
-  if (command === 'version' || command === '--version') {
-    console.log(`Claude-Flow v${VERSION}`);
-    return;
-  }
-  
-  switch (command) {
-    case 'init':
-      await executeInit(args.slice(1));
-      break;
-      
-    case 'status':
-      await executeStatus();
-      break;
-      
-    case 'start':
-      await handleDenoCommand('start', args.slice(1));
-      break;
-      
-    case 'agent':
-    case 'task':
-    case 'memory':
-    case 'config':
-    case 'monitor':
-    case 'mcp':
-    case 'claude':
-    case 'session':
-    case 'workflow':
-      await handleDenoCommand(command, args.slice(1));
-      break;
-      
-    default:
-      error(`Unknown command: ${command}`);
-      console.log('Run \'claude-flow help\' for usage information.');
-      process.exit(1);
-  }
-}
-
-// Run the CLI
-main().catch(err => {
-  error(`Fatal error: ${err.message}`);
-  process.exit(1);
-});

package/src/cli/commands/swarm.ts

@@ -1,227 +0,0 @@
-/**
- * Claude Swarm Mode - Self-orchestrating agent swarms
- */
-
-import { Command } from '@cliffy/command';
-import { colors } from '@cliffy/ansi/colors';
-import { generateId } from '../../utils/helpers.ts';
-
-export const swarmCommand = new Command()
-  .description('Create self-orchestrating Claude agent swarms')
-  .arguments('<objective:string>')
-  .option('-s, --strategy <strategy:string>', 'Orchestration strategy (auto, research, development, analysis)', {
-    default: 'auto'
-  })
-  .option('--max-agents <count:number>', 'Maximum number of agents to spawn', { default: 5 })
-  .option('--max-depth <depth:number>', 'Maximum delegation depth', { default: 3 })
-  .option('--research', 'Enable research capabilities for all agents')
-  .option('--parallel', 'Enable parallel execution')
-  .option('--memory-namespace <ns:string>', 'Shared memory namespace', { default: 'swarm' })
-  .option('--timeout <minutes:number>', 'Swarm timeout in minutes', { default: 60 })
-  .option('--review', 'Enable peer review between agents')
-  .option('--coordinator', 'Spawn dedicated coordinator agent')
-  .option('-c, --config <file:string>', 'MCP config file')
-  .option('-v, --verbose', 'Enable verbose output')
-  .option('-d, --dry-run', 'Preview swarm configuration')
-  .action(async (objective: string, options: any) => {
-    const swarmId = generateId('swarm');
-    
-    if (options.dryRun) {
-      console.log(colors.yellow('DRY RUN - Swarm Configuration:'));
-      console.log(`Swarm ID: ${swarmId}`);
-      console.log(`Objective: ${objective}`);
-      console.log(`Strategy: ${options.strategy}`);
-      console.log(`Max Agents: ${options.maxAgents}`);
-      console.log(`Max Depth: ${options.maxDepth}`);
-      console.log(`Research: ${options.research}`);
-      console.log(`Parallel: ${options.parallel}`);
-      console.log(`Review Mode: ${options.review}`);
-      console.log(`Coordinator: ${options.coordinator}`);
-      return;
-    }
-    
-    console.log(colors.green(`🐝 Initializing Claude Swarm: ${swarmId}`));
-    console.log(colors.cyan(`📋 Objective: ${objective}`));
-    
-    // Build the orchestration prompt
-    const orchestrationPrompt = buildOrchestrationPrompt(objective, options);
-    
-    // Spawn the master orchestrator
-    console.log(colors.blue('🎯 Spawning Master Orchestrator...'));
-    
-    const orchestratorTask = {
-      id: `${swarmId}-orchestrator`,
-      description: orchestrationPrompt,
-      tools: buildOrchestratorTools(options),
-      config: options.config,
-      environment: {
-        CLAUDE_SWARM_ID: swarmId,
-        CLAUDE_SWARM_MODE: 'orchestrator',
-        CLAUDE_SWARM_OBJECTIVE: objective,
-        CLAUDE_SWARM_STRATEGY: options.strategy,
-        CLAUDE_SWARM_MAX_AGENTS: options.maxAgents.toString(),
-        CLAUDE_SWARM_MAX_DEPTH: options.maxDepth.toString(),
-        CLAUDE_SWARM_MEMORY_NS: options.memoryNamespace,
-      }
-    };
-    
-    if (options.verbose) {
-      console.log(colors.gray('Orchestrator configuration:'));
-      console.log(JSON.stringify(orchestratorTask, null, 2));
-    }
-    
-    // Spawn the master orchestrator using Deno.Command
-    try {
-      // Build Claude command arguments
-      const claudeArgs = [orchestrationPrompt];
-      claudeArgs.push('--allowedTools', orchestratorTask.tools);
-      
-      if (orchestratorTask.config) {
-        claudeArgs.push('--mcp-config', orchestratorTask.config);
-      }
-      
-      if (options.verbose) {
-        claudeArgs.push('--verbose');
-      }
-      
-      // Show progress
-      console.log(colors.gray('Launching orchestrator with Claude...'));
-      
-      // Create the command
-      const command = new Deno.Command('claude', {
-        args: claudeArgs,
-        stdin: 'piped',
-        stdout: 'inherit',
-        stderr: 'inherit',
-        env: {
-          ...Deno.env.toObject(),
-          ...orchestratorTask.environment,
-        },
-      });
-      
-      // Spawn the process
-      const process = command.spawn();
-      
-      console.log(colors.green('✅ Master Orchestrator spawned successfully'));
-      console.log(colors.blue('🚀 Swarm is now active and self-orchestrating...'));
-      
-      // Wait for the orchestrator to complete
-      const status = await process.status;
-      
-      if (status.success) {
-        console.log(colors.green(`\n✅ Swarm ${swarmId} completed successfully`));
-      } else {
-        console.log(colors.red(`\n❌ Swarm ${swarmId} exited with code ${status.code}`));
-      }
-      
-    } catch (error) {
-      console.error(colors.red('❌ Failed to spawn orchestrator:'), (error as Error).message);
-      console.error(colors.yellow('Make sure Claude CLI is installed and available in your PATH'));
-    }
-  });
-
-function buildOrchestrationPrompt(objective: string, options: any): string {
-  const strategies = {
-    auto: 'Automatically determine the best approach',
-    research: 'Focus on research and information gathering',
-    development: 'Focus on implementation and coding',
-    analysis: 'Focus on analysis and insights'
-  };
-  
-  return `
-# Claude Swarm Orchestration Task
-
-You are the Master Orchestrator for a Claude agent swarm. Your objective is to coordinate multiple specialized agents to achieve the following goal:
-
-**OBJECTIVE**: ${objective}
-
-## Orchestration Parameters:
-- Strategy: ${strategies[options.strategy as keyof typeof strategies] || strategies.auto}
-- Maximum Agents: ${options.maxAgents}
-- Maximum Delegation Depth: ${options.maxDepth}
-- Parallel Execution: ${options.parallel ? 'Enabled' : 'Disabled'}
-- Peer Review: ${options.review ? 'Enabled' : 'Disabled'}
-- Research Capabilities: ${options.research ? 'Enabled' : 'Disabled'}
-
-## Your Responsibilities:
-
-1. **Task Decomposition**: Break down the objective into subtasks
-2. **Agent Spawning**: Create specialized agents for each subtask
-3. **Resource Allocation**: Assign appropriate tools and permissions
-4. **Coordination**: Manage dependencies and communication
-5. **Quality Control**: ${options.review ? 'Implement peer review processes' : 'Monitor task quality'}
-6. **Progress Tracking**: Monitor and report on swarm progress
-
-## Available Agent Types:
-- **Researcher**: Information gathering, web research, analysis
-- **Developer**: Code implementation, testing, debugging
-- **Analyst**: Data analysis, pattern recognition, insights
-- **Reviewer**: Code review, quality assurance, validation
-- **Coordinator**: Sub-task coordination, dependency management
-
-## Swarm Execution Process:
-
-1. Analyze the objective and create a detailed execution plan
-2. Identify required agent types and their responsibilities
-3. Spawn agents with appropriate configurations using:
-   \`\`\`
-   claude-flow agent spawn <type> --name "<name>" --task "<specific task>"
-   \`\`\`
-4. Create tasks and assign them to agents:
-   \`\`\`
-   claude-flow task create <type> "<description>" --assign-to <agent-id>
-   \`\`\`
-5. Monitor progress and adjust as needed
-6. ${options.review ? 'Implement peer review cycles between agents' : 'Validate outputs'}
-7. Synthesize results and report completion
-
-## Memory Coordination:
-All agents share the memory namespace: "${options.memoryNamespace}"
-Use this for:
-- Sharing discoveries and insights
-- Avoiding duplicate work
-- Building on each other's findings
-- Maintaining context across the swarm
-
-## Special Instructions:
-${options.coordinator ? '- Spawn a dedicated coordinator agent for complex subtasks' : ''}
-${options.research ? '- All agents should have research capabilities enabled' : ''}
-${options.parallel ? '- Maximize parallel execution where dependencies allow' : ''}
-${options.maxDepth > 1 ? `- Agents can delegate to sub-agents up to depth ${options.maxDepth}` : ''}
-
-## Output Format:
-Provide regular status updates in this format:
-\`\`\`
-[SWARM STATUS]
-- Active Agents: X/Y
-- Tasks Completed: X/Y
-- Current Phase: <phase>
-- Next Actions: <list>
-\`\`\`
-
-Begin by analyzing the objective and presenting your execution plan.
-`;
-}
-
-function buildOrchestratorTools(options: any): string {
-  const tools = [
-    'View',
-    'Edit',
-    'Replace',
-    'GlobTool',
-    'GrepTool',
-    'LS',
-    'Bash',
-    'dispatch_agent'
-  ];
-  
-  if (options.research) {
-    tools.push('WebFetchTool');
-  }
-  
-  if (options.parallel) {
-    tools.push('BatchTool');
-  }
-  
-  return tools.join(',');
-}