@navneet_25/tempjs 1.0.4 → 2.0.0

package/cli/file-tree.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { shouldSkipPath } from "./fs-ignore.js";
+
+/**
+ * @param {string} filePath
+ * @returns {string}
+ */
+export function hashFileContents(filePath) {
+  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+
+/**
+ * @param {string} rootDir
+ * @returns {Record<string, string>}
+ */
+export function collectFileHashes(rootDir) {
+  const hashes = {};
+  collectRecursive(rootDir, rootDir, hashes);
+  return hashes;
+}
+
+/**
+ * @param {string} rootDir
+ * @param {string} currentDir
+ * @param {Record<string, string>} hashes
+ */
+function collectRecursive(rootDir, currentDir, hashes) {
+  if (!existsSync(currentDir)) return;
+
+  for (const name of readdirSync(currentDir)) {
+    const fullPath = join(currentDir, name);
+    const relPath = relative(rootDir, fullPath).replace(/\\/g, "/");
+
+    if (shouldSkipPath(relPath, name)) continue;
+
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      collectRecursive(rootDir, fullPath, hashes);
+    } else {
+      hashes[relPath] = hashFileContents(fullPath);
+    }
+  }
+}
+
+/**
+ * @param {string} rootDir
+ * @returns {number}
+ */
+export function countFiles(rootDir) {
+  return Object.keys(collectFileHashes(rootDir)).length;
+}
+
+/**
+ * @typedef {{
+ *   newFiles: string[],
+ *   upToDate: string[],
+ *   safeUpdates: string[],
+ *   conflicts: string[],
+ *   protectedSkips: string[],
+ *   removedFromTemplate: string[]
+ * }} UpdateDiff
+ */
+
+/**
+ * Compare project against baseline (at generation) and latest template hashes.
+ * @param {Record<string, string>} baselineHashes
+ * @param {Record<string, string>} currentHashes
+ * @param {Record<string, string>} latestHashes
+ * @returns {UpdateDiff}
+ */
+export function diffTemplateTrees(baselineHashes, currentHashes, latestHashes) {
+  const diff = {
+    newFiles: [],
+    upToDate: [],
+    safeUpdates: [],
+    conflicts: [],
+    protectedSkips: [],
+    removedFromTemplate: [],
+  };
+
+  for (const path of Object.keys(latestHashes).sort()) {
+    const latest = latestHashes[path];
+    const current = currentHashes[path];
+    const baseline = baselineHashes[path];
+
+    if (current === undefined) {
+      diff.newFiles.push(path);
+      continue;
+    }
+
+    if (current === latest) {
+      diff.upToDate.push(path);
+      continue;
+    }
+
+    if (baseline !== undefined && current === baseline && latest !== baseline) {
+      diff.safeUpdates.push(path);
+      continue;
+    }
+
+    diff.conflicts.push(path);
+  }
+
+  for (const path of Object.keys(baselineHashes).sort()) {
+    if (!latestHashes[path]) {
+      diff.removedFromTemplate.push(path);
+    }
+  }
+
+  return diff;
+}

package/cli/fs-ignore.js

@@ -0,0 +1,60 @@
+/** Files and directories never copied from templates or merged on update. */
+export const NEVER_COPY_NAMES = new Set([".git", ".gitignore.bak"]);
+
+/** Paths relative to project root that must not be overwritten by template update. */
+export const UPDATE_PROTECTED_PATHS = new Set([
+  ".env",
+  ".tempjsrc",
+  ".tempjs.json",
+  "constants/site.ts",
+  "app/tempjs-theme.css",
+]);
+
+/** Directory names skipped when walking trees. */
+export const SKIP_DIR_NAMES = new Set([
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+]);
+
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function shouldSkipFileName(name) {
+  if (NEVER_COPY_NAMES.has(name)) return true;
+  if (name === ".env" || name.startsWith(".env.")) {
+    return name !== ".env.example";
+  }
+  return false;
+}
+
+/**
+ * @param {string} relativePath
+ * @param {string} [name]
+ * @returns {boolean}
+ */
+export function shouldSkipPath(relativePath, name) {
+  const base = name ?? relativePath.split("/").pop() ?? "";
+  if (shouldSkipFileName(base)) return true;
+
+  const parts = relativePath.split("/");
+  for (const part of parts) {
+    if (SKIP_DIR_NAMES.has(part)) return true;
+  }
+  return false;
+}
+
+/**
+ * @param {string} relativePath
+ * @returns {boolean}
+ */
+export function isUpdateProtected(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (UPDATE_PROTECTED_PATHS.has(normalized)) return true;
+  if (normalized.startsWith(".env.") && normalized !== ".env.example") return true;
+  return false;
+}

