@fluixi/cli 0.1.0-alpha.74 → 0.1.0-alpha.76

package/dist/generate.cjs

@@ -0,0 +1,211 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  generate: () => generate
+});
+module.exports = __toCommonJS(generate_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_ui = require("@fluixi/start/ui");
+var GEN_USAGE = `Usage: fluixi generate <kind> <name>
+
+Kinds:
+  component <Name>      a reusable component        → src/components/<Name>.{tsx,ts}
+  route <path>          a file-based route page     → src/routes/<path>.{tsx,ts}
+  middleware            the request middleware file → src/middleware.ts
+  auth                  @fluixi/auth wiring         → auth.config + auth.client + middleware + /api/auth route
+
+Component/route syntax follows the project (JSX → .tsx, html\`\` → .ts); override with --jsx / --html.
+`;
+function detectFormat() {
+  const args = process.argv.slice(3);
+  if (args.includes("--html")) return "html";
+  if (args.includes("--jsx")) return "jsx";
+  try {
+    const ts = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.resolve)("tsconfig.json"), "utf8"));
+    if (ts?.compilerOptions && !ts.compilerOptions.jsx) return "html";
+  } catch {
+  }
+  return "jsx";
+}
+function pascal(s) {
+  return s.replace(/\[(.+?)\]/g, "$1").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join("") || "Component";
+}
+function resolveHint(Name, ext) {
+  const configs = ["vite.config.ts", "vite.config.js", "fluixi.config.ts", "fluixi.config.js"];
+  const found = configs.map((f) => (0, import_node_path.resolve)(f)).find((f) => (0, import_node_fs.existsSync)(f));
+  if (!found) return;
+  try {
+    if (/\bresolve\s*:\s*\[/.test((0, import_node_fs.readFileSync)(found, "utf8"))) return;
+  } catch {
+    return;
+  }
+  console.log(
+    `  ${import_ui.c.gray("to use")} ${import_ui.c.cyan(`<${Name} />`)} ${import_ui.c.gray("without importing it, add to")} ${import_ui.c.cyan((0, import_node_path.relative)(process.cwd(), found))}:`
+  );
+  console.log(`    ${import_ui.c.gray(`resolve: [{ match: /^([A-Z]\\w+)$/, module: '/src/components/$1.${ext}' }]`)}`);
+  console.log(`  ${import_ui.c.gray("one pattern covers the whole folder. Importing it works too — including with")} ${import_ui.c.cyan("load:")}`);
+}
+function write(file, content) {
+  const rel = (0, import_node_path.relative)(process.cwd(), file);
+  if ((0, import_node_fs.existsSync)(file)) {
+    console.error(`  ${import_ui.c.red("✗")} ${rel} ${import_ui.c.gray("already exists")}`);
+    process.exit(1);
+  }
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(file), { recursive: true });
+  (0, import_node_fs.writeFileSync)(file, content);
+  console.log(`  ${import_ui.c.green("✓")} ${import_ui.c.gray("created")} ${import_ui.c.cyan(rel)}`);
+}
+var component = (Name) => `import type { Component, ComponentChild } from '@fluixi/core';
+
+export type ${Name}Props = {
+  children?: ComponentChild;
+};
+
+// Typed component: \`props\` is inferred from ${Name}Props. Use FxParent/FxVoid/FxFlow
+// from '@fluixi/core' for children-required/forbidden variants.
+export const ${Name}: Component<${Name}Props> = (props) => {
+  return <div class="${Name.toLowerCase()}">{props.children ?? '${Name}'}</div>;
+};
+`;
+var route = (Name) => `export default function ${Name}() {
+  return (
+    <section>
+      <h1>${Name}</h1>
+    </section>
+  );
+}
+`;
+var componentHtml = (Name) => `import type { Component, ComponentChild } from '@fluixi/core';
+import { html } from '@fluixi/core';
+
+export type ${Name}Props = {
+  children?: ComponentChild;
+};
+
+// Typed component: \`props\` is inferred from ${Name}Props. Use FxParent/FxVoid/FxFlow
+// from '@fluixi/core' for children-required/forbidden variants.
+export const ${Name}: Component<${Name}Props> = (props) => {
+  return html\`<div class="${Name.toLowerCase()}">\${props.children ?? '${Name}'}</div>\`;
+};
+`;
+var routeHtml = (Name) => `import { html } from '@fluixi/start';
+
+export default function ${Name}() {
+  return html\`
+    <section>
+      <h1>${Name}</h1>
+    </section>
+  \`;
+}
+`;
+var middleware = () => `import { defineMiddleware } from '@fluixi/start';
+
+export default defineMiddleware([
+  (request, next) => {
+    // return a Response to short-circuit (auth/redirect), or next() to continue.
+    return next();
+  },
+]);
+`;
+var authConfig = () => `import { betterAuth } from 'better-auth';
+import { defineAuth } from '@fluixi/auth/server';
+
+export type AppUser = { id: string; email: string; name?: string; role?: string };
+
+// Better Auth owns the audited primitives; defineAuth registers it with @fluixi/auth.
+export const auth = defineAuth<AppUser>(
+  betterAuth({
+    // database: <your adapter>,
+    emailAndPassword: { enabled: true },
+    // socialProviders: { google: { … }, github: { … } },
+  } as Parameters<typeof betterAuth>[0]),
+);
+`;
+var authClient = () => `import { createAuthClient } from 'better-auth/client';
+import { createAuthHooks } from '@fluixi/auth/client';
+import type { AppUser } from './auth.config.js';
+
+const client = createAuthClient({ baseURL: '/api/auth' });
+
+// Or, to reuse an existing reactive session: createAuthHooks({ session: yourSessionStore }).
+export const { useUser, useSession, useAuth, useSignIn, useSignOut, protectedRoute } =
+  createAuthHooks<AppUser>({ client, loginPath: '/login' });
+`;
+var authMiddleware = () => `import { defineMiddleware } from '@fluixi/start';
+import { authMiddleware } from '@fluixi/auth/server';
+import './auth.config.js';
+
+export default defineMiddleware([authMiddleware()]);
+`;
+var authRoute = () => `import { mountAuthRoutes } from '@fluixi/auth/server';
+import '../../../auth.config.js';
+
+const handler = mountAuthRoutes();
+export const GET = handler;
+export const POST = handler;
+export default handler;
+`;
+function generate(kind, name) {
+  switch (kind) {
+    case "component":
+    case "c": {
+      if (!name) return fail("component name required, e.g. `fluixi g component Button`");
+      const Name = pascal(name);
+      const html = detectFormat() === "html";
+      const ext = html ? "ts" : "tsx";
+      write((0, import_node_path.resolve)("src/components", `${Name}.${ext}`), (html ? componentHtml : component)(Name));
+      resolveHint(Name, ext);
+      break;
+    }
+    case "route":
+    case "r": {
+      if (!name) return fail("route path required, e.g. `fluixi g route about`");
+      const html = detectFormat() === "html";
+      const Name = pascal((0, import_node_path.basename)(name));
+      write((0, import_node_path.resolve)("src/routes", `${name}.${html ? "ts" : "tsx"}`), (html ? routeHtml : route)(Name));
+      break;
+    }
+    case "middleware":
+    case "m":
+      write((0, import_node_path.resolve)("src/middleware.ts"), middleware());
+      break;
+    case "auth":
+      write((0, import_node_path.resolve)("src/auth.config.ts"), authConfig());
+      write((0, import_node_path.resolve)("src/auth.client.ts"), authClient());
+      write((0, import_node_path.resolve)("src/middleware.ts"), authMiddleware());
+      write((0, import_node_path.resolve)("src/routes/api/auth/[...all].ts"), authRoute());
+      console.log(`  ${import_ui.c.gray("next: install")} ${import_ui.c.cyan("better-auth")}${import_ui.c.gray(", set your DB adapter in auth.config.ts, and forward `request` in entry-server")}`);
+      break;
+    default:
+      console.error(GEN_USAGE);
+      process.exit(1);
+  }
+}
+function fail(msg) {
+  console.error(`  ${import_ui.c.red("✗")} ${msg}`);
+  process.exit(1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate
+});

