claude-flow 2.0.0-alpha.32 → 2.0.0-alpha.34

package/README.md

@@ -143,7 +143,6 @@ npx claude-flow hooks session-end --generate-summary --persist-state
 ```
 
 ---
-
 ## 🐝 **Revolutionary Hive-Mind Intelligence**
 
 ### **Queen-Led AI Coordination**
@@ -827,4 +826,4 @@ npx --y claude-flow@alpha init --force
 
 *v2.0.0 Alpha - The Future of AI Orchestration*
 
-</div>
+</div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "2.0.0-alpha.32",
+  "version": "2.0.0-alpha.34",
   "description": "Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)",
   "main": "cli.mjs",
   "bin": {

package/src/cli/formatter.ts

@@ -256,7 +256,7 @@ export function displayVersion(version: string, buildDate: string): void {
     chalk.white('  • MCP Server'),
     chalk.white('  • Task Coordination'),
     '',
-    chalk.blue('Homepage: ') + chalk.underline('https://github.com/anthropics/claude-code-flow'),
+    chalk.blue('Homepage: ') + chalk.underline('https://github.com/ruvnet/claude-flow'),
   ];
   
   console.log(info.join('\n'));

package/src/cli/simple-commands/hive-mind/db-optimizer.js

@@ -583,16 +583,30 @@ export async function performMaintenance(dbPath, options = {}) {
     
     // Clean up old memory entries
     if (options.cleanMemory) {
-      spinner.text = 'Cleaning old memory entries...';
-      const cutoffDate = new Date();
-      cutoffDate.setDate(cutoffDate.getDate() - (options.memoryRetentionDays || 30));
-      
-      const result = db.prepare(`
-        DELETE FROM collective_memory 
-        WHERE last_accessed < ? AND access_count < 5
-      `).run(cutoffDate.toISOString());
+      // Check if collective_memory table exists
+      const hasMemoryTable = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='collective_memory'
+      `).get();
       
-      console.log(chalk.green(`✓ Removed ${result.changes} old memory entries`));
+      if (hasMemoryTable) {
+        spinner.text = 'Cleaning old memory entries...';
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - (options.memoryRetentionDays || 30));
+        
+        try {
+          const result = db.prepare(`
+            DELETE FROM collective_memory 
+            WHERE accessed_at < ? AND access_count < 5
+          `).run(cutoffDate.toISOString());
+          
+          console.log(chalk.green(`✓ Removed ${result.changes} old memory entries`));
+        } catch (error) {
+          console.warn(chalk.yellow(`⚠ Could not clean memory entries: ${error.message}`));
+        }
+      } else {
+        console.log(chalk.yellow('⚠ collective_memory table not found, skipping memory cleanup'));
+      }
     }
     
     // Archive completed tasks

