@navneet_25/tempjs 1.0.0

package/README.md

@@ -0,0 +1,237 @@
+# Website Templates
+
+A single repository containing multiple website project templates, plus a small CLI that instantiates any template directly into your current directory.
+
+## Quick start
+
+```bash
+# Install the CLI globally (after publishing or linking locally)
+npm install -g tempjs
+
+# Create a new project
+mkdir hotel-client
+cd hotel-client
+tempjs hotel
+git init
+git add .
+git commit -m "Initial project"
+```
+
+## Available templates
+
+| ID            | Name                 | Description                                      |
+|---------------|----------------------|--------------------------------------------------|
+| `hotel`       | Hotel Website        | Hotel and resort site with admin, gallery, booking |
+| `real-estate` | Real Estate Website  | Property listings with admin panel               |
+
+List templates from the CLI:
+
+```bash
+tempjs list
+```
+
+## CLI usage
+
+```bash
+tempjs list                  # show available templates
+tempjs hotel                 # create project from hotel template
+tempjs real-estate --force   # overwrite existing files
+tempjs --help                # show help
+```
+
+### Options
+
+| Option        | Description |
+|---------------|-------------|
+| `--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) |
+| `--help`      | Show help |
+
+The CLI copies template **contents** into the current directory — not a nested folder:
+
+```
+hotel-client/
+├── .gitignore
+├── package.json
+├── app/
+├── public/
+└── ...
+```
+
+Generated projects are fully independent. No submodule, worktree, or connection to this repository.
+
+## Local development (without publishing)
+
+From this repository root:
+
+```bash
+npm link
+
+mkdir /tmp/hotel-client
+cd /tmp/hotel-client
+tempjs hotel
+```
+
+When templates exist locally under `templates/`, the CLI uses them directly (fast, no network). Use `--remote` to test GitHub fetching.
+
+## Installation
+
+### Global install (npm)
+
+```bash
+npm install -g tempjs
+```
+
+### From this repository
+
+```bash
+git clone https://github.com/<username>/templates.git
+cd templates
+npm link
+```
+
+## Configuration
+
+All template mappings live in **`templates.json`** at the repository root:
+
+```json
+{
+  "repository": {
+    "owner": "your-username",
+    "repo": "templates",
+    "branch": "main",
+    "templatesPath": "templates"
+  },
+  "templates": {
+    "hotel": {
+      "directory": "hotel-website-template",
+      "name": "Hotel Website",
+      "description": "Modern hotel and resort website template"
+    }
+  }
+}
+```
+
+### GitHub repository URL
+
+Configure in one place — `templates.json` or environment variables:
+
+| Variable               | Description |
+|------------------------|-------------|
+| `TEMPLATES_REPO_URL`   | Full URL or `owner/repo` |
+| `TEMPLATES_REPO_OWNER` | GitHub username or org |
+| `TEMPLATES_REPO_REPO`  | Repository name |
+| `TEMPLATES_REPO_BRANCH`| Branch (default: `main`) |
+| `GITHUB_TOKEN`         | Optional token for higher API rate limits |
+
+Example:
+
+```bash
+export TEMPLATES_REPO_URL="https://github.com/myuser/templates"
+tempjs hotel --remote
+```
+
+## How fetching works
+
+`tempjs hotel` does **not** clone the entire repository.
+
+1. The CLI reads the GitHub API tree for the configured branch.
+2. It filters files under `templates/hotel-website-template/`.
+3. Only those files are downloaded (via blob API or raw content).
+4. Files are validated in a temporary directory, then copied to your project.
+
+Other templates are not transferred.
+
+## Repository structure
+
+```
+templates/                          # this repository root
+├── README.md
+├── package.json                    # CLI package (bin: tempjs)
+├── templates.json                  # manifest + repo config
+├── .gitignore                      # for THIS repo only (not copied to projects)
+├── cli/
+│   ├── index.js
+│   ├── config.js
+│   ├── copy.js
+│   └── fetch.js
+└── templates/
+    ├── hotel-website-template/
+    │   ├── .gitignore              # copied to generated projects
+    │   ├── package.json
+    │   ├── app/
+    │   └── ...
+    └── real-estate-website-template/
+        └── ...
+```
+
+## Adding a new template
+
+1. Add a directory under `templates/`, e.g. `templates/restaurant-website-template/`.
+2. Include a template-specific `.gitignore` for that stack (Next.js, Vite, etc.).
+3. Add one entry to `templates.json`:
+
+```json
+"restaurant": {
+  "directory": "restaurant-website-template",
+  "name": "Restaurant Website",
+  "description": "Restaurant website with menu and reservations"
+}
+```
+
+4. Commit and push. No CLI source changes required.
+
+## Gitignore rules
+
+### Template repository (this repo)
+
+The root `.gitignore` keeps the templates repository clean:
+
+- `node_modules/`, `.next/`, `dist/`, build caches, logs
+- `.env` files (but not `.env.example`)
+- OS and IDE junk
+- Nested `.git/` directories inside templates
+
+### Generated projects
+
+Each template has its own `.gitignore` (e.g. Next.js ignores). That file is copied into the generated project. The **root** repository `.gitignore` is never copied.
+
+## Safety
+
+- Non-empty directories: warns and prompts before overwriting (use `--force` to skip).
+- Never copies `.git` from templates.
+- Warns if the target directory is already a Git repository.
+- Does not run `npm install`, builds, or other scripts automatically.
+- Downloads to a temp directory first; cleans up on failure.
+
+## Tech stack (current templates)
+
+Both current templates use:
+
+- **Next.js 16** (App Router)
+- **React 19**
+- **TypeScript**
+- **Tailwind CSS 4**
+- **Prisma** + MariaDB
+- **NextAuth**
+
+After generating a project:
+
+```bash
+pnpm install
+cp .env.example .env   # configure database credentials
+pnpm dev
+```
+
+## Contributing
+
+1. Fork and clone this repository.
+2. Make changes inside `templates/<template-name>/`.
+3. Update `templates.json` if adding a new template.
+4. Test locally with `npm link` and `tempjs <id>`.
+5. Open a pull request.
+
+## License
+
+MIT

package/cli/config.js

@@ -0,0 +1,78 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+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 {{ repository: RepositoryConfig, templates: Record<string, TemplateEntry> }} Manifest */
+
+/**
+ * @returns {Manifest}
+ */
+export function loadManifest() {
+  const manifestPath = join(packageRoot, "templates.json");
+  const raw = readFileSync(manifestPath, "utf8");
+  return JSON.parse(raw);
+}
+
+export function getPackageRoot() {
+  return packageRoot;
+}
+
+/**
+ * Repository settings can be overridden via environment variables.
+ * @param {RepositoryConfig} defaults
+ * @returns {RepositoryConfig}
+ */
+export function resolveRepositoryConfig(defaults) {
+  const url = process.env.TEMPLATES_REPO_URL?.trim();
+  if (url) {
+    const parsed = parseGitHubUrl(url);
+    if (parsed) {
+      return {
+        owner: parsed.owner,
+        repo: parsed.repo,
+        branch:
+          process.env.TEMPLATES_REPO_BRANCH?.trim() || parsed.branch || defaults.branch,
+        templatesPath: defaults.templatesPath,
+      };
+    }
+  }
+
+  const owner = process.env.TEMPLATES_REPO_OWNER?.trim();
+  const repo = process.env.TEMPLATES_REPO_REPO?.trim();
+  const branch = process.env.TEMPLATES_REPO_BRANCH?.trim();
+
+  return {
+    owner: owner || defaults.owner,
+    repo: repo || defaults.repo,
+    branch: branch || defaults.branch,
+    templatesPath: defaults.templatesPath,
+  };
+}
+
+/**
+ * @param {string} url
+ * @returns {{ owner: string, repo: string, branch?: string } | null}
+ */
+function parseGitHubUrl(url) {
+  const patterns = [
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+))?$/,
+    /^git@github\.com:([^/]+)\/([^/.]+)(?:\.git)?$/,
+    /^([^/]+)\/([^/]+)$/,
+  ];
+
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) {
+      return {
+        owner: match[1],
+        repo: match[2].replace(/\.git$/, ""),
+        branch: match[3] || undefined,
+      };
+    }
+  }
+  return null;
+}

package/cli/copy.js

@@ -0,0 +1,164 @@
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readlinkSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { join } from "node:path";
+
+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[]}
+ */
+export function listDirectoryEntries(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((name) => name !== "." && name !== "..");
+}
+
+/**
+ * @param {string} dir
+ * @returns {boolean}
+ */
+export function isDirectoryEmpty(dir) {
+  return listDirectoryEntries(dir).length === 0;
+}
+
+/**
+ * @param {string} targetDir
+ * @returns {boolean}
+ */
+export function targetHasGitRepo(targetDir) {
+  return existsSync(join(targetDir, ".git"));
+}
+
+/**
+ * Files in targetDir that would be overwritten by source copy.
+ * @param {string} sourceDir
+ * @param {string} targetDir
+ * @returns {string[]}
+ */
+export function findConflictingPaths(sourceDir, targetDir) {
+  const conflicts = [];
+  collectConflicts(sourceDir, targetDir, "", conflicts);
+  return conflicts.sort();
+}
+
+/**
+ * @param {string} sourceDir
+ * @param {string} targetDir
+ * @param {string} relative
+ * @param {string[]} conflicts
+ */
+function collectConflicts(sourceDir, targetDir, relative, conflicts) {
+  const currentSource = join(sourceDir, relative);
+  if (!existsSync(currentSource)) return;
+
+  const sourceNames = readdirSync(currentSource);
+  for (const name of sourceNames) {
+    if (shouldSkipFile(name)) continue;
+
+    const relPath = relative ? join(relative, name) : name;
+    const sourcePath = join(sourceDir, relPath);
+    const targetPath = join(targetDir, relPath);
+
+    if (existsSync(targetPath)) {
+      conflicts.push(relPath);
+    }
+
+    if (statSync(sourcePath).isDirectory()) {
+      collectConflicts(sourceDir, targetDir, relPath, conflicts);
+    }
+  }
+}
+
+/**
+ * Copy template source into target directory.
+ * @param {string} sourceDir
+ * @param {string} targetDir
+ * @param {{ force?: boolean }} options
+ */
+export function copyTemplate(sourceDir, targetDir, options = {}) {
+  const force = options.force ?? false;
+
+  if (!existsSync(sourceDir)) {
+    throw new Error(`Template source not found: ${sourceDir}`);
+  }
+
+  if (!force && !isDirectoryEmpty(targetDir)) {
+    const conflicts = findConflictingPaths(sourceDir, targetDir);
+    if (conflicts.length > 0) {
+      const err = new Error("TARGET_NOT_EMPTY");
+      err.conflicts = conflicts;
+      throw err;
+    }
+  }
+
+  copyRecursive(sourceDir, targetDir, "");
+}
+
+/**
+ * @param {string} sourceRoot
+ * @param {string} targetRoot
+ * @param {string} relative
+ */
+function copyRecursive(sourceRoot, targetRoot, relative) {
+  const sourcePath = join(sourceRoot, relative);
+  const names = readdirSync(sourcePath);
+
+  for (const name of names) {
+    if (shouldSkipFile(name)) continue;
+
+    const relPath = relative ? join(relative, name) : name;
+    const from = join(sourceRoot, relPath);
+    const to = join(targetRoot, relPath);
+
+    if (NEVER_OVERWRITE.has(name) && existsSync(to)) {
+      continue;
+    }
+
+    const stat = lstatSync(from);
+    if (stat.isSymbolicLink()) {
+      const linkTarget = readlinkSync(from);
+      mkdirSync(join(to, ".."), { recursive: true });
+      cpSync(from, to, { recursive: true, force: true });
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      mkdirSync(to, { recursive: true });
+      copyRecursive(sourceRoot, targetRoot, relPath);
+    } else {
+      mkdirSync(join(to, ".."), { recursive: true });
+      cpSync(from, to, { force: true });
+    }
+  }
+}
+
+/**
+ * @param {string} dir
+ */
+export function removeDirectory(dir) {
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

package/cli/fetch.js

@@ -0,0 +1,243 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+
+const GITHUB_API = "https://api.github.com";
+const RAW_BASE = "https://raw.githubusercontent.com";
+const LARGE_FILE_BYTES = 1024 * 1024;
+
+/**
+ * Download a single template directory from GitHub without cloning the full repo.
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {string} templateDirectory
+ * @returns {Promise<string>} Path to temp directory containing template files
+ */
+export async function fetchTemplateFromGitHub(repo, templateDirectory) {
+  const prefix = `${repo.templatesPath}/${templateDirectory}/`;
+  const tree = await fetchRepoTree(repo);
+
+  const blobs = tree
+    .filter((entry) => entry.type === "blob" && entry.path.startsWith(prefix))
+    .map((entry) => ({
+      githubPath: entry.path,
+      relPath: entry.path.slice(prefix.length),
+      sha: entry.sha,
+    }));
+
+  if (blobs.length === 0) {
+    throw new Error(
+      `Template directory not found on GitHub: ${repo.templatesPath}/${templateDirectory}`
+    );
+  }
+
+  const tempRoot = await mkdtemp(join(tmpdir(), "template-cli-"));
+  const templateRoot = join(tempRoot, "template");
+  await mkdir(templateRoot, { recursive: true });
+
+  const concurrency = 8;
+  let index = 0;
+  const errors = [];
+
+  async function worker() {
+    while (index < blobs.length) {
+      const current = index++;
+      const blob = blobs[current];
+      try {
+        await downloadBlob(repo, blob, templateRoot);
+      } catch (error) {
+        errors.push({ relPath: blob.relPath, error });
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+
+  if (errors.length > 0) {
+    const detail = errors
+      .slice(0, 5)
+      .map((e) => `${e.relPath}: ${e.error.message}`)
+      .join("\n");
+    throw new Error(
+      `Failed to download ${errors.length} file(s).\n${detail}`
+    );
+  }
+
+  return templateRoot;
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @returns {Promise<Array<{ path: string, type: string, sha: string }>>}
+ */
+async function fetchRepoTree(repo) {
+  const refUrl = `${GITHUB_API}/repos/${repo.owner}/${repo.repo}/git/ref/heads/${repo.branch}`;
+  const refResponse = await githubRequest(refUrl);
+
+  if (!refResponse.ok) {
+    throw await formatGitHubError(
+      refResponse,
+      `Could not resolve branch "${repo.branch}" for ${repo.owner}/${repo.repo}`
+    );
+  }
+
+  const refData = await refResponse.json();
+  const commitSha = refData.object?.sha;
+  if (!commitSha) {
+    throw new Error(`Invalid ref response for branch ${repo.branch}`);
+  }
+
+  const commitUrl = `${GITHUB_API}/repos/${repo.owner}/${repo.repo}/git/commits/${commitSha}`;
+  const commitResponse = await githubRequest(commitUrl);
+  if (!commitResponse.ok) {
+    throw await formatGitHubError(commitResponse, "Could not fetch commit metadata");
+  }
+
+  const commitData = await commitResponse.json();
+  const treeSha = commitData.tree?.sha;
+  if (!treeSha) {
+    throw new Error("Invalid commit response: missing tree SHA");
+  }
+
+  const treeUrl = `${GITHUB_API}/repos/${repo.owner}/${repo.repo}/git/trees/${treeSha}?recursive=1`;
+  const treeResponse = await githubRequest(treeUrl);
+  if (!treeResponse.ok) {
+    throw await formatGitHubError(treeResponse, "Could not fetch repository tree");
+  }
+
+  const treeData = await treeResponse.json();
+  if (treeData.truncated) {
+    throw new Error(
+      "Repository tree is too large for a single API request. Contact the repository maintainer."
+    );
+  }
+
+  return treeData.tree ?? [];
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {{ githubPath: string, relPath: string, sha: string }} blob
+ * @param {string} templateRoot
+ */
+async function downloadBlob(repo, blob, templateRoot) {
+  const { githubPath, relPath, sha } = blob;
+
+  if (relPath.includes(".git/") || relPath === ".git" || githubPath.includes("/.git/")) {
+    return;
+  }
+
+  const baseName = relPath.includes("/") ? relPath.slice(relPath.lastIndexOf("/") + 1) : relPath;
+  if (baseName === ".env" || (baseName.startsWith(".env.") && baseName !== ".env.example")) {
+    return;
+  }
+
+  const targetPath = join(templateRoot, relPath);
+  await mkdir(dirname(targetPath), { recursive: true });
+
+  const blobUrl = `${GITHUB_API}/repos/${repo.owner}/${repo.repo}/git/blobs/${sha}`;
+  const blobResponse = await githubRequest(blobUrl);
+  if (!blobResponse.ok) {
+    throw await formatGitHubError(blobResponse, `Failed to fetch blob for ${relPath}`);
+  }
+
+  const blobData = await blobResponse.json();
+
+  if (blobData.encoding === "base64" && blobData.content && blobData.size <= LARGE_FILE_BYTES) {
+    const content = Buffer.from(blobData.content.replace(/\n/g, ""), "base64");
+    await writeFile(targetPath, content);
+    return;
+  }
+
+  await downloadRawFile(repo, githubPath, targetPath);
+}
+
+/**
+ * @param {import('./config.js').RepositoryConfig} repo
+ * @param {string} githubPath
+ * @param {string} targetPath
+ */
+async function downloadRawFile(repo, githubPath, targetPath) {
+  const url = `${RAW_BASE}/${repo.owner}/${repo.repo}/${repo.branch}/${githubPath}`;
+  const response = await fetch(url, {
+    headers: buildHeaders(),
+    redirect: "follow",
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} for ${url}`);
+  }
+
+  if (!response.body) {
+    throw new Error(`Empty response body for ${url}`);
+  }
+
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(targetPath));
+}
+
+/**
+ * @param {string} url
+ */
+async function githubRequest(url) {
+  return fetch(url, {
+    headers: {
+      ...buildHeaders(),
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+    },
+  });
+}
+
+function buildHeaders() {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (token) {
+    return { Authorization: `Bearer ${token}` };
+  }
+  return {};
+}
+
+/**
+ * @param {Response} response
+ * @param {string} message
+ */
+async function formatGitHubError(response, message) {
+  let detail = message;
+  try {
+    const body = await response.json();
+    if (body?.message) detail = `${message}: ${body.message}`;
+  } catch {
+    // ignore parse errors
+  }
+
+  if (response.status === 404) {
+    return new Error(
+      `${detail}\nVerify TEMPLATES_REPO_URL / templates.json repository settings.`
+    );
+  }
+
+  if (response.status === 403) {
+    return new Error(
+      `${detail}\nGitHub API rate limit may apply. Set GITHUB_TOKEN for higher limits.`
+    );
+  }
+
+  return new Error(`${detail} (HTTP ${response.status})`);
+}
+
+/**
+ * @param {string} packageRoot
+ * @param {string} templatesPath
+ * @param {string} templateDirectory
+ * @returns {Promise<string | null>}
+ */
+export async function resolveLocalTemplate(packageRoot, templatesPath, templateDirectory) {
+  const localPath = join(packageRoot, templatesPath, templateDirectory);
+  try {
+    await readFile(join(localPath, "package.json"));
+    return localPath;
+  } catch {
+    return null;
+  }
+}

