claude-flow 2.7.34 → 2.7.35

package/scripts/create-github-issue.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+# Create GitHub Issue for Automatic Error Recovery
+# Run this after confirming fix works in Docker/CLI
+
+set -e
+
+echo "📝 Creating GitHub Issue for Automatic Error Recovery"
+echo ""
+
+# Check if gh CLI is installed
+if ! command -v gh &> /dev/null; then
+    echo "❌ GitHub CLI (gh) is not installed"
+    echo "   Install: https://cli.github.com/"
+    exit 1
+fi
+
+# Check if authenticated
+if ! gh auth status &> /dev/null; then
+    echo "❌ Not authenticated with GitHub CLI"
+    echo "   Run: gh auth login"
+    exit 1
+fi
+
+echo "✅ GitHub CLI ready"
+echo ""
+
+# Issue title
+TITLE="✅ Fixed: Automatic recovery for WSL better-sqlite3 ENOTEMPTY error during init"
+
+# Issue body (from template)
+BODY=$(cat docs/github-issues/wsl-enotempty-automatic-recovery.md)
+
+# Labels
+LABELS="enhancement,bug-fix,wsl,user-experience,v2.7.35"
+
+# Milestone
+MILESTONE="v2.7.35"
+
+echo "Creating issue..."
+echo "Title: $TITLE"
+echo "Labels: $LABELS"
+echo "Milestone: $MILESTONE"
+echo ""
+
+# Create the issue
+gh issue create \
+    --title "$TITLE" \
+    --body "$BODY" \
+    --label "$LABELS" \
+    --milestone "$MILESTONE"
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "✅ GitHub issue created successfully!"
+    echo ""
+    echo "Next steps:"
+    echo "1. Add test results to the issue"
+    echo "2. Attach screenshots if available"
+    echo "3. Request review from maintainers"
+else
+    echo ""
+    echo "❌ Failed to create issue"
+    exit 1
+fi

package/scripts/test-docker-wsl.sh