package/cli/index.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 
 import { execSync } from "node:child_process";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
 import { loadManifest, getPackageRoot, resolveRepositoryConfig } from "./config.js";
 import {
   promptTheme,
@@ -10,53 +8,71 @@ import {
   applyThemeAndFont,
   getSavedConfig,
 } from "./theme-manager.js";
+import { promptAndApplyBrand } from "./brand-manager.js";
+import { promptAndSetupDb } from "./db-setup.js";
+import { printTemplateInfo } from "./info.js";
+import { parseArgs, toCliOptions } from "./parse-args.js";
 import {
   copyTemplate,
   findConflictingPaths,
   isDirectoryEmpty,
   listDirectoryEntries,
-  removeDirectory,
   targetHasGitRepo,
 } from "./copy.js";
-import { fetchTemplateFromGitHub, resolveLocalTemplate } from "./fetch.js";
+import { writeProjectStamp } from "./project-stamp.js";
+import { printFetchComplete } from "./progress.js";
+import { confirmYesNo } from "./prompt.js";
+import { resolveTemplateSource } from "./template-resolver.js";
+import { runUpdate } from "./update.js";
 
 const HELP_TEXT = `
 tempjs — instantiate project templates from GitHub
 
 USAGE
   tempjs list
+  tempjs info <template-id>
   tempjs <template-id> [options]
-  tempjs <template-id> config     Initialize with interactive theme & typography setup
-  tempjs theme                    Change the project's theme in an initialized directory
-  tempjs font                     Change the project's font styling in an initialized directory
+  tempjs <template-id> config     Interactive theme, typography, brand & database setup
+  tempjs update [--check | --merge]
+  tempjs theme                    Change theme in an initialized project
+  tempjs font                     Change font styling in an initialized project
+  tempjs brand                    Configure brand & contact info
+  tempjs init-db                  Configure .env and sync database schema
   tempjs --help
 
+UPDATE
+  tempjs update --check           Show diff vs latest template (read-only)
+  tempjs update --merge           Apply non-conflicting template updates only
+  tempjs update --merge --yes     Apply without confirmation prompt
+
 OPTIONS
-  --config      Prompt for theme and font pairings during initialization
-  --force       Overwrite existing files in the current directory
-  --remote      Fetch from GitHub even if a local template copy exists
-  --init-git    Run git init after copying the template
-  --help        Show this help message
+  --config          Run full setup (theme, font, brand, database) after copying
+  --yes, -y         Skip all prompts
+  --no-prompt       Same as --yes
+  --force, -f       Overwrite existing files without prompting
+  --remote          Fetch from GitHub even if a local template copy exists
+  --init-git        Run git init after copying the template
+
+  (See tempjs --help for theme, brand, and database flags.)
 
 EXAMPLES
   mkdir hotel-client && cd hotel-client
   tempjs hotel config
-  tempjs theme
+
+  tempjs update --check
+  tempjs update --merge --yes
 
 ENVIRONMENT
-  TEMPLATES_REPO_URL       GitHub repo URL or owner/repo (overrides templates.json)
+  TEMPLATES_REPO_URL       GitHub repo URL or owner/repo
   TEMPLATES_REPO_OWNER     GitHub owner/username
   TEMPLATES_REPO_REPO      GitHub repository name
   TEMPLATES_REPO_BRANCH    Branch name (default: main)
   TEMPLATE_USE_REMOTE=1    Always fetch from GitHub
-  GITHUB_TOKEN / GH_TOKEN    Optional — required only for private repositories
-
-CONFIGURATION
-  Repository and template mappings live in templates.json at the package root.
+  GITHUB_TOKEN / GH_TOKEN  Optional — private repositories only
 `;
 
 /**
- * @param {Record<string, { name: string, description: string }>} templates
+ * @param {Record<string, import('./config.js').TemplateEntry>} templates
  */
 function printTemplateList(templates) {
   console.log("Available templates:\n");
@@ -65,41 +81,20 @@ function printTemplateList(templates) {
 
   for (const id of ids) {
     const entry = templates[id];
-    console.log(`${id.padEnd(idWidth + 2)}${entry.name}`);
+    const version = entry.version ? ` v${entry.version}` : "";
+    console.log(`${id.padEnd(idWidth + 2)}${entry.name}${version}`);
     if (entry.description) {
       console.log(`${"".padEnd(idWidth + 2)}${entry.description}`);
     }
-  }
-  console.log("");
-}
-
-/**
- * @param {string[]} argv
- */
-function parseArgs(argv) {
-  const flags = {
-    force: false,
-    remote: false,
-    initGit: false,
-    help: false,
-    config: false,
-  };
-  const positionals = [];
-
-  for (const arg of argv) {
-    if (arg === "--force") flags.force = true;
-    else if (arg === "--remote") flags.remote = true;
-    else if (arg === "--init-git") flags.initGit = true;
-    else if (arg === "--help" || arg === "-h") flags.help = true;
-    else if (arg === "--config") flags.config = true;
-    else if (arg.startsWith("-")) {
-      throw new Error(`Unknown option: ${arg}`);
-    } else {
-      positionals.push(arg);
+    if (entry.tags?.length) {
+      console.log(`${"".padEnd(idWidth + 2)}[${entry.tags.join(", ")}]`);
+    }
+    if (entry.stack?.length) {
+      console.log(`${"".padEnd(idWidth + 2)}${entry.stack.slice(0, 4).join(" · ")}`);
     }
   }
-
-  return { flags, positionals };
+  console.log("");
+  console.log("Run `tempjs info <template-id>` for full details.\n");
 }
 
 /**
@@ -118,24 +113,10 @@ function printConflictWarning(conflicts) {
   console.log("");
 }
 
-/**
- * @param {boolean} force
- */
-async function confirmOverwrite(force) {
-  if (force) return true;
-  const rl = createInterface({ input, output });
-  try {
-    const answer = await rl.question("Continue? [y/N] ");
-    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
-  } finally {
-    rl.close();
-  }
-}
-
 /**
  * @param {string} targetDir
  * @param {string} templateId
- * @param {{ force: boolean, remote: boolean, initGit: boolean }} flags
+ * @param {import('./parse-args.js').CliFlags} flags
  * @param {boolean} runWithConfig
  */
 async function runTemplate(targetDir, templateId, flags, runWithConfig = false) {
@@ -151,30 +132,22 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
 
   const repo = resolveRepositoryConfig(manifest.repository);
   const packageRoot = getPackageRoot();
+  const cliOptions = toCliOptions(flags);
   const useRemote =
     flags.remote ||
     process.env.TEMPLATE_USE_REMOTE === "1" ||
     process.env.TEMPLATE_USE_REMOTE === "true";
 
-  let sourceDir = null;
-  let cleanupDir = null;
+  let resolved = null;
 
   try {
-    if (!useRemote) {
-      sourceDir = await resolveLocalTemplate(
-        packageRoot,
-        repo.templatesPath,
-        entry.directory
-      );
-    }
-
-    if (!sourceDir) {
-      console.log(`Fetching template "${templateId}" from ${repo.owner}/${repo.repo}...`);
-      sourceDir = await fetchTemplateFromGitHub(repo, entry.directory);
-      cleanupDir = sourceDir.replace(/[/\\]template$/, "");
-    } else {
-      console.log(`Using local template "${templateId}"...`);
-    }
+    resolved = await resolveTemplateSource({
+      repo,
+      packageRoot,
+      templateDirectory: entry.directory,
+      useRemote,
+    });
+    printFetchComplete({ templateId, stats: resolved.stats });
 
     if (targetHasGitRepo(targetDir)) {
       console.warn(
@@ -184,19 +157,20 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
 
     const entries = listDirectoryEntries(targetDir);
     const hasContent = entries.length > 0;
+    const autoConfirm = flags.force || flags.yes;
 
     if (hasContent && !flags.force) {
-      const conflicts = findConflictingPaths(sourceDir, targetDir);
+      const conflicts = findConflictingPaths(resolved.templateRoot, targetDir);
       if (conflicts.length > 0) {
         printConflictWarning(conflicts);
-        const confirmed = await confirmOverwrite(false);
+        const confirmed = await confirmYesNo("Continue? [y/N] ", autoConfirm);
         if (!confirmed) {
           console.log("Aborted.");
           return;
         }
       } else if (!isDirectoryEmpty(targetDir)) {
         console.log("Current directory is not empty, but no files would be overwritten.");
-        const confirmed = await confirmOverwrite(false);
+        const confirmed = await confirmYesNo("Continue? [y/N] ", autoConfirm);
         if (!confirmed) {
           console.log("Aborted.");
           return;
@@ -205,7 +179,17 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
     }
 
     const allowOverwrite = flags.force || hasContent;
-    copyTemplate(sourceDir, targetDir, { force: allowOverwrite });
+    copyTemplate(resolved.templateRoot, targetDir, { force: allowOverwrite });
+
+    await writeProjectStamp(targetDir, {
+      templateId,
+      templateVersion: entry.version ?? "0.0.0",
+      templateDirectory: entry.directory,
+      repository: `${repo.owner}/${repo.repo}`,
+      branch: repo.branch,
+      sourceDir: resolved.templateRoot,
+      isUpdate: false,
+    });
 
     if (flags.initGit && !targetHasGitRepo(targetDir)) {
       execSync("git init", { cwd: targetDir, stdio: "inherit" });
@@ -213,12 +197,16 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
 
     if (runWithConfig) {
       console.log("\nConfiguring project theme and typography...");
-      const selectedTheme = await promptTheme("theme1");
-      const selectedFont = await promptFont("default");
+      const selectedTheme = await promptTheme("theme1", cliOptions);
+      const selectedFont = await promptFont("default", cliOptions);
       await applyThemeAndFont(targetDir, selectedTheme, selectedFont);
+
+      await promptAndApplyBrand(targetDir, cliOptions);
+      await promptAndSetupDb(targetDir, cliOptions);
     }
 
     console.log(`\nTemplate "${entry.name}" created successfully in ${targetDir}`);
+    console.log(`Stamped .tempjs.json (template v${entry.version ?? "0.0.0"})`);
     console.log("\nNext steps:");
     console.log("  pnpm install   # or npm install");
     console.log("  pnpm dev       # start development server");
@@ -236,8 +224,8 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
     console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
     process.exitCode = 1;
   } finally {
-    if (cleanupDir) {
-      removeDirectory(cleanupDir);
+    if (resolved) {
+      resolved.release();
     }
   }
 }
@@ -247,29 +235,87 @@ async function runTemplate(targetDir, templateId, flags, runWithConfig = false)
  */
 async function main(argv) {
   const { flags, positionals } = parseArgs(argv);
-  let command = positionals[0];
+  const command = positionals[0];
 
   if (flags.help || command === "help" || (!command && argv.length === 0)) {
     console.log(HELP_TEXT.trim());
     return;
   }
 
-  if (command === "theme" || command === "font") {
+  const manifest = loadManifest();
+  const repo = resolveRepositoryConfig(manifest.repository);
+  const cliOptions = toCliOptions(flags);
+
+  if (command === "list") {
+    printTemplateList(manifest.templates);
+    return;
+  }
+
+  if (command === "info") {
+    const templateId = positionals[1];
+    if (!templateId) {
+      console.error("Usage: tempjs info <template-id>");
+      console.error("Run `tempjs list` to see available templates.");
+      process.exitCode = 1;
+      return;
+    }
+    const entry = manifest.templates[templateId];
+    if (!entry) {
+      console.error(`Unknown template: ${templateId}`);
+      console.error("Run `tempjs list` to see available templates.");
+      process.exitCode = 1;
+      return;
+    }
+    printTemplateInfo(templateId, entry, repo);
+    return;
+  }
+
+  if (command === "update") {
+    const hasCheck = flags.updateCheck || argv.includes("--check");
+    const hasMerge = flags.updateMerge || argv.includes("--merge");
+
+    if (!hasCheck && !hasMerge) {
+      console.error("Usage: tempjs update --check | tempjs update --merge [--yes]");
+      process.exitCode = 1;
+      return;
+    }
+
+    const targetDir = process.cwd();
+    await runUpdate(targetDir, flags, { checkOnly: hasCheck && !hasMerge });
+    return;
+  }
+
+  if (
+    command === "theme" ||
+    command === "font" ||
+    command === "brand" ||
+    command === "init-db"
+  ) {
     const targetDir = process.cwd();
     const currentConfig = getSavedConfig(targetDir);
 
     if (command === "theme") {
-      const selectedTheme = await promptTheme(currentConfig.theme || "theme1");
-      await applyThemeAndFont(targetDir, selectedTheme, currentConfig.font || "default");
-    } else {
-      const selectedFont = await promptFont(currentConfig.font || "default");
-      await applyThemeAndFont(targetDir, currentConfig.theme || "theme1", selectedFont);
+      const selectedTheme = await promptTheme(currentConfig.theme || "theme1", cliOptions);
+      const selectedFont = await promptFont(currentConfig.font || "default", {
+        ...cliOptions,
+        yes: cliOptions.yes || Boolean(cliOptions.font),
+      });
+      await applyThemeAndFont(targetDir, selectedTheme, selectedFont);
+    } else if (command === "font") {
+      const selectedFont = await promptFont(currentConfig.font || "default", cliOptions);
+      await applyThemeAndFont(
+        targetDir,
+        currentConfig.theme || "theme1",
+        selectedFont
+      );
+    } else if (command === "brand") {
+      await promptAndApplyBrand(targetDir, cliOptions);
+    } else if (command === "init-db") {
+      await promptAndSetupDb(targetDir, cliOptions);
     }
     return;
   }
 
-  const manifest = loadManifest();
-
   let runWithConfig = flags.config;
   if (positionals.length >= 2 && positionals[1] === "config") {
     runWithConfig = true;

package/cli/info.js

@@ -0,0 +1,88 @@
+import { loadManifest, resolveRepositoryConfig } from "./config.js";
+
+/**
+ * @param {string} templateId
+ * @param {import('./config.js').TemplateEntry} entry
+ * @param {import('./config.js').RepositoryConfig} repo
+ */
+export function printTemplateInfo(templateId, entry, repo) {
+  const lines = [];
+
+  lines.push(`${entry.name} (${templateId})`);
+  lines.push("=".repeat(Math.min(60, entry.name.length + templateId.length + 4)));
+  lines.push("");
+
+  if (entry.description) {
+    lines.push(entry.description);
+    lines.push("");
+  }
+
+  if (entry.version) {
+    lines.push(`Version:          ${entry.version}`);
+  }
+
+  if (entry.stack?.length) {
+    lines.push(`Stack:            ${entry.stack.join(", ")}`);
+  }
+
+  if (entry.node) {
+    lines.push(`Node.js:          ${entry.node}`);
+  }
+
+  if (entry.packageManager) {
+    lines.push(`Package manager:  ${entry.packageManager}`);
+  }
+
+  if (entry.setupTime) {
+    lines.push(`Typical setup:    ${entry.setupTime}`);
+  }
+
+  if (entry.docker !== undefined) {
+    lines.push(`Docker support:   ${entry.docker ? "Yes (docker-compose.yml)" : "No"}`);
+  }
+
+  if (entry.tags?.length) {
+    lines.push(`Tags:             ${entry.tags.join(", ")}`);
+  }
+
+  lines.push(`Source directory: ${repo.templatesPath}/${entry.directory}`);
+  lines.push(`Repository:       github.com/${repo.owner}/${repo.repo} (${repo.branch})`);
+
+  if (entry.features?.length) {
+    lines.push("");
+    lines.push("Features:");
+    for (const feature of entry.features) {
+      lines.push(`  • ${feature}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("Quick start:");
+  lines.push(`  mkdir my-project && cd my-project`);
+  lines.push(`  tempjs ${templateId} config`);
+  lines.push(`  pnpm install && pnpm dev`);
+  lines.push("");
+  lines.push("Non-interactive:");
+  lines.push(
+    `  tempjs ${templateId} --config --yes --theme theme1 --name "My Brand" --db-host localhost`
+  );
+
+  if (entry.docs) {
+    lines.push("");
+    lines.push(`Docs in generated project: ${entry.docs}`);
+  }
+
+  console.log(lines.join("\n"));
+}
+
+/**
+ * @param {Record<string, import('./config.js').TemplateEntry>} templates
+ * @param {import('./config.js').RepositoryConfig} repo
+ */
+export function printAllTemplatesInfo(templates, repo) {
+  const ids = Object.keys(templates).sort();
+  for (let i = 0; i < ids.length; i++) {
+    if (i > 0) console.log("\n");
+    printTemplateInfo(ids[i], templates[ids[i]], repo);
+  }
+}