easybuild-nox 1.0.0

package/src/commands/analyze.js

@@ -0,0 +1,203 @@
+const { Command } = require('commander');
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+const ProjectDetector = require('../utils/detector');
+
+const analyzeCommand = new Command('analyze')
+  .description('Analyze bundle size and dependencies')
+  .option('-d, --dir <dir>', 'Directory to analyze', 'dist')
+  .option('-f, --format <format>', 'Output format (text, json)', 'text')
+  .action(async (options) => {
+    logger.header('📊 Analyzing Project');
+
+    const detector = new ProjectDetector();
+
+    try {
+      const projectInfo = await detector.detect();
+
+      await analyzeProject(projectInfo, options);
+    } catch (error) {
+      logger.error(`Analysis failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function analyzeProject(projectInfo, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+
+  // Analyze package.json dependencies
+  logger.section('Dependencies Analysis');
+
+  const deps = pkg.dependencies || {};
+  const devDeps = pkg.devDependencies || {};
+
+  logger.info(`Production dependencies: ${Object.keys(deps).length}`);
+  logger.info(`Development dependencies: ${Object.keys(devDeps).length}`);
+
+  // Analyze dependencies
+  const allDeps = { ...deps, ...devDeps };
+  const categories = categorizeDependencies(allDeps);
+
+  logger.info('');
+  logger.section('Dependency Categories');
+
+  for (const [category, depList] of Object.entries(categories)) {
+    if (depList.length > 0) {
+      logger.info(`${category}: ${depList.length}`);
+      depList.forEach(dep => logger.dim(`  - ${dep}`));
+    }
+  }
+
+  // Check for outdated dependencies
+  logger.info('');
+  logger.section('Outdated Dependencies Check');
+
+  const child = spawn('npm', ['outdated', '--json'], {
+    stdio: 'pipe',
+    shell: true,
+  });
+
+  let output = '';
+  child.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  child.on('close', (code) => {
+    if (output) {
+      try {
+        const outdated = JSON.parse(output);
+        const outdatedCount = Object.keys(outdated).length;
+
+        if (outdatedCount > 0) {
+          logger.warning(`Found ${outdatedCount} outdated dependencies:`);
+          for (const [name, info] of Object.entries(outdated)) {
+            logger.dim(`  ${name}: ${info.current} -> ${info.latest}`);
+          }
+        } else {
+          logger.success('All dependencies are up to date!');
+        }
+      } catch (e) {
+        logger.dim('Could not parse outdated dependencies');
+      }
+    } else {
+      logger.dim('No outdated dependencies found');
+    }
+
+    // Analyze dist folder if it exists
+    analyzeDistFolder(options.dir);
+  });
+}
+
+function categorizeDependencies(deps) {
+  const categories = {
+    'Backend': [],
+    'Frontend': [],
+    'Database': [],
+    'Testing': [],
+    'Build Tools': [],
+    'Linting': [],
+    'TypeScript': [],
+    'Utilities': [],
+    'Other': [],
+  };
+
+  const patterns = {
+    'Backend': ['express', 'fastify', 'koa', 'hapi', 'nest', 'adonis', 'strapi'],
+    'Frontend': ['react', 'vue', 'angular', 'svelte', 'preact', 'lit'],
+    'Database': ['mongoose', 'sequelize', 'typeorm', 'prisma', 'knex', 'pg', 'mysql', 'mongodb'],
+    'Testing': ['jest', 'mocha', 'chai', 'vitest', 'cypress', 'playwright'],
+    'Build Tools': ['webpack', 'esbuild', 'vite', 'rollup', 'parcel', 'turbo', 'babel'],
+    'Linting': ['eslint', 'prettier', 'stylelint'],
+    'TypeScript': ['typescript', 'ts-node', 'tsx'],
+    'Utilities': ['lodash', 'axios', 'dotenv', 'chalk', 'commander', 'inquirer'],
+  };
+
+  for (const [dep] of Object.entries(deps)) {
+    let categorized = false;
+
+    for (const [category, keywords] of Object.entries(patterns)) {
+      if (keywords.some(keyword => dep.toLowerCase().includes(keyword))) {
+        categories[category].push(dep);
+        categorized = true;
+        break;
+      }
+    }
+
+    if (!categorized) {
+      categories['Other'].push(dep);
+    }
+  }
+
+  return categories;
+}
+
+async function analyzeDistFolder(dir) {
+  const distPath = path.join(process.cwd(), dir);
+
+  if (!(await fs.pathExists(distPath))) {
+    logger.info('');
+    logger.dim(`No ${dir} folder found. Run "easy build" first to analyze build output.`);
+    return;
+  }
+
+  logger.info('');
+  logger.section('Build Output Analysis');
+
+  const files = await getAllFiles(distPath);
+  let totalSize = 0;
+
+  for (const file of files) {
+    const stat = await fs.stat(file);
+    totalSize += stat.size;
+  }
+
+  logger.info(`Total files: ${files.length}`);
+  logger.info(`Total size: ${formatSize(totalSize)}`);
+
+  // Find largest files
+  const fileSizes = [];
+  for (const file of files) {
+    const stat = await fs.stat(file);
+    fileSizes.push({ file: path.relative(distPath, file), size: stat.size });
+  }
+
+  fileSizes.sort((a, b) => b.size - a.size);
+
+  if (fileSizes.length > 0) {
+    logger.info('');
+    logger.info('Largest files:');
+    fileSizes.slice(0, 10).forEach(({ file, size }) => {
+      logger.dim(`  ${file}: ${formatSize(size)}`);
+    });
+  }
+}
+
+async function getAllFiles(dir) {
+  const files = [];
+  const items = await fs.readdir(dir);
+
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    const stat = await fs.stat(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...await getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function formatSize(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];
+}
+
+module.exports = analyzeCommand;

package/src/commands/build.js

@@ -0,0 +1,80 @@
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+const ProjectDetector = require('../utils/detector');
+const ConfigLoader = require('../utils/config');
+const NodeBuilder = require('../targets/node');
+const FrontendBuilder = require('../targets/frontend');
+const ElectronBuilder = require('../targets/electron');
+const DockerBuilder = require('../targets/docker');
+const LibraryBuilder = require('../targets/library');
+
+const buildCommand = new Command('build')
+  .description('Build your project')
+  .option('-t, --target <target>', 'Build target (node, frontend, electron, docker, library)', 'auto')
+  .option('-p, --platform <platform>', 'Target platform (win, linux, mac, all)', 'current')
+  .option('--minify', 'Minify output', true)
+  .option('--sourcemap', 'Generate source maps', false)
+  .option('--analyze', 'Analyze bundle size', false)
+  .option('-o, --outDir <dir>', 'Output directory', 'dist')
+  .action(async (options) => {
+    logger.header('🔨 Building Project');
+
+    const detector = new ProjectDetector();
+    const config = new ConfigLoader();
+
+    try {
+      const projectInfo = await detector.detect();
+      const configData = await config.load();
+
+      logger.info(`Framework: ${projectInfo.framework?.name || 'Unknown'}`);
+      logger.info(`Type: ${projectInfo.type || 'Unknown'}`);
+      logger.info(`Bundler: ${projectInfo.bundler || 'Unknown'}`);
+      logger.info(`Target: ${options.target}`);
+
+      // Clean output directory if configured
+      if (configData.build.clean) {
+        await fs.remove(path.join(process.cwd(), options.outDir));
+      }
+
+      // Build based on target
+      let builder;
+      const target = options.target === 'auto' ? determineTarget(projectInfo) : options.target;
+
+      switch (target) {
+        case 'electron':
+          builder = new ElectronBuilder(projectInfo, configData);
+          break;
+        case 'docker':
+          builder = new DockerBuilder(projectInfo, configData);
+          break;
+        case 'library':
+          builder = new LibraryBuilder(projectInfo, configData);
+          break;
+        case 'frontend':
+          builder = new FrontendBuilder(projectInfo, configData);
+          break;
+        case 'node':
+        default:
+          builder = new NodeBuilder(projectInfo, configData);
+      }
+
+      await builder.build(options);
+
+      logger.success('Build completed successfully!');
+    } catch (error) {
+      logger.error(`Build failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+function determineTarget(projectInfo) {
+  if (projectInfo.type === 'desktop') return 'electron';
+  if (projectInfo.type === 'frontend') return 'frontend';
+  if (projectInfo.type === 'library') return 'library';
+  if (projectInfo.type === 'mobile') return 'frontend';
+  return 'node';
+}
+
+module.exports = buildCommand;

package/src/commands/clean.js

@@ -0,0 +1,109 @@
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+const cleanCommand = new Command('clean')
+  .description('Clean build artifacts and caches')
+  .option('-d, --dist', 'Clean dist folder', false)
+  .option('-n, --node-modules', 'Clean node_modules', false)
+  .option('-c, --cache', 'Clean cache', false)
+  .option('-a, --all', 'Clean everything', false)
+  .action(async (options) => {
+    logger.header('🧹 Cleaning Project');
+
+    try {
+      if (options.all || (!options.dist && !options.nodeModules && !options.cache)) {
+        // Clean everything by default
+        await cleanDist();
+        await cleanCache();
+        logger.success('Project cleaned!');
+      } else {
+        if (options.dist) await cleanDist();
+        if (options.nodeModules) await cleanNodeModules();
+        if (options.cache) await cleanCache();
+        logger.success('Selected items cleaned!');
+      }
+    } catch (error) {
+      logger.error(`Clean failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function cleanDist() {
+  const distPath = path.join(process.cwd(), 'dist');
+  const buildPath = path.join(process.cwd(), 'build');
+  const outPath = path.join(process.cwd(), 'out');
+  const releasePath = path.join(process.cwd(), 'release');
+
+  const paths = [distPath, buildPath, outPath, releasePath];
+
+  for (const p of paths) {
+    if (await fs.pathExists(p)) {
+      await fs.remove(p);
+      logger.info(`Removed: ${path.relative(process.cwd(), p)}`);
+    }
+  }
+}
+
+async function cleanNodeModules() {
+  const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+  const packageLockPath = path.join(process.cwd(), 'package-lock.json');
+  const yarnLockPath = path.join(process.cwd(), 'yarn.lock');
+  const pnpmLockPath = path.join(process.cwd(), 'pnpm-lock.yaml');
+
+  const paths = [nodeModulesPath, packageLockPath, yarnLockPath, pnpmLockPath];
+
+  for (const p of paths) {
+    if (await fs.pathExists(p)) {
+      await fs.remove(p);
+      logger.info(`Removed: ${path.relative(process.cwd(), p)}`);
+    }
+  }
+}
+
+async function cleanCache() {
+  // npm cache
+  const npmCachePath = path.join(process.cwd(), '.npm');
+  if (await fs.pathExists(npmCachePath)) {
+    await fs.remove(npmCachePath);
+    logger.info('Removed: .npm cache');
+  }
+
+  // ESLint cache
+  const eslintCachePath = path.join(process.cwd(), '.eslintcache');
+  if (await fs.pathExists(eslintCachePath)) {
+    await fs.remove(eslintCachePath);
+    logger.info('Removed: .eslintcache');
+  }
+
+  // TypeScript cache
+  const tsCachePath = path.join(process.cwd(), 'tsconfig.tsbuildinfo');
+  if (await fs.pathExists(tsCachePath)) {
+    await fs.remove(tsCachePath);
+    logger.info('Removed: tsconfig.tsbuildinfo');
+  }
+
+  // Vite cache
+  const viteCachePath = path.join(process.cwd(), 'node_modules/.vite');
+  if (await fs.pathExists(viteCachePath)) {
+    await fs.remove(viteCachePath);
+    logger.info('Removed: Vite cache');
+  }
+
+  // Next.js cache
+  const nextCachePath = path.join(process.cwd(), '.next');
+  if (await fs.pathExists(nextCachePath)) {
+    await fs.remove(nextCachePath);
+    logger.info('Removed: .next cache');
+  }
+
+  // Nuxt cache
+  const nuxtCachePath = path.join(process.cwd(), '.nuxt');
+  if (await fs.pathExists(nuxtCachePath)) {
+    await fs.remove(nuxtCachePath);
+    logger.info('Removed: .nuxt cache');
+  }
+}
+
+module.exports = cleanCommand;

package/src/commands/config.js

@@ -0,0 +1,104 @@
+const { Command } = require('commander');
+const logger = require('../utils/logger');
+const globalConfig = require('../utils/globalConfig');
+
+const configCommand = new Command('config')
+  .description('Manage global easy-build configuration')
+  .option('-g, --get <key>', 'Get config value')
+  .option('--enable-shared', 'Enable shared modules globally')
+  .option('--disable-shared', 'Disable shared modules globally')
+  .option('--show', 'Show current configuration')
+  .action(async (options) => {
+    logger.header('⚙️  Global Configuration');
+
+    try {
+      await globalConfig.load();
+
+      if (options.show) {
+        await showConfig();
+      } else if (options.enableShared) {
+        await globalConfig.enableSharedModules();
+      } else if (options.disableShared) {
+        await globalConfig.disableSharedModules();
+      } else if (options.get) {
+        const value = globalConfig.get(options.get);
+        if (value !== undefined) {
+          console.log(JSON.stringify(value, null, 2));
+        } else {
+          logger.warning(`Key "${options.get}" not found`);
+        }
+      } else {
+        await showConfig();
+      }
+    } catch (error) {
+      logger.error(`Config operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+configCommand
+  .command('set <key> <value>')
+  .description('Set a config value')
+  .action(async (key, value) => {
+    logger.header('⚙️  Global Configuration');
+
+    try {
+      await globalConfig.load();
+      globalConfig.set(key, parseValue(value));
+      await globalConfig.save();
+      logger.success(`Set ${key} = ${value}`);
+    } catch (error) {
+      logger.error(`Config operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function showConfig() {
+  const config = await globalConfig.load();
+
+  logger.section('Current Configuration');
+  logger.info(`Config file: ${globalConfig.getConfigPath()}`);
+  logger.info('');
+
+  // Shared Modules
+  logger.bold('Shared Modules:');
+  logger.dim(`  enabled: ${config.sharedModules?.enabled || false}`);
+  logger.dim(`  autoSync: ${config.sharedModules?.autoSync || false}`);
+  logger.dim(`  autoInstall: ${config.sharedModules?.autoInstall || true}`);
+  logger.info('');
+
+  // Build
+  logger.bold('Build:');
+  logger.dim(`  minify: ${config.build?.minify || true}`);
+  logger.dim(`  sourcemap: ${config.build?.sourcemap || false}`);
+  logger.dim(`  outDir: ${config.build?.outDir || 'dist'}`);
+  logger.info('');
+
+  // Dev
+  logger.bold('Dev Server:');
+  logger.dim(`  port: ${config.dev?.port || 3000}`);
+  logger.dim(`  host: ${config.dev?.host || 'localhost'}`);
+  logger.dim(`  open: ${config.dev?.open || true}`);
+  logger.info('');
+
+  // Tips
+  logger.section('Quick Commands');
+  logger.dim('  easy config --enable-shared   Enable shared modules');
+  logger.dim('  easy config --disable-shared  Disable shared modules');
+  logger.dim('  easy config -s build.minify false  Disable minification');
+}
+
+function parseValue(value) {
+  // Parse boolean
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+
+  // Parse number
+  const num = Number(value);
+  if (!isNaN(num)) return num;
+
+  // Return string
+  return value;
+}
+
+module.exports = configCommand;