easybuild-nox 1.0.0

package/src/commands/dev.js

@@ -0,0 +1,188 @@
+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 sharedModules = require('../utils/modules');
+const globalConfig = require('../utils/globalConfig');
+
+const devCommand = new Command('dev')
+  .description('Start development server with hot reload')
+  .option('-p, --port <port>', 'Port number', '3000')
+  .option('-h, --host <host>', 'Host address', 'localhost')
+  .option('--open', 'Open browser', true)
+  .option('--no-shared', 'Disable shared modules for this run')
+  .action(async (options) => {
+    logger.header('⚡ Starting Development Server');
+
+    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(`Port: ${options.port}`);
+
+      // Use shared modules by default (unless --no-shared is passed)
+      if (options.shared !== false) {
+        await sharedModules.init();
+        const configData = await globalConfig.load();
+        const useShared = configData.sharedModules?.enabled !== false;
+
+        if (useShared) {
+          const packageJsonPath = path.join(process.cwd(), 'package.json');
+          if (await fs.pathExists(packageJsonPath)) {
+            logger.dim('Using shared modules...');
+            await sharedModules.installFromPackageJson(packageJsonPath);
+            await setupNodePath();
+          }
+        }
+      }
+
+      // Set environment
+      process.env.NODE_ENV = 'development';
+      process.env.PORT = options.port;
+      process.env.HOST = options.host;
+
+      await startDevServer(projectInfo, configData, options);
+    } catch (error) {
+      logger.error(`Failed to start dev server: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function startDevServer(projectInfo, config, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const scripts = pkg.scripts || {};
+
+  let command = null;
+  let args = [];
+
+  if (projectInfo.framework) {
+    const devCommands = {
+      // Backend
+      express: { command: 'nodemon', args: ['src/index.js'] },
+      fastify: { command: 'nodemon', args: ['src/index.js'] },
+      koa: { command: 'nodemon', args: ['src/index.js'] },
+      hapi: { command: 'nodemon', args: ['src/index.js'] },
+      nestjs: { command: 'npm', args: ['run', 'start:dev'] },
+      adonis: { command: 'npm', args: ['run', 'dev'] },
+      strapi: { command: 'npm', args: ['run', 'develop'] },
+      hono: { command: 'npm', args: ['run', 'dev'] },
+      trpc: { command: 'npm', args: ['run', 'dev'] },
+      graphql: { command: 'npm', args: ['run', 'dev'] },
+      socketio: { command: 'npm', args: ['run', 'dev'] },
+
+      // Frontend
+      react: { command: 'npm', args: ['start'] },
+      vue: { command: 'npm', args: ['run', 'serve'] },
+      angular: { command: 'ng', args: ['serve'] },
+      svelte: { command: 'npm', args: ['run', 'dev'] },
+      solid: { command: 'npm', args: ['run', 'dev'] },
+      preact: { command: 'npm', args: ['run', 'dev'] },
+      lit: { command: 'npm', args: ['run', 'dev'] },
+      alpine: { command: 'npm', args: ['run', 'dev'] },
+      htmx: { command: 'npm', args: ['run', 'dev'] },
+
+      // Full-stack
+      nextjs: { command: 'npm', args: ['run', 'dev'] },
+      nuxt: { command: 'npm', args: ['run', 'dev'] },
+      remix: { command: 'npm', args: ['run', 'dev'] },
+      gatsby: { command: 'npm', args: ['run', 'develop'] },
+      astro: { command: 'npm', args: ['run', 'dev'] },
+      sveltekit: { command: 'npm', args: ['run', 'dev'] },
+      solidstart: { command: 'npm', args: ['run', 'dev'] },
+      qwik: { command: 'npm', args: ['run', 'dev'] },
+      analog: { command: 'npm', args: ['run', 'dev'] },
+      fresh: { command: 'deno', args: ['task', 'dev'] },
+      tanstack: { command: 'npm', args: ['run', 'dev'] },
+      waku: { command: 'npm', args: ['run', 'dev'] },
+
+      // Desktop
+      electron: { command: 'npm', args: ['run', 'dev'] },
+      tauri: { command: 'npm', args: ['run', 'dev'] },
+      nwjs: { command: 'npm', args: ['run', 'dev'] },
+
+      // Mobile
+      reactnative: { command: 'npm', args: ['start'] },
+      expo: { command: 'npm', args: ['start'] },
+      ionic: { command: 'npm', args: ['start'] },
+      tamagui: { command: 'npm', args: ['start'] },
+      nativebase: { command: 'npm', args: ['start'] },
+
+      // Database
+      drizzle: { command: 'npm', args: ['run', 'dev'] },
+      prisma: { command: 'npm', args: ['run', 'dev'] },
+    };
+
+    const devConfig = devCommands[projectInfo.framework.name];
+    if (devConfig) {
+      command = devConfig.command;
+      args = devConfig.args;
+    }
+  }
+
+  // Fallback to package.json scripts
+  if (!command) {
+    if (scripts.dev) {
+      command = 'npm';
+      args = ['run', 'dev'];
+    } else if (scripts['start:dev']) {
+      command = 'npm';
+      args = ['run', 'start:dev'];
+    } else if (scripts.serve) {
+      command = 'npm';
+      args = ['run', 'serve'];
+    } else {
+      throw new Error('No dev script found. Add a "dev" script to package.json');
+    }
+  }
+
+  logger.info(`Starting: ${command} ${args.join(' ')}`);
+  logger.dim('Press Ctrl+C to stop');
+  logger.info('');
+
+  const child = spawn(command, args, {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      NODE_ENV: 'development',
+      PORT: options.port,
+      HOST: options.host,
+    },
+  });
+
+  child.on('error', (error) => {
+    logger.error(`Process failed: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      logger.error(`Process exited with code ${code}`);
+      process.exit(code);
+    }
+  });
+}
+
+async function setupNodePath() {
+  const sharedPath = sharedModules.getSharedModulesPath();
+  const currentPath = process.env.NODE_PATH || '';
+  
+  if (!currentPath.includes(sharedPath)) {
+    process.env.NODE_PATH = currentPath
+      ? `${sharedPath}${path.delimiter}${currentPath}`
+      : sharedPath;
+    
+    // Rehash require paths
+    require('module')._initPaths();
+  }
+}
+
+module.exports = devCommand;

