@guchen_0521/create-temp 0.1.6 → 0.1.7

package/lib/scaffold.js

@@ -3,8 +3,10 @@ import {
   mkdir,
   mkdtemp,
   readdir,
+  readFile,
   rm,
   stat,
+  writeFile,
 } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -29,6 +31,10 @@ 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) {
@@ -38,6 +44,10 @@ function assertInteractive() {
   }
 }
 
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
 async function cloneTemplateRepo() {
   const tempDir = await mkdtemp(path.join(os.tmpdir(), "template-cli-"));
   const repoDir = path.join(tempDir, `repo-${Date.now().toString(36)}`);
@@ -111,6 +121,112 @@ function normalizeTemplateKey(templateKey) {
     .replace(/^\.\/+/, "");
 }
 
+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,
+      });
+    });
+  });
+
+  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 selected = Array.isArray(response.selected) ? response.selected : [];
+  if (selected.length === 0) {
+    return [];
+  }
+
+  const selectedSet = new Set(selected);
+  return optionalPackages.filter((pkg) => selectedSet.has(pkg.name));
+}
+
 function buildTemplateTree(templates) {
   const root = { name: "", children: new Map(), template: null };
   templates.forEach((template) => {
@@ -248,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;
@@ -300,11 +466,22 @@ export async function scaffold({ templateKey, targetDir }) {
     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.6",
+  "version": "0.1.7",
   "description": "Project scaffolding CLI (templates pulled from GitHub)",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin",
     "lib",
+    "optional-packages.json",
     "README.md",
     "LICENSE"
   ],