@buenojs/bueno 0.8.0

package/src/cli/commands/start.ts

@@ -0,0 +1,208 @@
+/**
+ * Start Command
+ *
+ * Start the production server
+ */
+
+import { defineCommand } from './index';
+import { getOption, hasFlag, type ParsedArgs } from '../core/args';
+import { cliConsole, colors } from '../core/console';
+import { spinner } from '../core/spinner';
+import {
+	fileExists,
+	getProjectRoot,
+	isBuenoProject,
+	joinPaths,
+} from '../utils/fs';
+import { CLIError, CLIErrorType } from '../index';
+
+/**
+ * Find the entry point for the application
+ */
+async function findEntryPoint(projectRoot: string): Promise<string | null> {
+	// Check for built files first
+	const possibleBuiltEntries = [
+		'dist/index.js',
+		'dist/main.js',
+		'dist/server.js',
+		'dist/app.js',
+	];
+
+	for (const entry of possibleBuiltEntries) {
+		const entryPath = joinPaths(projectRoot, entry);
+		if (await fileExists(entryPath)) {
+			return entry;
+		}
+	}
+
+	// Fall back to source files
+	const possibleSourceEntries = [
+		'server/main.ts',
+		'src/main.ts',
+		'src/index.ts',
+		'main.ts',
+		'index.ts',
+		'server.ts',
+		'app.ts',
+	];
+
+	for (const entry of possibleSourceEntries) {
+		const entryPath = joinPaths(projectRoot, entry);
+		if (await fileExists(entryPath)) {
+			return entry;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Handle start command
+ */
+async function handleStart(args: ParsedArgs): Promise<void> {
+	// Get options
+	const port = getOption(args, 'port', {
+		name: 'port',
+		alias: 'p',
+		type: 'number',
+		default: 3000,
+		description: '',
+	});
+
+	const host = getOption<string>(args, 'host', {
+		name: 'host',
+		alias: 'H',
+		type: 'string',
+		default: '0.0.0.0',
+		description: '',
+	});
+
+	const workers = getOption(args, 'workers', {
+		name: 'workers',
+		alias: 'w',
+		type: 'string',
+		default: 'auto',
+		description: '',
+	});
+
+	const configPath = getOption<string>(args, 'config', {
+		name: 'config',
+		alias: 'c',
+		type: 'string',
+		description: '',
+	});
+
+	// Check if in a Bueno project
+	const projectRoot = await getProjectRoot();
+	if (!projectRoot) {
+		throw new CLIError(
+			'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.',
+			CLIErrorType.NOT_FOUND,
+		);
+	}
+
+	// Find entry point
+	const entryPoint = await findEntryPoint(projectRoot);
+	if (!entryPoint) {
+		throw new CLIError(
+			'Could not find entry point. Make sure you have built the application or have a main.ts file.',
+			CLIErrorType.FILE_NOT_FOUND,
+		);
+	}
+
+	// Display startup info
+	cliConsole.header('Starting Production Server');
+	cliConsole.log(`${colors.bold('Entry:')} ${entryPoint}`);
+	cliConsole.log(`${colors.bold('Port:')} ${port}`);
+	cliConsole.log(`${colors.bold('Host:')} ${host}`);
+	cliConsole.log(`${colors.bold('Workers:')} ${workers}`);
+	cliConsole.log('');
+
+	// Set environment variables
+	const env: Record<string, string> = {
+		NODE_ENV: 'production',
+		PORT: String(port),
+		HOST: host,
+	};
+
+	if (configPath) {
+		env.BUENO_CONFIG = configPath;
+	}
+
+	// Start the server using Bun
+	const s = spinner('Starting production server...');
+
+	try {
+		// Use Bun's spawn to run the production server
+		const proc = Bun.spawn(['bun', 'run', entryPoint], {
+			cwd: projectRoot,
+			env: { ...process.env, ...env },
+			stdout: 'inherit',
+			stderr: 'inherit',
+		});
+
+		s.success(`Production server running at ${colors.cyan(`http://${host}:${port}`)}`);
+
+		// Wait for the process to exit
+		const exitCode = await proc.exited;
+
+		if (exitCode !== 0 && exitCode !== null) {
+			cliConsole.error(`Server exited with code ${exitCode}`);
+			process.exit(exitCode);
+		}
+	} catch (error) {
+		s.error();
+		throw error;
+	}
+}
+
+// Register the command
+defineCommand(
+	{
+		name: 'start',
+		description: 'Start the production server',
+		options: [
+			{
+				name: 'port',
+				alias: 'p',
+				type: 'number',
+				default: 3000,
+				description: 'Server port',
+			},
+			{
+				name: 'host',
+				alias: 'H',
+				type: 'string',
+				default: '0.0.0.0',
+				description: 'Server hostname',
+			},
+			{
+				name: 'workers',
+				alias: 'w',
+				type: 'string',
+				default: 'auto',
+				description: 'Number of worker threads',
+			},
+			{
+				name: 'config',
+				alias: 'c',
+				type: 'string',
+				description: 'Path to config file',
+			},
+		],
+		examples: [
+			'bueno start',
+			'bueno start --port 8080',
+			'bueno start --host 0.0.0.0',
+			'bueno start --workers 4',
+		],
+	},
+	handleStart,
+);

package/src/cli/core/args.ts

@@ -0,0 +1,283 @@
+/**
+ * Argument Parser for Bueno CLI
+ *
+ * Parses command line arguments using Bun's native process.argv
+ * Supports positional arguments, flags, and options
+ */
+
+export interface ParsedArgs {
+	command: string;
+	positionals: string[];
+	options: Record<string, string | boolean | number>;
+	flags: Set<string>;
+}
+
+export interface OptionDefinition {
+	name: string;
+	alias?: string;
+	type: 'string' | 'boolean' | 'number';
+	default?: string | boolean | number;
+	description: string;
+}
+
+export interface CommandDefinition {
+	name: string;
+	alias?: string;
+	description: string;
+	options?: OptionDefinition[];
+	positionals?: { name: string; required: boolean; description: string }[];
+	examples?: string[];
+}
+
+/**
+ * Parse command line arguments
+ */
+export function parseArgs(
+	argv: string[] = process.argv.slice(2),
+): ParsedArgs {
+	const result: ParsedArgs = {
+		command: '',
+		positionals: [],
+		options: {},
+		flags: new Set(),
+	};
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+
+		if (!arg) continue;
+
+		// Long option: --option=value or --option value
+		if (arg.startsWith('--')) {
+			const eqIndex = arg.indexOf('=');
+			if (eqIndex !== -1) {
+				// --option=value
+				const name = arg.slice(2, eqIndex);
+				const value = arg.slice(eqIndex + 1);
+				result.options[name] = value;
+			} else {
+				// --option value or --flag
+				const name = arg.slice(2);
+				const nextArg = argv[i + 1];
+
+				// Check if it's a flag (no value or next arg starts with -)
+				if (!nextArg || nextArg.startsWith('-')) {
+					result.options[name] = true;
+					result.flags.add(name);
+				} else {
+					result.options[name] = nextArg;
+					i++; // Skip next arg as it's the value
+				}
+			}
+		}
+		// Short option: -o value or -abc (multiple flags)
+		else if (arg.startsWith('-') && arg.length > 1) {
+			const chars = arg.slice(1);
+
+			// Check if it's a combined flag like -abc
+			if (chars.length > 1) {
+				// Treat each char as a flag
+				for (const char of chars) {
+					result.options[char] = true;
+					result.flags.add(char);
+				}
+			} else {
+				// Single short option
+				const name = chars;
+				const nextArg = argv[i + 1];
+
+				if (!nextArg || nextArg.startsWith('-')) {
+					result.options[name] = true;
+					result.flags.add(name);
+				} else {
+					result.options[name] = nextArg;
+					i++; // Skip next arg as it's the value
+				}
+			}
+		}
+		// Positional argument
+		else {
+			if (!result.command) {
+				result.command = arg;
+			} else {
+				result.positionals.push(arg);
+			}
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Get option value with type coercion and default
+ */
+export function getOption<T extends string | boolean | number>(
+	parsed: ParsedArgs,
+	name: string,
+	definition: OptionDefinition,
+): T {
+	const value = parsed.options[name] ?? parsed.options[definition.alias ?? ''];
+
+	if (value === undefined) {
+		return definition.default as T;
+	}
+
+	if (definition.type === 'boolean') {
+		return (value === true || value === 'true') as T;
+	}
+
+	if (definition.type === 'number') {
+		return (typeof value === 'number' ? value : typeof value === 'string' ? parseInt(value, 10) : NaN) as T;
+	}
+
+	return value as T;
+}
+
+/**
+ * Check if a flag is set
+ */
+export function hasFlag(parsed: ParsedArgs, name: string, alias?: string): boolean {
+	return parsed.flags.has(name) || (alias ? parsed.flags.has(alias) : false);
+}
+
+/**
+ * Check if an option is set (either as flag or with value)
+ */
+export function hasOption(parsed: ParsedArgs, name: string, alias?: string): boolean {
+	return name in parsed.options || (alias ? alias in parsed.options : false);
+}
+
+/**
+ * Get all values for an option that can be specified multiple times
+ * Parses raw argv to collect all occurrences of the option
+ */
+export function getOptionValues(parsed: ParsedArgs, name: string, alias?: string): string[] {
+	const values: string[] = [];
+	const argv = process.argv.slice(2);
+	
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (!arg) continue;
+		
+		// Long option: --name value or --name=value
+		if (arg === `--${name}`) {
+			const nextArg = argv[i + 1];
+			if (nextArg && !nextArg.startsWith('-')) {
+				values.push(nextArg);
+				i++; // Skip next arg
+			}
+		} else if (arg.startsWith(`--${name}=`)) {
+			const value = arg.slice(name.length + 3); // --name=
+			values.push(value);
+		}
+		// Short option: -n value
+		else if (alias && arg === `-${alias}`) {
+			const nextArg = argv[i + 1];
+			if (nextArg && !nextArg.startsWith('-')) {
+				values.push(nextArg);
+				i++; // Skip next arg
+			}
+		}
+	}
+	
+	return values;
+}
+
+/**
+ * Generate help text from command definition
+ */
+export function generateHelpText(
+	command: CommandDefinition,
+	cliName = 'bueno',
+): string {
+	const lines: string[] = [];
+
+	// Description
+	lines.push(`\n${command.description}\n`);
+
+	// Usage
+	lines.push('Usage:');
+	let usage = `  ${cliName} ${command.name}`;
+
+	if (command.positionals) {
+		for (const pos of command.positionals) {
+			usage += pos.required ? ` <${pos.name}>` : ` [${pos.name}]`;
+		}
+	}
+
+	usage += ' [options]';
+	lines.push(usage + '\n');
+
+	// Positionals
+	if (command.positionals && command.positionals.length > 0) {
+		lines.push('Arguments:');
+		for (const pos of command.positionals) {
+			const required = pos.required ? ' (required)' : '';
+			lines.push(`  ${pos.name.padEnd(20)} ${pos.description}${required}`);
+		}
+		lines.push('');
+	}
+
+	// Options
+	if (command.options && command.options.length > 0) {
+		lines.push('Options:');
+		for (const opt of command.options) {
+			let flag = `--${opt.name}`;
+			if (opt.alias) {
+				flag = `-${opt.alias}, ${flag}`;
+			}
+
+			let defaultValue = '';
+			if (opt.default !== undefined) {
+				defaultValue = ` (default: ${opt.default})`;
+			}
+
+			lines.push(`  ${flag.padEnd(20)} ${opt.description}${defaultValue}`);
+		}
+		lines.push('');
+	}
+
+	// Examples
+	if (command.examples && command.examples.length > 0) {
+		lines.push('Examples:');
+		for (const example of command.examples) {
+			lines.push(`  ${example}`);
+		}
+		lines.push('');
+	}
+
+	return lines.join('\n');
+}
+
+/**
+ * Generate global help text
+ */
+export function generateGlobalHelpText(
+	commands: CommandDefinition[],
+	cliName = 'bueno',
+): string {
+	const lines: string[] = [];
+
+	lines.push(`\n${cliName} - A Bun-Native Full-Stack Framework CLI\n`);
+	lines.push('Usage:');
+	lines.push(`  ${cliName} <command> [options]\n`);
+
+	lines.push('Commands:');
+	for (const cmd of commands) {
+		const name = cmd.alias ? `${cmd.name} (${cmd.alias})` : cmd.name;
+		lines.push(`  ${name.padEnd(20)} ${cmd.description}`);
+	}
+	lines.push('');
+
+	lines.push('Global Options:');
+	lines.push('  --help, -h          Show help for command');
+	lines.push('  --version, -v       Show CLI version');
+	lines.push('  --verbose           Enable verbose output');
+	lines.push('  --quiet             Suppress non-essential output');
+	lines.push('  --no-color          Disable colored output');
+	lines.push('');
+
+	lines.push(`Run '${cliName} <command> --help' for more information about a command.\n`);
+
+	return lines.join('\n');
+}