@navneet_25/tempjs 1.0.3 → 1.1.0

package/README.md

@@ -34,7 +34,12 @@ tempjs list
 
 ```bash
 tempjs list                  # show available templates
-tempjs hotel                 # create project from hotel template
+tempjs hotel                 # create project from hotel template using default theme
+tempjs hotel config          # create project and run full interactive configuration (theme, font, brand, database)
+tempjs theme                 # change/reset the theme of an initialized project
+tempjs font                  # change/reset the font pairing of an initialized project
+tempjs brand                 # configure brand identity & contact info of an initialized project
+tempjs init-db               # set up .env file and run database schema sync on an initialized project
 tempjs real-estate --force   # overwrite existing files
 tempjs --help                # show help
 ```
@@ -43,6 +48,7 @@ tempjs --help                # show help
 
 | Option        | Description |
 |---------------|-------------|
+| `--config`    | Prompt for full configuration (theme, font, brand, db) during template initialization |
 | `--force`     | Overwrite files in the current directory without prompting |
 | `--remote`    | Fetch from GitHub even when a local template copy exists |
 | `--init-git`  | Run `git init` after copying (optional) |

package/cli/brand-manager.js

@@ -0,0 +1,108 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { readFile, writeFile } from "node:fs/promises";
+import { findSiteTs } from "./theme-manager.js";
+
+export async function promptAndApplyBrand(targetDir) {
+  const siteTsPath = await findSiteTs(targetDir);
+  if (!siteTsPath) {
+    console.error("Error: Could not locate constants/site.ts. Make sure you are inside an initialized tempjs template directory.");
+    return;
+  }
+
+  // Load current values if possible to provide defaults
+  let siteContent = await readFile(siteTsPath, "utf8");
+
+  // Parse existing values using simple regex
+  const currentBrandName = (siteContent.match(/name:\s*"([^"]+)"/) || [])[1] || "Chanakya Resort";
+  const currentShortName = (siteContent.match(/shortName:\s*"([^"]+)"/) || [])[1] || "Chanakya";
+  const currentBaseUrl = (siteContent.match(/baseUrl:\s*"([^"]+)"/) || [])[1] || "https://chanakyaresort.com";
+  const currentPhone = (siteContent.match(/phone:\s*"([^"]+)"/) || [])[1] || "9876543210";
+  const currentPhoneDisplay = (siteContent.match(/phoneDisplay:\s*"([^"]+)"/) || [])[1] || "+91 98765 43210";
+  const currentCountryCode = (siteContent.match(/countryCode:\s*"([^"]+)"/) || [])[1] || "91";
+  const currentEmail = (siteContent.match(/email:\s*"([^"]+)"/) || [])[1] || "reservations@chanakyaresort.com";
+  const currentAddress = (siteContent.match(/full:\s*"([^"]+)"/) || [])[1] || "Lonavala, Maharashtra, India";
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n--- Configure Brand & Contact Details ---");
+
+    const brandName = (await rl.question(`Brand Name [${currentBrandName}]: `)).trim() || currentBrandName;
+    const shortName = (await rl.question(`Short/Display Name [${currentShortName}]: `)).trim() || currentShortName;
+    const baseUrl = (await rl.question(`Base URL [${currentBaseUrl}]: `)).trim() || currentBaseUrl;
+
+    // Derive wwwHost from baseUrl
+    let wwwHost = "www.example.com";
+    try {
+      const url = new URL(baseUrl);
+      wwwHost = url.hostname.startsWith("www.") ? url.hostname : `www.${url.hostname}`;
+    } catch {
+      wwwHost = baseUrl.replace(/^https?:\/\//, "");
+      if (!wwwHost.startsWith("www.")) wwwHost = `www.${wwwHost}`;
+    }
+
+    const phone = (await rl.question(`Contact Phone Number [${currentPhone}]: `)).trim() || currentPhone;
+    const phoneDisplay = (await rl.question(`Display Phone Number [${currentPhoneDisplay}]: `)).trim() || currentPhoneDisplay;
+    const countryCode = (await rl.question(`Country Code [${currentCountryCode}]: `)).trim() || currentCountryCode;
+    const email = (await rl.question(`Contact Email [${currentEmail}]: `)).trim() || currentEmail;
+    const address = (await rl.question(`Full Address [${currentAddress}]: `)).trim() || currentAddress;
+
+    // Build replacement blocks
+    const newBrandBlock = `brand: {
+    name: "${brandName}",
+    shortName: "${shortName}",
+    tagline: "Where Nature Meets Refined Comfort",
+    developerName: "${brandName}",
+    channelPartner: "${brandName} Partner",
+    copyright: "${brandName}. All Rights Reserved.",
+    managedBy: "Managed by ${brandName}.",
+  }`;
+
+    const newDomainBlock = `domain: {
+    baseUrl: "${baseUrl}",
+    wwwHost: "${wwwHost}",
+  }`;
+
+    // Extract address locality/region/country or keep defaults
+    let locality = "Lonavala";
+    let region = "MH";
+    const addressParts = address.split(",");
+    if (addressParts.length >= 2) {
+      locality = addressParts[0].trim();
+      region = addressParts[1].trim();
+    }
+
+    const newContactBlock = `contact: {
+    phone: "${phone}",
+    phoneDisplay: "${phoneDisplay}",
+    countryCode: "${countryCode}",
+    email: "${email}",
+    address: {
+      locality: "${locality}",
+      region: "${region}",
+      country: "IN",
+      full: "${address}",
+    },
+  }`;
+
+    // Apply replacements using exact patterns matching our templates
+    const brandRegex = /brand:\s*\{[\s\S]*?\n\s*\},/;
+    const domainRegex = /domain:\s*\{[\s\S]*?\n\s*\},/;
+    const contactRegex = /contact:\s*\{[\s\S]*?address:\s*\{[\s\S]*?\}[\s\S]*?\n\s*\},/;
+
+    if (brandRegex.test(siteContent)) {
+      siteContent = siteContent.replace(brandRegex, newBrandBlock + ",");
+    }
+    if (domainRegex.test(siteContent)) {
+      siteContent = siteContent.replace(domainRegex, newDomainBlock + ",");
+    }
+    if (contactRegex.test(siteContent)) {
+      siteContent = siteContent.replace(contactRegex, newContactBlock + ",");
+    }
+
+    await writeFile(siteTsPath, siteContent, "utf8");
+    console.log("Successfully updated brand and contact configurations in constants/site.ts.");
+  } finally {
+    rl.close();
+  }
+}