package/dist/generate.js

@@ -1,5 +1,5 @@
 /**
- * `fluixi generate <kind> <name>` (alias `g`) — scaffold a piece into the current app.
+ * `fluixi generate <kind> <name>` (alias `g`), scaffold a piece into the current app.
  *   fluixi g component Button        → src/components/Button.tsx
  *   fluixi g route about             → src/routes/about.tsx  (a file route)
  *   fluixi g route blog/[id]         → src/routes/blog/[id].tsx
@@ -20,7 +20,7 @@ Component/route syntax follows the project (JSX → .tsx, html\`\` → .ts); ove
 `;
 /**
  * Which template syntax to emit. Explicit --jsx/--html wins; otherwise infer from
- * the project — an app whose tsconfig doesn't configure `jsx` is html``-authored.
+ * the project: an app whose tsconfig doesn't configure `jsx` is html``-authored.
  */
 function detectFormat() {
     const args = process.argv.slice(3);
@@ -34,7 +34,7 @@ function detectFormat() {
             return 'html';
     }
     catch {
-        // no/invalid tsconfig — fall back to JSX
+        // no/invalid tsconfig: fall back to JSX
     }
     return 'jsx';
 }
@@ -49,8 +49,8 @@ function pascal(s) {
 /**
  * Say how to use a generated component without importing it, when nothing would resolve it.
  *
- * Read-only on purpose. A vite/fluixi config is arbitrary TypeScript — it can spread a
- * shared object, compute its rules, or call a resolver function — so editing it means
+ * Read-only on purpose. A vite/fluixi config is arbitrary TypeScript, it can spread a
+ * shared object, compute its rules, or call a resolver function, so editing it means
  * parsing and reprinting, which loses the author's formatting and breaks on any shape we
  * didn't anticipate. Printing the line to paste costs the user one paste and cannot
  * corrupt anything.
@@ -106,7 +106,7 @@ const route = (Name) => `export default function ${Name}() {
   );
 }
 `;
-// html`` variants — plain .ts, no JSX. Emitted when the project is html``-authored
+// html`` variants: plain .ts, no JSX. Emitted when the project is html``-authored
 // (no `jsx` in tsconfig) or with --html.
 const componentHtml = (Name) => `import type { Component, ComponentChild } from '@fluixi/core';
 import { html } from '@fluixi/core';

package/dist/generate.mjs

@@ -0,0 +1,186 @@
+// src/generate.ts
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve, dirname, relative, basename } from "node:path";
+import { c } from "@fluixi/start/ui";
+var GEN_USAGE = `Usage: fluixi generate <kind> <name>
+
+Kinds:
+  component <Name>      a reusable component        → src/components/<Name>.{tsx,ts}
+  route <path>          a file-based route page     → src/routes/<path>.{tsx,ts}
+  middleware            the request middleware file → src/middleware.ts
+  auth                  @fluixi/auth wiring         → auth.config + auth.client + middleware + /api/auth route
+
+Component/route syntax follows the project (JSX → .tsx, html\`\` → .ts); override with --jsx / --html.
+`;
+function detectFormat() {
+  const args = process.argv.slice(3);
+  if (args.includes("--html")) return "html";
+  if (args.includes("--jsx")) return "jsx";
+  try {
+    const ts = JSON.parse(readFileSync(resolve("tsconfig.json"), "utf8"));
+    if (ts?.compilerOptions && !ts.compilerOptions.jsx) return "html";
+  } catch {
+  }
+  return "jsx";
+}
+function pascal(s) {
+  return s.replace(/\[(.+?)\]/g, "$1").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join("") || "Component";
+}
+function resolveHint(Name, ext) {
+  const configs = ["vite.config.ts", "vite.config.js", "fluixi.config.ts", "fluixi.config.js"];
+  const found = configs.map((f) => resolve(f)).find((f) => existsSync(f));
+  if (!found) return;
+  try {
+    if (/\bresolve\s*:\s*\[/.test(readFileSync(found, "utf8"))) return;
+  } catch {
+    return;
+  }
+  console.log(
+    `  ${c.gray("to use")} ${c.cyan(`<${Name} />`)} ${c.gray("without importing it, add to")} ${c.cyan(relative(process.cwd(), found))}:`
+  );
+  console.log(`    ${c.gray(`resolve: [{ match: /^([A-Z]\\w+)$/, module: '/src/components/$1.${ext}' }]`)}`);
+  console.log(`  ${c.gray("one pattern covers the whole folder. Importing it works too — including with")} ${c.cyan("load:")}`);
+}
+function write(file, content) {
+  const rel = relative(process.cwd(), file);
+  if (existsSync(file)) {
+    console.error(`  ${c.red("✗")} ${rel} ${c.gray("already exists")}`);
+    process.exit(1);
+  }
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, content);
+  console.log(`  ${c.green("✓")} ${c.gray("created")} ${c.cyan(rel)}`);
+}
+var component = (Name) => `import type { Component, ComponentChild } from '@fluixi/core';
+
+export type ${Name}Props = {
+  children?: ComponentChild;
+};
+
+// Typed component: \`props\` is inferred from ${Name}Props. Use FxParent/FxVoid/FxFlow
+// from '@fluixi/core' for children-required/forbidden variants.
+export const ${Name}: Component<${Name}Props> = (props) => {
+  return <div class="${Name.toLowerCase()}">{props.children ?? '${Name}'}</div>;
+};
+`;
+var route = (Name) => `export default function ${Name}() {
+  return (
+    <section>
+      <h1>${Name}</h1>
+    </section>
+  );
+}
+`;
+var componentHtml = (Name) => `import type { Component, ComponentChild } from '@fluixi/core';
+import { html } from '@fluixi/core';
+
+export type ${Name}Props = {
+  children?: ComponentChild;
+};
+
+// Typed component: \`props\` is inferred from ${Name}Props. Use FxParent/FxVoid/FxFlow
+// from '@fluixi/core' for children-required/forbidden variants.
+export const ${Name}: Component<${Name}Props> = (props) => {
+  return html\`<div class="${Name.toLowerCase()}">\${props.children ?? '${Name}'}</div>\`;
+};
+`;
+var routeHtml = (Name) => `import { html } from '@fluixi/start';
+
+export default function ${Name}() {
+  return html\`
+    <section>
+      <h1>${Name}</h1>
+    </section>
+  \`;
+}
+`;
+var middleware = () => `import { defineMiddleware } from '@fluixi/start';
+
+export default defineMiddleware([
+  (request, next) => {
+    // return a Response to short-circuit (auth/redirect), or next() to continue.
+    return next();
+  },
+]);
+`;
+var authConfig = () => `import { betterAuth } from 'better-auth';
+import { defineAuth } from '@fluixi/auth/server';
+
+export type AppUser = { id: string; email: string; name?: string; role?: string };
+
+// Better Auth owns the audited primitives; defineAuth registers it with @fluixi/auth.
+export const auth = defineAuth<AppUser>(
+  betterAuth({
+    // database: <your adapter>,
+    emailAndPassword: { enabled: true },
+    // socialProviders: { google: { … }, github: { … } },
+  } as Parameters<typeof betterAuth>[0]),
+);
+`;
+var authClient = () => `import { createAuthClient } from 'better-auth/client';
+import { createAuthHooks } from '@fluixi/auth/client';
+import type { AppUser } from './auth.config.js';
+
+const client = createAuthClient({ baseURL: '/api/auth' });
+
+// Or, to reuse an existing reactive session: createAuthHooks({ session: yourSessionStore }).
+export const { useUser, useSession, useAuth, useSignIn, useSignOut, protectedRoute } =
+  createAuthHooks<AppUser>({ client, loginPath: '/login' });
+`;
+var authMiddleware = () => `import { defineMiddleware } from '@fluixi/start';
+import { authMiddleware } from '@fluixi/auth/server';
+import './auth.config.js';
+
+export default defineMiddleware([authMiddleware()]);
+`;
+var authRoute = () => `import { mountAuthRoutes } from '@fluixi/auth/server';
+import '../../../auth.config.js';
+
+const handler = mountAuthRoutes();
+export const GET = handler;
+export const POST = handler;
+export default handler;
+`;
+function generate(kind, name) {
+  switch (kind) {
+    case "component":
+    case "c": {
+      if (!name) return fail("component name required, e.g. `fluixi g component Button`");
+      const Name = pascal(name);
+      const html = detectFormat() === "html";
+      const ext = html ? "ts" : "tsx";
+      write(resolve("src/components", `${Name}.${ext}`), (html ? componentHtml : component)(Name));
+      resolveHint(Name, ext);
+      break;
+    }
+    case "route":
+    case "r": {
+      if (!name) return fail("route path required, e.g. `fluixi g route about`");
+      const html = detectFormat() === "html";
+      const Name = pascal(basename(name));
+      write(resolve("src/routes", `${name}.${html ? "ts" : "tsx"}`), (html ? routeHtml : route)(Name));
+      break;
+    }
+    case "middleware":
+    case "m":
+      write(resolve("src/middleware.ts"), middleware());
+      break;
+    case "auth":
+      write(resolve("src/auth.config.ts"), authConfig());
+      write(resolve("src/auth.client.ts"), authClient());
+      write(resolve("src/middleware.ts"), authMiddleware());
+      write(resolve("src/routes/api/auth/[...all].ts"), authRoute());
+      console.log(`  ${c.gray("next: install")} ${c.cyan("better-auth")}${c.gray(", set your DB adapter in auth.config.ts, and forward `request` in entry-server")}`);
+      break;
+    default:
+      console.error(GEN_USAGE);
+      process.exit(1);
+  }
+}
+function fail(msg) {
+  console.error(`  ${c.red("✗")} ${msg}`);
+  process.exit(1);
+}
+export {
+  generate
+};

package/dist/index.cjs

@@ -0,0 +1,41 @@
+/*! @fluixi/cli v0.1.0-alpha.76 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  build: () => import_commands.build,
+  defineConfig: () => import_start.defineConfig,
+  dev: () => import_commands.dev,
+  loadConfig: () => import_config.loadConfig,
+  start: () => import_commands.start
+});
+module.exports = __toCommonJS(index_exports);
+var import_start = require("@fluixi/start");
+var import_config = require("@fluixi/start/config");
+var import_commands = require("@fluixi/start/commands");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  defineConfig,
+  dev,
+  loadConfig,
+  start
+});

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 /**
- * @fluixi/cli — the `fluixi` command-line tool.
+ * @fluixi/cli: the `fluixi` command-line tool.
  *
  * The binary lives in `cli.ts` (`fluixi <dev|build|start>`). This entry re-exports
  * the underlying runtime so the commands can also be driven programmatically.
  */
-export { defineConfig, loadConfig } from '@fluixi/start';
+export { defineConfig } from '@fluixi/start';
+export { loadConfig } from '@fluixi/start/config';
 export { dev, build, start } from '@fluixi/start/commands';
 export type { FluixiConfig } from '@fluixi/start';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,8 +1,11 @@
 /**
- * @fluixi/cli — the `fluixi` command-line tool.
+ * @fluixi/cli: the `fluixi` command-line tool.
  *
  * The binary lives in `cli.ts` (`fluixi <dev|build|start>`). This entry re-exports
  * the underlying runtime so the commands can also be driven programmatically.
  */
-export { defineConfig, loadConfig } from '@fluixi/start';
+export { defineConfig } from '@fluixi/start';
+// The loader reads a file, so it is behind the config subpath rather than the root
+// entry, which stays importable from a browser bundle.
+export { loadConfig } from '@fluixi/start/config';
 export { dev, build, start } from '@fluixi/start/commands';

package/dist/index.mjs

@@ -0,0 +1,13 @@
+/*! @fluixi/cli v0.1.0-alpha.76 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/index.ts
+import { defineConfig } from "@fluixi/start";
+import { loadConfig } from "@fluixi/start/config";
+import { dev, build, start } from "@fluixi/start/commands";
+export {
+  build,
+  defineConfig,
+  dev,
+  loadConfig,
+  start
+};