claude-flow-novice 2.2.3 → 2.2.4

package/dist/scripts/legacy/README.md

@@ -0,0 +1,272 @@
+# Legacy Scripts
+
+This directory contains scripts that have been superseded by consolidated versions in Phase 12 cleanup. These scripts are kept for reference, fallback purposes, and historical documentation.
+
+## Purpose
+
+Legacy scripts serve several important functions:
+
+1. **Reference Documentation** - Historical implementation patterns
+2. **Fallback Options** - Emergency alternatives if consolidated scripts fail
+3. **Migration Assistance** - Understanding changes between versions
+4. **Educational Value** - Learning from previous implementations
+5. **Debugging Support** - Comparing old vs new behavior
+
+## ⚠️ Important Notice
+
+**These scripts are considered DEPRECATED** and should not be used in normal operations. They are maintained for:
+- Emergency fallback scenarios
+- Development reference
+- Migration troubleshooting
+- Historical documentation
+
+For current operations, use the consolidated scripts in the appropriate directories:
+- `../build/` - Modern build scripts
+- `../test/` - Current testing scripts
+- `../dev/` - Active development tools
+- `../utils/` - Current utility scripts
+
+## Legacy Script Categories
+
+### Build Scripts (Superseded by `../build/unified-builder.sh`)
+
+#### Build Workarounds
+- **`build-workaround.sh`** - Basic build with workarounds
+- **`build-with-filter.sh`** - Filtered build output
+- **`build-migration.sh`** - Migration-compatible builds
+- **`force-build.sh`** - Force build ignoring errors
+- **`safe-build.sh`** - Safe build with backups
+
+#### Build Monitoring
+- **`build-monitor.js`** - Build process monitoring
+
+**Replacement:** Use `scripts/build/unified-builder.sh [mode]` where mode is one of: workaround, filter, migration, force, safe, monitor
+
+### TypeScript Fix Scripts (Superseded by `../build/typescript-fixer.js`)
+
+#### TypeScript Error Fixes
+- **`fix-typescript-errors.js`** - Basic TypeScript error fixes
+- **`fix-ts-advanced.js`** - Advanced TypeScript error resolution
+- **`fix-ts-final.sh`** - Final TypeScript fix pass
+- **`fix-ts-targeted.sh`** - Targeted TypeScript fixes
+- **`quick-fix-ts.js`** - Quick TypeScript error fixes
+- **`batch-fix-ts.sh`** - Batch TypeScript error processing
+
+**Replacement:** Use `node scripts/build/typescript-fixer.js [strategy]` where strategy is one of: basic, advanced, targeted, quick, batch, all
+
+### Performance Scripts (Superseded by `../build/performance-monitor.js`)
+
+#### Performance Testing
+- **`performance-test-runner.js`** - Basic performance test runner
+- **`performance-monitor.js`** - Performance monitoring
+- **`performance-monitoring.js`** - Extended performance monitoring
+- **`optimize-performance.js`** - Performance optimization
+
+**Replacement:** Use `node scripts/build/performance-monitor.js [command]` where command is one of: test, monitor, report, metrics
+
+## Migration Mapping
+
+### Old Script → New Script Mapping
+
+```bash
+# Build Scripts
+scripts/build-workaround.sh → scripts/build/unified-builder.sh workaround
+scripts/build-with-filter.sh → scripts/build/unified-builder.sh filter
+scripts/safe-build.sh → scripts/build/unified-builder.sh safe
+scripts/force-build.sh → scripts/build/unified-builder.sh force
+scripts/build-migration.sh → scripts/build/unified-builder.sh migration
+scripts/build-monitor.js → scripts/build/unified-builder.sh monitor
+
+# TypeScript Fixes
+scripts/fix-typescript-errors.js → node scripts/build/typescript-fixer.js basic
+scripts/fix-ts-advanced.js → node scripts/build/typescript-fixer.js advanced
+scripts/quick-fix-ts.js → node scripts/build/typescript-fixer.js quick
+scripts/batch-fix-ts.sh → node scripts/build/typescript-fixer.js batch
+scripts/fix-ts-targeted.sh → node scripts/build/typescript-fixer.js targeted
+
+# Performance Scripts
+scripts/performance-test-runner.js → node scripts/build/performance-monitor.js test
+scripts/performance-monitor.js → node scripts/build/performance-monitor.js monitor
+scripts/optimize-performance.js → node scripts/build/performance-monitor.js optimize
+```
+
+### NPM Script Migration
+
+```json
+{
+  "scripts": {
+    "// OLD SCRIPTS (deprecated)": "//",
+    "build:old-workaround": "scripts/legacy/build-workaround.sh",
+    "fix:old-typescript": "scripts/legacy/fix-typescript-errors.js",
+
+    "// NEW SCRIPTS (recommended)": "//",
+    "build": "scripts/build/unified-builder.sh safe",
+    "build:workaround": "scripts/build/unified-builder.sh workaround",
+    "fix:typescript": "node scripts/build/typescript-fixer.js"
+  }
+}
+```
+
+## Emergency Usage
+
+### When to Use Legacy Scripts
+
+**Only use legacy scripts in these scenarios:**
+
+1. **Consolidated script failure** - New script has a critical bug
+2. **Emergency debugging** - Need to compare old vs new behavior
+3. **Rollback scenario** - Need to revert to previous functionality
+4. **Development reference** - Understanding how features were implemented
+
+### Safe Usage Pattern
+
+```bash
+# 1. Backup current state
+git add -A && git commit -m "Pre-legacy-script checkpoint"
+
+# 2. Use legacy script with caution
+bash scripts/legacy/build-workaround.sh
+
+# 3. Test results thoroughly
+npm test
+
+# 4. Consider migrating to new script
+scripts/build/unified-builder.sh workaround
+```
+
+## Differences from Modern Scripts
+
+### Functionality Gaps
+
+Legacy scripts may lack:
+- **Coordination hooks integration**
+- **Enhanced error handling**
+- **Comprehensive logging**
+- **Parameter validation**
+- **Help systems**
+- **Dry-run capabilities**
+- **Performance optimizations**
+- **Security improvements**
+
+### Known Issues
+
+Legacy scripts may have:
+- **Deprecated dependencies**
+- **Security vulnerabilities**
+- **Performance limitations**
+- **Limited error recovery**
+- **Inconsistent interfaces**
+- **Missing documentation**
+
+## Development Value
+
+### Learning Opportunities
+
+Legacy scripts provide insights into:
+- **Evolution of build processes**
+- **TypeScript error handling approaches**
+- **Performance optimization techniques**
+- **Script organization patterns**
+- **Error handling strategies**
+
+### Code Archaeology
+
+Use legacy scripts to understand:
+- **Why certain decisions were made**
+- **How problems were solved historically**
+- **Evolution of project requirements**
+- **Performance optimization history**
+- **Testing strategy development**
+
+## Maintenance Policy
+
+### Retention Guidelines
+
+Legacy scripts are retained for:
+- **6 months minimum** after replacement
+- **Until next major version** release
+- **Historical reference** indefinitely
+- **Emergency fallback** scenarios
+
+### Update Policy
+
+Legacy scripts are **NOT UPDATED** except for:
+- **Critical security vulnerabilities**
+- **Emergency compatibility fixes**
+- **Documentation corrections**
+
+### Removal Schedule
+
+Legacy scripts may be removed when:
+- Consolidated scripts prove stable (6+ months)
+- No emergency usage in 1+ year
+- Storage optimization required
+- Major version upgrade
+
+## Troubleshooting Legacy Scripts
+
+### Common Issues
+
+#### Permission Problems
+```bash
+# Fix execute permissions
+chmod +x scripts/legacy/*.sh
+```
+
+#### Dependency Issues
+```bash
+# Install legacy dependencies
+npm install --legacy-peer-deps
+```
+
+#### Path Issues
+```bash
+# Run from project root
+cd /path/to/project-root
+bash scripts/legacy/script-name.sh
+```
+
+#### Environment Issues
+```bash
+# Set legacy environment
+export LEGACY_MODE=true
+export NODE_OPTIONS='--legacy-openssl-provider'
+```
+
+### Getting Help
+
+If you must use legacy scripts:
+
+1. **Check the modern equivalent first**
+2. **Review the migration mapping**
+3. **Test in safe environment**
+4. **Document the usage reason**
+5. **Plan migration to modern scripts**
+
+## Contributing to Legacy
+
+### New Additions
+
+**DO NOT add new scripts to legacy** unless:
+- Moving deprecated script from main directories
+- Adding emergency fallback for critical functionality
+- Documenting historical implementation
+
+### Documentation Updates
+
+When updating legacy documentation:
+- Keep historical accuracy
+- Note deprecation status clearly
+- Provide modern alternatives
+- Explain migration path
+
+## Related Documentation
+
+- **Phase 12 Cleanup Report** - Details of consolidation process
+- **Migration Guide** - How to migrate from legacy to modern scripts
+- **Troubleshooting Guide** - Common issues and solutions
+- **Development History** - Evolution of the script ecosystem
+
+---
+
+**Remember: Legacy scripts are for reference and emergency use only. Always prefer the modern consolidated scripts in the appropriate category directories.**

