@buenojs/bueno 0.8.3 → 0.8.5

package/src/cli/commands/build.ts

@@ -4,43 +4,53 @@
  * Build the application for production
  */
 
-import { defineCommand } from './index';
-import { getOption, hasFlag, type ParsedArgs } from '../core/args';
-import { cliConsole, colors, formatSize, formatDuration } from '../core/console';
-import { spinner } from '../core/spinner';
+import { type ParsedArgs, getOption, hasFlag } from "../core/args";
 import {
+	cliConsole,
+	colors,
+	formatDuration,
+	formatSize,
+} from "../core/console";
+import { spinner } from "../core/spinner";
+import { CLIError, CLIErrorType } from "../index";
+import {
+	deleteDirectory,
 	fileExists,
 	getProjectRoot,
 	isBuenoProject,
 	joinPaths,
-	readFile,
-	deleteDirectory,
 	listFiles,
-} from '../utils/fs';
-import { CLIError, CLIErrorType } from '../index';
+	readFile,
+} from "../utils/fs";
+import { defineCommand } from "./index";
 
 /**
  * Build targets
  */
-type BuildTarget = 'bun' | 'node' | 'standalone';
+type BuildTarget = "bun" | "node" | "standalone";
 
 /**
  * Cross-compile targets
  */
-type CrossCompileTarget = 'linux-x64' | 'linux-arm64' | 'windows-x64' | 'darwin-x64' | 'darwin-arm64';
+type CrossCompileTarget =
+	| "linux-x64"
+	| "linux-arm64"
+	| "windows-x64"
+	| "darwin-x64"
+	| "darwin-arm64";
 
 /**
  * Find the entry point for the application
  */
 async function findEntryPoint(projectRoot: string): Promise<string | null> {
 	const possibleEntries = [
-		'server/main.ts',
-		'src/main.ts',
-		'src/index.ts',
-		'main.ts',
-		'index.ts',
-		'server.ts',
-		'app.ts',
+		"server/main.ts",
+		"src/main.ts",
+		"src/index.ts",
+		"main.ts",
+		"index.ts",
+		"server.ts",
+		"app.ts",
 	];
 
 	for (const entry of possibleEntries) {
@@ -58,58 +68,58 @@ async function findEntryPoint(projectRoot: string): Promise<string | null> {
  */
 async function handleBuild(args: ParsedArgs): Promise<void> {
 	// Get options
-	const target = getOption(args, 'target', {
-		name: 'target',
-		alias: 't',
-		type: 'string',
-		default: 'bun',
-		description: '',
+	const target = getOption(args, "target", {
+		name: "target",
+		alias: "t",
+		type: "string",
+		default: "bun",
+		description: "",
 	}) as BuildTarget;
 
-	const outDir = getOption<string>(args, 'outdir', {
-		name: 'outdir',
-		alias: 'o',
-		type: 'string',
-		default: './dist',
-		description: '',
+	const outDir = getOption<string>(args, "outdir", {
+		name: "outdir",
+		alias: "o",
+		type: "string",
+		default: "./dist",
+		description: "",
 	});
 
-	const minify = !hasFlag(args, 'no-minify');
-	const sourcemap = hasFlag(args, 'sourcemap');
-	const analyze = hasFlag(args, 'analyze');
-	const configPath = getOption(args, 'config', {
-		name: 'config',
-		alias: 'c',
-		type: 'string',
-		description: '',
+	const minify = !hasFlag(args, "no-minify");
+	const sourcemap = hasFlag(args, "sourcemap");
+	const analyze = hasFlag(args, "analyze");
+	const configPath = getOption(args, "config", {
+		name: "config",
+		alias: "c",
+		type: "string",
+		description: "",
 	});
 
 	// Compile options
-	const compile = hasFlag(args, 'compile');
-	const crossCompile = getOption(args, 'cross-compile', {
-		name: 'cross-compile',
-		type: 'string',
-		description: '',
+	const compile = hasFlag(args, "compile");
+	const crossCompile = getOption(args, "cross-compile", {
+		name: "cross-compile",
+		type: "string",
+		description: "",
 	}) as CrossCompileTarget | undefined;
-	const executableName = getOption<string>(args, 'executable-name', {
-		name: 'executable-name',
-		type: 'string',
-		default: 'main',
-		description: '',
+	const executableName = getOption<string>(args, "executable-name", {
+		name: "executable-name",
+		type: "string",
+		default: "main",
+		description: "",
 	});
 
 	// Validate cross-compile target
 	if (crossCompile) {
 		const validCrossCompileTargets: CrossCompileTarget[] = [
-			'linux-x64',
-			'linux-arm64',
-			'windows-x64',
-			'darwin-x64',
-			'darwin-arm64',
+			"linux-x64",
+			"linux-arm64",
+			"windows-x64",
+			"darwin-x64",
+			"darwin-arm64",
 		];
 		if (!validCrossCompileTargets.includes(crossCompile)) {
 			throw new CLIError(
-				`Invalid cross-compile target: ${crossCompile}. Valid targets: ${validCrossCompileTargets.join(', ')}`,
+				`Invalid cross-compile target: ${crossCompile}. Valid targets: ${validCrossCompileTargets.join(", ")}`,
 				CLIErrorType.INVALID_ARGS,
 			);
 		}
@@ -118,16 +128,16 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 	// Validate that cross-compile requires compile
 	if (crossCompile && !compile) {
 		throw new CLIError(
-			'--cross-compile requires --compile flag',
+			"--cross-compile requires --compile flag",
 			CLIErrorType.INVALID_ARGS,
 		);
 	}
 
 	// Validate target
-	const validTargets: BuildTarget[] = ['bun', 'node', 'standalone'];
+	const validTargets: BuildTarget[] = ["bun", "node", "standalone"];
 	if (!validTargets.includes(target)) {
 		throw new CLIError(
-			`Invalid target: ${target}. Valid targets: ${validTargets.join(', ')}`,
+			`Invalid target: ${target}. Valid targets: ${validTargets.join(", ")}`,
 			CLIErrorType.INVALID_ARGS,
 		);
 	}
@@ -136,14 +146,14 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 	const projectRoot = await getProjectRoot();
 	if (!projectRoot) {
 		throw new CLIError(
-			'Not in a project directory. Run this command from a Bueno project.',
+			"Not in a project directory. Run this command from a Bueno project.",
 			CLIErrorType.NOT_FOUND,
 		);
 	}
 
 	if (!(await isBuenoProject())) {
 		throw new CLIError(
-			'Not a Bueno project. Make sure you have a bueno.config.ts or bueno in your dependencies.',
+			"Not a Bueno project. Make sure you have a bueno.config.ts or bueno in your dependencies.",
 			CLIErrorType.NOT_FOUND,
 		);
 	}
@@ -152,33 +162,39 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 	const entryPoint = await findEntryPoint(projectRoot);
 	if (!entryPoint) {
 		throw new CLIError(
-			'Could not find entry point. Make sure you have a main.ts or index.ts file.',
+			"Could not find entry point. Make sure you have a main.ts or index.ts file.",
 			CLIErrorType.FILE_NOT_FOUND,
 		);
 	}
 
 	// Display build info
 	if (compile) {
-		cliConsole.header('Compiling Single-File Executable');
+		cliConsole.header("Compiling Single-File Executable");
 	} else {
-		cliConsole.header('Building for Production');
+		cliConsole.header("Building for Production");
 	}
-	cliConsole.log(`${colors.bold('Entry:')} ${entryPoint}`);
-	cliConsole.log(`${colors.bold('Target:')} ${target}`);
+	cliConsole.log(`${colors.bold("Entry:")} ${entryPoint}`);
+	cliConsole.log(`${colors.bold("Target:")} ${target}`);
 	if (compile) {
-		cliConsole.log(`${colors.bold('Compile:')} ${colors.green('enabled')}`);
+		cliConsole.log(`${colors.bold("Compile:")} ${colors.green("enabled")}`);
 		if (crossCompile) {
-			cliConsole.log(`${colors.bold('Cross-compile:')} ${colors.cyan(crossCompile)}`);
+			cliConsole.log(
+				`${colors.bold("Cross-compile:")} ${colors.cyan(crossCompile)}`,
+			);
 		}
-		cliConsole.log(`${colors.bold('Executable:')} ${executableName}`);
+		cliConsole.log(`${colors.bold("Executable:")} ${executableName}`);
 	}
-	cliConsole.log(`${colors.bold('Output:')} ${outDir}`);
-	cliConsole.log(`${colors.bold('Minify:')} ${minify ? colors.green('enabled') : colors.red('disabled')}`);
-	cliConsole.log(`${colors.bold('Sourcemap:')} ${sourcemap ? colors.green('enabled') : colors.red('disabled')}`);
-	cliConsole.log('');
+	cliConsole.log(`${colors.bold("Output:")} ${outDir}`);
+	cliConsole.log(
+		`${colors.bold("Minify:")} ${minify ? colors.green("enabled") : colors.red("disabled")}`,
+	);
+	cliConsole.log(
+		`${colors.bold("Sourcemap:")} ${sourcemap ? colors.green("enabled") : colors.red("disabled")}`,
+	);
+	cliConsole.log("");
 
 	const startTime = Date.now();
-	const s = spinner('Building...');
+	const s = spinner("Building...");
 
 	try {
 		// Clean output directory
@@ -190,7 +206,7 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 		// Handle compile build
 		if (compile) {
 			// Determine the executable filename
-			const isWindows = crossCompile === 'windows-x64';
+			const isWindows = crossCompile === "windows-x64";
 			const executableFileName = isWindows
 				? `${executableName}.exe`
 				: executableName;
@@ -200,13 +216,13 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 			const buildOptions: any = {
 				entrypoints: [joinPaths(projectRoot, entryPoint)],
 				outdir: fullOutDir,
-				target: crossCompile || 'bun',
+				target: crossCompile || "bun",
 				minify,
-				sourcemap: sourcemap ? 'external' : undefined,
+				sourcemap: sourcemap ? "external" : undefined,
 				naming: executableFileName,
 				compile: true,
 				define: {
-					'process.env.NODE_ENV': '"production"',
+					"process.env.NODE_ENV": '"production"',
 				},
 			};
 
@@ -218,21 +234,18 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 				for (const error of buildResult.logs) {
 					cliConsole.error(error.message);
 				}
-				throw new CLIError(
-					'Compile failed',
-					CLIErrorType.TEMPLATE_ERROR,
-				);
+				throw new CLIError("Compile failed", CLIErrorType.TEMPLATE_ERROR);
 			}
 
 			const elapsed = Date.now() - startTime;
 			s.success(`Compile completed in ${formatDuration(elapsed)}`);
 
 			// Show output info
-			cliConsole.log('');
-			cliConsole.log(`${colors.bold('Output Executable:')}`);
-			
+			cliConsole.log("");
+			cliConsole.log(`${colors.bold("Output Executable:")}`);
+
 			// Get executable file size
-			const fs = require('fs');
+			const fs = require("fs");
 			let executableSize = 0;
 			try {
 				const stat = fs.statSync(executablePath);
@@ -243,17 +256,19 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 					executableSize = buildResult.outputs[0].size;
 				}
 			}
-			
-			cliConsole.log(`  ${colors.cyan(executablePath.replace(projectRoot, '.'))} ${colors.dim(`(${formatSize(executableSize)})`)}`);
-			cliConsole.log('');
-			
+
+			cliConsole.log(
+				`  ${colors.cyan(executablePath.replace(projectRoot, "."))} ${colors.dim(`(${formatSize(executableSize)})`)}`,
+			);
+			cliConsole.log("");
+
 			// Show success message with run instructions
-			cliConsole.success('Single-file executable created successfully!');
+			cliConsole.success("Single-file executable created successfully!");
 			if (crossCompile) {
-				cliConsole.log(`${colors.bold('Target Platform:')} ${crossCompile}`);
+				cliConsole.log(`${colors.bold("Target Platform:")} ${crossCompile}`);
 			}
-			cliConsole.log('');
-			cliConsole.info('You can run the executable directly:');
+			cliConsole.log("");
+			cliConsole.info("You can run the executable directly:");
 			if (isWindows) {
 				cliConsole.log(colors.cyan(`  .${outDir}/${executableFileName}`));
 			} else {
@@ -262,9 +277,9 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 
 			// Analyze if requested
 			if (analyze) {
-				cliConsole.log('');
-				cliConsole.header('Bundle Analysis');
-				cliConsole.log('Output:');
+				cliConsole.log("");
+				cliConsole.header("Bundle Analysis");
+				cliConsole.log("Output:");
 				for (const entry of buildResult.outputs) {
 					cliConsole.log(`  ${entry.path} (${formatSize(entry.size)})`);
 				}
@@ -277,14 +292,14 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 		const buildResult = await Bun.build({
 			entrypoints: [joinPaths(projectRoot, entryPoint)],
 			outdir: fullOutDir,
-			target: target === 'node' ? 'node' : 'bun',
+			target: target === "node" ? "node" : "bun",
 			minify,
-			sourcemap: sourcemap ? 'external' : undefined,
+			sourcemap: sourcemap ? "external" : undefined,
 			splitting: true,
-			format: 'esm',
-			external: target === 'standalone' ? [] : ['bun:*'],
+			format: "esm",
+			external: target === "standalone" ? [] : ["bun:*"],
 			define: {
-				'process.env.NODE_ENV': '"production"',
+				"process.env.NODE_ENV": '"production"',
 			},
 		});
 
@@ -293,10 +308,7 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 			for (const error of buildResult.logs) {
 				cliConsole.error(error.message);
 			}
-			throw new CLIError(
-				'Build failed',
-				CLIErrorType.TEMPLATE_ERROR,
-			);
+			throw new CLIError("Build failed", CLIErrorType.TEMPLATE_ERROR);
 		}
 
 		const elapsed = Date.now() - startTime;
@@ -304,43 +316,48 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 		// Get output files info
 		const outputFiles = await listFiles(fullOutDir, { recursive: true });
 		const totalSize = outputFiles.reduce((acc, file) => {
-			const stat = require('fs').statSync(file);
+			const stat = require("fs").statSync(file);
 			return acc + stat.size;
 		}, 0);
 
 		s.success(`Build completed in ${formatDuration(elapsed)}`);
 
 		// Show output info
-		cliConsole.log('');
-		cliConsole.log(`${colors.bold('Output Files:')}`);
+		cliConsole.log("");
+		cliConsole.log(`${colors.bold("Output Files:")}`);
 		for (const file of outputFiles.slice(0, 10)) {
-			const stat = require('fs').statSync(file);
-			const relativePath = file.replace(projectRoot, '.');
-			cliConsole.log(`  ${colors.dim(relativePath)} ${colors.dim(`(${formatSize(stat.size)})`)}`);
+			const stat = require("fs").statSync(file);
+			const relativePath = file.replace(projectRoot, ".");
+			cliConsole.log(
+				`  ${colors.dim(relativePath)} ${colors.dim(`(${formatSize(stat.size)})`)}`,
+			);
 		}
 		if (outputFiles.length > 10) {
-			cliConsole.log(`  ${colors.dim(`... and ${outputFiles.length - 10} more files`)}`);
+			cliConsole.log(
+				`  ${colors.dim(`... and ${outputFiles.length - 10} more files`)}`,
+			);
 		}
-		cliConsole.log('');
-		cliConsole.log(`${colors.bold('Total Size:')} ${formatSize(totalSize)}`);
+		cliConsole.log("");
+		cliConsole.log(`${colors.bold("Total Size:")} ${formatSize(totalSize)}`);
 
 		// Analyze if requested
 		if (analyze) {
-			cliConsole.log('');
-			cliConsole.header('Bundle Analysis');
-			cliConsole.log('Entry points:');
+			cliConsole.log("");
+			cliConsole.header("Bundle Analysis");
+			cliConsole.log("Entry points:");
 			for (const entry of buildResult.outputs) {
 				cliConsole.log(`  ${entry.path} (${formatSize(entry.size)})`);
 			}
 		}
 
 		// Show standalone build info
-		if (target === 'standalone') {
-			cliConsole.log('');
-			cliConsole.info('Standalone bundle created. You can run it with:');
-			cliConsole.log(colors.cyan(`  bun .${outDir}/${entryPoint.replace('.ts', '.js')}`));
+		if (target === "standalone") {
+			cliConsole.log("");
+			cliConsole.info("Standalone bundle created. You can run it with:");
+			cliConsole.log(
+				colors.cyan(`  bun .${outDir}/${entryPoint.replace(".ts", ".js")}`),
+			);
 		}
-
 	} catch (error) {
 		s.error();
 		throw error;
@@ -350,76 +367,77 @@ async function handleBuild(args: ParsedArgs): Promise<void> {
 // Register the command
 defineCommand(
 	{
-		name: 'build',
-		description: 'Build the application for production',
+		name: "build",
+		description: "Build the application for production",
 		options: [
 			{
-				name: 'target',
-				alias: 't',
-				type: 'string',
-				default: 'bun',
-				description: 'Build target (bun, node, standalone)',
+				name: "target",
+				alias: "t",
+				type: "string",
+				default: "bun",
+				description: "Build target (bun, node, standalone)",
 			},
 			{
-				name: 'outdir',
-				alias: 'o',
-				type: 'string',
-				default: './dist',
-				description: 'Output directory',
+				name: "outdir",
+				alias: "o",
+				type: "string",
+				default: "./dist",
+				description: "Output directory",
 			},
 			{
-				name: 'no-minify',
-				type: 'boolean',
+				name: "no-minify",
+				type: "boolean",
 				default: false,
-				description: 'Disable minification',
+				description: "Disable minification",
 			},
 			{
-				name: 'sourcemap',
-				type: 'boolean',
+				name: "sourcemap",
+				type: "boolean",
 				default: false,
-				description: 'Generate source maps',
+				description: "Generate source maps",
 			},
 			{
-				name: 'analyze',
-				type: 'boolean',
+				name: "analyze",
+				type: "boolean",
 				default: false,
-				description: 'Analyze bundle size',
+				description: "Analyze bundle size",
 			},
 			{
-				name: 'config',
-				alias: 'c',
-				type: 'string',
-				description: 'Path to config file',
+				name: "config",
+				alias: "c",
+				type: "string",
+				description: "Path to config file",
 			},
 			{
-				name: 'compile',
-				type: 'boolean',
+				name: "compile",
+				type: "boolean",
 				default: false,
-				description: 'Create a single-file executable using Bun compile',
+				description: "Create a single-file executable using Bun compile",
 			},
 			{
-				name: 'cross-compile',
-				type: 'string',
-				description: 'Cross-compile for different platforms (linux-x64, linux-arm64, windows-x64, darwin-x64, darwin-arm64)',
+				name: "cross-compile",
+				type: "string",
+				description:
+					"Cross-compile for different platforms (linux-x64, linux-arm64, windows-x64, darwin-x64, darwin-arm64)",
 			},
 			{
-				name: 'executable-name',
-				type: 'string',
-				default: 'main',
-				description: 'Custom name for the output executable (default: main)',
+				name: "executable-name",
+				type: "string",
+				default: "main",
+				description: "Custom name for the output executable (default: main)",
 			},
 		],
 		examples: [
-			'bueno build',
-			'bueno build --target node',
-			'bueno build --target standalone',
-			'bueno build --sourcemap',
-			'bueno build --analyze',
-			'bueno build --compile',
-			'bueno build --compile --outdir ./bin',
-			'bueno build --compile --cross-compile linux-x64',
-			'bueno build --compile --executable-name myapp',
+			"bueno build",
+			"bueno build --target node",
+			"bueno build --target standalone",
+			"bueno build --sourcemap",
+			"bueno build --analyze",
+			"bueno build --compile",
+			"bueno build --compile --outdir ./bin",
+			"bueno build --compile --cross-compile linux-x64",
+			"bueno build --compile --executable-name myapp",
 		],
 	},
 	handleBuild,
-);
+);