easybuild-nox 1.0.0

package/src/commands/lint.js

@@ -0,0 +1,111 @@
+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 lintCommand = new Command('lint')
+  .description('Run linting and formatting')
+  .option('-f, --fix', 'Auto-fix issues', false)
+  .option('-p, --prettier', 'Run Prettier', false)
+  .option('-e, --eslint', 'Run ESLint', false)
+  .option('-a, --all', 'Run all linters', false)
+  .action(async (options) => {
+    logger.header('🔍 Linting Project');
+
+    const detector = new ProjectDetector();
+
+    try {
+      const projectInfo = await detector.detect();
+
+      if (options.all || (!options.prettier && !options.eslint)) {
+        // Run all linters
+        await runESLint(projectInfo, options);
+        await runPrettier(projectInfo, options);
+      } else {
+        if (options.eslint) await runESLint(projectInfo, options);
+        if (options.prettier) await runPrettier(projectInfo, options);
+      }
+
+      logger.success('Linting completed!');
+    } catch (error) {
+      logger.error(`Linting failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function runESLint(projectInfo, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  if (!deps.eslint) {
+    logger.dim('ESLint not installed, skipping...');
+    return;
+  }
+
+  logger.info('Running ESLint...');
+
+  const args = ['eslint', '.'];
+  if (options.fix) args.push('--fix');
+
+  const child = spawn('npx', args, {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('ESLint passed!');
+        resolve();
+      } else if (code === 1) {
+        logger.warning('ESLint found issues');
+        resolve(); // Don't fail, just warn
+      } else {
+        reject(new Error('ESLint failed'));
+      }
+    });
+  });
+}
+
+async function runPrettier(projectInfo, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  if (!deps.prettier) {
+    logger.dim('Prettier not installed, skipping...');
+    return;
+  }
+
+  logger.info('Running Prettier...');
+
+  const args = ['prettier', '--write', '.'];
+  if (!options.fix) {
+    args[2] = '--check';
+  }
+
+  const child = spawn('npx', args, {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Prettier passed!');
+        resolve();
+      } else {
+        reject(new Error('Prettier failed'));
+      }
+    });
+  });
+}
+
+module.exports = lintCommand;

package/src/commands/modules.js

@@ -0,0 +1,333 @@
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const { spawn } = require('child_process');
+const logger = require('../utils/logger');
+const sharedModules = require('../utils/modules');
+
+const modulesCommand = new Command('modules')
+  .description('Manage shared modules (saves disk space!)')
+  .option('-a, --action <action>', 'Action (install, update, list, clean, sync, stats)', 'list')
+  .option('-n, --name <name>', 'Module name for specific operations')
+  .option('-f, --force', 'Force reinstall/update', false)
+  .action(async (options) => {
+    logger.header('📦 Shared Modules Manager');
+
+    try {
+      await sharedModules.init();
+
+      // Check if using sub-commands (handled by commander)
+      if (options.args && options.args.length > 0) {
+        return; // Let commander handle sub-commands
+      }
+
+      const actions = {
+        install: modulesInstall,
+        update: modulesUpdate,
+        list: modulesList,
+        clean: modulesClean,
+        sync: modulesSync,
+        stats: modulesStats,
+      };
+
+      const action = actions[options.action];
+      if (!action) {
+        logger.error(`Unknown action: ${options.action}`);
+        process.exit(1);
+      }
+
+      await action(options);
+    } catch (error) {
+      logger.error(`Modules operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function modulesInstall(options) {
+  logger.section('Installing Modules');
+
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    logger.error('No package.json found in current directory');
+    process.exit(1);
+  }
+
+  if (options.name) {
+    // Install specific module
+    logger.info(`Installing ${options.name}...`);
+    const result = await sharedModules.installModule(options.name, '*', { force: options.force });
+
+    if (result.installed) {
+      logger.success(`${options.name} installed to shared modules`);
+    } else if (result.cached) {
+      logger.info(`${options.name} already exists in shared modules`);
+    } else {
+      logger.error(`Failed to install ${options.name}`);
+    }
+  } else {
+    // Install all from package.json
+    const results = await sharedModules.installFromPackageJson(packageJsonPath, { force: options.force });
+
+    logger.info('');
+    logger.section('Installation Summary');
+    logger.success(`Newly installed: ${results.installed}`);
+    logger.info(`Already cached: ${results.cached}`);
+    if (results.failed > 0) {
+      logger.error(`Failed: ${results.failed}`);
+    }
+
+    // Create symlink in project
+    await createModuleSymlink();
+  }
+}
+
+async function modulesUpdate(options) {
+  logger.section('Updating Modules');
+
+  if (options.name) {
+    // Update specific module
+    logger.info(`Updating ${options.name}...`);
+    const result = await sharedModules.updateModule(options.name, { force: options.force });
+
+    if (result.updated) {
+      logger.success(`${options.name} updated successfully`);
+    }
+  } else {
+    // Update all modules
+    const results = await sharedModules.updateAllModules({ force: options.force });
+
+    logger.info('');
+    logger.section('Update Summary');
+    logger.success(`Updated: ${results.updated}`);
+    if (results.failed > 0) {
+      logger.error(`Failed: ${results.failed}`);
+    }
+  }
+}
+
+async function modulesList(options) {
+  const modules = await sharedModules.listModules();
+  const moduleList = Object.values(modules);
+
+  if (moduleList.length === 0) {
+    logger.info('No shared modules installed yet');
+    logger.info('Run: easy modules install');
+    return;
+  }
+
+  logger.section('Shared Modules');
+
+  // Group by first letter
+  const grouped = {};
+  for (const mod of moduleList) {
+    const firstLetter = mod.name[0].toUpperCase();
+    if (!grouped[firstLetter]) grouped[firstLetter] = [];
+    grouped[firstLetter].push(mod);
+  }
+
+  // Display grouped
+  for (const [letter, mods] of Object.entries(grouped).sort()) {
+    logger.bold(`\n${letter}:`);
+    for (const mod of mods) {
+      logger.dim(`  ${mod.name}@${mod.version}`);
+    }
+  }
+
+  logger.info('');
+  logger.dim(`Total: ${moduleList.length} modules`);
+}
+
+async function modulesClean(options) {
+  logger.section('Cleaning Unused Modules');
+
+  const results = await sharedModules.cleanUnused();
+
+  logger.info('');
+  logger.section('Clean Summary');
+  logger.success(`Removed: ${results.removed} modules`);
+  logger.info(`Kept: ${results.kept} modules`);
+}
+
+async function modulesSync(options) {
+  logger.section('Syncing Project Dependencies');
+
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    logger.error('No package.json found in current directory');
+    process.exit(1);
+  }
+
+  // Install all dependencies from package.json
+  const results = await sharedModules.installFromPackageJson(packageJsonPath, { force: options.force });
+
+  // Create symlink
+  await createModuleSymlink();
+
+  logger.info('');
+  logger.section('Sync Summary');
+  logger.success(`Synced ${results.installed + results.cached} modules`);
+  logger.info('Project now uses shared modules');
+}
+
+async function modulesStats(options) {
+  const stats = await sharedModules.getStats();
+
+  logger.section('Shared Modules Statistics');
+
+  logger.info(`Modules installed: ${stats.moduleCount}`);
+  logger.info(`Total disk usage: ${formatSize(stats.totalSize)}`);
+  logger.info(`Shared location: ${stats.sharedPath}`);
+
+  if (stats.lastUpdate) {
+    logger.info(`Last updated: ${new Date(stats.lastUpdate).toLocaleString()}`);
+  }
+
+  // Calculate savings
+  const estimatedPerProject = stats.moduleCount * 2 * 1024 * 1024; // ~2MB per module average
+  const potentialSavings = estimatedPerProject - stats.totalSize;
+
+  if (potentialSavings > 0) {
+    logger.info('');
+    logger.success(`Estimated disk savings: ${formatSize(potentialSavings)}`);
+    logger.dim('(vs having modules in each project)');
+  }
+}
+
+async function modulesLink(options) {
+  logger.section('Linking Local Modules');
+
+  const results = await sharedModules.linkFromLocal();
+
+  logger.info('');
+  logger.section('Link Summary');
+  logger.success(`Linked: ${results.linked} modules`);
+  logger.info(`Skipped (already exists): ${results.skipped} modules`);
+}
+
+async function modulesOpen(options) {
+  const modulesPath = sharedModules.getSharedModulesPath();
+  
+  logger.info(`Opening: ${modulesPath}`);
+  
+  // Open in file manager based on platform
+  const platform = process.platform;
+  let command;
+  
+  if (platform === 'darwin') {
+    command = 'open';
+  } else if (platform === 'win32') {
+    command = 'explorer';
+  } else {
+    command = 'xdg-open';
+  }
+  
+  try {
+    spawn(command, [modulesPath], { 
+      stdio: 'ignore',
+      detached: true 
+    }).unref();
+    logger.success('Opened modules folder!');
+  } catch (error) {
+    logger.dim(`Could not open folder automatically`);
+    logger.info(`Manually navigate to: ${modulesPath}`);
+  }
+}
+
+async function createModuleSymlink() {
+  const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+  const sharedPath = sharedModules.getSharedModulesPath();
+
+  // Check if node_modules already exists
+  if (await fs.pathExists(nodeModulesPath)) {
+    const stat = await fs.lstat(nodeModulesPath);
+    if (stat.isSymbolicLink()) {
+      // Already a symlink, update it
+      await fs.remove(nodeModulesPath);
+    } else {
+      // It's a real directory, don't overwrite
+      logger.dim('node_modules directory exists, skipping symlink creation');
+      return;
+    }
+  }
+
+  // Create symlink
+  try {
+    await fs.symlink(sharedPath, nodeModulesPath, 'junction');
+    logger.dim('Created symlink: node_modules -> shared modules');
+  } catch (error) {
+    // Fallback: copy package.json references
+    logger.dim('Could not create symlink, using NODE_PATH instead');
+  }
+}
+
+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];
+}
+
+// Add sub-commands
+modulesCommand
+  .command('install [name]')
+  .description('Install modules to shared folder')
+  .option('-f, --force', 'Force reinstall')
+  .action(async (name, options) => {
+    await modulesInstall({ name, force: options.force });
+  });
+
+modulesCommand
+  .command('update [name]')
+  .description('Update modules')
+  .option('-f, --force', 'Force update')
+  .action(async (name, options) => {
+    await modulesUpdate({ name, force: options.force });
+  });
+
+modulesCommand
+  .command('list')
+  .description('List installed modules')
+  .action(async () => {
+    await modulesList({});
+  });
+
+modulesCommand
+  .command('clean')
+  .description('Remove unused modules')
+  .action(async () => {
+    await modulesClean({});
+  });
+
+modulesCommand
+  .command('sync')
+  .description('Sync project dependencies to shared modules')
+  .option('-f, --force', 'Force sync')
+  .action(async (options) => {
+    await modulesSync({ force: options.force });
+  });
+
+modulesCommand
+  .command('stats')
+  .description('Show disk usage statistics')
+  .action(async () => {
+    await modulesStats({});
+  });
+
+modulesCommand
+  .command('link')
+  .description('Link local node_modules to shared folder')
+  .action(async () => {
+    await modulesLink({});
+  });
+
+modulesCommand
+  .command('open')
+  .description('Open shared modules folder')
+  .action(async () => {
+    await modulesOpen({});
+  });
+
+module.exports = modulesCommand;

