claude-flow-novice 2.2.3 → 2.2.5

package/dist/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 ".claude-flow-novice/dist" ]] && [[ $(find .claude-flow-novice/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 ".claude-flow-novice/dist" ]] && [[ $(find .claude-flow-novice/dist -name "*.js" | wc -l) -gt 0 ]]; then
+        echo -e "\n${GREEN}🎉 All build operations completed successfully!${NC}"
+        echo -e "${CYAN}📍 Compiled modules: .claude-flow-novice/dist/src/cli/main.js${NC}"
+        echo -e "${CYAN}📊 Build log: $LOG_FILE${NC}"
+
+        # Count compiled files
+        local js_files=$(find .claude-flow-novice/dist -name "*.js" | wc -l)
+        echo -e "${CYAN}📈 Generated $js_files JavaScript files${NC}"
+
+        # Show main entry point
+        if [[ -f ".claude-flow-novice/dist/src/cli/main.js" ]]; then
+            echo -e "${GREEN}✅ Main CLI entry point: .claude-flow-novice/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/dist/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}`);

package/dist/scripts/build/validate-agents.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Validation Script
+ * Validates Claude Code agent definitions before package distribution
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'yaml';
+import { glob } from 'glob';
+
+const VALID_TOOLS = [
+  'Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep',
+  'WebSearch', 'WebFetch', 'TodoWrite', 'Task', 'SlashCommand',
+  // MCP coordination tools
+  'mcp__claude-flow-novice__swarm_init', 'mcp__claude-flow-novice__agent_spawn',
+  'mcp__claude-flow-novice__task_orchestrate', 'mcp__claude-flow-novice__memory_usage'
+];
+
+const VALID_MODELS = ['sonnet', 'haiku', 'opus', 'inherit'];
+
+class AgentValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.agentCount = 0;
+  }
+
+  log(message, type = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = type === 'error' ? '❌' : type === 'warning' ? '⚠️' : 'ℹ️';
+    console.log(`${prefix} [${timestamp}] ${message}`);
+  }
+
+  addError(file, message) {
+    this.errors.push({ file, message });
+    this.log(`Error in ${file}: ${message}`, 'error');
+  }
+
+  addWarning(file, message) {
+    this.warnings.push({ file, message });
+    this.log(`Warning in ${file}: ${message}`, 'warning');
+  }
+
+  validateAgentFile(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+
+      // Check if file has YAML frontmatter
+      if (!content.startsWith('---')) {
+        this.addError(relativePath, 'Missing YAML frontmatter (should start with ---)');
+        return false;
+      }
+
+      // Extract frontmatter
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!frontmatterMatch) {
+        this.addError(relativePath, 'Invalid YAML frontmatter format');
+        return false;
+      }
+
+      let frontmatter;
+      try {
+        frontmatter = yaml.parse(frontmatterMatch[1]);
+      } catch (error) {
+        this.addError(relativePath, `Invalid YAML syntax: ${error.message}`);
+        return false;
+      }
+
+      // Validate required fields
+      this.validateRequiredFields(relativePath, frontmatter);
+      this.validateTools(relativePath, frontmatter);
+      this.validateModel(relativePath, frontmatter);
+      this.validateNaming(relativePath, frontmatter, filePath);
+      this.validateSystemPrompt(relativePath, content);
+
+      this.agentCount++;
+      return true;
+
+    } catch (error) {
+      this.addError(relativePath, `Failed to read file: ${error.message}`);
+      return false;
+    }
+  }
+
+  validateRequiredFields(file, frontmatter) {
+    const required = ['name', 'description'];
+
+    for (const field of required) {
+      if (!frontmatter[field]) {
+        this.addError(file, `Missing required field: ${field}`);
+      } else if (typeof frontmatter[field] !== 'string') {
+        this.addError(file, `Field '${field}' must be a string`);
+      }
+    }
+
+    // Validate description is meaningful
+    if (frontmatter.description && frontmatter.description.length < 20) {
+      this.addWarning(file, 'Description should be more descriptive (at least 20 characters)');
+    }
+  }
+
+  validateTools(file, frontmatter) {
+    if (frontmatter.tools) {
+      if (typeof frontmatter.tools === 'string') {
+        // Convert comma-separated string to array
+        const tools = frontmatter.tools.split(',').map(t => t.trim());
+        this.validateToolArray(file, tools);
+      } else if (Array.isArray(frontmatter.tools)) {
+        this.validateToolArray(file, frontmatter.tools);
+      } else {
+        this.addError(file, 'Tools field must be a string or array');
+      }
+    } else {
+      this.addWarning(file, 'No tools specified - agent will inherit all tools');
+    }
+  }
+
+  validateToolArray(file, tools) {
+    for (const tool of tools) {
+      if (!VALID_TOOLS.includes(tool)) {
+        this.addWarning(file, `Unknown tool: ${tool}. Valid tools: ${VALID_TOOLS.join(', ')}`);
+      }
+    }
+  }
+
+  validateModel(file, frontmatter) {
+    if (frontmatter.model && !VALID_MODELS.includes(frontmatter.model)) {
+      this.addWarning(file, `Unknown model: ${frontmatter.model}. Valid models: ${VALID_MODELS.join(', ')}`);
+    }
+  }
+
+  validateNaming(file, frontmatter, filePath) {
+    const fileName = path.basename(filePath, '.md');
+
+    // Check naming convention
+    if (!/^[a-z]+(-[a-z]+)*$/.test(fileName)) {
+      this.addError(file, 'File name should use lowercase-with-hyphens format');
+    }
+
+    // Check name matches file name
+    if (frontmatter.name && frontmatter.name !== fileName) {
+      this.addWarning(file, `Agent name '${frontmatter.name}' doesn't match file name '${fileName}'`);
+    }
+  }
+
+  validateSystemPrompt(file, content) {
+    // Extract system prompt (everything after frontmatter)
+    const promptMatch = content.match(/^---\n[\s\S]*?\n---\n\n?([\s\S]*)$/);
+    if (!promptMatch || !promptMatch[1].trim()) {
+      this.addError(file, 'Missing system prompt after YAML frontmatter');
+      return;
+    }
+
+    const prompt = promptMatch[1].trim();
+
+    // Check prompt length
+    if (prompt.length < 100) {
+      this.addWarning(file, 'System prompt should be more detailed (at least 100 characters)');
+    }
+
+    // Check for key elements
+    const hasExpertise = /expertise|expert|specialist|specializ/i.test(prompt);
+    const hasMethodology = /methodology|approach|process|workflow/i.test(prompt);
+    const hasUsage = /use this|when to|should be used/i.test(prompt);
+
+    if (!hasExpertise) {
+      this.addWarning(file, 'System prompt should define agent expertise');
+    }
+    if (!hasMethodology) {
+      this.addWarning(file, 'System prompt should describe methodology or approach');
+    }
+    if (!hasUsage) {
+      this.addWarning(file, 'System prompt should explain when to use this agent');
+    }
+  }
+
+  async validateAll() {
+    this.log('Starting agent validation...');
+
+    try {
+      // Find all agent files
+      const agentFiles = await glob('.claude/agents/**/*.md');
+
+      if (agentFiles.length === 0) {
+        this.addError('validation', 'No agent files found in .claude/agents/');
+        return false;
+      }
+
+      this.log(`Found ${agentFiles.length} agent files to validate`);
+
+      // Validate each file
+      for (const file of agentFiles) {
+        this.validateAgentFile(file);
+      }
+
+      // Summary
+      this.log(`\n📊 Validation Summary:`);
+      this.log(`   Agents validated: ${this.agentCount}`);
+      this.log(`   Errors: ${this.errors.length}`);
+      this.log(`   Warnings: ${this.warnings.length}`);
+
+      if (this.errors.length > 0) {
+        this.log('\n❌ Validation failed with errors:', 'error');
+        return false;
+      }
+
+      if (this.warnings.length > 0) {
+        this.log('\n⚠️ Validation passed with warnings', 'warning');
+      } else {
+        this.log('\n✅ All agents passed validation!');
+      }
+
+      return true;
+
+    } catch (error) {
+      this.addError('validation', `Validation failed: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+// CLI usage
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const validator = new AgentValidator();
+
+  validator.validateAll().then(success => {
+    process.exit(success ? 0 : 1);
+  }).catch(error => {
+    console.error('❌ Validation crashed:', error);
+    process.exit(1);
+  });
+}
+
+export default AgentValidator;