claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/optimization/build-optimizer.js

@@ -1,438 +0,0 @@
-/**
- * Build Optimizer - Implementing issue #772 performance improvements
- *
- * Achieves 51% faster build times through:
- * - File consolidation and removal of unnecessary files
- * - Dependency optimization
- * - Incremental compilation
- * - Build cache management
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { execSync } = require('child_process');
-
-class BuildOptimizer {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.buildCache = new Map();
-    this.stats = {
-      filesRemoved: 0,
-      duplicatesConsolidated: 0,
-      buildTimeImprovement: 0,
-      spaceSaved: 0,
-    };
-
-    // Files to remove based on #772 (32 UI-related files removed)
-    this.filesToRemove = [
-      // UI files that aren't needed for core functionality
-      'src/ui/console/**/*.css',
-      'src/ui/console/**/*.html',
-      'src/ui/portal/**/*.legacy.*',
-      'dist/ui/**/*.map.old',
-      // Old test files
-      'src/**/*.test.old.js',
-      'tests/**/*.legacy.test.ts',
-      // Temporary and build artifacts
-      '**/*.tmp',
-      '**/*.bak',
-      'dist/**/*.js.map.old',
-      // Documentation that's moved to wiki
-      'docs/legacy/**',
-      'README.old.md',
-      // Old configuration files
-      'config/**/*.old.*',
-      '.eslintrc.old.json',
-      'tsconfig.old.json',
-    ];
-
-    // Duplicate patterns to consolidate
-    this.duplicatePatterns = [
-      {
-        pattern: 'src/agents/**/types.ts',
-        consolidateTo: 'src/types/agent-types.ts',
-      },
-      {
-        pattern: 'src/**/logger.ts',
-        consolidateTo: 'src/core/logger.ts',
-      },
-      {
-        pattern: 'src/**/helpers.ts',
-        consolidateTo: 'src/utils/helpers.ts',
-      },
-    ];
-  }
-
-  async optimize() {
-    console.log('🚀 Starting build optimization...');
-
-    const startTime = Date.now();
-
-    try {
-      // Phase 1: Remove unnecessary files
-      await this.removeUnnecessaryFiles();
-
-      // Phase 2: Consolidate duplicates
-      await this.consolidateDuplicates();
-
-      // Phase 3: Optimize dependencies
-      await this.optimizeDependencies();
-
-      // Phase 4: Setup incremental compilation
-      await this.setupIncrementalCompilation();
-
-      // Phase 5: Optimize build cache
-      await this.optimizeBuildCache();
-
-      const endTime = Date.now();
-      this.stats.buildTimeImprovement = endTime - startTime;
-
-      console.log('✅ Build optimization complete!');
-      this.printStats();
-
-      return this.stats;
-    } catch (error) {
-      console.error('❌ Build optimization failed:', error);
-      throw error;
-    }
-  }
-
-  async removeUnnecessaryFiles() {
-    console.log('🧹 Removing unnecessary files...');
-
-    for (const pattern of this.filesToRemove) {
-      try {
-        const files = await this.glob(pattern);
-
-        for (const file of files) {
-          const filePath = path.join(this.projectRoot, file);
-          const stats = await fs.stat(filePath).catch(() => null);
-
-          if (stats) {
-            await fs.unlink(filePath);
-            this.stats.filesRemoved++;
-            this.stats.spaceSaved += stats.size;
-            console.log(`  Removed: ${file}`);
-          }
-        }
-      } catch (error) {
-        console.warn(`  Warning: Could not process pattern ${pattern}:`, error.message);
-      }
-    }
-
-    console.log(`  ✅ Removed ${this.stats.filesRemoved} files, saved ${this.formatBytes(this.stats.spaceSaved)}`);
-  }
-
-  async consolidateDuplicates() {
-    console.log('🔄 Consolidating duplicate files...');
-
-    for (const { pattern, consolidateTo } of this.duplicatePatterns) {
-      try {
-        const files = await this.glob(pattern);
-        const targetPath = path.join(this.projectRoot, consolidateTo);
-
-        if (files.length > 1) {
-          // Analyze and merge duplicate files
-          const mergedContent = await this.mergeDuplicateFiles(files, consolidateTo);
-
-          // Ensure target directory exists
-          await fs.mkdir(path.dirname(targetPath), { recursive: true });
-
-          // Write consolidated file
-          await fs.writeFile(targetPath, mergedContent);
-
-          // Remove duplicates (keep the target)
-          for (const file of files) {
-            const filePath = path.join(this.projectRoot, file);
-            if (filePath !== targetPath) {
-              await fs.unlink(filePath);
-              this.stats.duplicatesConsolidated++;
-            }
-          }
-
-          console.log(`  ✅ Consolidated ${files.length - 1} duplicates into ${consolidateTo}`);
-        }
-      } catch (error) {
-        console.warn(`  Warning: Could not consolidate ${pattern}:`, error.message);
-      }
-    }
-  }
-
-  async optimizeDependencies() {
-    console.log('📦 Optimizing dependencies...');
-
-    try {
-      // Analyze package.json for optimization opportunities
-      const packageJsonPath = path.join(this.projectRoot, 'package.json');
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-
-      // Remove unused dependencies
-      const unusedDeps = await this.findUnusedDependencies(packageJson);
-
-      if (unusedDeps.length > 0) {
-        console.log(`  Found ${unusedDeps.length} potentially unused dependencies:`);
-        unusedDeps.forEach(dep => console.log(`    - ${dep}`));
-
-        // Note: Don't automatically remove - just report
-        console.log(`  ⚠️  Review these dependencies manually before removing`);
-      }
-
-      // Optimize development dependencies
-      await this.optimizeDevDependencies(packageJson, packageJsonPath);
-
-      console.log('  ✅ Dependency optimization complete');
-    } catch (error) {
-      console.warn('  Warning: Could not optimize dependencies:', error.message);
-    }
-  }
-
-  async setupIncrementalCompilation() {
-    console.log('⚡ Setting up incremental compilation...');
-
-    try {
-      // Update TypeScript config for incremental compilation
-      const tsconfigPath = path.join(this.projectRoot, 'config/typescript/tsconfig.json');
-      const tsconfig = JSON.parse(await fs.readFile(tsconfigPath, 'utf8'));
-
-      // Enable incremental compilation
-      tsconfig.compilerOptions = {
-        ...tsconfig.compilerOptions,
-        incremental: true,
-        tsBuildInfoFile: path.join(this.projectRoot, '.tsbuild/buildinfo.json'),
-        composite: false, // Disable if not using project references
-      };
-
-      // Create .tsbuild directory
-      await fs.mkdir(path.join(this.projectRoot, '.tsbuild'), { recursive: true });
-
-      await fs.writeFile(tsconfigPath, JSON.stringify(tsconfig, null, 2));
-
-      console.log('  ✅ Incremental compilation enabled');
-    } catch (error) {
-      console.warn('  Warning: Could not setup incremental compilation:', error.message);
-    }
-  }
-
-  async optimizeBuildCache() {
-    console.log('💾 Optimizing build cache...');
-
-    try {
-      // Setup SWC cache optimization
-      const swcrcPath = path.join(this.projectRoot, '.swcrc');
-
-      if (await this.fileExists(swcrcPath)) {
-        const swcConfig = JSON.parse(await fs.readFile(swcrcPath, 'utf8'));
-
-        // Enable caching
-        swcConfig.env = {
-          ...swcConfig.env,
-          caching: true,
-          cacheRoot: '.swc-cache',
-        };
-
-        await fs.writeFile(swcrcPath, JSON.stringify(swcConfig, null, 2));
-      }
-
-      // Create cache directories
-      await fs.mkdir(path.join(this.projectRoot, '.swc-cache'), { recursive: true });
-      await fs.mkdir(path.join(this.projectRoot, 'node_modules/.cache'), { recursive: true });
-
-      console.log('  ✅ Build cache optimized');
-    } catch (error) {
-      console.warn('  Warning: Could not optimize build cache:', error.message);
-    }
-  }
-
-  async mergeDuplicateFiles(files, targetPath) {
-    const imports = new Set();
-    const exports = new Set();
-    const interfaces = new Map();
-    const types = new Map();
-    const functions = new Map();
-
-    for (const file of files) {
-      const filePath = path.join(this.projectRoot, file);
-
-      try {
-        const content = await fs.readFile(filePath, 'utf8');
-
-        // Extract imports
-        const importMatches = content.match(/^import\s+.*?from\s+['"][^'"]+['"];?$/gm);
-        if (importMatches) {
-          importMatches.forEach(imp => imports.add(imp.trim()));
-        }
-
-        // Extract exports
-        const exportMatches = content.match(/^export\s+.*?$/gm);
-        if (exportMatches) {
-          exportMatches.forEach(exp => exports.add(exp.trim()));
-        }
-
-        // Extract interfaces and types (simplified)
-        const interfaceMatches = content.match(/export\s+interface\s+(\w+)[\s\S]*?^}/gm);
-        if (interfaceMatches) {
-          interfaceMatches.forEach(int => {
-            const name = int.match(/interface\s+(\w+)/)?.[1];
-            if (name && !interfaces.has(name)) {
-              interfaces.set(name, int);
-            }
-          });
-        }
-
-      } catch (error) {
-        console.warn(`    Warning: Could not process file ${file}:`, error.message);
-      }
-    }
-
-    // Build merged content
-    const mergedContent = [
-      '/**',
-      ` * Consolidated ${targetPath}`,
-      ' * Auto-generated by build optimizer',
-      ' */',
-      '',
-      ...Array.from(imports),
-      '',
-      ...Array.from(interfaces.values()),
-      '',
-      ...Array.from(types.values()),
-      '',
-      ...Array.from(functions.values()),
-      '',
-      ...Array.from(exports),
-    ].join('\n');
-
-    return mergedContent;
-  }
-
-  async findUnusedDependencies(packageJson) {
-    const dependencies = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies,
-    };
-
-    const unusedDeps = [];
-
-    for (const dep of Object.keys(dependencies)) {
-      try {
-        // Simple check: search for import/require statements
-        const result = execSync(
-          `grep -r "from ['\"]${dep}['\"]\\|require(['\"]${dep}['\"])" src/ --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx"`,
-          { encoding: 'utf8', cwd: this.projectRoot }
-        );
-
-        if (!result.trim()) {
-          unusedDeps.push(dep);
-        }
-      } catch (error) {
-        // No matches found - potentially unused
-        if (error.status === 1) {
-          unusedDeps.push(dep);
-        }
-      }
-    }
-
-    return unusedDeps;
-  }
-
-  async optimizeDevDependencies(packageJson, packageJsonPath) {
-    // Move runtime dependencies that should be dev dependencies
-    const devOnlyPackages = [
-      '@types/',
-      'eslint',
-      'prettier',
-      'jest',
-      'playwright',
-      '@playwright/',
-      'typescript',
-      '@typescript-eslint/',
-      '@swc/',
-      'babel-',
-      '@babel/',
-    ];
-
-    let modified = false;
-    const deps = packageJson.dependencies || {};
-    const devDeps = packageJson.devDependencies || {};
-
-    for (const dep of Object.keys(deps)) {
-      if (devOnlyPackages.some(pattern => dep.startsWith(pattern))) {
-        devDeps[dep] = deps[dep];
-        delete deps[dep];
-        modified = true;
-        console.log(`  Moved ${dep} to devDependencies`);
-      }
-    }
-
-    if (modified) {
-      packageJson.dependencies = deps;
-      packageJson.devDependencies = devDeps;
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    }
-  }
-
-  async glob(pattern) {
-    // Simple glob implementation - in production, use a proper glob library
-    const files = [];
-
-    try {
-      const result = execSync(`find . -path "./${pattern}" 2>/dev/null || true`, {
-        encoding: 'utf8',
-        cwd: this.projectRoot,
-      });
-
-      files.push(...result.split('\n').filter(f => f.trim()).map(f => f.replace('./', '')));
-    } catch (error) {
-      // Ignore errors for glob patterns
-    }
-
-    return files;
-  }
-
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  formatBytes(bytes) {
-    if (bytes === 0) return '0 Bytes';
-    const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-  }
-
-  printStats() {
-    console.log('\n📊 Optimization Results:');
-    console.log(`  Files removed: ${this.stats.filesRemoved}`);
-    console.log(`  Duplicates consolidated: ${this.stats.duplicatesConsolidated}`);
-    console.log(`  Space saved: ${this.formatBytes(this.stats.spaceSaved)}`);
-    console.log(`  Optimization time: ${this.stats.buildTimeImprovement}ms`);
-    console.log('\n🎯 Expected improvements:');
-    console.log('  • 51% faster build times');
-    console.log('  • Reduced bundle size');
-    console.log('  • Better incremental compilation');
-    console.log('  • Improved cache efficiency');
-  }
-}
-
-// CLI interface
-if (require.main === module) {
-  const optimizer = new BuildOptimizer();
-
-  optimizer.optimize()
-    .then(stats => {
-      console.log('\n✅ Build optimization completed successfully!');
-      process.exit(0);
-    })
-    .catch(error => {
-      console.error('\n❌ Build optimization failed:', error);
-      process.exit(1);
-    });
-}
-
-module.exports = BuildOptimizer;