@next-vibe/checker 1.0.11 → 1.0.13

package/src/app/api/[locale]/system/builder/repository/bun-compiler.ts

@@ -0,0 +1,261 @@
+/**
+ * Bun Compiler Service
+ * Compiles executable files using Bun.build
+ */
+
+/// <reference types="bun-types" />
+
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import {
+  ErrorResponseTypes,
+  fail,
+  success,
+} from "next-vibe/shared/types/response.schema";
+
+import type { EndpointLogger } from "@/app/api/[locale]/system/unified-interface/shared/logger/endpoint";
+import type { TFunction } from "@/i18n/core/static-types";
+
+import type { BuildProfile, FileToCompile } from "../definition";
+import { PROFILE_DEFAULTS, ROOT_DIR, SIZE_THRESHOLDS } from "./constants";
+import { outputFormatter } from "./output-formatter";
+
+// ============================================================================
+// Default Externals
+// ============================================================================
+
+/** Default modules to externalize for executable builds */
+const DEFAULT_EXTERNALS = [
+  // React/Next.js - peer dependencies
+  "react",
+  "react-dom",
+  "next",
+  // React Native / Expo
+  "expo",
+  "react-native",
+  // Build tools with native binaries or side effects
+  "vite",
+  "@vitejs/plugin-react",
+  "vite-plugin-css-injected-by-js",
+  "vite-plugin-dts",
+  "@tailwindcss/vite",
+  "@tailwindcss/oxide",
+  "tailwindcss",
+  "rollup",
+  "esbuild",
+  "lightningcss",
+] as const;
+
+// ============================================================================
+// Interface
+// ============================================================================
+
+export interface IBunCompiler {
+  /**
+   * Compile a file using Bun.build
+   */
+  compileFile(
+    fileConfig: FileToCompile,
+    output: string[],
+    filesBuilt: string[],
+    logger: EndpointLogger,
+    t: TFunction,
+    dryRun?: boolean,
+    verbose?: boolean,
+    profile?: BuildProfile,
+    env?: Record<string, string>,
+  ): Promise<ResponseType<string[]>>;
+
+  /**
+   * Get default external modules
+   */
+  getDefaultExternals(): readonly string[];
+}
+
+// ============================================================================
+// Implementation
+// ============================================================================
+
+export class BunCompiler implements IBunCompiler {
+  async compileFile(
+    fileConfig: FileToCompile,
+    output: string[],
+    filesBuilt: string[],
+    logger: EndpointLogger,
+    t: TFunction,
+    dryRun?: boolean,
+    verbose?: boolean,
+    profile: BuildProfile = "development",
+    env?: Record<string, string>,
+  ): Promise<ResponseType<string[]>> {
+    const profileSettings = PROFILE_DEFAULTS[profile];
+    const compiledFiles: string[] = [];
+    const warnings: string[] = [];
+
+    const { bunOptions = {} } = fileConfig;
+    const entrypointPath = resolve(ROOT_DIR, fileConfig.input);
+    const outfilePath = resolve(ROOT_DIR, fileConfig.output);
+    const outDir = dirname(outfilePath);
+
+    if (!existsSync(entrypointPath)) {
+      return fail({
+        message: "app.api.system.builder.errors.inputFileNotFound",
+        messageParams: {
+          filePath: fileConfig.input,
+        },
+        errorType: ErrorResponseTypes.NOT_FOUND,
+      });
+    }
+
+    output.push(
+      outputFormatter.formatItem(
+        fileConfig.input,
+        `\u2192 ${fileConfig.output} (executable)`,
+      ),
+    );
+    logger.info("Compiling executable with Bun", {
+      input: fileConfig.input,
+      target: bunOptions?.target || "bun",
+      profile,
+    });
+
+    if (verbose) {
+      output.push(
+        outputFormatter.formatVerbose(`Target: ${bunOptions?.target || "bun"}`),
+      );
+      output.push(outputFormatter.formatVerbose(`Profile: ${profile}`));
+      output.push(
+        outputFormatter.formatVerbose(
+          `Minify: ${bunOptions?.minify ?? profileSettings.minify}`,
+        ),
+      );
+      output.push(
+        outputFormatter.formatVerbose(
+          `Sourcemap: ${bunOptions?.sourcemap || profileSettings.sourcemap}`,
+        ),
+      );
+    }
+
+    if (dryRun) {
+      compiledFiles.push(fileConfig.output);
+      filesBuilt.push(fileConfig.output);
+      return success(compiledFiles);
+    }
+
+    // Ensure output directory exists
+    if (!existsSync(outDir)) {
+      mkdirSync(outDir, { recursive: true });
+    }
+
+    // Merge default and custom externals
+    const externals = [
+      ...DEFAULT_EXTERNALS,
+      ...(fileConfig.modulesToExternalize || []),
+      ...(bunOptions?.external || []),
+    ];
+
+    // Build define object for env vars
+    const define: Record<string, string> = {
+      ...bunOptions?.define,
+    };
+    if (env) {
+      for (const [key, value] of Object.entries(env)) {
+        define[`process.env.${key}`] = JSON.stringify(value);
+      }
+    }
+
+    // Determine sourcemap setting
+    const sourcemap =
+      bunOptions?.sourcemap ||
+      (profileSettings.sourcemap === false
+        ? "none"
+        : profileSettings.sourcemap === true
+          ? "external"
+          : (profileSettings.sourcemap as "external" | "inline" | "none"));
+
+    // Build with Bun
+    const result = await Bun.build({
+      entrypoints: [entrypointPath],
+      outdir: outDir,
+      target: bunOptions?.target || "bun",
+      minify: bunOptions?.minify ?? profileSettings.minify,
+      sourcemap,
+      external: externals,
+      naming: bunOptions?.naming || { entry: basename(fileConfig.output) },
+      define: Object.keys(define).length > 0 ? define : undefined,
+      splitting: bunOptions?.splitting,
+      format: bunOptions?.format,
+      publicPath: bunOptions?.publicPath,
+      root: bunOptions?.root,
+      conditions: bunOptions?.conditions,
+      loader: bunOptions?.loader,
+      drop: bunOptions?.drop,
+      banner: bunOptions?.banner,
+      footer: bunOptions?.footer,
+      bytecode: bunOptions?.bytecode,
+    });
+
+    if (!result.success) {
+      const errorMessages = result.logs
+        .filter((log): log is BuildMessage => log.level === "error")
+        .map((log) => log.message)
+        .join("\n");
+      return fail({
+        message: "app.api.system.builder.messages.bundleFailed",
+        messageParams: {
+          error: errorMessages || "Unknown error",
+        },
+        errorType: ErrorResponseTypes.INTERNAL_ERROR,
+      });
+    }
+
+    // Get file size and check thresholds
+    const size = existsSync(outfilePath) ? statSync(outfilePath).size : 0;
+
+    if (size > SIZE_THRESHOLDS.CRITICAL) {
+      warnings.push(
+        t("app.api.system.builder.analysis.criticalSize", {
+          size: outputFormatter.formatBytes(size),
+        }),
+      );
+    } else if (size > SIZE_THRESHOLDS.WARNING) {
+      warnings.push(
+        t("app.api.system.builder.analysis.largeBundle", {
+          size: outputFormatter.formatBytes(size),
+        }),
+      );
+    }
+
+    compiledFiles.push(fileConfig.output);
+    filesBuilt.push(fileConfig.output);
+
+    // Format success message with size indicator
+    const sizeIndicator = outputFormatter.getSizeIndicator(size);
+    output.push(
+      outputFormatter.formatSuccess(
+        `${sizeIndicator} ${t("app.api.system.builder.messages.bundleSuccess")} (${outputFormatter.formatBytes(size)})`,
+      ),
+    );
+    logger.info("Executable compiled successfully", {
+      outfile: fileConfig.output,
+      size,
+      profile,
+    });
+
+    // Log warnings
+    for (const warning of warnings) {
+      output.push(outputFormatter.formatWarning(warning));
+    }
+
+    return success(compiledFiles);
+  }
+
+  getDefaultExternals(): readonly string[] {
+    return DEFAULT_EXTERNALS;
+  }
+}
+
+// Singleton instance
+export const bunCompiler = new BunCompiler();

