@navneet_25/tempjs 1.0.4 → 2.0.0

package/cli/parse-args.js

@@ -0,0 +1,156 @@
+/**
+ * @typedef {ReturnType<typeof createDefaultFlags>} CliFlags
+ */
+
+export function createDefaultFlags() {
+  return {
+    force: false,
+    remote: false,
+    initGit: false,
+    help: false,
+    config: false,
+    yes: false,
+    theme: undefined,
+    font: undefined,
+    name: undefined,
+    shortName: undefined,
+    baseUrl: undefined,
+    phone: undefined,
+    phoneDisplay: undefined,
+    countryCode: undefined,
+    email: undefined,
+    address: undefined,
+    dbHost: undefined,
+    dbPort: undefined,
+    dbUser: undefined,
+    dbPassword: undefined,
+    dbName: undefined,
+    adminUser: undefined,
+    adminPassword: undefined,
+    skipDbPush: false,
+    dbPush: false,
+    updateCheck: false,
+    updateMerge: false,
+  };
+}
+
+const FLAG_MAP = {
+  "--force": { key: "force", type: "boolean" },
+  "-f": { key: "force", type: "boolean" },
+  "--remote": { key: "remote", type: "boolean" },
+  "--init-git": { key: "initGit", type: "boolean" },
+  "--help": { key: "help", type: "boolean" },
+  "-h": { key: "help", type: "boolean" },
+  "--config": { key: "config", type: "boolean" },
+  "--yes": { key: "yes", type: "boolean" },
+  "-y": { key: "yes", type: "boolean" },
+  "--no-prompt": { key: "yes", type: "boolean" },
+  "--skip-db-push": { key: "skipDbPush", type: "boolean" },
+  "--db-push": { key: "dbPush", type: "boolean" },
+  "--check": { key: "updateCheck", type: "boolean" },
+  "--merge": { key: "updateMerge", type: "boolean" },
+  "--theme": { key: "theme", type: "string" },
+  "--font": { key: "font", type: "string" },
+  "--name": { key: "name", type: "string" },
+  "--short-name": { key: "shortName", type: "string" },
+  "--base-url": { key: "baseUrl", type: "string" },
+  "--phone": { key: "phone", type: "string" },
+  "--phone-display": { key: "phoneDisplay", type: "string" },
+  "--country-code": { key: "countryCode", type: "string" },
+  "--email": { key: "email", type: "string" },
+  "--address": { key: "address", type: "string" },
+  "--db-host": { key: "dbHost", type: "string" },
+  "--db-port": { key: "dbPort", type: "string" },
+  "--db-user": { key: "dbUser", type: "string" },
+  "--db-password": { key: "dbPassword", type: "string" },
+  "--db-name": { key: "dbName", type: "string" },
+  "--admin-user": { key: "adminUser", type: "string" },
+  "--admin-password": { key: "adminPassword", type: "string" },
+};
+
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  const flags = createDefaultFlags();
+  const positionals = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg.includes("=") && arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      const flagName = arg.slice(0, eqIndex);
+      const value = arg.slice(eqIndex + 1);
+      applyFlag(flags, flagName, value);
+      continue;
+    }
+
+    const spec = FLAG_MAP[arg];
+    if (spec) {
+      if (spec.type === "boolean") {
+        flags[spec.key] = true;
+      } else {
+        const value = argv[++i];
+        if (!value || value.startsWith("-")) {
+          throw new Error(`Option ${arg} requires a value`);
+        }
+        flags[spec.key] = value;
+      }
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    positionals.push(arg);
+  }
+
+  return { flags, positionals };
+}
+
+/**
+ * @param {CliFlags} flags
+ * @param {string} flagName
+ * @param {string} value
+ */
+function applyFlag(flags, flagName, value) {
+  const spec = FLAG_MAP[flagName];
+  if (!spec) {
+    throw new Error(`Unknown option: ${flagName}`);
+  }
+  if (spec.type === "boolean") {
+    flags[spec.key] = value === "true" || value === "1";
+  } else {
+    flags[spec.key] = value;
+  }
+}
+
+/**
+ * @param {CliFlags} flags
+ */
+export function toCliOptions(flags) {
+  return {
+    yes: flags.yes,
+    theme: flags.theme,
+    font: flags.font,
+    name: flags.name,
+    shortName: flags.shortName,
+    baseUrl: flags.baseUrl,
+    phone: flags.phone,
+    phoneDisplay: flags.phoneDisplay,
+    countryCode: flags.countryCode,
+    email: flags.email,
+    address: flags.address,
+    dbHost: flags.dbHost,
+    dbPort: flags.dbPort,
+    dbUser: flags.dbUser,
+    dbPassword: flags.dbPassword,
+    dbName: flags.dbName,
+    adminUser: flags.adminUser,
+    adminPassword: flags.adminPassword,
+    skipDbPush: flags.skipDbPush,
+    dbPush: flags.dbPush,
+  };
+}

