@mars-stack/cli 5.0.3 → 6.0.0

package/dist/index.js

@@ -8543,6 +8543,217 @@ function upgradeCommand(program2) {
   });
 }
 
+// src/commands/template.ts
+init_logger();
+import fs30 from "fs-extra";
+import path30 from "path";
+import yaml from "js-yaml";
+var FEATURE_GATE_DIRS = {
+  admin: path30.join("src", "features", "admin"),
+  billing: path30.join("src", "features", "billing"),
+  uploads: path30.join("src", "features", "uploads")
+};
+var STATUS_ICONS = {
+  unchanged: "\u2713",
+  updated: "\u2191",
+  new: "+",
+  skipped: "\u2194"
+};
+function listFilesRecursively(dir) {
+  const files = [];
+  if (!fs30.existsSync(dir)) return files;
+  const entries = fs30.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path30.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listFilesRecursively(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function expandManifestEntry(templateDir, entry) {
+  const isGlob = entry.path.endsWith("/**");
+  if (isGlob) {
+    const baseDir = entry.path.slice(0, -3);
+    const templateBase = path30.join(templateDir, ...baseDir.split("/"));
+    const files = listFilesRecursively(templateBase);
+    return files.map(
+      (f) => path30.relative(templateDir, f).split(path30.sep).join("/")
+    );
+  }
+  return [entry.path];
+}
+function readManifest(manifestPath) {
+  const raw = fs30.readFileSync(manifestPath, "utf8");
+  const doc = yaml.load(raw);
+  if (!Array.isArray(doc)) {
+    throw new Error("Invalid sync manifest format: expected a YAML array.");
+  }
+  return doc;
+}
+async function runTemplateSync(options = {}) {
+  log.title("MARS Template Sync");
+  const projectDir = process.cwd();
+  const scaffoldPath = path30.join(projectDir, ".mars", "scaffold.json");
+  if (!await fs30.pathExists(scaffoldPath)) {
+    log.error(
+      "Not a Mars scaffold project. Run `mars create` to scaffold a new project."
+    );
+    process.exitCode = 1;
+    return [];
+  }
+  let fingerprint = null;
+  try {
+    fingerprint = await fs30.readJson(scaffoldPath);
+  } catch {
+    log.warn(
+      "Could not read .mars/scaffold.json \u2014 continuing without checksum comparison."
+    );
+  }
+  const templateDir = getTemplatePath();
+  const manifestPath = path30.join(templateDir, ".mars", "sync-manifest.yaml");
+  if (!await fs30.pathExists(manifestPath)) {
+    log.error(
+      "Sync manifest not found in template. Update @mars-stack/cli to the latest version."
+    );
+    process.exitCode = 1;
+    return [];
+  }
+  let entries;
+  try {
+    entries = readManifest(manifestPath);
+  } catch (error) {
+    log.error(
+      error instanceof Error ? error.message : "Failed to parse sync manifest."
+    );
+    process.exitCode = 1;
+    return [];
+  }
+  const syncCategory = options.only ?? "plumbing";
+  const results = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = path30.join(projectDir, ".mars", "backups", timestamp);
+  for (const entry of entries) {
+    if (entry.category === "excluded") continue;
+    if (entry.feature_gate) {
+      const gateDir = FEATURE_GATE_DIRS[entry.feature_gate];
+      if (gateDir && !await fs30.pathExists(path30.join(projectDir, gateDir))) {
+        continue;
+      }
+    }
+    const shouldSync = entry.category === syncCategory || options.force && entry.category === "user-owned" && syncCategory === "plumbing";
+    const filePaths = expandManifestEntry(templateDir, entry);
+    for (const relativePath of filePaths) {
+      const templateFile = path30.join(templateDir, ...relativePath.split("/"));
+      const projectFile = path30.join(projectDir, ...relativePath.split("/"));
+      if (!shouldSync) {
+        results.push({
+          relativePath,
+          status: "skipped",
+          category: entry.category,
+          reason: entry.category
+        });
+        continue;
+      }
+      if (!await fs30.pathExists(templateFile)) continue;
+      const templateStat = await fs30.stat(templateFile);
+      if (!templateStat.isFile()) continue;
+      const projectExists = await fs30.pathExists(projectFile);
+      if (!projectExists) {
+        if (!options.dryRun) {
+          await fs30.ensureDir(path30.dirname(projectFile));
+          await fs30.copy(templateFile, projectFile);
+        }
+        results.push({
+          relativePath,
+          status: "new",
+          category: entry.category
+        });
+        continue;
+      }
+      const templateChecksum = await checksumFile(templateFile);
+      const projectChecksum = await checksumFile(projectFile);
+      if (templateChecksum === projectChecksum) {
+        results.push({
+          relativePath,
+          status: "unchanged",
+          category: entry.category
+        });
+        continue;
+      }
+      const hasLocalEdits = fingerprint?.checksums?.[relativePath] ? fingerprint.checksums[relativePath] !== projectChecksum : true;
+      if (!options.dryRun) {
+        const backupPath = path30.join(backupDir, ...relativePath.split("/"));
+        await fs30.ensureDir(path30.dirname(backupPath));
+        await fs30.copy(projectFile, backupPath);
+        await fs30.copy(templateFile, projectFile);
+      }
+      results.push({
+        relativePath,
+        status: "updated",
+        category: entry.category,
+        backedUp: true,
+        reason: hasLocalEdits ? "you have local edits \u2014 backup created" : "backup created"
+      });
+    }
+  }
+  if (options.dryRun) {
+    log.step("mars template sync --dry-run");
+    log.blank();
+  }
+  for (const result of results) {
+    const icon = STATUS_ICONS[result.status];
+    let label;
+    switch (result.status) {
+      case "unchanged":
+        label = "unchanged";
+        break;
+      case "updated":
+        label = result.reason ? `will update (${result.reason})` : "will update";
+        break;
+      case "new":
+        label = "new file";
+        break;
+      case "skipped":
+        label = `skipped (${result.reason ?? result.category})`;
+        break;
+    }
+    log.info(`${icon} ${result.relativePath}  ${label}`);
+  }
+  log.blank();
+  const updated = results.filter((r) => r.status === "updated").length;
+  const added = results.filter((r) => r.status === "new").length;
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  const skipped = results.filter((r) => r.status === "skipped").length;
+  if (options.dryRun) {
+    log.info(
+      `Planned: ${updated} to update, ${added} new, ${unchanged} unchanged, ${skipped} skipped`
+    );
+    log.info("Run without --dry-run to apply changes.");
+  } else {
+    log.success(
+      `${updated + added} files updated, ${unchanged} unchanged, ${skipped} skipped`
+    );
+    if (updated > 0) {
+      log.info(`Backups saved to .mars/backups/${timestamp}/`);
+    }
+  }
+  return results;
+}
+function templateCommand(program2) {
+  const template = program2.command("template").description("Template management commands");
+  template.command("sync").description(
+    "Sync plumbing files from the upstream Mars template into your project"
+  ).option("--dry-run", "Show planned changes without writing any files").option("--force", "Also overwrite user-owned files (with backup)").option(
+    "--only <category>",
+    "Limit sync to a specific category (default: plumbing)"
+  ).action(async (syncOptions) => {
+    await runTemplateSync(syncOptions);
+  });
+}
+
 // src/index.ts
 init_blog();
 init_dark_mode();
@@ -8629,6 +8840,7 @@ program.command("doctor").description("Check your development environment").opti
   await doctorCommand(options);
 });
 upgradeCommand(program);
+templateCommand(program);
 program.command("telemetry").description("Manage anonymous usage telemetry").argument("<action>", "enable or disable").action((action) => {
   if (action === "enable") {
     enableTelemetry();