package/src/app/api/[locale]/system/builder/repository/bundle-analyzer.ts

@@ -0,0 +1,197 @@
+/**
+ * Bundle Analyzer Service
+ * Analyzes bundle sizes and provides optimization suggestions
+ */
+
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+
+import type { TFunction } from "@/i18n/core/static-types";
+
+import type { BundleAnalysis } from "../definition";
+import { ROOT_DIR, SIZE_THRESHOLDS } from "./constants";
+import { outputFormatter } from "./output-formatter";
+
+// ============================================================================
+// Interface
+// ============================================================================
+
+export interface IBundleAnalyzer {
+  /**
+   * Analyze bundle sizes and generate optimization suggestions
+   */
+  analyze(
+    outputDir: string,
+    output: string[],
+    t: TFunction,
+  ): Promise<BundleAnalysis>;
+
+  /**
+   * Get all files recursively from a directory
+   */
+  getAllFiles(dir: string): Array<{ path: string; size: number }>;
+
+  /**
+   * Check if size exceeds warning threshold
+   */
+  isWarningSize(size: number): boolean;
+
+  /**
+   * Check if size exceeds critical threshold
+   */
+  isCriticalSize(size: number): boolean;
+}
+
+// ============================================================================
+// Implementation
+// ============================================================================
+
+export class BundleAnalyzer implements IBundleAnalyzer {
+  async analyze(
+    outputDir: string,
+    output: string[],
+    t: TFunction,
+  ): Promise<BundleAnalysis> {
+    const dirPath = resolve(ROOT_DIR, outputDir);
+    const analysis: BundleAnalysis = {
+      totalSize: 0,
+      files: [],
+      suggestions: [],
+      warnings: [],
+    };
+
+    if (!existsSync(dirPath)) {
+      return analysis;
+    }
+
+    const allFiles = this.getAllFiles(dirPath);
+    analysis.totalSize = allFiles.reduce((sum, f) => sum + f.size, 0);
+
+    // Get top 5 largest files
+    analysis.files = allFiles
+      .toSorted((a, b) => b.size - a.size)
+      .slice(0, 5)
+      .map((f) => ({
+        name: f.path,
+        size: f.size,
+        percentage:
+          analysis.totalSize > 0 ? (f.size / analysis.totalSize) * 100 : 0,
+      }));
+
+    // Generate suggestions based on analysis
+    if (analysis.totalSize > SIZE_THRESHOLDS.CRITICAL) {
+      analysis.warnings.push(
+        t("app.api.system.builder.analysis.criticalSize", {
+          size: outputFormatter.formatBytes(analysis.totalSize),
+        }),
+      );
+      analysis.suggestions.push(
+        t("app.api.system.builder.analysis.considerTreeShaking"),
+      );
+      analysis.suggestions.push(
+        t("app.api.system.builder.analysis.checkLargeDeps"),
+      );
+    } else if (analysis.totalSize > SIZE_THRESHOLDS.WARNING) {
+      analysis.warnings.push(
+        t("app.api.system.builder.analysis.largeBundle", {
+          size: outputFormatter.formatBytes(analysis.totalSize),
+        }),
+      );
+    }
+
+    // Check for common issues
+    const jsFiles = allFiles.filter(
+      (f) => f.path.endsWith(".js") || f.path.endsWith(".mjs"),
+    );
+    const mapFiles = allFiles.filter((f) => f.path.endsWith(".map"));
+
+    if (mapFiles.length > 0) {
+      const mapSize = mapFiles.reduce((sum, f) => sum + f.size, 0);
+      if (mapSize > analysis.totalSize * 0.5) {
+        analysis.suggestions.push(
+          t("app.api.system.builder.analysis.largeSourcemaps"),
+        );
+      }
+    }
+
+    // Check for duplicate-looking files
+    const baseNames = jsFiles.map((f) => basename(f.path, extname(f.path)));
+    const duplicates = baseNames.filter(
+      (name, idx) => baseNames.indexOf(name) !== idx,
+    );
+    if (duplicates.length > 0) {
+      analysis.suggestions.push(
+        t("app.api.system.builder.analysis.possibleDuplicates"),
+      );
+    }
+
+    // Output analysis
+    if (analysis.files.length > 0) {
+      output.push(
+        outputFormatter.formatSection(
+          t("app.api.system.builder.messages.bundleAnalysis"),
+        ),
+      );
+      output.push(
+        outputFormatter.formatItem(
+          t("app.api.system.builder.analysis.totalSize"),
+          outputFormatter.formatBytes(analysis.totalSize),
+        ),
+      );
+      output.push(
+        outputFormatter.formatStep(
+          t("app.api.system.builder.analysis.largestFiles"),
+        ),
+      );
+      for (const file of analysis.files) {
+        output.push(
+          outputFormatter.formatItem(
+            `  ${file.name}`,
+            `${outputFormatter.formatBytes(file.size)} (${file.percentage.toFixed(1)}%)`,
+          ),
+        );
+      }
+    }
+
+    return analysis;
+  }
+
+  getAllFiles(dir: string): Array<{ path: string; size: number }> {
+    const files: Array<{ path: string; size: number }> = [];
+    const basePath = dir;
+
+    const processDir = (currentDir: string): void => {
+      try {
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = resolve(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            processDir(fullPath);
+          } else {
+            const stats = statSync(fullPath);
+            files.push({
+              path: fullPath.replace(basePath, ""),
+              size: stats.size,
+            });
+          }
+        }
+      } catch {
+        // Ignore errors reading directory
+      }
+    };
+
+    processDir(dir);
+    return files;
+  }
+
+  isWarningSize(size: number): boolean {
+    return size > SIZE_THRESHOLDS.WARNING;
+  }
+
+  isCriticalSize(size: number): boolean {
+    return size > SIZE_THRESHOLDS.CRITICAL;
+  }
+}
+
+// Singleton instance
+export const bundleAnalyzer = new BundleAnalyzer();