package/cli/db-setup.js

@@ -0,0 +1,120 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, basename, resolve } from "node:path";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+
+export async function promptAndSetupDb(targetDir) {
+  const envPath = join(targetDir, ".env");
+  const envExamplePath = join(targetDir, ".env.example");
+
+  // Load existing env values as defaults if .env exists
+  let existingEnv = "";
+  if (existsSync(envPath)) {
+    try {
+      existingEnv = await readFile(envPath, "utf8");
+    } catch {
+      // Ignore
+    }
+  }
+
+  // Helper to extract env var
+  const getEnvVal = (key, fallback) => {
+    const match = existingEnv.match(new RegExp(`^${key}\\s*=\\s*["']?([^"'\r\n]+)["']?`, "m"));
+    return match ? match[1] : fallback;
+  };
+
+  // Parse existing DB URL if any
+  const currentDbUrl = getEnvVal("DATABASE_URL", "");
+  let defaultHost = "localhost";
+  let defaultPort = "3306";
+  let defaultUser = "root";
+  let defaultPass = "";
+  let defaultDbName = basename(resolve(targetDir)).toLowerCase().replace(/[^a-z0-9_]/g, "_") + "_db";
+
+  if (currentDbUrl) {
+    const urlMatch = currentDbUrl.match(/mysql:\/\/([^:@]+)(?::([^@]+))?@([^:/]+)(?::(\d+))?\/([^?]+)/);
+    if (urlMatch) {
+      defaultUser = urlMatch[1];
+      defaultPass = urlMatch[2] || "";
+      defaultHost = urlMatch[3];
+      defaultPort = urlMatch[4] || "3306";
+      defaultDbName = urlMatch[5];
+    }
+  }
+
+  const defaultAdminUser = getEnvVal("ADMIN_USER", "admin");
+  const defaultAdminPass = getEnvVal("ADMIN_PASSWORD", crypto.randomBytes(4).toString("hex"));
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n--- Configure Database & Environment Variables ---");
+
+    const host = (await rl.question(`MySQL Database Host [${defaultHost}]: `)).trim() || defaultHost;
+    const port = (await rl.question(`MySQL Database Port [${defaultPort}]: `)).trim() || defaultPort;
+    const user = (await rl.question(`MySQL Database Username [${defaultUser}]: `)).trim() || defaultUser;
+    const pass = (await rl.question(`MySQL Database Password [${defaultPass ? "*****" : "(empty)"}]: `)).trim() || defaultPass;
+    const dbName = (await rl.question(`MySQL Database Name [${defaultDbName}]: `)).trim() || defaultDbName;
+
+    const adminUser = (await rl.question(`Admin Portal Username [${defaultAdminUser}]: `)).trim() || defaultAdminUser;
+    const adminPass = (await rl.question(`Admin Portal Password [${defaultAdminPass}]: `)).trim() || defaultAdminPass;
+
+    // Construct MySQL Connection URL
+    const dbUrl = `mysql://${user}${pass ? `:${encodeURIComponent(pass)}` : ""}@${host}:${port}/${dbName}`;
+
+    // Read template or write fresh environment file
+    let envContent = "";
+    if (existsSync(envExamplePath)) {
+      envContent = await readFile(envExamplePath, "utf8");
+    }
+
+    // Generate fresh secret
+    const randomSecret = crypto.randomBytes(32).toString("base64");
+
+    // Replace or construct env keys
+    const updateEnvKey = (content, key, value) => {
+      const regex = new RegExp(`^#?\\s*${key}\\s*=.*$`, "m");
+      if (regex.test(content)) {
+        return content.replace(regex, `${key}="${value}"`);
+      }
+      return `${content.trim()}\n${key}="${value}"\n`;
+    };
+
+    if (envContent) {
+      envContent = updateEnvKey(envContent, "DATABASE_URL", dbUrl);
+      envContent = updateEnvKey(envContent, "AUTH_SECRET", randomSecret);
+      envContent = updateEnvKey(envContent, "ADMIN_USER", adminUser);
+      envContent = updateEnvKey(envContent, "ADMIN_PASSWORD", adminPass);
+    } else {
+      envContent = `DATABASE_URL="${dbUrl}"
+AUTH_SECRET="${randomSecret}"
+ADMIN_USER="${adminUser}"
+ADMIN_PASSWORD="${adminPass}"
+AUTH_TRUST_HOST="true"
+`;
+    }
+
+    await writeFile(envPath, envContent, "utf8");
+    console.log("Successfully created/updated .env configuration file.");
+
+    // Prompt to run prisma database push
+    const runMigrate = await rl.question("\nDo you want to initialize the database tables now using Prisma? (y/n) [y]: ");
+    const choice = runMigrate.trim().toLowerCase();
+    if (choice === "" || choice === "y" || choice === "yes") {
+      console.log("\nRunning Prisma Database Push (npx prisma db push)...");
+      try {
+        execSync("npx prisma db push", { cwd: targetDir, stdio: "inherit" });
+        console.log("\nSuccessfully synchronized database schemas.");
+      } catch (err) {
+        console.error("\nWarning: Database synchronization failed. Make sure your MySQL server is running and the database details are correct.");
+        console.error("You can run this manually later inside the project folder via: npx prisma db push");
+      }
+    } else {
+      console.log("\nSkipped database table synchronization. Remember to run 'npx prisma db push' before running the app.");
+    }
+  } finally {
+    rl.close();
+  }
+}