@@ -0,0 +1,198 @@
+#!/bin/bash
+# Test automatic error recovery in Docker (simulates WSL)
+# Run this before creating GitHub issue
+
+set -e
+
+echo "🐳 Testing Automatic Error Recovery in Docker"
+echo ""
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test configurations
+DISTROS=("ubuntu:22.04" "ubuntu:20.04" "debian:11" "debian:12")
+TEST_RESULTS=()
+
+# Function to test on a distro
+test_distro() {
+    local distro=$1
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing on: $distro"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Run test in Docker
+    docker run --rm -i $distro bash -c "
+        set -e
+
+        echo '📦 Installing dependencies...'
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+
+        echo '📥 Installing Node.js...'
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '🔍 Node version:'
+        node --version
+        npm --version
+
+        echo ''
+        echo '🚀 Running claude-flow init --force...'
+        echo ''
+
+        # Run the actual test
+        npx claude-flow@alpha init --force
+
+        echo ''
+        echo '✅ Test completed successfully on $distro'
+    " && {
+        echo -e "${GREEN}✅ PASS: $distro${NC}"
+        TEST_RESULTS+=("PASS: $distro")
+    } || {
+        echo -e "${RED}❌ FAIL: $distro${NC}"
+        TEST_RESULTS+=("FAIL: $distro")
+    }
+}
+
+# Function to test with corrupted cache simulation
+test_corrupted_cache() {
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing with corrupted npm cache simulation"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    docker run --rm -i ubuntu:22.04 bash -c "
+        set -e
+
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '💥 Simulating corrupted npm cache...'
+        mkdir -p ~/.npm/_npx/test-corrupt/node_modules/better-sqlite3
+        touch ~/.npm/_npx/test-corrupt/node_modules/better-sqlite3/.lock
+
+        echo ''
+        echo '🚀 Running claude-flow init --force with corrupted cache...'
+        echo ''
+
+        npx claude-flow@alpha init --force
+
+        echo ''
+        echo '✅ Recovery from corrupted cache successful'
+    " && {
+        echo -e "${GREEN}✅ PASS: Corrupted cache recovery${NC}"
+        TEST_RESULTS+=("PASS: Corrupted cache recovery")
+    } || {
+        echo -e "${RED}❌ FAIL: Corrupted cache recovery${NC}"
+        TEST_RESULTS+=("FAIL: Corrupted cache recovery")
+    }
+}
+
+# Function to test without --force flag
+test_without_force() {
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Testing without --force flag (3 retries max)"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    docker run --rm -i ubuntu:22.04 bash -c "
+        set -e
+
+        apt-get update -qq
+        apt-get install -y -qq curl build-essential python3 git > /dev/null 2>&1
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash - > /dev/null 2>&1
+        apt-get install -y -qq nodejs > /dev/null 2>&1
+
+        echo '🚀 Running claude-flow init (no --force)...'
+        echo ''
+
+        npx claude-flow@alpha init
+
+        echo ''
+        echo '✅ Init without --force successful'
+    " && {
+        echo -e "${GREEN}✅ PASS: Init without --force${NC}"
+        TEST_RESULTS+=("PASS: Init without --force")
+    } || {
+        echo -e "${RED}❌ FAIL: Init without --force${NC}"
+        TEST_RESULTS+=("FAIL: Init without --force")
+    }
+}
+
+# Main test execution
+echo "Starting comprehensive Docker tests..."
+echo ""
+echo "This will test:"
+echo "  - Multiple Linux distributions"
+echo "  - Corrupted cache recovery"
+echo "  - With and without --force flag"
+echo ""
+
+read -p "Continue? (y/n) " -n 1 -r
+echo ""
+
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Aborted"
+    exit 1
+fi
+
+# Run tests
+for distro in "${DISTROS[@]}"; do
+    test_distro "$distro"
+done
+
+test_corrupted_cache
+test_without_force
+
+# Print summary
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "TEST SUMMARY"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+PASS_COUNT=0
+FAIL_COUNT=0
+
+for result in "${TEST_RESULTS[@]}"; do
+    if [[ $result == PASS* ]]; then
+        echo -e "${GREEN}✅ $result${NC}"
+        ((PASS_COUNT++))
+    else
+        echo -e "${RED}❌ $result${NC}"
+        ((FAIL_COUNT++))
+    fi
+done
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Total: $((PASS_COUNT + FAIL_COUNT)) tests"
+echo -e "${GREEN}Passed: $PASS_COUNT${NC}"
+echo -e "${RED}Failed: $FAIL_COUNT${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+if [ $FAIL_COUNT -eq 0 ]; then
+    echo -e "${GREEN}✅ All tests passed!${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "1. Review test results above"
+    echo "2. Run: bash scripts/create-github-issue.sh"
+    echo "3. Update issue with test results"
+    exit 0
+else
+    echo -e "${RED}❌ Some tests failed${NC}"
+    echo ""
+    echo "Please fix failing tests before creating GitHub issue"
+    exit 1
+fi

package/src/cli/init/index.ts

@@ -5,6 +5,7 @@ import { createSwarmCommands } from './swarm-commands.js';
 import { createSparcEnvironment } from './sparc-environment.js';
 import { createClaudeConfig } from './claude-config.js';
 import { createBatchToolsGuide } from './batch-tools.js';
