ferst-core 0.7.12 → 0.8.0

package/bin/ferst-update.mjs

@@ -11,8 +11,9 @@
 //   npx --no-install ferst-update --dry-run  # fetch + show what WOULD change; no writes
 //   npx --no-install ferst-update --no-core  # scaffold sync only; skip the npm bump
 //
-// The template-owned paths and the git upstream come from the repo's own
-// `ferst-template.json` (the ownership manifest). Client paths are NEVER touched —
+// The git upstream comes from the repo's own `ferst-template.json` (the ownership
+// manifest); the paths to sync come from the TEMPLATE's manifest at its latest version, so
+// a path it newly owns arrives in the same run (falling back to the repo's list). Client paths are NEVER touched —
 // the scaffold sync is a per-path OVERWRITE from upstream, conflict-free by
 // construction (see docs/CLIENT-TEMPLATE-ARCHITECTURE.md, Workstream D). It never
 // merges/rebases (the CMS bot commits to client repos continuously; a history merge
@@ -87,6 +88,35 @@ export function resolveOwnedPaths(manifest) {
   return owned;
 }
 
+/**
+ * The paths to sync: the TEMPLATE's own list at its latest version, so a path it newly
+ * owns arrives in the same run. Falls back to the site's list when the template's
+ * manifest can't be read or declares none (an older template, a fetch problem).
+ */
+export function ownedPathsToSync(localOwned, upstreamManifestRaw) {
+  try {
+    return resolveOwnedPaths(parseManifest(upstreamManifestRaw));
+  } catch {
+    return localOwned;
+  }
+}
+
+/**
+ * The manifest text to build on after the sync. The manifest is itself template-owned, so
+ * the sync has just replaced it: build on that, or the site's old ownedPaths would be
+ * written back over the template's new ones. Falls back to the pre-sync text when the file
+ * is missing or unreadable.
+ */
+export function manifestAfterSync(preSyncRaw, postSyncRaw) {
+  if (typeof postSyncRaw !== 'string') return preSyncRaw;
+  try {
+    parseManifest(postSyncRaw);
+    return postSyncRaw;
+  } catch {
+    return preSyncRaw;
+  }
+}
+
 /**
  * The template git URL to sync the scaffold from. Uses the manifest's `upstream`
  * when present; otherwise falls back to the canonical template repo and flags it so
@@ -280,11 +310,27 @@ function readSiteMeta(cwd) {
   }
 }
 
-/** Ensure an `upstream` remote points at `url` (add, or set-url if it already exists). */
-function ensureUpstream(url, cwd) {
+/**
+ * The git remote the template is fetched through. Never `upstream`, `github` or `origin`:
+ * `gh` takes the first of those it finds for "this repository", so a template remote named
+ * `upstream` made `gh` act on the public template instead of the site.
+ */
+export const TEMPLATE_REMOTE = 'ferst-template';
+
+/** Is this an older run's `upstream` remote that points at the template (safe to drop)? */
+export function isLeftoverTemplateRemote(name, remoteUrl, templateUrl) {
+  const norm = (u) => String(u ?? '').trim().replace(/\/+$/, '').replace(/\.git$/, '').toLowerCase();
+  return name === 'upstream' && norm(remoteUrl) !== '' && norm(remoteUrl) === norm(templateUrl);
+}
+
+/** Ensure TEMPLATE_REMOTE points at `url`, and drop an older run's `upstream` template remote. */
+function ensureTemplateRemote(url, cwd) {
   const remotes = (tryGit('remote', cwd) || '').split(/\r?\n/).map((s) => s.trim());
-  if (remotes.includes('upstream')) git(`remote set-url upstream ${q(url)}`, cwd);
-  else git(`remote add upstream ${q(url)}`, cwd);
+  if (remotes.includes('upstream') && isLeftoverTemplateRemote('upstream', tryGit('remote get-url upstream', cwd), url)) {
+    git('remote remove upstream', cwd);
+  }
+  if (remotes.includes(TEMPLATE_REMOTE)) git(`remote set-url ${TEMPLATE_REMOTE} ${q(url)}`, cwd);
+  else git(`remote add ${TEMPLATE_REMOTE} ${q(url)}`, cwd);
 }
 
 function printHelp() {
@@ -330,23 +376,26 @@ function main() {
   // 2. Git scaffold sync — overwrite the template-owned paths from upstream's default
   //    branch. Never a merge/rebase; path-checkout works across unrelated histories.
   try {
-    ensureUpstream(upstream.url, cwd);
+    ensureTemplateRemote(upstream.url, cwd);
     console.log(`ferst-update: fetching ${upstream.url} ...`);
-    git('fetch upstream', cwd);
+    git(`fetch ${TEMPLATE_REMOTE}`, cwd);
   } catch (e) {
     console.error(`ferst-update: git fetch failed — ${tail(e.stderr || e.message, 10)}`);
     process.exit(1);
   }
-  const branch = parseDefaultBranch(tryGit('ls-remote --symref upstream HEAD', cwd)) || 'main';
+  const branch = parseDefaultBranch(tryGit(`ls-remote --symref ${TEMPLATE_REMOTE} HEAD`, cwd)) || 'main';
   console.log(`ferst-update: upstream default branch = ${branch}`);
   // The exact template commit this run syncs from (for the provenance stamp / #18 ledger).
-  const templateCommit = (tryGit(`rev-parse upstream/${branch}`, cwd) || '').trim() || null;
+  const templateCommit = (tryGit(`rev-parse ${TEMPLATE_REMOTE}/${branch}`, cwd) || '').trim() || null;
+  // The template's own manifest decides what it owns now (see ownedPathsToSync).
+  const upstreamManifestRaw = tryGit(`show ${TEMPLATE_REMOTE}/${branch}:${MANIFEST}`, cwd) || '';
+  const syncPaths = ownedPathsToSync(ownedPaths, upstreamManifestRaw);
 
   let templateVersion = null; // the template version this sync brought (for the manifest + stamp)
   let scaffoldCount = 0; // files the scaffold sync touched (counted BEFORE the npm churn)
   if (dryRun) {
-    const spec = ownedPaths.map(q).join(' ');
-    const diff = (tryGit(`diff --stat upstream/${branch} -- ${spec}`, cwd) || '').trim();
+    const spec = syncPaths.map(q).join(' ');
+    const diff = (tryGit(`diff --stat ${TEMPLATE_REMOTE}/${branch} -- ${spec}`, cwd) || '').trim();
     console.log('ferst-update: --dry-run — scaffold changes that WOULD apply:');
     console.log(diff ? diff : '  (no scaffold changes)');
   } else {
@@ -354,10 +403,10 @@ function main() {
     const pkgPath = resolve(cwd, 'package.json');
     let clientPkg = null;
     try { clientPkg = readFileSync(pkgPath, 'utf8'); } catch { /* none yet */ }
-    for (const p of ownedPaths) {
+    for (const p of syncPaths) {
       // Per-path so one path that upstream no longer ships (pathspec no-match) can't
       // abort the whole sync — warn and continue.
-      if (tryGit(`checkout upstream/${branch} -- ${q(p)}`, cwd) === null) {
+      if (tryGit(`checkout ${TEMPLATE_REMOTE}/${branch} -- ${q(p)}`, cwd) === null) {
         console.warn(`ferst-update: could not sync "${p}" (not present upstream?) — skipped.`);
       }
     }
@@ -371,9 +420,15 @@ function main() {
         }
       } catch { /* package.json not synced — nothing to restore */ }
     }
-    // The manifest isn't a synced path (it holds the client's own settings), so carry the
-    // template's version across explicitly; `raw` is what the coreRange step builds on.
-    const upstreamVersion = readTemplateVersion(tryGit(`show upstream/${branch}:${MANIFEST}`, cwd) || '');
+    // The manifest is itself template-owned and was just synced: build on that text (see
+    // manifestAfterSync), so the coreRange step and the stamp see the template's manifest.
+    let syncedManifest = null;
+    try { syncedManifest = readFileSync(manifestPath, 'utf8'); } catch { /* not synced */ }
+    raw = manifestAfterSync(raw, syncedManifest);
+    manifest = parseManifest(raw);
+    // Carry the template's version across explicitly too, for a site whose manifest isn't
+    // among the synced paths; `raw` is what the coreRange step builds on.
+    const upstreamVersion = readTemplateVersion(upstreamManifestRaw);
     if (upstreamVersion) {
       const bumped = replaceTemplateVersion(raw, upstreamVersion);
       if (bumped && bumped !== raw) {