@pauldvlp/vp-react-ts-shadcn 0.4.1 → 0.5.1

package/README.md

@@ -9,9 +9,8 @@ A [Vite+](https://viteplus.dev) **monorepo generator** that scaffolds a minimal
 - `apps/website` — a React + Vite+ app (Tailwind v4, React Compiler)
 - `packages/ui` — a shared **shadcn** design system consumed by the app
 
-It's a [Bingo](https://create.bingo) template, so options can be passed on the `vp create` command
-line (anything after `--`) and the **shadcn theme is materialized at create time** from the preset
-you choose.
+Options can be passed on the `vp create` command line (anything after `--`) or answered interactively,
+and the **shadcn theme is materialized at create time** from the preset you choose.
 
 ## Usage
 
@@ -26,9 +25,8 @@ vp create @pauldvlp:vp-react-ts-shadcn -- \
   --name my-app --scope @acme --base base --preset vega --iconLibrary lucide --components button,card,dialog
 ```
 
-> Only **string/enum** options parse reliably as `vp create -- --flag value`. **Boolean** options
-> (`--cssVariables`, `--rtl`, `--pointer`, `--install`) are best left to the interactive prompt —
-> Bingo's CLI does not accept `--no-x` / `--x=false` cleanly. Omit them and answer the prompt.
+> **Boolean** options (`--cssVariables`, `--rtl`, `--pointer`, `--install`) accept both forms: pass
+> `--rtl` to enable or `--no-rtl` to disable. Omit any option to answer it at the interactive prompt.
 
 ## Options
 

package/dist/index.js

@@ -1,17 +1,14 @@
 #!/usr/bin/env node
 
-// bin/index.ts
-import { runTemplateCLI } from "bingo";
-
-// src/template.ts
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
-
 // ../template-kit/src/index.ts
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import * as prompts from "@clack/prompts";
 var RENAME = {
-  _gitignore: ".gitignore"
+  _gitignore: ".gitignore",
+  _dockerignore: ".dockerignore",
+  "_env.example": ".env.example"
 };
 var DEFAULT_PRESET = "b30557okNu";
 var ICON_LIBS = {
@@ -24,6 +21,10 @@ function toScope(name) {
   const n = name.trim();
   return n.startsWith("@") ? n : `@${n}`;
 }
+function dirName(directory) {
+  const base = path.basename(directory || "");
+  return base && base !== "." ? base : "my-app";
+}
 function readTree(dir, transform, base = dir) {
   const out = {};
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -62,6 +63,19 @@ function addIconDeps(pkg, iconLibrary) {
   const iconDeps = ICON_LIBS[iconLibrary] ?? ICON_LIBS.hugeicons;
   pkg.dependencies = { ...pkg.dependencies, ...iconDeps };
 }
+function validateScope(value) {
+  return /^@?[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value.trim()) ? void 0 : "must be a package scope/name, e.g. @acme";
+}
+function validateName(value) {
+  return /^@?[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value.trim()) ? void 0 : "must be a package name, e.g. my-app or @acme/app";
+}
+function validatePreset(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value.trim()) ? void 0 : "must be a style name or ui.shadcn.com code";
+}
+function validateComponents(value) {
+  const parts = value.split(",").map((c) => c.trim()).filter(Boolean);
+  return parts.every((c) => /^[a-z0-9][a-z0-9-]*$/.test(c)) ? void 0 : "comma-separated component names, e.g. button,card,dialog";
+}
 function withRequiredComponents(csv, required = ["button", "badge"]) {
   const requested = csv.split(",").map((c) => c.trim()).filter(Boolean);
   return Array.from(/* @__PURE__ */ new Set([...required, ...requested]));
@@ -105,99 +119,217 @@ function appComponentsJson(theme) {
     }
   };
 }
-function shadcnInitFlags(opts) {
+function shadcnInitArgs(opts) {
   return [
-    `--base ${opts.base}`,
-    `--preset ${opts.preset}`,
+    "--base",
+    opts.base,
+    "--preset",
+    opts.preset,
     opts.cssVariables ? "--css-variables" : "--no-css-variables",
     opts.rtl ? "--rtl" : "--no-rtl",
     opts.pointer ? "--pointer" : "--no-pointer",
     "--no-reinstall",
     "-y",
     "-f"
-  ].join(" ");
+  ];
 }
-
-// src/template.ts
-import { createTemplate } from "bingo";
-import { z } from "zod";
-
-// package.json
-var package_default = {
-  name: "@pauldvlp/vp-react-ts-shadcn",
-  version: "0.4.1",
-  description: "Vite+ monorepo template: one frontend app (website) + a shared shadcn UI package, themeable via shadcn presets.",
-  author: "pauldvlp (https://github.com/pauldvlp/vp-templates)",
-  license: "MIT",
-  homepage: "https://github.com/pauldvlp/vp-templates",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/pauldvlp/vp-templates.git",
-    directory: "packages/vp-react-ts-shadcn"
-  },
-  bugs: "https://github.com/pauldvlp/vp-templates/issues",
-  keywords: [
-    "vite-plus-generator",
-    "vite-plus",
-    "shadcn",
-    "react",
-    "template"
-  ],
-  bin: "./dist/index.js",
-  type: "module",
-  files: [
-    "dist",
-    "template"
-  ],
-  scripts: {
-    build: "esbuild bin/index.ts --bundle --outfile=dist/index.js --format=esm --platform=node --target=node22 --packages=external",
-    dev: "node bin/index.ts",
-    prepack: "pnpm run build"
-  },
-  dependencies: {
-    bingo: "^0.9.3",
-    zod: "^3.25.76"
-  },
-  devDependencies: {
-    "@pauldvlp/template-kit": "workspace:*",
-    "@types/node": "^24",
-    esbuild: "^0.25.0",
-    typescript: "^5"
-  },
-  engines: {
-    node: ">=22.18.0"
+function defineTemplate(config) {
+  return config;
+}
+function writeTree(node, dir, root = path.resolve(dir)) {
+  for (const [name, value] of Object.entries(node)) {
+    const p = path.resolve(dir, name);
+    const rel = path.relative(root, p);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+      throw new Error(`Refusing to write outside the target directory: ${name}`);
+    }
+    if (typeof value === "string") {
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, value);
+    } else {
+      fs.mkdirSync(p, { recursive: true });
+      writeTree(value, p, root);
+    }
   }
-};
+}
+function parseArgv(argv, descriptors) {
+  const booleanKeys = new Set(descriptors.filter((d) => d.type === "boolean").map((d) => d.key));
+  const values = {};
+  let directory;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    let body = arg.slice(2);
+    if (body.startsWith("no-") && booleanKeys.has(body.slice(3))) {
+      values[body.slice(3)] = false;
+      continue;
+    }
+    let inline;
+    const eq = body.indexOf("=");
+    if (eq !== -1) {
+      inline = body.slice(eq + 1);
+      body = body.slice(0, eq);
+    }
+    if (body === "directory") {
+      directory = inline ?? argv[++i];
+      continue;
+    }
+    if (booleanKeys.has(body)) {
+      values[body] = inline === void 0 ? true : inline !== "false";
+      continue;
+    }
+    values[body] = inline ?? argv[++i] ?? "";
+  }
+  return { values, directory };
+}
+function resolveDefault(d, options, directory) {
+  return typeof d.default === "function" ? d.default({ options, directory }) : d.default;
+}
+async function promptForOption(d, def) {
+  if (d.type === "boolean") {
+    return prompts.confirm({ message: d.message, initialValue: def === void 0 ? false : Boolean(def) });
+  }
+  if (d.type === "select") {
+    return prompts.select({
+      message: d.message,
+      options: (d.choices ?? []).map((c) => ({ value: c, label: c })),
+      initialValue: def
+    });
+  }
+  const fallback = def === void 0 ? void 0 : String(def);
+  return prompts.text({
+    message: d.message,
+    placeholder: fallback,
+    defaultValue: fallback,
+    // When a default exists, an empty submit means "use the default" — don't run validation on it,
+    // otherwise a rule like the port check would reject pressing Enter to accept 3000.
+    validate: d.validate ? (value) => !value && fallback !== void 0 ? void 0 : d.validate(value ?? "") : void 0
+  });
+}
+function printHelp(template) {
+  const lines = [];
+  if (template.about?.name) lines.push(template.about.name);
+  if (template.about?.description) lines.push(template.about.description);
+  lines.push("", "Options:", "  --directory <dir>      Where to scaffold");
+  for (const d of template.options) {
+    const hint = d.type === "select" && d.choices ? ` <${d.choices.join("|")}>` : d.type === "boolean" ? ` / --no-${d.key}` : " <value>";
+    lines.push(`  --${d.key}${hint}      ${d.message}`);
+  }
+  console.log(lines.join("\n"));
+}
+function initGit(dir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, stdio: "ignore" });
+    return;
+  } catch {
+  }
+  try {
+    execFileSync("git", ["init"], { cwd: dir, stdio: "ignore" });
+    execFileSync("git", ["add", "-A"], { cwd: dir, stdio: "ignore" });
+    let identity = [];
+    try {
+      execFileSync("git", ["config", "user.email"], { cwd: dir, stdio: "ignore" });
+    } catch {
+      identity = ["-c", "user.name=create", "-c", "user.email=create@users.noreply.github.com"];
+    }
+    execFileSync("git", [...identity, "commit", "-m", "feat: initialize project", "--no-gpg-sign"], { cwd: dir, stdio: "ignore" });
+  } catch {
+  }
+}
+async function runTemplateCLI(template) {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printHelp(template);
+    return 0;
+  }
+  const interactive = Boolean(process.stdout.isTTY) && !argv.includes("--no-interactive");
+  const { values, directory: dirArg } = parseArgv(argv, template.options);
+  prompts.intro(template.about?.name ?? "create");
+  let directory = dirArg;
+  if (!directory) {
+    if (interactive) {
+      const answer = await prompts.text({ message: "Where should we create your project?", placeholder: "my-app", defaultValue: "my-app" });
+      if (prompts.isCancel(answer)) {
+        prompts.cancel("Cancelled.");
+        return 2;
+      }
+      directory = answer || "my-app";
+    } else {
+      directory = "my-app";
+    }
+  }
+  const options = {};
+  for (const d of template.options) {
+    const def = resolveDefault(d, options, directory);
+    if (d.key in values) {
+      const value = values[d.key];
+      if (d.validate && typeof value === "string") {
+        const error = d.validate(value);
+        if (error) {
+          prompts.cancel(`Invalid --${d.key}: ${error}`);
+          return 1;
+        }
+      }
+      options[d.key] = value;
+      continue;
+    }
+    if (interactive) {
+      const answer = await promptForOption(d, def);
+      if (prompts.isCancel(answer)) {
+        prompts.cancel("Cancelled.");
+        return 2;
+      }
+      options[d.key] = answer === "" && def !== void 0 ? def : answer;
+    } else {
+      options[d.key] = def;
+    }
+  }
+  const creation = await template.produce({ options });
+  writeTree(creation.files, directory);
+  if (creation.scripts?.length) {
+    for (const step of [...creation.scripts].sort((a, b) => a.phase - b.phase)) {
+      for (const [program, ...commandArgs] of step.commands) {
+        if (!program) continue;
+        execFileSync(program, commandArgs, { cwd: directory, stdio: "inherit" });
+      }
+    }
+  }
+  if (template.git !== false) initGit(directory);
+  if (creation.suggestions?.length) {
+    prompts.note(creation.suggestions.join("\n"), "Next steps");
+  }
+  prompts.outro("Done!");
+  return 0;
+}
 
 // src/template.ts
+import { readFileSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
 var TEMPLATE_DIR = path2.join(path2.dirname(fileURLToPath(import.meta.url)), "..", "template");
-var template_default = createTemplate({
+var { name: pkgName, description: pkgDescription } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+var template_default = defineTemplate({
   about: {
-    name: package_default.name,
-    description: package_default.description
-  },
-  options: {
-    name: z.string().describe("Root project / package name").default("my-app"),
-    scope: z.string().describe("npm scope for workspace packages, e.g. @acme (defaults to @<name>)"),
-    // Unions of literals (not z.enum) so the value is settable on Bingo's CLI: bingo's arg parser
-    // handles ZodUnion/ZodLiteral but not ZodEnum (a bare `--base radix` would otherwise mis-parse to
-    // `base: true`). Both still render as an interactive `select`.
-    base: z.union([z.literal("radix"), z.literal("base")]).describe("shadcn component library base (radix-ui or @base-ui)").default("radix"),
-    preset: z.string().describe("shadcn preset: a style name (nova, vega, maia, lyra, mira, luma, sera, rhea) or a code from ui.shadcn.com").default(DEFAULT_PRESET),
-    iconLibrary: z.union([z.literal("lucide"), z.literal("hugeicons"), z.literal("radix"), z.literal("tabler")]).describe("Icon library").default("hugeicons"),
-    cssVariables: z.boolean().describe("Use CSS variables for theming").default(true),
-    rtl: z.boolean().describe("Enable RTL support").default(false),
-    pointer: z.boolean().describe("Use pointer cursor on interactive elements").default(false),
-    components: z.string().describe("Comma-separated shadcn components to pre-install, e.g. button,card,dialog").default("button,badge"),
-    install: z.boolean().describe("Install deps and apply the shadcn theme after scaffolding").default(true)
-  },
-  // Lazily default the package scope to `@<name>` (prefixing `@` unless the name already has one),
-  // so it tracks the project name instead of a fixed value. Falls back to `@app` when no name is set.
-  prepare({ options }) {
-    return {
-      scope: () => options.name ? toScope(options.name) : "@app"
-    };
+    name: pkgName,
+    description: pkgDescription
   },
+  options: [
+    // Default the name to the target directory the user chose, so they don't retype it.
+    { key: "name", type: "string", message: "Root project / package name", default: ({ directory }) => dirName(directory), validate: validateName },
+    // Lazily default the package scope to `@<name>` (prefixing `@` unless the name already has one),
+    // so it tracks the project name instead of a fixed value. Falls back to `@app` when no name is set.
+    { key: "scope", type: "string", message: "npm scope for workspace packages, e.g. @acme (defaults to @<name>)", default: ({ options }) => options.name ? toScope(options.name) : "@app", validate: validateScope },
+    { key: "base", type: "select", message: "shadcn component library base (radix-ui or @base-ui)", choices: ["radix", "base"], default: "radix" },
+    { key: "preset", type: "string", message: "shadcn preset: a style name (nova, vega, maia, lyra, mira, luma, sera, rhea) or a code from ui.shadcn.com", default: DEFAULT_PRESET, validate: validatePreset },
+    { key: "iconLibrary", type: "select", message: "Icon library", choices: ["lucide", "hugeicons", "radix", "tabler"], default: "hugeicons" },
+    { key: "cssVariables", type: "boolean", message: "Use CSS variables for theming", default: true },
+    { key: "rtl", type: "boolean", message: "Enable RTL support", default: false },
+    { key: "pointer", type: "boolean", message: "Use pointer cursor on interactive elements", default: false },
+    { key: "components", type: "string", message: "Comma-separated shadcn components to pre-install, e.g. button,card,dialog", default: "button,badge", validate: validateComponents },
+    { key: "install", type: "boolean", message: "Install deps and apply the shadcn theme after scaffolding", default: true }
+  ],
   async produce({ options }) {
     const scope = toScope(options.scope || options.name || "app");
     const files = readTree(
@@ -217,11 +349,11 @@ var template_default = createTemplate({
     }
     const adds = withRequiredComponents(options.components);
     const ui = `${scope}/ui`;
-    const initFlags = shadcnInitFlags(options);
+    const initArgs = shadcnInitArgs(options);
     const scripts = options.install ? [
-      { commands: ["pnpm install --silent"], phase: 0 },
-      { commands: [`pnpm --filter ${ui} exec shadcn init ${initFlags}`], phase: 1 },
-      { commands: [`pnpm --filter ${ui} exec shadcn add ${adds.join(" ")} -y`], phase: 2 }
+      { commands: [["pnpm", "install", "--silent"]], phase: 0 },
+      { commands: [["pnpm", "--filter", ui, "exec", "shadcn", "init", ...initArgs]], phase: 1 },
+      { commands: [["pnpm", "--filter", ui, "exec", "shadcn", "add", ...adds, "-y"]], phase: 2 }
     ] : [];
     return {
       files,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pauldvlp/vp-react-ts-shadcn",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Vite+ monorepo template: one frontend app (website) + a shared shadcn UI package, themeable via shadcn presets.",
   "author": "pauldvlp (https://github.com/pauldvlp/vp-templates)",
   "license": "MIT",
@@ -24,8 +24,7 @@
     "template"
   ],
   "dependencies": {
-    "bingo": "^0.9.3",
-    "zod": "^3.25.76"
+    "@clack/prompts": "^1.6.0"
   },
   "devDependencies": {
     "@types/node": "^24",