@epublishing/grunt-epublishing 1.0.7 → 1.1.2

package/lib/cli.js

@@ -0,0 +1,516 @@
+/**
+ * CLI Implementation
+ * 
+ * Main entry point for the build tools.
+ * Orchestrates webpack, sass, concat/minify tasks.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { program } = require('commander');
+const chalk = require('chalk');
+const ora = require('ora');
+const Resolver = require('@epublishing/jade-resolver');
+const { loadConfig } = require('./config-loader');
+const { configureWebpack, runWebpack, watchWebpack, splitEntries } = require('./webpack.config');
+const { compileSass } = require('./sass-compiler');
+const { runConcatMinify } = require('./concat-minify');
+const { writeTsConfigs, cleanTsConfigs } = require('./tsconfig-gen');
+
+// Package info for banner
+const pkg = require('../package.json');
+
+/**
+ * Print banner
+ */
+function printBanner(options) {
+  if (options.noBanner) return;
+  
+  console.log(chalk.cyan(`
+╔═══════════════════════════════════════════╗
+║                                           ║
+║   ePublishing Build Tools v${pkg.version.padEnd(13)}║
+║                                           ║
+╚═══════════════════════════════════════════╝
+`));
+}
+
+/**
+ * Print available options
+ */
+function printOptions(options) {
+  if (options.noBanner) return;
+  
+  const flags = [];
+  if (options.watch) flags.push('watch');
+  if (options.noMinify) flags.push('no-minify');
+  if (options.analyze) flags.push('analyze');
+  if (options.lint) flags.push('lint');
+  if (options.verbose) flags.push('verbose');
+  if (options.parallel) flags.push('parallel');
+  
+  if (flags.length > 0) {
+    console.log(chalk.gray(`  Options: ${flags.join(', ')}\n`));
+  }
+}
+
+/**
+ * Run npm install in jade and jade child gem directories.
+ * Installs packages from each gem's package.json (excluding site).
+ * @param {Object} config - Build configuration with paths
+ * @param {Object} options - Build options
+ */
+async function runNpmInstall(config, options) {
+  const paths = config.paths || {};
+  const resolver = new Resolver({ ...paths }, { includeSite: false });
+  resolver.removePath('site');
+
+  const packages = resolver.find('package.json');
+  if (!packages || packages.length === 0) {
+    return;
+  }
+
+  const origCwd = process.cwd();
+  const dirs = [...new Set(packages.map((p) => path.dirname(p)))];
+
+  for (const dir of dirs) {
+    const basename = path.basename(dir);
+    const spinner = ora(`Installing npm modules in ${basename}...`).start();
+
+    try {
+      const hasLock = fs.existsSync(path.join(dir, 'package-lock.json'));
+      const cmd = hasLock ? 'ci' : 'install';
+      await new Promise((resolve, reject) => {
+        process.chdir(dir);
+        const proc = spawn('npm', [cmd], {
+          stdio: options.verbose ? 'inherit' : 'pipe',
+          shell: true,
+        });
+        proc.on('close', (code) => {
+          process.chdir(origCwd);
+          if (code === 0) {
+            spinner.succeed(`npm ${cmd} completed in ${basename}`);
+            resolve();
+          } else {
+            spinner.fail(`npm ${cmd} failed in ${basename}`);
+            reject(new Error(`npm ${cmd} exited with code ${code}`));
+          }
+        });
+        proc.on('error', (err) => {
+          process.chdir(origCwd);
+          spinner.fail(`npm ${cmd} failed in ${basename}`);
+          reject(err);
+        });
+      });
+    } catch (err) {
+      process.chdir(origCwd);
+      throw err;
+    }
+  }
+}
+
+/**
+ * Run webpack build
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runWebpackBuild(config, options) {
+  const spinner = ora('Building webpack bundles...').start();
+  
+  try {
+    const webpackConfigs = configureWebpack(config, options);
+    const targets = Object.keys(webpackConfigs);
+    
+    if (targets.length === 0) {
+      spinner.info('No webpack targets configured');
+      return;
+    }
+    
+    for (const targetName of targets) {
+      const targetConfig = webpackConfigs[targetName];
+      
+      // Split entries if there are many (memory optimization)
+      if (targetConfig.entry && Object.keys(targetConfig.entry).length > 10 && !options.parallel) {
+        const batches = splitEntries(targetConfig.entry, 10);
+        spinner.text = `Building ${targetName} (${batches.length} batches)...`;
+        
+        for (let i = 0; i < batches.length; i++) {
+          const batchConfig = { ...targetConfig, entry: batches[i] };
+          spinner.text = `Building ${targetName} batch ${i + 1}/${batches.length}...`;
+          
+          const stats = await runWebpack(batchConfig);
+          
+          if (options.verbose) {
+            console.log(stats.toString({ colors: true }));
+          }
+          
+          // Allow GC between batches
+          if (global.gc) {
+            global.gc();
+          }
+        }
+      } else {
+        spinner.text = `Building ${targetName}...`;
+        const stats = await runWebpack(targetConfig);
+        
+        if (options.verbose) {
+          console.log(stats.toString({ colors: true }));
+        }
+      }
+    }
+    
+    spinner.succeed(`Webpack: ${targets.length} target(s) built`);
+  } catch (error) {
+    spinner.fail('Webpack build failed');
+    throw error;
+  }
+}
+
+/**
+ * Run webpack in watch mode
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runWebpackWatch(config, options) {
+  const webpackConfigs = configureWebpack(config, { ...options, watch: true });
+  const targets = Object.keys(webpackConfigs);
+  
+  if (targets.length === 0) {
+    console.log(chalk.yellow('No webpack targets configured'));
+    return;
+  }
+  
+  console.log(chalk.cyan('Starting webpack watch mode...'));
+  
+  const watchers = [];
+  
+  for (const targetName of targets) {
+    const targetConfig = webpackConfigs[targetName];
+    
+    const watcher = watchWebpack(targetConfig, (err, stats) => {
+      if (err) {
+        console.error(chalk.red(`[${targetName}] Error:`, err.message));
+        return;
+      }
+      
+      const info = stats.toJson();
+      
+      if (stats.hasErrors()) {
+        console.error(chalk.red(`[${targetName}] Errors:`));
+        info.errors.forEach(e => console.error(e.message));
+        return;
+      }
+      
+      if (stats.hasWarnings() && options.verbose) {
+        console.warn(chalk.yellow(`[${targetName}] Warnings:`));
+        info.warnings.forEach(w => console.warn(w.message));
+      }
+      
+      console.log(chalk.green(`[${targetName}] Rebuilt in ${info.time}ms`));
+    });
+    
+    watchers.push(watcher);
+  }
+  
+  // Handle process termination
+  const cleanup = () => {
+    console.log(chalk.yellow('\nStopping watchers...'));
+    watchers.forEach(w => w.close());
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  
+  // Keep process alive
+  await new Promise(() => {});
+}
+
+/**
+ * Run sass build
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runSassBuild(config, options) {
+  const spinner = ora('Compiling Sass...').start();
+  
+  try {
+    const results = await compileSass(config, {
+      verbose: options.verbose,
+      maxConcurrency: options.parallel ? 4 : 2,
+    });
+    
+    const successful = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+    
+    if (failed > 0) {
+      spinner.warn(`Sass: ${successful} compiled, ${failed} failed`);
+      results.filter(r => !r.success).forEach(r => {
+        console.error(chalk.red(`  ${path.basename(r.src)}: ${r.error.message}`));
+      });
+    } else if (successful > 0) {
+      spinner.succeed(`Sass: ${successful} file(s) compiled`);
+    } else {
+      spinner.info('Sass: No files to compile');
+    }
+  } catch (error) {
+    spinner.fail('Sass compilation failed');
+    throw error;
+  }
+}
+
+/**
+ * Run concat/minify build
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runConcatMinifyBuild(config, options) {
+  const spinner = ora('Concatenating and minifying...').start();
+  
+  try {
+    const results = await runConcatMinify(config, {
+      verbose: options.verbose,
+      noMinify: options.noMinify,
+    });
+    
+    const concatCount = results.concat.filter(r => r.success).length;
+    const minifyCount = results.minify.filter(r => r.success).length;
+    
+    if (concatCount > 0 || minifyCount > 0) {
+      spinner.succeed(`Concat: ${concatCount} bundles, Minify: ${minifyCount} files`);
+    } else {
+      spinner.info('No concat/minify targets configured');
+    }
+    
+    // Report any failures
+    const failures = [
+      ...results.concat.filter(r => !r.success),
+      ...results.minify.filter(r => !r.success),
+    ];
+    
+    if (failures.length > 0) {
+      console.warn(chalk.yellow('  Some targets failed:'));
+      failures.forEach(f => {
+        console.warn(chalk.red(`    ${f.target}: ${f.error?.message || 'Unknown error'}`));
+      });
+    }
+  } catch (error) {
+    spinner.fail('Concat/minify failed');
+    throw error;
+  }
+}
+
+/**
+ * Run clean task
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runClean(config, options) {
+  const spinner = ora('Cleaning...').start();
+  
+  try {
+    const cleanConfig = config.clean || {};
+    let cleaned = 0;
+    
+    for (const [targetName, targetConfig] of Object.entries(cleanConfig)) {
+      const src = Array.isArray(targetConfig.src) ? targetConfig.src : [targetConfig.src];
+      
+      for (const pattern of src) {
+        const resolvedPath = path.resolve(config.paths?.site || process.cwd(), pattern);
+        
+        // Simple glob handling for clean
+        if (pattern.includes('*')) {
+          // Skip complex globs for now
+          continue;
+        }
+        
+        if (fs.existsSync(resolvedPath)) {
+          await fs.promises.rm(resolvedPath, { recursive: true, force: true });
+          cleaned++;
+        }
+      }
+    }
+    
+    spinner.succeed(`Cleaned ${cleaned} path(s)`);
+  } catch (error) {
+    spinner.fail('Clean failed');
+    throw error;
+  }
+}
+
+/**
+ * Run full build
+ * @param {Object} config - Build configuration
+ * @param {Object} options - Build options
+ */
+async function runFullBuild(config, options) {
+  const startTime = Date.now();
+  
+  // Generate tsconfig files first
+  try {
+    const written = await writeTsConfigs(process.cwd());
+    if (options.verbose && written.length > 0) {
+      console.log(chalk.gray(`  Generated ${written.length} tsconfig.json file(s)`));
+    }
+  } catch {
+    // TSConfig generation is optional, continue on error
+  }
+  
+  // Run tasks sequentially for memory optimization (unless --parallel)
+  if (options.parallel) {
+    await Promise.all([
+      runWebpackBuild(config, options),
+      runSassBuild(config, options),
+      runConcatMinifyBuild(config, options),
+    ]);
+  } else {
+    // Sequential execution with GC hints between tasks
+    await runWebpackBuild(config, options);
+    if (global.gc) global.gc();
+    
+    await runSassBuild(config, options);
+    if (global.gc) global.gc();
+    
+    await runConcatMinifyBuild(config, options);
+  }
+  
+  // Clean tsconfig files after build
+  try {
+    await cleanTsConfigs(process.cwd());
+  } catch {
+    // Cleanup is optional
+  }
+  
+  const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+  console.log(chalk.green(`\n✓ Build completed in ${duration}s\n`));
+}
+
+/**
+ * Main CLI runner
+ * @param {Array<string>} argv - Command line arguments
+ */
+async function run(argv) {
+  program
+    .name('epublishing-build')
+    .description('Modern build tools for ePublishing sites')
+    .version(pkg.version)
+    .option('-w, --watch', 'Watch mode')
+    .option('--no-minify', 'Skip minification')
+    .option('--analyze', 'Generate bundle analysis')
+    .option('--lint', 'Run ESLint')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--parallel', 'Run tasks in parallel (uses more memory)')
+    .option('--no-banner', 'Hide banner')
+    .option('--env <env>', 'Set NODE_ENV')
+    .option('--gc-between-tasks', 'Force garbage collection between tasks')
+    .argument('[task]', 'Task to run (webpack, sass, concat, clean, or all)')
+    .parse(['node', 'epublishing-build', ...argv]);
+
+  const options = program.opts();
+  const task = program.args[0] || 'all';
+
+  // Set NODE_ENV if specified
+  if (options.env) {
+    process.env.NODE_ENV = options.env;
+  }
+
+  // Enable manual GC if requested
+  if (options.gcBetweenTasks && !global.gc) {
+    console.warn(chalk.yellow('Warning: --gc-between-tasks requires running with --expose-gc'));
+  }
+
+  printBanner(options);
+  printOptions(options);
+
+  // Load configuration
+  const spinner = ora('Loading configuration...').start();
+  
+  let config;
+  try {
+    config = await loadConfig(process.cwd(), { verbose: options.verbose });
+    spinner.succeed('Configuration loaded');
+  } catch (error) {
+    spinner.fail('Failed to load configuration');
+    throw error;
+  }
+
+  // Install npm packages from jade hierarchy (jade, jadechild) before build
+  if (task === 'webpack' || task === 'all') {
+    try {
+      await runNpmInstall(config, options);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  // Run requested task
+  switch (task) {
+    case 'webpack':
+      if (options.watch) {
+        await runWebpackWatch(config, options);
+      } else {
+        await runWebpackBuild(config, options);
+      }
+      break;
+
+    case 'sass':
+      await runSassBuild(config, options);
+      break;
+
+    case 'concat':
+      await runConcatMinifyBuild(config, options);
+      break;
+
+    case 'clean':
+      await runClean(config, options);
+      break;
+
+    case 'tsconfig':
+      const tsconfigSpinner = ora('Generating tsconfig.json files...').start();
+      try {
+        const written = await writeTsConfigs(process.cwd());
+        tsconfigSpinner.succeed(`Generated ${written.length} tsconfig.json file(s)`);
+      } catch (error) {
+        tsconfigSpinner.fail('TSConfig generation failed');
+        throw error;
+      }
+      break;
+
+    case 'clean-tsconfig':
+      const cleanTsconfigSpinner = ora('Cleaning tsconfig.json files...').start();
+      try {
+        const removed = await cleanTsConfigs(process.cwd());
+        cleanTsconfigSpinner.succeed(`Removed ${removed.length} tsconfig.json file(s)`);
+      } catch (error) {
+        cleanTsconfigSpinner.fail('TSConfig cleanup failed');
+        throw error;
+      }
+      break;
+
+    case 'all':
+    default:
+      if (options.watch) {
+        // In watch mode, run sass once then watch webpack
+        await runSassBuild(config, options);
+        await runConcatMinifyBuild(config, options);
+        await runWebpackWatch(config, options);
+      } else {
+        await runFullBuild(config, options);
+      }
+      break;
+  }
+}
+
+module.exports = {
+  run,
+  runWebpackBuild,
+  runWebpackWatch,
+  runSassBuild,
+  runConcatMinifyBuild,
+  runClean,
+  runFullBuild,
+};
+