@nlabs/lex 1.49.5 → 1.50.1

package/lib/commands/build/build.js

@@ -1,455 +1,352 @@
-import GraphqlLoaderPlugin from "@luckycatfactory/esbuild-graphql-loader";
-import { execa } from "execa";
-import { existsSync, readFileSync } from "fs";
-import { sync as globSync } from "glob";
-import { dirname, resolve as pathResolve } from "path";
-import { LexConfig, getTypeScriptConfigPath } from "../../LexConfig.js";
-import { checkLinkedModules, copyConfiguredFiles, createSpinner, handleWebpackProgress, removeFiles } from "../../utils/app.js";
-import { getDirName, relativeNodePath, resolveWebpackPaths, getLexPackageJsonPath } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-import { processTranslations } from "../../utils/translations.js";
-import { aiFunction } from "../ai/ai.js";
-import boxen from "boxen";
-import chalk from "chalk";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { transform } from '@swc/core';
+import { execa } from 'execa';
+import { existsSync, readFileSync } from 'fs';
+import { sync as globSync } from 'glob';
+import { dirname, resolve as pathResolve } from 'path';
+import { LexConfig, getTypeScriptConfigPath } from '../../LexConfig.js';
+import { checkLinkedModules, copyConfiguredFiles, createSpinner, handleWebpackProgress, removeFiles } from '../../utils/app.js';
+import { resolveWebpackPaths, getLexPackageJsonPath } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+import { processTranslations } from '../../utils/translations.js';
+import { aiFunction } from '../ai/ai.js';
+import boxen from 'boxen';
+import chalk from 'chalk';
 let currentFilename;
 let currentDirname;
 try {
-  currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
-  currentDirname = dirname(currentFilename);
-} catch {
-  currentFilename = process.cwd();
-  currentDirname = process.cwd();
+    currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
+    currentDirname = dirname(currentFilename);
+} catch  {
+    currentFilename = process.cwd();
+    currentDirname = process.cwd();
 }
-const displayBuildStatus = (bundler, outputPath, quiet, stats) => {
-  if (quiet) return;
-  let statsInfo = "";
-  if (stats && stats.modules && stats.assets) {
-    statsInfo = `
-${chalk.green("Modules:")}    ${chalk.cyan(stats.modules)}
-${chalk.green("Assets:")}     ${chalk.cyan(stats.assets)}
-${chalk.green("Size:")}       ${chalk.cyan(stats.size)}
-`;
-  }
-  const statusBox = boxen(
-    `${chalk.cyan.bold("\u{1F3D7}\uFE0F  Build Completed Successfully")}
-
-${chalk.green("Bundler:")}    ${chalk.cyan(bundler)}
-${chalk.green("Output:")}     ${chalk.underline(outputPath)}${statsInfo}
-${chalk.yellow("Ready for deployment! \u{1F680}")}`,
-    {
-      padding: 1,
-      margin: 1,
-      borderStyle: "round",
-      borderColor: "green",
-      backgroundColor: "#1a1a1a"
+const displayBuildStatus = (bundler, outputPath, quiet, stats)=>{
+    if (quiet) return;
+    let statsInfo = '';
+    if (stats && stats.modules && stats.assets) {
+        statsInfo = `\n${chalk.green('Modules:')}    ${chalk.cyan(stats.modules)}\n` + `${chalk.green('Assets:')}     ${chalk.cyan(stats.assets)}\n` + `${chalk.green('Size:')}       ${chalk.cyan(stats.size)}\n`;
     }
-  );
-  console.log("\n" + statusBox + "\n");
-};
-const buildWithEsBuild = async (spinner, commandOptions, callback) => {
-  const {
-    cliName = "Lex",
-    format = "esm",
-    outputPath,
-    quiet,
-    sourcePath,
-    watch
-  } = commandOptions;
-  const {
-    outputFullPath,
-    sourceFullPath,
-    targetEnvironment,
-    useGraphQl,
-    useTypescript
-  } = LexConfig.config;
-  const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || "";
-  const loader = {
-    ".js": "js"
-  };
-  if (useTypescript) {
-    loader[".ts"] = "ts";
-    loader[".tsx"] = "tsx";
-  }
-  const plugins = [];
-  if (useGraphQl) {
-    plugins.push(GraphqlLoaderPlugin());
-  }
-  const globOptions = {
-    cwd: sourceDir,
-    dot: false,
-    nodir: true,
-    nosort: true
-  };
-  const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);
-  const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);
-  const sourceFiles = [...tsFiles, ...jsFiles];
-  const packageJsonData = readFileSync(pathResolve(process.cwd(), "./package.json"));
-  const packageJson = JSON.parse(packageJsonData.toString());
-  const external = [
-    ...Object.keys(packageJson.dependencies || {}),
-    ...Object.keys(packageJson.peerDependencies || {})
-  ];
-  const dirName = getDirName();
-  const dirPath = pathResolve(dirName, "../..");
-  const outputDir = outputPath || outputFullPath || "";
-  const esbuildPath = relativeNodePath("esbuild/bin/esbuild", dirPath);
-  const esbuildConfig = LexConfig.config.esbuild || {};
-  const esbuildOptions = [
-    ...sourceFiles,
-    "--bundle",
-    "--color=true",
-    `--format=${format}`,
-    `--outdir=${outputDir}`,
-    `--platform=${esbuildConfig.platform || "node"}`,
-    `--target=${esbuildConfig.target || (targetEnvironment === "node" ? "node20" : "es2020")}`,
-    `--sourcemap=${esbuildConfig.sourcemap || "inline"}`
-  ];
-  if (esbuildConfig.minify !== false) {
-    esbuildOptions.push("--minify");
-  }
-  if (esbuildConfig.treeShaking !== false) {
-    esbuildOptions.push("--tree-shaking=true");
-  }
-  if (esbuildConfig.drop && esbuildConfig.drop.length > 0) {
-    esbuildConfig.drop.forEach((item) => {
-      esbuildOptions.push(`--drop:${item}`);
-    });
-  }
-  if (esbuildConfig.pure && esbuildConfig.pure.length > 0) {
-    esbuildConfig.pure.forEach((item) => {
-      esbuildOptions.push(`--pure:${item}`);
-    });
-  }
-  if (esbuildConfig.legalComments) {
-    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);
-  }
-  if (esbuildConfig.splitting !== false) {
-    esbuildOptions.push("--splitting");
-  }
-  if (esbuildConfig.metafile) {
-    esbuildOptions.push("--metafile");
-  }
-  if (esbuildConfig.banner) {
-    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {
-      esbuildOptions.push(`--banner:${type}=${content}`);
+    const statusBox = boxen(`${chalk.cyan.bold('🏗️  Build Completed Successfully')}\n\n` + `${chalk.green('Bundler:')}    ${chalk.cyan(bundler)}\n` + `${chalk.green('Output:')}     ${chalk.underline(outputPath)}${statsInfo}\n` + `${chalk.yellow('Ready for deployment! 🚀')}`, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'green',
+        backgroundColor: '#1a1a1a'
     });
-  }
-  if (esbuildConfig.footer) {
-    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {
-      esbuildOptions.push(`--footer:${type}=${content}`);
-    });
-  }
-  if (esbuildConfig.define) {
-    Object.entries(esbuildConfig.define).forEach(([key, value]) => {
-      esbuildOptions.push(`--define:${key}=${value}`);
-    });
-  }
-  if (external.length) {
-    esbuildOptions.push(`--external:${external.join(",")}`);
-  }
-  if (plugins.length) {
-    esbuildOptions.push(`--plugins=${plugins.join(",")}`);
-  }
-  if (watch) {
-    esbuildOptions.push("--watch");
-  }
-  try {
-    await execa(esbuildPath, esbuildOptions, { encoding: "utf8" });
-    spinner.succeed("Build completed successfully!");
-    displayBuildStatus("esbuild", outputDir, quiet);
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    if (!quiet) {
-      console.error(error);
-    }
-    spinner.fail("Code build failed.");
-    if (commandOptions.assist) {
-      spinner.start("AI is analyzing the error...");
-      try {
-        await aiFunction({
-          prompt: `Fix this esbuild error: ${error.message}
-
-Error details:
-${error.toString()}`,
-          task: "help",
-          context: true,
-          quiet
-        });
-        spinner.succeed("AI analysis complete");
-      } catch (aiError) {
-        spinner.fail("Could not generate AI assistance");
+    console.log('\n' + statusBox + '\n');
+};
+// Removed buildWithEsBuild function - using SWC instead
+export const buildWithSWC = async (spinner, commandOptions, callback)=>{
+    const { cliName = 'Lex', format = 'esm', outputPath, quiet, sourcePath, watch } = commandOptions;
+    const { outputFullPath, sourceFullPath, swc: swcConfig, targetEnvironment, useGraphQl, useTypescript } = LexConfig.config;
+    const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';
+    const globOptions = {
+        cwd: sourceDir,
+        dot: false,
+        nodir: true,
+        nosort: true
+    };
+    const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);
+    const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);
+    const sourceFiles = [
+        ...tsFiles,
+        ...jsFiles
+    ];
+    const outputDir = outputPath || outputFullPath || '';
+    try {
+        spinner.start('Building with SWC...');
+        for (const file of sourceFiles){
+            const sourcePath = pathResolve(sourceDir, file);
+            const outputPath = pathResolve(outputDir, file.replace(/\.(ts|tsx)$/, '.js'));
+            // Ensure output directory exists
+            const outputDirPath = dirname(outputPath);
+            if (!existsSync(outputDirPath)) {
+                const { mkdirSync } = await import('fs');
+                mkdirSync(outputDirPath, {
+                    recursive: true
+                });
+            }
+            const sourceCode = readFileSync(sourcePath, 'utf8');
+            const isTSX = file.endsWith('.tsx');
+            // Merge SWC config with command-specific overrides
+            const swcOptions = {
+                filename: file,
+                ...swcConfig,
+                jsc: {
+                    ...swcConfig?.jsc,
+                    parser: {
+                        syntax: 'typescript',
+                        tsx: isTSX,
+                        decorators: swcConfig?.jsc?.parser?.decorators ?? true,
+                        dynamicImport: swcConfig?.jsc?.parser?.dynamicImport ?? true
+                    },
+                    target: swcConfig?.jsc?.target ?? 'es2020',
+                    transform: isTSX ? {
+                        ...swcConfig?.jsc?.transform,
+                        react: {
+                            runtime: 'automatic',
+                            ...swcConfig?.jsc?.transform?.react
+                        }
+                    } : swcConfig?.jsc?.transform
+                },
+                module: {
+                    ...swcConfig?.module,
+                    type: format === 'cjs' ? 'commonjs' : swcConfig?.module?.type || 'es6'
+                }
+            };
+            const result = await transform(sourceCode, swcOptions);
+            const { writeFileSync } = await import('fs');
+            writeFileSync(outputPath, result.code);
+        }
+        spinner.succeed('Build completed with SWC');
+        displayBuildStatus('SWC', outputDir, quiet);
+        callback(0);
+        return 0;
+    } catch (error) {
+        spinner.fail('Build failed with SWC');
         if (!quiet) {
-          console.error("AI assistance error:", aiError);
+            console.error(error);
         }
-      }
+        callback(1);
+        return 1;
     }