package/src/cli/simple-commands/hive-mind-wizard.js

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
-const sqlite3 = require('sqlite3').verbose();
+const Database = require('better-sqlite3');
 
 // Interactive Wizard Implementation
 async function runInteractiveWizard() {

package/src/cli/simple-commands/hive-mind.js

@@ -13,6 +13,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { args, cwd, exit, writeTextFile, readTextFile, mkdirAsync } from '../node-compat.js';
 import { isInteractive, isRawModeSupported, warnNonInteractive, checkNonInteractiveAuth } from '../utils/interactive-detector.js';
+import { safeInteractive, nonInteractiveProgress, nonInteractiveSelect } from '../utils/safe-interactive.js';
 
 // Import SQLite for persistence
 import Database from 'better-sqlite3';
@@ -222,50 +223,87 @@ async function initHiveMind(flags) {
 /**
  * Interactive wizard for hive mind operations
  */
-async function hiveMindWizard() {
-  console.log(chalk.yellow('\n🧙 Hive Mind Interactive Wizard\n'));
-  
-  const { action } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'action',
-      message: 'What would you like to do?',
-      choices: [
-        { name: '🐝 Create new swarm', value: 'spawn' },
-        { name: '📊 View swarm status', value: 'status' },
-        { name: '🧠 Manage collective memory', value: 'memory' },
-        { name: '🤝 View consensus decisions', value: 'consensus' },
-        { name: '📈 Performance metrics', value: 'metrics' },
-        { name: '🔧 Configure hive mind', value: 'config' },
-        { name: '❌ Exit', value: 'exit' }
-      ]
+// Wrapped wizard function that handles non-interactive environments
+const hiveMindWizard = safeInteractive(
+  // Interactive version
+  async function(flags = {}) {
+    console.log(chalk.yellow('\n🧙 Hive Mind Interactive Wizard\n'));
+    
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: '🐝 Create new swarm', value: 'spawn' },
+          { name: '📊 View swarm status', value: 'status' },
+          { name: '🧠 Manage collective memory', value: 'memory' },
+          { name: '🤝 View consensus decisions', value: 'consensus' },
+          { name: '📈 Performance metrics', value: 'metrics' },
+          { name: '🔧 Configure hive mind', value: 'config' },
+          { name: '❌ Exit', value: 'exit' }
+        ]
+      }
+    ]);
+    
+    switch (action) {
+      case 'spawn':
+        await spawnSwarmWizard();
+        break;
+      case 'status':
+        await showStatus({});
+        break;
+      case 'memory':
+        await manageMemoryWizard();
+        break;
+      case 'consensus':
+        await showConsensus({});
+        break;
+      case 'metrics':
+        await showMetrics({});
+        break;
+      case 'config':
+        await configureWizard();
+        break;
+      case 'exit':
+        console.log(chalk.gray('Exiting wizard...'));
+        break;
     }
-  ]);
-  
-  switch (action) {
-    case 'spawn':
-      await spawnSwarmWizard();
-      break;
-    case 'status':
-      await showStatus({});
-      break;
-    case 'memory':
-      await manageMemoryWizard();
-      break;
-    case 'consensus':
-      await showConsensus({});
-      break;
-    case 'metrics':
-      await showMetrics({});
-      break;
-    case 'config':
-      await configureWizard();
-      break;
-    case 'exit':
-      console.log(chalk.gray('Exiting wizard...'));
-      break;
+  },
+  // Non-interactive fallback
+  async function(flags = {}) {
+    console.log(chalk.yellow('\n🧙 Hive Mind - Non-Interactive Mode\n'));
+    
+    // Default to creating a swarm with sensible defaults
+    console.log(chalk.cyan('Creating new swarm with default settings...'));
+    console.log(chalk.gray('Use command-line flags to customize:'));
+    console.log(chalk.gray('  --objective "Your task"    Set swarm objective'));
+    console.log(chalk.gray('  --queen-type strategic     Set queen type'));
+    console.log(chalk.gray('  --max-workers 8            Set worker count'));
+    console.log();
+    
+    const objective = flags.objective || 'General task coordination';
+    const config = {
+      name: flags.name || `swarm-${Date.now()}`,
+      queenType: flags.queenType || flags['queen-type'] || 'strategic',
+      maxWorkers: parseInt(flags.maxWorkers || flags['max-workers'] || '8'),
+      consensusAlgorithm: flags.consensus || 'majority',
+      autoScale: flags.autoScale || flags['auto-scale'] || false,
+      encryption: flags.encryption || false
+    };
+    
+    await spawnSwarm([objective], {
+      ...flags,
+      name: config.name,
+      queenType: config.queenType,
+      maxWorkers: config.maxWorkers,
+      consensusAlgorithm: config.consensusAlgorithm,
+      autoScale: config.autoScale,
+      encryption: config.encryption,
+      nonInteractive: true
+    });
   }