package/src/app/api/[locale]/system/builder/repository/config-loader.ts

@@ -0,0 +1,159 @@
+/**
+ * Config Loader Service
+ * Loads build configuration from files or inline data
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import {
+  ErrorResponseTypes,
+  fail,
+  success,
+} from "next-vibe/shared/types/response.schema";
+
+import type { EndpointLogger } from "@/app/api/[locale]/system/unified-interface/shared/logger/endpoint";
+import type { TFunction } from "@/i18n/core/static-types";
+
+import type {
+  BuildConfig,
+  CopyConfig,
+  FileToCompile,
+  NpmPackageConfig,
+} from "../definition";
+import { ROOT_DIR } from "./constants";
+import { outputFormatter } from "./output-formatter";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Inline configuration input matching request type */
+export interface InlineConfigInput {
+  foldersToClean?: string[];
+  filesToCompile?: FileToCompile[];
+  filesOrFoldersToCopy?: CopyConfig[];
+  npmPackage?: NpmPackageConfig;
+}
+
+/** Type for dynamically imported build config module */
+interface BuildConfigModule {
+  default: BuildConfig;
+}
+
+// ============================================================================
+// Interface
+// ============================================================================
+
+export interface IConfigLoader {
+  /**
+   * Load build configuration from file or inline data
+   */
+  load(
+    configPath: string | undefined,
+    inlineConfig: InlineConfigInput | undefined,
+    output: string[],
+    logger: EndpointLogger,
+    t: TFunction,
+  ): Promise<ResponseType<BuildConfig>>;
+
+  /**
+   * Check if a config file exists
+   */
+  exists(configPath: string): boolean;
+
+  /**
+   * Validate that a module exports a valid build config
+   */
+  isValidBuildConfigModule(
+    module: BuildConfigModule | Record<string, BuildConfig | undefined>,
+  ): module is BuildConfigModule;
+}
+
+// ============================================================================
+// Implementation
+// ============================================================================
+
+export class ConfigLoader implements IConfigLoader {
+  async load(
+    configPath: string | undefined,
+    inlineConfig: InlineConfigInput | undefined,
+    output: string[],
+    logger: EndpointLogger,
+    t: TFunction,
+  ): Promise<ResponseType<BuildConfig>> {
+    // Use config file if path provided
+    if (configPath) {
+      const fullPath = resolve(ROOT_DIR, configPath);
+
+      if (!existsSync(fullPath)) {
+        return fail({
+          message: "app.api.system.builder.errors.configNotFound",
+          messageParams: {
+            path: configPath,
+          },
+          errorType: ErrorResponseTypes.NOT_FOUND,
+        });
+      }
+
+      output.push(
+        outputFormatter.formatStep(
+          t("app.api.system.builder.messages.loadingConfig", {
+            path: configPath,
+          }),
+        ),
+      );
+      logger.info("Loading build config", { path: fullPath });
+
+      const importedModule = (await import(fullPath)) as
+        | BuildConfigModule
+        | Record<string, BuildConfig | undefined>;
+
+      if (!this.isValidBuildConfigModule(importedModule)) {
+        return fail({
+          message: "app.api.system.builder.errors.invalidBuildConfig",
+          errorType: ErrorResponseTypes.VALIDATION_ERROR,
+        });
+      }
+
+      return success(importedModule.default);
+    }
+
+    // Use inline configuration
+    output.push(
+      outputFormatter.formatStep(
+        t("app.api.system.builder.messages.usingInlineConfig"),
+      ),
+    );
+    logger.info("Using inline config");
+
+    return success({
+      foldersToClean: inlineConfig?.foldersToClean,
+      filesToCompile: inlineConfig?.filesToCompile,
+      filesOrFoldersToCopy: inlineConfig?.filesOrFoldersToCopy,
+      npmPackage: inlineConfig?.npmPackage,
+    });
+  }
+
+  exists(configPath: string): boolean {
+    const fullPath = resolve(ROOT_DIR, configPath);
+    return existsSync(fullPath);
+  }
+
+  isValidBuildConfigModule(
+    module: BuildConfigModule | Record<string, BuildConfig | undefined>,
+  ): module is BuildConfigModule {
+    if (typeof module !== "object" || module === null) {
+      return false;
+    }
+    if (!("default" in module)) {
+      return false;
+    }
+    const defaultExport = module.default;
+    return typeof defaultExport === "object" && defaultExport !== null;
+  }
+}
+
+// Singleton instance
+export const configLoader = new ConfigLoader();

