easybuild-nox 1.0.0

package/src/utils/detector.js

@@ -0,0 +1,407 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const FRAMEWORKS = {
+  // Backend frameworks
+  express: { type: 'backend', config: 'express' },
+  fastify: { type: 'backend', config: 'fastify' },
+  koa: { type: 'backend', config: 'koa' },
+  hapi: { type: 'backend', config: 'hapi' },
+  nestjs: { type: 'backend', config: 'nest' },
+  adonis: { type: 'backend', config: 'adonis' },
+  strapi: { type: 'backend', config: 'strapi' },
+  mikroorm: { type: 'backend', config: 'mikroorm' },
+  typeorm: { type: 'backend', config: 'typeorm' },
+  prisma: { type: 'backend', config: 'prisma' },
+  hono: { type: 'backend', config: 'hono' },
+  trpc: { type: 'backend', config: 'trpc' },
+  graphql: { type: 'backend', config: 'graphql' },
+  socketio: { type: 'backend', config: 'socketio' },
+
+  // Frontend frameworks
+  react: { type: 'frontend', config: 'react' },
+  vue: { type: 'frontend', config: 'vue' },
+  angular: { type: 'frontend', config: 'angular' },
+  svelte: { type: 'frontend', config: 'svelte' },
+  solid: { type: 'frontend', config: 'solid' },
+  preact: { type: 'frontend', config: 'preact' },
+  lit: { type: 'frontend', config: 'lit' },
+  alpine: { type: 'frontend', config: 'alpine' },
+  htmx: { type: 'frontend', config: 'htmx' },
+  stimulus: { type: 'frontend', config: 'stimulus' },
+  mithril: { type: 'frontend', config: 'mithril' },
+  inferno: { type: 'frontend', config: 'inferno' },
+  petitevue: { type: 'frontend', config: 'petitevue' },
+
+  // Full-stack frameworks
+  nextjs: { type: 'fullstack', config: 'next' },
+  nuxt: { type: 'fullstack', config: 'nuxt' },
+  remix: { type: 'fullstack', config: 'remix' },
+  gatsby: { type: 'fullstack', config: 'gatsby' },
+  astro: { type: 'fullstack', config: 'astro' },
+  sveltekit: { type: 'fullstack', config: 'sveltekit' },
+  solidstart: { type: 'fullstack', config: 'solidstart' },
+  analog: { type: 'fullstack', config: 'analog' },
+  qwik: { type: 'fullstack', config: 'qwik' },
+  fresh: { type: 'fullstack', config: 'fresh' },
+  hono_fullstack: { type: 'fullstack', config: 'hono' },
+  tanstack: { type: 'fullstack', config: 'tanstack' },
+  waku: { type: 'fullstack', config: 'waku' },
+  layr: { type: 'fullstack', config: 'layr' },
+
+  // Meta frameworks
+  electron: { type: 'desktop', config: 'electron' },
+  tauri: { type: 'desktop', config: 'tauri' },
+  neutralino: { type: 'desktop', config: 'neutralino' },
+  nwjs: { type: 'desktop', config: 'nwjs' },
+
+  // Mobile
+  reactnative: { type: 'mobile', config: 'reactnative' },
+  ionic: { type: 'mobile', config: 'ionic' },
+  nativescript: { type: 'mobile', config: 'nativescript' },
+  expo: { type: 'mobile', config: 'expo' },
+  reactnativeexpo: { type: 'mobile', config: 'expo' },
+  tamagui: { type: 'mobile', config: 'tamagui' },
+  nativebase: { type: 'mobile', config: 'nativebase' },
+
+  // CLI tools
+  commander: { type: 'cli', config: 'cli' },
+  yargs: { type: 'cli', config: 'cli' },
+  inquirer: { type: 'cli', config: 'cli' },
+  prompts: { type: 'cli', config: 'cli' },
+  meow: { type: 'cli', config: 'cli' },
+  cac: { type: 'cli', config: 'cli' },
+
+  // Libraries
+  typescript: { type: 'library', config: 'library' },
+  zod: { type: 'library', config: 'library' },
+  lodash: { type: 'library', config: 'library' },
+  datefns: { type: 'library', config: 'library' },
+  dayjs: { type: 'library', config: 'library' },
+  axios: { type: 'library', config: 'library' },
+  got: { type: 'library', config: 'library' },
+  ky: { type: 'library', config: 'library' },
+
+  // CMS
+  sanity: { type: 'cms', config: 'sanity' },
+  contentful: { type: 'cms', config: 'contentful' },
+  payload: { type: 'cms', config: 'payload' },
+  directus: { type: 'cms', config: 'directus' },
+
+  // Ecommerce
+  medusa: { type: 'ecommerce', config: 'medusa' },
+  saleor: { type: 'ecommerce', config: 'saleor' },
+  shopify: { type: 'ecommerce', config: 'shopify' },
+
+  // Database ORMs
+  drizzle: { type: 'database', config: 'drizzle' },
+  kysely: { type: 'database', config: 'kysely' },
+  sequelize: { type: 'database', config: 'sequelize' },
+  mongoose: { type: 'database', config: 'mongoose' },
+};
+
+const BUNDLERS = {
+  esbuild: 'esbuild',
+  webpack: 'webpack',
+  vite: 'vite',
+  rollup: 'rollup',
+  parcel: 'parcel',
+  swc: 'swc',
+  turbopack: 'turbopack',
+};
+
+class ProjectDetector {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.packageJson = null;
+    this.detectedFramework = null;
+    this.detectedBundler = null;
+    this.projectType = null;
+  }
+
+  async detect() {
+    await this.loadPackageJson();
+    await this.detectFramework();
+    await this.detectBundler();
+    await this.detectTypeScript();
+    await this.detectMonorepo();
+
+    return {
+      framework: this.detectedFramework,
+      bundler: this.detectedBundler,
+      type: this.projectType,
+      isTypeScript: this.isTypeScript,
+      isMonorepo: this.isMonorepo,
+      packageJson: this.packageJson,
+    };
+  }
+
+  async loadPackageJson() {
+    const pkgPath = path.join(this.rootDir, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+      this.packageJson = await fs.readJson(pkgPath);
+    }
+  }
+
+  async detectFramework() {
+    if (!this.packageJson) return;
+
+    const deps = {
+      ...this.packageJson.dependencies,
+      ...this.packageJson.devDependencies,
+    };
+
+    // Check for frameworks in dependencies
+    for (const [framework, info] of Object.entries(FRAMEWORKS)) {
+      const frameworkPatterns = this.getFrameworkPatterns(framework);
+      for (const pattern of frameworkPatterns) {
+        if (deps[pattern]) {
+          this.detectedFramework = { name: framework, ...info };
+          this.projectType = info.type;
+          return;
+        }
+      }
+    }
+
+    // Check for common file patterns
+    await this.detectByFilePatterns();
+  }
+
+  getFrameworkPatterns(framework) {
+    const patterns = {
+      // Backend
+      express: ['express'],
+      fastify: ['fastify', '@fastify/fastify'],
+      koa: ['koa'],
+      hapi: ['@hapi/hapi'],
+      nestjs: ['@nestjs/core', '@nestjs/common'],
+      adonis: ['@adonisjs/framework', '@adonisjs/core'],
+      strapi: ['@strapi/strapi'],
+      hono: ['hono'],
+      trpc: ['@trpc/server', '@trpc/client'],
+      graphql: ['graphql', '@graphql-js/core', 'apollo-server'],
+      socketio: ['socket.io'],
+
+      // Frontend
+      react: ['react', 'react-dom'],
+      vue: ['vue', 'nuxt'],
+      angular: ['@angular/core'],
+      svelte: ['svelte', '@sveltejs/kit'],
+      solid: ['solid-js', 'solid-start'],
+      preact: ['preact'],
+      lit: ['lit', 'lit-element'],
+      alpine: ['alpinejs'],
+      htmx: ['htmx.org'],
+      stimulus: ['@hotwired/stimulus'],
+      mithril: ['mithril'],
+      inferno: ['inferno'],
+      petitevue: ['petite-vue'],
+
+      // Full-stack
+      nextjs: ['next'],
+      nuxt: ['nuxt', '@nuxt/core'],
+      remix: ['@remix-run/react', '@remix-run/node'],
+      gatsby: ['gatsby'],
+      astro: ['astro'],
+      sveltekit: ['@sveltejs/kit'],
+      solidstart: ['solid-start'],
+      analog: ['@analogjs/core'],
+      qwik: ['@builder.io/qwik'],
+      fresh: ['fresh'],
+      tanstack: ['@tanstack/react-start', '@tanstack/react-router'],
+      waku: ['waku'],
+
+      // Desktop
+      electron: ['electron'],
+      tauri: ['@tauri-apps/api'],
+      nwjs: ['nw'],
+
+      // Mobile
+      reactnative: ['react-native'],
+      ionic: ['@ionic/core', '@ionic/react', '@ionic/vue', '@ionic/angular'],
+      expo: ['expo'],
+      tamagui: ['tamagui'],
+      nativebase: ['native-base'],
+
+      // CLI
+      commander: ['commander'],
+      yargs: ['yargs'],
+      inquirer: ['inquirer'],
+      prompts: ['prompts'],
+      meow: ['meow'],
+      cac: ['cac'],
+
+      // Libraries
+      zod: ['zod'],
+      lodash: ['lodash'],
+      datefns: ['date-fns'],
+      dayjs: ['dayjs'],
+      axios: ['axios'],
+      got: ['got'],
+      ky: ['ky'],
+
+      // CMS
+      sanity: ['@sanity/client', 'sanity'],
+      contentful: ['contentful'],
+      payload: ['payload'],
+      directus: ['@directus/sdk'],
+
+      // Ecommerce
+      medusa: ['@medusajs/medusa'],
+      saleor: ['@saleor/sdk'],
+      shopify: ['@shopify/shopify-api'],
+
+      // Database
+      drizzle: ['drizzle-orm', 'drizzle-kit'],
+      kysely: ['kysely'],
+      sequelize: ['sequelize'],
+      mongoose: ['mongoose'],
+    };
+    return patterns[framework] || [framework];
+  }
+
+  async detectByFilePatterns() {
+    const filePatterns = {
+      // Full-stack frameworks
+      'next.config.js': 'nextjs',
+      'next.config.mjs': 'nextjs',
+      'next.config.ts': 'nextjs',
+      'nuxt.config.js': 'nuxt',
+      'nuxt.config.ts': 'nuxt',
+      'nuxt.config.mjs': 'nuxt',
+      'remix.config.js': 'remix',
+      'remix.config.mjs': 'remix',
+      'gatsby-config.js': 'gatsby',
+      'gatsby-config.mjs': 'gatsby',
+      'gatsby-node.js': 'gatsby',
+      'svelte.config.js': 'sveltekit',
+      'svelte.config.mjs': 'sveltekit',
+      'astro.config.mjs': 'astro',
+      'astro.config.js': 'astro',
+      'astro.config.ts': 'astro',
+      'solid.config.js': 'solidstart',
+      'solid.config.ts': 'solidstart',
+      'vite.config.ts': 'vite',
+      'vite.config.js': 'vite',
+      'vite.config.mjs': 'vite',
+      'vite.config.mts': 'vite',
+      'vue.config.js': 'vue',
+      'vue.config.ts': 'vue',
+      'angular.json': 'angular',
+      'svelte.config.js': 'svelte',
+
+      // Backend frameworks
+      'nest-cli.json': 'nestjs',
+      '.adonisrc.json': 'adonis',
+      'strapi-server.js': 'strapi',
+
+      // Desktop
+      'tauri.conf.json': 'tauri',
+      'tauri.conf.json5': 'tauri',
+      'electron-builder.yml': 'electron',
+      'electron-builder.json': 'electron',
+      'electron-builder.json5': 'electron',
+      'electron.vite.config.ts': 'electron',
+      'electron.vite.config.js': 'electron',
+      'forge.config.js': 'electron',
+      'forge.config.ts': 'electron',
+
+      // Mobile
+      'app.json': 'expo',
+      'expo.json': 'expo',
+      'capacitor.config.ts': 'ionic',
+      'capacitor.config.js': 'ionic',
+
+      // Database
+      'drizzle.config.ts': 'drizzle',
+      'drizzle.config.js': 'drizzle',
+      'prisma/schema.prisma': 'prisma',
+      'sequelize.config.js': 'sequelize',
+
+      // CMS
+      'sanity.config.ts': 'sanity',
+      'sanity.config.js': 'sanity',
+      'payload.config.ts': 'payload',
+      'payload.config.js': 'payload',
+    };
+
+    for (const [file, framework] of Object.entries(filePatterns)) {
+      if (await fs.pathExists(path.join(this.rootDir, file))) {
+        this.detectedFramework = { name: framework, ...FRAMEWORKS[framework] };
+        this.projectType = FRAMEWORKS[framework].type;
+        return;
+      }
+    }
+  }
+
+  async detectBundler() {
+    if (!this.packageJson) return;
+
+    const deps = {
+      ...this.packageJson.dependencies,
+      ...this.packageJson.devDependencies,
+    };
+
+    const scripts = this.packageJson.scripts || {};
+
+    // Check for bundler in dependencies
+    for (const bundler of Object.keys(BUNDLERS)) {
+      if (deps[bundler] || deps[`@${bundler}/core`]) {
+        this.detectedBundler = bundler;
+        return;
+      }
+    }
+
+    // Check scripts for bundler usage
+    const scriptContent = Object.values(scripts).join(' ');
+    for (const bundler of Object.keys(BUNDLERS)) {
+      if (scriptContent.includes(bundler)) {
+        this.detectedBundler = bundler;
+        return;
+      }
+    }
+
+    // Default bundler based on framework
+    if (this.detectedFramework) {
+      const defaultBundlers = {
+        nextjs: 'turbopack',
+        nuxt: 'vite',
+        sveltekit: 'vite',
+        astro: 'vite',
+        solidstart: 'vite',
+        react: 'esbuild',
+        vue: 'vite',
+        angular: 'webpack',
+        svelte: 'vite',
+        electron: 'webpack',
+      };
+      this.detectedBundler = defaultBundlers[this.detectedFramework.name] || 'esbuild';
+    } else {
+      this.detectedBundler = 'esbuild';
+    }
+  }
+
+  async detectTypeScript() {
+    this.isTypeScript = await fs.pathExists(path.join(this.rootDir, 'tsconfig.json'));
+  }
+
+  async detectMonorepo() {
+    this.isMonorepo = await fs.pathExists(path.join(this.rootDir, 'lerna.json')) ||
+      await fs.pathExists(path.join(this.rootDir, 'pnpm-workspace.yaml')) ||
+      await fs.pathExists(path.join(this.rootDir, 'turbo.json')) ||
+      (this.packageJson?.workspaces !== undefined);
+  }
+
+  getConfig() {
+    return {
+      framework: this.detectedFramework,
+      bundler: this.detectedBundler,
+      type: this.projectType,
+      isTypeScript: this.isTypeScript,
+      isMonorepo: this.isMonorepo,
+      rootDir: this.rootDir,
+    };
+  }
+}
+
+module.exports = ProjectDetector;