-    callback(1);
-    return 1;
-  }
-  callback(0);
-  return 0;
 };
-const buildWithWebpack = async (spinner, cmd, callback) => {
-  const {
-    analyze,
-    cliName = "Lex",
-    config,
-    configName,
-    defineProcessEnvNodeEnv,
-    devtool,
-    disableInterpret,
-    entry,
-    env,
-    failOnWarnings,
-    json,
-    merge,
-    mode,
-    name,
-    nodeEnv,
-    noDevtool,
-    noStats,
-    noTarget,
-    noWatch,
-    noWatchOptionsStdin,
-    outputPath,
-    quiet = false,
-    stats,
-    target,
-    watch,
-    watchOptionsStdin
-  } = cmd;
-  console.log("entry:", entry, "type:", typeof entry);
-  console.log("outputPath:", outputPath, "type:", typeof outputPath);
-  const entryValue = Array.isArray(entry) ? entry[0] : entry;
-  let webpackConfig;
-  if (config) {
-    const isRelativeConfig = config.substr(0, 2) === "./";
-    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
-  } else {
-    const projectConfigPath = pathResolve(process.cwd(), "webpack.config.js");
-    const projectConfigPathTs = pathResolve(process.cwd(), "webpack.config.ts");
-    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);
-    if (hasProjectConfig) {
-      webpackConfig = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;
+export const buildWithWebpack = async (spinner, cmd, callback)=>{
+    const { analyze, cliName = 'Lex', config, configName, defineProcessEnvNodeEnv, devtool, disableInterpret, entry, env, failOnWarnings, json, merge, mode, name, nodeEnv, noDevtool, noStats, noTarget, noWatch, noWatchOptionsStdin, outputPath, quiet = false, stats, target, watch, watchOptionsStdin } = cmd;
+    console.log('entry:', entry, 'type:', typeof entry);
+    console.log('outputPath:', outputPath, 'type:', typeof outputPath);
+    const entryValue = Array.isArray(entry) ? entry[0] : entry;
+    let webpackConfig;
+    if (config) {
+        const isRelativeConfig = config.substr(0, 2) === './';
+        webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
     } else {
-      const { webpackConfig: resolvedConfig } = resolveWebpackPaths(currentDirname);
-      webpackConfig = resolvedConfig;
+        const projectConfigPath = pathResolve(process.cwd(), 'webpack.config.js');
+        const projectConfigPathTs = pathResolve(process.cwd(), 'webpack.config.ts');
+        const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);
+        if (hasProjectConfig) {
+            webpackConfig = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;
+        } else {
+            const { webpackConfig: resolvedConfig } = resolveWebpackPaths(currentDirname);
+            webpackConfig = resolvedConfig;
+        }
     }
-  }
-  console.log("webpackConfig path:", webpackConfig);
-  console.log("webpackConfig exists:", existsSync(webpackConfig));
-  if (!existsSync(webpackConfig)) {
-    const lexPackagePath = getLexPackageJsonPath();
-    const lexPackageDir = dirname(lexPackagePath);
-    const lexWebpackConfig = pathResolve(lexPackageDir, "webpack.config.js");
-    if (existsSync(lexWebpackConfig)) {
-      webpackConfig = lexWebpackConfig;
-      console.log("Using Lex webpack config:", webpackConfig);
-    } else {
-      log(`
-${cliName} Error: Could not find webpack.config.js`, "error", quiet);
-      spinner.fail("Build failed.");
-      callback(1);
-      return 1;
+    console.log('webpackConfig path:', webpackConfig);
+    console.log('webpackConfig exists:', existsSync(webpackConfig));
+    if (!existsSync(webpackConfig)) {
+        const lexPackagePath = getLexPackageJsonPath();
+        const lexPackageDir = dirname(lexPackagePath);
+        const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');
+        if (existsSync(lexWebpackConfig)) {
+            webpackConfig = lexWebpackConfig;
+            console.log('Using Lex webpack config:', webpackConfig);
+        } else {
+            log(`\n${cliName} Error: Could not find webpack.config.js`, 'error', quiet);
+            spinner.fail('Build failed.');
+            callback(1);
+            return 1;
+        }
     }
-  }
-  const webpackOptions = [
-    "--color",
-    "--progress",
-    "--config",
-    webpackConfig
-  ];
-  if (analyze) webpackOptions.push("--analyze");
-  if (configName) webpackOptions.push("--configName", configName);
-  if (defineProcessEnvNodeEnv) webpackOptions.push("--defineProcessEnvNodeEnv", defineProcessEnvNodeEnv);
-  if (devtool) webpackOptions.push("--devtool", devtool);
-  if (disableInterpret) webpackOptions.push("--disableInterpret");
-  if (entryValue) webpackOptions.push("--entry", entryValue.toString());
-  if (env) webpackOptions.push("--env", env);
-  if (failOnWarnings) webpackOptions.push("--failOnWarnings");
-  if (json) webpackOptions.push("--json", json);
-  if (mode) webpackOptions.push("--mode", mode);
-  if (merge) webpackOptions.push("--merge");
-  if (name) webpackOptions.push("--name", name);
-  if (noDevtool) webpackOptions.push("--noDevtool");
-  if (noStats) webpackOptions.push("--noStats");
-  if (noTarget) webpackOptions.push("--noTarget");
-  if (noWatch) webpackOptions.push("--noWatch");
-  if (noWatchOptionsStdin) webpackOptions.push("--noWatchOptionsStdin");
-  if (nodeEnv) webpackOptions.push("--nodeEnv", nodeEnv);
-  if (outputPath) webpackOptions.push("--output-path", outputPath.toString());
-  if (stats) webpackOptions.push("--stats", stats);
-  if (target) webpackOptions.push("--target", target);
-  if (watch) webpackOptions.push("--watch");
-  if (watchOptionsStdin) webpackOptions.push("--watchOptionsStdin");
-  try {
-    const { webpackPath } = resolveWebpackPaths(currentDirname);
-    let finalWebpackOptions;
-    if (webpackPath === "npx") {
-      finalWebpackOptions = ["webpack", ...webpackOptions];
-    } else {
-      finalWebpackOptions = [...webpackOptions];
+    const webpackOptions = [
+        '--color',
+        '--progress',
+        '--config',
+        webpackConfig
+    ];
+    if (analyze) webpackOptions.push('--analyze');
+    if (configName) webpackOptions.push('--configName', configName);
+    if (defineProcessEnvNodeEnv) webpackOptions.push('--defineProcessEnvNodeEnv', defineProcessEnvNodeEnv);
+    if (devtool) webpackOptions.push('--devtool', devtool);
+    if (disableInterpret) webpackOptions.push('--disableInterpret');
+    // Pass entry directly as CLI flag
+    if (entryValue) webpackOptions.push('--entry', entryValue.toString());
+    if (env) webpackOptions.push('--env', env);
+    if (failOnWarnings) webpackOptions.push('--failOnWarnings');
+    if (json) webpackOptions.push('--json', json);
+    if (mode) webpackOptions.push('--mode', mode);
+    if (merge) webpackOptions.push('--merge');
+    if (name) webpackOptions.push('--name', name);
+    if (noDevtool) webpackOptions.push('--noDevtool');
+    if (noStats) webpackOptions.push('--noStats');
+    if (noTarget) webpackOptions.push('--noTarget');
+    if (noWatch) webpackOptions.push('--noWatch');
+    if (noWatchOptionsStdin) webpackOptions.push('--noWatchOptionsStdin');
+    if (nodeEnv) webpackOptions.push('--nodeEnv', nodeEnv);
+    if (outputPath) webpackOptions.push('--output-path', outputPath.toString()); // Convert to string
+    if (stats) webpackOptions.push('--stats', stats);
+    if (target) webpackOptions.push('--target', target);
+    if (watch) webpackOptions.push('--watch');
+    if (watchOptionsStdin) webpackOptions.push('--watchOptionsStdin');
+    try {
+        const { webpackPath } = resolveWebpackPaths(currentDirname);
+        // Fix: Ensure finalWebpackOptions is always an array of strings
+        let finalWebpackOptions;
+        if (webpackPath === 'npx') {
+            finalWebpackOptions = [
+                'webpack',
+                ...webpackOptions
+            ];
+        } else {
+            finalWebpackOptions = [
+                ...webpackOptions
+            ];
+        }
+        console.log('webpackPath:', webpackPath);
+        console.log('finalWebpackOptions:', JSON.stringify(finalWebpackOptions));
+        console.log('finalWebpackOptions type:', Array.isArray(finalWebpackOptions) ? 'Array' : typeof finalWebpackOptions);
+        // Make sure we're passing an array of strings to execa
+        const childProcess = execa(webpackPath, finalWebpackOptions, {
+            encoding: 'utf8',
+            stdio: 'pipe'
+        });
+        let buildCompleted = false;
+        let buildStats = {
+            modules: 0,
+            assets: 0,
+            size: '0 B'
+        };
+        childProcess.stdout?.on('data', (data)=>{
+            const output = data.toString();
+            handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');
+            if (!buildCompleted && output.includes('compiled successfully')) {
+                buildCompleted = true;
+                spinner.succeed('Build completed successfully!');
+                const moduleMatch = output.match(/(\d+) modules/);
+                const assetMatch = output.match(/(\d+) assets/);
+                const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
+                if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
+                if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
+                if (sizeMatch) buildStats.size = sizeMatch[1];
+                displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
+            }
+        });
+        childProcess.stderr?.on('data', (data)=>{
+            const output = data.toString();
+            handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');
+            if (!buildCompleted && output.includes('compiled successfully')) {
+                buildCompleted = true;
+                spinner.succeed('Build completed successfully!');
+                const moduleMatch = output.match(/(\d+) modules/);
+                const assetMatch = output.match(/(\d+) assets/);
+                const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
+                if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
+                if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
+                if (sizeMatch) buildStats.size = sizeMatch[1];
+                displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
+            }
+        });
+        await childProcess;
+        if (!buildCompleted) {
+            spinner.succeed('Build completed successfully!');
+            displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);
+        }
+        callback(0);
+        return 0;
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        spinner.fail('Build failed.');
+        if (cmd.assist) {
+            spinner.start('AI is analyzing the webpack error...');
+            try {
+                await aiFunction({
+                    prompt: `Fix this webpack build error: ${error.message}\n\nError details:\n${error.toString()}\n\nConfiguration used:\n${JSON.stringify(webpackOptions, null, 2)}`,
+                    task: 'help',
+                    context: true,
+                    quiet
+                });
+                spinner.succeed('AI analysis complete');
+            } catch (aiError) {
+                spinner.fail('Could not generate AI assistance');
+                if (!quiet) {
+                    console.error('AI assistance error:', aiError);
+                }
+            }
+        }
+        callback(1);
+        return 1;
     }
-    console.log("webpackPath:", webpackPath);
-    console.log("finalWebpackOptions:", JSON.stringify(finalWebpackOptions));
-    console.log("finalWebpackOptions type:", Array.isArray(finalWebpackOptions) ? "Array" : typeof finalWebpackOptions);
-    const childProcess = execa(webpackPath, finalWebpackOptions, { encoding: "utf8", stdio: "pipe" });
-    let buildCompleted = false;
-    let buildStats = {
-      modules: 0,
-      assets: 0,
-      size: "0 B"
+};
+export const build = async (cmd, callback = ()=>({}))=>{
+    const { bundler = 'webpack', cliName = 'Lex', quiet = false, remove = false, test = false, translations = false, variables = '{}' } = cmd;
+    const spinner = createSpinner(quiet);
+    log(`${cliName} building...`, 'info', quiet);
+    await LexConfig.parseConfig(cmd);
+    const { outputFullPath, useTypescript } = LexConfig.config;
+    checkLinkedModules();
+    let variablesObj = {
+        NODE_ENV: 'production'
     };
-    childProcess.stdout?.on("data", (data) => {
-      const output = data.toString();
-      handleWebpackProgress(output, spinner, quiet, "\u{1F3D7}\uFE0F", "Webpack Building");
-      if (!buildCompleted && output.includes("compiled successfully")) {
-        buildCompleted = true;
-        spinner.succeed("Build completed successfully!");
-        const moduleMatch = output.match(/(\d+) modules/);
-        const assetMatch = output.match(/(\d+) assets/);
-        const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
-        if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
-        if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
-        if (sizeMatch) buildStats.size = sizeMatch[1];
-        displayBuildStatus("webpack", LexConfig.config.outputFullPath || "lib", quiet, buildStats);
-      }
-    });
-    childProcess.stderr?.on("data", (data) => {
-      const output = data.toString();
-      handleWebpackProgress(output, spinner, quiet, "\u{1F3D7}\uFE0F", "Webpack Building");
-      if (!buildCompleted && output.includes("compiled successfully")) {
-        buildCompleted = true;
-        spinner.succeed("Build completed successfully!");
-        const moduleMatch = output.match(/(\d+) modules/);
-        const assetMatch = output.match(/(\d+) assets/);
-        const sizeMatch = output.match(/assets by status ([\d.]+ \w+)/) || output.match(/assets by path.*?([\d.]+ \w+)/);
-        if (moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);
-        if (assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);
-        if (sizeMatch) buildStats.size = sizeMatch[1];
-        displayBuildStatus("webpack", LexConfig.config.outputFullPath || "lib", quiet, buildStats);
-      }
-    });
-    await childProcess;
-    if (!buildCompleted) {
-      spinner.succeed("Build completed successfully!");
-      displayBuildStatus("webpack", LexConfig.config.outputFullPath || "lib", quiet, buildStats);
+    if (variables) {
+        try {
+            variablesObj = JSON.parse(variables);
+        } catch (error) {
+            log(`\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);
+            callback(1);
+            return 1;
+        }
     }
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Build failed.");
-    if (cmd.assist) {
-      spinner.start("AI is analyzing the webpack error...");
-      try {
-        await aiFunction({
-          prompt: `Fix this webpack build error: ${error.message}
-
-Error details:
-${error.toString()}
-
-Configuration used:
-${JSON.stringify(webpackOptions, null, 2)}`,
-          task: "help",
-          context: true,
-          quiet
-        });
-        spinner.succeed("AI analysis complete");
-      } catch (aiError) {
-        spinner.fail("Could not generate AI assistance");
-        if (!quiet) {
-          console.error("AI assistance error:", aiError);
+    process.env = {
+        ...process.env,
+        ...variablesObj
+    };
+    // If in test mode, exit early
+    if (test) {
+        log('Test mode: Build environment loaded, exiting', 'info', quiet);
+        callback(0);
+        return 0;
+    }
+    // Process translations if flag is enabled (before building)
+    if (translations) {
+        spinner.start('Processing translations...');
+        try {
+            const sourcePath = LexConfig.config.sourceFullPath || process.cwd();
+            const outputPath = LexConfig.config.outputFullPath || 'lib';
+            await processTranslations(sourcePath, outputPath, quiet);
+            spinner.succeed('Translations processed successfully!');
+        } catch (translationError) {
+            log(`\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);
+            spinner.fail('Failed to process translations.');
+            callback(1);
+            return 1;
         }
-      }
     }
-    callback(1);
-    return 1;
-  }
-};
-const build = async (cmd, callback = () => ({})) => {
-  const {
-    bundler = "webpack",
-    cliName = "Lex",
-    quiet = false,
-    remove = false,
-    test = false,
-    translations = false,
-    variables = "{}"
-  } = cmd;
-  const spinner = createSpinner(quiet);
-  log(`${cliName} building...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  const { outputFullPath, useTypescript } = LexConfig.config;
-  checkLinkedModules();
-  let variablesObj = { NODE_ENV: "production" };
-  if (variables) {
-    try {
-      variablesObj = JSON.parse(variables);
-    } catch (error) {
-      log(`
-${cliName} Error: Environment variables option is not a valid JSON object.`, "error", quiet);
-      callback(1);
-      return 1;
+    spinner.start('Building code...');
+    if (remove) {
+        await removeFiles(outputFullPath || '');
     }
-  }
-  process.env = { ...process.env, ...variablesObj };
-  if (test) {
-    log("Test mode: Build environment loaded, exiting", "info", quiet);
-    callback(0);
-    return 0;
-  }
-  if (translations) {
-    spinner.start("Processing translations...");
-    try {
-      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();
-      const outputPath = LexConfig.config.outputFullPath || "lib";
-      await processTranslations(sourcePath, outputPath, quiet);
-      spinner.succeed("Translations processed successfully!");
-    } catch (translationError) {
-      log(`
-${cliName} Error: Failed to process translations: ${translationError.message}`, "error", quiet);
-      spinner.fail("Failed to process translations.");
-      callback(1);
-      return 1;
+    if (useTypescript) {
+        const compileConfigPath = getTypeScriptConfigPath('tsconfig.build.json');
+        if (existsSync(compileConfigPath)) {
+            log('Using tsconfig.build.json for build...', 'info', quiet);
+        } else {
+            LexConfig.checkCompileTypescriptConfig();
+        }
     }
-  }
-  spinner.start("Building code...");
-  if (remove) {
-    await removeFiles(outputFullPath || "");
-  }
-  if (useTypescript) {
-    const compileConfigPath = getTypeScriptConfigPath("tsconfig.build.json");
-    if (existsSync(compileConfigPath)) {
-      log("Using tsconfig.build.json for build...", "info", quiet);
+    let buildResult = 0;
+    if (bundler === 'swc') {
+        buildResult = await buildWithSWC(spinner, cmd, (status)=>{
+            buildResult = status;
+        });
     } else {
-      LexConfig.checkCompileTypescriptConfig();
+        buildResult = await buildWithWebpack(spinner, cmd, (status)=>{
+            buildResult = status;
+        });
     }
-  }
-  let buildResult = 0;
-  if (bundler === "esbuild") {
-    buildResult = await buildWithEsBuild(spinner, cmd, (status) => {
-      buildResult = status;
-    });
-  } else {
-    buildResult = await buildWithWebpack(spinner, cmd, (status) => {
-      buildResult = status;
-    });
-  }
-  if (buildResult === 0 && cmd.analyze) {
-    spinner.start("AI is analyzing the build output for optimization opportunities...");
-    try {
-      const stats = {
-        outputPath: LexConfig.config.outputFullPath,
-        entryPoints: bundler === "esbuild" ? `Source files: ${LexConfig.config.sourceFullPath}/**/*.{ts,js}` : LexConfig.config.webpack?.entry || "Unknown entry points"
-      };
-      await aiFunction({
-        prompt: `Analyze this build for optimization opportunities:
+    if (buildResult === 0 && cmd.analyze) {
+        spinner.start('AI is analyzing the build output for optimization opportunities...');
+        try {
+            const stats = {
+                outputPath: LexConfig.config.outputFullPath,
+                entryPoints: bundler === 'swc' ? `Source files: ${LexConfig.config.sourceFullPath}/**/*.{ts,js}` : LexConfig.config.webpack?.entry || 'Unknown entry points'
+            };
+            await aiFunction({
+                prompt: `Analyze this build for optimization opportunities:
 
 Build Type: ${bundler}
-Format: ${cmd.format || "default"}
+Format: ${cmd.format || 'default'}
 Environment: ${LexConfig.config.targetEnvironment}
 ${JSON.stringify(stats, null, 2)}
 
@@ -459,36 +356,30 @@ What are the key optimization opportunities for this build configuration? Consid
 3. Tree-shaking improvements
 4. Performance enhancements
 5. Dependency optimizations`,
-        task: "optimize",
-        context: true,
-        quiet
-      });
-      spinner.succeed("AI build analysis complete");
-    } catch (aiError) {
-      spinner.fail("Could not generate AI optimization analysis");
-      if (!quiet) {
-        console.error("AI analysis error:", aiError);
-      }
+                task: 'optimize',
+                context: true,
+                quiet
+            });
+            spinner.succeed('AI build analysis complete');
+        } catch (aiError) {
+            spinner.fail('Could not generate AI optimization analysis');
+            if (!quiet) {
+                console.error('AI analysis error:', aiError);
+            }
+        }
     }
-  }
-  if (buildResult === 0) {
-    try {
-      await copyConfiguredFiles(spinner, LexConfig.config, quiet);
-    } catch (copyError) {
-      log(`
-${cliName} Error: Failed to copy configured files: ${copyError.message}`, "error", quiet);
-      callback(1);
-      return 1;
+    if (buildResult === 0) {
+        try {
+            await copyConfiguredFiles(spinner, LexConfig.config, quiet);
+        } catch (copyError) {
+            log(`\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);
+            callback(1);
+            return 1;
+        }
     }
-  }
-  callback(buildResult);
-  return buildResult;
-};
-var build_default = build;
-export {
-  build,
-  buildWithEsBuild,
-  buildWithWebpack,
-  build_default as default
+    callback(buildResult);
+    return buildResult;
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/build/build.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport GraphqlLoaderPlugin from '@luckycatfactory/esbuild-graphql-loader';\nimport {execa} from 'execa';\nimport {existsSync, readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {dirname, resolve as pathResolve} from 'path';\n\nimport {LexConfig, getTypeScriptConfigPath} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, createSpinner, createProgressBar, handleWebpackProgress, removeFiles} from '../../utils/app.js';\nimport {getDirName, relativeNodePath, resolveWebpackPaths, getLexPackageJsonPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\nimport {processTranslations} from '../../utils/translations.js';\nimport {aiFunction} from '../ai/ai.js';\nimport boxen from 'boxen';\nimport chalk from 'chalk';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch {\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface BuildOptions {\n  readonly assist?: boolean;\n  readonly analyze?: boolean;\n  readonly bundler?: 'webpack' | 'esbuild';\n  readonly cliName?: string;\n  readonly entry?: string; // <-- add entry\n  readonly format?: string;\n  readonly outputPath?: string; // <-- already present\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly sourcePath?: string;\n  readonly test?: boolean;\n  readonly translations?: boolean;\n  readonly variables?: string;\n  readonly watch?: boolean;\n}\n\nexport type BuildCallback = (status: number) => void;\n\nconst displayBuildStatus = (bundler: string, outputPath: string, quiet: boolean, stats?: {modules?: number; assets?: number; size?: string}) => {\n  if(quiet) return;\n\n  let statsInfo = '';\n  if(stats && stats.modules && stats.assets) {\n    statsInfo = `\\n${chalk.green('Modules:')}    ${chalk.cyan(stats.modules)}\\n` +\n      `${chalk.green('Assets:')}     ${chalk.cyan(stats.assets)}\\n` +\n      `${chalk.green('Size:')}       ${chalk.cyan(stats.size)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('\uD83C\uDFD7\uFE0F  Build Completed Successfully')}\\n\\n` +\n    `${chalk.green('Bundler:')}    ${chalk.cyan(bundler)}\\n` +\n    `${chalk.green('Output:')}     ${chalk.underline(outputPath)}${statsInfo}\\n` +\n    `${chalk.yellow('Ready for deployment! \uD83D\uDE80')}`,\n    {\n      padding: 1,\n      margin: 1,\n      borderStyle: 'round',\n      borderColor: 'green',\n      backgroundColor: '#1a1a1a'\n    }\n  );\n\n  console.log('\\n' + statusBox + '\\n');\n};\n\nexport const buildWithEsBuild = async (spinner, commandOptions: BuildOptions, callback: BuildCallback) => {\n  const {\n    cliName = 'Lex',\n    format = 'esm',\n    outputPath,\n    quiet,\n    sourcePath,\n    watch\n  } = commandOptions;\n  const {\n    outputFullPath,\n    sourceFullPath,\n    targetEnvironment,\n    useGraphQl,\n    useTypescript\n  } = LexConfig.config;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n  const loader = {\n    '.js': 'js'\n  };\n\n  if(useTypescript) {\n    loader['.ts'] = 'ts';\n    loader['.tsx'] = 'tsx';\n  }\n\n  const plugins = [];\n\n  if(useGraphQl) {\n    plugins.push((GraphqlLoaderPlugin as unknown as () => never)());\n  }\n\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  const packageJsonData = readFileSync(pathResolve(process.cwd(), './package.json'));\n  const packageJson = JSON.parse(packageJsonData.toString());\n  const external = [\n    ...Object.keys(packageJson.dependencies || {}),\n    ...Object.keys(packageJson.peerDependencies || {})\n  ];\n\n  const dirName = getDirName();\n  const dirPath: string = pathResolve(dirName, '../..');\n  const outputDir: string = outputPath || outputFullPath || '';\n  const esbuildPath: string = relativeNodePath('esbuild/bin/esbuild', dirPath);\n  const esbuildConfig = LexConfig.config.esbuild || {};\n\n  const esbuildOptions: string[] = [\n    ...sourceFiles,\n    '--bundle',\n    '--color=true',\n    `--format=${format}`,\n    `--outdir=${outputDir}`,\n    `--platform=${esbuildConfig.platform || 'node'}`,\n    `--target=${esbuildConfig.target || (targetEnvironment === 'node' ? 'node20' : 'es2020')}`,\n    `--sourcemap=${esbuildConfig.sourcemap || 'inline'}`\n  ];\n\n  if(esbuildConfig.minify !== false) {\n    esbuildOptions.push('--minify');\n  }\n\n  if(esbuildConfig.treeShaking !== false) {\n    esbuildOptions.push('--tree-shaking=true');\n  }\n\n  if(esbuildConfig.drop && esbuildConfig.drop.length > 0) {\n    esbuildConfig.drop.forEach(item => {\n      esbuildOptions.push(`--drop:${item}`);\n    });\n  }\n\n  if(esbuildConfig.pure && esbuildConfig.pure.length > 0) {\n    esbuildConfig.pure.forEach(item => {\n      esbuildOptions.push(`--pure:${item}`);\n    });\n  }\n\n  if(esbuildConfig.legalComments) {\n    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);\n  }\n\n  if(esbuildConfig.splitting !== false) {\n    esbuildOptions.push('--splitting');\n  }\n\n  if(esbuildConfig.metafile) {\n    esbuildOptions.push('--metafile');\n  }\n\n  if(esbuildConfig.banner) {\n    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {\n      esbuildOptions.push(`--banner:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.footer) {\n    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {\n      esbuildOptions.push(`--footer:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.define) {\n    Object.entries(esbuildConfig.define).forEach(([key, value]) => {\n      esbuildOptions.push(`--define:${key}=${value}`);\n    });\n  }\n\n  if(external.length) {\n    esbuildOptions.push(`--external:${external.join(',')}`);\n  }\n\n  if(plugins.length) {\n    esbuildOptions.push(`--plugins=${plugins.join(',')}`);\n  }\n  if(watch) {\n    esbuildOptions.push('--watch');\n  }\n\n  try {\n    await execa(esbuildPath, esbuildOptions, {encoding: 'utf8'});\n\n    spinner.succeed('Build completed successfully!');\n    displayBuildStatus('esbuild', outputDir, quiet);\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    if(!quiet) {\n      console.error(error);\n    }\n\n    spinner.fail('Code build failed.');\n\n    if(commandOptions.assist) {\n      spinner.start('AI is analyzing the error...');\n\n      try {\n        await aiFunction({\n          prompt: `Fix this esbuild error: ${error.message}\\n\\nError details:\\n${error.toString()}`,\n          task: 'help',\n          context: true,\n          quiet\n        });\n\n        spinner.succeed('AI analysis complete');\n      } catch(aiError) {\n        spinner.fail('Could not generate AI assistance');\n        if(!quiet) {\n          console.error('AI assistance error:', aiError);\n        }\n      }\n    }\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};\n\nexport const buildWithWebpack = async (spinner, cmd, callback) => {\n  const {\n    analyze,\n    cliName = 'Lex',\n    config,\n    configName,\n    defineProcessEnvNodeEnv,\n    devtool,\n    disableInterpret,\n    entry,\n    env,\n    failOnWarnings,\n    json,\n    merge,\n    mode,\n    name,\n    nodeEnv,\n    noDevtool,\n    noStats,\n    noTarget,\n    noWatch,\n    noWatchOptionsStdin,\n    outputPath,\n    quiet = false,\n    stats,\n    target,\n    watch,\n    watchOptionsStdin\n  } = cmd;\n\n  console.log('entry:', entry, 'type:', typeof entry);\n  console.log('outputPath:', outputPath, 'type:', typeof outputPath);\n\n  const entryValue = Array.isArray(entry) ? entry[0] : entry;\n\n  let webpackConfig: string;\n\n  if(config) {\n    const isRelativeConfig: boolean = config.substr(0, 2) === './';\n    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;\n  } else {\n    const projectConfigPath = pathResolve(process.cwd(), 'webpack.config.js');\n    const projectConfigPathTs = pathResolve(process.cwd(), 'webpack.config.ts');\n    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);\n\n    if(hasProjectConfig) {\n      webpackConfig = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;\n    } else {\n      const {webpackConfig: resolvedConfig} = resolveWebpackPaths(currentDirname);\n      webpackConfig = resolvedConfig;\n    }\n  }\n\n  console.log('webpackConfig path:', webpackConfig);\n  console.log('webpackConfig exists:', existsSync(webpackConfig));\n\n  if(!existsSync(webpackConfig)) {\n    const lexPackagePath = getLexPackageJsonPath();\n    const lexPackageDir = dirname(lexPackagePath);\n    const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');\n\n    if(existsSync(lexWebpackConfig)) {\n      webpackConfig = lexWebpackConfig;\n      console.log('Using Lex webpack config:', webpackConfig);\n    } else {\n      log(`\\n${cliName} Error: Could not find webpack.config.js`, 'error', quiet);\n      spinner.fail('Build failed.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  const webpackOptions: string[] = [\n    '--color',\n    '--progress',\n    '--config', webpackConfig\n  ];\n\n  if(analyze) webpackOptions.push('--analyze');\n  if(configName) webpackOptions.push('--configName', configName);\n  if(defineProcessEnvNodeEnv) webpackOptions.push('--defineProcessEnvNodeEnv', defineProcessEnvNodeEnv);\n  if(devtool) webpackOptions.push('--devtool', devtool);\n  if(disableInterpret) webpackOptions.push('--disableInterpret');\n  // Pass entry directly as CLI flag\n  if(entryValue) webpackOptions.push('--entry', entryValue.toString());\n  if(env) webpackOptions.push('--env', env);\n  if(failOnWarnings) webpackOptions.push('--failOnWarnings');\n  if(json) webpackOptions.push('--json', json);\n  if(mode) webpackOptions.push('--mode', mode);\n  if(merge) webpackOptions.push('--merge');\n  if(name) webpackOptions.push('--name', name);\n  if(noDevtool) webpackOptions.push('--noDevtool');\n  if(noStats) webpackOptions.push('--noStats');\n  if(noTarget) webpackOptions.push('--noTarget');\n  if(noWatch) webpackOptions.push('--noWatch');\n  if(noWatchOptionsStdin) webpackOptions.push('--noWatchOptionsStdin');\n  if(nodeEnv) webpackOptions.push('--nodeEnv', nodeEnv);\n  if(outputPath) webpackOptions.push('--output-path', outputPath.toString()); // Convert to string\n  if(stats) webpackOptions.push('--stats', stats);\n  if(target) webpackOptions.push('--target', target);\n  if(watch) webpackOptions.push('--watch');\n  if(watchOptionsStdin) webpackOptions.push('--watchOptionsStdin');\n\n  try {\n    const {webpackPath} = resolveWebpackPaths(currentDirname);\n\n    // Fix: Ensure finalWebpackOptions is always an array of strings\n    let finalWebpackOptions: string[];\n    if(webpackPath === 'npx') {\n      finalWebpackOptions = ['webpack', ...webpackOptions];\n    } else {\n      finalWebpackOptions = [...webpackOptions];\n    }\n\n    console.log('webpackPath:', webpackPath);\n    console.log('finalWebpackOptions:', JSON.stringify(finalWebpackOptions));\n    console.log('finalWebpackOptions type:', Array.isArray(finalWebpackOptions) ? 'Array' : typeof finalWebpackOptions);\n\n    // Make sure we're passing an array of strings to execa\n    const childProcess = execa(webpackPath, finalWebpackOptions, {encoding: 'utf8', stdio: 'pipe'});\n\n    let buildCompleted = false;\n    let buildStats = {\n      modules: 0,\n      assets: 0,\n      size: '0 B'\n    };\n\n    childProcess.stdout?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '\uD83C\uDFD7\uFE0F', 'Webpack Building');\n\n      if(!buildCompleted && output.includes('compiled successfully')) {\n        buildCompleted = true;\n        spinner.succeed('Build completed successfully!');\n\n        const moduleMatch = output.match(/(\\d+) modules/);\n        const assetMatch = output.match(/(\\d+) assets/);\n        const sizeMatch = output.match(/assets by status ([\\d.]+ \\w+)/) || output.match(/assets by path.*?([\\d.]+ \\w+)/);\n\n        if(moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);\n        if(assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);\n        if(sizeMatch) buildStats.size = sizeMatch[1];\n\n        displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n      }\n    });\n\n    childProcess.stderr?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '\uD83C\uDFD7\uFE0F', 'Webpack Building');\n\n      if(!buildCompleted && output.includes('compiled successfully')) {\n        buildCompleted = true;\n        spinner.succeed('Build completed successfully!');\n\n        const moduleMatch = output.match(/(\\d+) modules/);\n        const assetMatch = output.match(/(\\d+) assets/);\n        const sizeMatch = output.match(/assets by status ([\\d.]+ \\w+)/) || output.match(/assets by path.*?([\\d.]+ \\w+)/);\n\n        if(moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);\n        if(assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);\n        if(sizeMatch) buildStats.size = sizeMatch[1];\n\n        displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n      }\n    });\n\n    await childProcess;\n\n    if(!buildCompleted) {\n      spinner.succeed('Build completed successfully!');\n      displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n    }\n\n    callback(0);\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('Build failed.');\n\n    if(cmd.assist) {\n      spinner.start('AI is analyzing the webpack error...');\n\n      try {\n        await aiFunction({\n          prompt: `Fix this webpack build error: ${error.message}\\n\\nError details:\\n${error.toString()}\\n\\nConfiguration used:\\n${JSON.stringify(webpackOptions, null, 2)}`,\n          task: 'help',\n          context: true,\n          quiet\n        });\n\n        spinner.succeed('AI analysis complete');\n      } catch(aiError) {\n        spinner.fail('Could not generate AI assistance');\n        if(!quiet) {\n          console.error('AI assistance error:', aiError);\n        }\n      }\n    }\n\n    callback(1);\n    return 1;\n  }\n};\n\nexport const build = async (cmd: BuildOptions, callback: BuildCallback = () => ({})): Promise<number> => {\n  const {\n    bundler = 'webpack',\n    cliName = 'Lex',\n    quiet = false,\n    remove = false,\n    test = false,\n    translations = false,\n    variables = '{}'\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} building...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, useTypescript} = LexConfig.config;\n\n  checkLinkedModules();\n\n  let variablesObj: object = {NODE_ENV: 'production'};\n\n  if(variables) {\n    try {\n      variablesObj = JSON.parse(variables);\n    } catch(error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  // If in test mode, exit early\n  if(test) {\n    log('Test mode: Build environment loaded, exiting', 'info', quiet);\n    callback(0);\n    return 0;\n  }\n\n  // Process translations if flag is enabled (before building)\n  if(translations) {\n    spinner.start('Processing translations...');\n\n    try {\n      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();\n      const outputPath = LexConfig.config.outputFullPath || 'lib';\n\n      await processTranslations(sourcePath, outputPath, quiet);\n      spinner.succeed('Translations processed successfully!');\n    } catch(translationError) {\n      log(`\\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);\n      spinner.fail('Failed to process translations.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  spinner.start('Building code...');\n\n  if(remove) {\n    await removeFiles(outputFullPath || '');\n  }\n\n  if(useTypescript) {\n    const compileConfigPath = getTypeScriptConfigPath('tsconfig.build.json');\n    if(existsSync(compileConfigPath)) {\n      log('Using tsconfig.build.json for build...', 'info', quiet);\n    } else {\n      LexConfig.checkCompileTypescriptConfig();\n    }\n  }\n\n  let buildResult = 0;\n\n  if(bundler === 'esbuild') {\n    buildResult = await buildWithEsBuild(spinner, cmd, (status) => {\n      buildResult = status;\n    });\n  } else {\n    buildResult = await buildWithWebpack(spinner, cmd, (status) => {\n      buildResult = status;\n    });\n  }\n\n  if(buildResult === 0 && cmd.analyze) {\n    spinner.start('AI is analyzing the build output for optimization opportunities...');\n\n    try {\n      const stats = {\n        outputPath: LexConfig.config.outputFullPath,\n        entryPoints: bundler === 'esbuild' ?\n          `Source files: ${LexConfig.config.sourceFullPath}/**/*.{ts,js}` :\n          LexConfig.config.webpack?.entry || 'Unknown entry points'\n      };\n\n      await aiFunction({\n        prompt: `Analyze this build for optimization opportunities:\n\nBuild Type: ${bundler}\nFormat: ${cmd.format || 'default'}\nEnvironment: ${LexConfig.config.targetEnvironment}\n${JSON.stringify(stats, null, 2)}\n\nWhat are the key optimization opportunities for this build configuration? Consider:\n1. Bundle size optimization strategies\n2. Code splitting recommendations\n3. Tree-shaking improvements\n4. Performance enhancements\n5. Dependency optimizations`,\n        task: 'optimize',\n        context: true,\n        quiet\n      });\n\n      spinner.succeed('AI build analysis complete');\n    } catch(aiError) {\n      spinner.fail('Could not generate AI optimization analysis');\n      if(!quiet) {\n        console.error('AI analysis error:', aiError);\n      }\n    }\n  }\n\n  if(buildResult === 0) {\n    try {\n      await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n    } catch(copyError) {\n      log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  callback(buildResult);\n  return buildResult;\n};\n\nexport default build;\n"],
  "mappings": "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",
  "names": []
}

+export default build;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/build/build.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {transform} from '@swc/core';\nimport {execa} from 'execa';\nimport {existsSync, readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {dirname, resolve as pathResolve} from 'path';\n\nimport {LexConfig, getTypeScriptConfigPath} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, createSpinner, createProgressBar, handleWebpackProgress, removeFiles} from '../../utils/app.js';\nimport {getDirName, relativeNodePath, resolveWebpackPaths, getLexPackageJsonPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\nimport {processTranslations} from '../../utils/translations.js';\nimport {aiFunction} from '../ai/ai.js';\nimport boxen from 'boxen';\nimport chalk from 'chalk';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch {\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface BuildOptions {\n  readonly assist?: boolean;\n  readonly analyze?: boolean;\n  readonly bundler?: 'webpack' | 'swc';\n  readonly cliName?: string;\n  readonly entry?: string; // <-- add entry\n  readonly format?: string;\n  readonly outputPath?: string; // <-- already present\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly sourcePath?: string;\n  readonly test?: boolean;\n  readonly translations?: boolean;\n  readonly variables?: string;\n  readonly watch?: boolean;\n}\n\nexport type BuildCallback = (status: number) => void;\n\nconst displayBuildStatus = (bundler: string, outputPath: string, quiet: boolean, stats?: {modules?: number; assets?: number; size?: string}) => {\n  if(quiet) return;\n\n  let statsInfo = '';\n  if(stats && stats.modules && stats.assets) {\n    statsInfo = `\\n${chalk.green('Modules:')}    ${chalk.cyan(stats.modules)}\\n` +\n      `${chalk.green('Assets:')}     ${chalk.cyan(stats.assets)}\\n` +\n      `${chalk.green('Size:')}       ${chalk.cyan(stats.size)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('🏗️  Build Completed Successfully')}\\n\\n` +\n    `${chalk.green('Bundler:')}    ${chalk.cyan(bundler)}\\n` +\n    `${chalk.green('Output:')}     ${chalk.underline(outputPath)}${statsInfo}\\n` +\n    `${chalk.yellow('Ready for deployment! 🚀')}`,\n    {\n      padding: 1,\n      margin: 1,\n      borderStyle: 'round',\n      borderColor: 'green',\n      backgroundColor: '#1a1a1a'\n    }\n  );\n\n  console.log('\\n' + statusBox + '\\n');\n};\n\n// Removed buildWithEsBuild function - using SWC instead\n\nexport const buildWithSWC = async (spinner, commandOptions: BuildOptions, callback: BuildCallback) => {\n  const {\n    cliName = 'Lex',\n    format = 'esm',\n    outputPath,\n    quiet,\n    sourcePath,\n    watch\n  } = commandOptions;\n  const {\n    outputFullPath,\n    sourceFullPath,\n    swc: swcConfig,\n    targetEnvironment,\n    useGraphQl,\n    useTypescript\n  } = LexConfig.config;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  const outputDir: string = outputPath || outputFullPath || '';\n\n  try {\n    spinner.start('Building with SWC...');\n\n    for(const file of sourceFiles) {\n      const sourcePath = pathResolve(sourceDir, file);\n      const outputPath = pathResolve(outputDir, file.replace(/\\.(ts|tsx)$/, '.js'));\n\n      // Ensure output directory exists\n      const outputDirPath = dirname(outputPath);\n      if(!existsSync(outputDirPath)) {\n        const {mkdirSync} = await import('fs');\n        mkdirSync(outputDirPath, {recursive: true});\n      }\n\n      const sourceCode = readFileSync(sourcePath, 'utf8');\n\n      const isTSX = file.endsWith('.tsx');\n\n      // Merge SWC config with command-specific overrides\n      const swcOptions = {\n        filename: file,\n        ...swcConfig,\n        jsc: {\n          ...swcConfig?.jsc,\n          parser: {\n            syntax: 'typescript' as const,\n            tsx: isTSX,\n            decorators: swcConfig?.jsc?.parser?.decorators ?? true,\n            dynamicImport: swcConfig?.jsc?.parser?.dynamicImport ?? true\n          },\n          target: swcConfig?.jsc?.target ?? 'es2020',\n          transform: isTSX ? {\n            ...swcConfig?.jsc?.transform,\n            react: {\n              runtime: 'automatic' as const,\n              ...swcConfig?.jsc?.transform?.react\n            }\n          } : swcConfig?.jsc?.transform\n        },\n        module: {\n          ...swcConfig?.module,\n          type: format === 'cjs' ? 'commonjs' as const : (swcConfig?.module?.type as 'es6' || 'es6')\n        }\n      };\n\n      const result = await transform(sourceCode, swcOptions);\n\n      const {writeFileSync} = await import('fs');\n      writeFileSync(outputPath, result.code);\n    }\n\n    spinner.succeed('Build completed with SWC');\n    displayBuildStatus('SWC', outputDir, quiet);\n    callback(0);\n    return 0;\n  } catch(error) {\n    spinner.fail('Build failed with SWC');\n    if(!quiet) {\n      console.error(error);\n    }\n    callback(1);\n    return 1;\n  }\n};\n\nexport const buildWithWebpack = async (spinner, cmd, callback) => {\n  const {\n    analyze,\n    cliName = 'Lex',\n    config,\n    configName,\n    defineProcessEnvNodeEnv,\n    devtool,\n    disableInterpret,\n    entry,\n    env,\n    failOnWarnings,\n    json,\n    merge,\n    mode,\n    name,\n    nodeEnv,\n    noDevtool,\n    noStats,\n    noTarget,\n    noWatch,\n    noWatchOptionsStdin,\n    outputPath,\n    quiet = false,\n    stats,\n    target,\n    watch,\n    watchOptionsStdin\n  } = cmd;\n\n  console.log('entry:', entry, 'type:', typeof entry);\n  console.log('outputPath:', outputPath, 'type:', typeof outputPath);\n\n  const entryValue = Array.isArray(entry) ? entry[0] : entry;\n\n  let webpackConfig: string;\n\n  if(config) {\n    const isRelativeConfig: boolean = config.substr(0, 2) === './';\n    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;\n  } else {\n    const projectConfigPath = pathResolve(process.cwd(), 'webpack.config.js');\n    const projectConfigPathTs = pathResolve(process.cwd(), 'webpack.config.ts');\n    const hasProjectConfig = existsSync(projectConfigPath) || existsSync(projectConfigPathTs);\n\n    if(hasProjectConfig) {\n      webpackConfig = existsSync(projectConfigPathTs) ? projectConfigPathTs : projectConfigPath;\n    } else {\n      const {webpackConfig: resolvedConfig} = resolveWebpackPaths(currentDirname);\n      webpackConfig = resolvedConfig;\n    }\n  }\n\n  console.log('webpackConfig path:', webpackConfig);\n  console.log('webpackConfig exists:', existsSync(webpackConfig));\n\n  if(!existsSync(webpackConfig)) {\n    const lexPackagePath = getLexPackageJsonPath();\n    const lexPackageDir = dirname(lexPackagePath);\n    const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');\n\n    if(existsSync(lexWebpackConfig)) {\n      webpackConfig = lexWebpackConfig;\n      console.log('Using Lex webpack config:', webpackConfig);\n    } else {\n      log(`\\n${cliName} Error: Could not find webpack.config.js`, 'error', quiet);\n      spinner.fail('Build failed.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  const webpackOptions: string[] = [\n    '--color',\n    '--progress',\n    '--config', webpackConfig\n  ];\n\n  if(analyze) webpackOptions.push('--analyze');\n  if(configName) webpackOptions.push('--configName', configName);\n  if(defineProcessEnvNodeEnv) webpackOptions.push('--defineProcessEnvNodeEnv', defineProcessEnvNodeEnv);\n  if(devtool) webpackOptions.push('--devtool', devtool);\n  if(disableInterpret) webpackOptions.push('--disableInterpret');\n  // Pass entry directly as CLI flag\n  if(entryValue) webpackOptions.push('--entry', entryValue.toString());\n  if(env) webpackOptions.push('--env', env);\n  if(failOnWarnings) webpackOptions.push('--failOnWarnings');\n  if(json) webpackOptions.push('--json', json);\n  if(mode) webpackOptions.push('--mode', mode);\n  if(merge) webpackOptions.push('--merge');\n  if(name) webpackOptions.push('--name', name);\n  if(noDevtool) webpackOptions.push('--noDevtool');\n  if(noStats) webpackOptions.push('--noStats');\n  if(noTarget) webpackOptions.push('--noTarget');\n  if(noWatch) webpackOptions.push('--noWatch');\n  if(noWatchOptionsStdin) webpackOptions.push('--noWatchOptionsStdin');\n  if(nodeEnv) webpackOptions.push('--nodeEnv', nodeEnv);\n  if(outputPath) webpackOptions.push('--output-path', outputPath.toString()); // Convert to string\n  if(stats) webpackOptions.push('--stats', stats);\n  if(target) webpackOptions.push('--target', target);\n  if(watch) webpackOptions.push('--watch');\n  if(watchOptionsStdin) webpackOptions.push('--watchOptionsStdin');\n\n  try {\n    const {webpackPath} = resolveWebpackPaths(currentDirname);\n\n    // Fix: Ensure finalWebpackOptions is always an array of strings\n    let finalWebpackOptions: string[];\n    if(webpackPath === 'npx') {\n      finalWebpackOptions = ['webpack', ...webpackOptions];\n    } else {\n      finalWebpackOptions = [...webpackOptions];\n    }\n\n    console.log('webpackPath:', webpackPath);\n    console.log('finalWebpackOptions:', JSON.stringify(finalWebpackOptions));\n    console.log('finalWebpackOptions type:', Array.isArray(finalWebpackOptions) ? 'Array' : typeof finalWebpackOptions);\n\n    // Make sure we're passing an array of strings to execa\n    const childProcess = execa(webpackPath, finalWebpackOptions, {encoding: 'utf8', stdio: 'pipe'});\n\n    let buildCompleted = false;\n    let buildStats = {\n      modules: 0,\n      assets: 0,\n      size: '0 B'\n    };\n\n    childProcess.stdout?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');\n\n      if(!buildCompleted && output.includes('compiled successfully')) {\n        buildCompleted = true;\n        spinner.succeed('Build completed successfully!');\n\n        const moduleMatch = output.match(/(\\d+) modules/);\n        const assetMatch = output.match(/(\\d+) assets/);\n        const sizeMatch = output.match(/assets by status ([\\d.]+ \\w+)/) || output.match(/assets by path.*?([\\d.]+ \\w+)/);\n\n        if(moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);\n        if(assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);\n        if(sizeMatch) buildStats.size = sizeMatch[1];\n\n        displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n      }\n    });\n\n    childProcess.stderr?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '🏗️', 'Webpack Building');\n\n      if(!buildCompleted && output.includes('compiled successfully')) {\n        buildCompleted = true;\n        spinner.succeed('Build completed successfully!');\n\n        const moduleMatch = output.match(/(\\d+) modules/);\n        const assetMatch = output.match(/(\\d+) assets/);\n        const sizeMatch = output.match(/assets by status ([\\d.]+ \\w+)/) || output.match(/assets by path.*?([\\d.]+ \\w+)/);\n\n        if(moduleMatch) buildStats.modules = parseInt(moduleMatch[1], 10);\n        if(assetMatch) buildStats.assets = parseInt(assetMatch[1], 10);\n        if(sizeMatch) buildStats.size = sizeMatch[1];\n\n        displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n      }\n    });\n\n    await childProcess;\n\n    if(!buildCompleted) {\n      spinner.succeed('Build completed successfully!');\n      displayBuildStatus('webpack', LexConfig.config.outputFullPath || 'lib', quiet, buildStats);\n    }\n\n    callback(0);\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('Build failed.');\n\n    if(cmd.assist) {\n      spinner.start('AI is analyzing the webpack error...');\n\n      try {\n        await aiFunction({\n          prompt: `Fix this webpack build error: ${error.message}\\n\\nError details:\\n${error.toString()}\\n\\nConfiguration used:\\n${JSON.stringify(webpackOptions, null, 2)}`,\n          task: 'help',\n          context: true,\n          quiet\n        });\n\n        spinner.succeed('AI analysis complete');\n      } catch(aiError) {\n        spinner.fail('Could not generate AI assistance');\n        if(!quiet) {\n          console.error('AI assistance error:', aiError);\n        }\n      }\n    }\n\n    callback(1);\n    return 1;\n  }\n};\n\nexport const build = async (cmd: BuildOptions, callback: BuildCallback = () => ({})): Promise<number> => {\n  const {\n    bundler = 'webpack',\n    cliName = 'Lex',\n    quiet = false,\n    remove = false,\n    test = false,\n    translations = false,\n    variables = '{}'\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} building...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, useTypescript} = LexConfig.config;\n\n  checkLinkedModules();\n\n  let variablesObj: object = {NODE_ENV: 'production'};\n\n  if(variables) {\n    try {\n      variablesObj = JSON.parse(variables);\n    } catch(error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  // If in test mode, exit early\n  if(test) {\n    log('Test mode: Build environment loaded, exiting', 'info', quiet);\n    callback(0);\n    return 0;\n  }\n\n  // Process translations if flag is enabled (before building)\n  if(translations) {\n    spinner.start('Processing translations...');\n\n    try {\n      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();\n      const outputPath = LexConfig.config.outputFullPath || 'lib';\n\n      await processTranslations(sourcePath, outputPath, quiet);\n      spinner.succeed('Translations processed successfully!');\n    } catch(translationError) {\n      log(`\\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);\n      spinner.fail('Failed to process translations.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  spinner.start('Building code...');\n\n  if(remove) {\n    await removeFiles(outputFullPath || '');\n  }\n\n  if(useTypescript) {\n    const compileConfigPath = getTypeScriptConfigPath('tsconfig.build.json');\n    if(existsSync(compileConfigPath)) {\n      log('Using tsconfig.build.json for build...', 'info', quiet);\n    } else {\n      LexConfig.checkCompileTypescriptConfig();\n    }\n  }\n\n  let buildResult = 0;\n\n  if(bundler === 'swc') {\n    buildResult = await buildWithSWC(spinner, cmd, (status) => {\n      buildResult = status;\n    });\n  } else {\n    buildResult = await buildWithWebpack(spinner, cmd, (status) => {\n      buildResult = status;\n    });\n  }\n\n  if(buildResult === 0 && cmd.analyze) {\n    spinner.start('AI is analyzing the build output for optimization opportunities...');\n\n    try {\n      const stats = {\n        outputPath: LexConfig.config.outputFullPath,\n        entryPoints: bundler === 'swc' ?\n          `Source files: ${LexConfig.config.sourceFullPath}/**/*.{ts,js}` :\n          LexConfig.config.webpack?.entry || 'Unknown entry points'\n      };\n\n      await aiFunction({\n        prompt: `Analyze this build for optimization opportunities:\n\nBuild Type: ${bundler}\nFormat: ${cmd.format || 'default'}\nEnvironment: ${LexConfig.config.targetEnvironment}\n${JSON.stringify(stats, null, 2)}\n\nWhat are the key optimization opportunities for this build configuration? Consider:\n1. Bundle size optimization strategies\n2. Code splitting recommendations\n3. Tree-shaking improvements\n4. Performance enhancements\n5. Dependency optimizations`,\n        task: 'optimize',\n        context: true,\n        quiet\n      });\n\n      spinner.succeed('AI build analysis complete');\n    } catch(aiError) {\n      spinner.fail('Could not generate AI optimization analysis');\n      if(!quiet) {\n        console.error('AI analysis error:', aiError);\n      }\n    }\n  }\n\n  if(buildResult === 0) {\n    try {\n      await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n    } catch(copyError) {\n      log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  callback(buildResult);\n  return buildResult;\n};\n\nexport default build;\n"],"names":["transform","execa","existsSync","readFileSync","sync","globSync","dirname","resolve","pathResolve","LexConfig","getTypeScriptConfigPath","checkLinkedModules","copyConfiguredFiles","createSpinner","handleWebpackProgress","removeFiles","resolveWebpackPaths","getLexPackageJsonPath","log","processTranslations","aiFunction","boxen","chalk","currentFilename","currentDirname","eval","process","cwd","displayBuildStatus","bundler","outputPath","quiet","stats","statsInfo","modules","assets","green","cyan","size","statusBox","bold","underline","yellow","padding","margin","borderStyle","borderColor","backgroundColor","console","buildWithSWC","spinner","commandOptions","callback","cliName","format","sourcePath","watch","outputFullPath","sourceFullPath","swc","swcConfig","targetEnvironment","useGraphQl","useTypescript","config","sourceDir","globOptions","dot","nodir","nosort","tsFiles","jsFiles","sourceFiles","outputDir","start","file","replace","outputDirPath","mkdirSync","recursive","sourceCode","isTSX","endsWith","swcOptions","filename","jsc","parser","syntax","tsx","decorators","dynamicImport","target","react","runtime","module","type","result","writeFileSync","code","succeed","error","fail","buildWithWebpack","cmd","analyze","configName","defineProcessEnvNodeEnv","devtool","disableInterpret","entry","env","failOnWarnings","json","merge","mode","name","nodeEnv","noDevtool","noStats","noTarget","noWatch","noWatchOptionsStdin","watchOptionsStdin","entryValue","Array","isArray","webpackConfig","isRelativeConfig","substr","projectConfigPath","projectConfigPathTs","hasProjectConfig","resolvedConfig","lexPackagePath","lexPackageDir","lexWebpackConfig","webpackOptions","push","toString","webpackPath","finalWebpackOptions","JSON","stringify","childProcess","encoding","stdio","buildCompleted","buildStats","stdout","on","data","output","includes","moduleMatch","match","assetMatch","sizeMatch","parseInt","stderr","message","assist","prompt","task","context","aiError","build","remove","test","translations","variables","parseConfig","variablesObj","NODE_ENV","parse","translationError","compileConfigPath","checkCompileTypescriptConfig","buildResult","status","entryPoints","webpack","copyError"],"mappings":"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"}