package/dist/scripts/legacy/batch-fix-ts.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+echo "🔧 Starting batch TypeScript fixes..."
+
+# Fix 1: Add missing .js extensions to relative imports
+echo "📝 Adding .js extensions to imports..."
+find src -name "*.ts" -type f -exec sed -i.bak -E "s/from '(\.\.[^']+)'/from '\1.js'/g" {} \;
+find src -name "*.ts" -type f -exec sed -i.bak -E "s/from '(\.\/[^']+)'/from '\1.js'/g" {} \;
+
+# Fix 2: Replace 'developer' with 'coder' and 'analyzer' with 'analyst'
+echo "📝 Fixing AgentType references..."
+find src -name "*.ts" -type f -exec sed -i.bak "s/'developer'/'coder'/g" {} \;
+find src -name "*.ts" -type f -exec sed -i.bak "s/'analyzer'/'analyst'/g" {} \;
+find src -name "*.ts" -type f -exec sed -i.bak 's/"developer"/"coder"/g' {} \;
+find src -name "*.ts" -type f -exec sed -i.bak 's/"analyzer"/"analyst"/g' {} \;
+
+# Fix 3: Add override modifiers
+echo "📝 Adding override modifiers..."
+find src -name "*.ts" -type f -exec sed -i.bak -E 's/^(\s*)(async )?(\w+)\(/$1$2override $3(/g' {} \;
+
+# Fix 4: Fix type imports
+echo "📝 Converting import type to regular imports for value usage..."
+find src -name "*.ts" -type f -exec sed -i.bak -E 's/import type \{ TodoItem \}/import \{ TodoItem \}/g' {} \;
+find src -name "*.ts" -type f -exec sed -i.bak -E 's/import type \{ MemoryEntry \}/import \{ MemoryEntry \}/g' {} \;
+find src -name "*.ts" -type f -exec sed -i.bak -E 's/import type \{ AgentState \}/import \{ AgentState \}/g' {} \;
+
+# Fix 5: Fix never array issues
+echo "📝 Fixing never[] array assignments..."
+find src -name "*.ts" -type f -exec sed -i.bak -E 's/(\w+)\.push\(/((\1 as any[]).push(/g' {} \;
+
+# Fix 6: Add missing imports
+echo "📝 Adding missing Node.js imports..."
+for file in $(find src -name "*.ts" -type f); do
+  if grep -q "__dirname" "$file" && ! grep -q "fileURLToPath" "$file"; then
+    sed -i.bak '1i\
+import { dirname } from "node:path";\
+import { fileURLToPath } from "node:url";\
+const __dirname = dirname(fileURLToPath(import.meta.url));' "$file"
+  fi
+  
+  if grep -q "process\." "$file" && ! grep -q "import.*process" "$file"; then
+    sed -i.bak '1i\
+import process from "node:process";' "$file"
+  fi
+done
+
+# Clean up backup files
+echo "🧹 Cleaning up backup files..."
+find src -name "*.bak" -type f -delete
+
+echo "✅ Batch fixes applied!"
+echo "🔧 Running TypeScript build to check remaining errors..."
+
+npm run build:ts 2>&1 | grep -c "error TS" || echo "0 errors"

