reroute-js 0.0.1

package/cli/bin.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/cli/src/commands/init.ts
+var exports_init = {};
+__export(exports_init, {
+  default: () => init
+});
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function init(args) {
+  const options = parseArgs(args);
+  if (!options) {
+    printHelp();
+    process.exit(1);
+  }
+  try {
+    await scaffoldProject(options);
+  } catch (error) {
+    console.error("Error scaffolding project:", error);
+    process.exit(1);
+  }
+}
+function parseArgs(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    return null;
+  }
+  const projectName = args[0];
+  if (!projectName || projectName.startsWith("-")) {
+    console.error("Error: Project name is required");
+    return null;
+  }
+  if (!/^[a-z0-9-_]+$/i.test(projectName)) {
+    console.error("Error: Project name can only contain letters, numbers, hyphens, and underscores");
+    return null;
+  }
+  let template = "basic";
+  const templateIndex = args.indexOf("--template");
+  if (templateIndex !== -1 && args[templateIndex + 1]) {
+    const templateArg = args[templateIndex + 1];
+    if (templateArg === "basic" || templateArg === "blog") {
+      template = templateArg;
+    } else {
+      console.error(`Error: Unknown template "${templateArg}". Available templates: basic, blog`);
+      return null;
+    }
+  }
+  return { projectName, template };
+}
+async function scaffoldProject(options) {
+  const { projectName, template } = options;
+  const projectPath = join(process.cwd(), projectName);
+  if (existsSync(projectPath)) {
+    console.error(`Error: Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  console.log(`
+\uD83D\uDE80 Creating new Reroute project: ${projectName}`);
+  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}`);
+    process.exit(1);
+  }
+  await mkdir(projectPath, { recursive: true });
+  await copyTemplateFiles(templatePath, projectPath, {
+    PROJECT_NAME: projectName
+  });
+  console.log(`\uD83D\uDCE5 Installing dependencies...
+`);
+  const proc = Bun.spawn(["bun", "install"], {
+    cwd: projectPath,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  await proc.exited;
+  printSuccess(projectName, template);
+}
+async function copyTemplateFiles(templatePath, targetPath, variables) {
+  const entries = await readdir(templatePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = join(templatePath, entry.name);
+    const destPath = join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      await mkdir(destPath, { recursive: true });
+      await copyTemplateFiles(sourcePath, destPath, variables);
+    } else if (entry.isFile()) {
+      const content = await readFile(sourcePath, "utf-8");
+      let processedContent = content;
+      for (const [key, value] of Object.entries(variables)) {
+        const placeholder = `{{${key}}}`;
+        processedContent = processedContent.split(placeholder).join(value);
+      }
+      await writeFile(destPath, processedContent);
+    }
+  }
+}
+function printSuccess(projectName, template) {
+  console.log(`
+✅ Project created successfully!
+`);
+  console.log(`Next steps:
+`);
+  console.log(`  cd ${projectName}`);
+  console.log(`  bun dev
+`);
+  console.log(`Your app will be running at http://localhost:3000
+`);
+  console.log("Project structure:");
+  console.log("  src/");
+  console.log("  ├── index.ts              # Server entry point");
+  console.log("  └── client/");
+  console.log("      ├── App.tsx           # Root React component");
+  console.log("      ├── index.tsx         # Client entry point");
+  console.log("      ├── index.html        # HTML template");
+  console.log("      ├── routes/           # File-based routes");
+  if (template === "blog") {
+    console.log("      │   ├── blog/");
+    console.log("      │   │   ├── content/  # Blog posts");
+    console.log("      │   │   ├── [slug].tsx");
+    console.log("      │   │   └── index.tsx");
+  }
+  console.log("      │   ├── index.tsx");
+  console.log("      │   └── about.tsx");
+  console.log(`      └── components/       # React components
+`);
+  console.log("Learn more at https://github.com/stewones/reroute");
+}
+function printHelp() {
+  console.log("reroute init - Scaffold a new Reroute project");
+  console.log("");
+  console.log("Usage:");
+  console.log("  reroute init <project-name> [options]");
+  console.log("");
+  console.log("Options:");
+  console.log("  --template <name>  Template to use (basic, blog)");
+  console.log("  -h, --help         Show help");
+  console.log("");
+  console.log("Examples:");
+  console.log("  reroute init my-app");
+  console.log("  reroute init my-blog --template blog");
+}
+var init_init = () => {};
+
+// packages/cli/src/commands/build.ts
+var exports_build = {};
+__export(exports_build, {
+  default: () => build
+});
+async function build(_args) {
+  console.log("reroute build - Coming Soon");
+  console.log("");
+  console.log("This command will build your Reroute application for production.");
+  console.log("");
+  console.log("Planned usage:");
+  console.log("  reroute build");
+  console.log("  reroute build --minify");
+  console.log("  reroute build --analyze");
+  console.log("");
+  console.log("For now, please use your own build setup or check the examples.");
+}
+
+// packages/cli/src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  default: () => dev
+});
+async function dev(_args) {
+  console.log("reroute dev - Coming Soon");
+  console.log("");
+  console.log("This command will start a development server with live reload.");
+  console.log("");
+  console.log("Planned usage:");
+  console.log("  reroute dev");
+  console.log("  reroute dev --port 3000");
+  console.log("  reroute dev --host 0.0.0.0");
+  console.log("");
+  console.log("Note: dev already generates content registry and static assets");
+  console.log("");
+  console.log("For now, please use your own dev server setup or check the examples.");
+}
+
+// packages/cli/src/libs/tailwind.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function isTailwindAvailable(cwd) {
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    return "@tailwindcss/cli" in deps;
+  } catch {
+    return false;
+  }
+}
+function getTailwindPaths(cwd) {
+  const input = join2(cwd, "src/client/theme.css");
+  const output = join2(cwd, ".reroute/theme.css");
+  return { input, output };
+}
+function hasTailwindInput(cwd) {
+  const { input } = getTailwindPaths(cwd);
+  if (!existsSync2(input)) {
+    return false;
+  }
+  try {
+    const content = readFileSync(input, "utf-8");
+    return content.includes('@import "tailwindcss"');
+  } catch {
+    return false;
+  }
+}
+function resolveTailwindBin(cwd) {
+  const pathsToTry = [
+    join2(cwd, "node_modules/.bin/tailwindcss"),
+    join2(cwd, "../node_modules/.bin/tailwindcss"),
+    join2(cwd, "../../node_modules/.bin/tailwindcss"),
+    join2(cwd, "../../../node_modules/.bin/tailwindcss")
+  ];
+  for (const binPath of pathsToTry) {
+    if (existsSync2(binPath)) {
+      return binPath;
+    }
+  }
+  return join2(cwd, "node_modules/.bin/tailwindcss");
+}
+async function buildTailwind(cwd) {
+  const { input, output } = getTailwindPaths(cwd);
+  return new Promise((resolve, reject) => {
+    const tailwindBin = resolveTailwindBin(cwd);
+    const args = ["-i", input, "-o", output];
+    const tailwind = spawn(tailwindBin, args, {
+      cwd,
+      stdio: "inherit"
+    });
+    tailwind.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Tailwind CSS build failed with code ${code}`));
+      }
+    });
+    tailwind.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+function watchTailwind(cwd) {
+  const { input, output } = getTailwindPaths(cwd);
+  const tailwindBin = resolveTailwindBin(cwd);
+  const args = ["-i", input, "-o", output, "--watch"];
+  console.log("[reroute/tailwind] Starting Tailwind CSS v4 in watch mode...");
+  const tailwind = spawn(tailwindBin, args, {
+    cwd,
+    stdio: "inherit"
+  });
+  tailwind.on("error", (error) => {
+    console.error("[reroute/tailwind] Error:", error);
+  });
+  const stop = () => {
+    console.log("[reroute/tailwind] Stopping Tailwind CSS...");
+    tailwind.kill();
+  };
+  return {
+    process: tailwind,
+    stop
+  };
+}
+function initTailwind(cwd, watch = false) {
+  if (!isTailwindAvailable(cwd)) {
+    return null;
+  }
+  if (!hasTailwindInput(cwd)) {
+    console.log('[reroute/tailwind] theme.css not found or missing @import "tailwindcss", skipping...');
+    return null;
+  }
+  console.log("[reroute/tailwind] Detected Tailwind CSS v4");
+  if (watch) {
+    return watchTailwind(cwd);
+  }
+  buildTailwind(cwd).then(() => {
+    console.log("[reroute/tailwind] Built successfully");
+  }).catch((error) => {
+    console.error("[reroute/tailwind] Build failed:", error);
+  });
+  return null;
+}
+var init_tailwind = () => {};
+
+// packages/cli/src/commands/gen.ts
+var exports_gen = {};
+__export(exports_gen, {
+  default: () => gen
+});
+import { watch } from "node:fs";
+import { mkdir as mkdir2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { pathToFileURL } from "node:url";
+async function cleanupOutputDir(cwd) {
+  const outputPath = join3(cwd, OUTPUT_DIR);
+  try {
+    await rm(outputPath, { recursive: true, force: true });
+    console.log(`[reroute/gen] Cleaned up ${outputPath}`);
+  } catch {}
+}
+async function scanDirectory(dir, base = "") {
+  const files = [];
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    const relativePath = join3(base, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "content")
+        continue;
+      const nested = await scanDirectory(fullPath, relativePath);
+      files.push(...nested);
+    } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
+      if (relativePath.includes("/content/") || relativePath.startsWith("content/")) {
+        continue;
+      }
+      if (!entry.name.startsWith("_") || entry.name === "[layout].tsx") {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files;
+}
+async function scan404Files(dir, base = "") {
+  const files = [];
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    const relativePath = join3(base, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await scan404Files(fullPath, relativePath);
+      files.push(...nested);
+    } else if (entry.isFile()) {
+      if (/^\[404]\.(tsx|ts)$/.test(entry.name))
+        files.push(relativePath);
+    }
+  }
+  return files;
+}
+function fileToRoute(filePath) {
+  const isLayout = filePath.endsWith("[layout].tsx") || filePath.endsWith("[layout].ts");
+  let routePath = filePath.replace(/\.(tsx|ts)$/, "");
+  if (isLayout) {
+    routePath = routePath.replace(/[layout]$/, "").replace(/\/$/, "");
+  }
+  routePath = routePath.replace(/\/index$/, "").replace(/^index$/, "");
+  const params = [];
+  const pattern = routePath.replace(/\[([^\]]+)\]/g, (_, param) => {
+    params.push(param);
+    return `:${param}`;
+  });
+  const normalizedPattern = pattern === "" ? "/" : `/${pattern}`;
+  const isNotFound = /(^|\/)\[404\]$/.test(routePath);
+  let notFoundBasePattern;
+  if (isNotFound) {
+    const base = routePath.replace(/(^|\/)\[404\]$/, "").replace(/\/$/, "");
+    notFoundBasePattern = base ? `/${base}` : "/";
+  }
+  return {
+    path: routePath,
+    pattern: normalizedPattern,
+    filePath,
+    isLayout,
+    isDynamic: params.length > 0,
+    params,
+    isNotFound,
+    notFoundBasePattern
+  };
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    const aDepth = a.pattern.split("/").length;
+    const bDepth = b.pattern.split("/").length;
+    if (aDepth !== bDepth)
+      return bDepth - aDepth;
+    if (!a.isDynamic && b.isDynamic)
+      return -1;
+    if (a.isDynamic && !b.isDynamic)
+      return 1;
+    return a.pattern.localeCompare(b.pattern);
+  });
+}
+function generateRouteTree(files) {
+  const routes = [];
+  const layouts = [];
+  const notFoundRoutes = [];
+  for (const file of files) {
+    const route = fileToRoute(file);
+    if (route.isLayout) {
+      layouts.push(route);
+    } else if (route.isNotFound) {
+      notFoundRoutes.push(route);
+    } else {
+      routes.push(route);
+    }
+  }
+  return {
+    routes: sortRoutes(routes),
+    layouts,
+    notFoundRoutes
+  };
+}
+function generateTypeScript(tree) {
+  const imports = [
+    ...tree.routes.map((r, i) => `import Route${i} from '../src/client/routes/${r.filePath.replace(/\.(tsx|ts)$/, "")}';`),
+    ...tree.layouts.map((l, i) => `import Layout${i} from '../src/client/routes/${l.filePath.replace(/\.(tsx|ts)$/, "")}';`),
+    ...tree.notFoundRoutes.map((nf, i) => `import NotFound${i} from '../src/client/routes/${nf.filePath.replace(/\.(tsx|ts)$/, "")}';`)
+  ].join(`
+`);
+  const routesArray = tree.routes.map((r, i) => {
+    return `  {
+    pattern: "${r.pattern}",
+    path: "${r.path}",
+    component: Route${i},
+    params: ${JSON.stringify(r.params)},
+    isDynamic: ${r.isDynamic},
+  } as const`;
+  }).join(`,
+`);
+  const routePatterns = tree.routes.map((r) => `  | "${r.pattern}"`).join(`
+`);
+  const routeParamsUnion = tree.routes.filter((r) => r.isDynamic).map((r) => {
+    const params = r.params.map((p) => `${p}: string`).join("; ");
+    return `  T extends "${r.pattern}" ? { ${params} } :`;
+  }).join(`
+`);
+  const layoutsArray = tree.layouts.map((l, i) => {
+    return `  {
+    pattern: "${l.pattern}",
+    path: "${l.path}",
+    component: Layout${i},
+  } as const`;
+  }).join(`,
+`);
+  const notFoundRoutesArray = tree.notFoundRoutes.map((nf, i) => {
+    return `  {
+    pattern: "${nf.notFoundBasePattern || "/"}",
+    path: "${nf.path}",
+    component: NotFound${i},
+  } as const`;
+  }).join(`,
+`);
+  return `// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8
+/* eslint-disable */
+// @ts-nocheck
+
+${imports}
+
+export const routes: RouteInfo = [
+${routesArray}
+] as const;
+
+export const layouts = [
+${layoutsArray || ""}
+] as const;
+
+export const notFoundRoutes = [
+${notFoundRoutesArray || ""}
+] as const;
+
+export type RoutePath =
+${routePatterns || '  | "/"'};
+
+export type RouteParams<T extends RoutePath> = ${routeParamsUnion ? `
+${routeParamsUnion}
+  Record<string, never>;` : "Record<string, never>;"}
+
+export interface Route {
+  pattern: string;
+  path: string;
+  component: any;
+  params: string[];
+  isDynamic: boolean;
+}
+
+export function matchRoute(pathname: string): { route: Route; params: Record<string, string> } | null {
+  for (const route of routes) {
+    const match = matchPattern(route.pattern, pathname);
+    if (match) {
+      return { route, params: match };
+    }
+  }
+  return null;
+}
+
+function matchPattern(pattern: string, pathname: string): Record<string, string> | null {
+  const patternParts = pattern.split('/').filter(Boolean);
+  const pathnameParts = pathname.split('/').filter(Boolean);
+
+  if (patternParts.length !== pathnameParts.length) {
+    return null;
+  }
+
+  const params: Record<string, string> = {};
+
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathnamePart = pathnameParts[i];
+
+    if (patternPart.startsWith(':')) {
+      params[patternPart.slice(1)] = pathnamePart;
+    } else if (patternPart !== pathnamePart) {
+      return null;
+    }
+  }
+
+  return params;
+}
+`;
+}
+async function listContentFiles(collectionDir) {
+  try {
+    const entries = await readdir2(collectionDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && /\.(tsx|ts)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function sha8(text) {
+  const data = new TextEncoder().encode(text);
+  const buf = await crypto.subtle.digest("SHA-256", data);
+  let hex = "";
+  for (const b of new Uint8Array(buf))
+    hex += b.toString(16).padStart(2, "0");
+  return hex.slice(0, 8);
+}
+async function buildContentChunks(cwd) {
+  const routesRoot = join3(cwd, ROUTES_DIR);
+  console.log(`[reroute/content] scan ${routesRoot}`);
+  const collections = await readdir2(routesRoot, { withFileTypes: true });
+  const results = [];
+  for (const c of collections) {
+    if (!c.isDirectory())
+      continue;
+    const collection = c.name;
+    const contentDir = join3(routesRoot, collection, "content");
+    console.log(`[reroute/content] collection ${collection} dir ${contentDir}`);
+    const files = await listContentFiles(contentDir);
+    console.log(`[reroute/content] files ${files.join(",")}`);
+    if (!files.length)
+      continue;
+    for (const file of files) {
+      const name = file.replace(/\.(tsx|ts)$/, "");
+      const absSrc = join3(contentDir, file);
+      let code = "";
+      try {
+        console.log(`[reroute/content] build ${absSrc}`);
+        const result = await Bun.build({
+          entrypoints: [absSrc],
+          target: "browser",
+          format: "esm",
+          splitting: false,
+          sourcemap: "none",
+          minify: false,
+          define: { "process.env.NODE_ENV": '"production"' }
+        });
+        if (!result.success)
+          throw new Error("build failed");
+        code = await result.outputs[0].text();
+      } catch (e) {
+        console.error("[reroute/gen] Failed to build content chunk:", absSrc, e);
+        continue;
+      }
+      const hash = await sha8(code);
+      const chunkRelDir = join3(".reroute", "chunks", collection);
+      const chunkAbsDir = join3(cwd, chunkRelDir);
+      const outFile = `${name}.${hash}.js`;
+      const absOut = join3(chunkAbsDir, outFile);
+      await mkdir2(chunkAbsDir, { recursive: true });
+      try {
+        const exists = await Bun.file(absOut).exists();
+        if (!exists)
+          await writeFile2(absOut, code, "utf-8");
+      } catch {}
+      let meta = {};
+      try {
+        console.log(`[reroute/content] meta ${absSrc}`);
+        const url = `${pathToFileURL(absSrc).href}?t=${Date.now()}`;
+        const m = await import(url);
+        meta = m.meta || {};
+      } catch {}
+      results.push({
+        collection,
+        name,
+        slug: name,
+        href: `/${collection}/${name}`,
+        moduleUrl: ("/" + chunkRelDir.replace(/\\/g, "/") + "/" + outFile).replace(/\\+/g, "/"),
+        meta
+      });
+    }
+  }
+  const lines = [];
+  lines.push("// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8");
+  lines.push("/* eslint-disable */");
+  lines.push("// @ts-nocheck");
+  lines.push("");
+  lines.push("export const contents = [");
+  for (const e of results) {
+    lines.push("  { collection: '" + e.collection + "', slug: '" + e.slug + "', name: '" + e.name + "', href: '" + e.href + "', module: '" + e.moduleUrl + "', meta: " + JSON.stringify(e.meta || {}) + " },");
+  }
+  lines.push("] as const;");
+  lines.push("");
+  lines.push("export const byCollection: Record<string, any[]> = {};");
+  lines.push("for (const c of contents) { (byCollection[c.collection] ||= []).push(c as any); }");
+  lines.push("");
+  lines.push("export const byCollectionAndName: Record<string, Record<string, any>> = {};");
+  lines.push("for (const c of contents) { ((byCollectionAndName[c.collection] ||= {})[c.name] = c as any); }");
+  lines.push("");
+  lines.push("export type Collections = keyof typeof byCollection;");
+  lines.push("export type Names<C extends Collections> = keyof (typeof byCollectionAndName)[C];");
+  lines.push("export type ContentEntry = (typeof contents)[number];");
+  lines.push("");
+  lines.push("export function getContentEntry<C extends string, N extends string>(collection: C, name: N) {");
+  lines.push("  const m = (byCollectionAndName as any)[collection];");
+  lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
+  lines.push("}");
+  lines.push("");
+  await mkdir2(join3(cwd, ".reroute"), { recursive: true });
+  await writeFile2(join3(cwd, OUTPUT_CONTENT_TS), lines.join(`
+`), "utf-8");
+  console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_CONTENT_TS)}`);
+  const collectionsSet = new Set(results.map((r) => r.collection));
+  await mkdir2(join3(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+  for (const collection of collectionsSet) {
+    const items = results.filter((r) => r.collection === collection);
+    const js = [];
+    js.push("// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8");
+    js.push("");
+    js.push("export const items = [");
+    for (const e of items) {
+      js.push(`  { collection: '${e.collection}', slug: '${e.slug}', name: '${e.name}', href: '${e.href}', module: '${e.moduleUrl}', meta: ${JSON.stringify(e.meta || {})} },`);
+    }
+    js.push("];");
+    js.push("");
+    js.push("export const byName = {};");
+    js.push("for (const it of items) { byName[it.name] = it; }");
+    js.push("");
+    js.push("export function get(collectionName, name) {");
+    js.push(`  if (collectionName !== '${collection}') return undefined;`);
+    js.push("  return byName[name];");
+    js.push("}");
+    js.push("");
+    await writeFile2(join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
+`), "utf-8");
+    console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
+  }
+}
+async function generate(cwd) {
+  console.log("[reroute/gen] Starting generation...");
+  await cleanupOutputDir(cwd);
+  const routesPath = join3(cwd, ROUTES_DIR);
+  try {
+    const files = await scanDirectory(routesPath);
+    const nfFiles = await scan404Files(routesPath);
+    const all = Array.from(new Set([...files, ...nfFiles]));
+    const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
+    const ts = generateTypeScript(tree);
+    await mkdir2(join3(cwd, ".reroute"), { recursive: true });
+    await writeFile2(join3(cwd, OUTPUT_ROUTES), ts, "utf-8");
+    console.log(`[reroute/gen] Generated routes: ${join3(cwd, OUTPUT_ROUTES)}`);
+  } catch (error) {
+    console.error("[reroute/gen] Failed to generate routes:", error);
+    throw error;
+  }
+  try {
+    await buildContentChunks(cwd);
+    console.log(`[reroute/gen] Generated content: ${join3(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
+  } catch (error) {
+    console.error("[reroute/gen] Failed to generate content:", error);
+    throw error;
+  }
+  const indexLines = [];
+  indexLines.push("// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8");
+  indexLines.push("/* eslint-disable */");
+  indexLines.push("// @ts-nocheck");
+  indexLines.push("");
+  indexLines.push("import { layouts, matchRoute, notFoundRoutes } from './routes';");
+  indexLines.push("");
+  indexLines.push("export const artifacts = {");
+  indexLines.push("  layouts,");
+  indexLines.push("  matchRoute,");
+  indexLines.push("  notFoundRoutes,");
+  indexLines.push("  contentBaseUrl: '/.reroute/collections'");
+  indexLines.push("} as const;");
+  indexLines.push("");
+  indexLines.push("export type RerouteArtifacts = typeof artifacts;");
+  await writeFile2(join3(cwd, OUTPUT_INDEX), indexLines.join(`
+`), "utf-8");
+  console.log(`[reroute/gen] Generated index: ${join3(cwd, OUTPUT_INDEX)}`);
+  console.log("[reroute/gen] ✅ Generation complete!");
+}
+async function gen(args) {
+  const watchMode = args.includes("--watch") || args.includes("-w");
+  const cwd = process.cwd();
+  if (watchMode) {
+    console.log("[reroute/gen] Watch mode enabled");
+    console.log("[reroute/gen] Initial generation...");
+    await generate(cwd);
+    const tailwindProcess = initTailwind(cwd, true);
+    const routesPath = join3(cwd, ROUTES_DIR);
+    console.log(`[reroute/gen] Watching ${routesPath} for changes...`);
+    let timeout = null;
+    const watcher = watch(routesPath, { recursive: true }, (_eventType, filename) => {
+      if (!filename)
+        return;
+      if (timeout)
+        clearTimeout(timeout);
+      timeout = setTimeout(async () => {
+        console.log("[reroute/gen] Change detected, regenerating...");
+        try {
+          await generate(cwd);
+        } catch (error) {
+          console.error("[reroute/gen] Error during regeneration:", error);
+        }
+      }, 300);
+    });
+    process.on("SIGINT", () => {
+      console.log(`
+[reroute/gen] Stopping watch mode...`);
+      watcher.close();
+      if (tailwindProcess) {
+        tailwindProcess.stop();
+      }
+      process.exit(0);
+    });
+  } else {
+    await generate(cwd);
+    initTailwind(cwd, false);
+  }
+}
+var ROUTES_DIR = "src/client/routes", OUTPUT_DIR = ".reroute", OUTPUT_ROUTES = ".reroute/routes.ts", OUTPUT_CONTENT_TS = ".reroute/content.ts", OUTPUT_COLLECTIONS_DIR = ".reroute/collections", OUTPUT_INDEX = ".reroute/index.ts";
+var init_gen = __esm(() => {
+  init_tailwind();
+});
+
+// packages/cli/src/index.ts
+var commands = {
+  init: () => Promise.resolve().then(() => (init_init(), exports_init)),
+  build: () => Promise.resolve().then(() => exports_build),
+  dev: () => Promise.resolve().then(() => exports_dev),
+  gen: () => Promise.resolve().then(() => (init_gen(), exports_gen))
+};
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp2();
+    process.exit(0);
+  }
+  const command = args[0];
+  if (!commands[command]) {
+    console.error(`Unknown command: ${command}`);
+    console.error("");
+    printHelp2();
+    process.exit(1);
+  }
+  try {
+    const module = await commands[command]();
+    await module.default(args.slice(1));
+  } catch (error) {
+    console.error("Error executing command:", error);
+    process.exit(1);
+  }
+}
+function printHelp2() {
+  console.log("Reroute CLI - File-based routing framework");
+  console.log("");
+  console.log("Usage:");
+  console.log("  reroute <command> [options]");
+  console.log("");
+  console.log("Commands:");
+  console.log("  gen         Generate content registry and static assets");
+  console.log("  init        Scaffold a new Reroute project");
+  console.log("  build       Build for production");
+  console.log("  dev         Start development server");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show help");
+  console.log("");
+  console.log("Examples:");
+  console.log("  reroute gen");
+  console.log("  reroute gen --watch");
+  console.log("  reroute init my-app");
+  console.log("  reroute build --minify");
+  console.log("  reroute dev --port 3000");
+}
+main();
+
+//# debugId=EE3FCBAF7FD3057864756E2164756E21