package/cli/index.js

@@ -0,0 +1,249 @@
+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 {
+  copyTemplate,
+  findConflictingPaths,
+  isDirectoryEmpty,
+  listDirectoryEntries,
+  removeDirectory,
+  targetHasGitRepo,
+} from "./copy.js";
+import { fetchTemplateFromGitHub, resolveLocalTemplate } from "./fetch.js";
+
+const HELP_TEXT = `
+tempjs — instantiate project templates from GitHub
+
+USAGE
+  tempjs list
+  tempjs <template-id> [options]
+  tempjs --help
+
+OPTIONS
+  --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
+  --help        Show this help message
+
+EXAMPLES
+  mkdir hotel-client && cd hotel-client
+  tempjs hotel
+  git init
+
+ENVIRONMENT
+  TEMPLATES_REPO_URL       GitHub repo URL or owner/repo (overrides templates.json)
+  TEMPLATES_REPO_OWNER     GitHub owner/username
+  TEMPLATES_REPO_REPO      GitHub repository name
+  TEMPLATES_REPO_BRANCH    Branch name (default: main)
+  TEMPLATE_USE_REMOTE=1    Always fetch from GitHub
+  GITHUB_TOKEN / GH_TOKEN    GitHub token for API rate limits
+
+CONFIGURATION
+  Repository and template mappings live in templates.json at the package root.
+`;
+
+/**
+ * @param {Record<string, { name: string, description: string }>} templates
+ */
+function printTemplateList(templates) {
+  console.log("Available templates:\n");
+  const ids = Object.keys(templates).sort();
+  const idWidth = Math.max(...ids.map((id) => id.length), 10);
+
+  for (const id of ids) {
+    const entry = templates[id];
+    console.log(`${id.padEnd(idWidth + 2)}${entry.name}`);
+    if (entry.description) {
+      console.log(`${"".padEnd(idWidth + 2)}${entry.description}`);
+    }
+  }
+  console.log("");
+}
+
+/**
+ * @param {string[]} argv
+ */
+function parseArgs(argv) {
+  const flags = {
+    force: false,
+    remote: false,
+    initGit: false,
+    help: false,
+  };
+  const positionals = [];
+
+  for (const arg of argv) {
+    if (arg === "--force") flags.force = true;
+    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.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return { flags, positionals };
+}
+
+/**
+ * @param {string[]} conflicts
+ */
+function printConflictWarning(conflicts) {
+  console.log("Current directory is not empty.");
+  console.log("The following files may be overwritten:");
+  const preview = conflicts.slice(0, 20);
+  for (const path of preview) {
+    console.log(`  ${path}`);
+  }
+  if (conflicts.length > preview.length) {
+    console.log(`  ... and ${conflicts.length - preview.length} more`);
+  }
+  console.log("");
+}
+
+/**
+ * @param {boolean} force
+ */
+async function confirmOverwrite(force) {
+  if (force) return true;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question("Continue? [y/N] ");
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+/**
+ * @param {string} targetDir
+ * @param {string} templateId
+ * @param {{ force: boolean, remote: boolean, initGit: boolean }} flags
+ */
+async function runTemplate(targetDir, templateId, flags) {
+  const manifest = loadManifest();
+  const entry = manifest.templates[templateId];
+
+  if (!entry) {
+    console.error(`Unknown template: ${templateId}`);
+    console.error("Run `tempjs list` to see available templates.");
+    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";
+
+  let sourceDir = null;
+  let cleanupDir = null;
+
+  try {
+    if (!useRemote) {
+      sourceDir = await resolveLocalTemplate(
+        packageRoot,
+        repo.templatesPath,
+        entry.directory
+      );
+    }
+
+    if (!sourceDir) {
+      console.log(`Fetching template "${templateId}" from ${repo.owner}/${repo.repo}...`);
+      sourceDir = await fetchTemplateFromGitHub(repo, entry.directory);
+      cleanupDir = sourceDir.replace(/[/\\]template$/, "");
+    } else {
+      console.log(`Using local template "${templateId}"...`);
+    }
+
+    if (targetHasGitRepo(targetDir)) {
+      console.warn(
+        "Warning: This directory already contains a .git folder (existing Git repository)."
+      );
+    }
+
+    const entries = listDirectoryEntries(targetDir);
+    const hasContent = entries.length > 0;
+
+    if (hasContent && !flags.force) {
+      const conflicts = findConflictingPaths(sourceDir, targetDir);
+      if (conflicts.length > 0) {
+        printConflictWarning(conflicts);
+        const confirmed = await confirmOverwrite(false);
+        if (!confirmed) {
+          console.log("Aborted.");
+          return;
+        }
+      } else if (!isDirectoryEmpty(targetDir)) {
+        console.log("Current directory is not empty, but no files would be overwritten.");
+        const confirmed = await confirmOverwrite(false);
+        if (!confirmed) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+    }
+
+    const allowOverwrite = flags.force || hasContent;
+    copyTemplate(sourceDir, targetDir, { force: allowOverwrite });
+
+    if (flags.initGit && !targetHasGitRepo(targetDir)) {
+      execSync("git init", { cwd: targetDir, stdio: "inherit" });
+    }
+
+    console.log(`\nTemplate "${entry.name}" created successfully in ${targetDir}`);
+    console.log("\nNext steps:");
+    console.log("  pnpm install   # or npm install");
+    console.log("  pnpm dev       # start development server");
+    if (!flags.initGit && !targetHasGitRepo(targetDir)) {
+      console.log("  git init       # optional: initialize a new repository");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message === "TARGET_NOT_EMPTY") {
+      printConflictWarning(error.conflicts ?? []);
+      console.error("Use --force to overwrite without prompting.");
+      process.exitCode = 1;
+      return;
+    }
+
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  } finally {
+    if (cleanupDir) {
+      removeDirectory(cleanupDir);
+    }
+  }
+}
+
+/**
+ * @param {string[]} argv
+ */
+async function main(argv) {
+  const { flags, positionals } = parseArgs(argv);
+  const command = positionals[0];
+
+  if (flags.help || command === "help" || (!command && argv.length === 0)) {
+    console.log(HELP_TEXT.trim());
+    return;
+  }
+
+  const manifest = loadManifest();
+
+  if (command === "list") {
+    printTemplateList(manifest.templates);
+    return;
+  }
+
+  const targetDir = process.cwd();
+  await runTemplate(targetDir, command, flags);
+}
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@navneet_25/tempjs",
+  "version": "1.0.0",
+  "description": "CLI to instantiate website project templates from a single GitHub repository",
+  "type": "module",
+  "bin": {
+    "tempjs": "./cli/index.js"
+  },
+  "files": [
+    "cli",
+    "templates.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "navneet_25 <navneetnishchal1420@gmail.com>",
+  "keywords": [
+    "template",
+    "cli",
+    "website",
+    "nextjs"
+  ],
+  "license": "MIT"
+}

package/templates.json

@@ -0,0 +1,20 @@
+{
+  "repository": {
+    "owner": "your-username",
+    "repo": "templates",
+    "branch": "main",
+    "templatesPath": "templates"
+  },
+  "templates": {
+    "hotel": {
+      "directory": "hotel-website-template",
+      "name": "Hotel Website",
+      "description": "Modern hotel and resort website with admin panel, gallery, and booking features"
+    },
+    "real-estate": {
+      "directory": "real-estate-website-template",
+      "name": "Real Estate Website",
+      "description": "Real estate and property listing website with admin panel and property management"
+    }
+  }
+}