create-better-t-stack 3.10.0 → 3.11.0-pr749.29bf48d

package/bin/create-better-t-stack

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Bin stub for create-better-t-stack.
+ * Finds and runs the platform-specific compiled binary.
+ *
+ * The binary is installed as an optional dependency:
+ *   @better-t-stack/cli-{platform}-{arch}
+ *
+ * This stub searches node_modules for the matching binary package.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { platform as osPlatform, arch as osArch } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function run(target) {
+    const result = spawnSync(target, process.argv.slice(2), {
+        stdio: "inherit",
+    });
+    if (result.error) {
+        console.error(result.error.message);
+        process.exit(1);
+    }
+    const code = typeof result.status === "number" ? result.status : 0;
+    process.exit(code);
+}
+
+// Allow override via environment variable
+const envPath = process.env.CREATE_BETTER_T_STACK_BIN_PATH;
+if (envPath) {
+    run(envPath);
+}
+
+const scriptPath = realpathSync(__filename);
+const scriptDir = dirname(scriptPath);
+
+const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+};
+
+const archMap = {
+    x64: "x64",
+    arm64: "arm64",
+};
+
+let platform = platformMap[osPlatform()];
+if (!platform) {
+    platform = osPlatform();
+}
+
+let arch = archMap[osArch()];
+if (!arch) {
+    arch = osArch();
+}
+
+// Scoped package name: @better-t-stack/cli-{platform}-{arch}
+const scopedPackage = "@better-t-stack/cli-" + platform + "-" + arch;
+const binary = platform === "windows" ? "create-better-t-stack.exe" : "create-better-t-stack";
+
+function findBinary(startDir) {
+    let current = startDir;
+    for (; ;) {
+        const modules = join(current, "node_modules");
+        if (existsSync(modules)) {
+            // Check for scoped package: node_modules/@better-t-stack/cli-{platform}-{arch}
+            const scopedPath = join(modules, "@better-t-stack", "cli-" + platform + "-" + arch);
+            const candidate = join(scopedPath, "bin", binary);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return;
+        }
+        current = parent;
+    }
+}
+
+const resolved = findBinary(scriptDir);
+
+if (!resolved) {
+    console.error(
+        'No binary found for your platform (' + platform + '-' + arch + ').\n' +
+        'You can try manually installing the "' + scopedPackage + '" package.',
+    );
+    process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.10.0",
+  "version": "3.11.0-pr749.29bf48d",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -37,59 +37,69 @@
     "directory": "apps/cli"
   },
   "bin": {
-    "create-better-t-stack": "dist/cli.mjs"
+    "create-better-t-stack": "./bin/create-better-t-stack"
   },
   "files": [
-    "dist",
+    "bin",
+    "src",
     "templates"
   ],
   "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
-    },
-    "./cli": {
-      "import": "./dist/cli.mjs"
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown --publint",
-    "dev": "tsdown --watch",
+    "build": "bun run scripts/build.ts",
+    "build:local": "bun run scripts/build.ts --single",
+    "dev": "bun run src/cli.ts",
     "check-types": "tsc --noEmit",
-    "test": "bun run build && bun test",
-    "test:watch": "bun run build && bun test --watch",
-    "test:coverage": "bun run build && bun test --coverage",
-    "test:ci": "bun run build && AGENT=1 bun test --bail=5",
-    "prepublishOnly": "npm run build"
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "test:ci": "AGENT=1 bun test --bail=5",
+    "prepublishOnly": "echo 'Build binaries separately before publishing'"
   },
   "dependencies": {
-    "@better-t-stack/types": "^3.10.0",
-    "@clack/prompts": "^1.0.0-alpha.8",
-    "@orpc/server": "^1.12.2",
-    "consola": "^3.4.2",
-    "execa": "^9.6.1",
-    "fs-extra": "^11.3.2",
-    "gradient-string": "^3.0.0",
+    "@better-t-stack/types": "3.11.0-pr749.29bf48d",
+    "@opentui/core": "^0.1.62",
+    "@opentui/react": "^0.1.62",
+    "commander": "^14.0.2",
+    "fs-extra": "^11.3.3",
     "handlebars": "^4.7.8",
     "jsonc-parser": "^3.3.1",
-    "oxfmt": "^0.19.0",
-    "picocolors": "^1.1.1",
+    "react": "^19.1.0",
     "tinyglobby": "^0.2.15",
-    "trpc-cli": "^0.12.1",
     "ts-morph": "^27.0.2",
     "yaml": "^2.8.2",
-    "zod": "^4.1.13"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.17",
+    "@types/bun": "^1.3.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^24.10.2",
-    "publint": "^0.3.16",
-    "tsdown": "^0.17.2",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "tsdown": "^0.18.2",
     "typescript": "^5.9.3"
+  },
+  "optionalDependencies": {
+    "@better-t-stack/cli-darwin-arm64": "3.11.0",
+    "@better-t-stack/cli-darwin-x64": "3.11.0",
+    "@better-t-stack/cli-linux-arm64": "3.11.0",
+    "@better-t-stack/cli-linux-x64": "3.11.0",
+    "@better-t-stack/cli-windows-x64": "3.11.0",
+    "@opentui/core-darwin-arm64": "0.1.63",
+    "@opentui/core-darwin-x64": "0.1.63",
+    "@opentui/core-linux-arm64": "0.1.63",
+    "@opentui/core-linux-x64": "0.1.63",
+    "@opentui/core-win32-arm64": "0.1.63",
+    "@opentui/core-win32-x64": "0.1.63"
   }
 }