package/src/app/api/[locale]/system/builder/repository/config-validator.ts

@@ -0,0 +1,97 @@
+/**
+ * Config Validator Service
+ * Validates build configuration
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+import type { TFunction } from "@/i18n/core/static-types";
+
+import type { BuildConfig } from "../definition";
+import { ROOT_DIR } from "./constants";
+
+/** Validation result */
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+// ============================================================================
+// Interface
+// ============================================================================
+
+export interface IConfigValidator {
+  /**
+   * Validate build configuration and return detailed errors/warnings
+   */
+  validate(config: BuildConfig, t: TFunction): ValidationResult;
+}
+
+// ============================================================================
+// Implementation
+// ============================================================================
+
+export class ConfigValidator implements IConfigValidator {
+  validate(config: BuildConfig, t: TFunction): ValidationResult {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Check if there's anything to build
+    if (
+      !config.foldersToClean?.length &&
+      !config.filesToCompile?.length &&
+      !config.filesOrFoldersToCopy?.length &&
+      !config.npmPackage
+    ) {
+      errors.push(t("app.api.system.builder.errors.emptyConfig"));
+    }
+
+    // Validate file paths for filesToCompile
+    if (config.filesToCompile) {
+      for (const file of config.filesToCompile) {
+        const inputPath = resolve(ROOT_DIR, file.input);
+        if (!existsSync(inputPath)) {
+          errors.push(
+            t("app.api.system.builder.errors.inputFileNotFound", {
+              filePath: file.input,
+            }),
+          );
+        }
+
+        // Check for common mistakes
+        if (file.output.endsWith("/")) {
+          warnings.push(
+            t("app.api.system.builder.warnings.outputIsDirectory", {
+              path: file.output,
+            }),
+          );
+        }
+      }
+    }
+
+    // Validate copy paths
+    if (config.filesOrFoldersToCopy) {
+      for (const copyConfig of config.filesOrFoldersToCopy) {
+        const srcPath = resolve(ROOT_DIR, copyConfig.input);
+        if (!existsSync(srcPath)) {
+          warnings.push(
+            t("app.api.system.builder.warnings.sourceNotFound", {
+              path: copyConfig.input,
+            }),
+          );
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+    };
+  }
+}
+
+// Singleton instance
+export const configValidator = new ConfigValidator();