@navneet_25/tempjs 1.0.4 → 2.0.0

package/cli/brand-manager.js

@@ -0,0 +1,220 @@
+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";
+
+/**
+ * @typedef {{
+ *   yes?: boolean,
+ *   name?: string,
+ *   shortName?: string,
+ *   baseUrl?: string,
+ *   phone?: string,
+ *   phoneDisplay?: string,
+ *   countryCode?: string,
+ *   email?: string,
+ *   address?: string
+ * }} BrandOptions
+ */
+
+/**
+ * @param {string} siteContent
+ */
+function parseCurrentBrandValues(siteContent) {
+  return {
+    brandName: (siteContent.match(/name:\s*"([^"]+)"/) || [])[1] || "Chanakya Resort",
+    shortName: (siteContent.match(/shortName:\s*"([^"]+)"/) || [])[1] || "Chanakya",
+    baseUrl: (siteContent.match(/baseUrl:\s*"([^"]+)"/) || [])[1] || "https://chanakyaresort.com",
+    phone: (siteContent.match(/phone:\s*"([^"]+)"/) || [])[1] || "9876543210",
+    phoneDisplay: (siteContent.match(/phoneDisplay:\s*"([^"]+)"/) || [])[1] || "+91 98765 43210",
+    countryCode: (siteContent.match(/countryCode:\s*"([^"]+)"/) || [])[1] || "91",
+    email: (siteContent.match(/email:\s*"([^"]+)"/) || [])[1] || "reservations@chanakyaresort.com",
+    address: (siteContent.match(/full:\s*"([^"]+)"/) || [])[1] || "Lonavala, Maharashtra, India",
+  };
+}
+
+/**
+ * @param {string} baseUrl
+ */
+function deriveWwwHost(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    return url.hostname.startsWith("www.") ? url.hostname : `www.${url.hostname}`;
+  } catch {
+    let wwwHost = baseUrl.replace(/^https?:\/\//, "");
+    if (!wwwHost.startsWith("www.")) wwwHost = `www.${wwwHost}`;
+    return wwwHost;
+  }
+}
+
+/**
+ * @param {string} siteContent
+ * @param {{
+ *   brandName: string,
+ *   shortName: string,
+ *   baseUrl: string,
+ *   phone: string,
+ *   phoneDisplay: string,
+ *   countryCode: string,
+ *   email: string,
+ *   address: string
+ * }} values
+ */
+function applyBrandToSiteContent(siteContent, values) {
+  const {
+    brandName,
+    shortName,
+    baseUrl,
+    phone,
+    phoneDisplay,
+    countryCode,
+    email,
+    address,
+  } = values;
+
+  const wwwHost = deriveWwwHost(baseUrl);
+
+  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}",
+  }`;
+
+  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}",
+    },
+  }`;
+
+  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 + ",");
+  }
+
+  return siteContent;
+}
+
+/**
+ * @param {string} targetDir
+ * @param {BrandOptions} options
+ */
+export async function applyBrand(targetDir, options = {}) {
+  const siteTsPath = await findSiteTs(targetDir);
+  if (!siteTsPath) {
+    throw new Error(
+      "Could not locate constants/site.ts. Make sure you are inside an initialized tempjs template directory."
+    );
+  }
+
+  let siteContent = await readFile(siteTsPath, "utf8");
+  const current = parseCurrentBrandValues(siteContent);
+
+  const values = {
+    brandName: options.name?.trim() || current.brandName,
+    shortName: options.shortName?.trim() || current.shortName,
+    baseUrl: options.baseUrl?.trim() || current.baseUrl,
+    phone: options.phone?.trim() || current.phone,
+    phoneDisplay: options.phoneDisplay?.trim() || current.phoneDisplay,
+    countryCode: options.countryCode?.trim() || current.countryCode,
+    email: options.email?.trim() || current.email,
+    address: options.address?.trim() || current.address,
+  };
+
+  siteContent = applyBrandToSiteContent(siteContent, values);
+  await writeFile(siteTsPath, siteContent, "utf8");
+  console.log("Successfully updated brand and contact configurations in constants/site.ts.");
+}
+
+/**
+ * @param {string} targetDir
+ * @param {BrandOptions} options
+ */
+export async function promptAndApplyBrand(targetDir, options = {}) {
+  if (options.yes) {
+    await applyBrand(targetDir, options);
+    return;
+  }
+
+  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;
+  }
+
+  let siteContent = await readFile(siteTsPath, "utf8");
+  const current = parseCurrentBrandValues(siteContent);
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n--- Configure Brand & Contact Details ---");
+
+    const brandName =
+      (await rl.question(`Brand Name [${current.brandName}]: `)).trim() || current.brandName;
+    const shortName =
+      (await rl.question(`Short/Display Name [${current.shortName}]: `)).trim() || current.shortName;
+    const baseUrl =
+      (await rl.question(`Base URL [${current.baseUrl}]: `)).trim() || current.baseUrl;
+    const phone =
+      (await rl.question(`Contact Phone Number [${current.phone}]: `)).trim() || current.phone;
+    const phoneDisplay =
+      (await rl.question(`Display Phone Number [${current.phoneDisplay}]: `)).trim() ||
+      current.phoneDisplay;
+    const countryCode =
+      (await rl.question(`Country Code [${current.countryCode}]: `)).trim() || current.countryCode;
+    const email =
+      (await rl.question(`Contact Email [${current.email}]: `)).trim() || current.email;
+    const address =
+      (await rl.question(`Full Address [${current.address}]: `)).trim() || current.address;
+
+    siteContent = applyBrandToSiteContent(siteContent, {
+      brandName,
+      shortName,
+      baseUrl,
+      phone,
+      phoneDisplay,
+      countryCode,
+      email,
+      address,
+    });
+
+    await writeFile(siteTsPath, siteContent, "utf8");
+    console.log("Successfully updated brand and contact configurations in constants/site.ts.");
+  } finally {
+    rl.close();
+  }
+}

