@navneet_25/tempjs 1.1.0 → 3.0.0

package/cli/init-options.js

@@ -0,0 +1,209 @@
+/**
+ * Per-template init field registry and flag resolution.
+ * Maintainers: add fields here once, then reference keys in templates.json `init.brandFields`.
+ */
+
+/** @typedef {{
+ *   flag: string,
+ *   cliKey: string,
+ *   prompt: string,
+ *   description: string,
+ *   siteKey?: string,
+ *   example?: string
+ * }} InitFieldDef */
+
+/** @typedef {{
+ *   flagGroups?: string[],
+ *   brandFields?: string[],
+ *   skipBrand?: boolean,
+ *   skipDatabase?: boolean
+ * }} TemplateInitConfig */
+
+export const DEFAULT_FLAG_GROUPS = ["generate", "theme", "brand", "database"];
+
+export const DEFAULT_BRAND_FIELDS = [
+  "name",
+  "shortName",
+  "baseUrl",
+  "phone",
+  "phoneDisplay",
+  "countryCode",
+  "email",
+  "address",
+];
+
+/**
+ * All supported brand/init fields. Keys match templates.json `init.brandFields` entries.
+ * @type {Record<string, InitFieldDef>}
+ */
+export const INIT_FIELD_REGISTRY = {
+  name: {
+    flag: "--name",
+    cliKey: "name",
+    prompt: "Brand Name",
+    description: "Primary business name shown across the site",
+    siteKey: "brandName",
+    example: "--name \"Lakeside Haven Resort\"",
+  },
+  shortName: {
+    flag: "--short-name",
+    cliKey: "shortName",
+    prompt: "Short/Display Name",
+    description: "Compact label for headers and compact UI",
+    example: "--short-name \"Lakeside Haven\"",
+  },
+  baseUrl: {
+    flag: "--base-url",
+    cliKey: "baseUrl",
+    prompt: "Base URL",
+    description: "Production site URL (SEO, sitemap, canonical links)",
+    example: "--base-url https://lakesidehaven.com",
+  },
+  phone: {
+    flag: "--phone",
+    cliKey: "phone",
+    prompt: "Contact Phone Number",
+    description: "Raw phone digits without spaces",
+    example: "--phone 9876543210",
+  },
+  phoneDisplay: {
+    flag: "--phone-display",
+    cliKey: "phoneDisplay",
+    prompt: "Display Phone Number",
+    description: "Formatted phone for display in UI",
+    example: "--phone-display \"+91 98765 43210\"",
+  },
+  countryCode: {
+    flag: "--country-code",
+    cliKey: "countryCode",
+    prompt: "Country Code",
+    description: "Phone country code (no plus sign)",
+    example: "--country-code 91",
+  },
+  email: {
+    flag: "--email",
+    cliKey: "email",
+    prompt: "Contact Email",
+    description: "Public contact email",
+    example: "--email reservations@example.com",
+  },
+  address: {
+    flag: "--address",
+    cliKey: "address",
+    prompt: "Full Address",
+    description: "Full address string (locality and region are derived for structured fields)",
+    example: "--address \"Lonavala, Maharashtra, India\"",
+  },
+  tagline: {
+    flag: "--tagline",
+    cliKey: "tagline",
+    prompt: "Tagline",
+    description: "Short brand tagline under the logo",
+    example: "--tagline \"Where Nature Meets Refined Comfort\"",
+  },
+  developerName: {
+    flag: "--developer-name",
+    cliKey: "developerName",
+    prompt: "Developer / Company Name",
+    description: "Legal or developer entity name (real estate) or resort operator name",
+    example: "--developer-name \"Greenfield Properties\"",
+  },
+  channelPartner: {
+    flag: "--channel-partner",
+    cliKey: "channelPartner",
+    prompt: "Channel Partner Name",
+    description: "Sales or hospitality partner label used in consent text",
+    example: "--channel-partner \"Greenfield Realty Partners\"",
+  },
+  agentRera: {
+    flag: "--agent-rera",
+    cliKey: "agentRera",
+    prompt: "Agent RERA Number",
+    description: "RERA registration for real-estate agent/consent (legal.agentRera)",
+    example: "--agent-rera A52100012345",
+  },
+  templeDistance: {
+    flag: "--temple-distance",
+    cliKey: "templeDistance",
+    prompt: "Nearby Landmark Distance",
+    description: "Hotel-specific nearby landmark line (contact.templeDistance)",
+    example: "--temple-distance \"5 min walk to Lonavala Lake viewpoint\"",
+  },
+  company: {
+    flag: "--company",
+    cliKey: "company",
+    prompt: "Company Name",
+    description: "Alias for developer/company name when templates use company branding",
+    siteKey: "developerName",
+    example: "--company \"Mi Plaza Hospitality\"",
+  },
+  location: {
+    flag: "--location",
+    cliKey: "location",
+    prompt: "Primary Location",
+    description: "City or locality label (updates address locality when full address is not set)",
+    example: "--location \"Lonavala\"",
+  },
+};
+
+/**
+ * @param {import('./config.js').TemplateEntry} entry
+ * @returns {TemplateInitConfig}
+ */
+export function resolveTemplateInitConfig(entry) {
+  const init = entry.init ?? {};
+  return {
+    flagGroups: init.flagGroups ?? DEFAULT_FLAG_GROUPS,
+    brandFields: init.brandFields ?? DEFAULT_BRAND_FIELDS,
+    skipBrand: init.skipBrand ?? false,
+    skipDatabase: init.skipDatabase ?? false,
+  };
+}
+
+/**
+ * @param {import('./config.js').TemplateEntry} entry
+ * @returns {InitFieldDef[]}
+ */
+export function getTemplateBrandFields(entry) {
+  const { brandFields } = resolveTemplateInitConfig(entry);
+  return brandFields
+    .map((key) => INIT_FIELD_REGISTRY[key])
+    .filter(Boolean);
+}
+
+/**
+ * @param {string} templateId
+ * @param {import('./config.js').TemplateEntry} entry
+ * @param {Record<string, string | undefined>} options
+ */
+export function pickBrandOptionsForTemplate(templateId, entry, options) {
+  const { brandFields, skipBrand } = resolveTemplateInitConfig(entry);
+  if (skipBrand) return {};
+
+  const picked = { yes: options.yes };
+
+  for (const fieldKey of brandFields) {
+    const def = INIT_FIELD_REGISTRY[fieldKey];
+    if (!def) continue;
+
+    const value = options[def.cliKey];
+    if (value !== undefined && value !== "") {
+      picked[def.cliKey] = value;
+    }
+  }
+
+  // company flag maps to developerName in brand-manager
+  if (options.company && !picked.developerName) {
+    picked.developerName = options.company;
+  }
+
+  return picked;
+}
+
+/**
+ * @param {import('./config.js').TemplateEntry} entry
+ * @returns {string[]}
+ */
+export function getTemplateFlagGroups(entry) {
+  return resolveTemplateInitConfig(entry).flagGroups;
+}

