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

package/dist/cli.cjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_config = require("@fluixi/start/config");
+var import_commands = require("@fluixi/start/commands");
+var import_ui2 = require("@fluixi/start/ui");
+
+// src/generate.ts
+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);
+}
+
+// src/cli.ts
+function usage() {
+  const cmd = (name, desc) => `  ${import_ui2.c.cyan(name.padEnd(25))}${import_ui2.c.gray(desc)}`;
+  return [
+    "",
+    `  ${(0, import_ui2.wordmark)()}  ${import_ui2.c.gray("the Fluixi command-line tool")}`,
+    "",
+    `  ${import_ui2.c.bold("Usage")}  ${import_ui2.c.gray("fluixi <command>")}`,
+    "",
+    cmd("dev", "start the SSR dev server (Vite middleware + HMR)"),
+    cmd("build", "build the client + server bundles for production"),
+    cmd("start", "run the production SSR server (after build)"),
+    cmd("generate <kind> <name>", "scaffold a component / route / middleware / auth  " + import_ui2.c.dim("(alias: g)")),
+    "",
+    `  ${import_ui2.c.gray("New project:")}  ${import_ui2.c.cyan("npm create fluixi")} ${import_ui2.c.gray("<dir>")}`,
+    ""
+  ].join("\n");
+}
+async function main() {
+  const cmd = process.argv[2];
+  if (!cmd || cmd === "-h" || cmd === "--help") {
+    console.log(usage());
+    process.exit(cmd ? 0 : 1);
+  }
+  if (cmd === "generate" || cmd === "g") {
+    generate(process.argv[3], process.argv[4]);
+    return;
+  }
+  const config = await (0, import_config.loadConfig)();
+  switch (cmd) {
+    case "dev":
+      await (0, import_commands.dev)(config);
+      break;
+    case "build":
+      await (0, import_commands.build)(config);
+      break;
+    case "start":
+      await (0, import_commands.start)(config);
+      break;
+    default:
+      console.error(`
+  ${import_ui2.c.red("✗")} Unknown command: ${import_ui2.c.bold(cmd)}`);
+      console.log(usage());
+      process.exit(1);
+  }
+}
+main().catch((e) => {
+  console.error(`
+  ${import_ui2.c.red("✗")} ${e?.message ?? e}
+`);
+  process.exit(1);
+});

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { loadConfig } from '@fluixi/start';
+import { loadConfig } from '@fluixi/start/config';
 import { dev, build, start } from '@fluixi/start/commands';
 import { wordmark, c } from '@fluixi/start/ui';
 import { generate } from './generate.js';

package/dist/cli.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { loadConfig } from "@fluixi/start/config";
+import { dev, build, start } from "@fluixi/start/commands";
+import { wordmark, c as c2 } from "@fluixi/start/ui";
+
+// 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);
+}
+
+// src/cli.ts
+function usage() {
+  const cmd = (name, desc) => `  ${c2.cyan(name.padEnd(25))}${c2.gray(desc)}`;
+  return [
+    "",
+    `  ${wordmark()}  ${c2.gray("the Fluixi command-line tool")}`,
+    "",
+    `  ${c2.bold("Usage")}  ${c2.gray("fluixi <command>")}`,
+    "",
+    cmd("dev", "start the SSR dev server (Vite middleware + HMR)"),
+    cmd("build", "build the client + server bundles for production"),
+    cmd("start", "run the production SSR server (after build)"),
+    cmd("generate <kind> <name>", "scaffold a component / route / middleware / auth  " + c2.dim("(alias: g)")),
+    "",
+    `  ${c2.gray("New project:")}  ${c2.cyan("npm create fluixi")} ${c2.gray("<dir>")}`,
+    ""
+  ].join("\n");
+}
+async function main() {
+  const cmd = process.argv[2];
+  if (!cmd || cmd === "-h" || cmd === "--help") {
+    console.log(usage());
+    process.exit(cmd ? 0 : 1);
+  }
+  if (cmd === "generate" || cmd === "g") {
+    generate(process.argv[3], process.argv[4]);
+    return;
+  }
+  const config = await loadConfig();
+  switch (cmd) {
+    case "dev":
+      await dev(config);
+      break;
+    case "build":
+      await build(config);
+      break;
+    case "start":
+      await start(config);
+      break;
+    default:
+      console.error(`
+  ${c2.red("✗")} Unknown command: ${c2.bold(cmd)}`);
+      console.log(usage());
+      process.exit(1);
+  }
+}
+main().catch((e) => {
+  console.error(`
+  ${c2.red("✗")} ${e?.message ?? e}
+`);
+  process.exit(1);
+});