package/src/utils/globalConfig.js

@@ -0,0 +1,106 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const logger = require('./logger');
+
+const EASY_HOME = path.join(os.homedir(), '.easy');
+const GLOBAL_CONFIG_PATH = path.join(EASY_HOME, 'config.json');
+
+const DEFAULT_GLOBAL_CONFIG = {
+  // Shared modules settings
+  sharedModules: {
+    enabled: true,
+    autoSync: true,
+    autoInstall: true,
+  },
+
+  // Default build settings
+  build: {
+    minify: true,
+    sourcemap: false,
+    outDir: 'dist',
+  },
+
+  // Default dev server settings
+  dev: {
+    port: 3000,
+    host: 'localhost',
+    open: true,
+  },
+
+  // Default electron settings
+  electron: {
+    platforms: ['current'],
+    arch: ['x64'],
+  },
+
+  // Telemetry (opt-in)
+  telemetry: false,
+};
+
+class GlobalConfig {
+  constructor() {
+    this.config = null;
+  }
+
+  async load() {
+    await this.ensureConfigExists();
+    this.config = await fs.readJson(GLOBAL_CONFIG_PATH);
+    return this.config;
+  }
+
+  async save() {
+    await fs.ensureDir(EASY_HOME);
+    await fs.writeJson(GLOBAL_CONFIG_PATH, this.config, { spaces: 2 });
+  }
+
+  async ensureConfigExists() {
+    await fs.ensureDir(EASY_HOME);
+    if (!(await fs.pathExists(GLOBAL_CONFIG_PATH))) {
+      await fs.writeJson(GLOBAL_CONFIG_PATH, DEFAULT_GLOBAL_CONFIG, { spaces: 2 });
+    }
+  }
+
+  get(key) {
+    if (!this.config) return null;
+    return key.split('.').reduce((obj, k) => obj?.[k], this.config);
+  }
+
+  set(key, value) {
+    if (!this.config) return;
+    const keys = key.split('.');
+    let obj = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!obj[keys[i]]) obj[keys[i]] = {};
+      obj = obj[keys[i]];
+    }
+
+    obj[keys[keys.length - 1]] = value;
+  }
+
+  async enableSharedModules() {
+    await this.load();
+    this.set('sharedModules.enabled', true);
+    await this.save();
+    logger.success('Shared modules enabled globally');
+  }
+
+  async disableSharedModules() {
+    await this.load();
+    this.set('sharedModules.enabled', false);
+    await this.save();
+    logger.success('Shared modules disabled globally');
+  }
+
+  async isSharedModulesEnabled() {
+    await this.load();
+    return this.get('sharedModules.enabled') || false;
+  }
+
+  getConfigPath() {
+    return GLOBAL_CONFIG_PATH;
+  }
+}
+
+module.exports = new GlobalConfig();