package/cli/config.js

@@ -5,7 +5,20 @@ import { fileURLToPath } from "node:url";
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
 
 /** @typedef {{ owner: string, repo: string, branch: string, templatesPath: string }} RepositoryConfig */
-/** @typedef {{ directory: string, name: string, description: string }} TemplateEntry */
+/** @typedef {{
+ *   directory: string,
+ *   name: string,
+ *   description: string,
+ *   version?: string,
+ *   stack?: string[],
+ *   packageManager?: string,
+ *   node?: string,
+ *   setupTime?: string,
+ *   docker?: boolean,
+ *   tags?: string[],
+ *   features?: string[],
+ *   docs?: string
+ * }} TemplateEntry */
 /** @typedef {{ repository: RepositoryConfig, templates: Record<string, TemplateEntry> }} Manifest */
 
 /**

package/cli/copy.js

@@ -9,23 +9,10 @@ import {
   statSync,
 } from "node:fs";
 import { join } from "node:path";
+import { NEVER_COPY_NAMES, shouldSkipFileName } from "./fs-ignore.js";
 
-const NEVER_COPY = new Set([".git", ".gitignore.bak"]);
 const NEVER_OVERWRITE = new Set([".git"]);
 
-/**
- * Files that must never be transferred into a generated project.
- * @param {string} name
- * @returns {boolean}
- */
-function shouldSkipFile(name) {
-  if (NEVER_COPY.has(name)) return true;
-  if (name === ".env" || name.startsWith(".env.")) {
-    return name !== ".env.example";
-  }
-  return false;
-}
-
 /**
  * @param {string} dir
  * @returns {string[]}
@@ -75,7 +62,7 @@ function collectConflicts(sourceDir, targetDir, relative, conflicts) {
 
   const sourceNames = readdirSync(currentSource);
   for (const name of sourceNames) {
-    if (shouldSkipFile(name)) continue;
+    if (shouldSkipFileName(name)) continue;
 
     const relPath = relative ? join(relative, name) : name;
     const sourcePath = join(sourceDir, relPath);
@@ -126,7 +113,7 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
   const names = readdirSync(sourcePath);
 
   for (const name of names) {
-    if (shouldSkipFile(name)) continue;
+    if (shouldSkipFileName(name) || NEVER_COPY_NAMES.has(name)) continue;
 
     const relPath = relative ? join(relative, name) : name;
     const from = join(sourceRoot, relPath);
@@ -138,7 +125,6 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
 
     const stat = lstatSync(from);
     if (stat.isSymbolicLink()) {
-      const linkTarget = readlinkSync(from);
       mkdirSync(join(to, ".."), { recursive: true });
       cpSync(from, to, { recursive: true, force: true });
       continue;
@@ -158,7 +144,7 @@ function copyRecursive(sourceRoot, targetRoot, relative) {
  * @param {string} dir
  */
 export function removeDirectory(dir) {
-  if (existsSync(dir)) {
+  if (dir && existsSync(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
 }

package/cli/db-setup.js

@@ -0,0 +1,241 @@
+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";
+
+/**
+ * @typedef {{
+ *   yes?: boolean,
+ *   dbHost?: string,
+ *   dbPort?: string,
+ *   dbUser?: string,
+ *   dbPassword?: string,
+ *   dbName?: string,
+ *   adminUser?: string,
+ *   adminPassword?: string,
+ *   skipDbPush?: boolean,
+ *   dbPush?: boolean
+ * }} DbSetupOptions
+ */
+
+/**
+ * @param {string} targetDir
+ * @param {DbSetupOptions} options
+ */
+export async function setupDb(targetDir, options = {}) {
+  const envPath = join(targetDir, ".env");
+  const envExamplePath = join(targetDir, ".env.example");
+
+  let existingEnv = "";
+  if (existsSync(envPath)) {
+    try {
+      existingEnv = await readFile(envPath, "utf8");
+    } catch {
+      // Ignore
+    }
+  }
+
+  const getEnvVal = (key, fallback) => {
+    const match = existingEnv.match(new RegExp(`^${key}\\s*=\\s*["']?([^"'\r\n]+)["']?`, "m"));
+    return match ? match[1] : fallback;
+  };
+
+  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 host = options.dbHost?.trim() || defaultHost;
+  const port = options.dbPort?.trim() || defaultPort;
+  const user = options.dbUser?.trim() || defaultUser;
+  const pass = options.dbPassword !== undefined ? options.dbPassword : defaultPass;
+  const dbName = options.dbName?.trim() || defaultDbName;
+  const adminUser = options.adminUser?.trim() || defaultAdminUser;
+  const adminPass = options.adminPassword?.trim() || defaultAdminPass;
+
+  const dbUrl = `mysql://${user}${pass ? `:${encodeURIComponent(pass)}` : ""}@${host}:${port}/${dbName}`;
+
+  let envContent = "";
+  if (existsSync(envExamplePath)) {
+    envContent = await readFile(envExamplePath, "utf8");
+  }
+
+  const randomSecret = crypto.randomBytes(32).toString("base64");
+
+  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.");
+
+  const shouldPush =
+    options.dbPush ||
+    (options.yes && !options.skipDbPush);
+
+  if (shouldPush) {
+    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 {
+      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 if (options.yes && options.skipDbPush) {
+    console.log("\nSkipped database table synchronization (--skip-db-push).");
+  }
+}
+
+/**
+ * @param {string} targetDir
+ * @param {DbSetupOptions} options
+ */
+export async function promptAndSetupDb(targetDir, options = {}) {
+  if (options.yes) {
+    await setupDb(targetDir, options);
+    return;
+  }
+
+  const envPath = join(targetDir, ".env");
+  const envExamplePath = join(targetDir, ".env.example");
+
+  let existingEnv = "";
+  if (existsSync(envPath)) {
+    try {
+      existingEnv = await readFile(envPath, "utf8");
+    } catch {
+      // Ignore
+    }
+  }
+
+  const getEnvVal = (key, fallback) => {
+    const match = existingEnv.match(new RegExp(`^${key}\\s*=\\s*["']?([^"'\r\n]+)["']?`, "m"));
+    return match ? match[1] : fallback;
+  };
+
+  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;
+
+    await setupDb(targetDir, {
+      dbHost: host,
+      dbPort: port,
+      dbUser: user,
+      dbPassword: pass,
+      dbName,
+      adminUser,
+      adminPassword: adminPass,
+      skipDbPush: true,
+    });
+
+    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 {
+        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/fetch.js

@@ -1,39 +1,44 @@
 import { execFileSync } from "node:child_process";
-import { createWriteStream, existsSync } from "node:fs";
+import { createWriteStream, existsSync, statSync } from "node:fs";
 import { mkdir, mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
+import { shouldSkipFileName } from "./fs-ignore.js";
+import { countFiles } from "./file-tree.js";
 
 const CODELOAD_BASE = "https://codeload.github.com";
 
 /**
- * Download a single template directory from GitHub without cloning or per-file API calls.
- *
- * Strategy: one tarball download from codeload.github.com (not the REST API), then
- * extract only templates/<templateDirectory>/ from the archive. This uses a single
- * HTTP request instead of 60+ blob API calls, avoiding unauthenticated rate limits.
- *
+ * @typedef {{ bytes: number, files: number, durationMs: number, source: string }} FetchStats
+ * @typedef {{ templateRoot: string, cleanupDir: string, stats: FetchStats }} FetchResult
+ */
+
+/**
  * @param {import('./config.js').RepositoryConfig} repo
  * @param {string} templateDirectory
- * @returns {Promise<string>} Path to temp directory containing template files
+ * @returns {Promise<FetchResult>}
  */
 export async function fetchTemplateFromGitHub(repo, templateDirectory) {
+  const startMs = performance.now();
   const tempRoot = await mkdtemp(join(tmpdir(), "template-cli-"));
   const tarballPath = join(tempRoot, "archive.tar.gz");
   const templateRoot = join(tempRoot, "template");
 
   try {
-    await downloadTarball(repo, tarballPath);
-    await extractTemplateFromTarball(
-      tarballPath,
-      templateRoot,
-      repo,
-      templateDirectory
-    );
+    const bytes = await downloadTarball(repo, tarballPath);
+    await extractTemplateFromTarball(tarballPath, templateRoot, repo, templateDirectory);
     await readFile(join(templateRoot, "package.json"));
-    return templateRoot;
+
+    const durationMs = performance.now() - startMs;
+    const files = countFiles(templateRoot);
+
+    return {
+      templateRoot,
+      cleanupDir: tempRoot,
+      stats: { bytes, files, durationMs, source: "remote" },
+    };
   } catch (error) {
     await rm(tempRoot, { recursive: true, force: true });
     throw error;
@@ -43,6 +48,7 @@ export async function fetchTemplateFromGitHub(repo, templateDirectory) {
 /**
  * @param {import('./config.js').RepositoryConfig} repo
  * @param {string} destPath
+ * @returns {Promise<number>} Downloaded bytes
  */
 async function downloadTarball(repo, destPath) {
   const branch = encodeURIComponent(repo.branch);
@@ -69,6 +75,7 @@ async function downloadTarball(repo, destPath) {
   }
 
   await pipeline(Readable.fromWeb(response.body), createWriteStream(destPath));
+  return statSync(destPath).size;
 }
 
 /**
@@ -128,13 +135,12 @@ async function extractTemplateFromTarball(
 }
 
 /**
- * Remove files that must never appear in generated projects.
  * @param {string} dir
  */
 async function removeSkippedFiles(dir) {
   if (!existsSync(dir)) return;
 
-  const entries = await readDirSafe(dir);
+  const entries = await readDirEntries(dir);
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory) {
@@ -155,7 +161,7 @@ async function removeSkippedFiles(dir) {
 /**
  * @param {string} dir
  */
-async function readDirSafe(dir) {
+async function readDirEntries(dir) {
   const names = await readdir(dir);
   const result = [];
   for (const name of names) {
@@ -166,16 +172,6 @@ async function readDirSafe(dir) {
   return result;
 }
 
-/**
- * @param {string} name
- */
-function shouldSkipFileName(name) {
-  if (name === ".env" || (name.startsWith(".env.") && name !== ".env.example")) {
-    return true;
-  }
-  return false;
-}
-
 function buildHeaders() {
   const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
   if (token) {
@@ -199,3 +195,25 @@ export async function resolveLocalTemplate(packageRoot, templatesPath, templateD
     return null;
   }
 }
+
+/**
+ * @param {string} packageRoot
+ * @param {string} templatesPath
+ * @param {string} templateDirectory
+ * @returns {Promise<FetchResult | null>}
+ */
+export async function loadLocalTemplate(packageRoot, templatesPath, templateDirectory) {
+  const localPath = await resolveLocalTemplate(packageRoot, templatesPath, templateDirectory);
+  if (!localPath) return null;
+
+  return {
+    templateRoot: localPath,
+    cleanupDir: "",
+    stats: {
+      bytes: 0,
+      files: countFiles(localPath),
+      durationMs: 0,
+      source: "local",
+    },
+  };
+}