claude-flow-novice 1.3.0 → 1.3.2

package/scripts/legacy/build-monitor.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * Build Monitor - Continuous build verification for alpha release
+ * Agent: Build-Verifier
+ * Mission: Monitor and verify build progress toward zero-error alpha
+ */
+
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class BuildMonitor {
+  constructor() {
+    this.errorCount = 282; // Baseline
+    this.lastCheck = Date.now();
+    this.monitoringActive = true;
+    this.buildHistory = [];
+    this.errorCategories = {
+      'type_compatibility': 87,
+      'missing_properties': 56,
+      'import_export': 45,
+      'null_undefined': 41,
+      'constructor_issues': 23,
+      'other': 30
+    };
+  }
+
+  async runBuild() {
+    return new Promise((resolve, reject) => {
+      console.log('🔨 Running build verification...');
+      exec('npm run build', (error, stdout, stderr) => {
+        const buildOutput = stderr || stdout;
+        const errors = this.parseErrors(buildOutput);
+        
+        const buildResult = {
+          timestamp: new Date().toISOString(),
+          errorCount: errors.length,
+          errors: errors,
+          success: errors.length === 0
+        };
+
+        this.buildHistory.push(buildResult);
+        resolve(buildResult);
+      });
+    });
+  }
+
+  parseErrors(buildOutput) {
+    if (!buildOutput) return [];
+    
+    const errorLines = buildOutput.split('\n').filter(line => 
+      line.includes('error TS') || line.includes('Error:')
+    );
+    
+    return errorLines.map(line => {
+      const match = line.match(/([^:]+):\s*error\s+TS(\d+):\s*(.+)/);
+      if (match) {
+        return {
+          file: match[1],
+          code: match[2],
+          message: match[3]
+        };
+      }
+      return { message: line };
+    });
+  }
+
+  async checkSwarmMemory() {
+    try {
+      // Check for swarm agent updates
+      const result = await new Promise((resolve) => {
+        exec('npx ruv-swarm hook pre-search --query "agent-progress" --cache-results true', 
+          (error, stdout) => {
+            resolve(stdout || '');
+          }
+        );
+      });
+      
+      return result.includes('progress') || result.includes('fixed');
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async monitor() {
+    console.log('🐝 Build-Verifier Agent - Continuous Monitoring Active');
+    console.log(`📊 Baseline: ${this.errorCount} TypeScript errors`);
+    console.log('🎯 Target: 0 errors for alpha release');
+    
+    while (this.monitoringActive) {
+      try {
+        // Check for swarm activity
+        const swarmActivity = await this.checkSwarmMemory();
+        
+        if (swarmActivity) {
+          console.log('🔄 Swarm activity detected - Running build verification...');
+          const buildResult = await this.runBuild();
+          
+          if (buildResult.errorCount < this.errorCount) {
+            const reduction = this.errorCount - buildResult.errorCount;
+            console.log(`✅ Progress! Errors reduced by ${reduction}: ${this.errorCount} → ${buildResult.errorCount}`);
+            
+            // Update baseline
+            this.errorCount = buildResult.errorCount;
+            
+            // Store progress
+            await this.storeProgress(buildResult);
+            
+            // Alert swarm
+            await this.alertSwarm(buildResult);
+          } else if (buildResult.errorCount > this.errorCount) {
+            const increase = buildResult.errorCount - this.errorCount;
+            console.log(`⚠️  WARNING: New errors introduced! +${increase} errors: ${this.errorCount} → ${buildResult.errorCount}`);
+            
+            // Alert swarm of regression
+            await this.alertRegression(buildResult);
+          }
+          
+          if (buildResult.errorCount === 0) {
+            console.log('🎉 ALPHA RELEASE READY: ZERO ERRORS ACHIEVED!');
+            await this.certifyAlphaReady();
+            break;
+          }
+        }
+        
+        // Wait before next check
+        await new Promise(resolve => setTimeout(resolve, 30000)); // 30 second intervals
+        
+      } catch (error) {
+        console.error('❌ Monitor error:', error.message);
+        await new Promise(resolve => setTimeout(resolve, 60000)); // 1 minute on error
+      }
+    }
+  }
+
+  async storeProgress(buildResult) {
+    try {
+      exec(`npx ruv-swarm hook notification --message "BUILD PROGRESS: ${buildResult.errorCount} errors remaining (${this.errorCount - buildResult.errorCount} fixed)" --telemetry true`);
+    } catch (error) {
+      console.error('Failed to store progress:', error.message);
+    }
+  }
+
+  async alertSwarm(buildResult) {
+    const message = `🔨 BUILD UPDATE: ${buildResult.errorCount} errors remaining. Progress: ${this.errorCount - buildResult.errorCount} errors fixed.`;
+    console.log(message);
+    
+    try {
+      exec(`npx ruv-swarm hook notification --message "${message}" --telemetry true`);
+    } catch (error) {
+      console.error('Failed to alert swarm:', error.message);
+    }
+  }
+
+  async alertRegression(buildResult) {
+    const message = `⚠️ REGRESSION ALERT: ${buildResult.errorCount - this.errorCount} new errors introduced. Review recent changes.`;
+    console.log(message);
+    
+    try {
+      exec(`npx ruv-swarm hook notification --message "${message}" --telemetry true`);
+    } catch (error) {
+      console.error('Failed to alert regression:', error.message);
+    }
+  }
+
+  async certifyAlphaReady() {
+    const certification = {
+      timestamp: new Date().toISOString(),
+      status: 'ALPHA_READY',
+      errorCount: 0,
+      buildSuccess: true,
+      verifiedBy: 'Build-Verifier-Agent'
+    };
+    
+    console.log('🏆 ALPHA CERTIFICATION COMPLETE');
+    console.log('✅ Zero TypeScript compilation errors');
+    console.log('✅ Build successful');
+    console.log('✅ Ready for alpha release');
+    
+    try {
+      exec(`npx ruv-swarm hook notification --message "🏆 ALPHA CERTIFICATION: Zero errors achieved! Build ready for alpha release." --telemetry true`);
+      exec(`npx ruv-swarm hook post-task --task-id "alpha-build-verification" --analyze-performance true`);
+    } catch (error) {
+      console.error('Failed to certify alpha:', error.message);
+    }
+  }
+
+  generateReport() {
+    const report = {
+      timestamp: new Date().toISOString(),
+      currentErrorCount: this.errorCount,
+      buildHistory: this.buildHistory,
+      errorCategories: this.errorCategories,
+      status: this.errorCount === 0 ? 'ALPHA_READY' : 'IN_PROGRESS'
+    };
+    
+    fs.writeFileSync('build-verification-status.json', JSON.stringify(report, null, 2));
+    return report;
+  }
+}
+
+// Start monitoring if run directly
+if (require.main === module) {
+  const monitor = new BuildMonitor();
+  monitor.monitor().catch(console.error);
+}
+
+module.exports = BuildMonitor;

package/scripts/legacy/build-with-filter.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# Build script that works around Deno compile deprecation warnings
+
+echo "🔨 Building Claude Flow (filtering deprecation warnings)..."
+
+# Ensure bin directory exists
+mkdir -p bin
+
+# Set Deno path
+export PATH="/home/codespace/.deno/bin:$PATH"
+
+# Remove any existing binary to avoid conflicts
+rm -f bin/claude-flow
+
+# Create a temporary script that will capture the build process
+cat > /tmp/deno-build.sh << 'EOF'
+#!/bin/bash
+# Run deno compile and capture all output
+deno compile --allow-all --no-check --output bin/claude-flow src/cli/main.ts 2>&1
+EOF
+
+chmod +x /tmp/deno-build.sh
+
+# Run the build and capture output
+BUILD_OUTPUT=$(/tmp/deno-build.sh)
+BUILD_EXIT_CODE=$?
+
+# Check if the binary was created despite the error
+if [ -f "bin/claude-flow" ]; then
+    echo "✅ Binary created successfully!"
+    chmod +x bin/claude-flow
+    
+    # Test if it works
+    if bin/claude-flow --version &>/dev/null; then
+        echo "✅ Binary is functional!"
+        echo "📍 Location: bin/claude-flow"
+        exit 0
+    else
+        echo "⚠️  Binary was created but may not be functional"
+    fi
+else
+    # Check for temporary files that might have been created
+    TEMP_FILES=$(find bin -name "claude-flow.tmp*" -type f 2>/dev/null)
+    
+    if [ -n "$TEMP_FILES" ]; then
+        echo "📦 Found temporary build artifacts..."
+        
+        for temp_file in $TEMP_FILES; do
+            echo "  Checking: $temp_file"
+            
+            # Check if it's a valid executable
+            if file "$temp_file" | grep -q "executable"; then
+                echo "  ✅ Valid executable found!"
+                
+                # Move it to the final location
+                mv "$temp_file" bin/claude-flow
+                chmod +x bin/claude-flow
+                
+                if bin/claude-flow --version &>/dev/null; then
+                    echo "✅ Build successful!"
+                    echo "📍 Location: bin/claude-flow"
+                    exit 0
+                fi
+            fi
+        done
+    fi
+fi
+
+# If we get here, build failed
+echo "❌ Build failed"
+echo ""
+echo "Build output:"
+echo "$BUILD_OUTPUT" | grep -v "Import assertions are deprecated"
+
+# Restore backup if available
+if [ -f "bin/claude-flow.working-backup" ]; then
+    echo ""
+    echo "🔄 Restoring working backup..."
+    cp bin/claude-flow.working-backup bin/claude-flow
+    chmod +x bin/claude-flow
+    echo "✅ Backup restored"
+fi
+
+exit 1

package/scripts/legacy/build-workaround.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Workaround build script for Deno deprecation warning
+
+echo "🔨 Building Claude Flow with workaround..."
+
+# Ensure bin directory exists
+mkdir -p bin
+
+# Set Deno path
+export PATH="/home/codespace/.deno/bin:$PATH"
+
+# First, try to build normally to a temp file
+echo "Attempting build..."
+
+# Build command that continues despite warnings
+(deno compile --allow-all --no-check --output=bin/claude-flow.tmp src/cli/main.ts 2>&1 || true) | grep -v "Import assertions are deprecated"
+
+# Check if the temporary binary was created despite the error
+if [ -f "bin/claude-flow.tmp" ]; then
+    echo "✅ Build artifact created!"
+    
+    # The binary might still work, so let's test it
+    if bin/claude-flow.tmp --version &>/dev/null; then
+        echo "✅ Binary is functional!"
+        
+        # Backup existing binary
+        if [ -f "bin/claude-flow" ]; then
+            cp bin/claude-flow bin/claude-flow.backup
+        fi
+        
+        # Replace with new binary
+        mv bin/claude-flow.tmp bin/claude-flow
+        chmod +x bin/claude-flow
+        echo "✅ Build successful!"
+        exit 0
+    else
+        echo "❌ Binary is not functional"
+        rm -f bin/claude-flow.tmp
+    fi
+fi
+
+# If we get here, try bundling as a fallback
+echo "Trying bundle approach..."
+
+# Bundle the TypeScript to JavaScript first
+if deno bundle src/cli/main.ts bin/claude-flow.bundle.js &>/dev/null; then
+    # Create a wrapper script
+    cat > bin/claude-flow.new << 'EOF'
+#!/usr/bin/env -S deno run --allow-all --no-check
+import "./claude-flow.bundle.js";
+EOF
+    
+    chmod +x bin/claude-flow.new
+    
+    # Test the wrapper
+    if bin/claude-flow.new --version &>/dev/null; then
+        echo "✅ Bundle wrapper is functional!"
+        
+        # Backup and replace
+        if [ -f "bin/claude-flow" ]; then
+            cp bin/claude-flow bin/claude-flow.backup
+        fi
+        mv bin/claude-flow.new bin/claude-flow
+        echo "✅ Build successful (bundle mode)!"
+        exit 0
+    fi
+fi
+
+echo "❌ All build attempts failed"
+echo "Keeping existing binary in place"
+exit 1