package/src/commands/docker.js

@@ -0,0 +1,264 @@
+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 dockerCommand = new Command('docker')
+  .description('Docker operations')
+  .option('-a, --action <action>', 'Action (build, run, stop, logs, push)', 'build')
+  .option('-t, --tag <tag>', 'Docker image tag', 'latest')
+  .option('-p, --port <port>', 'Port mapping', '3000')
+  .action(async (options) => {
+    logger.header('🐳 Docker Operations');
+
+    const detector = new ProjectDetector();
+    const config = new ConfigLoader();
+
+    try {
+      const projectInfo = await detector.detect();
+      const configData = await config.load();
+
+      logger.info(`Action: ${options.action}`);
+      logger.info(`Tag: ${options.tag}`);
+
+      await dockerOperation(projectInfo, configData, options);
+    } catch (error) {
+      logger.error(`Docker operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function dockerOperation(projectInfo, config, options) {
+  // Ensure Dockerfile exists
+  const dockerfilePath = path.join(process.cwd(), 'Dockerfile');
+  if (!(await fs.pathExists(dockerfilePath))) {
+    logger.warning('No Dockerfile found. Generating one...');
+    await generateDockerfile(projectInfo, config);
+  }
+
+  const actions = {
+    build: dockerBuild,
+    run: dockerRun,
+    stop: dockerStop,
+    logs: dockerLogs,
+    push: dockerPush,
+    compose: dockerCompose,
+  };
+
+  const action = actions[options.action];
+  if (!action) {
+    throw new Error(`Unknown action: ${options.action}`);
+  }
+
+  await action(projectInfo, config, options);
+}
+
+async function generateDockerfile(projectInfo, config) {
+  const dockerConfig = config.docker || {};
+  const baseImage = dockerConfig.baseImage || 'node:20-alpine';
+  const workdir = dockerConfig.workdir || '/app';
+  const port = dockerConfig.port || 3000;
+
+  const dockerfile = `# Use Node.js alpine image
+FROM ${baseImage} AS builder
+
+# Set working directory
+WORKDIR ${workdir}
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy source code
+COPY . .
+
+# Build application (if needed)
+RUN npm run build 2>/dev/null || true
+
+# Production stage
+FROM ${baseImage}
+
+# Set working directory
+WORKDIR ${workdir}
+
+# Copy package files
+COPY package*.json ./
+
+# Install production dependencies only
+RUN npm ci --only=production
+
+# Copy built application
+COPY --from=builder ${workdir}/dist ./dist
+COPY --from=builder ${workdir}/src ./src
+
+# Expose port
+EXPOSE ${port}
+
+# Start application
+CMD ["node", "src/index.js"]
+`;
+
+  await fs.writeFile(dockerfilePath, dockerfile);
+  logger.success('Dockerfile generated');
+}
+
+async function dockerBuild(projectInfo, config, options) {
+  logger.info('Building Docker image...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+
+  const child = spawn('docker', ['build', '-t', `${imageName}:${options.tag}`, '.'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`Docker image built: ${imageName}:${options.tag}`);
+        resolve();
+      } else {
+        reject(new Error('Docker build failed'));
+      }
+    });
+  });
+}
+
+async function dockerRun(projectInfo, config, options) {
+  logger.info('Running Docker container...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+  const containerName = `${imageName}-container`;
+
+  // Stop existing container if running
+  try {
+    await new Promise((resolve) => {
+      const stop = spawn('docker', ['stop', containerName], {
+        shell: true,
+      });
+      stop.on('close', () => resolve());
+    });
+  } catch (e) {
+    // Ignore if container doesn't exist
+  }
+
+  const child = spawn('docker', [
+    'run', '-d',
+    '--name', containerName,
+    '-p', `${options.port}:3000`,
+    `${imageName}:${options.tag}`,
+  ], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`Container running on port ${options.port}`);
+        resolve();
+      } else {
+        reject(new Error('Docker run failed'));
+      }
+    });
+  });
+}
+
+async function dockerStop(projectInfo, config, options) {
+  logger.info('Stopping Docker container...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+  const containerName = `${imageName}-container`;
+
+  const child = spawn('docker', ['stop', containerName], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Container stopped');
+        resolve();
+      } else {
+        reject(new Error('Docker stop failed'));
+      }
+    });
+  });
+}
+
+async function dockerLogs(projectInfo, config, options) {
+  logger.info('Showing Docker logs...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+  const containerName = `${imageName}-container`;
+
+  const child = spawn('docker', ['logs', '-f', containerName], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error('Docker logs failed'));
+      }
+    });
+  });
+}
+
+async function dockerPush(projectInfo, config, options) {
+  logger.info('Pushing Docker image...');
+
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const imageName = pkg.name || 'app';
+
+  const child = spawn('docker', ['push', `${imageName}:${options.tag}`], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Image pushed successfully');
+        resolve();
+      } else {
+        reject(new Error('Docker push failed'));
+      }
+    });
+  });
+}
+
+async function dockerCompose(projectInfo, config, options) {
+  logger.info('Running Docker Compose...');
+
+  const child = spawn('docker-compose', ['up', '-d'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Docker Compose started');
+        resolve();
+      } else {
+        reject(new Error('Docker Compose failed'));
+      }
+    });
+  });
+}
+
+module.exports = dockerCommand;

package/src/commands/electron.js

@@ -0,0 +1,210 @@
+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 electronCommand = new Command('electron')
+  .description('Electron operations')
+  .option('-a, --action <action>', 'Action (dev, build, pack)', 'dev')
+  .option('-p, --platform <platform>', 'Target platform (win, mac, linux, all)', 'current')
+  .option('--arch <arch>', 'Target architecture (x64, arm64, all)', 'current')
+  .action(async (options) => {
+    logger.header('⚡ Electron Operations');
+
+    const detector = new ProjectDetector();
+    const config = new ConfigLoader();
+
+    try {
+      const projectInfo = await detector.detect();
+      const configData = await config.load();
+
+      logger.info(`Action: ${options.action}`);
+      logger.info(`Platform: ${options.platform}`);
+
+      await electronOperation(projectInfo, configData, options);
+    } catch (error) {
+      logger.error(`Electron operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function electronOperation(projectInfo, config, options) {
+  // Ensure electron config exists
+  const electronConfig = config.electron || {};
+
+  // Check if electron-builder config exists
+  const builderConfigPath = path.join(process.cwd(), 'electron-builder.yml');
+  const builderJsonPath = path.join(process.cwd(), 'electron-builder.json');
+
+  if (!(await fs.pathExists(builderConfigPath)) && !(await fs.pathExists(builderJsonPath))) {
+    logger.warning('No electron-builder config found. Generating one...');
+    await generateElectronConfig(projectInfo, config);
+  }
+
+  const actions = {
+    dev: electronDev,
+    build: electronBuild,
+    pack: electronPack,
+  };
+
+  const action = actions[options.action];
+  if (!action) {
+    throw new Error(`Unknown action: ${options.action}`);
+  }
+
+  await action(projectInfo, config, options);
+}
+
+async function generateElectronConfig(projectInfo, config) {
+  const electronConfig = config.electron || {};
+
+  const builderConfig = {
+    appId: `com.${projectInfo.packageJson?.name || 'app'}.electron`,
+    productName: projectInfo.packageJson?.name || 'Electron App',
+    directories: {
+      output: electronConfig.output || 'release',
+    },
+    files: [
+      'electron/**/*',
+      'dist/**/*',
+      'package.json',
+    ],
+    mac: {
+      category: 'public.app-category.developer-tools',
+      icon: electronConfig.icon || null,
+      target: [
+        { target: 'dmg', arch: ['x64', 'arm64'] },
+        { target: 'zip', arch: ['x64', 'arm64'] },
+      ],
+    },
+    win: {
+      icon: electronConfig.icon || null,
+      target: [
+        { target: 'nsis', arch: ['x64'] },
+        { target: 'portable', arch: ['x64'] },
+      ],
+    },
+    linux: {
+      icon: electronConfig.icon || null,
+      target: [
+        { target: 'AppImage', arch: ['x64'] },
+        { target: 'deb', arch: ['x64'] },
+        { target: 'rpm', arch: ['x64'] },
+      ],
+      category: 'Development',
+    },
+    nsis: {
+      oneClick: false,
+      allowToChangeInstallationDirectory: true,
+    },
+  };
+
+  await fs.writeFile(
+    path.join(process.cwd(), 'electron-builder.yml'),
+    require('js-yaml').dump(builderConfig)
+  );
+
+  logger.success('electron-builder.yml generated');
+}
+
+async function electronDev(projectInfo, config, options) {
+  logger.info('Starting Electron in development mode...');
+
+  // Check if electron is installed
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  if (!pkg.devDependencies?.electron && !pkg.dependencies?.electron) {
+    logger.info('Installing Electron...');
+    await new Promise((resolve, reject) => {
+      const install = spawn('npm', ['install', 'electron', '--save-dev'], {
+        stdio: 'inherit',
+        shell: true,
+      });
+      install.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error('Failed to install Electron'));
+      });
+    });
+  }
+
+  const child = spawn('electron', ['.'], {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      NODE_ENV: 'development',
+    },
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error('Electron dev failed'));
+      }
+    });
+  });
+}
+
+async function electronBuild(projectInfo, config, options) {
+  logger.info('Building Electron application...');
+
+  const args = ['electron-builder'];
+
+  // Platform
+  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');
+  }
+
+  // Architecture
+  if (options.arch && options.arch !== 'current') {
+    args.push(`--${options.arch}`);
+  }
+
+  const child = spawn('npx', args, {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Electron build completed!');
+        resolve();
+      } else {
+        reject(new Error('Electron build failed'));
+      }
+    });
+  });
+}
+
+async function electronPack(projectInfo, config, options) {
+  logger.info('Packaging Electron application...');
+
+  const child = spawn('npx', ['electron-builder', '--dir'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Electron packaging completed!');
+        resolve();
+      } else {
+        reject(new Error('Electron packaging failed'));
+      }
+    });
+  });
+}
+
+module.exports = electronCommand;