package/cli/index.js

@@ -4,6 +4,14 @@ 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,
+  promptFont,
+  applyThemeAndFont,
+  getSavedConfig,
+} from "./theme-manager.js";
+import { promptAndApplyBrand } from "./brand-manager.js";
+import { promptAndSetupDb } from "./db-setup.js";
 import {
   copyTemplate,
   findConflictingPaths,
@@ -20,9 +28,15 @@ tempjs — instantiate project templates from GitHub
 USAGE
   tempjs list
   tempjs <template-id> [options]
+  tempjs <template-id> config     Initialize with interactive theme, typography, brand & database 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 brand                    Configure the brand & contact info in an initialized directory
+  tempjs init-db                  Configure .env and sync database schema in an initialized directory
   tempjs --help
 
 OPTIONS
+  --config      Prompt for full interactive setup (theme, font, brand, db) 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
@@ -30,8 +44,9 @@ OPTIONS
 
 EXAMPLES
   mkdir hotel-client && cd hotel-client
-  tempjs hotel
-  git init
+  tempjs hotel config
+  tempjs brand
+  tempjs init-db
 
 ENVIRONMENT
   TEMPLATES_REPO_URL       GitHub repo URL or owner/repo (overrides templates.json)
@@ -72,6 +87,7 @@ function parseArgs(argv) {
     remote: false,
     initGit: false,
     help: false,
+    config: false,
   };
   const positionals = [];
 
@@ -80,6 +96,7 @@ function parseArgs(argv) {
     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 {
@@ -124,8 +141,9 @@ async function confirmOverwrite(force) {
  * @param {string} targetDir
  * @param {string} templateId
  * @param {{ force: boolean, remote: boolean, initGit: boolean }} flags
+ * @param {boolean} runWithConfig
  */
-async function runTemplate(targetDir, templateId, flags) {
+async function runTemplate(targetDir, templateId, flags, runWithConfig = false) {
   const manifest = loadManifest();
   const entry = manifest.templates[templateId];
 
@@ -198,6 +216,19 @@ async function runTemplate(targetDir, templateId, flags) {
       execSync("git init", { cwd: targetDir, stdio: "inherit" });
     }
 
+    if (runWithConfig) {
+      console.log("\nConfiguring project theme and typography...");
+      const selectedTheme = await promptTheme("theme1");
+      const selectedFont = await promptFont("default");
+      await applyThemeAndFont(targetDir, selectedTheme, selectedFont);
+
+      // Interactive Brand & Contact Details configuration
+      await promptAndApplyBrand(targetDir);
+
+      // Environment & Database auto-setup
+      await promptAndSetupDb(targetDir);
+    }
+
     console.log(`\nTemplate "${entry.name}" created successfully in ${targetDir}`);
     console.log("\nNext steps:");
     console.log("  pnpm install   # or npm install");
@@ -227,22 +258,41 @@ async function runTemplate(targetDir, templateId, flags) {
  */
 async function main(argv) {
   const { flags, positionals } = parseArgs(argv);
-  const command = positionals[0];
+  let command = positionals[0];
 
   if (flags.help || command === "help" || (!command && argv.length === 0)) {
     console.log(HELP_TEXT.trim());
     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 if (command === "font") {
+      const selectedFont = await promptFont(currentConfig.font || "default");
+      await applyThemeAndFont(targetDir, currentConfig.theme || "theme1", selectedFont);
+    } else if (command === "brand") {
+      await promptAndApplyBrand(targetDir);
+    } else if (command === "init-db") {
+      await promptAndSetupDb(targetDir);
+    }
+    return;
+  }
+
   const manifest = loadManifest();
 
-  if (command === "list") {
-    printTemplateList(manifest.templates);
-    return;
+  let runWithConfig = flags.config;
+  if (positionals.length >= 2 && positionals[1] === "config") {
+    runWithConfig = true;
+    positionals.splice(1, 1);
   }
 
   const targetDir = process.cwd();
-  await runTemplate(targetDir, command, flags);
+  await runTemplate(targetDir, command, flags, runWithConfig);
 }
 
 main(process.argv.slice(2)).catch((error) => {

package/cli/theme-manager.js

@@ -0,0 +1,356 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const THEMES = [
+  {
+    id: "theme1",
+    name: "Theme 1 (Slate / Blue)",
+    colors: {
+      primary: "#2563EB",
+      primaryHover: "#1D4ED8",
+      accent: "#38BDF8",
+      accentDark: "#0284C7",
+      accentLight: "#EFF6FF",
+      textMain: "#0F172A",
+      textMuted: "#64748B",
+      bgMain: "#F8FAFC",
+      bgLight: "#EFF6FF",
+      bgCard: "#FFFFFF",
+      footerBg: "#E2E8F0",
+      ctaPrimary: "#2563EB",
+      ctaPrimaryHover: "#1D4ED8",
+    }
+  },
+  {
+    id: "theme2",
+    name: "Theme 2 (Forest / Green)",
+    colors: {
+      primary: "#58812F",
+      primaryHover: "#466725",
+      accent: "#8BC34A",
+      accentDark: "#689F38",
+      accentLight: "#F1F5EA",
+      textMain: "#1D3108",
+      textMuted: "#4A5441",
+      bgMain: "#F9FAF7",
+      bgLight: "#F1F5EA",
+      bgCard: "#FFFFFF",
+      footerBg: "#E6EBDC",
+      ctaPrimary: "#58812F",
+      ctaPrimaryHover: "#466725",
+    }
+  },
+  {
+    id: "theme3",
+    name: "Theme 3 (Purple / Violet)",
+    colors: {
+      primary: "#7C3AED",
+      primaryHover: "#6D28D9",
+      accent: "#A78BFA",
+      accentDark: "#8B5CF6",
+      accentLight: "#F5F3FF",
+      textMain: "#2E1065",
+      textMuted: "#6B6382",
+      bgMain: "#FAF9FF",
+      bgLight: "#F5F3FF",
+      bgCard: "#FFFFFF",
+      footerBg: "#E9E3FF",
+      ctaPrimary: "#7C3AED",
+      ctaPrimaryHover: "#6D28D9",
+    }
+  },
+  {
+    id: "theme4",
+    name: "Theme 4 (Red / Crimson)",
+    colors: {
+      primary: "#DC2626",
+      primaryHover: "#B91C1C",
+      accent: "#F87171",
+      accentDark: "#EF4444",
+      accentLight: "#FEF2F2",
+      textMain: "#450A0A",
+      textMuted: "#7F1D1D",
+      bgMain: "#FFFBFB",
+      bgLight: "#FEF2F2",
+      bgCard: "#FFFFFF",
+      footerBg: "#FEE2E2",
+      ctaPrimary: "#DC2626",
+      ctaPrimaryHover: "#B91C1C",
+    }
+  },
+  {
+    id: "theme5",
+    name: "Theme 5 (Amber / Gold)",
+    colors: {
+      primary: "#D97706",
+      primaryHover: "#B45309",
+      accent: "#FBBF24",
+      accentDark: "#F59E0B",
+      accentLight: "#FFFBEB",
+      textMain: "#1C1917",
+      textMuted: "#78350F",
+      bgMain: "#FFFCF5",
+      bgLight: "#FFFBEB",
+      bgCard: "#FFFFFF",
+      footerBg: "#FEF3C7",
+      ctaPrimary: "#D97706",
+      ctaPrimaryHover: "#B45309",
+    }
+  }
+];
+
+export const FONTS = [
+  {
+    id: "default",
+    name: "Playfair Display (Serif) + Outfit (Sans-serif) [Default]",
+    serif: "'Playfair Display', Georgia, serif",
+    sans: "'Outfit', system-ui, sans-serif",
+    importUrl: "https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&family=Playfair+Display:ital,wght@0,400;0,500;0,600;0,700;1,400&display=swap"
+  },
+  {
+    id: "inter",
+    name: "Inter (Sans-serif) + Inter (Sans-serif)",
+    serif: "'Inter', system-ui, sans-serif",
+    sans: "'Inter', system-ui, sans-serif",
+    importUrl: "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
+  },
+  {
+    id: "lora-montserrat",
+    name: "Lora (Serif) + Montserrat (Sans-serif)",
+    serif: "'Lora', Georgia, serif",
+    sans: "'Montserrat', system-ui, sans-serif",
+    importUrl: "https://fonts.googleapis.com/css2?family=Lora:ital,wght@0,400;0,700;1,400&family=Montserrat:wght@300;400;500;600;700&display=swap"
+  },
+  {
+    id: "merriweather-open-sans",
+    name: "Merriweather (Serif) + Open Sans (Sans-serif)",
+    serif: "'Merriweather', Georgia, serif",
+    sans: "'Open Sans', system-ui, sans-serif",
+    importUrl: "https://fonts.googleapis.com/css2?family=Merriweather:ital,wght@0,300;0,400;0,700;1,300&family=Open+Sans:wght@300;400;500;600;700&display=swap"
+  },
+  {
+    id: "cinzel-montserrat",
+    name: "Cinzel (Serif) + Montserrat (Sans-serif)",
+    serif: "'Cinzel', serif",
+    sans: "'Montserrat', system-ui, sans-serif",
+    importUrl: "https://fonts.googleapis.com/css2?family=Cinzel:wght@400;700&family=Montserrat:wght@300;400;500;600;700&display=swap"
+  }
+];
+
+export function getSavedConfig(targetDir) {
+  const configPath = join(targetDir, ".tempjsrc");
+  if (existsSync(configPath)) {
+    try {
+      return JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+async function promptSelection(options, promptText, defaultValue) {
+  const rl = createInterface({ input, output });
+  try {
+    console.log(`\n${promptText}`);
+    for (let i = 0; i < options.length; i++) {
+      const isDefault = options[i].id === defaultValue ? " (current default)" : "";
+      console.log(`  [${i + 1}] ${options[i].name}${isDefault}`);
+    }
+    const defaultIndex = options.findIndex(o => o.id === defaultValue) + 1;
+    const placeholder = defaultIndex > 0 ? defaultIndex : 1;
+    const actualDefault = defaultIndex > 0 ? defaultValue : options[0].id;
+
+    while (true) {
+      const answer = await rl.question(`Choose an option (1-${options.length}) [${placeholder}]: `);
+      const trimmed = answer.trim();
+      if (trimmed === "") return actualDefault;
+      const num = parseInt(trimmed, 10);
+      if (num >= 1 && num <= options.length) {
+        return options[num - 1].id;
+      }
+      console.log("Invalid option. Please try again.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptTheme(currentThemeId = "theme1") {
+  return promptSelection(THEMES, "Available Themes:", currentThemeId);
+}
+
+export async function promptFont(currentFontId = "default") {
+  return promptSelection(FONTS, "Available Font combinations:", currentFontId);
+}
+
+export async function findGlobalsCss(dir) {
+  const commonPaths = [
+    join(dir, "app/globals.css"),
+    join(dir, "src/app/globals.css"),
+    join(dir, "src/globals.css"),
+    join(dir, "globals.css"),
+  ];
+  for (const p of commonPaths) {
+    if (existsSync(p)) return p;
+  }
+
+  async function search(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (
+          entry.name === "node_modules" ||
+          entry.name === ".next" ||
+          entry.name === ".git" ||
+          entry.name === "dist" ||
+          entry.name === "build"
+        ) {
+          continue;
+        }
+        const found = await search(join(currentDir, entry.name));
+        if (found) return found;
+      } else if (entry.name === "globals.css") {
+        return join(currentDir, entry.name);
+      }
+    }
+    return null;
+  }
+  return search(dir);
+}
+
+export async function findSiteTs(dir) {
+  const commonPaths = [
+    join(dir, "constants/site.ts"),
+    join(dir, "src/constants/site.ts"),
+    join(dir, "constants/site.js"),
+    join(dir, "src/constants/site.js"),
+  ];
+  for (const p of commonPaths) {
+    if (existsSync(p)) return p;
+  }
+
+  async function search(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (
+          entry.name === "node_modules" ||
+          entry.name === ".next" ||
+          entry.name === ".git" ||
+          entry.name === "dist" ||
+          entry.name === "build"
+        ) {
+          continue;
+        }
+        const found = await search(join(currentDir, entry.name));
+        if (found) return found;
+      } else if (entry.name === "site.ts" || entry.name === "site.js") {
+        return join(currentDir, entry.name);
+      }
+    }
+    return null;
+  }
+  return search(dir);
+}
+
+export async function applyThemeAndFont(targetDir, themeId, fontId) {
+  const theme = THEMES.find(t => t.id === themeId) || THEMES[0];
+  const font = FONTS.find(f => f.id === fontId) || FONTS[0];
+
+  // 1. Write metadata config file .tempjsrc
+  const configPath = join(targetDir, ".tempjsrc");
+  const config = {
+    theme: theme.id,
+    font: font.id,
+    updatedAt: new Date().toISOString()
+  };
+  await writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+
+  // 2. Find and update globals.css
+  const globalsPath = await findGlobalsCss(targetDir);
+  if (globalsPath) {
+    const cssDir = join(globalsPath, "..");
+    const themeCssPath = join(cssDir, "tempjs-theme.css");
+
+    // Construct the theme css content
+    const cssContent = `/* tempjs generated theme settings */
+@import url('${font.importUrl}');
+
+:root {
+  --primary: ${theme.colors.primary} !important;
+  --primary-hover: ${theme.colors.primaryHover} !important;
+  --accent-gold: ${theme.colors.accent} !important;
+  --accent-gold-dark: ${theme.colors.accentDark} !important;
+  --accent-gold-light: ${theme.colors.accentLight} !important;
+  --text-main: ${theme.colors.textMain} !important;
+  --text-muted: ${theme.colors.textMuted} !important;
+  --bg-tan: ${theme.colors.bgMain} !important;
+  --bg-light: ${theme.colors.bgLight} !important;
+  --bg-card: ${theme.colors.bgCard} !important;
+  --footer-bg: ${theme.colors.footerBg} !important;
+  --cta-primary: ${theme.colors.ctaPrimary} !important;
+  --cta-primary-hover: ${theme.colors.ctaPrimaryHover} !important;
+
+  --font-serif: ${font.serif} !important;
+  --font-sans: ${font.sans} !important;
+}
+`;
+    await writeFile(themeCssPath, cssContent, "utf8");
+
+    // Ensure it's imported in globals.css
+    let globalsContent = await readFile(globalsPath, "utf8");
+    if (!globalsContent.includes("tempjs-theme.css")) {
+      // Prepend import at the top of the file
+      globalsContent = `@import "./tempjs-theme.css";\n` + globalsContent;
+    }
+
+    // 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.");
+  }
+
+  // 3. Find and update site.ts
+  const siteTsPath = await findSiteTs(targetDir);
+  if (siteTsPath) {
+    let siteContent = await readFile(siteTsPath, "utf8");
+    const colorsRegex = /colors:\s*\{[\s\S]*?\}/;
+    const replacement = `colors: {
+      primary: "${theme.colors.primary}",
+      primaryHover: "${theme.colors.primaryHover}",
+      accent: "${theme.colors.accent}",
+      accentDark: "${theme.colors.accentDark}",
+      accentLight: "${theme.colors.accentLight}",
+      textMain: "${theme.colors.textMain}",
+      textMuted: "${theme.colors.textMuted}",
+      bgMain: "${theme.colors.bgMain}",
+      bgLight: "${theme.colors.bgLight}",
+      bgCard: "${theme.colors.bgCard}",
+      footerBg: "${theme.colors.footerBg}",
+      ctaPrimary: "${theme.colors.ctaPrimary}",
+      ctaPrimaryHover: "${theme.colors.ctaPrimaryHover}",
+    }`;
+    if (colorsRegex.test(siteContent)) {
+      siteContent = siteContent.replace(colorsRegex, replacement);
+      await writeFile(siteTsPath, siteContent, "utf8");
+    }
+  }
+
+  console.log(`\nSuccessfully applied theme "${theme.name}" and font pairing "${font.name}".`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navneet_25/tempjs",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "CLI to instantiate website project templates from a single GitHub repository",
   "type": "module",
   "bin": {