rothzerg 0.1.0

package/dist/cli.js

@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import path8 from "path";
+import { fileURLToPath } from "url";
+import fs7 from "fs";
+import * as p4 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/commands/create.ts
+import path6 from "path";
+import * as p2 from "@clack/prompts";
+import pc from "picocolors";
+
+// src/engine/discovery.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".html",
+  ".css",
+  ".scss",
+  ".md",
+  ".txt",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".svg",
+  ".dart",
+  ".gradle",
+  ".kt",
+  ".swift",
+  ".plist",
+  ".sh",
+  ".env",
+  ".gitignore",
+  ".npmrc",
+  ".prettierrc",
+  ".eslintrc",
+  ".editorconfig"
+]);
+function isTextFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  const textBasenames = /* @__PURE__ */ new Set([
+    "makefile",
+    "dockerfile",
+    "procfile",
+    "rakefile",
+    ".env",
+    ".gitignore",
+    ".npmrc",
+    ".prettierrc"
+  ]);
+  return TEXT_EXTENSIONS.has(ext) || textBasenames.has(base);
+}
+function applyFileRename(relativePath) {
+  const parts = relativePath.split(path.sep);
+  const renamed = parts.map((part) => {
+    if (part.startsWith("_") && !part.startsWith("__")) {
+      return "." + part.slice(1);
+    }
+    return part;
+  });
+  return renamed.join(path.sep);
+}
+function listFilesRecursive(dir) {
+  const results = [];
+  function walk(current, relative) {
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRelative = relative ? path.join(relative, entry.name) : entry.name;
+      const entryAbsolute = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(entryAbsolute, entryRelative);
+      } else {
+        results.push(entryRelative);
+      }
+    }
+  }
+  walk(dir, "");
+  return results;
+}
+function readJson(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(`Failed to read JSON at ${filePath}: ${err.message}`);
+  }
+}
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function exists(p5) {
+  return fs.existsSync(p5);
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function matchesGlob(pattern, filePath) {
+  const normalizedFile = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexStr = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "__STAR__").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/__GLOBSTAR__/g, ".*").replace(/__STAR__/g, "\\*");
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(normalizedFile);
+}
+function matchesAnyGlob(patterns, filePath) {
+  return patterns.some((p5) => matchesGlob(p5, filePath));
+}
+
+// src/engine/discovery.ts
+var TEMPLATE_CONFIG_FILENAME = "rothzerg.template.json";
+function discoverTemplates(templatesDir) {
+  if (!fs2.existsSync(templatesDir)) {
+    return [];
+  }
+  const entries = fs2.readdirSync(templatesDir, { withFileTypes: true });
+  const templates = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith("_")) continue;
+    const configPath = path2.join(templatesDir, entry.name, TEMPLATE_CONFIG_FILENAME);
+    if (!fs2.existsSync(configPath)) continue;
+    try {
+      const config = readJson(configPath);
+      templates.push(config);
+    } catch {
+    }
+  }
+  templates.sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    const aOrder = a.order ?? 999;
+    const bOrder = b.order ?? 999;
+    if (aOrder !== bOrder) return aOrder - bOrder;
+    return a.displayName.localeCompare(b.displayName);
+  });
+  return templates;
+}
+function loadTemplateConfig(templatesDir, name) {
+  const configPath = path2.join(templatesDir, name, TEMPLATE_CONFIG_FILENAME);
+  if (!fs2.existsSync(configPath)) {
+    throw new Error(`Template "${name}" not found at ${configPath}`);
+  }
+  return readJson(configPath);
+}
+function getTemplateDir(templatesDir, name) {
+  return path2.join(templatesDir, name);
+}
+function groupByCategory(templates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const group = groups.get(template.category) ?? [];
+    group.push(template);
+    groups.set(template.category, group);
+  }
+  return groups;
+}
+
+// src/engine/inheritance.ts
+import path3 from "path";
+import fs3 from "fs";
+function resolveTemplate(templatesDir, templateConfig) {
+  if (!templateConfig.extends) {
+    const dir = getTemplateDir(templatesDir, templateConfig.name);
+    const files2 = buildFileList(dir, dir);
+    return { config: templateConfig, files: files2, dir };
+  }
+  const baseConfig = loadTemplateConfig(templatesDir, templateConfig.extends);
+  const baseDir = getTemplateDir(templatesDir, templateConfig.extends);
+  const childDir = getTemplateDir(templatesDir, templateConfig.name);
+  const overridesDir = path3.join(childDir, "overrides");
+  const baseFiles = buildFileList(baseDir, baseDir);
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const f of baseFiles) {
+    fileMap.set(f.relativePath, f);
+  }
+  if (fs3.existsSync(overridesDir)) {
+    const overrideFiles = buildFileList(overridesDir, overridesDir);
+    for (const f of overrideFiles) {
+      fileMap.set(f.relativePath, f);
+    }
+  }
+  const files = Array.from(fileMap.values());
+  const mergedConfig = mergeConfigs(baseConfig, templateConfig);
+  return { config: mergedConfig, files, dir: baseDir };
+}
+function buildFileList(dir, rootDir) {
+  const relativePaths = listFilesRecursive(dir);
+  return relativePaths.filter((rel) => {
+    const normalized = rel.replace(/\\/g, "/");
+    return normalized !== "rothzerg.template.json" && !normalized.startsWith("overrides/");
+  }).map((relativePath) => ({
+    src: path3.join(rootDir, relativePath),
+    relativePath
+  }));
+}
+function mergeConfigs(base, child) {
+  return {
+    // Scalar fields: child wins
+    name: child.name,
+    displayName: child.displayName,
+    description: child.description,
+    icon: child.icon ?? base.icon,
+    category: child.category,
+    order: child.order ?? base.order,
+    extends: child.extends,
+    // Prompts: concatenated
+    prompts: [...base.prompts ?? [], ...child.prompts ?? []],
+    // Derived: merged, child overrides
+    derived: { ...base.derived ?? {}, ...child.derived ?? {} },
+    // Target: child wins, falls back to base
+    target: child.target ?? base.target,
+    // ConditionalFiles: merged, child overrides
+    conditionalFiles: {
+      ...base.conditionalFiles ?? {},
+      ...child.conditionalFiles ?? {}
+    },
+    // Hooks: concatenated
+    hooks: {
+      postCreate: [
+        ...base.hooks?.postCreate ?? [],
+        ...child.hooks?.postCreate ?? []
+      ],
+      postUpgrade: [
+        ...base.hooks?.postUpgrade ?? [],
+        ...child.hooks?.postUpgrade ?? []
+      ]
+    },
+    // Upgrade: child wins
+    upgrade: child.upgrade ?? base.upgrade,
+    // NextSteps: child wins
+    nextSteps: child.nextSteps ?? base.nextSteps
+  };
+}
+
+// src/engine/prompts.ts
+import * as p from "@clack/prompts";
+
+// src/engine/placeholders.ts
+var FILTERS = {
+  pascalCase: (v) => v.replace(/[-_.\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase()),
+  camelCase: (v) => v.replace(/[-_.\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toLowerCase()),
+  snakeCase: (v) => v.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-.\s]+/g, "_").toLowerCase(),
+  kebabCase: (v) => v.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_.\s]+/g, "-").toLowerCase(),
+  titleCase: (v) => {
+    const stripped = v.replace(/\.[a-z]{2,}$/i, "");
+    return stripped.charAt(0).toUpperCase() + stripped.slice(1).toLowerCase();
+  },
+  upperCase: (v) => v.toUpperCase(),
+  lowerCase: (v) => v.toLowerCase(),
+  stripTld: (v) => v.replace(/\.[a-z]{2,}$/i, "")
+};
+function applyFilters(value, filterNames) {
+  return filterNames.reduce((v, name) => {
+    const filter = FILTERS[name.trim()];
+    if (!filter) throw new Error(`Unknown placeholder filter: "${name.trim()}"`);
+    return filter(v);
+  }, value);
+}
+function resolveExpr(expr, vars, configVars) {
+  const parts = expr.split("|").map((p5) => p5.trim());
+  const [head, ...filters] = parts;
+  let value;
+  if (head.startsWith("config:")) {
+    const key = head.slice("config:".length);
+    value = configVars[key] ?? "";
+  } else if (head.startsWith("builtIn:")) {
+    const key = head.slice("builtIn:".length);
+    value = resolveBuiltIn(key);
+  } else {
+    const raw = vars[head];
+    if (raw === void 0) return `{{${expr}}}`;
+    value = String(raw);
+  }
+  return filters.length > 0 ? applyFilters(value, filters) : value;
+}
+function resolveBuiltIn(key) {
+  switch (key) {
+    case "year":
+      return String((/* @__PURE__ */ new Date()).getFullYear());
+    case "timestamp":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "date":
+      return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    default:
+      return "";
+  }
+}
+var PLACEHOLDER_RE = /\{\{([^}]+)\}\}/g;
+function interpolate(template, vars, configVars = {}) {
+  return template.replace(PLACEHOLDER_RE, (match, expr) => {
+    try {
+      return resolveExpr(expr.trim(), vars, configVars);
+    } catch {
+      return match;
+    }
+  });
+}
+function computeDerived(derived, vars, configVars = {}) {
+  const result = { ...vars };
+  for (const [key, template] of Object.entries(derived)) {
+    result[key] = interpolate(template, result, configVars);
+  }
+  return result;
+}
+function processFileContent(content, vars, configVars = {}) {
+  return interpolate(content, vars, configVars);
+}
+function evaluateCondition(condition, vars, configVars = {}) {
+  const trimmed = condition.trim();
+  if (trimmed.startsWith("!")) {
+    const inner = trimmed.slice(1).trim();
+    return !evaluateCondition(inner, vars, configVars);
+  }
+  const resolved = interpolate(trimmed, vars, configVars);
+  if (resolved === "true" || resolved === "1" || resolved === "yes") return true;
+  if (resolved === "false" || resolved === "0" || resolved === "no" || resolved === "") return false;
+  return resolved.length > 0;
+}
+
+// src/engine/prompts.ts
+async function runPrompts(prompts, prefilled = {}, configVars = {}) {
+  const vars = { ...prefilled };
+  for (const prompt of prompts) {
+    if (vars[prompt.name] !== void 0) continue;
+    const answer = await runSinglePrompt(prompt, vars, configVars);
+    if (p.isCancel(answer)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    vars[prompt.name] = answer;
+  }
+  return vars;
+}
+async function runSinglePrompt(prompt, currentVars, configVars) {
+  const message = prompt.message;
+  switch (prompt.type) {
+    case "text": {
+      const defaultValue = resolveDefault(prompt.default, currentVars, configVars);
+      return p.text({
+        message,
+        placeholder: prompt.placeholder,
+        defaultValue: typeof defaultValue === "string" ? defaultValue : void 0,
+        validate: prompt.validate ? (value) => {
+          const pattern = new RegExp(prompt.validate);
+          if (!pattern.test(value)) {
+            return prompt.validateMessage ?? `Must match pattern: ${prompt.validate}`;
+          }
+          return void 0;
+        } : void 0
+      });
+    }
+    case "confirm": {
+      const defaultValue = resolveDefault(prompt.default, currentVars, configVars);
+      return p.confirm({
+        message,
+        initialValue: typeof defaultValue === "boolean" ? defaultValue : prompt.default
+      });
+    }
+    case "select": {
+      const options = (prompt.options ?? []).map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint
+      }));
+      return p.select({ message, options });
+    }
+    case "multiselect": {
+      const options = (prompt.options ?? []).map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint
+      }));
+      return p.multiselect({
+        message,
+        options,
+        required: prompt.required ?? false
+      });
+    }
+    default:
+      throw new Error(`Unknown prompt type: "${prompt.type}"`);
+  }
+}
+function resolveDefault(defaultValue, vars, configVars) {
+  if (defaultValue === void 0) return void 0;
+  if (typeof defaultValue === "boolean") return defaultValue;
+  if (Array.isArray(defaultValue)) return defaultValue;
+  return interpolate(defaultValue, vars, configVars);
+}
+function parseCliFlags(args) {
+  const vars = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith("--")) continue;
+    const withoutDashes = arg.slice(2);
+    if (withoutDashes.includes("=")) {
+      const [key, ...valueParts] = withoutDashes.split("=");
+      vars[key] = coerceValue(valueParts.join("="));
+    } else {
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        vars[withoutDashes] = coerceValue(next);
+        i++;
+      }
+    }
+  }
+  return vars;
+}
+function coerceValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+
+// src/engine/conditions.ts
+function filterConditionalFiles(files, conditionalFiles, vars, configVars = {}) {
+  if (!conditionalFiles || Object.keys(conditionalFiles).length === 0) {
+    return files;
+  }
+  return files.filter((file) => {
+    const normalizedPath = file.relativePath.replace(/\\/g, "/");
+    for (const [glob, condition] of Object.entries(conditionalFiles)) {
+      if (matchesGlob(glob, normalizedPath)) {
+        const include = evaluateCondition(condition, vars, configVars);
+        if (!include) return false;
+      }
+    }
+    return true;
+  });
+}
+
+// src/engine/copy.ts
+import fs4 from "fs";
+import path4 from "path";
+function copyFiles(files, targetDir, vars, configVars = {}) {
+  const copied = [];
+  const skipped = [];
+  ensureDir(targetDir);
+  for (const file of files) {
+    const renamedRelative = applyFileRename(file.relativePath);
+    const destPath = path4.join(targetDir, renamedRelative);
+    ensureDir(path4.dirname(destPath));
+    if (isTextFile(file.src)) {
+      try {
+        const content = fs4.readFileSync(file.src, "utf-8");
+        const processed = processFileContent(content, vars, configVars);
+        fs4.writeFileSync(destPath, processed, "utf-8");
+        copied.push(renamedRelative);
+      } catch {
+        fs4.copyFileSync(file.src, destPath);
+        copied.push(renamedRelative);
+      }
+    } else {
+      fs4.copyFileSync(file.src, destPath);
+      copied.push(renamedRelative);
+    }
+  }
+  return { copied, skipped };
+}
+function copyFileWithTransform(src, dest, vars, configVars = {}) {
+  ensureDir(path4.dirname(dest));
+  if (isTextFile(src)) {
+    const content = fs4.readFileSync(src, "utf-8");
+    const processed = processFileContent(content, vars, configVars);
+    fs4.writeFileSync(dest, processed, "utf-8");
+  } else {
+    fs4.copyFileSync(src, dest);
+  }
+}
+
+// src/engine/hooks.ts
+import { spawnSync } from "child_process";
+async function runHooks(hooks, context) {
+  const results = [];
+  for (const hook of hooks) {
+    if (hook.when) {
+      const shouldRun = evaluateCondition(hook.when, context.vars, context.configVars);
+      if (!shouldRun) continue;
+    }
+    const result = await runHook(hook, context);
+    results.push(result);
+  }
+  return results;
+}
+async function runHook(hook, context) {
+  const hookName = interpolate(hook.run, context.vars, context.configVars);
+  try {
+    if (hook.builtin) {
+      const builtin = context.builtins[hook.run];
+      if (!builtin) {
+        throw new Error(`Unknown built-in hook: "${hook.run}"`);
+      }
+      await builtin(context);
+      return { hook: hookName, success: true };
+    }
+    const cwd = hook.cwd ? interpolate(hook.cwd, context.vars, context.configVars) : context.projectDir;
+    const [cmd, ...args] = hookName.split(" ");
+    const result = spawnSync(cmd, args, {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+    if (result.status !== 0) {
+      throw new Error(`Command exited with code ${result.status ?? "unknown"}`);
+    }
+    return { hook: hookName, success: true };
+  } catch (err) {
+    return { hook: hookName, success: false, error: err.message };
+  }
+}
+
+// src/hooks/register-website.ts
+import fs5 from "fs";
+import path5 from "path";
+var registerWebsite = (context) => {
+  const { vars, configVars } = context;
+  const websitesRoot = configVars["websitesRoot"];
+  if (!websitesRoot) {
+    throw new Error(
+      'register-website hook requires "websitesRoot" in global config. Set it in ~/.rothzerg/config.json or via --config flag.'
+    );
+  }
+  const indexPath = path5.join(websitesRoot, "app", "index.ts");
+  if (!fs5.existsSync(indexPath)) {
+    throw new Error(`Could not find app/index.ts at: ${indexPath}`);
+  }
+  const domain = String(vars["domain"] ?? "");
+  const handlerName = String(vars["handlerName"] ?? `handleRequest`);
+  const localDomain = String(vars["localDomain"] ?? `${domain.replace(/\.[^.]+$/, "")}.localhost.com`);
+  let content = fs5.readFileSync(indexPath, "utf-8");
+  const importStatement = `import { handleRequest as ${handlerName} } from "./websites/${domain}";`;
+  if (!content.includes(importStatement)) {
+    const lastImportMatch = [...content.matchAll(/^import .+;?$/gm)];
+    if (lastImportMatch.length > 0) {
+      const lastImport = lastImportMatch[lastImportMatch.length - 1];
+      const insertAt = lastImport.index + lastImport[0].length;
+      content = content.slice(0, insertAt) + "\n" + importStatement + content.slice(insertAt);
+    } else {
+      content = importStatement + "\n" + content;
+    }
+  }
+  const websiteEntry = `  {
+    location: "${domain}",
+    domains: ["${localDomain}", "dev.${domain}", "www.${domain}", "${domain}"],
+    handleRequest: (hostname: string, pathname: string, req: Request) => ${handlerName}(hostname, pathname),
+  },`;
+  if (!content.includes(`location: "${domain}"`)) {
+    const arrayMatch = content.match(/const websites[^=]*=\s*\[/);
+    if (arrayMatch && arrayMatch.index !== void 0) {
+      const startIdx = arrayMatch.index + arrayMatch[0].length;
+      let depth = 1;
+      let i = startIdx;
+      while (i < content.length && depth > 0) {
+        if (content[i] === "[") depth++;
+        else if (content[i] === "]") depth--;
+        i++;
+      }
+      const closingIdx = i - 1;
+      content = content.slice(0, closingIdx) + "\n" + websiteEntry + "\n" + content.slice(closingIdx);
+    } else {
+      throw new Error(
+        "Could not find `const websites = [` array in app/index.ts. Please manually add the entry."
+      );
+    }
+  }
+  fs5.writeFileSync(indexPath, content, "utf-8");
+};
+
+// src/commands/create.ts
+async function createCommand(options) {
+  const { templatesDir, globalConfig, cliFlags, version } = options;
+  const configVars = globalConfig;
+  const allTemplates = discoverTemplates(templatesDir);
+  if (allTemplates.length === 0) {
+    p2.log.error("No templates found in " + templatesDir);
+    process.exit(1);
+  }
+  let templateConfig;
+  if (options.templateName) {
+    try {
+      templateConfig = loadTemplateConfig(templatesDir, options.templateName);
+    } catch {
+      p2.log.error(`Template "${options.templateName}" not found.`);
+      p2.log.info(`Available templates: ${allTemplates.map((t) => t.name).join(", ")}`);
+      process.exit(1);
+    }
+  } else {
+    templateConfig = await promptTemplateSelection(allTemplates);
+  }
+  const resolved = resolveTemplate(templatesDir, templateConfig);
+  const config = resolved.config;
+  const answers = await runPrompts(config.prompts, cliFlags, configVars);
+  const vars = computeDerived(config.derived ?? {}, answers, configVars);
+  const targetDir = resolveTargetDir(config, vars, configVars);
+  if (exists(targetDir)) {
+    const overwrite = await p2.confirm({
+      message: `Directory ${pc.yellow(targetDir)} already exists. Continue anyway?`,
+      initialValue: false
+    });
+    if (p2.isCancel(overwrite) || !overwrite) {
+      p2.cancel("Aborted.");
+      process.exit(0);
+    }
+  }
+  const filteredFiles = filterConditionalFiles(
+    resolved.files,
+    config.conditionalFiles,
+    vars,
+    configVars
+  );
+  p2.log.step(`Creating ${pc.cyan(config.displayName)} \u2192 ${pc.dim(targetDir)}`);
+  const { copied } = copyFiles(filteredFiles, targetDir, vars, configVars);
+  p2.log.success(`Copied ${copied.length} files`);
+  const projectConfigPath = path6.join(targetDir, ".rothzerg.json");
+  writeJson(projectConfigPath, {
+    engine: "rothzerg",
+    template: config.name,
+    version,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    variables: vars
+  });
+  if (config.hooks?.postCreate && config.hooks.postCreate.length > 0) {
+    const hookContext = {
+      vars,
+      configVars,
+      projectDir: targetDir,
+      builtins: {
+        "register-website": registerWebsite
+      }
+    };
+    const results = await runHooks(config.hooks.postCreate, hookContext);
+    for (const result of results) {
+      if (result.success) {
+        p2.log.success(result.hook);
+      } else {
+        p2.log.warn(`${result.hook} \u2014 ${result.error}`);
+      }
+    }
+  }
+  p2.outro(pc.green("Done! Your project is ready."));
+  if (config.nextSteps && config.nextSteps.length > 0) {
+    console.log("\n  Next steps:");
+    for (const step of config.nextSteps) {
+      console.log("  " + pc.cyan(interpolate(step, vars, configVars)));
+    }
+    console.log();
+  }
+}
+async function promptTemplateSelection(templates) {
+  const groups = groupByCategory(templates);
+  const options = [];
+  for (const [category, items] of groups) {
+    const groupLabel = category.charAt(0).toUpperCase() + category.slice(1) + "s";
+    for (const tmpl of items) {
+      options.push({
+        value: tmpl.name,
+        label: `${tmpl.icon ?? "\u2022"} ${tmpl.displayName}`,
+        hint: tmpl.description,
+        group: groupLabel
+      });
+    }
+  }
+  const selected = await p2.select({
+    message: "What would you like to create?",
+    options
+  });
+  if (p2.isCancel(selected)) {
+    p2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return templates.find((t) => t.name === selected);
+}
+function resolveTargetDir(config, vars, configVars) {
+  const { target } = config;
+  const dirName = interpolate(target.dirName, vars, configVars);
+  if (target.type === "subdirectory" && target.baseDir) {
+    const baseDir = interpolate(target.baseDir, vars, configVars);
+    return path6.resolve(baseDir, dirName);
+  }
+  return path6.resolve(process.cwd(), dirName);
+}
+
+// src/commands/upgrade.ts
+import path7 from "path";
+import fs6 from "fs";
+import * as p3 from "@clack/prompts";
+import pc2 from "picocolors";
+async function upgradeCommand(options) {
+  const { projectDir, templatesDir, globalConfig, dryRun, version } = options;
+  const configVars = globalConfig;
+  const projectConfigPath = path7.join(projectDir, ".rothzerg.json");
+  if (!exists(projectConfigPath)) {
+    p3.log.error(
+      `No ${pc2.yellow(".rothzerg.json")} found in ${projectDir}.
+  Run this command from inside a project created with rothzerg.`
+    );
+    process.exit(1);
+  }
+  const projectConfig = readJson(projectConfigPath);
+  const storedVars = projectConfig.variables;
+  p3.intro(`Upgrading ${pc2.cyan(projectConfig.template)} (was v${projectConfig.version} \u2192 now v${version})`);
+  const templateConfig = loadTemplateConfig(templatesDir, projectConfig.template);
+  const resolved = resolveTemplate(templatesDir, templateConfig);
+  const config = resolved.config;
+  const vars = computeDerived(config.derived ?? {}, storedVars, configVars);
+  const filteredFiles = filterConditionalFiles(
+    resolved.files,
+    config.conditionalFiles,
+    vars,
+    configVars
+  );
+  const upgradeRules = config.upgrade;
+  const summary = {
+    merged: [],
+    overwritten: [],
+    added: [],
+    skipped: []
+  };
+  for (const file of filteredFiles) {
+    const rel = file.relativePath.replace(/\\/g, "/");
+    const destPath = path7.join(projectDir, rel);
+    const destExists = exists(destPath);
+    if (matchesAnyGlob(upgradeRules.ignore, rel)) {
+      summary.skipped.push(rel);
+      continue;
+    }
+    if (matchesAnyGlob(upgradeRules.merge, rel)) {
+      if (!dryRun) {
+        mergeFile(file.src, destPath, rel);
+      }
+      summary.merged.push(rel);
+      continue;
+    }
+    if (matchesAnyGlob(upgradeRules.overwrite, rel)) {
+      if (!dryRun) {
+        if (destExists) {
+          fs6.copyFileSync(destPath, destPath + ".rothzerg-backup");
+        }
+        copyFileWithTransform(file.src, destPath, vars, configVars);
+      }
+      summary.overwritten.push(rel);
+      continue;
+    }
+    if (!destExists) {
+      if (!dryRun) {
+        copyFileWithTransform(file.src, destPath, vars, configVars);
+      }
+      summary.added.push(rel);
+    } else {
+      summary.skipped.push(rel);
+    }
+  }
+  if (dryRun) {
+    p3.log.info(pc2.yellow("Dry run \u2014 no changes were made."));
+    console.log();
+  }
+  if (summary.overwritten.length > 0) {
+    p3.log.success(`Overwritten (${summary.overwritten.length}):`);
+    for (const f of summary.overwritten) console.log("  " + pc2.cyan(f));
+  }
+  if (summary.merged.length > 0) {
+    p3.log.success(`Merged (${summary.merged.length}):`);
+    for (const f of summary.merged) console.log("  " + pc2.cyan(f));
+  }
+  if (summary.added.length > 0) {
+    p3.log.success(`Added (${summary.added.length}):`);
+    for (const f of summary.added) console.log("  " + pc2.green(f));
+  }
+  if (summary.skipped.length > 0) {
+    p3.log.info(`Skipped (${summary.skipped.length})`);
+  }
+  if (!dryRun) {
+    writeJson(projectConfigPath, {
+      ...projectConfig,
+      version
+    });
+  }
+  if (!dryRun && config.hooks?.postUpgrade && config.hooks.postUpgrade.length > 0) {
+    const hookContext = {
+      vars,
+      configVars,
+      projectDir,
+      builtins: {
+        "register-website": registerWebsite
+      }
+    };
+    const results = await runHooks(config.hooks.postUpgrade, hookContext);
+    for (const result of results) {
+      if (result.success) {
+        p3.log.success(result.hook);
+      } else {
+        p3.log.warn(`${result.hook} \u2014 ${result.error}`);
+      }
+    }
+  }
+  p3.outro(pc2.green("Upgrade complete."));
+}
+function mergeFile(srcPath, destPath, rel) {
+  if (rel === "package.json" || rel.endsWith("/package.json")) {
+    mergePackageJson(srcPath, destPath);
+    return;
+  }
+  if (rel === "pubspec.yaml" || rel.endsWith("/pubspec.yaml")) {
+    fs6.copyFileSync(srcPath, destPath);
+    return;
+  }
+  fs6.copyFileSync(srcPath, destPath);
+}
+function mergePackageJson(srcPath, destPath) {
+  if (!exists(destPath)) {
+    fs6.copyFileSync(srcPath, destPath);
+    return;
+  }
+  const template = JSON.parse(fs6.readFileSync(srcPath, "utf-8"));
+  const existing = JSON.parse(fs6.readFileSync(destPath, "utf-8"));
+  const merged = {
+    ...template,
+    // Preserve user fields
+    name: existing.name ?? template.name,
+    version: existing.version ?? template.version,
+    description: existing.description ?? template.description,
+    private: existing.private ?? template.private,
+    author: existing.author ?? template.author,
+    license: existing.license ?? template.license,
+    // Merge dependencies: template versions take precedence, user additions kept
+    dependencies: mergeDepMap(template.dependencies, existing.dependencies),
+    devDependencies: mergeDepMap(template.devDependencies, existing.devDependencies),
+    // Scripts: template wins, but user-added scripts are preserved
+    scripts: {
+      ...existing.scripts ?? {},
+      ...template.scripts ?? {}
+    }
+  };
+  fs6.writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+function mergeDepMap(templateDeps, existingDeps) {
+  const result = { ...existingDeps ?? {} };
+  for (const [pkg2, ver] of Object.entries(templateDeps ?? {})) {
+    result[pkg2] = ver;
+  }
+  return result;
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path8.dirname(__filename);
+var TEMPLATES_DIR = path8.resolve(__dirname, "..", "templates");
+var pkg = JSON.parse(
+  fs7.readFileSync(path8.resolve(__dirname, "..", "package.json"), "utf-8")
+);
+var VERSION = pkg.version;
+function loadGlobalConfig() {
+  const configPaths = [
+    // Project-local config (takes priority)
+    path8.resolve(process.cwd(), ".rothzerg", "config.json"),
+    // User home config
+    path8.resolve(process.env["HOME"] ?? "~", ".rothzerg", "config.json")
+  ];
+  for (const configPath of configPaths) {
+    if (fs7.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+var HELP = `
+  ${pc3.bold("rothzerg")} v${VERSION}
+
+  ${pc3.dim("Plugin-style CLI engine for scaffolding projects from config-driven templates.")}
+
+  ${pc3.bold("Usage:")}
+    ${pc3.cyan("rothzerg create [template]")}    Create a new project
+    ${pc3.cyan("rothzerg upgrade")}              Upgrade the current project
+
+  ${pc3.bold("Options:")}
+    ${pc3.cyan("--help, -h")}                    Show this help
+    ${pc3.cyan("--version, -v")}                 Show version
+    ${pc3.cyan("--dry-run")}                     (upgrade) Preview without applying changes
+
+  ${pc3.bold("Examples:")}
+    ${pc3.dim("bunx rothzerg create")}
+    ${pc3.dim("bunx rothzerg create web-app --name my-app")}
+    ${pc3.dim("bunx rothzerg create website-blog --domain myblog.com")}
+    ${pc3.dim("bunx rothzerg upgrade")}
+    ${pc3.dim("bunx rothzerg upgrade --dry-run")}
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  const command = args[0];
+  const rest = args.slice(1);
+  p4.intro(`${pc3.bold("rothzerg")} ${pc3.dim(`v${VERSION}`)}`);
+  const globalConfig = loadGlobalConfig();
+  switch (command) {
+    case "create": {
+      const templateName = rest[0] && !rest[0].startsWith("--") ? rest[0] : void 0;
+      const flagArgs = templateName ? rest.slice(1) : rest;
+      const cliFlags = parseCliFlags(flagArgs);
+      await createCommand({
+        templateName,
+        cliFlags,
+        templatesDir: TEMPLATES_DIR,
+        globalConfig,
+        version: VERSION
+      });
+      break;
+    }
+    case "upgrade": {
+      const dryRun = rest.includes("--dry-run");
+      await upgradeCommand({
+        dryRun,
+        projectDir: process.cwd(),
+        templatesDir: TEMPLATES_DIR,
+        globalConfig,
+        version: VERSION
+      });
+      break;
+    }
+    default:
+      p4.log.error(`Unknown command: "${command}"`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(pc3.red("Fatal error:"), err.message ?? err);
+  process.exit(1);
+});