create-blitzpack 0.1.17 → 0.1.19

package/README.md

@@ -31,9 +31,11 @@ pnpm create blitzpack [project-name] [options]
 
 The scaffold wizard supports three profiles:
 
-- **Recommended**: All app features plus Docker deployment assets and CD workflow.
-- **Platform-First**: All app features, without deployment assets.
-- **Custom**: Pick app features and deployment options independently.
+- **Recommended**: Core app with everything included.
+- **Platform-Agnostic**: Core app without dockerfiles.
+- **Modular**: Core app with features of your choice.
+
+Each profile is a setup path. The **Modular** path opens full feature customization before files are created.
 
 ## Requirements
 

package/dist/index.js

@@ -10,13 +10,82 @@ import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 import { spawn } from "child_process";
 import fs3 from "fs-extra";
-import ora from "ora";
+import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
+import ora2 from "ora";
 import path4 from "path";
-import prompts2 from "prompts";
 
 // src/checks.ts
 import chalk from "chalk";
+import { execSync as execSync3 } from "child_process";
+import ora from "ora";
+
+// src/docker.ts
 import { execSync } from "child_process";
+function isDockerInstalled() {
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDockerRunning() {
+  try {
+    execSync("docker info", { stdio: "ignore", timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runDockerCompose(targetDir) {
+  try {
+    execSync("docker compose up -d", {
+      cwd: targetDir,
+      stdio: "inherit"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runDatabaseMigrations(targetDir) {
+  try {
+    const isWindows = process.platform === "win32";
+    execSync(isWindows ? "pnpm.cmd db:migrate" : "pnpm db:migrate", {
+      cwd: targetDir,
+      stdio: "inherit"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/git.ts
+import { execSync as execSync2 } from "child_process";
+function isGitInstalled() {
+  try {
+    execSync2("git --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function initGit(targetDir) {
+  try {
+    execSync2("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync2("git add -A", { cwd: targetDir, stdio: "ignore" });
+    execSync2('git commit -m "Initial commit from create-blitzpack"', {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/checks.ts
 function checkNodeVersion() {
   try {
     const nodeVersion = process.version;
@@ -24,127 +93,126 @@ function checkNodeVersion() {
     if (majorVersion >= 20) {
       return {
         passed: true,
-        name: "Node.js"
+        name: "Node.js",
+        required: true,
+        message: nodeVersion
       };
     }
     return {
       passed: false,
       name: "Node.js",
+      required: true,
       message: `Node.js >= 20.0.0 required (found ${nodeVersion})`
     };
   } catch {
     return {
       passed: false,
       name: "Node.js",
+      required: true,
       message: "Failed to check Node.js version"
     };
   }
 }
 function checkPnpmInstalled() {
   try {
-    execSync("pnpm --version", { stdio: "ignore" });
+    const version = execSync3("pnpm --version", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
     return {
       passed: true,
-      name: "pnpm"
+      name: "pnpm",
+      required: true,
+      message: `v${version}`
     };
   } catch {
     return {
       passed: false,
       name: "pnpm",
+      required: true,
       message: "pnpm not found. Install: npm install -g pnpm"
     };
   }
 }
+function checkGit() {
+  const installed = isGitInstalled();
+  return {
+    passed: installed,
+    name: "git",
+    required: false,
+    message: installed ? "available (repository initialization supported)" : "not found (git init step will be skipped)"
+  };
+}
+function checkDocker() {
+  const installed = isDockerInstalled();
+  return {
+    passed: installed,
+    name: "Docker",
+    required: false,
+    message: installed ? "available (automatic local DB setup supported)" : "not found (start PostgreSQL separately)"
+  };
+}
 async function runPreflightChecks() {
   console.log();
-  console.log(chalk.bold("  Checking requirements..."));
+  console.log(chalk.bold("  System readiness"));
+  console.log(chalk.dim("  Validating required and optional local tooling..."));
   console.log();
-  const checks = [checkNodeVersion(), checkPnpmInstalled()];
-  let hasErrors = false;
+  const checks = [
+    checkNodeVersion(),
+    checkPnpmInstalled(),
+    checkGit(),
+    checkDocker()
+  ];
+  const requiredFailures = [];
+  const optionalWarnings = [];
   for (const check of checks) {
+    const spinner = ora(`Checking ${check.name}...`).start();
     if (check.passed) {
-      console.log(chalk.green("  \u2714"), check.name);
+      spinner.succeed(chalk.bold(check.name));
     } else {
-      hasErrors = true;
-      console.log(chalk.red("  \u2716"), check.name);
-      if (check.message) {
-        console.log(chalk.dim(`    ${check.message}`));
+      if (check.required) {
+        requiredFailures.push(check);
+        spinner.fail(chalk.bold(check.name));
+      } else {
+        optionalWarnings.push(check);
+        spinner.warn(chalk.bold(check.name));
       }
+      console.log(chalk.dim(`    ${check.message}`));
     }
   }
   console.log();
-  if (hasErrors) {
+  if (optionalWarnings.length > 0) {
+    console.log(chalk.yellow("  Optional tools missing:"));
+    for (const warning of optionalWarnings) {
+      console.log(chalk.dim(`    \u2022 ${warning.name}: ${warning.message}`));
+    }
+    console.log();
+  }
+  if (requiredFailures.length > 0) {
     console.log(
       chalk.red("  \u2716"),
-      "Requirements not met. Please fix the errors above."
+      "Required dependencies are missing. Fix the items below and try again:"
     );
+    for (const failure of requiredFailures) {
+      console.log(chalk.dim(`    \u2022 ${failure.name}: ${failure.message}`));
+    }
     console.log();
     return false;
   }
   return true;
 }
 
-// src/docker.ts
-import { execSync as execSync2 } from "child_process";
-function isDockerRunning() {
-  try {
-    execSync2("docker info", { stdio: "ignore", timeout: 3e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function runDockerCompose(targetDir) {
-  try {
-    execSync2("docker compose up -d", {
-      cwd: targetDir,
-      stdio: "inherit"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function runDatabaseMigrations(targetDir) {
-  try {
-    const isWindows = process.platform === "win32";
-    execSync2(isWindows ? "pnpm.cmd db:migrate" : "pnpm db:migrate", {
-      cwd: targetDir,
-      stdio: "inherit"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/git.ts
-import { execSync as execSync3 } from "child_process";
-function isGitInstalled() {
-  try {
-    execSync3("git --version", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function initGit(targetDir) {
-  try {
-    execSync3("git init", { cwd: targetDir, stdio: "ignore" });
-    execSync3("git add -A", { cwd: targetDir, stdio: "ignore" });
-    execSync3('git commit -m "Initial commit from create-blitzpack"', {
-      cwd: targetDir,
-      stdio: "ignore"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/prompts.ts
 import chalk3 from "chalk";
-import prompts from "prompts";
+import {
+  cancel,
+  confirm,
+  isCancel,
+  multiselect,
+  note,
+  select,
+  text
+} from "@clack/prompts";
 
 // src/constants.ts
 var REPLACEABLE_FILES = [
@@ -229,10 +297,49 @@ var FEATURE_EXCLUSIONS = {
     "apps/api/.dockerignore",
     "apps/api/Dockerfile",
     "apps/web/Dockerfile",
-    "deploy/docker"
+    "deploy/docker",
+    ".github/workflows/docker-build.yml"
   ],
   ciCd: [".github/workflows/cd.yml"]
 };
+var PROJECT_PROFILES = [
+  {
+    key: "recommended",
+    name: "Recommended",
+    description: "Core app with everything included",
+    defaultFeatures: {
+      testing: true,
+      admin: true,
+      uploads: true,
+      dockerDeploy: true,
+      ciCd: true
+    }
+  },
+  {
+    key: "platformAgnostic",
+    name: "Platform-Agnostic",
+    description: "Core app without dockerfiles",
+    defaultFeatures: {
+      testing: true,
+      admin: true,
+      uploads: true,
+      dockerDeploy: false,
+      ciCd: false
+    }
+  },
+  {
+    key: "modular",
+    name: "Modular",
+    description: "Core app with features of your choice",
+    defaultFeatures: {
+      testing: false,
+      admin: false,
+      uploads: false,
+      dockerDeploy: false,
+      ciCd: false
+    }
+  }
+];
 
 // src/utils.ts
 import chalk2 from "chalk";
@@ -350,46 +457,84 @@ function printError(message) {
 }
 
 // src/prompts.ts
-async function getProjectOptions(providedName, flags = {}) {
-  const questions = [];
-  if (!providedName) {
-    questions.push({
-      type: "text",
-      name: "projectName",
-      message: "Project name:",
-      initial: "my-app",
-      validate: (value) => {
-        const result = validateProjectName(value);
-        if (!result.valid) {
-          return result.problems?.[0] || "Invalid project name";
-        }
-        return true;
-      }
-    });
-  }
-  questions.push({
-    type: "text",
-    name: "projectDescription",
-    message: "Project description:",
-    initial: DEFAULT_DESCRIPTION
-  });
-  let cancelled = false;
-  const response = await prompts(questions, {
-    onCancel: () => {
-      cancelled = true;
-    }
-  });
-  if (cancelled) {
+var FEATURE_LABELS = {
+  testing: "Testing",
+  admin: "Admin Dashboard",
+  uploads: "File Uploads",
+  dockerDeploy: "Docker deploy assets",
+  ciCd: "CD workflow"
+};
+var FEATURE_HINTS = {
+  testing: "Vitest, integration tests, and test helpers",
+  admin: "Admin routes, dashboard views, and management hooks",
+  uploads: "Upload APIs, storage service, and UI upload components",
+  dockerDeploy: "API/Web Dockerfiles and production Docker Compose",
+  ciCd: "GitHub Actions workflow for image build and publish"
+};
+function handleCancelledPrompt(value) {
+  if (isCancel(value)) {
+    cancel("Setup cancelled.");
     return null;
   }
-  const projectName = providedName || response.projectName;
+  return value;
+}
+function getEnabledFeatureKeys(features) {
+  return Object.keys(features).filter((key) => features[key]);
+}
+function deriveProfileFeatureSelection(profileKey) {
+  const profile = PROJECT_PROFILES.find((item) => item.key === profileKey) ?? PROJECT_PROFILES[0];
+  return getEnabledFeatureKeys(profile.defaultFeatures);
+}
+function resolveFeatureSelection(selected) {
+  const unique = Array.from(new Set(selected));
+  const hasCiCd = unique.includes("ciCd");
+  const hasDockerDeploy = unique.includes("dockerDeploy");
+  if (hasCiCd && !hasDockerDeploy) {
+    return [...unique.filter((key) => key !== "dockerDeploy"), "dockerDeploy"];
+  }
+  return unique;
+}
+function buildFeatureOptions(selectedFeatures) {
+  const normalized = resolveFeatureSelection(selectedFeatures);
+  return {
+    testing: normalized.includes("testing"),
+    admin: normalized.includes("admin"),
+    uploads: normalized.includes("uploads"),
+    dockerDeploy: normalized.includes("dockerDeploy"),
+    ciCd: normalized.includes("ciCd")
+  };
+}
+function printWizardStep(step, total, title) {
+  console.log();
+  console.log(chalk3.bold(`  Step ${step}/${total}`), chalk3.dim(title));
+  console.log();
+}
+function getStepTotal(profileKey) {
+  return profileKey === "modular" ? 4 : 2;
+}
+function printMultiselectControls() {
+  console.log(
+    chalk3.dim("  Controls: \u2191/\u2193 navigate \u2022 Space toggle \u2022 Enter confirm")
+  );
+  console.log();
+}
+function printConfigurationSummary(profileName, features) {
+  const lines = [
+    `${chalk3.dim("Profile")}: ${profileName}`,
+    `${chalk3.dim("Testing")}: ${features.testing ? "yes" : "no"}`,
+    `${chalk3.dim("Admin dashboard")}: ${features.admin ? "yes" : "no"}`,
+    `${chalk3.dim("File uploads")}: ${features.uploads ? "yes" : "no"}`,
+    `${chalk3.dim("Docker deploy assets")}: ${features.dockerDeploy ? "yes" : "no"}`,
+    `${chalk3.dim("CD workflow")}: ${features.ciCd ? "yes" : "no"}`
+  ];
+  note(lines.join("\n"), chalk3.cyan("Configuration summary"));
+}
+function finalizeOptions(state, providedName, flags) {
+  const projectName = providedName || state.projectNameInput;
   const validation = validateProjectName(projectName);
   if (!validation.valid) {
-    console.log(`Invalid project name: ${validation.problems?.[0]}`);
-    return null;
-  }
-  const features = await promptFeatureSelection();
-  if (!features) {
+    console.log();
+    console.log(chalk3.red("  \u2716"), validation.problems?.[0] ?? "Invalid project name");
     return null;
   }
   const useCurrentDir = projectName === ".";
@@ -397,134 +542,201 @@ async function getProjectOptions(providedName, flags = {}) {
   return {
     projectName: actualProjectName,
     projectSlug: toSlug(actualProjectName),
-    projectDescription: response.projectDescription || DEFAULT_DESCRIPTION,
+    projectDescription: state.projectDescription || DEFAULT_DESCRIPTION,
     skipGit: flags.skipGit || false,
     skipInstall: flags.skipInstall || false,
     useCurrentDir,
-    features
+    features: buildFeatureOptions(state.selectedFeatures)
   };
 }
-async function promptFeatureSelection() {
-  let cancelled = false;
-  const { setupType } = await prompts(
-    {
-      type: "select",
-      name: "setupType",
-      message: "Project profile:",
-      choices: [
-        {
-          title: "Recommended",
-          description: "all app features + Docker deploy assets + CD workflow",
-          value: "recommended"
-        },
-        {
-          title: "Platform-First",
-          description: "all app features, no deployment assets",
-          value: "platform"
-        },
-        {
-          title: "Custom",
-          description: "choose app and deployment features",
-          value: "customize"
+async function getProjectOptions(providedName, flags = {}) {
+  const initialProjectName = providedName || "my-app";
+  const initialProfileKey = "recommended";
+  const state = {
+    projectNameInput: initialProjectName,
+    projectDescription: DEFAULT_DESCRIPTION,
+    profileKey: initialProfileKey,
+    selectedFeatures: deriveProfileFeatureSelection(initialProfileKey)
+  };
+  let stage = "details";
+  while (true) {
+    if (stage === "details") {
+      printWizardStep(1, getStepTotal(state.profileKey), "Project details");
+      if (!providedName) {
+        const projectNameInput = handleCancelledPrompt(
+          await text({
+            message: chalk3.cyan("Project name"),
+            initialValue: state.projectNameInput,
+            validate: (value) => {
+              if (typeof value !== "string") {
+                return "Project name is required";
+              }
+              const result = validateProjectName(value);
+              return result.valid ? void 0 : result.problems?.[0] ?? "Invalid project name";
+            }
+          })
+        );
+        if (projectNameInput === null) {
+          return null;
         }
-      ],
-      initial: 0,
-      hint: "- Use arrow-keys, Enter to submit"
-    },
-    {
-      onCancel: () => {
-        cancelled = true;
+        state.projectNameInput = projectNameInput;
+      } else {
+        console.log(chalk3.dim("  Project name:"), chalk3.white(providedName));
       }
+      const descriptionInput = handleCancelledPrompt(
+        await text({
+          message: chalk3.cyan("Project description"),
+          initialValue: state.projectDescription
+        })
+      );
+      if (descriptionInput === null) {
+        return null;
+      }
+      state.projectDescription = descriptionInput;
+      stage = "profile";
+      continue;
     }
-  );
-  if (cancelled) {
-    return null;
-  }
-  if (setupType === "recommended") {
-    return {
-      testing: true,
-      admin: true,
-      uploads: true,
-      dockerDeploy: true,
-      ciCd: true
-    };
-  }
-  if (setupType === "platform") {
-    return {
-      testing: true,
-      admin: true,
-      uploads: true,
-      dockerDeploy: false,
-      ciCd: false
-    };
-  }
-  const appFeatureChoices = APP_FEATURES.map((feature) => ({
-    title: feature.name,
-    description: feature.description,
-    value: feature.key,
-    selected: true
-  }));
-  const { selectedAppFeatures } = await prompts(
-    {
-      type: "multiselect",
-      name: "selectedAppFeatures",
-      message: "Select app features:",
-      choices: appFeatureChoices,
-      hint: "- Space to toggle, Enter to confirm",
-      instructions: false
-    },
-    {
-      onCancel: () => {
-        cancelled = true;
+    if (stage === "profile") {
+      printWizardStep(2, getStepTotal(state.profileKey), "Choose a setup preset");
+      const profileAction = handleCancelledPrompt(
+        await select({
+          message: chalk3.cyan("Setup preset"),
+          options: [
+            ...PROJECT_PROFILES.map((profile2) => ({
+              value: profile2.key,
+              label: profile2.name,
+              hint: profile2.description
+            })),
+            {
+              value: "__back__",
+              label: "Back",
+              hint: "Return to project details"
+            }
+          ],
+          initialValue: state.profileKey
+        })
+      );
+      if (profileAction === null) {
+        return null;
+      }
+      if (profileAction === "__back__") {
+        stage = "details";
+        continue;
       }
+      state.profileKey = profileAction;
+      state.selectedFeatures = deriveProfileFeatureSelection(state.profileKey);
+      if (state.profileKey !== "modular") {
+        const result = finalizeOptions(state, providedName, flags);
+        if (!result) {
+          stage = "details";
+          continue;
+        }
+        return result;
+      }
+      stage = "features";
+      continue;
     }
-  );
-  if (cancelled) {
-    return null;
-  }
-  const deploymentFeatureChoices = DEPLOYMENT_FEATURES.map((feature) => ({
-    title: feature.name,
-    description: feature.description,
-    value: feature.key,
-    selected: false
-  }));
-  const { selectedDeploymentFeatures } = await prompts(
-    {
-      type: "multiselect",
-      name: "selectedDeploymentFeatures",
-      message: "Select deployment options (optional):",
-      choices: deploymentFeatureChoices,
-      hint: "- Space to toggle, Enter to confirm",
-      instructions: false
-    },
-    {
-      onCancel: () => {
-        cancelled = true;
+    if (stage === "features") {
+      const isModular = state.profileKey === "modular";
+      printWizardStep(3, 4, isModular ? "Select features" : "Deployment options");
+      if (isModular) {
+        printMultiselectControls();
+        const selectedFeatures = handleCancelledPrompt(
+          await multiselect({
+            message: chalk3.cyan("Select features"),
+            options: [...APP_FEATURES, ...DEPLOYMENT_FEATURES].map((feature) => ({
+              value: feature.key,
+              label: FEATURE_LABELS[feature.key],
+              hint: FEATURE_HINTS[feature.key]
+            })),
+            initialValues: state.selectedFeatures,
+            required: false
+          })
+        );
+        if (selectedFeatures === null) {
+          return null;
+        }
+        state.selectedFeatures = resolveFeatureSelection(
+          selectedFeatures
+        );
+        if (state.selectedFeatures.includes("ciCd") && !selectedFeatures.includes("dockerDeploy")) {
+          console.log();
+          console.log(
+            chalk3.dim(
+              "  \u2139 CD workflow requires Docker deployment assets, enabling both."
+            )
+          );
+        }
       }
+      const nextAction = handleCancelledPrompt(
+        await select({
+          message: chalk3.cyan("Continue"),
+          options: [
+            {
+              value: "review",
+              label: "Review configuration"
+            },
+            {
+              value: "profile",
+              label: "Back",
+              hint: "Return to preset selection"
+            }
+          ],
+          initialValue: "review"
+        })
+      );
+      if (nextAction === null) {
+        return null;
+      }
+      stage = nextAction;
+      continue;
     }
-  );
-  if (cancelled) {
-    return null;
-  }
-  const selectedApp = selectedAppFeatures || [];
-  const selectedDeployment = selectedDeploymentFeatures || [];
-  const includesCiCd = selectedDeployment.includes("ciCd");
-  const includesDockerDeploy = selectedDeployment.includes("dockerDeploy") || includesCiCd;
-  if (includesCiCd && !selectedDeployment.includes("dockerDeploy")) {
-    console.log();
-    console.log(
-      chalk3.dim(
-        "  \u2139 CD workflow requires Docker deployment assets, enabling both."
-      )
+    const profile = PROJECT_PROFILES.find((item) => item.key === state.profileKey) ?? PROJECT_PROFILES[0];
+    const options = finalizeOptions(state, providedName, flags);
+    if (!options) {
+      stage = "details";
+      continue;
+    }
+    const features = options.features;
+    const reviewStep = state.profileKey === "modular" ? 4 : 3;
+    printWizardStep(reviewStep, getStepTotal(state.profileKey), "Review and confirm");
+    printConfigurationSummary(profile.name, features);
+    const reviewOptions = [
+      {
+        value: "create",
+        label: "Create project"
+      },
+      {
+        value: "profile",
+        label: "Edit preset"
+      },
+      {
+        value: "details",
+        label: "Edit project details"
+      }
+    ];
+    if (state.profileKey === "modular") {
+      reviewOptions.splice(1, 0, {
+        value: "features",
+        label: "Edit features"
+      });
+    }
+    const reviewAction = handleCancelledPrompt(
+      await select({
+        message: chalk3.cyan("Ready to scaffold?"),
+        options: reviewOptions,
+        initialValue: "create"
+      })
     );
+    if (reviewAction === null) {
+      return null;
+    }
+    if (reviewAction !== "create") {
+      stage = reviewAction;
+      continue;
+    }
+    return options;
   }
-  return {
-    testing: selectedApp.includes("testing"),
-    admin: selectedApp.includes("admin"),
-    uploads: selectedApp.includes("uploads"),
-    dockerDeploy: includesDockerDeploy,
-    ciCd: includesCiCd
-  };
 }
 async function promptAutomaticSetup() {
   const dockerRunning = isDockerRunning();
@@ -541,13 +753,16 @@ async function promptAutomaticSetup() {
     return false;
   }
   console.log();
-  const { runSetup } = await prompts({
-    type: "confirm",
-    name: "runSetup",
-    message: "Run local setup now? (start PostgreSQL with Docker + run migrations)",
-    initial: true
-  });
-  return runSetup || false;
+  const runSetup = handleCancelledPrompt(
+    await confirm({
+      message: "Run local setup now? (Docker PostgreSQL + database migrations)",
+      initialValue: true
+    })
+  );
+  if (runSetup === null) {
+    return false;
+  }
+  return runSetup;
 }
 
 // src/template.ts
@@ -958,6 +1173,59 @@ jobs:
           BETTER_AUTH_SECRET: 'test-secret-minimum-32-characters-long-for-ci'
           BETTER_AUTH_URL: 'http://localhost:8080'
           NEXT_PUBLIC_API_URL: 'http://localhost:8080/api'
+
+`;
+
+// src/docker-ci-workflow-template.ts
+var DOCKER_CI_WORKFLOW_TEMPLATE = `name: Docker Build
+
+on:
+  pull_request:
+    branches: [main, development]
+  push:
+    branches: [main]
+
+# Cancel in-progress runs when a new commit is pushed
+concurrency:
+  group: \${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-api:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build API image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./apps/api/Dockerfile
+          push: false
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  build-web:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Web image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./apps/web/Dockerfile
+          push: false
+          build-args: |
+            NEXT_PUBLIC_API_URL=http://localhost:8080/api
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
 `;
 
 // src/transform.ts
@@ -989,6 +1257,7 @@ var TESTING_FILE_PATTERNS = [
 var TS_CONFIG_FILE_PATTERN = /^tsconfig(?:\.[^.]+)?\.json$/;
 var AGENT_DOC_TARGETS = ["CLAUDE.md", "AGENTS.md"];
 var CI_WORKFLOW_RELATIVE_PATH = ".github/workflows/ci.yml";
+var DOCKER_CI_WORKFLOW_RELATIVE_PATH = ".github/workflows/docker-build.yml";
 var MARKER_FILES = [
   "apps/api/src/app.ts",
   "apps/api/src/plugins/services.ts",
@@ -1177,6 +1446,7 @@ async function applyFeatureTransforms(targetDir, features) {
     await transformForNoTesting(targetDir);
   }
   await transformCiWorkflow(targetDir, disabledFeatures);
+  await transformDockerCiWorkflow(targetDir, features);
   await transformAgentDocs(targetDir, disabledFeatures);
 }
 async function transformForNoTesting(targetDir) {
@@ -1350,6 +1620,18 @@ async function transformCiWorkflow(targetDir, disabledFeatures) {
   content = cleanEmptyLines(content).trimEnd() + "\n";
   await fs2.writeFile(workflowPath, content, "utf-8");
 }
+async function transformDockerCiWorkflow(targetDir, features) {
+  const workflowPath = path3.join(targetDir, DOCKER_CI_WORKFLOW_RELATIVE_PATH);
+  if (!features.dockerDeploy) {
+    if (await fs2.pathExists(workflowPath)) {
+      await fs2.remove(workflowPath);
+    }
+    return;
+  }
+  await fs2.ensureDir(path3.dirname(workflowPath));
+  const content = DOCKER_CI_WORKFLOW_TEMPLATE.trimEnd() + "\n";
+  await fs2.writeFile(workflowPath, content, "utf-8");
+}
 
 // src/commands/create.ts
 var ENV_FILES = [
@@ -1376,6 +1658,37 @@ function runInstall(cwd) {
     child.on("error", () => resolve(false));
   });
 }
+function renderProgressBar(current, total) {
+  const width = 28;
+  const clampedTotal = Math.max(total, 1);
+  const ratio = Math.min(Math.max(current / clampedTotal, 0), 1);
+  const filled = Math.round(width * ratio);
+  const empty = width - filled;
+  const filledBar = chalk4.cyan("\u2588".repeat(filled));
+  const emptyBar = chalk4.dim("\u2591".repeat(empty));
+  const percentage = `${Math.round(ratio * 100)}`.padStart(3, " ");
+  return `[${filledBar}${emptyBar}] ${percentage}%`;
+}
+function renderStepTrack(step, total) {
+  const segments = [];
+  for (let index = 1; index <= total; index++) {
+    if (index < step) {
+      segments.push(chalk4.green("\u25CF"));
+    } else if (index === step) {
+      segments.push(chalk4.cyan("\u25C6"));
+    } else {
+      segments.push(chalk4.dim("\u25C7"));
+    }
+  }
+  return segments.join(chalk4.dim("\u2500\u2500"));
+}
+function printStepHeader(step, total, title) {
+  const completed = step - 1;
+  console.log();
+  console.log(chalk4.cyan(`  Step ${step}/${total}`), chalk4.bold(title));
+  console.log(`  ${renderProgressBar(completed, total)}`);
+  console.log(`  ${renderStepTrack(step, total)}`);
+}
 function printDryRun(options) {
   console.log(chalk4.yellow("  Dry run mode - no changes will be made"));
   console.log();
@@ -1447,13 +1760,11 @@ async function create(projectName, flags) {
     const files = await fs3.readdir(targetDir);
     if (files.length > 0) {
       if (options.useCurrentDir) {
-        const { confirm } = await prompts2({
-          type: "confirm",
-          name: "confirm",
-          message: `Current directory is not empty. Continue?`,
-          initial: false
+        const shouldContinue = await confirm2({
+          message: "Current directory is not empty. Continue?",
+          initialValue: false
         });
-        if (!confirm) {
+        if (isCancel2(shouldContinue) || !shouldContinue) {
           return;
         }
       } else {
@@ -1462,11 +1773,18 @@ async function create(projectName, flags) {
       }
     }
   }
-  const spinner = ora();
+  const shouldRunSetup = await promptAutomaticSetup();
+  const totalSteps = 2 + (options.skipGit ? 0 : 1) + (options.skipInstall ? 0 : 1) + (shouldRunSetup ? 1 : 0);
+  let currentStep = 0;
+  let spinner;
   try {
-    spinner.start("Downloading template from GitHub...");
+    currentStep += 1;
+    printStepHeader(currentStep, totalSteps, "Scaffold template");
+    spinner = ora2("Downloading template from GitHub...").start();
     await downloadAndPrepareTemplate(targetDir, spinner, options.features);
-    spinner.start("Configuring project...");
+    currentStep += 1;
+    printStepHeader(currentStep, totalSteps, "Configure project files");
+    spinner.start("Applying template transforms...");
     await transformFiles(
       targetDir,
       {
@@ -1479,6 +1797,8 @@ async function create(projectName, flags) {
     await copyEnvFiles(targetDir);
     spinner.succeed("Configured project");
     if (!options.skipGit && isGitInstalled()) {
+      currentStep += 1;
+      printStepHeader(currentStep, totalSteps, "Initialize git repository");
       spinner.start("Initializing git repository...");
       const gitSuccess = initGit(targetDir);
       if (gitSuccess) {
@@ -1486,8 +1806,14 @@ async function create(projectName, flags) {
       } else {
         spinner.warn("Failed to initialize git repository");
       }
+    } else if (!options.skipGit) {
+      currentStep += 1;
+      printStepHeader(currentStep, totalSteps, "Initialize git repository");
+      spinner.warn("Skipped git initialization (git not installed)");
     }
     if (!options.skipInstall) {
+      currentStep += 1;
+      printStepHeader(currentStep, totalSteps, "Install dependencies");
       spinner.start("Installing dependencies...");
       const success = await runInstall(targetDir);
       if (success) {
@@ -1499,9 +1825,9 @@ async function create(projectName, flags) {
       }
     }
     let ranAutomaticSetup = false;
-    const shouldRunSetup = await promptAutomaticSetup();
     if (shouldRunSetup) {
-      console.log();
+      currentStep += 1;
+      printStepHeader(currentStep, totalSteps, "Run local database setup");
       spinner.start("Starting PostgreSQL database...");
       const dockerSuccess = runDockerCompose(targetDir);
       if (dockerSuccess) {
@@ -1528,7 +1854,7 @@ async function create(projectName, flags) {
       ranAutomaticSetup
     );
   } catch (error) {
-    spinner.fail();
+    spinner?.fail();
     printError(
       error instanceof Error ? error.message : "Unknown error occurred"
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-blitzpack",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Create a new Blitzpack project - full-stack TypeScript monorepo with Next.js and Fastify",
   "type": "module",
   "bin": {
@@ -16,18 +16,17 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
+    "@clack/prompts": "^1.0.0",
     "chalk": "^5.6.2",
     "commander": "^13.1.0",
     "fs-extra": "^11.3.3",
     "giget": "^2.0.0",
     "ora": "^8.2.0",
-    "prompts": "^2.4.2",
     "validate-npm-package-name": "^6.0.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.19.3",
-    "@types/prompts": "^2.4.9",
     "@types/validate-npm-package-name": "^4.0.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"