claude-flow-novice 1.3.0 → 1.3.2

package/scripts/build/unified-builder.sh

@@ -0,0 +1,428 @@
+#!/bin/bash
+# Unified Build Script - Consolidates 7+ build workaround scripts
+# Phase 12: Script Consolidation - Build Operations
+# Usage: ./unified-builder.sh [mode] [options]
+
+set -euo pipefail
+
+# Script metadata
+SCRIPT_VERSION="1.0.0"
+SCRIPT_NAME="unified-builder"
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+# Configuration
+BIN_DIR="${PROJECT_ROOT}/bin"
+TEMP_DIR="${PROJECT_ROOT}/.tmp-build"
+BACKUP_DIR="${PROJECT_ROOT}/.build-backups"
+LOG_FILE="${PROJECT_ROOT}/.build-logs/$(date +%Y%m%d-%H%M%S).log"
+
+# Build modes
+declare -A BUILD_MODES=(
+    ["workaround"]="Build with deprecation warning workarounds"
+    ["filter"]="Build with filtered output (removes warnings)"
+    ["safe"]="Build with automatic backup and rollback"
+    ["force"]="Force build ignoring errors"
+    ["migration"]="Build with migration compatibility"
+    ["clean"]="Clean build artifacts before building"
+    ["monitor"]="Build with continuous monitoring"
+)
+
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Initialize logging
+init_logging() {
+    mkdir -p "$(dirname "$LOG_FILE")"
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - Starting unified build: $*" | tee "$LOG_FILE"
+}
+
+# Print usage information
+print_usage() {
+    echo -e "${CYAN}Unified Builder v${SCRIPT_VERSION}${NC}"
+    echo -e "${BLUE}Consolidates multiple build scripts into mode-based operations${NC}"
+    echo ""
+    echo "Usage: $0 [mode] [options]"
+    echo ""
+    echo -e "${YELLOW}Available Modes:${NC}"
+    for mode in "${!BUILD_MODES[@]}"; do
+        printf "  %-12s %s\n" "$mode" "${BUILD_MODES[$mode]}"
+    done
+    echo ""
+    echo -e "${YELLOW}Options:${NC}"
+    echo "  --dry-run     Show commands without executing"
+    echo "  --verbose     Show detailed output"
+    echo "  --no-backup   Skip backup creation"
+    echo "  --timeout N   Set timeout in seconds (default: 300)"
+    echo "  --help        Show this help"
+    echo ""
+    echo -e "${YELLOW}Examples:${NC}"
+    echo "  $0 workaround              # Build with deprecation workarounds"
+    echo "  $0 safe --verbose          # Safe build with detailed output"
+    echo "  $0 clean filter            # Clean then filter build"
+    echo ""
+}
+
+# Setup build environment
+setup_environment() {
+    echo -e "${BLUE}🔧 Setting up build environment...${NC}"
+
+    # Create necessary directories
+    mkdir -p "$BIN_DIR" "$TEMP_DIR" "$BACKUP_DIR"
+
+    # Set environment variables - check for Deno in multiple locations
+    if [[ -d "/home/codespace/.deno/bin" ]]; then
+        export PATH="/home/codespace/.deno/bin:$PATH"
+    elif [[ -d "$HOME/.deno/bin" ]]; then
+        export PATH="$HOME/.deno/bin:$PATH"
+    fi
+    export NODE_OPTIONS="${NODE_OPTIONS:-}"
+
+    # Clear any existing build artifacts if clean mode
+    if [[ "$1" == "clean" ]]; then
+        echo -e "${YELLOW}🧹 Cleaning build artifacts...${NC}"
+        rm -rf "$BIN_DIR"/* "$TEMP_DIR"/* 2>/dev/null || true
+    fi
+}
+
+# Create backup of working binary
+create_backup() {
+    if [[ "${NO_BACKUP:-false}" == "true" ]]; then
+        return 0
+    fi
+
+    if [[ -f "$BIN_DIR/claude-flow" ]]; then
+        local backup_file="${BACKUP_DIR}/claude-flow-$(date +%Y%m%d-%H%M%S).backup"
+        echo -e "${CYAN}💾 Creating backup: $(basename "$backup_file")${NC}"
+        cp "$BIN_DIR/claude-flow" "$backup_file"
+        ln -sf "$backup_file" "$BACKUP_DIR/claude-flow.latest-backup"
+    fi
+}
+
+# Restore from backup if build fails
+restore_backup() {
+    local latest_backup="${BACKUP_DIR}/claude-flow.latest-backup"
+    if [[ -L "$latest_backup" && -f "$(readlink "$latest_backup")" ]]; then
+        echo -e "${YELLOW}🔄 Restoring from backup...${NC}"
+        cp "$(readlink "$latest_backup")" "$BIN_DIR/claude-flow"
+        chmod +x "$BIN_DIR/claude-flow"
+        echo -e "${GREEN}✅ Backup restored${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ No backup available${NC}"
+        return 1
+    fi
+}
+
+# Test binary functionality
+test_binary() {
+    local binary_path="$1"
+
+    if [[ ! -f "$binary_path" ]]; then
+        return 1
+    fi
+
+    chmod +x "$binary_path"
+
+    # Test basic functionality
+    if timeout 10 "$binary_path" --version &>/dev/null; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Build mode: workaround (handles deprecation warnings)
+build_workaround() {
+    echo -e "${PURPLE}🔨 Building with deprecation workarounds...${NC}"
+
+    # Ensure dist directory exists
+    mkdir -p dist
+
+    # Try SWC with ignored warnings
+    echo -e "${CYAN}Trying SWC with warning suppression...${NC}"
+    local build_output
+    build_output=$(npm run build:swc 2>&1 || true)
+
+    # Filter out deprecation warnings from output
+    echo "$build_output" | grep -v "Import assertions are deprecated" | grep -v "^$" || true
+
+    # Check if build was successful by checking for compiled files
+    if [[ -d "dist" ]] && [[ $(find dist -name "*.js" | wc -l) -gt 0 ]]; then
+        echo -e "${GREEN}✅ Build successful (workaround mode)${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ Build failed in workaround mode${NC}"
+        return 1
+    fi
+}
+
+# Build mode: filter (filters output warnings)
+build_filter() {
+    echo -e "${PURPLE}🔨 Building with filtered output...${NC}"
+
+    local temp_script="${TEMP_DIR}/build-script.sh"
+
+    # Create temporary build script
+    cat > "$temp_script" << 'EOF'
+#!/bin/bash
+deno compile --allow-all --no-check --output bin/claude-flow src/cli/main.ts 2>&1
+EOF
+    chmod +x "$temp_script"
+
+    # Run build and capture output
+    local build_output exit_code
+    build_output=$("$temp_script")
+    exit_code=$?
+
+    # Check if binary was created despite warnings
+    if [[ -f "$BIN_DIR/claude-flow" ]] && test_binary "$BIN_DIR/claude-flow"; then
+        echo -e "${GREEN}✅ Binary created successfully (filter mode)${NC}"
+        return 0
+    else
+        # Show filtered output on failure
+        echo "$build_output" | grep -v "Import assertions are deprecated" | head -20
+        return 1
+    fi
+}
+
+# Build mode: safe (with backup and rollback)
+build_safe() {
+    echo -e "${PURPLE}🔨 Safe build with backup...${NC}"
+
+    create_backup
+
+    # Ensure dist directory exists
+    mkdir -p dist
+
+    # Try SWC build first (most reliable for TypeScript)
+    echo -e "${CYAN}Trying SWC build...${NC}"
+    if npm run build:swc &>>"$LOG_FILE"; then
+        echo -e "${GREEN}✅ Safe build successful with SWC${NC}"
+        return 0
+    else
+        echo -e "${YELLOW}⚠️ SWC build failed, trying alternative builds...${NC}"
+
+        # Try TypeScript compiler
+        echo -e "${CYAN}Trying TypeScript build...${NC}"
+        if npm run build:esm &>>"$LOG_FILE"; then
+            echo -e "${GREEN}✅ Safe build successful with TypeScript${NC}"
+            return 0
+        else
+            echo -e "${YELLOW}⚠️ TypeScript build failed, trying workaround...${NC}"
+            if build_workaround; then
+                return 0
+            else
+                echo -e "${RED}❌ All build attempts failed${NC}"
+                restore_backup
+                return 1
+            fi
+        fi
+    fi
+}
+
+# Build mode: force (ignores errors)
+build_force() {
+    echo -e "${PURPLE}🔨 Force build (ignoring errors)...${NC}"
+
+    # Try multiple build strategies
+    local strategies=("npm run build:swc" "npm run build:legacy" "build_workaround")
+
+    for strategy in "${strategies[@]}"; do
+        echo -e "${CYAN}Trying: $strategy${NC}"
+
+        if [[ "$strategy" == "build_workaround" ]]; then
+            if build_workaround; then
+                echo -e "${GREEN}✅ Force build successful with workaround${NC}"
+                return 0
+            fi
+        else
+            if $strategy &>>"$LOG_FILE"; then
+                echo -e "${GREEN}✅ Force build successful with: $strategy${NC}"
+                return 0
+            fi
+        fi
+    done
+
+    echo -e "${RED}❌ All force build attempts failed${NC}"
+    return 1
+}
+
+# Build mode: migration (compatibility mode)
+build_migration() {
+    echo -e "${PURPLE}🔨 Migration compatibility build...${NC}"
+
+    # Ensure legacy compatibility
+    if [[ ! -f "config/typescript/tsconfig.json" ]]; then
+        echo -e "${YELLOW}⚠️ Missing TypeScript config, using defaults${NC}"
+    fi
+
+    # Run legacy build
+    if npm run build:legacy &>>"$LOG_FILE"; then
+        echo -e "${GREEN}✅ Migration build successful${NC}"
+        return 0
+    else
+        echo -e "${YELLOW}⚠️ Legacy build failed, trying modern build${NC}"
+        return build_safe
+    fi
+}
+
+# Build mode: monitor (with continuous monitoring)
+build_monitor() {
+    echo -e "${PURPLE}🔨 Build with monitoring...${NC}"
+
+    # Start monitoring in background
+    {
+        while true; do
+            sleep 30
+            if [[ -f "$BIN_DIR/claude-flow" ]]; then
+                echo "$(date '+%H:%M:%S') - Binary status: OK" >> "$LOG_FILE"
+            else
+                echo "$(date '+%H:%M:%S') - Binary status: MISSING" >> "$LOG_FILE"
+            fi
+        done
+    } &
+    local monitor_pid=$!
+
+    # Cleanup function
+    cleanup_monitor() {
+        kill $monitor_pid 2>/dev/null || true
+    }
+    trap cleanup_monitor EXIT
+
+    # Run build
+    if build_safe; then
+        echo -e "${GREEN}✅ Monitored build successful${NC}"
+        echo -e "${CYAN}📊 Monitor log: $LOG_FILE${NC}"
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Main execution function
+main() {
+    local modes=()
+    local dry_run=false
+    local verbose=false
+    local timeout=300
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --dry-run)
+                dry_run=true
+                shift
+                ;;
+            --verbose)
+                verbose=true
+                shift
+                ;;
+            --no-backup)
+                export NO_BACKUP=true
+                shift
+                ;;
+            --timeout)
+                timeout="$2"
+                shift 2
+                ;;
+            --help|-h)
+                print_usage
+                exit 0
+                ;;
+            *)
+                if [[ "${BUILD_MODES[$1]:-}" ]]; then
+                    modes+=("$1")
+                else
+                    echo -e "${RED}❌ Unknown mode: $1${NC}"
+                    print_usage
+                    exit 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    # Default mode if none specified
+    if [[ ${#modes[@]} -eq 0 ]]; then
+        modes=("safe")
+    fi
+
+    # Initialize
+    init_logging "${modes[@]}"
+
+    if [[ "$verbose" == "true" ]]; then
+        set -x
+    fi
+
+    # Dry run mode
+    if [[ "$dry_run" == "true" ]]; then
+        echo -e "${CYAN}🔍 Dry run mode - showing planned operations:${NC}"
+        for mode in "${modes[@]}"; do
+            echo -e "${YELLOW}Would execute: build_${mode}${NC}"
+        done
+        exit 0
+    fi
+
+    # Setup environment
+    setup_environment "${modes[0]}"
+
+    # Execute build modes in sequence
+    for mode in "${modes[@]}"; do
+        echo -e "\n${BLUE}🚀 Executing build mode: $mode${NC}"
+
+        # Execute build mode (remove timeout functionality that's causing issues)
+        case $mode in
+            workaround) build_workaround ;;
+            filter) build_filter ;;
+            safe) build_safe ;;
+            force) build_force ;;
+            migration) build_migration ;;
+            clean) setup_environment clean ;;
+            monitor) build_monitor ;;
+            *)
+                echo -e "${RED}❌ Unknown mode: $mode${NC}"
+                exit 1
+                ;;
+        esac
+
+        local exit_code=$?
+        if [[ $exit_code -ne 0 ]]; then
+            echo -e "${RED}❌ Build mode '$mode' failed with exit code $exit_code${NC}"
+            echo -e "${CYAN}📊 Build log: $LOG_FILE${NC}"
+            exit $exit_code
+        fi
+    done
+
+    # Final verification - check for compiled JavaScript modules instead of binary
+    if [[ -d "dist" ]] && [[ $(find dist -name "*.js" | wc -l) -gt 0 ]]; then
+        echo -e "\n${GREEN}🎉 All build operations completed successfully!${NC}"
+        echo -e "${CYAN}📍 Compiled modules: dist/src/cli/main.js${NC}"
+        echo -e "${CYAN}📊 Build log: $LOG_FILE${NC}"
+
+        # Count compiled files
+        local js_files=$(find dist -name "*.js" | wc -l)
+        echo -e "${CYAN}📈 Generated $js_files JavaScript files${NC}"
+
+        # Show main entry point
+        if [[ -f "dist/src/cli/main.js" ]]; then
+            echo -e "${GREEN}✅ Main CLI entry point: dist/src/cli/main.js${NC}"
+        fi
+
+        # Coordination hook
+        if command -v npx >/dev/null; then
+            npx claude-flow@alpha hooks post-edit --file "unified-builder" --memory-key "swarm/phase12/build-success" 2>/dev/null || true
+        fi
+    else
+        echo -e "\n${RED}❌ Build verification failed - no compiled JavaScript files found${NC}"
+        exit 1
+    fi
+}
+
+# Execute main function with all arguments
+main "$@"

package/scripts/build/update-bin-version.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+/**
+ * Updates the VERSION in bin/claude-flow shell script to match package.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Read package.json
+const packagePath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+const version = packageJson.version;
+
+// Read bin/claude-flow
+const binPath = path.join(__dirname, '..', 'bin', 'claude-flow');
+let binContent = fs.readFileSync(binPath, 'utf8');
+
+// Update VERSION line
+binContent = binContent.replace(
+  /^VERSION=".*"$/m,
+  `VERSION="${version}"`
+);
+
+// Write back
+fs.writeFileSync(binPath, binContent);
+
+console.log(`✅ Updated bin/claude-flow VERSION to ${version}`);