package/cli/module-manager.js

@@ -0,0 +1,168 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { rm } from "node:fs/promises";
+
+import { getPackageRoot } from "./config.js";
+import { fetchCoreModulesFromGitHub, resolveLocalCoreDir } from "./fetch-core-modules.js";
+import { readProjectStamp } from "./project-stamp.js";
+
+const scriptsDir = join(dirname(fileURLToPath(import.meta.url)), "..", "scripts");
+
+/**
+ * @param {string} projectDir
+ */
+function assertInitializedProject(projectDir) {
+  const stamp = readProjectStamp(projectDir);
+  if (!stamp) {
+    throw new Error(
+      "This directory does not look like a tempjs project (missing .tempjs.json).\n" +
+        "Run tempjs <template-id> from an empty directory first."
+    );
+  }
+}
+
+/**
+ * @param {string} coreDir
+ * @param {string} projectDir
+ */
+function writeMergedPrismaSchema(coreDir, projectDir) {
+  const coreSchemaPath = join(coreDir, "prisma", "schema.prisma");
+  if (!existsSync(coreSchemaPath)) {
+    return;
+  }
+
+  let merged = readFileSync(coreSchemaPath, "utf8").trim();
+  const domainPath = join(projectDir, "prisma", "domain.prisma");
+
+  if (existsSync(domainPath)) {
+    const domainPart = readFileSync(domainPath, "utf8").trim();
+    if (domainPart) {
+      merged = `${merged}\n\n${domainPart}`;
+    }
+  }
+
+  const destSchema = join(projectDir, "prisma", "schema.prisma");
+  mkdirSync(dirname(destSchema), { recursive: true });
+  writeFileSync(destSchema, `${merged}\n`, "utf8");
+  console.log("  ✓ merged prisma/schema.prisma");
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {{ useRemote?: boolean }} [options]
+ * @returns {Promise<{ coreDir: string, cleanupDir: string }>}
+ */
+async function resolveCoreDir(repo, options = {}) {
+  const packageRoot = getPackageRoot();
+  const localCore = resolveLocalCoreDir(packageRoot);
+
+  if (localCore && !options.useRemote) {
+    return { coreDir: localCore, cleanupDir: "" };
+  }
+
+  return fetchCoreModulesFromGitHub(repo);
+}
+
+/**
+ * Add optional core modules to an initialized client project.
+ * @param {string} projectDir
+ * @param {string[]} moduleIds
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {{ useRemote?: boolean }} [options]
+ */
+export async function runAddModule(projectDir, moduleIds, repo, options = {}) {
+  assertInitializedProject(projectDir);
+
+  if (moduleIds.length === 0) {
+    throw new Error("No module ids provided. Example: tempjs add-module seo,gallery");
+  }
+
+  const stamp = readProjectStamp(projectDir);
+  const displayName = stamp?.template
+    ? stamp.template.replace(/-website-template$/, "").replace(/-/g, " ")
+    : "Your Site";
+
+  const { coreDir, cleanupDir } = await resolveCoreDir(repo, {
+    useRemote: options.useRemote,
+  });
+
+  const installerPath = join(scriptsDir, "module-installer-core.mjs");
+  const { copyModulesIntoProject, listModuleIds, resolveModuleIds, parseModuleSpecs, moduleInstallOptionsFromSpecs } = await import(
+    pathToFileURL(installerPath).href
+  );
+
+  const specs = parseModuleSpecs(moduleIds.join(","));
+  const resolvedIds = specs.map((s) => s.id);
+  const available = listModuleIds(coreDir);
+  const resolved = resolveModuleIds(coreDir, resolvedIds);
+  const installOptions = moduleInstallOptionsFromSpecs(specs);
+
+  console.log(`Adding core modules to ${relative(process.cwd(), projectDir) || "."}:`);
+  console.log(`  modules: ${resolved.join(", ")}`);
+
+  try {
+    const installed = copyModulesIntoProject(projectDir, resolved, {
+      coreDir,
+      displayName,
+      skipHomePage: true,
+      skipSeoMetadataReplace: true,
+      installOptions,
+      writePrismaSchema: () => writeMergedPrismaSchema(coreDir, projectDir),
+    });
+
+    const cmsModules = installed.filter((id) => id === "gallery" || id === "reviews");
+    if (cmsModules.length > 0) {
+      console.log(
+        `  Admin tabs: gallery/reviews wired on /admin via app/admin/registry.ts`
+      );
+    }
+
+    console.log(`\n✓ Installed: ${installed.join(", ")}`);
+    console.log("\nNext steps:");
+    console.log("  pnpm prisma db push");
+    console.log("  pnpm dev");
+    if (cmsModules.length > 0) {
+      console.log("  Open /admin — Gallery and Reviews tabs appear when SITE.features flags are true");
+    }
+    console.log(`\nAvailable modules: ${available.join(", ")}`);
+  } finally {
+    if (cleanupDir) {
+      await rm(cleanupDir, { recursive: true, force: true });
+    }
+  }
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ */
+export async function printAvailableModules(repo) {
+  const packageRoot = getPackageRoot();
+  const localCore = resolveLocalCoreDir(packageRoot);
+
+  let coreDir = localCore;
+  let cleanupDir = "";
+
+  if (!coreDir) {
+    const fetched = await fetchCoreModulesFromGitHub(repo);
+    coreDir = fetched.coreDir;
+    cleanupDir = fetched.cleanupDir;
+  }
+
+  try {
+    const installerPath = join(scriptsDir, "module-installer-core.mjs");
+    const { listModuleIds, loadModulesRegistry } = await import(pathToFileURL(installerPath).href);
+    const registry = loadModulesRegistry(coreDir);
+    for (const id of listModuleIds(coreDir)) {
+      const mod = registry.modules[id];
+      console.log(`  ${id.padEnd(16)} ${mod.label}`);
+      if (mod.description) {
+        console.log(`                   ${mod.description}`);
+      }
+    }
+  } finally {
+    if (cleanupDir) {
+      await rm(cleanupDir, { recursive: true, force: true });
+    }
+  }
+}

package/cli/parse-args.js

@@ -0,0 +1,177 @@
+/**
+ * @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,
+    tagline: undefined,
+    developerName: undefined,
+    channelPartner: undefined,
+    agentRera: undefined,
+    templeDistance: undefined,
+    company: undefined,
+    location: 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" },
+  "--tagline": { key: "tagline", type: "string" },
+  "--developer-name": { key: "developerName", type: "string" },
+  "--channel-partner": { key: "channelPartner", type: "string" },
+  "--agent-rera": { key: "agentRera", type: "string" },
+  "--temple-distance": { key: "templeDistance", type: "string" },
+  "--company": { key: "company", type: "string" },
+  "--location": { key: "location", 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,
+    tagline: flags.tagline,
+    developerName: flags.developerName,
+    channelPartner: flags.channelPartner,
+    agentRera: flags.agentRera,
+    templeDistance: flags.templeDistance,
+    company: flags.company,
+    location: flags.location,
+    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();
+  }
+}