@linyjs/cli 0.0.4 → 0.0.6

package/src/utils/builder.ts

@@ -1,472 +0,0 @@
-/**
- * Smart builder for plugin projects
- * 
- * Design Philosophy:
- * - Zero configuration required
- * - CLI handles all build details automatically
- * - Users just write TypeScript/TSX code
- * - Sensible defaults and optimizations out of the box
- */
-
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import chalk from 'chalk';
-import ora from 'ora';
-
-export interface BuildOptions {
-  projectRoot: string;
-  verbose: boolean;
-  minify?: boolean;
-  external?: string[];
-}
-
-export interface BuildResult {
-  success: boolean;
-  outputDir: string;
-  files: string[];
-  size: number;
-  duration: number;
-}
-
-/**
- * Detect build system and execute build
- */
-export async function buildProject(options: BuildOptions): Promise<BuildResult> {
-  const startTime = Date.now();
-  const { projectRoot, verbose } = options;
-  
-  const spinner = ora('Detecting build system...').start();
-  
-  // Step 1: Detect build system
-  const buildSystem = detectBuildSystem(projectRoot);
-  
-  if (!buildSystem) {
-    spinner.fail('No build system detected');
-    console.error(chalk.red('\nPlease add a build script to package.json:'));
-    console.error(chalk.gray('  "scripts": { "build": "tsc" }'));
-    process.exit(1);
-  }
-  
-  spinner.succeed(`Build system detected: ${buildSystem.name}`);
-  
-  if (verbose) {
-    console.log(chalk.gray('  Type:'), buildSystem.type);
-    console.log(chalk.gray('  Config:'), buildSystem.configFile || 'none');
-  }
-  
-  // Step 2: Execute build
-  const buildSpinner = ora('Building project...').start();
-  
-  try {
-    let outputDir: string;
-    
-    // DEFAULT: Always use esbuild for optimal bundles
-    // Users don't need to configure webpack/rollup themselves
-    if (buildSystem.type === 'typescript' || buildSystem.type === 'custom') {
-      // Even if project has tsc, we use esbuild for better optimization
-      if (verbose) {
-        console.log(chalk.yellow('\n💡 Using esbuild for optimized bundle (ignoring tsc config)'));
-      }
-      outputDir = await buildWithEsbuild(projectRoot, buildSystem, options, verbose);
-    } else if (buildSystem.type === 'esbuild') {
-      // Project already uses esbuild, use it directly
-      outputDir = await buildWithEsbuild(projectRoot, buildSystem, options, verbose);
-    } else {
-      // For webpack/rollup, still prefer our esbuild approach
-      if (verbose) {
-        console.log(chalk.yellow('\n💡 Using CLI built-in esbuild (ignoring webpack/rollup config)'));
-      }
-      outputDir = await buildWithEsbuild(projectRoot, buildSystem, options, verbose);
-    }
-    
-    // Step 3: Collect output files
-    const files = collectOutputFiles(outputDir);
-    const size = calculateTotalSize(files);
-    const duration = Date.now() - startTime;
-    
-    buildSpinner.succeed(`Build completed in ${duration}ms`);
-    
-    if (verbose) {
-      console.log(chalk.gray('  Output directory:'), outputDir);
-      console.log(chalk.gray('  Total files:'), files.length);
-      console.log(chalk.gray('  Total size:'), formatFileSize(size));
-    }
-    
-    return {
-      success: true,
-      outputDir,
-      files,
-      size,
-      duration
-    };
-  } catch (error) {
-    buildSpinner.fail('Build failed');
-    
-    if (error instanceof Error) {
-      console.error(chalk.red('\nBuild error:'));
-      console.error(error.message);
-      
-      if (verbose && 'stdout' in error) {
-        console.error(chalk.gray('\nDetailed output:'));
-        console.error((error as any).stdout?.toString());
-      }
-    }
-    
-    process.exit(1);
-  }
-}
-
-/**
- * Detect build system from project configuration
- */
-function detectBuildSystem(projectRoot: string): BuildSystem | null {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-  
-  if (!fs.existsSync(packageJsonPath)) {
-    return null;
-  }
-  
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-  const buildScript = packageJson.scripts?.build || '';
-  
-  // Check for TypeScript
-  if (fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
-    if (buildScript.includes('tsc') || buildScript.includes('typescript')) {
-      return {
-        type: 'typescript',
-        name: 'TypeScript Compiler',
-        configFile: 'tsconfig.json',
-        command: buildScript
-      };
-    }
-  }
-  
-  // Check for esbuild
-  if (buildScript.includes('esbuild')) {
-    return {
-      type: 'esbuild',
-      name: 'esbuild',
-      configFile: null,
-      command: buildScript
-    };
-  }
-  
-  // Check for webpack
-  if (fs.existsSync(path.join(projectRoot, 'webpack.config.js')) || 
-      fs.existsSync(path.join(projectRoot, 'webpack.config.ts'))) {
-    return {
-      type: 'webpack',
-      name: 'Webpack',
-      configFile: 'webpack.config.js',
-      command: buildScript
-    };
-  }
-  
-  // Check for rollup
-  if (fs.existsSync(path.join(projectRoot, 'rollup.config.js'))) {
-    return {
-      type: 'rollup',
-      name: 'Rollup',
-      configFile: 'rollup.config.js',
-      command: buildScript
-    };
-  }
-  
-  // Default to npm run build
-  if (buildScript) {
-    return {
-      type: 'custom',
-      name: 'Custom Build Script',
-      configFile: null,
-      command: buildScript
-    };
-  }
-  
-  return null;
-}
-
-/**
- * Build with TypeScript compiler
- */
-async function buildWithTsc(
-  projectRoot: string,
-  buildSystem: BuildSystem,
-  verbose: boolean
-): Promise<string> {
-  // Read tsconfig.json to get output directory
-  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-  const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
-  const outputDir = tsconfig.compilerOptions?.outDir || 'dist';
-  
-  // Execute tsc
-  execSync('npx tsc', {
-    stdio: verbose ? 'inherit' : 'pipe',
-    cwd: projectRoot
-  });
-  
-  return path.join(projectRoot, outputDir);
-}
-
-/**
- * Build with esbuild (DEFAULT strategy)
- * This is the recommended approach for production builds
- */
-async function buildWithEsbuild(
-  projectRoot: string,
-  buildSystem: BuildSystem,
-  options: BuildOptions,
-  verbose: boolean
-): Promise<string> {
-  const outputDir = path.join(projectRoot, 'dist');
-  
-  // Ensure output directory exists
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-  
-  // Detect entry points (smart detection)
-  const serverEntry = findEntryFile(projectRoot, 'server');
-  const clientEntry = findEntryFile(projectRoot, 'client');
-  
-  if (!serverEntry && !clientEntry) {
-    throw new Error('No entry files found. Expected src/server/index.ts or src/client/index.tsx');
-  }
-  
-  // Default external dependencies (Ling framework provides these)
-  const defaultExternal = [
-    'react',
-    'react-dom',
-    'express',
-    '@linyjs/*',
-    '@ling/*'
-  ];
-  
-  const externalDeps = options.external || defaultExternal;
-  
-  // Build server bundle (if exists)
-  if (serverEntry) {
-    const serverOutput = path.join(outputDir, 'server', 'index.js');
-    
-    const serverCmd = [
-      'npx esbuild',
-      serverEntry,
-      '--bundle',
-      `--outfile=${serverOutput}`,
-      '--format=esm',
-      '--platform=node',
-      '--target=node18',
-      ...externalDeps.map(dep => `--external:${dep}`),
-      options.minify !== false ? '--minify' : '', // Default to minify
-      '--sourcemap',
-      '--log-level=warning'
-    ].filter(Boolean).join(' ');
-    
-    if (verbose) {
-      console.log(chalk.cyan('\n🔨 Building server bundle...'));
-      console.log(chalk.gray('  Entry:'), serverEntry);
-      console.log(chalk.gray('  Output:'), serverOutput);
-      console.log(chalk.gray('  Command:'), serverCmd);
-    }
-    
-    try {
-      execSync(serverCmd, {
-        stdio: verbose ? 'inherit' : 'pipe',
-        cwd: projectRoot
-      });
-      
-      if (verbose) {
-        const size = fs.statSync(serverOutput).size;
-        console.log(chalk.green('  ✓ Server bundle created'), chalk.gray(`(${formatFileSize(size)})`));
-      }
-    } catch (error) {
-      throw new Error(`Server build failed: ${(error as Error).message}`);
-    }
-  }
-  
-  // Build client bundle (if exists)
-  if (clientEntry) {
-    const clientOutput = path.join(outputDir, 'client', 'index.js');
-    
-    // For client bundle, we need different external dependencies
-    // Server-only packages should NOT be bundled in client
-    const clientExternal = [
-      // ⚠️ IMPORTANT: React and ReactDOM MUST be externalized
-      // All plugins must share the SAME React instance to avoid:
-      // - Context identity issues (createContext from different React instances are not equal)
-      // - Hook ordering problems (different React versions have different internal structures)
-      // - Memory leaks (multiple React renderers running simultaneously)
-      // - Dependency injection failures (contexts/services created by one React can't be used by another)
-      'react',              // Provided by SSR host application
-      'react-dom',          // Provided by SSR host application
-      'react-dom/client',   // Provided by SSR host application
-      
-      // UI slots interface is type-only, safe to external
-      '@linyjs/ui-slots-interface',
-      
-      // Explicitly exclude server-only packages
-      // These should never appear in client code, but just in case:
-      'express',
-      '@linyjs/server-module-interface',  // Server-only interface (type-only)
-      '@linyjs/mongodb',                  // Server-only service
-      
-      // NOTE: @linyjs/client-module-interface is NOT externalized
-      // because it contains runtime values (React Context, Hooks)
-      // that must be included in the client bundle
-    ];
-    
-    // Merge with user-provided externals (if any)
-    if (options.external) {
-      options.external.forEach(dep => {
-        if (!clientExternal.includes(dep)) {
-          clientExternal.push(dep);
-        }
-      });
-    }
-    
-    const clientCmd = [
-      'npx esbuild',
-      clientEntry,
-      '--bundle',
-      `--outfile=${clientOutput}`,
-      '--format=esm',
-      '--platform=browser',
-      '--target=es2020',
-      ...clientExternal.map(dep => `--external:${dep}`),
-      options.minify !== false ? '--minify' : '',
-      '--sourcemap',
-      '--log-level=warning'
-    ].filter(Boolean).join(' ');
-    
-    if (verbose) {
-      console.log(chalk.cyan('\n🔨 Building client bundle...'));
-      console.log(chalk.gray('  Entry:'), clientEntry);
-      console.log(chalk.gray('  Output:'), clientOutput);
-      console.log(chalk.gray('  Command:'), clientCmd);
-    }
-    
-    try {
-      execSync(clientCmd, {
-        stdio: verbose ? 'inherit' : 'pipe',
-        cwd: projectRoot
-      });
-      
-      if (verbose) {
-        const size = fs.statSync(clientOutput).size;
-        console.log(chalk.green('  ✓ Client bundle created'), chalk.gray(`(${formatFileSize(size)})`));
-      }
-    } catch (error) {
-      throw new Error(`Client build failed: ${(error as Error).message}`);
-    }
-  }
-  
-  return outputDir;
-}
-
-/**
- * Build with npm run build (fallback)
- */
-async function buildWithNpm(projectRoot: string, verbose: boolean): Promise<string> {
-  execSync('npm run build', {
-    stdio: verbose ? 'inherit' : 'pipe',
-    cwd: projectRoot
-  });
-  
-  // Try to detect output directory
-  const possibleDirs = ['dist', 'build', 'lib'];
-  for (const dir of possibleDirs) {
-    const fullPath = path.join(projectRoot, dir);
-    if (fs.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  
-  return path.join(projectRoot, 'dist');
-}
-
-/**
- * Find entry file for server or client
- */
-function findEntryFile(projectRoot: string, type: 'server' | 'client'): string | null {
-  const possibleEntries = [
-    `src/${type}/index.ts`,
-    `src/${type}/index.tsx`,
-    `src/${type}.ts`,
-    `src/${type}.tsx`,
-    `${type}/index.ts`
-  ];
-  
-  for (const entry of possibleEntries) {
-    const fullPath = path.join(projectRoot, entry);
-    if (fs.existsSync(fullPath)) {
-      return entry;
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Collect all output files
- */
-function collectOutputFiles(outputDir: string): string[] {
-  const files: string[] = [];
-  
-  function walk(dir: string) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      
-      if (entry.isDirectory()) {
-        // Skip node_modules and .git
-        if (entry.name === 'node_modules' || entry.name === '.git') {
-          continue;
-        }
-        walk(fullPath);
-      } else {
-        files.push(fullPath);
-      }
-    }
-  }
-  
-  walk(outputDir);
-  return files;
-}
-
-/**
- * Calculate total size of files
- */
-function calculateTotalSize(files: string[]): number {
-  return files.reduce((total, file) => {
-    try {
-      const stats = fs.statSync(file);
-      return total + stats.size;
-    } catch {
-      return total;
-    }
-  }, 0);
-}
-
-/**
- * Format file size
- */
-function formatFileSize(bytes: number): string {
-  const units = ['B', 'KB', 'MB', 'GB'];
-  let size = bytes;
-  let unitIndex = 0;
-  
-  while (size >= 1024 && unitIndex < units.length - 1) {
-    size /= 1024;
-    unitIndex++;
-  }
-  
-  return `${size.toFixed(2)} ${units[unitIndex]}`;
-}
-
-interface BuildSystem {
-  type: 'typescript' | 'esbuild' | 'webpack' | 'rollup' | 'custom';
-  name: string;
-  configFile: string | null;
-  command: string;
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "lib": ["ES2022", "dom"]
-  },
-  "include": ["src"]
-}