package/src/commands/package.js

@@ -0,0 +1,265 @@
+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 ConfigLoader = require('../utils/config');
+
+const packageCommand = new Command('package')
+  .description('Package your application for distribution')
+  .option('-t, --type <type>', 'Package type (bin, app, docker, npm)', 'bin')
+  .option('-p, --platform <platform>', 'Target platform (win, linux, mac, current)', 'current')
+  .option('--arch <arch>', 'Target architecture (x64, arm64, all)', 'x64')
+  .option('-o, --output <dir>', 'Output directory', 'dist')
+  .action(async (options) => {
+    logger.header('📦 Packaging Application');
+
+    const detector = new ProjectDetector();
+    const config = new ConfigLoader();
+
+    try {
+      const projectInfo = await detector.detect();
+      const configData = await config.load();
+
+      logger.info(`Type: ${options.type}`);
+      logger.info(`Platform: ${options.platform}`);
+      logger.info(`Architecture: ${options.arch}`);
+
+      await packageApp(projectInfo, configData, options);
+    } catch (error) {
+      logger.error(`Packaging failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function packageApp(projectInfo, config, options) {
+  const types = {
+    bin: packageAsBinary,
+    app: packageAsApp,
+    docker: packageAsDocker,
+    npm: packageAsNpm,
+    single: packageAsSingleFile,
+  };
+
+  const packager = types[options.type];
+  if (!packager) {
+    throw new Error(`Unknown package type: ${options.type}`);
+  }
+
+  await packager(projectInfo, config, options);
+}
+
+async function packageAsBinary(projectInfo, config, options) {
+  logger.info('Packaging as standalone binary...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const entryPoint = pkg.main || 'src/index.js';
+
+  // Ensure pkg is available
+  try {
+    require.resolve('pkg');
+  } catch {
+    logger.info('Installing pkg...');
+    await new Promise((resolve, reject) => {
+      const install = spawn('npm', ['install', 'pkg', '--save-dev'], {
+        stdio: 'inherit',
+        shell: true,
+      });
+      install.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error('Failed to install pkg'));
+      });
+    });
+  }
+
+  const platforms = {
+    win: 'win',
+    linux: 'linux',
+    mac: 'macos',
+    current: process.platform === 'win32' ? 'win' : process.platform === 'darwin' ? 'macos' : 'linux',
+  };
+
+  const target = platforms[options.platform] || 'linux';
+  const arch = options.arch === 'all' ? 'x64' : options.arch;
+
+  const args = [
+    'pkg',
+    entryPoint,
+    '--targets',
+    `${target}-${arch}`,
+    '--output',
+    `${options.output}/${pkg.name}`,
+  ];
+
+  const child = spawn('npx', args, {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`Binary packaged: ${options.output}/${pkg.name}`);
+        resolve();
+      } else {
+        reject(new Error('Binary packaging failed'));
+      }
+    });
+  });
+}
+
+async function packageAsApp(projectInfo, config, options) {
+  logger.info('Packaging as application...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+
+  // Check if it's an Electron app
+  if (projectInfo.type === 'desktop' || pkg.dependencies?.electron || pkg.devDependencies?.electron) {
+    // Use electron-builder
+    const args = ['electron-builder'];
+
+    if (options.platform === 'all') {
+      args.push('-mwl');
+    } else if (options.platform === 'win') {
+      args.push('--win');
+    } else if (options.platform === 'mac') {
+      args.push('--mac');
+    } else if (options.platform === 'linux') {
+      args.push('--linux');
+    }
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Application packaged!');
+          resolve();
+        } else {
+          reject(new Error('Application packaging failed'));
+        }
+      });
+    });
+  }
+
+  // For Node.js apps, use pkg
+  await packageAsBinary(projectInfo, config, options);
+}
+
+async function packageAsDocker(projectInfo, config, options) {
+  logger.info('Packaging as Docker image...');
+
+  // Ensure Dockerfile exists
+  const dockerfilePath = path.join(process.cwd(), 'Dockerfile');
+  if (!(await fs.pathExists(dockerfilePath))) {
+    logger.warning('No Dockerfile found. Please run: easy docker build');
+    return;
+  }
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+
+  const child = spawn('docker', ['build', '-t', `${imageName}:latest`, '.'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`Docker image packaged: ${imageName}:latest`);
+        resolve();
+      } else {
+        reject(new Error('Docker packaging failed'));
+      }
+    });
+  });
+}
+
+async function packageAsNpm(projectInfo, config, options) {
+  logger.info('Packaging for npm...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+
+  // Ensure package is ready for publishing
+  const requiredFields = ['name', 'version', 'main'];
+  const missing = requiredFields.filter(field => !pkg[field]);
+
+  if (missing.length > 0) {
+    logger.error(`Missing required fields in package.json: ${missing.join(', ')}`);
+    return;
+  }
+
+  // Build if needed
+  if (pkg.scripts?.build) {
+    logger.info('Building package...');
+    await new Promise((resolve, reject) => {
+      const build = spawn('npm', ['run', 'build'], {
+        stdio: 'inherit',
+        shell: true,
+      });
+      build.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error('Build failed'));
+      });
+    });
+  }
+
+  // Pack
+  const child = spawn('npm', ['pack'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Package created for npm!');
+        resolve();
+      } else {
+        reject(new Error('npm pack failed'));
+      }
+    });
+  });
+}
+
+async function packageAsSingleFile(projectInfo, config, options) {
+  logger.info('Packaging as single executable...');
+
+  // Use Node.js SEA (Single Executable Application) if available
+  logger.info('Note: Single Executable Application requires Node.js 20+');
+  logger.info('Building...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const entryPoint = pkg.main || 'src/index.js';
+
+  // Bundle with esbuild first
+  const child = spawn('npx', [
+    'esbuild',
+    entryPoint,
+    '--bundle',
+    '--platform=node',
+    '--target=node20',
+    `--outfile=${options.output}/bundle.js`,
+  ], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`Single file packaged: ${options.output}/bundle.js`);
+        resolve();
+      } else {
+        reject(new Error('Single file packaging failed'));
+      }
+    });
+  });
+}
+
+module.exports = packageCommand;