@navneet_25/tempjs 1.1.0 → 3.0.0

package/cli/fetch-core-modules.js

@@ -0,0 +1,130 @@
+import { execFileSync } from "node:child_process";
+import { createWriteStream, existsSync, statSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm } 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";
+
+const CODELOAD_BASE = "https://codeload.github.com";
+
+/**
+ * @typedef {{ coreDir: string, cleanupDir: string }} CoreModulesFetchResult
+ */
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @returns {Promise<CoreModulesFetchResult>}
+ */
+export async function fetchCoreModulesFromGitHub(repo) {
+  const tempRoot = await mkdtemp(join(tmpdir(), "tempjs-core-"));
+  const tarballPath = join(tempRoot, "archive.tar.gz");
+  const coreDir = join(tempRoot, "core");
+
+  try {
+    await downloadTarball(repo, tarballPath);
+    await extractCoreFromTarball(tarballPath, coreDir, repo);
+    await readFile(join(coreDir, "modules.json"));
+
+    return { coreDir, cleanupDir: tempRoot };
+  } catch (error) {
+    await rm(tempRoot, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+/**
+ * @param {string} packageRoot
+ * @returns {string | null}
+ */
+export function resolveLocalCoreDir(packageRoot) {
+  const localPath = join(packageRoot, "packages", "core");
+  if (existsSync(join(localPath, "modules.json"))) {
+    return localPath;
+  }
+  return null;
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {string} destPath
+ */
+async function downloadTarball(repo, destPath) {
+  const branch = encodeURIComponent(repo.branch);
+  const url = `${CODELOAD_BASE}/${repo.owner}/${repo.repo}/tar.gz/${branch}`;
+
+  const response = await fetch(url, {
+    headers: buildHeaders(),
+    redirect: "follow",
+  });
+
+  if (!response.ok) {
+    let detail = `Could not download ${repo.owner}/${repo.repo}@${repo.branch}`;
+    if (response.status === 404) {
+      detail += "\nVerify the repository, branch, and templates.json settings.";
+    }
+    if (response.status === 401 || response.status === 403) {
+      detail += "\nFor private repositories, set GITHUB_TOKEN or GH_TOKEN.";
+    }
+    throw new Error(`${detail} (HTTP ${response.status})`);
+  }
+
+  if (!response.body) {
+    throw new Error("Empty response while downloading repository archive");
+  }
+
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(destPath));
+  return statSync(destPath).size;
+}
+
+/**
+ * @param {string} tarballPath
+ * @param {string} destDir
+ * @param {import('./config.js').RepositoryConfig} repo
+ */
+async function extractCoreFromTarball(tarballPath, destDir, repo) {
+  const listing = execFileSync("tar", ["-tzf", tarballPath], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+  const lines = listing.split("\n").filter(Boolean);
+  if (lines.length === 0) {
+    throw new Error("Repository archive is empty");
+  }
+
+  const archiveRoot = lines[0].replace(/\/$/, "").split("/")[0];
+  const coreArchivePath = `${archiveRoot}/packages/core`;
+  const corePrefix = `${coreArchivePath}/`;
+
+  const hasCore = lines.some((line) => line === corePrefix || line.startsWith(corePrefix));
+
+  if (!hasCore) {
+    throw new Error(`Core package not found in repository: packages/core`);
+  }
+
+  const stripComponents = coreArchivePath.split("/").length;
+
+  await mkdir(destDir, { recursive: true });
+
+  execFileSync(
+    "tar",
+    [
+      "-xzf",
+      tarballPath,
+      "-C",
+      destDir,
+      `--strip-components=${stripComponents}`,
+      coreArchivePath,
+    ],
+    { stdio: "pipe", maxBuffer: 64 * 1024 * 1024 }
+  );
+}
+
+function buildHeaders() {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (token) {
+    return { Authorization: `token ${token}` };
+  }
+  return {};
+}

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",
+    },
+  };
+}

package/cli/file-tree.js

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

package/cli/fs-ignore.js

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