package/dist/scripts/legacy/build-migration.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+# Build script for Claude-Flow Migration System
+
+set -e
+
+echo "🚀 Building Claude-Flow Migration System..."
+
+# Check if we're in the right directory
+if [ ! -f "package.json" ]; then
+    echo "❌ Error: package.json not found. Please run from project root."
+    exit 1
+fi
+
+# Clean previous builds
+echo "🧹 Cleaning previous builds..."
+rm -rf dist/migration
+rm -rf src/migration/dist
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+npm install
+
+# Build TypeScript
+echo "🔨 Compiling TypeScript..."
+cd src/migration
+npm run build || {
+    echo "⚠️  TypeScript build with npm not available, using tsc directly..."
+    npx tsc
+}
+cd ../..
+
+# Create distribution directory
+echo "📁 Creating distribution structure..."
+mkdir -p dist/migration
+cp -r src/migration/dist/* dist/migration/
+cp src/migration/package.json dist/migration/
+cp src/migration/README.md dist/migration/
+cp src/migration/migration-manifest.json dist/migration/
+
+# Copy source templates for development
+echo "📋 Copying templates..."
+mkdir -p dist/migration/templates
+cp -r .claude/ dist/migration/templates/claude || echo "⚠️  .claude folder not found, skipping..."
+cp CLAUDE.md dist/migration/templates/ || echo "⚠️  CLAUDE.md not found, skipping..."
+cp .roomodes dist/migration/templates/ || echo "⚠️  .roomodes not found, skipping..."
+
+# Make executable
+chmod +x dist/migration/index.js
+
+# Create symlink for global usage
+echo "🔗 Creating symlinks..."
+mkdir -p bin
+ln -sf ../dist/migration/index.js bin/claude-flow-migrate
+
+# Run tests
+echo "🧪 Running tests..."
+cd src/migration
+npm test || echo "⚠️  Tests failed or not configured"
+cd ../..
+
+# Create package info
+echo "📄 Creating package information..."
+cat > dist/migration/INSTALL.md << 'EOF'
+# Claude-Flow Migration System Installation
+
+## Quick Install
+
+```bash
+# From project root
+npm install -g ./dist/migration
+
+# Or use directly
+./bin/claude-flow-migrate --help
+```
+
+## Usage
+
+```bash
+# Analyze project
+claude-flow-migrate analyze
+
+# Migrate with selective strategy
+claude-flow-migrate --strategy selective --preserve-custom
+
+# Rollback if needed
+claude-flow-migrate rollback
+```
+
+## Documentation
+
+See README.md for complete documentation.
+EOF
+
+echo "✅ Build completed successfully!"
+echo ""
+echo "📋 Next steps:"
+echo "   1. Test installation: ./bin/claude-flow-migrate --help"
+echo "   2. Run on test project: ./bin/claude-flow-migrate analyze /path/to/project"
+echo "   3. Create distribution: npm pack dist/migration"
+echo ""
+echo "📦 Built files:"
+echo "   - dist/migration/ - Complete migration system"
+echo "   - bin/claude-flow-migrate - Executable symlink"
+echo ""

package/dist/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;