package/src/utils/logger.js

@@ -0,0 +1,98 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+class Logger {
+  constructor() {
+    this.spinner = null;
+  }
+
+  info(message) {
+    console.log(chalk.blue('ℹ'), message);
+  }
+
+  success(message) {
+    console.log(chalk.green('✓'), message);
+  }
+
+  warning(message) {
+    console.log(chalk.yellow('⚠'), message);
+  }
+
+  error(message) {
+    console.log(chalk.red('✖'), message);
+  }
+
+  fun(message) {
+    console.log(chalk.magenta('✨'), message);
+  }
+
+  startSpinner(message) {
+    this.spinner = ora({
+      text: message,
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+    return this.spinner;
+  }
+
+  stopSpinner(message, success = true) {
+    if (this.spinner) {
+      if (success) {
+        this.spinner.succeed(message);
+      } else {
+        this.spinner.fail(message);
+      }
+      this.spinner = null;
+    }
+  }
+
+  header(message) {
+    console.log('');
+    console.log(chalk.bold.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk.bold.cyan(`  ${message}`));
+    console.log(chalk.bold.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log('');
+  }
+
+  banner() {
+    console.log('');
+    console.log(chalk.bold.green('🚀 easy-build v1.0.0'));
+    console.log(chalk.gray('   The universal build tool for EVERYTHING'));
+    console.log('');
+  }
+
+  section(title) {
+    console.log('');
+    console.log(chalk.bold.white(`📦 ${title}`));
+    console.log(chalk.gray('─'.repeat(50)));
+  }
+
+  dim(message) {
+    console.log(chalk.gray(message));
+  }
+
+  bold(message) {
+    console.log(chalk.bold.white(message));
+  }
+
+  list(items) {
+    items.forEach(item => {
+      console.log(`  ${chalk.cyan('•')} ${item}`);
+    });
+  }
+
+  progress(current, total, label = '') {
+    const percentage = Math.round((current / total) * 100);
+    const filled = Math.round(percentage / 5);
+    const empty = 20 - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    
+    console.log(`\r${chalk.cyan(bar)} ${chalk.white(`${percentage}%`)} ${label}`);
+  }
+
+  emoji(text, emoji) {
+    console.log(`${emoji} ${text}`);
+  }
+}
+
+module.exports = new Logger();