-}
+);
 
 /**
  * Spawn swarm wizard
@@ -1179,7 +1217,7 @@ export async function hiveMindCommand(args, flags) {
       break;
       
     case 'wizard':
-      await hiveMindWizard();
+      await hiveMindWizard(flags);
       break;
       
     case 'help':

package/src/cli/simple-commands/init/index.js

@@ -506,7 +506,7 @@ export async function initCommand(subArgs, flags) {
         }
       } else if (!initDryRun && !isClaudeCodeInstalled()) {
         console.log('\n⚠️  Claude Code CLI not detected!');
-        console.log('  📥 Install with: npm install -g @anthropics/claude-code');
+        console.log('  📥 Install with: npm install -g @anthropic-ai/claude-code');
         console.log('  📋 Then add MCP servers manually with:');
         console.log('     claude mcp add claude-flow claude-flow mcp start');
         console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
@@ -1147,7 +1147,7 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
     } else if (!dryRun && !isClaudeCodeInstalled()) {
       console.log('\n⚠️  Claude Code CLI not detected!');
       console.log('\n  📥 To install Claude Code:');
-      console.log('     npm install -g @anthropics/claude-code');
+      console.log('     npm install -g @anthropic-ai/claude-code');
       console.log('\n  📋 After installing, add MCP servers:');
       console.log('     claude mcp add claude-flow claude-flow mcp start');
       console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
@@ -1161,7 +1161,7 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
       console.log('2. Start a swarm: npx claude-flow swarm init');
       console.log('3. Use MCP tools in Claude Code for enhanced coordination');
     } else {
-      console.log('1. Install Claude Code: npm install -g @anthropics/claude-code');
+      console.log('1. Install Claude Code: npm install -g @anthropic-ai/claude-code');
       console.log('2. Add MCP servers (see instructions above)');
       console.log('3. View available commands: ls .claude/commands/');
       console.log('4. Start a swarm: npx claude-flow swarm init');

package/src/cli/simple-commands/init/templates/claude-flow-universal

@@ -11,12 +11,20 @@
   const { resolve } = await import('path');
   const { fileURLToPath } = await import('url');
   
+  // Detect if we're running in ES module context
+  let __dirname;
   try {
-    // Try to use import.meta.url (ES modules)
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = resolve(__filename, '..');
+    // Check if import.meta is available (ES modules)
+    if (typeof import.meta !== 'undefined' && import.meta.url) {
+      const __filename = fileURLToPath(import.meta.url);
+      __dirname = resolve(__filename, '..');
+    } else {
+      // Fallback for CommonJS
+      __dirname = process.cwd();
+    }
   } catch {
     // Fallback for CommonJS
+    __dirname = process.cwd();
   }
 
   // Try multiple strategies to find claude-flow

package/src/cli/ui/fallback-handler.ts

@@ -36,6 +36,8 @@ export async function handleRawModeError(
   console.log();
   console.log(chalk.cyan('Common causes:'));
   console.log(chalk.gray('• VS Code integrated terminal'));
+  console.log(chalk.gray('• WSL (Windows Subsystem for Linux)'));
+  console.log(chalk.gray('• Native Windows terminals'));
   console.log(chalk.gray('• CI/CD environments'));
   console.log(chalk.gray('• Docker containers'));
   console.log(chalk.gray('• SSH sessions without TTY'));

package/src/cli/utils/environment-detector.ts

@@ -14,6 +14,8 @@ export interface ExecutionEnvironment {
   isSSH: boolean;
   isGitBash: boolean;
   isWindowsTerminal: boolean;
+  isWSL: boolean;
+  isWindows: boolean;
   supportsRawMode: boolean;
   supportsColor: boolean;
   terminalType: string;
@@ -40,6 +42,8 @@ export function detectExecutionEnvironment(options: EnvironmentOptions = {}): Ex
     isSSH: false,
     isGitBash: false,
     isWindowsTerminal: false,
+    isWSL: false,
+    isWindows: false,
     supportsRawMode: false,
     supportsColor: true,
     terminalType: 'unknown',
@@ -85,6 +89,16 @@ export function detectExecutionEnvironment(options: EnvironmentOptions = {}): Ex
   // Windows Terminal detection
   env.isWindowsTerminal = Boolean(process.env.WT_SESSION);
   
+  // Windows detection
+  env.isWindows = process.platform === 'win32';
+  
+  // WSL detection
+  env.isWSL = Boolean(
+    process.env.WSL_DISTRO_NAME ||
+    process.env.WSL_INTEROP ||
+    (existsSync('/proc/version') && readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft'))
+  );
+  
   // Raw mode support check
   env.supportsRawMode = checkRawModeSupport();
   
@@ -160,6 +174,21 @@ function generateRecommendations(env: ExecutionEnvironment): void {
     env.warnings.push('Git Bash detected - some interactive features may not work correctly');
   }
   
+  // WSL specific recommendations
+  if (env.isWSL) {
+    env.recommendedFlags.push('--no-interactive');
+    env.warnings.push('WSL detected - raw mode may cause hangs, using non-interactive mode');
+    if (!env.supportsRawMode) {
+      env.warnings.push('WSL subprocess context detected - interactive features disabled');
+    }
+  }
+  
+  // Windows specific recommendations
+  if (env.isWindows && !env.isWSL) {
+    env.recommendedFlags.push('--compatible-ui');
+    env.warnings.push('Native Windows detected - using compatible UI mode');
+  }
+  
   // Raw mode not supported
   if (!env.supportsRawMode && env.isInteractive) {
     env.recommendedFlags.push('--compatible-ui');
@@ -242,6 +271,8 @@ export function getEnvironmentDescription(env?: ExecutionEnvironment): string {
   if (environment.isSSH) parts.push('SSH');
   if (environment.isGitBash) parts.push('Git Bash');
   if (environment.isWindowsTerminal) parts.push('Windows Terminal');
+  if (environment.isWSL) parts.push('WSL');
+  if (environment.isWindows && !environment.isWSL) parts.push('Windows');
   
   if (parts.length === 0) {
     parts.push(environment.terminalType);
@@ -265,6 +296,8 @@ export function shouldUseNonInteractiveMode(options?: { force?: boolean }): bool
   return !env.isInteractive || 
          env.isCI || 
          env.isVSCode || 
+         env.isWSL ||
+         env.isWindows ||
          !env.supportsRawMode;
 }
 

package/src/cli/utils/interactive-detector.js

@@ -63,6 +63,9 @@ export function getEnvironmentType() {
   if (process.env.CI) return 'ci-environment';
   if (process.env.GITHUB_ACTIONS) return 'github-actions';
   if (process.env.DOCKER_CONTAINER) return 'docker';
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) return 'wsl';
+  if (process.platform === 'win32') return 'windows';
+  if (process.env.TERM_PROGRAM === 'vscode') return 'vscode';
   if (!isRawModeSupported()) return 'no-raw-mode';
   return 'interactive';
 }

package/src/cli/utils/safe-interactive.js

@@ -0,0 +1,142 @@
+/**
+ * Safe Interactive Wrapper - Handles interactive commands in non-interactive environments
+ */
+
+import chalk from 'chalk';
+import { isInteractive, isRawModeSupported, getEnvironmentType } from './interactive-detector.js';
+
+/**
+ * Wraps an interactive function with safety checks
+ * @param {Function} interactiveFn - The interactive function to wrap
+ * @param {Function} fallbackFn - The non-interactive fallback function
+ * @param {Object} options - Options for the wrapper
+ * @returns {Function} The wrapped function
+ */
+export function safeInteractive(interactiveFn, fallbackFn, options = {}) {
+  return async function(...args) {
+    const flags = args[args.length - 1] || {};
+    
+    // Check if user explicitly requested non-interactive mode
+    if (flags.nonInteractive || flags['no-interactive']) {
+      if (fallbackFn) {
+        return fallbackFn(...args);
+      } else {
+        console.log(chalk.yellow('⚠️  Non-interactive mode requested but no fallback available'));
+        console.log(chalk.gray('This command requires interactive mode to function properly'));
+        process.exit(1);
+      }
+    }
+    
+    // Auto-detect if we should use non-interactive mode
+    if (!isInteractive() || !isRawModeSupported()) {
+      const envType = getEnvironmentType();
+      
+      if (!options.silent) {
+        console.log(chalk.yellow('\n⚠️  Interactive mode not available'));
+        console.log(chalk.gray(`Detected environment: ${envType}`));
+        
+        // Provide specific message based on environment
+        if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+          console.log(chalk.gray('WSL detected - raw mode may cause process hangs'));
+          console.log(chalk.cyan('💡 Tip: Use --no-interactive flag or run in native Linux'));
+        } else if (process.platform === 'win32') {
+          console.log(chalk.gray('Windows detected - terminal compatibility issues'));
+          console.log(chalk.cyan('💡 Tip: Use Windows Terminal or WSL2 for better experience'));
+        } else if (process.env.TERM_PROGRAM === 'vscode') {
+          console.log(chalk.gray('VS Code terminal detected - limited interactive support'));
+          console.log(chalk.cyan('💡 Tip: Use external terminal for full functionality'));
+        } else if (!isRawModeSupported()) {
+          console.log(chalk.gray('Terminal does not support raw mode'));
+        }
+        
+        console.log();
+      }
+      
+      if (fallbackFn) {
+        return fallbackFn(...args);
+      } else {
+        console.log(chalk.red('❌ This command requires interactive mode'));
+        console.log(chalk.gray('Please run in a compatible terminal environment'));
+        process.exit(1);
+      }
+    }
+    
+    // Try to run the interactive function
+    try {
+      return await interactiveFn(...args);
+    } catch (error) {
+      // Check if it's a raw mode error
+      if (error.message && (
+        error.message.includes('setRawMode') ||
+        error.message.includes('raw mode') ||
+        error.message.includes('stdin') ||
+        error.message.includes('TTY')
+      )) {
+        console.log(chalk.yellow('\n⚠️  Interactive mode failed'));
+        console.log(chalk.gray(error.message));
+        
+        if (fallbackFn) {
+          console.log(chalk.cyan('Falling back to non-interactive mode...'));
+          return fallbackFn(...args);
+        } else {
+          console.log(chalk.red('❌ No non-interactive fallback available'));
+          process.exit(1);
+        }
+      }
+      
+      // Re-throw other errors
+      throw error;
+    }
+  };
+}
+
+/**
+ * Create a non-interactive version of a prompt
+ * @param {string} message - The prompt message
+ * @param {*} defaultValue - The default value to use
+ * @returns {*} The default value
+ */
+export function nonInteractivePrompt(message, defaultValue) {
+  console.log(chalk.gray(`📝 ${message}`));
+  console.log(chalk.cyan(`   Using default: ${defaultValue}`));
+  return defaultValue;
+}
+
+/**
+ * Create a non-interactive version of a selection
+ * @param {string} message - The selection message
+ * @param {Array} choices - The available choices
+ * @param {*} defaultChoice - The default choice
+ * @returns {*} The default choice
+ */
+export function nonInteractiveSelect(message, choices, defaultChoice) {
+  console.log(chalk.gray(`📋 ${message}`));
+  console.log(chalk.gray('   Available choices:'));
+  choices.forEach(choice => {
+    const isDefault = choice === defaultChoice || choice.value === defaultChoice;
+    console.log(chalk.gray(`   ${isDefault ? '▶' : ' '} ${choice.name || choice}`));
+  });
+  console.log(chalk.cyan(`   Using default: ${defaultChoice}`));
+  return defaultChoice;
+}
+
+/**
+ * Show a non-interactive progress indicator
+ * @param {string} message - The progress message
+ * @returns {Object} Progress control object
+ */
+export function nonInteractiveProgress(message) {
+  console.log(chalk.gray(`⏳ ${message}...`));
+  
+  return {
+    update: (newMessage) => {
+      console.log(chalk.gray(`   ${newMessage}`));
+    },
+    succeed: (finalMessage) => {
+      console.log(chalk.green(`✅ ${finalMessage || message}`));
+    },
+    fail: (errorMessage) => {
+      console.log(chalk.red(`❌ ${errorMessage || 'Failed'}`));
+    }
+  };
+}