easybuild-nox 1.0.0

package/src/commands/proxy.js

@@ -0,0 +1,73 @@
+const { Command } = require('commander');
+const http = require('http');
+const https = require('https');
+const url = require('url');
+const logger = require('../utils/logger');
+
+const proxyCommand = new Command('proxy')
+  .description('Start a proxy server for development')
+  .option('-p, --port <port>', 'Port number', '8080')
+  .option('-t, --target <target>', 'Target URL to proxy to', 'http://localhost:3000')
+  .option('-c, --cors', 'Enable CORS', true)
+  .option('-l, --log', 'Log requests', true)
+  .action(async (options) => {
+    logger.header('🔄 Proxy Server');
+    logger.info(`Proxying to: ${options.target}`);
+    logger.info(`Listening on: http://localhost:${options.port}`);
+    logger.dim('Press Ctrl+C to stop');
+    logger.info('');
+
+    const server = http.createServer((req, res) => {
+      if (options.log) {
+        logger.dim(`${req.method} ${req.url}`);
+      }
+
+      // Handle CORS
+      if (options.cors) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+        if (req.method === 'OPTIONS') {
+          res.writeHead(200);
+          res.end();
+          return;
+        }
+      }
+
+      // Parse target URL
+      const targetUrl = new URL(req.url, options.target);
+
+      // Choose http or https based on protocol
+      const client = targetUrl.protocol === 'https:' ? https : http;
+
+      const proxyReq = client.request(
+        targetUrl,
+        {
+          method: req.method,
+          headers: {
+            ...req.headers,
+            host: targetUrl.host,
+          },
+        },
+        (proxyRes) => {
+          res.writeHead(proxyRes.statusCode, proxyRes.headers);
+          proxyRes.pipe(res);
+        }
+      );
+
+      proxyReq.on('error', (error) => {
+        logger.error(`Proxy error: ${error.message}`);
+        res.writeHead(502);
+        res.end('Bad Gateway');
+      });
+
+      req.pipe(proxyReq);
+    });
+
+    server.listen(options.port, () => {
+      logger.success(`Proxy server running on http://localhost:${options.port}`);
+    });
+  });
+
+module.exports = proxyCommand;

package/src/commands/run.js