package/cli/progress.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * @param {number} ms
+ * @returns {string}
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+/**
+ * @param {{
+ *   templateId: string,
+ *   stats: { bytes: number, files: number, durationMs: number, source?: string }
+ * }} options
+ */
+export function printFetchComplete(options) {
+  const { templateId, stats } = options;
+  const sourceLabel = stats.source === "local" ? "local copy" : "download";
+  const sizePart = stats.bytes > 0 ? `${formatBytes(stats.bytes)}, ` : "";
+  console.log(
+    `Fetching template "${templateId}"... done (${sizePart}${stats.files} files, ${formatDuration(stats.durationMs)}, ${sourceLabel})`
+  );
+}

package/cli/project-stamp.js

@@ -0,0 +1,69 @@
+import { writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { collectFileHashes } from "./file-tree.js";
+
+export const STAMP_FILENAME = ".tempjs.json";
+
+/**
+ * @typedef {{
+ *   template: string,
+ *   templateVersion: string,
+ *   templateDirectory: string,
+ *   generatedAt: string,
+ *   updatedAt?: string,
+ *   repository?: string,
+ *   branch?: string,
+ *   fileHashes: Record<string, string>
+ * }} ProjectStamp
+ */
+
+/**
+ * @param {string} projectDir
+ * @returns {ProjectStamp | null}
+ */
+export function readProjectStamp(projectDir) {
+  const stampPath = join(projectDir, STAMP_FILENAME);
+  if (!existsSync(stampPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(stampPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} projectDir
+ * @param {{
+ *   templateId: string,
+ *   templateVersion: string,
+ *   templateDirectory: string,
+ *   repository?: string,
+ *   branch?: string,
+ *   sourceDir: string,
+ *   isUpdate?: boolean
+ * }} options
+ */
+export async function writeProjectStamp(projectDir, options) {
+  const existing = readProjectStamp(projectDir);
+  const fileHashes = collectFileHashes(options.sourceDir);
+
+  /** @type {ProjectStamp} */
+  const stamp = {
+    template: options.templateId,
+    templateVersion: options.templateVersion,
+    templateDirectory: options.templateDirectory,
+    generatedAt: existing?.generatedAt ?? new Date().toISOString(),
+    updatedAt: options.isUpdate ? new Date().toISOString() : existing?.updatedAt,
+    repository: options.repository,
+    branch: options.branch,
+    fileHashes,
+  };
+
+  if (options.isUpdate) {
+    stamp.updatedAt = new Date().toISOString();
+  }
+
+  await writeFile(join(projectDir, STAMP_FILENAME), JSON.stringify(stamp, null, 2) + "\n", "utf8");
+}

package/cli/prompt.js

@@ -0,0 +1,19 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+/**
+ * @param {string} message
+ * @param {boolean} autoConfirm
+ */
+export async function confirmYesNo(message, autoConfirm = false) {
+  if (autoConfirm) return true;
+
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(message);
+    const trimmed = answer.trim().toLowerCase();
+    return trimmed === "y" || trimmed === "yes";
+  } finally {
+    rl.close();
+  }
+}

package/cli/template-resolver.js

@@ -0,0 +1,48 @@
+import { removeDirectory } from "./copy.js";
+import { fetchTemplateFromGitHub, loadLocalTemplate } from "./fetch.js";
+
+/**
+ * @typedef {{
+ *   templateRoot: string,
+ *   cleanupDir: string,
+ *   stats: import('./fetch.js').FetchStats,
+ *   release: () => void
+ * }} ResolvedTemplate
+ */
+
+/**
+ * Resolve template source from local package or remote GitHub tarball.
+ * @param {{
+ *   repo: import('./config.js').RepositoryConfig,
+ *   packageRoot: string,
+ *   templateDirectory: string,
+ *   useRemote: boolean
+ * }} options
+ * @returns {Promise<ResolvedTemplate>}
+ */
+export async function resolveTemplateSource(options) {
+  const { repo, packageRoot, templateDirectory, useRemote } = options;
+
+  let result = null;
+
+  if (!useRemote) {
+    result = await loadLocalTemplate(packageRoot, repo.templatesPath, templateDirectory);
+  }
+
+  if (!result) {
+    result = await fetchTemplateFromGitHub(repo, templateDirectory);
+  }
+
+  const cleanupDir = result.cleanupDir;
+
+  return {
+    templateRoot: result.templateRoot,
+    cleanupDir,
+    stats: result.stats,
+    release: () => {
+      if (cleanupDir) {
+        removeDirectory(cleanupDir);
+      }
+    },
+  };
+}

package/cli/theme-manager.js

@@ -152,6 +152,26 @@ export function getSavedConfig(targetDir) {
   return {};
 }
 
+export function resolveThemeId(id) {
+  const theme = THEMES.find((t) => t.id === id);
+  if (!theme) {
+    throw new Error(
+      `Unknown theme: ${id}. Valid options: ${THEMES.map((t) => t.id).join(", ")}`
+    );
+  }
+  return theme.id;
+}
+
+export function resolveFontId(id) {
+  const font = FONTS.find((f) => f.id === id);
+  if (!font) {
+    throw new Error(
+      `Unknown font: ${id}. Valid options: ${FONTS.map((f) => f.id).join(", ")}`
+    );
+  }
+  return font.id;
+}
+
 async function promptSelection(options, promptText, defaultValue) {
   const rl = createInterface({ input, output });
   try {
@@ -179,11 +199,17 @@ async function promptSelection(options, promptText, defaultValue) {
   }
 }
 
-export async function promptTheme(currentThemeId = "theme1") {
+export async function promptTheme(currentThemeId = "theme1", options = {}) {
+  if (options.yes || options.theme) {
+    return resolveThemeId(options.theme || currentThemeId || "theme1");
+  }
   return promptSelection(THEMES, "Available Themes:", currentThemeId);
 }
 
-export async function promptFont(currentFontId = "default") {
+export async function promptFont(currentFontId = "default", options = {}) {
+  if (options.yes || options.font) {
+    return resolveFontId(options.font || currentFontId || "default");
+  }
   return promptSelection(FONTS, "Available Font combinations:", currentFontId);
 }
 
@@ -316,8 +342,12 @@ export async function applyThemeAndFont(targetDir, themeId, fontId) {
     if (!globalsContent.includes("tempjs-theme.css")) {
       // Prepend import at the top of the file
       globalsContent = `@import "./tempjs-theme.css";\n` + globalsContent;
-      await writeFile(globalsPath, globalsContent, "utf8");
     }
+
+    // Always append/update a timestamp touch comment to force bundler/Tailwind CSS recompilation
+    globalsContent = globalsContent.replace(/\/\* tempjs-touch: \d+ \*\/\s*$/, "");
+    globalsContent = globalsContent.trim() + `\n/* tempjs-touch: ${Date.now()} */\n`;
+    await writeFile(globalsPath, globalsContent, "utf8");
   } else {
     console.warn("Could not locate globals.css file in the project. CSS variables and font imports were not applied.");
   }

package/cli/update.js

@@ -0,0 +1,212 @@
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { loadManifest, resolveRepositoryConfig, getPackageRoot } from "./config.js";
+import { isUpdateProtected, shouldSkipFileName } from "./fs-ignore.js";
+import {
+  collectFileHashes,
+  diffTemplateTrees,
+  hashFileContents,
+} from "./file-tree.js";
+import { readProjectStamp, writeProjectStamp } from "./project-stamp.js";
+import { confirmYesNo } from "./prompt.js";
+import { resolveTemplateSource } from "./template-resolver.js";
+
+/**
+ * @param {import('./file-tree.js').UpdateDiff} diff
+ * @param {{
+ *   projectVersion: string,
+ *   latestVersion: string,
+ *   templateName: string
+ * }} meta
+ */
+export function printUpdateReport(diff, meta) {
+  console.log(`\nTemplate update report: ${meta.templateName}`);
+  console.log(`  Project version:  ${meta.projectVersion}`);
+  console.log(`  Latest version: ${meta.latestVersion}`);
+  console.log("");
+
+  if (
+    diff.newFiles.length === 0 &&
+    diff.safeUpdates.length === 0 &&
+    diff.conflicts.length === 0 &&
+    diff.removedFromTemplate.length === 0
+  ) {
+    console.log("Your project is up to date with the latest template.");
+    return;
+  }
+
+  if (diff.newFiles.length > 0) {
+    console.log(`New files in template (${diff.newFiles.length}):`);
+    diff.newFiles.slice(0, 25).forEach((p) => console.log(`  + ${p}`));
+    if (diff.newFiles.length > 25) {
+      console.log(`  ... and ${diff.newFiles.length - 25} more`);
+    }
+    console.log("");
+  }
+
+  if (diff.safeUpdates.length > 0) {
+    console.log(`Safe updates (${diff.safeUpdates.length}) — template changed, you did not edit:`);
+    diff.safeUpdates.slice(0, 25).forEach((p) => console.log(`  ~ ${p}`));
+    if (diff.safeUpdates.length > 25) {
+      console.log(`  ... and ${diff.safeUpdates.length - 25} more`);
+    }
+    console.log("");
+  }
+
+  if (diff.conflicts.length > 0) {
+    console.log(`Conflicts (${diff.conflicts.length}) — you modified these files:`);
+    diff.conflicts.slice(0, 25).forEach((p) => console.log(`  ! ${p}`));
+    if (diff.conflicts.length > 25) {
+      console.log(`  ... and ${diff.conflicts.length - 25} more`);
+    }
+    console.log("");
+  }
+
+  if (diff.removedFromTemplate.length > 0) {
+    console.log(`Removed from template (${diff.removedFromTemplate.length}) — not deleted locally:`);
+    diff.removedFromTemplate.slice(0, 15).forEach((p) => console.log(`  - ${p}`));
+    if (diff.removedFromTemplate.length > 15) {
+      console.log(`  ... and ${diff.removedFromTemplate.length - 15} more`);
+    }
+    console.log("");
+  }
+
+  if (diff.upToDate.length > 0) {
+    console.log(`${diff.upToDate.length} file(s) already match the latest template.\n`);
+  }
+}
+
+/**
+ * @param {string} sourcePath
+ * @param {string} targetPath
+ */
+export function copyTemplateFile(sourcePath, targetPath) {
+  mkdirSync(dirname(targetPath), { recursive: true });
+  cpSync(sourcePath, targetPath, { force: true });
+}
+
+/**
+ * @param {string} projectDir
+ * @param {import('./parse-args.js').CliFlags} flags
+ * @param {{ checkOnly: boolean }} mode
+ */
+export async function runUpdate(projectDir, flags, mode) {
+  const stamp = readProjectStamp(projectDir);
+
+  if (!stamp) {
+    console.error("No .tempjs.json found in this directory.");
+    console.error("Run `tempjs <template-id>` here first, or this project was not created with tempjs.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const manifest = loadManifest();
+  const entry = manifest.templates[stamp.template];
+  if (!entry) {
+    console.error(`Unknown template in .tempjs.json: ${stamp.template}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const repo = resolveRepositoryConfig(manifest.repository);
+  const packageRoot = getPackageRoot();
+  const useRemote =
+    flags.remote ||
+    process.env.TEMPLATE_USE_REMOTE === "1" ||
+    process.env.TEMPLATE_USE_REMOTE === "true";
+
+  const latestVersion = entry.version ?? "0.0.0";
+  let resolved = null;
+
+  try {
+    resolved = await resolveTemplateSource({
+      repo,
+      packageRoot,
+      templateDirectory: entry.directory,
+      useRemote,
+    });
+
+    const latestHashes = collectFileHashes(resolved.templateRoot);
+    const baselineHashes = stamp.fileHashes ?? {};
+    const currentHashes = {};
+
+    for (const path of Object.keys(latestHashes)) {
+      const projectPath = join(projectDir, path);
+      if (existsSync(projectPath) && !shouldSkipFileName(path.split("/").pop() ?? "")) {
+        currentHashes[path] = hashFileContents(projectPath);
+      }
+    }
+
+    const diff = diffTemplateTrees(baselineHashes, currentHashes, latestHashes);
+
+    printUpdateReport(diff, {
+      projectVersion: stamp.templateVersion,
+      latestVersion,
+      templateName: entry.name,
+    });
+
+    if (mode.checkOnly) {
+      if (stamp.templateVersion !== latestVersion) {
+        console.log("Run `tempjs update --merge` to apply non-conflicting template updates.");
+      }
+      return;
+    }
+
+    const pathsToApply = [...diff.newFiles, ...diff.safeUpdates].filter(
+      (path) => !isUpdateProtected(path)
+    );
+
+    const skippedProtected = [...diff.newFiles, ...diff.safeUpdates].filter((path) =>
+      isUpdateProtected(path)
+    );
+    if (skippedProtected.length > 0) {
+      console.log(`Skipping ${skippedProtected.length} protected path(s) (brand, .env, etc.).`);
+    }
+
+    if (pathsToApply.length === 0) {
+      if (diff.conflicts.length > 0) {
+        console.log("\nNo safe updates to apply. Resolve conflicts manually.");
+      }
+      return;
+    }
+
+    const confirmed = await confirmYesNo(
+      `\nApply ${pathsToApply.length} non-conflicting update(s)? [y/N] `,
+      flags.yes
+    );
+
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+
+    for (const relPath of pathsToApply) {
+      const from = join(resolved.templateRoot, relPath);
+      const to = join(projectDir, relPath);
+      copyTemplateFile(from, to);
+    }
+
+    await writeProjectStamp(projectDir, {
+      templateId: stamp.template,
+      templateVersion: latestVersion,
+      templateDirectory: entry.directory,
+      repository: `${repo.owner}/${repo.repo}`,
+      branch: repo.branch,
+      sourceDir: resolved.templateRoot,
+      isUpdate: true,
+    });
+
+    console.log(`\nApplied ${pathsToApply.length} update(s). Project stamped at template v${latestVersion}.`);
+
+    if (diff.conflicts.length > 0) {
+      console.log(`${diff.conflicts.length} conflict(s) still need manual review.`);
+    }
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  } finally {
+    if (resolved) {
+      resolved.release();
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navneet_25/tempjs",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "description": "CLI to instantiate website project templates from a single GitHub repository",
   "type": "module",
   "bin": {
@@ -20,5 +20,9 @@
     "website",
     "nextjs"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "scripts": {
+    "sync-templates": "node scripts/sync-templates.mjs",
+    "sync-templates:check": "node scripts/sync-templates.mjs --check"
+  }
 }

package/templates.json

@@ -9,12 +9,42 @@
     "hotel": {
       "directory": "hotel-website-template",
       "name": "Hotel Website",
-      "description": "Modern hotel and resort website with admin panel, gallery, and booking features"
+      "description": "Modern hotel and resort website with admin panel, gallery, and booking features",
+      "version": "1.2.0",
+      "stack": ["Next.js 16", "React 19", "TypeScript", "Tailwind CSS 4", "Prisma", "MariaDB", "NextAuth"],
+      "packageManager": "pnpm",
+      "node": ">=20",
+      "setupTime": "~10 min",
+      "docker": true,
+      "tags": ["admin", "cms", "gallery", "booking", "leads"],
+      "features": [
+        "Admin dashboard for rooms, facilities, reviews, and leads",
+        "Gallery and promo banner management",
+        "FTP asset upload pipeline",
+        "LeadRat CRM integration",
+        "Docker Compose for local MariaDB"
+      ],
+      "docs": "DEVELOPER_GUIDE.md"
     },
     "real-estate": {
       "directory": "real-estate-website-template",
       "name": "Real Estate Website",
-      "description": "Real estate and property listing website with admin panel and property management"
+      "description": "Real estate and property listing website with admin panel and property management",
+      "version": "1.2.0",
+      "stack": ["Next.js 16", "React 19", "TypeScript", "Tailwind CSS 4", "Prisma", "MariaDB", "NextAuth"],
+      "packageManager": "pnpm",
+      "node": ">=20",
+      "setupTime": "~10 min",
+      "docker": true,
+      "tags": ["admin", "cms", "properties", "leads"],
+      "features": [
+        "Admin dashboard for property listings and leads",
+        "Dynamic project pages with slug routing",
+        "FTP asset upload pipeline",
+        "LeadRat CRM integration",
+        "Docker Compose for local MariaDB"
+      ],
+      "docs": "DEVELOPER_GUIDE.md"
     }
   }
-}
+}