@guchen_0521/create-temp 0.1.5 → 0.1.7

package/README.md

@@ -23,6 +23,12 @@ Use with npm create:
 npm create @guchen_0521/temp@latest -- backend/express/express-no-ts my-api
 ```
 
+Interactive selection (TUI):
+
+```bash
+npm create @guchen_0521/temp@latest
+```
+
 ## Requirements
 
 - Git installed and available in PATH

package/lib/scaffold.js

@@ -3,14 +3,16 @@ import {
   mkdir,
   mkdtemp,
   readdir,
+  readFile,
   rm,
   stat,
+  writeFile,
 } from "node:fs/promises";
 import { execFile } from "node:child_process";
-import { createInterface } from "node:readline/promises";
 import { promisify } from "node:util";
 import os from "node:os";
 import path from "node:path";
+import prompts from "prompts";
 
 const IGNORE_NAMES = new Set([
   ".git",
@@ -27,6 +29,24 @@ const TEMPLATE_REPO_URL =
 const CLONE_RETRIES = 3;
 const GIT_SSH_COMMAND =
   "ssh -o ServerAliveInterval=30 -o ServerAliveCountMax=6";
+const PROMPT_CANCELLED_MESSAGE = "Prompt cancelled.";
+const PROMPT_BACK_VALUE = "__back";
+const OPTIONAL_PACKAGES_PATH = new URL(
+  "../optional-packages.json",
+  import.meta.url
+);
+
+function assertInteractive() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "Interactive prompts require a TTY. Pass template and target arguments."
+    );
+  }
+}
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
 
 async function cloneTemplateRepo() {
   const tempDir = await mkdtemp(path.join(os.tmpdir(), "template-cli-"));
@@ -101,33 +121,211 @@ function normalizeTemplateKey(templateKey) {
     .replace(/^\.\/+/, "");
 }
 
-async function promptSelectTemplate(templates) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  console.log("Available templates:");
-  templates.forEach((template, index) => {
-    console.log(`  ${index + 1}) ${template.key}`);
+async function loadOptionalPackageRules() {
+  try {
+    const raw = await readFile(OPTIONAL_PACKAGES_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function matchOptionalRule(rule, templateKey) {
+  if (!rule || !templateKey) {
+    return false;
+  }
+
+  const normalizedTemplate = normalizeTemplateKey(templateKey);
+
+  if (rule.match) {
+    return normalizeTemplateKey(rule.match) === normalizedTemplate;
+  }
+
+  if (rule.matchPrefix) {
+    const normalizedPrefix = normalizeTemplateKey(rule.matchPrefix);
+    const prefixWithSlash = normalizedPrefix.endsWith("/")
+      ? normalizedPrefix
+      : `${normalizedPrefix}/`;
+    return normalizedTemplate.startsWith(prefixWithSlash);
+  }
+
+  return false;
+}
+
+function collectOptionalPackages(rules, templateKey) {
+  if (!rules || !Array.isArray(rules.rules)) {
+    return [];
+  }
+
+  const collected = [];
+  const seen = new Set();
+
+  rules.rules.forEach((rule) => {
+    if (!matchOptionalRule(rule, templateKey)) {
+      return;
+    }
+
+    if (!Array.isArray(rule.packages)) {
+      return;
+    }
+
+    rule.packages.forEach((pkg) => {
+      if (!pkg || !pkg.name || typeof pkg.name !== "string") {
+        return;
+      }
+      if (seen.has(pkg.name)) {
+        return;
+      }
+      seen.add(pkg.name);
+      collected.push({
+        name: pkg.name,
+        dev: Boolean(pkg.dev),
+        version: pkg.version,
+        description: pkg.description,
+      });
+    });
   });
 
-  const answer = await rl.question("Select a template number: ");
-  rl.close();
+  return collected;
+}
+
+async function promptOptionalPackages(optionalPackages) {
+  if (!isInteractive() || optionalPackages.length === 0) {
+    return [];
+  }
+
+  const choices = optionalPackages.map((pkg) => ({
+    title: `${pkg.name}${pkg.dev ? " (dev)" : ""}${
+      pkg.description ? ` - ${pkg.description}` : ""
+    }`,
+    value: pkg.name,
+  }));
+
+  const response = await prompts(
+    {
+      type: "multiselect",
+      name: "selected",
+      message: "Select optional packages:",
+      choices,
+    },
+    {
+      onCancel: () => {
+        throw new Error(PROMPT_CANCELLED_MESSAGE);
+      },
+    }
+  );
 
-  const choice = Number.parseInt(answer.trim(), 10);
-  if (!Number.isInteger(choice) || choice < 1 || choice > templates.length) {
-    throw new Error("Invalid template selection.");
+  const selected = Array.isArray(response.selected) ? response.selected : [];
+  if (selected.length === 0) {
+    return [];
   }
 
-  return templates[choice - 1];
+  const selectedSet = new Set(selected);
+  return optionalPackages.filter((pkg) => selectedSet.has(pkg.name));
 }
 
-async function promptTargetDir() {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await rl.question("Project folder name: ");
-  rl.close();
-  const trimmed = answer.trim();
-  if (!trimmed) {
-    throw new Error("Project folder name is required.");
+function buildTemplateTree(templates) {
+  const root = { name: "", children: new Map(), template: null };
+  templates.forEach((template) => {
+    const parts = template.key.split("/");
+    let node = root;
+    parts.forEach((part, index) => {
+      if (!node.children.has(part)) {
+        node.children.set(part, {
+          name: part,
+          children: new Map(),
+          template: null,
+        });
+      }
+      node = node.children.get(part);
+      if (index === parts.length - 1) {
+        node.template = template;
+      }
+    });
+  });
+  return root;
+}
+
+async function promptSelectTemplateTree(templates) {
+  assertInteractive();
+  const tree = buildTemplateTree(templates);
+  const parents = [];
+  let current = tree;
+
+  while (true) {
+    const choices = Array.from(current.children.values())
+      .sort((left, right) => left.name.localeCompare(right.name))
+      .map((node) => ({
+        title: node.name,
+        value: node.name,
+      }));
+
+    if (parents.length > 0) {
+      choices.unshift({ title: "<- Back", value: PROMPT_BACK_VALUE });
+    }
+
+    const { selection } = await prompts(
+      {
+        type: "select",
+        name: "selection",
+        message:
+          parents.length === 0
+            ? "Select a template category:"
+            : "Select a folder:",
+        choices,
+      },
+      {
+        onCancel: () => {
+          throw new Error(PROMPT_CANCELLED_MESSAGE);
+        },
+      }
+    );
+
+    if (!selection) {
+      throw new Error("Invalid template selection.");
+    }
+
+    if (selection === PROMPT_BACK_VALUE) {
+      current = parents.pop();
+      continue;
+    }
+
+    const next = current.children.get(selection);
+    if (!next) {
+      throw new Error("Invalid template selection.");
+    }
+
+    if (next.template) {
+      return next.template;
+    }
+
+    parents.push(current);
+    current = next;
   }
-  return trimmed;
+}
+
+async function promptTargetDir() {
+  assertInteractive();
+  const response = await prompts(
+    {
+      type: "text",
+      name: "targetDir",
+      message: "Project folder name:",
+      validate: (value) =>
+        value && value.trim().length > 0
+          ? true
+          : "Project folder name is required.",
+    },
+    {
+      onCancel: () => {
+        throw new Error(PROMPT_CANCELLED_MESSAGE);
+      },
+    }
+  );
+  return response.targetDir.trim();
 }
 
 async function ensureEmptyDir(targetDir) {
@@ -166,6 +364,56 @@ async function copyDir(sourceDir, targetDir) {
   }
 }
 
+async function applyOptionalPackages(targetPath, packages) {
+  if (!packages || packages.length === 0) {
+    return;
+  }
+
+  const packageJsonPath = path.join(targetPath, "package.json");
+  const raw = await readFile(packageJsonPath, "utf8");
+  const pkgJson = JSON.parse(raw);
+
+  const hadDependencies = Object.prototype.hasOwnProperty.call(
+    pkgJson,
+    "dependencies"
+  );
+  const hadDevDependencies = Object.prototype.hasOwnProperty.call(
+    pkgJson,
+    "devDependencies"
+  );
+
+  const dependencies = hadDependencies ? { ...pkgJson.dependencies } : {};
+  const devDependencies = hadDevDependencies ? { ...pkgJson.devDependencies } : {};
+
+  let changed = false;
+
+  packages.forEach((pkg) => {
+    if (dependencies[pkg.name] || devDependencies[pkg.name]) {
+      return;
+    }
+    const version = pkg.version || "latest";
+    if (pkg.dev) {
+      devDependencies[pkg.name] = version;
+    } else {
+      dependencies[pkg.name] = version;
+    }
+    changed = true;
+  });
+
+  if (!changed) {
+    return;
+  }
+
+  if (hadDependencies || Object.keys(dependencies).length > 0) {
+    pkgJson.dependencies = dependencies;
+  }
+  if (hadDevDependencies || Object.keys(devDependencies).length > 0) {
+    pkgJson.devDependencies = devDependencies;
+  }
+
+  await writeFile(packageJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
+}
+
 export async function scaffold({ templateKey, targetDir }) {
   let repoDir = null;
   let tempDir = null;
@@ -215,14 +463,25 @@ export async function scaffold({ templateKey, targetDir }) {
       throw new Error(`Template not found. Available: ${keys}`);
     }
   } else {
-    selectedTemplate = await promptSelectTemplate(templates);
+    selectedTemplate = await promptSelectTemplateTree(templates);
   }
 
+  const optionalRules = await loadOptionalPackageRules();
+  const optionalPackages = collectOptionalPackages(
+    optionalRules,
+    selectedTemplate.key
+  );
+  const selectedOptionalPackages =
+    optionalPackages.length > 0
+      ? await promptOptionalPackages(optionalPackages)
+      : [];
+
   const resolvedTargetDir = targetDir || (await promptTargetDir());
   const targetPath = path.resolve(process.cwd(), resolvedTargetDir);
 
   await ensureEmptyDir(targetPath);
   await copyDir(selectedTemplate.dir, targetPath);
+  await applyOptionalPackages(targetPath, selectedOptionalPackages);
 
   if (tempDir) {
     await rm(tempDir, { recursive: true, force: true });

package/optional-packages.json

@@ -0,0 +1,30 @@
+{
+  "rules": [
+    {
+      "match": "backend/express/express-no-ts",
+      "packages": [
+        {
+          "name": "sequelize",
+          "dev": false
+        },
+        {
+          "name": "mysql2",
+          "dev": false
+        }
+      ]
+    },
+    {
+      "matchPrefix": "front/web/vue3/",
+      "packages": [
+        {
+          "name": "axios",
+          "dev": false
+        },
+        {
+          "name": "eslint",
+          "dev": true
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guchen_0521/create-temp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Project scaffolding CLI (templates pulled from GitHub)",
   "type": "module",
   "bin": {
@@ -9,10 +9,14 @@
   "files": [
     "bin",
     "lib",
+    "optional-packages.json",
     "README.md",
     "LICENSE"
   ],
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
   }
 }