+import { errorRecovery } from '../../utils/error-recovery.js';
 
 export interface InitOptions {
   sparc?: boolean;
@@ -12,56 +13,85 @@ export interface InitOptions {
 }
 
 export async function initCommand(options: InitOptions = {}) {
-  try {
-    const fs = await import('fs/promises');
-    const path = await import('path');
+  // Wrap entire initialization in retry logic with automatic recovery
+  return errorRecovery.retryWithRecovery(
+    async () => {
+      try {
+        const fs = await import('fs/promises');
+        const path = await import('path');
 
-    printSuccess('Initializing Claude-Flow project...');
+        printSuccess('Initializing Claude-Flow project...');
 
-    // Phase 1: Create directory structure
-    console.log('\n📁 Phase 1: Creating directory structure...');
-    await createDirectoryStructure();
+        // Check WSL environment and apply fixes proactively
+        if (errorRecovery.isWSL()) {
+          console.log('🔍 WSL environment detected');
+          const wslCheck = await errorRecovery.recoverWSLErrors();
+          if (wslCheck.recovered) {
+            console.log('✅ WSL environment optimized\n');
+          }
+        }
 
-    // Phase 2: Create base configuration
-    console.log('\n⚙️  Phase 2: Creating configuration...');
-    await createClaudeConfig(options);
+        // Phase 1: Create directory structure
+        console.log('\n📁 Phase 1: Creating directory structure...');
+        await createDirectoryStructure();
 
-    // Phase 3: Create swarm commands and documentation
-    console.log('\n🤖 Phase 3: Creating swarm commands...');
-    await createSwarmCommands();
+        // Phase 2: Create base configuration
+        console.log('\n⚙️  Phase 2: Creating configuration...');
+        await createClaudeConfig(options);
 
-    // Phase 4: Create batch tools guides
-    console.log('\n🔧 Phase 4: Creating batch tools guides...');
-    await createBatchToolsGuide();
+        // Phase 3: Create swarm commands and documentation
+        console.log('\n🤖 Phase 3: Creating swarm commands...');
+        await createSwarmCommands();
 
-    // Phase 5: SPARC environment (if requested)
-    if (options.sparc) {
-      console.log('\n🚀 Phase 5: Creating SPARC environment...');
-      await createSparcEnvironment();
-    }
+        // Phase 4: Create batch tools guides
+        console.log('\n🔧 Phase 4: Creating batch tools guides...');
+        await createBatchToolsGuide();
+
+        // Phase 5: SPARC environment (if requested)
+        if (options.sparc) {
+          console.log('\n🚀 Phase 5: Creating SPARC environment...');
+          await createSparcEnvironment();
+        }
+
+        // Success summary
+        console.log('\n🎉 Project initialized successfully!');
+        console.log('   📁 Created .claude/ directory structure');
+        console.log('   📋 Created comprehensive swarm command documentation');
+        console.log('   🔧 Created batch tools coordination guides');
+        console.log('   📖 Created detailed usage examples with orchestration');
 
-    // Success summary
-    console.log('\n🎉 Project initialized successfully!');
-    console.log('   📁 Created .claude/ directory structure');
-    console.log('   📋 Created comprehensive swarm command documentation');
-    console.log('   🔧 Created batch tools coordination guides');
-    console.log('   📖 Created detailed usage examples with orchestration');
+        console.log('\n   Next steps:');
+        console.log('   1. Run "claude-flow swarm --help" to see swarm options');
+        console.log('   2. Check .claude/commands/swarm/ for detailed documentation');
+        console.log('   3. Review batch tools guide for orchestration patterns');
+        console.log('   4. Run "claude-flow help" for all available commands');
 
-    console.log('\n   Next steps:');
-    console.log('   1. Run "claude-flow swarm --help" to see swarm options');
-    console.log('   2. Check .claude/commands/swarm/ for detailed documentation');
-    console.log('   3. Review batch tools guide for orchestration patterns');
-    console.log('   4. Run "claude-flow help" for all available commands');
+        if (options.sparc) {
+          console.log('   5. Run "claude-flow sparc modes" to see available SPARC modes');
+          console.log('   6. Use TodoWrite/TodoRead for task coordination');
+          console.log('   7. Use Task tool for parallel agent execution');
+        }
+      } catch (error) {
+        // Attempt automatic error recovery
+        const recovery = await errorRecovery.recoverInitErrors(error);
 
-    if (options.sparc) {
-      console.log('   5. Run "claude-flow sparc modes" to see available SPARC modes');
-      console.log('   6. Use TodoWrite/TodoRead for task coordination');
-      console.log('   7. Use Task tool for parallel agent execution');
+        if (recovery.recovered) {
+          console.log('✅ Recovered from error, retrying initialization...\n');
+          throw error; // Trigger retry
+        } else {
+          printError(
+            `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          throw error;
+        }
+      }
+    },
+    {
+      maxRetries: options.force ? 5 : 3,
+      delay: 1000,
+      onRetry: (attempt, error) => {
+        console.log(`\n🔄 Retry attempt ${attempt} after error recovery...`);
+      }
     }
-  } catch (error) {
-    printError(
-      `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
+  );
 }

package/src/core/DatabaseManager.ts

@@ -12,6 +12,8 @@ export class DatabaseManager implements IDatabaseProvider {
   private dbType: 'sqlite' | 'json';
   private dbPath: string;
   private initialized: boolean = false;
+  private retryCount: number = 0;
+  private maxRetries: number = 3;
 
   constructor(dbType: 'sqlite' | 'json' = 'sqlite', dbPath?: string) {
     this.dbType = dbType;
@@ -19,18 +21,36 @@ export class DatabaseManager implements IDatabaseProvider {
 
     // Try SQLite first, fallback to JSON if needed
     if (this.dbType === 'sqlite') {
-      try {
-        this.provider = new SQLiteProvider(this.dbPath);
-      } catch (error) {
-        console.warn('SQLite not available, falling back to JSON storage:', error);
-        this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
-        this.dbType = 'json';
-      }
+      this.provider = this.initializeSQLiteWithRecovery();
     } else {
       this.provider = new JSONProvider(this.dbPath);
     }
   }
 
+  /**
+   * Initialize SQLite with automatic error recovery
+   */
+  private initializeSQLiteWithRecovery(): IDatabaseProvider {
+    try {
+      return new SQLiteProvider(this.dbPath);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+
+      // Check if it's an npm cache error
+      if (errorMsg.includes('ENOTEMPTY') || errorMsg.includes('better-sqlite3')) {
+        console.warn('⚠️  SQLite initialization failed due to npm cache error');
+        console.warn('   Will attempt automatic recovery during initialize()');
+      } else {
+        console.warn('SQLite not available, falling back to JSON storage:', error);
+      }
+
+      // Fallback to JSON for now
+      this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
+      this.dbType = 'json';
+      return this.provider;
+    }
+  }
+
   private getDefaultPath(): string {
     const baseDir = path.join(process.cwd(), '.claude-flow');
     return this.dbType === 'sqlite'
@@ -40,8 +60,34 @@ export class DatabaseManager implements IDatabaseProvider {
 
   async initialize(): Promise<void> {
     await fs.ensureDir(path.dirname(this.dbPath));
-    await this.provider.initialize();
-    this.initialized = true;
+
+    try {
+      await this.provider.initialize();
+      this.initialized = true;
+    } catch (error) {
+      // If JSON provider failed, just propagate the error
+      if (this.dbType === 'json') {
+        throw error;
+      }
+
+      // For SQLite errors, attempt recovery
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (this.retryCount < this.maxRetries) {
+        console.warn(`⚠️  Database initialization failed (attempt ${this.retryCount + 1}/${this.maxRetries})`);
+        console.warn(`   Error: ${errorMsg}`);
+
+        // Attempt to recover by switching to JSON
+        console.log('🔄 Switching to JSON storage as fallback...');
+        this.provider = new JSONProvider(this.dbPath.replace('.sqlite', '.json'));
+        this.dbType = 'json';
+        this.retryCount++;
+
+        // Retry initialization with JSON provider
+        await this.initialize();
+      } else {
+        throw error;
+      }
+    }
   }
 
   async store(key: string, value: any, namespace: string = 'default'): Promise<void> {