@flight-framework/cli 0.0.9 → 0.0.11

package/dist/index.js

@@ -33,6 +33,11 @@ var UI_FRAMEWORKS = [
   { title: "Htmx", value: "htmx", description: "HTML over the wire, no JavaScript" },
   { title: "Vanilla", value: "vanilla", description: "No framework, just TypeScript" }
 ];
+var BUNDLERS = [
+  { title: "Vite", value: "vite", description: "Next Gen Frontend Tooling (recommended)" },
+  { title: "esbuild", value: "esbuild", description: "Ultra-fast builds for performance-focused projects" },
+  { title: "Rolldown", value: "rolldown", description: "Rust-based Rollup replacement (experimental)" }
+];
 async function createCommand(name, options) {
   printLogo();
   console.log(pc.cyan("\n[*] Creating a new Flight project...\n"));
@@ -70,6 +75,21 @@ async function createCommand(name, options) {
     console.log(pc.red("Project creation cancelled."));
     return;
   }
+  let bundler = options.bundler;
+  if (!bundler) {
+    const response = await prompts({
+      type: "select",
+      name: "bundler",
+      message: "Choose your bundler:",
+      choices: BUNDLERS,
+      initial: 0
+    });
+    bundler = response.bundler;
+  }
+  if (!bundler) {
+    console.log(pc.red("Project creation cancelled."));
+    return;
+  }
   const projectPath = resolve(process.cwd(), projectName);
   if (existsSync(projectPath)) {
     const files = readdirSync(projectPath);
@@ -90,7 +110,7 @@ async function createCommand(name, options) {
 Creating project in ${projectPath}...
 `));
   try {
-    copyTemplate(projectPath, uiFramework, projectName);
+    copyTemplate(projectPath, uiFramework, bundler, projectName);
     console.log(pc.green("\u2713") + " Project structure created");
     if (options.git) {
       try {
@@ -136,7 +156,7 @@ function detectPackageManager() {
   if (process.env.npm_config_user_agent?.includes("bun")) return "bun";
   return "npm";
 }
-function copyTemplate(projectPath, ui, projectName) {
+function copyTemplate(projectPath, ui, bundler, projectName) {
   const baseDir = join(TEMPLATES_DIR, "base");
   const uiDir = join(TEMPLATES_DIR, ui);
   mkdirSync(projectPath, { recursive: true });
@@ -146,6 +166,8 @@ function copyTemplate(projectPath, ui, projectName) {
   const vars = {
     "{{PROJECT_NAME}}": projectName,
     "{{UI_FRAMEWORK}}": ui,
+    "{{BUNDLER}}": bundler,
+    "{{BUNDLER_PACKAGE}}": `@flight-framework/bundler-${bundler}`,
     "{{LANGUAGE}}": "TypeScript"
   };
   copyDirWithTemplates(baseDir, projectPath, vars);
@@ -449,8 +471,16 @@ function getNetworkAddress() {
 
 // src/commands/build.ts
 import { resolve as resolve3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 import pc3 from "picocolors";
 import { loadConfig as loadConfig2 } from "@flight-framework/core/config";
+function findEntryServer(root, srcDir) {
+  const tsxPath = resolve3(root, srcDir, "entry-server.tsx");
+  const tsPath = resolve3(root, srcDir, "entry-server.ts");
+  if (existsSync3(tsxPath)) return tsxPath;
+  if (existsSync3(tsPath)) return tsPath;
+  return tsxPath;
+}
 async function buildCommand(options) {
   const startTime = Date.now();
   printLogo();
@@ -491,7 +521,7 @@ async function buildCommand(options) {
           minify: minify ? "esbuild" : false,
           ssr: true,
           rollupOptions: {
-            input: resolve3(root, config.build.srcDir, "entry-server.ts")
+            input: findEntryServer(root, config.build.srcDir)
           }
         }
       });
@@ -563,6 +593,292 @@ async function previewCommand(options) {
   }
 }
 
+// src/commands/routes-generate.ts
+import { resolve as resolve5 } from "path";
+
+// src/generators/routes.ts
+import { readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function filePathToUrlPath(filePath) {
+  let urlPath = filePath.replace(/\.(page|route)\.(tsx?|jsx?)$/, "").replace(/\.(get|post|put|patch|delete|options|head)$/, "").replace(/\/index$/, "").replace(/\/?\([^)]+\)/g, "").replace(/\[\.\.\.(\w+)\]/g, "*$1").replace(/\[(\w+)\]/g, ":$1");
+  if (!urlPath.startsWith("/")) {
+    urlPath = "/" + urlPath;
+  }
+  if (urlPath === "" || urlPath === "/") {
+    urlPath = "/";
+  }
+  urlPath = urlPath.replace(/\/+/g, "/");
+  return urlPath;
+}
+function extractHttpMethod(filename) {
+  const match = filename.match(/\.(get|post|put|patch|delete|options|head)\.(tsx?|jsx?)$/i);
+  return match ? match[1].toUpperCase() : void 0;
+}
+function isLayoutFile(filename) {
+  return filename.startsWith("_layout.");
+}
+function isLoadingFile(filename) {
+  return filename.startsWith("_loading.");
+}
+function isErrorFile(filename) {
+  return filename.startsWith("_error.");
+}
+function isNotFoundFile(filename) {
+  return filename.startsWith("_not-found.");
+}
+function isRouteFile(filename) {
+  return /\.(page|route)\.(tsx?|jsx?)$/.test(filename);
+}
+function isApiRouteFile(filename) {
+  return /\.(get|post|put|patch|delete|options|head)\.(tsx?|jsx?)$/.test(filename);
+}
+function hasDynamicSegments(path) {
+  return path.includes("[") && path.includes("]");
+}
+function scanDirectory(dir, basePath = "", results = []) {
+  if (!existsSync4(dir)) {
+    return results;
+  }
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
+    const relativePath = join3(basePath, entry);
+    const stat = statSync2(fullPath);
+    if (stat.isDirectory()) {
+      if (entry.startsWith(".") || entry === "node_modules") {
+        continue;
+      }
+      scanDirectory(fullPath, relativePath, results);
+    } else if (stat.isFile()) {
+      const routePath = filePathToUrlPath(dirname2(relativePath));
+      const normalizedFilePath = relativePath.replace(/\\/g, "/");
+      const isDynamic = hasDynamicSegments(relativePath);
+      if (isLayoutFile(entry)) {
+        results.push({
+          path: routePath,
+          filePath: normalizedFilePath,
+          isLayout: true,
+          isLoading: false,
+          isError: false,
+          isNotFound: false,
+          isDynamic,
+          isApiRoute: false
+        });
+      } else if (isLoadingFile(entry)) {
+        results.push({
+          path: routePath,
+          filePath: normalizedFilePath,
+          isLayout: false,
+          isLoading: true,
+          isError: false,
+          isNotFound: false,
+          isDynamic,
+          isApiRoute: false
+        });
+      } else if (isErrorFile(entry)) {
+        results.push({
+          path: routePath,
+          filePath: normalizedFilePath,
+          isLayout: false,
+          isLoading: false,
+          isError: true,
+          isNotFound: false,
+          isDynamic,
+          isApiRoute: false
+        });
+      } else if (isNotFoundFile(entry)) {
+        results.push({
+          path: routePath,
+          filePath: normalizedFilePath,
+          isLayout: false,
+          isLoading: false,
+          isError: false,
+          isNotFound: true,
+          isDynamic,
+          isApiRoute: false
+        });
+      } else if (isApiRouteFile(entry)) {
+        const method = extractHttpMethod(entry);
+        results.push({
+          path: filePathToUrlPath(relativePath),
+          filePath: normalizedFilePath,
+          isLayout: false,
+          isLoading: false,
+          isError: false,
+          isNotFound: false,
+          isDynamic,
+          isApiRoute: true,
+          httpMethod: method
+        });
+      } else if (isRouteFile(entry)) {
+        results.push({
+          path: filePathToUrlPath(relativePath),
+          filePath: normalizedFilePath,
+          isLayout: false,
+          isLoading: false,
+          isError: false,
+          isNotFound: false,
+          isDynamic,
+          isApiRoute: false
+        });
+      }
+    }
+  }
+  return results;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (!a.isDynamic && b.isDynamic) return -1;
+    if (a.isDynamic && !b.isDynamic) return 1;
+    const aSegments = a.path.split("/").length;
+    const bSegments = b.path.split("/").length;
+    if (aSegments !== bSegments) return aSegments - bSegments;
+    return a.path.localeCompare(b.path);
+  });
+}
+function generateRouteManifest(routesDir) {
+  const allRoutes = scanDirectory(routesDir);
+  const isPageRoute = (r) => !r.isLayout && !r.isLoading && !r.isError && !r.isNotFound && !r.isApiRoute;
+  const routes = sortRoutes(allRoutes.filter(isPageRoute));
+  const layouts = allRoutes.filter((r) => r.isLayout);
+  const loadingStates = allRoutes.filter((r) => r.isLoading);
+  const errorBoundaries = allRoutes.filter((r) => r.isError);
+  const notFoundPages = allRoutes.filter((r) => r.isNotFound);
+  const apiRoutes = sortRoutes(allRoutes.filter((r) => r.isApiRoute));
+  return {
+    routes,
+    layouts,
+    loadingStates,
+    errorBoundaries,
+    notFoundPages,
+    apiRoutes,
+    generated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function generateRoutesFile(manifest, outputDir) {
+  if (!existsSync4(outputDir)) {
+    mkdirSync2(outputDir, { recursive: true });
+  }
+  const routesContent = `/**
+ * Auto-generated by Flight CLI
+ * Do not edit manually
+ * Generated: ${manifest.generated}
+ */
+
+import type { RouteDefinition } from '@flight-framework/router';
+
+// Page Routes
+export const routes: RouteDefinition[] = [
+${manifest.routes.map((r) => `    {
+        path: '${r.path}',
+        component: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// Layout Components
+export const layouts = [
+${manifest.layouts.map((r) => `    {
+        path: '${r.path}',
+        component: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// Loading State Components
+export const loadingStates = [
+${manifest.loadingStates.map((r) => `    {
+        path: '${r.path}',
+        component: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// Error Boundary Components
+export const errorBoundaries = [
+${manifest.errorBoundaries.map((r) => `    {
+        path: '${r.path}',
+        component: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// Not Found Page Components
+export const notFoundPages = [
+${manifest.notFoundPages.map((r) => `    {
+        path: '${r.path}',
+        component: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// API Routes
+export const apiRoutes = [
+${manifest.apiRoutes.map((r) => `    {
+        path: '${r.path}',
+        method: '${r.httpMethod}',
+        handler: () => import('../routes/${r.filePath.replace(/\.(tsx?|jsx?)$/, "")}'),
+    },`).join("\n")}
+];
+
+// Type-safe route paths
+export type AppRoutes = ${manifest.routes.length > 0 ? manifest.routes.map((r) => `'${r.path}'`).join(" | ") : "never"};
+
+// Type-safe API route paths
+export type ApiRoutes = ${manifest.apiRoutes.length > 0 ? manifest.apiRoutes.map((r) => `'${r.path}'`).join(" | ") : "never"};
+`;
+  writeFileSync2(join3(outputDir, "routes.ts"), routesContent, "utf-8");
+  const typesContent = `/**
+ * Auto-generated route types
+ * Generated: ${manifest.generated}
+ */
+
+import type { RouteParams } from '@flight-framework/router';
+
+// Extract params from route patterns
+${manifest.routes.filter((r) => r.isDynamic).map((r) => {
+    const paramMatches = r.path.match(/:(\w+)/g) || [];
+    const params = paramMatches.map((p) => p.slice(1));
+    const typeName = r.path.replace(/[/:]/g, "_").replace(/^_/, "").replace(/_$/, "") || "Root";
+    return `export type ${typeName}Params = { ${params.map((p) => `${p}: string`).join("; ")} };`;
+  }).join("\n")}
+`;
+  writeFileSync2(join3(outputDir, "types.ts"), typesContent, "utf-8");
+}
+async function generateRoutes(options) {
+  const { routesDir, outputDir } = options;
+  console.log(`Scanning routes in: ${routesDir}`);
+  const manifest = generateRouteManifest(routesDir);
+  const stats = [
+    `${manifest.routes.length} pages`,
+    `${manifest.layouts.length} layouts`,
+    `${manifest.loadingStates.length} loading states`,
+    `${manifest.errorBoundaries.length} error boundaries`,
+    `${manifest.notFoundPages.length} not-found pages`,
+    `${manifest.apiRoutes.length} API routes`
+  ].join(", ");
+  console.log(`Found: ${stats}`);
+  generateRoutesFile(manifest, outputDir);
+  console.log(`Generated route manifest in: ${outputDir}`);
+  return manifest;
+}
+
+// src/commands/routes-generate.ts
+async function routesGenerateCommand(options = {}) {
+  const cwd = process.cwd();
+  const routesDir = options.routesDir ? resolve5(cwd, options.routesDir) : resolve5(cwd, "src/routes");
+  const outputDir = options.outputDir ? resolve5(cwd, options.outputDir) : resolve5(cwd, "src/.flight");
+  try {
+    const manifest = await generateRoutes({
+      routesDir,
+      outputDir,
+      watch: options.watch
+    });
+    console.log("\nRoute manifest generated successfully!");
+    console.log(`  Pages: ${manifest.routes.length}`);
+    console.log(`  API Routes: ${manifest.apiRoutes.length}`);
+    console.log(`  Layouts: ${manifest.layouts.length}`);
+  } catch (error) {
+    console.error("Failed to generate routes:", error);
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 var cli = cac("flight");
 var LOGO = `
@@ -585,6 +901,7 @@ cli.command("create [name]", "Create a new Flight project").option("-t, --templa
 cli.command("dev", "Start development server").option("-p, --port <port>", "Port to listen on").option("-h, --host <host>", "Host to bind to").option("--open", "Open browser on start").option("--https", "Enable HTTPS").option("--ssr", "Enable Server-Side Rendering").action(devCommand);
 cli.command("build", "Build for production").option("--outDir <dir>", "Output directory").option("--sourcemap", "Generate source maps").option("--minify", "Minify output", { default: true }).action(buildCommand);
 cli.command("preview", "Preview production build").option("-p, --port <port>", "Port to listen on").option("-h, --host <host>", "Host to bind to").option("--open", "Open browser on start").action(previewCommand);
+cli.command("routes:generate", "Generate route manifest from routes directory").option("--routesDir <dir>", "Routes directory", { default: "src/routes" }).option("--outputDir <dir>", "Output directory", { default: "src/.flight" }).action(routesGenerateCommand);
 function run() {
   try {
     cli.parse(process.argv, { run: false });