@burger-api/cli 0.7.1 → 0.9.1

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to the Burger API CLI will be documented in this file.
 
+## Version 0.9.0 - (March 15, 2026)
+
+-   ✨ **Create** – New projects get a config file (`burger.config.ts`) from
+    your answers; the build uses this config when present.
+-   🔨 **Build** – One build pipeline for both bundle and executable; routes
+    are found at build time so production is fast and reliable.
+-   📂 **Defaults** – Executable output: `.build/executable/<project>` (or
+    `.exe` on Windows); bundle: `.build/bundle/app.js`.
+-   🧪 **Tests** – New tests for routes, config, and build output; CI catches
+    broken builds early.
+-   🐛 **Fixed** – Invalid route combinations are caught at build time.
+-   🐛 **Fixed** – Production build keeps your middleware and options (e.g.
+    title, description) instead of dropping them.
+-   📚 **Docs** – README updated with production build steps and test
+    commands.
+
 ## Version 0.7.0 - (December 23, 2025)
 
 ### Added
@@ -32,7 +48,7 @@ All notable changes to the Burger API CLI will be documented in this file.
 - `list` command to show available middleware from ecosystem
 - `add` command to download and install middleware
 - `build` command to bundle projects to single JS file
-- `build:executable` command to compile to standalone executable
+- `build:exec` command to compile to standalone executable
 - `serve` command for development server with hot reload
 - Beautiful console output with colors and symbols
 - Zero external dependencies for file operations (uses Bun's native APIs)

package/README.md

@@ -69,9 +69,24 @@ installed!
 -   ✅ Full project structure
 -   ✅ TypeScript configured
 -   ✅ Dependencies installed
+-   ✅ `burger.config.ts` generated from your answers
 -   ✅ Example routes
 -   ✅ Ready to run!
 
+Generated config example:
+
+```ts
+export default {
+    apiDir: './src/api',
+    pageDir: './src/pages',
+    apiPrefix: '/api',
+    pagePrefix: '/',
+    debug: false,
+};
+```
+
+Edit `burger.config.ts` anytime to change routes, prefixes, or debug mode.
+
 ---
 
 ### `burger-api list`
@@ -151,7 +166,8 @@ const app = new Burger({
 
 ### `burger-api build <file>`
 
-Bundle your project into a single JavaScript file.
+Bundle your project with build-time (AOT) route discovery.
+The CLI scans routes first, generates a virtual entry file, then runs Bun build.
 
 **Example:**
 
@@ -171,22 +187,29 @@ burger-api build index.ts --sourcemap linked
 
 **Options:**
 
--   `--outfile <path>` - Output file path (default: `.build/bundle.js`)
+-   `--outfile <path>` - Output file path (default: `.build/bundle/app.js`)
 -   `--minify` - Minify the output for smaller file size
 -   `--sourcemap <type>` - Generate sourcemaps (inline, linked, or none)
 -   `--target <target>` - Target environment (e.g., bun, node)
 
+Build config is loaded from `burger.config.ts` or `burger.config.js` when
+present. If no config exists, the CLI uses defaults:
+`apiDir=./src/api`, `pageDir=./src/pages`, `apiPrefix=/api`, `pagePrefix=/`.
+
 **Output:**
 
 ```
 ✓ Build completed successfully!
-  Output: .build/bundle.js
+  Output: .build/bundle/app.js
   Size: 42.5 KB
 ```
 
+- API-only apps: `app.js` is usually enough to deploy.
+- Apps with pages/assets: deploy the full `.build/bundle/` directory.
+
 ---
 
-### `burger-api build:executable <file>`
+### `burger-api build:exec <file>`
 
 Compile your project to a standalone executable that runs without Bun installed!
 
@@ -194,19 +217,19 @@ Compile your project to a standalone executable that runs without Bun installed!
 
 ```bash
 # Build for current platform
-burger-api build:executable index.ts
+burger-api build:exec index.ts
 
 # Build for Windows
-burger-api build:executable index.ts --target bun-windows-x64
+burger-api build:exec index.ts --target bun-windows-x64
 
 # Build for Linux
-burger-api build:executable index.ts --target bun-linux-x64
+burger-api build:exec index.ts --target bun-linux-x64
 
 # Build for Mac (ARM)
-burger-api build:executable index.ts --target bun-darwin-arm64
+burger-api build:exec index.ts --target bun-darwin-arm64
 
 # Custom output name
-burger-api build:executable index.ts --outfile my-server.exe
+burger-api build:exec index.ts --outfile my-server.exe
 ```
 
 **Options:**
@@ -228,11 +251,11 @@ burger-api build:executable index.ts --outfile my-server.exe
 
 ```
 ✓ Compilation completed successfully!
-  Executable: .build/my-api.exe
+  Executable: .build/executable/<project>.exe
   Size: 45.2 MB
 
   Your standalone executable is ready to run!
-  Run it: .build/my-api.exe
+  Run it: .build/executable/<project>.exe
 ```
 
 **Use case:** Perfect for deploying your API to production servers without
@@ -371,9 +394,13 @@ burger-api serve
 1. You're in a Burger API project directory
 2. The entry file exists
 3. There are no TypeScript errors in your code
+4. Route folder rules are valid (no mixed dynamic + wildcard siblings)
 
 Run `bun run dev` first to see any errors.
 
+If you use custom folders or prefixes, verify your `burger.config.ts` /
+`burger.config.js` values.
+
 ### Cross-compilation fails from Windows (D:\ drive)
 
 **Error:**
@@ -500,17 +527,23 @@ you encounter crashes, rebuild without `--bytecode`. The build scripts use
 
 ### Testing
 
-Test commands locally:
+Run tests (from `packages/cli`):
 
 ```bash
-# Create a test project
-bun run src/index.ts create test-app
+# Run all CLI tests
+bun run test
+
+# Run build tests only (check production matches dev)
+bun run test:build
+
+# Run one test file
+bun test test/build-output.test.ts
+```
+
+From the **repo root**, run all CLI tests with:
 
-# Test other commands
-cd test-app
-bun run ../src/index.ts list
-bun run ../src/index.ts add cors
-bun run ../src/index.ts serve
+```bash
+bun run test:cli
 ```
 
 ### Contributing
@@ -527,6 +560,11 @@ bun run ../src/index.ts serve
 -   Add comments explaining your code
 -   Test all commands before submitting
 -   Update README if adding new features
+-   Keep route rules in one place:
+    - runtime/shared rules: `packages/burger-api/src/utils/pathConversion.ts`
+    - scanner traversal: `packages/cli/src/utils/scanner.ts`
+-   Run build tests when changing routing/build (keeps dev and production behavior the same):
+    - `bun run test:build`
 
 ### Design Principles
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burger-api/cli",
-  "version": "0.7.1",
+  "version": "0.9.1",
   "description": "Simple command-line tool for Burger API projects",
   "module": "src/index.ts",
   "type": "module",
@@ -18,6 +18,8 @@
   },
   "scripts": {
     "dev": "bun run src/index.ts",
+    "test": "bun test --timeout 30000 ./test",
+    "test:build": "bun test test/scanner.test.ts test/virtual-entry.test.ts test/entry-options.test.ts test/build-preserve-options.test.ts",
     "build:win": "bun build ./src/index.ts --compile --target bun-windows-x64 --outfile dist/burger-api.exe --minify",
     "build:linux": "bun build ./src/index.ts --compile --target bun-linux-x64 --outfile dist/burger-api-linux --minify",
     "build:mac": "bun build ./src/index.ts --compile --target bun-darwin-arm64 --outfile dist/burger-api-mac --minify",
@@ -29,8 +31,7 @@
     "@clack/prompts": "^0.7.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "@types/commander": "^2.12.5"
+    "@types/bun": "latest"
   },
   "peerDependencies": {
     "typescript": "^5"
@@ -47,5 +48,8 @@
     "type": "git",
     "url": "git+https://github.com/isfhan/burger-api.git",
     "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}

package/src/commands/build.ts

@@ -2,15 +2,15 @@
  * Build Commands
  *
  * Two commands for packaging your Burger API project:
- * 1. `burger-api build <file>` - Bundle to single JS file
- * 2. `burger-api build:executable <file>` - Compile to standalone executable
+ * 1. `burger-api build <file>`      — Bundle to .build/bundle/
+ * 2. `burger-api build:exec <file>` — Compile to .build/executable/
  *
- * These are wrappers around Bun's build commands with sensible defaults.
+ * Both use build-time (AOT) route discovery — no filesystem scanning at runtime.
  */
 
 import { Command } from 'commander';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync } from 'fs';
+import { dirname, resolve } from 'path';
 import {
     spinner,
     success,
@@ -20,9 +20,11 @@ import {
     formatSize,
     dim,
 } from '../utils/logger';
+import { runVirtualEntryBuild } from '../utils/build/pipeline';
+import { getProjectName } from '../utils/build/project';
 
 /**
- * Build command options
+ * Options for the `build` command.
  */
 interface BuildCommandOptions {
     outfile: string;
@@ -32,7 +34,7 @@ interface BuildCommandOptions {
 }
 
 /**
- * Build executable command options
+ * Options for the `build:exec` command.
  */
 interface BuildExecutableOptions {
     outfile?: string;
@@ -42,74 +44,81 @@ interface BuildExecutableOptions {
 }
 
 /**
- * Create the "build" command
- * Bundles your code into a single JavaScript file
+ * `burger-api build <file>`
+ *
+ * Bundles your project into .build/bundle/ using AOT route discovery.
+ *
+ * Output:
+ *   .build/bundle/
+ *     app.js             — Bun server (run with: bun .build/bundle/app.js)
+ *     index.html         — HTML pages (flat, one per page route)
+ *     style-[hash].css   — CSS assets (flat)
+ *     app-[hash].js      — JS chunks (flat)
+ *
+ * API-only projects: app.js is a self-contained single file.
+ * Projects with HTML pages: deploy the entire .build/bundle/ directory.
  */
 export const buildCommand = new Command('build')
-    .description('Bundle your project to a single JavaScript file')
-    .argument('<file>', 'Entry file to build (e.g., index.ts)')
-    .option('--outfile <path>', 'Output file path', '.build/bundle.js')
+    .description('Bundle your project into .build/bundle/')
+    .argument(
+        '<file>',
+        'Entry file (used for compatibility; config from burger.config.ts or conventions)'
+    )
+    .option('--outfile <path>', 'Output bundle path', '.build/bundle/app.js')
     .option('--minify', 'Minify the output')
     .option(
         '--sourcemap <type>',
         'Generate sourcemaps (inline, linked, or none)'
     )
-    .option('--target <target>', 'Target environment (e.g., bun, node)')
+    .option('--target <env>', 'Target environment (default: bun)')
     .action(async (file: string, options: BuildCommandOptions) => {
-        // Check if the input file exists
-        if (!existsSync(file)) {
-            logError(`File not found: ${file}`);
+        const cwd = process.cwd();
+        const entryPath = resolve(cwd, file);
+        if (!existsSync(entryPath)) {
+            logError(`Entry file not found: ${file}`);
+            info('Make sure you are in the project directory.');
             process.exit(1);
         }
 
         const spin = spinner('Building project...');
 
         try {
-            // Build the command arguments for Bun
-            const args = ['build', file];
-
-            // Add output file
-            args.push('--outfile', options.outfile);
-
-            // Add optional flags
-            if (options.minify) {
-                args.push('--minify');
-            }
-
-            if (options.sourcemap) {
-                args.push('--sourcemap', options.sourcemap);
-            }
-
-            // Always target bun by default since BurgerAPI uses Bun builtins
-            args.push('--target', options.target || 'bun');
-
-            // Run the build using Bun.spawn
-            const proc = Bun.spawn(['bun', ...args], {
-                stdout: 'pipe',
-                stderr: 'pipe',
+            info('Build-time route discovery enabled.');
+
+            const { success: ok, hasPages } = await runVirtualEntryBuild({
+                cwd,
+                entryFile: file,
+                outfile: options.outfile,
+                target: options.target || 'bun',
+                minify: options.minify,
+                sourcemap: options.sourcemap,
             });
 
-            // Wait for it to complete
-            const exitCode = await proc.exited;
-
-            if (exitCode !== 0) {
-                // Read error output
-                const errorText = await new Response(proc.stderr).text();
+            if (!ok) {
                 spin.stop('Build failed', true);
-                logError(errorText || 'Build process failed');
+                logError(
+                    'Bun.build failed. Check that api/page directories and route files are valid.'
+                );
                 process.exit(1);
             }
 
-            // Get file size
-            const outputFile = Bun.file(options.outfile);
-            const size = outputFile.size;
+            const size = Bun.file(options.outfile).size;
+            const bundleDir = dirname(options.outfile);
 
             spin.stop('Build completed successfully!');
             newline();
-            success(`Output: ${options.outfile}`);
-            info(`Size: ${formatSize(size)}`);
+            success(`Bundle:  ${options.outfile}  (${formatSize(size)})`);
             newline();
-            dim('Run your bundle with: bun ' + options.outfile);
+            if (hasPages) {
+                info(`Pages and assets are in: ${bundleDir}/`);
+                dim(
+                    'Deploy the entire directory — HTML pages depend on their chunks.'
+                );
+                dim(`Run: bun ${options.outfile}`);
+            } else {
+                info('API-only bundle — self-contained single file.');
+                dim(`Run anywhere: bun ${options.outfile}`);
+            }
             newline();
         } catch (err) {
             spin.stop('Build failed', true);
@@ -119,109 +128,92 @@ export const buildCommand = new Command('build')
     });
 
 /**
- * Create the "build:executable" command
- * Compiles your code to a standalone executable
+ * `burger-api build:exec <file>`
+ *
+ * Compiles your project into a standalone binary in .build/executable/.
+ * The binary is fully self-contained — no Bun installation required on the target.
+ * All routes, pages, and assets are embedded inside the binary.
  */
-export const buildExecutableCommand = new Command('build:executable')
-    .description('Compile your project to a standalone executable')
-    .argument('<file>', 'Entry file to compile (e.g., index.ts)')
-    .option('--outfile <path>', 'Output file path')
+export const buildExecutableCommand = new Command('build:exec')
+    .description(
+        'Compile your project to a standalone executable in .build/executable/'
+    )
+    .argument(
+        '<file>',
+        'Entry file (used for compatibility; config from burger.config.ts or conventions)'
+    )
+    .option('--outfile <path>', 'Output executable path')
     .option(
-        '--target <target>',
+        '--target <platform>',
         'Target platform (bun-windows-x64, bun-linux-x64, bun-darwin-arm64)'
     )
     .option('--minify', 'Minify the output (enabled by default)', true)
     .option('--no-bytecode', 'Disable bytecode compilation')
     .action(async (file: string, options: BuildExecutableOptions) => {
-        // Check if the input file exists
-        if (!existsSync(file)) {
-            logError(`File not found: ${file}`);
+        const cwd = process.cwd();
+        const entryPath = resolve(cwd, file);
+        if (!existsSync(entryPath)) {
+            logError(`Entry file not found: ${file}`);
+            info('Make sure you are in the project directory.');
             process.exit(1);
         }
 
-        // Determine output filename
         let outfile = options.outfile;
         if (!outfile) {
-            // Get project name from package.json or use basename
-            const projectName = getProjectName();
-
-            // Add platform-specific extension
-            // Check if targeting Windows or if we're on Windows without a specific target
+            const projectName = getProjectName(cwd);
             const isWindows =
                 options.target?.includes('windows') ||
                 (!options.target && process.platform === 'win32');
-
-            if (isWindows) {
-                outfile = `.build/${projectName}.exe`;
-            } else {
-                outfile = `.build/${projectName}`;
-            }
+            outfile = isWindows
+                ? `.build/executable/${projectName}.exe`
+                : `.build/executable/${projectName}`;
         }
 
         const spin = spinner('Compiling to executable...');
 
         try {
-            // Build the command arguments for Bun
-            const args = ['build', file, '--compile'];
-
-            // Add output file
-            args.push('--outfile', outfile);
-
-            // Add target platform
-            if (options.target) {
-                args.push('--target', options.target);
-            }
-
-            // Add minify (on by default)
-            if (options.minify) {
-                args.push('--minify');
-            }
-
-            // Add bytecode (on by default, unless --no-bytecode is passed)
-            if (options.bytecode !== false) {
-                args.push('--bytecode');
-            }
-
+            info('Build-time route discovery enabled.');
             spin.update('Compiling... (this may take a minute)');
 
-            // Run the build using Bun.spawn
-            const proc = Bun.spawn(['bun', ...args], {
-                stdout: 'pipe',
-                stderr: 'pipe',
+            const { success: ok, outputs } = await runVirtualEntryBuild({
+                cwd,
+                entryFile: file,
+                outfile,
+                target: options.target,
+                minify: options.minify,
+                bytecode: options.bytecode !== false,
+                compile: true,
             });
 
-            // Wait for it to complete
-            const exitCode = await proc.exited;
-
-            if (exitCode !== 0) {
-                // Read error output
-                const errorText = await new Response(proc.stderr).text();
+            if (!ok) {
                 spin.stop('Compilation failed', true);
-                logError(errorText || 'Compilation process failed');
+                logError(
+                    'Bun.build failed. Check that api/page directories and route files are valid.'
+                );
                 process.exit(1);
             }
 
-            // Get file size - check if file exists first
-            let size = 0;
-            if (existsSync(outfile)) {
-                const executableFile = Bun.file(outfile);
-                size = executableFile.size;
-            }
+            const size = existsSync(outfile)
+                ? Bun.file(outfile).size
+                : (outputs[0]?.size ?? 0);
 
             spin.stop('Compilation completed successfully!');
             newline();
             success(`Executable: ${outfile}`);
-            if (size > 0) {
-                info(`Size: ${formatSize(size)}`);
-            }
+            if (size > 0) info(`Size: ${formatSize(size)}`);
+            newline();
+            info(
+                'Standalone binary — copy it anywhere, no Bun required on the target.'
+            );
+            dim(
+                'All routes, pages, and assets are embedded inside the binary.'
+            );
             newline();
-            info('Your standalone executable is ready to run!');
-
             if (process.platform !== 'win32') {
-                dim(`Make it executable: chmod +x ${outfile}`);
-                dim(`Run it: ./${outfile}`);
+                dim(`Make executable: chmod +x ${outfile}`);
+                dim(`Run: ./${outfile}`);
             } else {
-                dim(`Run it: ${outfile}`);
+                dim(`Run: ${outfile}`);
             }
             newline();
         } catch (err) {
@@ -230,21 +222,3 @@ export const buildExecutableCommand = new Command('build:executable')
             process.exit(1);
         }
     });
-
-/**
- * Get the project name from package.json
- * Falls back to 'app' if not found
- */
-function getProjectName(): string {
-    try {
-        const packageJsonPath = join(process.cwd(), 'package.json');
-        if (existsSync(packageJsonPath)) {
-            const content = readFileSync(packageJsonPath, 'utf-8');
-            const packageJson = JSON.parse(content);
-            return packageJson?.name || 'app';
-        }
-    } catch (err) {
-        // Ignore errors
-    }
-    return 'app';
-}

package/src/commands/create.ts

@@ -82,6 +82,7 @@ export const createCommand = new Command('create')
             info('Creating project with the following configuration:');
             newline();
             console.log(`  Name: ${projectName}`);
+            console.log(`  Config File: burger.config.ts`);
             if (options.useApi) {
                 console.log(`  API Routes: ${options.apiDir || 'api'}`);
             }
@@ -106,10 +107,13 @@ export const createCommand = new Command('create')
             console.log(`  2. Start the development server:`);
             command('bun run dev');
             newline();
-            console.log(`  3. Open your browser:`);
+            console.log(`  3. Edit config if needed:`);
+            command('burger.config.ts');
+            newline();
+            console.log(`  4. Open your browser:`);
             console.log(`     ${highlight('http://localhost:4000')}`);
             newline();
-            console.log(`  4. Add middleware (optional):`);
+            console.log(`  5. Add middleware (optional):`);
             command('burger-api add cors logger');
             newline();
             success('Happy coding!');

package/src/index.ts

@@ -10,6 +10,8 @@
  * This makes it easy to add new commands and provide helpful error messages.
  */
 
+import { readFileSync } from 'fs';
+import { join } from 'path';
 import { Command } from 'commander';
 import { createCommand } from './commands/create';
 import { addCommand } from './commands/add';
@@ -18,6 +20,22 @@ import { buildCommand, buildExecutableCommand } from './commands/build';
 import { serveCommand } from './commands/serve';
 import { showBanner } from './utils/logger';
 
+/**
+ * Read CLI version from package.json (single source of truth for publish).
+ * @returns The version of the CLI.
+ */
+function getVersion(): string {
+    try {
+        const pkgPath = join(import.meta.dir, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as {
+            version?: string;
+        };
+        return pkg.version ?? '0.0.0';
+    } catch {
+        return '0.0.0';
+    }
+}
+
 /**
  * Create the main CLI program
  * This is what runs when someone types 'burger-api' in their terminal
@@ -28,7 +46,7 @@ const program = new Command();
 program
     .name('burger-api')
     .description('Simple tool to work with BurgerAPI projects')
-    .version('0.7.1');
+    .version(getVersion());
 
 // Add all our commands to the CLI
 // Each command is defined in its own file for better organization
@@ -41,7 +59,7 @@ program.addCommand(serveCommand); // Run development server
 
 // Show banner + help when no command is provided
 program.action(() => {
-    showBanner();
+    showBanner(getVersion());
     program.help();
 });
 

package/src/types/index.ts

@@ -51,3 +51,15 @@ export interface GitHubFile {
     download_url?: string;
     size: number;
 }
+
+/**
+ * Build-time configuration for Burger API (conventions or burger.config.ts).
+ * Used by the CLI when generating the virtual entry and scanning routes.
+ */
+export interface BuildConfig {
+    apiDir: string;
+    pageDir: string;
+    apiPrefix: string;
+    pagePrefix: string;
+    debug?: boolean;
+}