reroute-js 0.6.0 → 0.7.0

package/cli/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v0.6.0
+ * reroute-js v0.7.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -10,7 +10,22 @@
  * Built with Bun <3
  */
 import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -32,7 +47,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "0.6.0";
+    return "0.7.0";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -50,7 +65,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "a76a267";
+    return "4b119c0";
   }
   return "dev";
 }
@@ -115,15 +130,53 @@ async function scaffoldProject(options) {
   console.log(`
 \uD83D\uDCE6  Template: ${template}
 `);
-  const templatePath = join(import.meta.dir, "..", "_", template);
-  if (!existsSync(templatePath)) {
-    console.error(`Error: Template directory not found at ${templatePath}`);
+  const possibleTemplatePaths = [
+    join(import.meta.dir, "..", "_", template),
+    join(import.meta.dir, "..", "..", "..", "_", template)
+  ];
+  let templatePath;
+  for (const path2 of possibleTemplatePaths) {
+    if (existsSync(path2)) {
+      templatePath = path2;
+      break;
+    }
+  }
+  if (!templatePath) {
+    console.error(`Error: Template directory not found for template "${template}"`);
+    console.error(`Tried paths: ${possibleTemplatePaths.join(", ")}`);
     process.exit(1);
   }
+  const possibleExamplesPaths = [
+    join(import.meta.dir, "..", "..", "..", "..", "examples", template, "src"),
+    join(import.meta.dir, "..", "..", "..", "..", "..", "examples", template, "src")
+  ];
+  let examplesPath;
+  for (const path2 of possibleExamplesPaths) {
+    if (existsSync(path2)) {
+      examplesPath = path2;
+      break;
+    }
+  }
   await mkdir(projectPath, { recursive: true });
   await copyTemplateFiles(templatePath, projectPath, {
     PROJECT_NAME: projectName
   });
+  const sourceVariables = {
+    PROJECT_NAME: projectName
+  };
+  if (examplesPath) {
+    await copySourceFiles(examplesPath, join(projectPath, "src"), sourceVariables);
+  } else {
+    const templateSrcPath = join(templatePath, "src");
+    if (existsSync(templateSrcPath)) {
+      await copySourceFiles(templateSrcPath, join(projectPath, "src"), sourceVariables);
+    } else {
+      console.error(`Error: No src directory found for template "${template}"`);
+      console.error(`Tried examples paths: ${possibleExamplesPaths.join(", ")}`);
+      console.error(`Tried template path: ${templateSrcPath}`);
+      process.exit(1);
+    }
+  }
   console.log(`\uD83D\uDCE5  Installing dependencies...
 `);
   const proc = Bun.spawn(["bun", "install"], {
@@ -137,6 +190,9 @@ async function scaffoldProject(options) {
 async function copyTemplateFiles(templatePath, targetPath, variables) {
   const entries = await readdir(templatePath, { withFileTypes: true });
   for (const entry of entries) {
+    if (entry.isDirectory() && entry.name === "src") {
+      continue;
+    }
     const sourcePath = join(templatePath, entry.name);
     const destPath = join(targetPath, entry.name);
     if (entry.isDirectory()) {
@@ -153,6 +209,34 @@ async function copyTemplateFiles(templatePath, targetPath, variables) {
     }
   }
 }
+function applyVariableReplacements(content, fileName, variables) {
+  const shouldReplaceVariables = VARIABLE_REPLACEMENT_PATTERNS.some((pattern) => pattern.test(fileName));
+  if (!shouldReplaceVariables) {
+    return content;
+  }
+  let processedContent = content;
+  if (/\.html$/i.test(fileName)) {
+    if (variables.PROJECT_NAME) {
+      processedContent = processedContent.replace(/<title>.*?<\/title>/i, `<title>${variables.PROJECT_NAME}</title>`);
+    }
+  }
+  return processedContent;
+}
+async function copySourceFiles(sourcePath, targetPath, variables) {
+  const entries = await readdir(sourcePath, { withFileTypes: true });
+  await mkdir(targetPath, { recursive: true });
+  for (const entry of entries) {
+    const sourceEntryPath = join(sourcePath, entry.name);
+    const targetEntryPath = join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      await copySourceFiles(sourceEntryPath, targetEntryPath, variables);
+    } else if (entry.isFile()) {
+      const content = await readFile(sourceEntryPath, "utf-8");
+      const processedContent = variables ? applyVariableReplacements(content, entry.name, variables) : content;
+      await writeFile(targetEntryPath, processedContent);
+    }
+  }
+}
 function printSuccess(projectName, template) {
   console.log(`
 \uD83C\uDFCE️ Project created successfully!
@@ -205,8 +289,12 @@ async function printHelp() {
   console.log("  reroute init my-blog --template blog");
   console.log("  reroute init my-store --template store");
 }
+var VARIABLE_REPLACEMENT_PATTERNS;
 var init_init = __esm(() => {
   init_version();
+  VARIABLE_REPLACEMENT_PATTERNS = [
+    /\.html$/i
+  ];
 });
 
 // packages/cli/src/libs/markdown.ts
@@ -1155,7 +1243,7 @@ async function generate(cwd) {
   await writeFile2(join5(cwd, OUTPUT_INDEX), indexLines.join(`
 `), "utf-8");
   console.log(`[reroute/gen] Generated index: ${join5(cwd, OUTPUT_INDEX)}`);
-  console.log("[reroute/gen] ✅ Generation complete!");
+  console.log("[reroute/gen] Generation complete");
 }
 async function gen(args) {
   const cwd = process.cwd();
@@ -1269,7 +1357,7 @@ async function boot(_) {
     console.log(`[reroute/boot] Created stub: ${OUTPUT_CONTENT_TS2}`);
     await writeFile3(join6(cwd, OUTPUT_INDEX2), STUB_INDEX, "utf-8");
     console.log(`[reroute/boot] Created stub: ${OUTPUT_INDEX2}`);
-    console.log("[reroute/boot] ✅ Initialization complete!");
+    console.log("[reroute/boot] Initialization complete");
     console.log('[reroute/boot] Run "reroute gen" to generate actual routes and content.');
   } catch (error) {
     console.error("[reroute/boot] Failed to initialize:", error);
@@ -1313,12 +1401,692 @@ export type RerouteArtifacts = typeof artifacts;
 `;
 var init_boot = () => {};
 
+// packages/cli/src/libs/log.ts
+function colorizeLogPrefix(text) {
+  let colored = text;
+  const sortedPrefixes = Object.entries(PREFIX_COLORS).sort(([a], [b]) => b.length - a.length);
+  for (const [prefix, colorTag] of sortedPrefixes) {
+    colored = colored.replace(new RegExp(`(${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`, "g"), `${colorTag}$1{/}`);
+  }
+  return colored;
+}
+function blessedToAnsi(text) {
+  return text.replace(/\{cyan-fg\}/g, "\x1B[36m").replace(/\{blue-fg\}/g, "\x1B[34m").replace(/\{magenta-fg\}/g, "\x1B[35m").replace(/\{yellow-fg\}/g, "\x1B[33m").replace(/\{green-fg\}/g, "\x1B[32m").replace(/\{red-fg\}/g, "\x1B[31m").replace(/\{bright-cyan-fg\}/g, "\x1B[96m").replace(/\{bright-blue-fg\}/g, "\x1B[94m").replace(/\{bright-magenta-fg\}/g, "\x1B[95m").replace(/\{bright-yellow-fg\}/g, "\x1B[93m").replace(/\{bright-green-fg\}/g, "\x1B[92m").replace(/\{bright-red-fg\}/g, "\x1B[91m").replace(/\{\/\}/g, "\x1B[0m");
+}
+function colorizeLogPrefixAnsi(text) {
+  return blessedToAnsi(colorizeLogPrefix(text));
+}
+function createServerOutputHandler(buffer) {
+  return (data) => {
+    const text = buffer.current + data.toString();
+    const lines = text.split(`
+`);
+    buffer.current = lines.pop() || "";
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) {
+        continue;
+      }
+      const ansiColored = colorizeLogPrefixAnsi(line);
+      console.log(ansiColored);
+    }
+  };
+}
+var PREFIX_COLORS;
+var init_log = __esm(() => {
+  PREFIX_COLORS = {
+    "[reroute]": "{cyan-fg}",
+    "[reroute/gen]": "{bright-blue-fg}",
+    "[reroute/content]": "{magenta-fg}",
+    "[reroute/markdown]": "{yellow-fg}",
+    "[reroute/tailwind]": "{red-fg}",
+    "[reroute/mdx]": "{bright-red-fg}",
+    "[reroute/boot]": "{bright-yellow-fg}",
+    "[reroute/dev]": "{green-fg}",
+    "[reroute/start]": "{bright-cyan-fg}",
+    "[reroute/build]": "{bright-magenta-fg}",
+    "[api]": "{blue-fg}",
+    "[app]": "{bright-green-fg}"
+  };
+});
+
+// packages/cli/src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  default: () => dev
+});
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+function getRerouteCommand() {
+  const binPath = join7(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync5(binPath);
+  if (isBunDev) {
+    return `bun ${binPath}`;
+  }
+  const cwd = process.cwd();
+  const nodeModulesPaths = [
+    join7(cwd, "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync5(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+async function dev(args) {
+  const singleColumn = args.includes("--single") || args.includes("-s");
+  try {
+    console.log("[reroute/dev] Running boot...");
+    await boot([]);
+    console.log(`[reroute/dev] Boot complete
+`);
+    console.log("[reroute/dev] Starting development servers...");
+    console.log(`[reroute/dev] Press Ctrl+C to stop
+`);
+    const rerouteCmd = getRerouteCommand();
+    const useShell = rerouteCmd.includes(" ");
+    const genCommand = useShell ? `${rerouteCmd} gen --watch` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen", "--watch"];
+    const genProcess = spawn2(genCommand, genArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: useShell
+    });
+    const serverProcess = spawn2("bun", ["--watch", "src/index.ts"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (singleColumn) {
+      const genBuffer = { current: "" };
+      const serverBuffer = { current: "" };
+      const handleGenOutput = (data) => {
+        const text = genBuffer.current + data.toString();
+        const lines = text.split(`
+`);
+        genBuffer.current = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) {
+            continue;
+          }
+          const ansiColored = colorizeLogPrefixAnsi(line);
+          console.log(ansiColored);
+        }
+      };
+      const handleServerOutput = createServerOutputHandler(serverBuffer);
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      serverProcess.stdout?.on("data", handleServerOutput);
+      serverProcess.stderr?.on("data", handleServerOutput);
+      genProcess.on("exit", (code) => {
+        console.log(`
+[reroute/gen] Process exited with code ${code}`);
+      });
+      serverProcess.on("exit", (code) => {
+        console.log(`
+[server] Process exited with code ${code}`);
+      });
+      process.on("SIGINT", () => {
+        console.log(`
+[reroute/dev] Shutting down...`);
+        genProcess.kill("SIGINT");
+        serverProcess.kill("SIGINT");
+        process.exit(0);
+      });
+    } else {
+      const blessed = await import("blessed");
+      const contrib = await import("blessed-contrib");
+      const screen = blessed.default.screen({
+        smartCSR: true,
+        title: "reroute dev",
+        mouse: true
+      });
+      const grid = new contrib.default.grid({
+        rows: 1,
+        cols: 2,
+        screen
+      });
+      const genBox = grid.set(0, 0, 1, 1, blessed.default.log, {
+        label: " reroute gen --watch ",
+        border: { type: "line" },
+        style: {
+          border: { fg: "cyan" }
+        },
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+          ch: " ",
+          inverse: true
+        },
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        input: true,
+        clickable: true
+      });
+      const serverBox = grid.set(0, 1, 1, 1, blessed.default.log, {
+        label: " bun --watch src/index.ts ",
+        border: { type: "line" },
+        style: {
+          border: { fg: "green" }
+        },
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+          ch: " ",
+          inverse: true
+        },
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        input: true,
+        clickable: true
+      });
+      genBox.key(["up", "k"], () => {
+        genBox.scroll(-1);
+        screen.render();
+      });
+      genBox.key(["down", "j"], () => {
+        genBox.scroll(1);
+        screen.render();
+      });
+      genBox.key(["pageup"], () => {
+        genBox.scroll(-genBox.height);
+        screen.render();
+      });
+      genBox.key(["pagedown"], () => {
+        genBox.scroll(genBox.height);
+        screen.render();
+      });
+      genBox.key(["home", "g"], () => {
+        genBox.setScrollPerc(0);
+        screen.render();
+      });
+      genBox.key(["end", "G"], () => {
+        genBox.setScrollPerc(100);
+        screen.render();
+      });
+      serverBox.key(["up", "k"], () => {
+        serverBox.scroll(-1);
+        screen.render();
+      });
+      serverBox.key(["down", "j"], () => {
+        serverBox.scroll(1);
+        screen.render();
+      });
+      serverBox.key(["pageup"], () => {
+        serverBox.scroll(-serverBox.height);
+        screen.render();
+      });
+      serverBox.key(["pagedown"], () => {
+        serverBox.scroll(serverBox.height);
+        screen.render();
+      });
+      serverBox.key(["home", "g"], () => {
+        serverBox.setScrollPerc(0);
+        screen.render();
+      });
+      serverBox.key(["end", "G"], () => {
+        serverBox.setScrollPerc(100);
+        screen.render();
+      });
+      genBox.on("wheeldown", () => {
+        genBox.scroll(3);
+        screen.render();
+      });
+      genBox.on("wheelup", () => {
+        genBox.scroll(-3);
+        screen.render();
+      });
+      serverBox.on("wheeldown", () => {
+        serverBox.scroll(3);
+        screen.render();
+      });
+      serverBox.on("wheelup", () => {
+        serverBox.scroll(-3);
+        screen.render();
+      });
+      genBox.on("click", () => {
+        genBox.focus();
+        screen.render();
+      });
+      serverBox.on("click", () => {
+        serverBox.focus();
+        screen.render();
+      });
+      screen.key(["tab"], () => {
+        if (screen.focused === genBox) {
+          serverBox.focus();
+        } else {
+          genBox.focus();
+        }
+        screen.render();
+      });
+      genBox.focus();
+      screen.render();
+      genProcess.stdout?.on("data", (data) => {
+        const text = data.toString();
+        const lines = text.split(`
+`).filter((line) => line.trim());
+        if (lines.length > 0) {
+          const colored = colorizeLogPrefix(lines.join(`
+`));
+          genBox.log(colored);
+          screen.render();
+        }
+      });
+      genProcess.stderr?.on("data", (data) => {
+        const text = data.toString();
+        const lines = text.split(`
+`).filter((line) => line.trim());
+        if (lines.length > 0) {
+          const colored = colorizeLogPrefix(lines.join(`
+`));
+          genBox.log(colored);
+          screen.render();
+        }
+      });
+      serverProcess.stdout?.on("data", (data) => {
+        const text = data.toString();
+        const filteredText = text.split(`
+`).filter((line) => line.trim()).join(`
+`);
+        if (filteredText) {
+          const colored = colorizeLogPrefix(filteredText);
+          serverBox.log(colored);
+          screen.render();
+        }
+      });
+      serverProcess.stderr?.on("data", (data) => {
+        const text = data.toString();
+        const filteredText = text.split(`
+`).filter((line) => line.trim()).join(`
+`);
+        if (filteredText) {
+          const colored = colorizeLogPrefix(filteredText);
+          serverBox.log(colored);
+          screen.render();
+        }
+      });
+      genProcess.on("exit", (code) => {
+        genBox.log(`
+[Process exited with code ${code}]`);
+        screen.render();
+      });
+      serverProcess.on("exit", (code) => {
+        serverBox.log(`
+[Process exited with code ${code}]`);
+        screen.render();
+      });
+      screen.key(["escape", "q", "C-c"], () => {
+        genProcess.kill("SIGINT");
+        serverProcess.kill("SIGINT");
+        screen.destroy();
+        process.exit(0);
+      });
+      screen.on("resize", () => {
+        screen.render();
+      });
+    }
+  } catch (error) {
+    if (error.code === "SIGINT") {
+      console.log(`
+[reroute/dev] Shutting down...`);
+      process.exit(0);
+    }
+    console.error("[reroute/dev] Error:", error);
+    throw error;
+  }
+}
+var init_dev = __esm(() => {
+  init_log();
+  init_boot();
+});
+
+// packages/cli/src/commands/start.ts
+var exports_start = {};
+__export(exports_start, {
+  default: () => start
+});
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+function getRerouteCommand2() {
+  const binPath = join8(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync6(binPath);
+  if (isBunDev) {
+    return `bun ${binPath}`;
+  }
+  const cwd = process.cwd();
+  const nodeModulesPaths = [
+    join8(cwd, "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync6(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+async function start(_args) {
+  try {
+    const rerouteCmd = getRerouteCommand2();
+    const useShell = rerouteCmd.includes(" ");
+    const bootBuffer = { current: "" };
+    const genBuffer = { current: "" };
+    const handleBootOutput = (data) => {
+      const text = bootBuffer.current + data.toString();
+      const lines = text.split(`
+`);
+      bootBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        console.log(ansiColored);
+      }
+    };
+    const handleGenOutput = (data) => {
+      const text = genBuffer.current + data.toString();
+      const lines = text.split(`
+`);
+      genBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        console.log(ansiColored);
+      }
+    };
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Running boot...")}
+`);
+    const bootCommand = useShell ? `${rerouteCmd} boot` : rerouteCmd;
+    const bootArgs = useShell ? [] : ["boot"];
+    await new Promise((resolve, reject) => {
+      const bootProcess = spawn3(bootCommand, bootArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      bootProcess.stdout?.on("data", handleBootOutput);
+      bootProcess.stderr?.on("data", handleBootOutput);
+      bootProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Boot exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      bootProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Boot complete
+`));
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Running gen...")}
+`);
+    const genCommand = useShell ? `${rerouteCmd} gen` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen"];
+    await new Promise((resolve, reject) => {
+      const genProcess = spawn3(genCommand, genArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      genProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Gen exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      genProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Generation complete
+`));
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Starting server...")}
+`);
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Press Ctrl+C to stop
+`));
+    const serverProcess = spawn3("bun", ["src/index.ts"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const serverBuffer = { current: "" };
+    const handleServerOutput = createServerOutputHandler(serverBuffer);
+    serverProcess.stdout?.on("data", handleServerOutput);
+    serverProcess.stderr?.on("data", handleServerOutput);
+    process.on("SIGINT", () => {
+      process.stdout.write(`${colorizeLogPrefixAnsi(`
+[reroute/start] Shutting down...`)}
+`);
+      serverProcess.kill("SIGINT");
+      process.exit(0);
+    });
+    await new Promise((resolve, reject) => {
+      serverProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          console.error(colorizeLogPrefixAnsi(`[reroute/start] Server exited with code ${code}`));
+          reject(new Error(`Server exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      serverProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  } catch (error) {
+    if (error.code === "SIGINT") {
+      process.stdout.write(`${colorizeLogPrefixAnsi(`
+[reroute/start] Shutting down...`)}
+`);
+      process.exit(0);
+    }
+    process.stderr.write(`${colorizeLogPrefixAnsi("[reroute/start] Error: ") + String(error)}
+`);
+    throw error;
+  }
+}
+var init_start = __esm(() => {
+  init_log();
+});
+
+// packages/cli/src/commands/build.ts
+var exports_build = {};
+__export(exports_build, {
+  default: () => build
+});
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
+import { join as join9 } from "node:path";
+function getRerouteCommand3() {
+  const binPath = join9(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync7(binPath);
+  if (isBunDev) {
+    return `bun ${binPath}`;
+  }
+  const cwd = process.cwd();
+  const nodeModulesPaths = [
+    join9(cwd, "node_modules", ".bin", "reroute"),
+    join9(cwd, "..", "node_modules", ".bin", "reroute"),
+    join9(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join9(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync7(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+function getOutputName() {
+  const cwd = process.cwd();
+  const packageJsonPath = join9(cwd, "package.json");
+  if (existsSync7(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+      const name = packageJson.name;
+      if (name) {
+        const parts = name.split("-");
+        if (parts.length > 1 && parts[parts.length - 1] === "example") {
+          return parts[parts.length - 2] || "app";
+        }
+        return parts[parts.length - 1] || name;
+      }
+    } catch {}
+  }
+  return "app";
+}
+async function build(args) {
+  try {
+    const rerouteCmd = getRerouteCommand3();
+    const useShell = rerouteCmd.includes(" ");
+    let outputPath = `./dist/${getOutputName()}`;
+    const outfileIndex = args.indexOf("--outfile");
+    const shortOutfileIndex = args.indexOf("-o");
+    const outfileArgIndex = outfileIndex !== -1 ? outfileIndex : shortOutfileIndex;
+    if (outfileArgIndex !== -1 && args[outfileArgIndex + 1]) {
+      outputPath = args[outfileArgIndex + 1];
+    }
+    const bootBuffer = { current: "" };
+    const genBuffer = { current: "" };
+    const handleBootOutput = (data) => {
+      const text = bootBuffer.current + data.toString();
+      const lines = text.split(`
+`);
+      bootBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        console.log(ansiColored);
+      }
+    };
+    const handleGenOutput = (data) => {
+      const text = genBuffer.current + data.toString();
+      const lines = text.split(`
+`);
+      genBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        console.log(ansiColored);
+      }
+    };
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running boot...")}
+`);
+    const bootCommand = useShell ? `${rerouteCmd} boot` : rerouteCmd;
+    const bootArgs = useShell ? [] : ["boot"];
+    await new Promise((resolve, reject) => {
+      const bootProcess = spawn4(bootCommand, bootArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      bootProcess.stdout?.on("data", handleBootOutput);
+      bootProcess.stderr?.on("data", handleBootOutput);
+      bootProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Boot exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      bootProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Boot complete
+`));
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running gen...")}
+`);
+    const genCommand = useShell ? `${rerouteCmd} gen` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen"];
+    await new Promise((resolve, reject) => {
+      const genProcess = spawn4(genCommand, genArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      genProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Gen exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      genProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Generation complete
+`));
+    process.stdout.write(`${colorizeLogPrefixAnsi(`[reroute/build] Building binary to ${outputPath}...`)}
+`);
+    const isProduction = true;
+    const buildArgs = ["build", "src/index.ts", "--target", "bun", "--compile"];
+    if (isProduction) {
+      buildArgs.push("--minify");
+    }
+    const filteredArgs = args.filter((arg, idx) => {
+      if (outfileArgIndex !== -1) {
+        if (idx === outfileArgIndex || idx === outfileArgIndex + 1) {
+          return false;
+        }
+      }
+      return arg !== "--outfile" && arg !== "-o" && arg !== "--minify" && arg !== "--no-minify";
+    });
+    buildArgs.push(...filteredArgs, "--outfile", outputPath);
+    await new Promise((resolve, reject) => {
+      const buildProcess = spawn4("bun", buildArgs, {
+        stdio: "inherit"
+      });
+      buildProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Build exited with code ${code}`));
+        } else {
+          process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Build complete: ${outputPath}
+`));
+          resolve();
+        }
+      });
+      buildProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  } catch (error) {
+    process.stderr.write(`${colorizeLogPrefixAnsi("[reroute/build] Error: ") + String(error)}
+`);
+    throw error;
+  }
+}
+var init_build = __esm(() => {
+  init_log();
+});
+
 // packages/cli/src/cli.ts
 import path2 from "node:path";
 var commands = {
   init: () => Promise.resolve().then(() => (init_init(), exports_init)),
   gen: () => Promise.resolve().then(() => (init_gen(), exports_gen)),
-  boot: () => Promise.resolve().then(() => (init_boot(), exports_boot))
+  boot: () => Promise.resolve().then(() => (init_boot(), exports_boot)),
+  dev: () => Promise.resolve().then(() => (init_dev(), exports_dev)),
+  start: () => Promise.resolve().then(() => (init_start(), exports_start)),
+  build: () => Promise.resolve().then(() => (init_build(), exports_build))
 };
 async function main() {
   const args = process.argv.slice(2);
@@ -1347,25 +2115,49 @@ async function main() {
   }
 }
 async function printHelp2() {
+  console.log("");
   console.log(await getVersionString2());
   console.log("");
+  console.log("");
   console.log("Usage:");
+  console.log("");
   console.log("  reroute <command> [options]");
   console.log("");
+  console.log("");
   console.log("Commands:");
+  console.log("");
+  console.log("  init        Scaffold a new Reroute project");
   console.log("  boot        Initialize .reroute directory with stub files");
   console.log("  gen         Generate content registry and static assets");
-  console.log("  init        Scaffold a new Reroute project");
+  console.log("  dev         Start development environment");
+  console.log("  start       Run production-like server locally");
+  console.log("  build       Build production binary");
+  console.log("");
   console.log("");
   console.log("Options:");
+  console.log("");
   console.log("  -h, --help     Show help");
   console.log("  -v, --version  Show version");
   console.log("");
+  console.log("");
   console.log("Examples:");
+  console.log("");
+  console.log("  reroute init my-app");
   console.log("  reroute boot");
+  console.log("");
   console.log("  reroute gen");
+  console.log("  reroute gen -w");
   console.log("  reroute gen --watch");
-  console.log("  reroute init my-app");
+  console.log("");
+  console.log("  reroute dev");
+  console.log("  reroute dev -s");
+  console.log("  reroute dev --single");
+  console.log("");
+  console.log("  reroute start");
+  console.log("");
+  console.log("  reroute build");
+  console.log("  reroute build -o ./dist/myapp");
+  console.log("  reroute build --outfile ./dist/myapp");
 }
 async function getVersionString2() {
   const version = await getVersion2();
@@ -1374,7 +2166,7 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "0.6.0";
+    return "0.7.0";
   }
   const possiblePaths = [
     path2.join(import.meta.dir, "../../../package.json"),
@@ -1391,10 +2183,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "a76a267";
+    return "4b119c0";
   }
   return "dev";
 }
 main();
 
-//# debugId=2D274D049C51338A64756E2164756E21
+//# debugId=B8066BB70A3F2A9464756E2164756E21