@guchen_0521/create-temp 0.1.0

package/README.md

@@ -0,0 +1,35 @@
+# create-temp
+
+Local template scaffolding CLI for this repository. It clones the latest
+templates from GitHub on each run (SSH access required).
+
+## Usage
+
+```bash
+npm link
+create-temp
+```
+
+Or pass args directly:
+
+```bash
+create-temp backend/express/express-no-ts my-api
+create-temp front/web/vue3/vue3-no-ts my-web
+```
+
+Use with npm create:
+
+```bash
+npm create @guchen_0521/temp@latest -- backend/express/express-no-ts my-api
+```
+
+## Requirements
+
+- Git installed and available in PATH
+- SSH access to `ssh://git@ssh.github.com:443/GuChena/template.git`
+
+## Publish
+
+```bash
+npm publish --access public
+```

package/bin/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { scaffold } from "../lib/scaffold.js";
+
+const args = process.argv.slice(2);
+const [templateArg, targetArg] = args;
+
+try {
+  await scaffold({
+    templateKey: templateArg,
+    targetDir: targetArg,
+  });
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+}

package/lib/scaffold.js

@@ -0,0 +1,207 @@
+import {
+  copyFile,
+  mkdir,
+  mkdtemp,
+  readdir,
+  rm,
+  stat,
+} 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";
+
+const IGNORE_NAMES = new Set([
+  ".git",
+  "node_modules",
+  ".DS_Store",
+  ".pnpm",
+  ".pnpm-store",
+]);
+
+const execFileAsync = promisify(execFile);
+const TEMPLATE_REPO_SSH = "ssh://git@ssh.github.com:443/GuChena/template.git";
+
+async function cloneTemplateRepo() {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "template-cli-"));
+  const repoDir = path.join(tempDir, `repo-${Date.now().toString(36)}`);
+
+  await execFileAsync("git", [
+    "clone",
+    "--depth",
+    "1",
+    TEMPLATE_REPO_SSH,
+    repoDir,
+  ]);
+
+  return { repoDir, tempDir };
+}
+
+async function findTemplateDirs(rootDir) {
+  const results = [];
+  const entries = await readdir(rootDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || IGNORE_NAMES.has(entry.name)) {
+      continue;
+    }
+
+    const fullPath = path.join(rootDir, entry.name);
+    const packageJsonPath = path.join(fullPath, "package.json");
+    try {
+      const info = await stat(packageJsonPath);
+      if (info.isFile()) {
+        results.push(fullPath);
+        continue;
+      }
+    } catch {
+      // Not a template root; keep searching.
+    }
+
+    const nested = await findTemplateDirs(fullPath);
+    results.push(...nested);
+  }
+
+  return results;
+}
+
+function formatTemplateKey(projectRoot, templateDir) {
+  return path
+    .relative(projectRoot, templateDir)
+    .split(path.sep)
+    .join("/");
+}
+
+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}`);
+  });
+
+  const answer = await rl.question("Select a template number: ");
+  rl.close();
+
+  const choice = Number.parseInt(answer.trim(), 10);
+  if (!Number.isInteger(choice) || choice < 1 || choice > templates.length) {
+    throw new Error("Invalid template selection.");
+  }
+
+  return templates[choice - 1];
+}
+
+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.");
+  }
+  return trimmed;
+}
+
+async function ensureEmptyDir(targetDir) {
+  try {
+    const items = await readdir(targetDir);
+    if (items.length > 0) {
+      throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      await mkdir(targetDir, { recursive: true });
+      return;
+    }
+    throw error;
+  }
+}
+
+async function copyDir(sourceDir, targetDir) {
+  await mkdir(targetDir, { recursive: true });
+  const entries = await readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (IGNORE_NAMES.has(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDir(sourcePath, targetPath);
+    } else if (entry.isFile()) {
+      await mkdir(path.dirname(targetPath), { recursive: true });
+      await copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+export async function scaffold({ templateKey, targetDir }) {
+  let repoDir = null;
+  let tempDir = null;
+  try {
+    const cloneResult = await cloneTemplateRepo();
+    repoDir = cloneResult.repoDir;
+    tempDir = cloneResult.tempDir;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to clone template repo. Ensure SSH access works. ${message}`
+    );
+  }
+
+  const templateRoots = [
+    path.join(repoDir, "backend"),
+    path.join(repoDir, "front"),
+  ];
+
+  const templates = [];
+  for (const root of templateRoots) {
+    try {
+      const dirs = await findTemplateDirs(root);
+      dirs.forEach((dir) => {
+        templates.push({
+          key: formatTemplateKey(repoDir, dir),
+          dir,
+        });
+      });
+    } catch {
+      // Missing template root is fine.
+    }
+  }
+
+  if (templates.length === 0) {
+    throw new Error("No templates found under backend/ or front/.");
+  }
+
+  let selectedTemplate = null;
+  if (templateKey) {
+    selectedTemplate = templates.find(
+      (template) => template.key === templateKey
+    );
+    if (!selectedTemplate) {
+      const keys = templates.map((template) => template.key).join(", ");
+      throw new Error(`Template not found. Available: ${keys}`);
+    }
+  } else {
+    selectedTemplate = await promptSelectTemplate(templates);
+  }
+
+  const resolvedTargetDir = targetDir || (await promptTargetDir());
+  const targetPath = path.resolve(process.cwd(), resolvedTargetDir);
+
+  await ensureEmptyDir(targetPath);
+  await copyDir(selectedTemplate.dir, targetPath);
+
+  if (tempDir) {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+
+  console.log(`Created project in ${targetPath}`);
+  console.log("Next steps:");
+  console.log(`  cd ${resolvedTargetDir}`);
+  console.log("  npm install");
+  console.log("  npm run dev");
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@guchen_0521/create-temp",
+  "version": "0.1.0",
+  "description": "Project scaffolding CLI (templates pulled from GitHub)",
+  "type": "module",
+  "bin": {
+    "create-temp": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}