package/src/api.ts

@@ -0,0 +1,203 @@
+/**
+ * Programmatic API for create-better-t-stack
+ *
+ * This module provides a clean, programmatic interface for creating Better-T-Stack projects.
+ * It returns JSON results and never calls process.exit().
+ */
+
+import path from "node:path";
+import fs from "fs-extra";
+import { getDefaultConfig } from "./constants";
+import { createProject } from "./helpers/core/create-project";
+import { generateReproducibleCommand } from "./utils/generate-reproducible-command";
+import type {
+  Addons,
+  API,
+  Auth,
+  Backend,
+  Database,
+  DatabaseSetup,
+  Examples,
+  Frontend,
+  ORM,
+  PackageManager,
+  Payments,
+  ProjectConfig,
+  Runtime,
+  ServerDeploy,
+  WebDeploy,
+} from "./types";
+
+export interface CreateOptions {
+  /** Project name or path */
+  projectName?: string;
+  /** Use defaults for unspecified options */
+  defaults?: boolean;
+  /** Frontend frameworks to use */
+  frontend?: Frontend[];
+  /** Backend framework */
+  backend?: Backend;
+  /** Runtime (bun or node) */
+  runtime?: Runtime;
+  /** Database type */
+  database?: Database;
+  /** ORM to use */
+  orm?: ORM;
+  /** Authentication provider */
+  auth?: Auth;
+  /** Payments provider */
+  payments?: Payments;
+  /** API type (trpc, orpc, etc.) */
+  api?: API;
+  /** Addons to include */
+  addons?: Addons[];
+  /** Examples to include */
+  examples?: Examples[];
+  /** Database setup method */
+  dbSetup?: DatabaseSetup;
+  /** Web deployment target */
+  webDeploy?: WebDeploy;
+  /** Server deployment target */
+  serverDeploy?: ServerDeploy;
+  /** Initialize git repository */
+  git?: boolean;
+  /** Package manager to use */
+  packageManager?: PackageManager;
+  /** Install dependencies after creation */
+  install?: boolean;
+}
+
+export interface CreateResult {
+  /** Whether the project was created successfully */
+  success: boolean;
+  /** Absolute path to the created project directory */
+  projectDirectory?: string;
+  /** Relative path from current working directory */
+  relativePath?: string;
+  /** The final project configuration */
+  config?: ProjectConfig;
+  /** Command to reproduce this configuration */
+  reproducibleCommand?: string;
+  /** Time taken in milliseconds */
+  elapsedTimeMs: number;
+  /** Error message if creation failed */
+  error?: string;
+}
+
+/**
+ * Create a new Better-T-Stack project programmatically.
+ *
+ * @example
+ * ```typescript
+ * import { create } from "create-better-t-stack";
+ *
+ * const result = await create({
+ *   projectName: "my-app",
+ *   frontend: ["tanstack-router"],
+ *   backend: "hono",
+ *   database: "sqlite",
+ *   orm: "drizzle",
+ *   defaults: true,
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`Created at: ${result.projectDirectory}`);
+ * }
+ * ```
+ */
+export async function create(options: CreateOptions = {}): Promise<CreateResult> {
+  const startTime = Date.now();
+
+  try {
+    const defaultConfig = getDefaultConfig();
+    const projectName = options.projectName ?? defaultConfig.projectName;
+    const projectDir = path.resolve(process.cwd(), projectName);
+    const relativePath = projectName;
+
+    // Ensure directory doesn't exist or is empty
+    if (await fs.pathExists(projectDir)) {
+      const contents = await fs.readdir(projectDir);
+      if (contents.length > 0) {
+        return {
+          success: false,
+          elapsedTimeMs: Date.now() - startTime,
+          error: `Directory "${projectName}" already exists and is not empty`,
+        };
+      }
+    }
+
+    // Build final configuration
+    const config: ProjectConfig = {
+      projectName,
+      projectDir,
+      relativePath,
+      frontend:
+        options.frontend ?? (options.defaults ? defaultConfig.frontend : defaultConfig.frontend),
+      backend:
+        options.backend ?? (options.defaults ? defaultConfig.backend : defaultConfig.backend),
+      runtime:
+        options.runtime ?? (options.defaults ? defaultConfig.runtime : defaultConfig.runtime),
+      database:
+        options.database ?? (options.defaults ? defaultConfig.database : defaultConfig.database),
+      orm: options.orm ?? (options.defaults ? defaultConfig.orm : defaultConfig.orm),
+      auth: options.auth ?? (options.defaults ? defaultConfig.auth : defaultConfig.auth),
+      payments:
+        options.payments ?? (options.defaults ? defaultConfig.payments : defaultConfig.payments),
+      api: options.api ?? (options.defaults ? defaultConfig.api : defaultConfig.api),
+      addons: options.addons ?? (options.defaults ? defaultConfig.addons : defaultConfig.addons),
+      examples:
+        options.examples ?? (options.defaults ? defaultConfig.examples : defaultConfig.examples),
+      dbSetup:
+        options.dbSetup ?? (options.defaults ? defaultConfig.dbSetup : defaultConfig.dbSetup),
+      webDeploy:
+        options.webDeploy ?? (options.defaults ? defaultConfig.webDeploy : defaultConfig.webDeploy),
+      serverDeploy:
+        options.serverDeploy ??
+        (options.defaults ? defaultConfig.serverDeploy : defaultConfig.serverDeploy),
+      git: options.git ?? (options.defaults ? defaultConfig.git : defaultConfig.git),
+      packageManager:
+        options.packageManager ??
+        (options.defaults ? defaultConfig.packageManager : defaultConfig.packageManager),
+      install: options.install ?? false,
+    };
+
+    // Create project directory
+    await fs.ensureDir(projectDir);
+
+    // Create the project (suppress console output)
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const originalWarn = console.warn;
+    console.log = () => {};
+    console.info = () => {};
+    console.warn = () => {};
+
+    try {
+      await createProject(config, { manualDb: true });
+    } finally {
+      console.log = originalLog;
+      console.info = originalInfo;
+      console.warn = originalWarn;
+    }
+
+    const reproducibleCommand = generateReproducibleCommand(config);
+    const elapsedTimeMs = Date.now() - startTime;
+
+    return {
+      success: true,
+      projectDirectory: projectDir,
+      relativePath,
+      config,
+      reproducibleCommand,
+      elapsedTimeMs,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      elapsedTimeMs: Date.now() - startTime,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+// Types are exported above via the main export

package/src/cli.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env bun
+/**
+ * CLI entry point with TUI support
+ * Replaces the old clack-prompts based CLI with OpenTUI
+ */
+import { Command } from "commander";
+import { renderTui } from "./tui/app";
+import { create, type CreateOptions } from "./api";
+import { createProject } from "./helpers/core/create-project";
+import { getDefaultConfig } from "./constants";
+import { getLatestCLIVersion } from "./utils/get-latest-cli-version";
+import { generateReproducibleCommand } from "./utils/generate-reproducible-command";
+import path from "node:path";
+import type {
+  PackageManager,
+  Database,
+  ORM,
+  Backend,
+  Runtime,
+  Frontend,
+  Addons,
+  Examples,
+  DatabaseSetup,
+  API,
+  WebDeploy,
+  ServerDeploy,
+  DirectoryConflict,
+  Template,
+  Auth,
+  Payments,
+  ProjectConfig,
+} from "./types";
+
+const program = new Command();
+
+program
+  .name("create-better-t-stack")
+  .description("Create a new Better-T-Stack project")
+  .version(getLatestCLIVersion())
+  .argument("[project-name]", "Name of the project")
+  .option("-t, --template <template>", "Use a predefined template")
+  .option("-y, --yes", "Use default configuration (skip TUI)", false)
+  .option("--yolo", "(WARNING) Bypass validations and compatibility checks", false)
+  .option("--verbose", "Show detailed result information", false)
+  .option("--database <database>", "Database to use")
+  .option("--orm <orm>", "ORM to use")
+  .option("--auth <auth>", "Authentication provider")
+  .option("--payments <payments>", "Payments provider")
+  .option("--frontend <frontend...>", "Frontend framework(s)")
+  .option("--addons <addons...>", "Addons to include")
+  .option("--examples <examples...>", "Examples to include")
+  .option("--git", "Initialize git repository")
+  .option("--no-git", "Skip git initialization")
+  .option("--package-manager <pm>", "Package manager to use")
+  .option("--install", "Install dependencies")
+  .option("--no-install", "Skip dependency installation")
+  .option("--db-setup <setup>", "Database setup method")
+  .option("--backend <backend>", "Backend framework")
+  .option("--runtime <runtime>", "Runtime to use")
+  .option("--api <api>", "API framework")
+  .option("--web-deploy <deploy>", "Web deployment target")
+  .option("--server-deploy <deploy>", "Server deployment target")
+  .option("--directory-conflict <action>", "How to handle directory conflicts")
+  .option("--disable-analytics", "Disable analytics", false)
+  .option("--manual-db", "Skip automatic database setup prompt", false)
+  .action(async (projectName: string | undefined, options: Record<string, unknown>) => {
+    try {
+      // Check if we should use TUI (interactive mode)
+      const useInteractive = !options.yes && process.stdin.isTTY && process.stdout.isTTY;
+
+      if (useInteractive) {
+        // Launch TUI
+        await renderTui({
+          initialConfig: {
+            projectName,
+            frontend: options.frontend as Frontend[] | undefined,
+            backend: options.backend as Backend | undefined,
+            runtime: options.runtime as Runtime | undefined,
+            database: options.database as Database | undefined,
+            orm: options.orm as ORM | undefined,
+            auth: options.auth as Auth | undefined,
+            payments: options.payments as Payments | undefined,
+            addons: options.addons as Addons[] | undefined,
+          },
+          onComplete: async (config: ProjectConfig) => {
+            // Create project in logs panel
+            console.log("\nCreating project...\n");
+
+            await createProject(config, {
+              manualDb: options.manualDb as boolean,
+            });
+
+            const reproducibleCommand = generateReproducibleCommand(config);
+            console.log(`\n✓ Project created at: ${config.projectDir}`);
+            console.log(`\nReproducible command:\n${reproducibleCommand}\n`);
+          },
+          onCancel: () => {
+            console.log("\nOperation cancelled.\n");
+            process.exit(0);
+          },
+        });
+      } else {
+        // Non-interactive mode: use defaults or provided flags
+        const result = await create({
+          projectName,
+          defaults: options.yes as boolean,
+          frontend: options.frontend as Frontend[] | undefined,
+          backend: options.backend as Backend | undefined,
+          runtime: options.runtime as Runtime | undefined,
+          database: options.database as Database | undefined,
+          orm: options.orm as ORM | undefined,
+          auth: options.auth as Auth | undefined,
+          payments: options.payments as Payments | undefined,
+          api: options.api as API | undefined,
+          addons: options.addons as Addons[] | undefined,
+          examples: options.examples as Examples[] | undefined,
+          dbSetup: options.dbSetup as DatabaseSetup | undefined,
+          webDeploy: options.webDeploy as WebDeploy | undefined,
+          serverDeploy: options.serverDeploy as ServerDeploy | undefined,
+          git: options.git as boolean | undefined,
+          packageManager: options.packageManager as PackageManager | undefined,
+          install: options.install as boolean | undefined,
+        });
+
+        if (result.success) {
+          if (options.verbose) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log(`\n✓ Project created at: ${result.projectDirectory}`);
+            console.log(`\nReproducible command:\n${result.reproducibleCommand}\n`);
+          }
+        } else {
+          console.error(`\n✗ Failed to create project: ${result.error}\n`);
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      console.error(`\n✗ Error: ${error instanceof Error ? error.message : String(error)}\n`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("add")
+  .description("Add addons or deployment configurations to an existing project")
+  .option("--addons <addons...>", "Addons to add")
+  .option("--web-deploy <deploy>", "Web deployment target")
+  .option("--server-deploy <deploy>", "Server deployment target")
+  .option("--project-dir <dir>", "Project directory")
+  .option("--install", "Install dependencies after adding", false)
+  .option("--package-manager <pm>", "Package manager to use")
+  .action(async (options: Record<string, unknown>) => {
+    // TODO: Implement add command with TUI
+    console.log("Add command - TUI coming soon");
+  });
+
+program
+  .command("docs")
+  .description("Open Better-T-Stack documentation")
+  .action(async () => {
+    const { openUrl } = await import("./utils/open-url");
+    const DOCS_URL = "https://better-t-stack.dev/docs";
+    try {
+      await openUrl(DOCS_URL);
+      console.log("Opened docs in your default browser.");
+    } catch {
+      console.log(`Please visit ${DOCS_URL}`);
+    }
+  });
+
+program
+  .command("builder")
+  .description("Open the web-based stack builder")
+  .action(async () => {
+    const { openUrl } = await import("./utils/open-url");
+    const BUILDER_URL = "https://better-t-stack.dev/new";
+    try {
+      await openUrl(BUILDER_URL);
+      console.log("Opened builder in your default browser.");
+    } catch {
+      console.log(`Please visit ${BUILDER_URL}`);
+    }
+  });
+
+program.parse();