@@ -0,0 +1,199 @@
+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 runCommand = new Command('run')
+  .description('Run your project')
+  .option('-p, --port <port>', 'Port number', '3000')
+  .option('-h, --host <host>', 'Host address', 'localhost')
+  .option('-e, --env <environment>', 'Environment', 'development')
+  .option('--no-shared', 'Disable shared modules for this run')
+  .action(async (options) => {
+    logger.header('🏃 Running 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(`Environment: ${options.env}`);
+
+      // 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 variables
+      process.env.NODE_ENV = options.env;
+      process.env.PORT = options.port;
+      process.env.HOST = options.host;
+
+      await runProject(projectInfo, configData, options);
+    } catch (error) {
+      logger.error(`Failed to run project: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function runProject(projectInfo, config, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const scripts = pkg.scripts || {};
+
+  // Determine the run command based on framework
+  let command = null;
+  let args = [];
+
+  if (projectInfo.framework) {
+    const runCommands = {
+      // Backend
+      express: 'node',
+      fastify: 'node',
+      koa: 'node',
+      hapi: 'node',
+      nestjs: { command: 'npm', args: ['run', 'start:dev'] },
+      adonis: { command: 'npm', args: ['run', 'dev'] },
+      strapi: { command: 'npm', args: ['run', 'develop'] },
+      hono: 'npm run dev',
+      trpc: 'npm run dev',
+      graphql: 'npm run dev',
+      socketio: 'npm run dev',
+
+      // Frontend
+      react: 'npm start',
+      vue: 'npm run serve',
+      angular: 'ng serve',
+      svelte: 'npm run dev',
+      solid: 'npm run dev',
+      preact: 'npm run dev',
+      lit: 'npm run dev',
+      alpine: 'npm run dev',
+      htmx: 'npm run dev',
+
+      // Full-stack
+      nextjs: 'npm run dev',
+      nuxt: 'npm run dev',
+      remix: 'npm run dev',
+      gatsby: 'npm run develop',
+      astro: 'npm run dev',
+      sveltekit: 'npm run dev',
+      solidstart: 'npm run dev',
+      qwik: 'npm run dev',
+      analog: 'npm run dev',
+      fresh: 'deno task dev',
+      tanstack: 'npm run dev',
+      waku: 'npm run dev',
+
+      // Desktop
+      electron: 'npm run dev',
+      tauri: 'npm run dev',
+      nwjs: 'npm run dev',
+
+      // Mobile
+      reactnative: 'npm start',
+      expo: 'npm start',
+      ionic: 'npm start',
+      tamagui: 'npm start',
+      nativebase: 'npm start',
+
+      // Database
+      drizzle: 'npm run dev',
+      prisma: 'npm run dev',
+    };
+
+    const runConfig = runCommands[projectInfo.framework.name];
+
+    if (typeof runConfig === 'object') {
+      command = runConfig.command;
+      args = runConfig.args;
+    } else if (runConfig) {
+      const parts = runConfig.split(' ');
+      command = parts[0];
+      args = parts.slice(1);
+    }
+  }
+
+  // Fallback to package.json scripts
+  if (!command) {
+    if (scripts.dev) {
+      command = 'npm';
+      args = ['run', 'dev'];
+    } else if (scripts.start) {
+      command = 'npm';
+      args = ['run', 'start'];
+    } else if (scripts.serve) {
+      command = 'npm';
+      args = ['run', 'serve'];
+    } else {
+      // Try to run the entry point directly
+      const entryPoint = config.entry || 'src/index.js';
+      if (await fs.pathExists(path.join(process.cwd(), entryPoint))) {
+        command = 'node';
+        args = [entryPoint];
+      } else {
+        throw new Error('No run command found. Add a "dev" or "start" script to package.json');
+      }
+    }
+  }
+
+  logger.info(`Running: ${command} ${args.join(' ')}`);
+
+  const child = spawn(command, args, {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      NODE_ENV: options.env,
+      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 = runCommand;

package/src/commands/test.js

@@ -0,0 +1,104 @@
+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 testCommand = new Command('test')
+  .description('Run tests')
+  .option('-w, --watch', 'Watch mode', false)
+  .option('-c, --coverage', 'Generate coverage report', false)
+  .option('-f, --filter <pattern>', 'Filter tests by pattern')
+  .action(async (options) => {
+    logger.header('🧪 Running Tests');
+
+    const detector = new ProjectDetector();
+
+    try {
+      const projectInfo = await detector.detect();
+
+      logger.info(`Framework: ${projectInfo.framework?.name || 'Unknown'}`);
+
+      await runTests(projectInfo, options);
+    } catch (error) {
+      logger.error(`Failed to run tests: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function runTests(projectInfo, options) {
+  const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+  const scripts = pkg.scripts || {};
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  let command = null;
+  let args = [];
+
+  // Detect test framework
+  if (deps.jest || scripts.test?.includes('jest')) {
+    command = 'npm';
+    args = ['test'];
+    if (options.watch) args.push('--watch');
+    if (options.coverage) args.push('--coverage');
+    if (options.filter) args.push('--testNamePattern', options.filter);
+  } else if (deps.vitest || scripts.test?.includes('vitest')) {
+    command = 'npm';
+    args = ['test'];
+    if (options.watch) args.push('--watch');
+    if (options.coverage) args.push('--coverage');
+    if (options.filter) args.push('-t', options.filter);
+  } else if (deps.mocha || scripts.test?.includes('mocha')) {
+    command = 'npm';
+    args = ['test'];
+    if (options.watch) args.push('--watch');
+    if (options.filter) args.push('--grep', options.filter);
+  } else if (deps['@playwright/test'] || scripts.test?.includes('playwright')) {
+    command = 'npx';
+    args = ['playwright', 'test'];
+    if (options.filter) args.push(options.filter);
+  } else if (deps.cypress || scripts.test?.includes('cypress')) {
+    command = 'npx';
+    args = ['cypress', 'run'];
+    if (options.filter) args.push('--spec', options.filter);
+  } else if (scripts.test) {
+    command = 'npm';
+    args = ['test'];
+  } else {
+    // Try to run node test files
+    command = 'node';
+    args = ['--test'];
+    if (options.watch) args.push('--watch');
+  }
+
+  logger.info(`Running: ${command} ${args.join(' ')}`);
+  logger.info('');
+
+  const child = spawn(command, args, {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      NODE_ENV: 'test',
+    },
+  });
+
+  child.on('error', (error) => {
+    logger.error(`Test process failed: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0) {
+      logger.error(`Tests failed with code ${code}`);
+      process.exit(code);
+    } else {
+      logger.success('All tests passed!');
+    }
+  });
+}
+
+module.exports = testCommand;

package/src/index.js

@@ -0,0 +1,30 @@
+const ProjectDetector = require('./utils/detector');
+const ConfigLoader = require('./utils/config');
+const logger = require('./utils/logger');
+
+module.exports = {
+  ProjectDetector,
+  ConfigLoader,
+  logger,
+
+  // Commands
+  run: require('./commands/run'),
+  build: require('./commands/build'),
+  init: require('./commands/init'),
+  dev: require('./commands/dev'),
+  test: require('./commands/test'),
+  deploy: require('./commands/deploy'),
+  docker: require('./commands/docker'),
+  electron: require('./commands/electron'),
+  package: require('./commands/package'),
+  analyze: require('./commands/analyze'),
+  clean: require('./commands/clean'),
+  lint: require('./commands/lint'),
+
+  // Targets
+  NodeBuilder: require('./targets/node'),
+  FrontendBuilder: require('./targets/frontend'),
+  ElectronBuilder: require('./targets/electron'),
+  DockerBuilder: require('./targets/docker'),
+  LibraryBuilder: require('./targets/library'),
+};

package/src/targets/docker.js

@@ -0,0 +1,201 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+class DockerBuilder {
+  constructor(projectInfo, config) {
+    this.projectInfo = projectInfo;
+    this.config = config;
+    this.dockerConfig = config.docker || {};
+  }
+
+  async build(options) {
+    logger.section('Building Docker Image');
+
+    // Ensure Dockerfile exists
+    await this.ensureDockerfile();
+
+    // Build image
+    await this.buildImage(options);
+
+    // Optionally run
+    if (options.run) {
+      await this.runContainer(options);
+    }
+  }
+
+  async ensureDockerfile() {
+    const dockerfilePath = path.join(process.cwd(), 'Dockerfile');
+
+    if (!(await fs.pathExists(dockerfilePath))) {
+      logger.info('Generating Dockerfile...');
+
+      const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+      const baseImage = this.dockerConfig.baseImage || 'node:20-alpine';
+      const workdir = this.dockerConfig.workdir || '/app';
+      const port = this.dockerConfig.port || 3000;
+
+      // Determine if it's a frontend or backend project
+      const isFrontend = this.projectInfo.type === 'frontend' || this.projectInfo.type === 'fullstack';
+
+      let dockerfile;
+
+      if (isFrontend) {
+        dockerfile = `# Build stage
+FROM ${baseImage} AS builder
+
+WORKDIR ${workdir}
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM nginx:alpine
+
+COPY --from=builder ${workdir}/dist /usr/share/nginx/html
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]
+`;
+      } else {
+        dockerfile = `# Build stage
+FROM ${baseImage} AS builder
+
+WORKDIR ${workdir}
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+
+# Build if build script exists
+RUN npm run build 2>/dev/null || true
+
+# Production stage
+FROM ${baseImage}
+
+WORKDIR ${workdir}
+
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY --from=builder ${workdir}/dist ./dist
+COPY --from=builder ${workdir}/src ./src
+
+EXPOSE ${port}
+
+CMD ["node", "src/index.js"]
+`;
+      }
+
+      await fs.writeFile(dockerfilePath, dockerfile);
+      logger.success('Dockerfile generated');
+    }
+
+    // Ensure .dockerignore exists
+    const dockerignorePath = path.join(process.cwd(), '.dockerignore');
+    if (!(await fs.pathExists(dockerignorePath))) {
+      const dockerignore = `node_modules
+npm-debug.log
+dist
+build
+.git
+.env
+.env.*
+*.log
+`;
+      await fs.writeFile(dockerignorePath, dockerignore);
+      logger.success('.dockerignore generated');
+    }
+  }
+
+  async buildImage(options) {
+    const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+    const imageName = pkg.name || 'app';
+    const tag = options.tag || 'latest';
+
+    logger.info(`Building Docker image: ${imageName}:${tag}`);
+
+    const args = ['build', '-t', `${imageName}:${tag}`, '.'];
+
+    const child = spawn('docker', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success(`Docker image built: ${imageName}:${tag}`);
+          resolve();
+        } else {
+          reject(new Error('Docker build failed'));
+        }
+      });
+    });
+  }
+
+  async runContainer(options) {
+    const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+    const imageName = pkg.name || 'app';
+    const tag = options.tag || 'latest';
+    const containerName = `${imageName}-container`;
+    const port = this.dockerConfig.port || 3000;
+
+    logger.info(`Running container: ${containerName}`);
+
+    // 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
+    }
+
+    // Remove existing container
+    try {
+      await new Promise((resolve) => {
+        const rm = spawn('docker', ['rm', containerName], {
+          shell: true,
+        });
+        rm.on('close', () => resolve());
+      });
+    } catch (e) {
+      // Ignore
+    }
+
+    const args = [
+      'run', '-d',
+      '--name', containerName,
+      '-p', `${port}:${port}`,
+      `${imageName}:${tag}`,
+    ];
+
+    const child = spawn('docker', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success(`Container running on port ${port}`);
+          resolve();
+        } else {
+          reject(new Error('Docker run failed'));
+        }
+      });
+    });
+  }
+}
+
+module.exports = DockerBuilder;