saasaloy 0.1.2 → 0.2.0

package/dist/index.js

@@ -30,6 +30,7 @@ import { dirname as dirname3, posix as posix2 } from "path";
 var EXIT_OK = 0;
 var EXIT_FAILURE = 1;
 var EXIT_REFUSED = 2;
+var EXIT_MERGE_PENDING = 3;
 var RefusalError = class extends Error {
   name = "RefusalError";
 };
@@ -3676,7 +3677,7 @@ import pc3 from "picocolors";
 import { createHash as createHash2 } from "crypto";
 import { mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile12, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { basename, join as join10, posix as posix6 } from "path";
+import { join as join10, posix as posix6 } from "path";
 
 // src/lib/scaffold.ts
 import { mkdir as mkdir5, readdir as readdir2, readFile as readFile11, writeFile as writeFile7 } from "fs/promises";
@@ -3686,7 +3687,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 // package.json
 var package_default = {
   name: "saasaloy",
-  version: "0.1.2",
+  version: "0.2.0",
   description: "Composable SaaS accelerator kit.",
   keywords: [
     "saas",
@@ -3826,10 +3827,20 @@ var BASE_MODULE = "base";
 var DEFAULT_BASE_NAME = "web";
 var BASE_NO_MERGE_BASE = "the template ships with the CLI; the previous version isn't on disk";
 var BASE_INTENT = "the base template changed; keep local edits, take the upstream change";
+function compileGlob(pattern) {
+  const source = pattern.split("/").map(
+    (segment) => segment === "**" ? "[^\0]*" : segment.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "[^/]*")
+  ).join("/").replaceAll("[^\0]*/", "(?:[^\0]*/)?");
+  return new RegExp(`^${source}$`);
+}
+function ownedMatcher(declaration) {
+  const patterns = declaration.ownedFiles.map(compileGlob);
+  return (target) => patterns.some((re) => re.test(target));
+}
 async function readBaseDeclaration(templateDir) {
   const raw = await readIfPresent(join10(templateDir, BASE_DECLARATION));
   if (raw === void 0) {
-    return { seedFiles: [] };
+    return { seedFiles: [], ownedFiles: [] };
   }
   const parsed = JSON.parse(raw);
   const seedFiles = parsed.seedFiles;
@@ -3838,7 +3849,16 @@ async function readBaseDeclaration(templateDir) {
       `${BASE_DECLARATION} must declare "seedFiles" as a list of project-relative paths.`
     );
   }
-  return { seedFiles };
+  const ownedFiles = parsed.ownedFiles ?? [];
+  if (!Array.isArray(ownedFiles) || !ownedFiles.every((entry) => typeof entry === "string" && entry !== "")) {
+    throw new Error(
+      `${BASE_DECLARATION} must declare "ownedFiles" as a list of project-relative globs.`
+    );
+  }
+  return {
+    seedFiles,
+    ownedFiles
+  };
 }
 async function listTemplateFiles(templateDir) {
   const out = [];
@@ -3900,6 +3920,7 @@ function recordBaseFiles(manifest, files) {
     manifest.managed[file.target] = {
       module: BASE_MODULE,
       hash: file.hash,
+      ...file.adopted ? { adopted: true } : {},
       from: file.from
     };
   }
@@ -3920,13 +3941,15 @@ async function missingBaseTargets(root, manifest, templateDir) {
   }
   return missing.toSorted((a, b) => a < b ? -1 : 1);
 }
-async function renderTemplate(root, templateDir) {
+async function renderTemplate(root, templateDir, projectName) {
   const dir = await mkdtemp2(join10(tmpdir2(), "saasaloy-base-render-"));
   const files = await copyTemplate(
     templateDir,
     dir,
-    templateVars(basename(root)),
-    { keepNames: true }
+    templateVars(projectName),
+    {
+      keepNames: true
+    }
   );
   return {
     dir,
@@ -3935,9 +3958,16 @@ async function renderTemplate(root, templateDir) {
   };
 }
 async function adoptBase(args) {
-  const { root, cliVersion, manifest, lock, dryRun = false } = args;
+  const {
+    root,
+    cliVersion,
+    projectName,
+    manifest,
+    lock,
+    dryRun = false
+  } = args;
   const templateDir = args.templateDir ?? await baseTemplateDir();
-  const render = await renderTemplate(root, templateDir);
+  const render = await renderTemplate(root, templateDir, projectName);
   try {
     const files = [];
     const adopted = [];
@@ -3952,7 +3982,8 @@ async function adoptBase(args) {
         files.push({
           target: file.target,
           from: file.from,
-          hash: hashContent(mine)
+          hash: hashContent(mine),
+          adopted: true
         });
       }
     }
@@ -3973,9 +4004,18 @@ async function adoptBase(args) {
   }
 }
 async function baseUpdateInput(args) {
-  const { root, manifest, lock, templateDir, cliVersion, comparison } = args;
-  const render = await renderTemplate(root, templateDir);
-  const seed = new Set((await readBaseDeclaration(templateDir)).seedFiles);
+  const {
+    root,
+    manifest,
+    lock,
+    templateDir,
+    cliVersion,
+    projectName,
+    comparison
+  } = args;
+  const render = await renderTemplate(root, templateDir, projectName);
+  const declaration = await readBaseDeclaration(templateDir);
+  const seed = new Set(declaration.seedFiles);
   const shipped = render.files.filter((file) => !seed.has(file.target));
   const targets = new Set(shipped.map((file) => file.target));
   return {
@@ -4000,6 +4040,7 @@ async function baseUpdateInput(args) {
       noMergeBase: BASE_NO_MERGE_BASE,
       intent: [],
       ignoreTargets: seed,
+      isOwned: ownedMatcher(declaration),
       reapplyPatches: manifest.patches.filter(
         (patch) => targets.has(patch.file)
       ),
@@ -4015,7 +4056,7 @@ async function baseUpdateInput(args) {
 
 // src/lib/doctor.ts
 import { readFile as readFile13 } from "fs/promises";
-import { basename as basename2, dirname as dirname6, join as join11, posix as posix7, resolve as resolve3 } from "path";
+import { basename, dirname as dirname6, join as join11, posix as posix7, resolve as resolve3 } from "path";
 var SKILL_PREFIX = "saasaloy-";
 var PINNED_DEP = /^(@[^/@]+\/)?[^/@]+@\d+\.\d+\.\d+(-[\w.-]+)?(\+[\w.-]+)?$/;
 function finding(module, where, message) {
@@ -4069,7 +4110,7 @@ async function readDescriptor(dir) {
 }
 async function checkModule(input) {
   const { aliases, dir, siblings } = input;
-  const module = basename2(dir);
+  const module = basename(dir);
   const findings = [];
   const report = () => ({ dir, findings, module });
   const file = join11(dir, "registry-item.json");
@@ -4273,7 +4314,7 @@ function checkProject(args) {
 async function resolveDoctorTarget(path) {
   const dir = resolve3(path);
   if (await pathExists(join11(dir, "registry-item.json"))) {
-    return { names: [basename2(dir)], registryDir: dirname6(dir) };
+    return { names: [basename(dir)], registryDir: dirname6(dir) };
   }
   return { names: await registryModuleNames(dir), registryDir: dir };
 }
@@ -5122,8 +5163,8 @@ ${entry.declaration.description}`,
 
 // src/commands/init.ts
 import { spawn } from "child_process";
-import { readdir as readdir4 } from "fs/promises";
-import { basename as basename3, join as join14, resolve as resolve6 } from "path";
+import { readdir as readdir4, readFile as readFile16 } from "fs/promises";
+import { basename as basename2, join as join14, resolve as resolve6 } from "path";
 import {
   cancel as cancel4,
   intro as intro4,
@@ -5315,7 +5356,7 @@ async function runInit(argv) {
         if (!trimmed) {
           return "Enter a project name (or `.` for the current directory).";
         }
-        const name = basename3(resolve6(process.cwd(), trimmed));
+        const name = basename2(resolve6(process.cwd(), trimmed));
         if (!NAME_PATTERN.test(name)) {
           return "Use lowercase letters, digits, and hyphens (e.g. my-app).";
         }
@@ -5329,7 +5370,7 @@ async function runInit(argv) {
     nameArg = answer.trim();
   }
   const target = resolve6(process.cwd(), nameArg);
-  const projectName = basename3(target);
+  const projectName = basename2(target);
   if (!NAME_PATTERN.test(projectName)) {
     cancel4(
       `Invalid project name "${projectName}". Use lowercase letters, digits, and hyphens (e.g. my-app).`
@@ -5356,6 +5397,17 @@ async function runInit(argv) {
   s.stop(
     `Scaffolded ${pc6.cyan(projectName)} ${pc6.dim("(apps/web \xB7 packages/ui \xB7 packages/tsconfig)")}`
   );
+  try {
+    const config = await loadConfig(target);
+    await saveConfig(target, { ...config, name: projectName });
+    const entry = written.find((file) => file.target === CONFIG_FILE);
+    if (entry) {
+      entry.hash = hashContent(await readFile16(entry.path, "utf-8"));
+    }
+  } catch (error) {
+    cancel4(`Couldn't record the project name: ${errorMessage(error)}`);
+    return EXIT_FAILURE;
+  }
   try {
     const manifest = await loadManifest(target);
     const lock = await loadLock(target);
@@ -5919,11 +5971,11 @@ import { cancel as cancel7, intro as intro7, log as log5, note as note7, outro a
 import pc9 from "picocolors";
 
 // src/lib/updater.ts
-import { mkdir as mkdir8, readFile as readFile17, rm as rmPath2, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile18, rm as rmPath2, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname11, posix as posix9 } from "path";
 
 // src/lib/remover.ts
-import { readdir as readdir5, readFile as readFile16, rm as rmPath, writeFile as writeFile10 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile17, rm as rmPath, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname10, join as join18, relative as relative5, sep as sep3 } from "path";
 function classifyTrackedFile(content, manifestHash) {
   if (content === void 0) {
@@ -5948,7 +6000,7 @@ async function buildRemovePlan(args) {
       continue;
     }
     const targetAbs = resolveWithinRoot(root, target);
-    const oldContent = await pathExists(targetAbs) ? await readFile16(targetAbs, "utf-8") : void 0;
+    const oldContent = await pathExists(targetAbs) ? await readFile17(targetAbs, "utf-8") : void 0;
     files.push({
       module: name,
       target,
@@ -6015,7 +6067,7 @@ async function previewPatchRemoval(root, entry) {
     return { entry, action: "gone", diff: "" };
   }
   await assertNoSymlinkPath(root, fileAbs);
-  const source = await readFile16(fileAbs, "utf-8");
+  const source = await readFile17(fileAbs, "utf-8");
   const attempt = tryReversePatch(source, entry);
   if (!attempt.ok) {
     return { entry, action: "refused", diff: "", reason: attempt.reason };
@@ -6083,7 +6135,7 @@ async function recheckFile(file) {
   if (file.oldContent === void 0) {
     return "changed";
   }
-  const current = await readFile16(file.targetAbs, "utf-8");
+  const current = await readFile17(file.targetAbs, "utf-8");
   return hashContent(current) === hashContent(file.oldContent) ? "unchanged" : "changed";
 }
 async function executeRemovePlan(plan, args) {
@@ -6135,7 +6187,7 @@ async function executeRemovePlan(plan, args) {
     let reversed = false;
     if (await pathExists(fileAbs)) {
       await assertNoSymlinkPath(root, fileAbs);
-      const source = await readFile16(fileAbs, "utf-8");
+      const source = await readFile17(fileAbs, "utf-8");
       const attempt = tryReversePatch(source, entry);
       if (!attempt.ok) {
         patchRefusals.push({ patch: entry, reason: attempt.reason });
@@ -6418,18 +6470,21 @@ async function planOneModule(args) {
   const baseFiles = base ? await listModuleFiles(base, aliasView, installedSet) : void 0;
   const files = [];
   for (const ref of theirsFiles.values()) {
-    const theirsContent = await readFile17(ref.abs, "utf-8");
+    const theirsContent = await readFile18(ref.abs, "utf-8");
     const baseRef = baseFiles?.get(ref.target);
-    const baseContent = baseRef ? await readFile17(baseRef.abs, "utf-8") : void 0;
+    const baseContent = baseRef ? await readFile18(baseRef.abs, "utf-8") : void 0;
     const targetAbs = resolveWithinRoot(root, ref.target);
     const managed = manifest.managed[ref.target];
     const owned = managed?.module === name ? managed : void 0;
     const mine = await readIfPresent(targetAbs);
+    const projectOwned = input.isOwned?.(ref.target) ?? false;
     const action = classifyUpdate(
       baseContent,
       theirsContent,
       mine,
-      owned?.hash
+      owned?.hash,
+      owned?.adopted ?? false,
+      projectOwned
     );
     const patchedBy = patchersOf(manifest, ref.target);
     files.push({
@@ -6438,6 +6493,8 @@ async function planOneModule(args) {
       target: ref.target,
       targetAbs,
       action,
+      ...projectOwned ? { projectOwned: true } : {},
+      ...owned?.adopted ? { adopted: true } : {},
       base: baseContent,
       theirs: theirsContent,
       mine,
@@ -6453,13 +6510,14 @@ async function planOneModule(args) {
     const targetAbs = resolveWithinRoot(root, target);
     const mine = await readIfPresent(targetAbs);
     const baseRef = baseFiles?.get(target);
+    const keep = mine !== void 0 && ((entry.adopted ?? false) || (input.isOwned?.(target) ?? false));
     removals.push({
       module: name,
       from: entry.from ?? baseRef?.from ?? target,
       target,
       targetAbs,
-      action: DELETE_ACTION[classifyTrackedFile(mine, entry.hash)],
-      base: baseRef ? await readFile17(baseRef.abs, "utf-8") : void 0,
+      action: keep ? "delete-drift" : DELETE_ACTION[classifyTrackedFile(mine, entry.hash)],
+      base: baseRef ? await readFile18(baseRef.abs, "utf-8") : void 0,
       mine
     });
   }
@@ -6580,7 +6638,7 @@ function newEnvVars(base, theirs) {
   }
   return out;
 }
-function classifyUpdate(base, theirs, mine, managedHash) {
+function classifyUpdate(base, theirs, mine, managedHash, adopted, projectOwned) {
   if (base !== void 0 && base === theirs) {
     return "skip";
   }
@@ -6593,6 +6651,9 @@ function classifyUpdate(base, theirs, mine, managedHash) {
   if (managedHash === void 0) {
     return "conflict";
   }
+  if (adopted || projectOwned) {
+    return "drift";
+  }
   return hashContent(mine) === managedHash ? "overwrite" : "drift";
 }
 async function planLinks(root, theirs) {
@@ -6748,7 +6809,7 @@ async function executeUpdatePlan(plan, args) {
         clean = false;
         continue;
       }
-      const source = await readFile17(p.fileAbs, "utf-8");
+      const source = await readFile18(p.fileAbs, "utf-8");
       const { content, changed } = applyPatch(source, p.patch, p.file);
       if (!changed) {
         continue;
@@ -7372,8 +7433,8 @@ ${pc10.dim("Hand-edited since \u2014 left on disk, now untracked.")}`
 }
 
 // src/commands/update.ts
-import { mkdir as mkdir9, realpath, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute4, join as join19, resolve as resolve8 } from "path";
+import { mkdir as mkdir10, realpath, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename4, dirname as dirname13, isAbsolute as isAbsolute4, join as join20, resolve as resolve8 } from "path";
 import {
   cancel as cancel9,
   confirm as confirm3,
@@ -7385,6 +7446,145 @@ import {
 } from "@clack/prompts";
 import pc11 from "picocolors";
 
+// src/lib/backup.ts
+import {
+  copyFile,
+  mkdir as mkdir9,
+  readdir as readdir6,
+  readFile as readFile19,
+  rm as rmPath3,
+  writeFile as writeFile12
+} from "fs/promises";
+import { dirname as dirname12, join as join19 } from "path";
+var BACKUP_DIR = join19(".saasaloy", "backups");
+var RECORD_FILE = "backup.json";
+var STATE_FILES = [
+  "saasaloy.json",
+  "saasaloy-lock.json",
+  "package.json",
+  join19(".saasaloy", "manifest.json")
+];
+function stampName(now) {
+  return now.toISOString().replaceAll(/[:.]/g, "-");
+}
+async function writeBackup(args) {
+  const { root, targets, cliVersion } = args;
+  const createdAt = (args.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const rel = join19(BACKUP_DIR, stampName(args.now ?? new Date(createdAt)));
+  const dir = join19(root, rel);
+  const files = [];
+  const absent = [];
+  for (const target of /* @__PURE__ */ new Set([...targets, ...STATE_FILES])) {
+    const source = resolveWithinRoot(root, target);
+    if (!await pathExists(source)) {
+      absent.push(target);
+      continue;
+    }
+    const destination = join19(dir, target);
+    await mkdir9(dirname12(destination), { recursive: true });
+    await copyFile(source, destination);
+    files.push(target);
+  }
+  const record = {
+    createdAt,
+    cliVersion,
+    files: files.toSorted(),
+    absent: absent.toSorted()
+  };
+  await mkdir9(dir, { recursive: true });
+  await writeFile12(
+    join19(dir, RECORD_FILE),
+    `${JSON.stringify(record, null, 2)}
+`,
+    "utf-8"
+  );
+  return rel;
+}
+async function listBackups(root) {
+  const dir = join19(root, BACKUP_DIR);
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  const entries = await readdir6(dir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted();
+}
+async function restoreLatestBackup(root) {
+  const backups = await listBackups(root);
+  const newest = backups.at(-1);
+  if (!newest) {
+    throw new RefusalError(
+      `No backup to restore \u2014 nothing under ${BACKUP_DIR}. \`saasaloy update\` writes one before it applies a plan.`
+    );
+  }
+  const rel = join19(BACKUP_DIR, newest);
+  const dir = join19(root, rel);
+  const raw = await readIfPresent(join19(dir, RECORD_FILE));
+  if (raw === void 0) {
+    throw new RefusalError(
+      `${join19(rel, RECORD_FILE)} is missing \u2014 that backup can't be restored safely.`
+    );
+  }
+  let record;
+  try {
+    record = JSON.parse(raw);
+  } catch (error) {
+    throw new RefusalError(`${join19(rel, RECORD_FILE)} is invalid.`, {
+      cause: error
+    });
+  }
+  const restored = [];
+  for (const target of record.files) {
+    const source = join19(dir, target);
+    const destination = resolveWithinRoot(root, target);
+    if (!await pathExists(source)) {
+      continue;
+    }
+    await mkdir9(dirname12(destination), { recursive: true });
+    await copyFile(source, destination);
+    restored.push(target);
+  }
+  const removed = [];
+  for (const target of record.absent) {
+    const destination = resolveWithinRoot(root, target);
+    if (await pathExists(destination)) {
+      await rmPath3(destination, { force: true });
+      removed.push(target);
+    }
+  }
+  return { from: rel, restored, removed };
+}
+
+// src/lib/git-state.ts
+import { execFile } from "child_process";
+async function workingTreeState(root) {
+  return new Promise((resolve9) => {
+    execFile(
+      "git",
+      // `-- .` scopes the answer to the project. Without it a project nested inside a
+      // larger repository reports every unrelated change in that repository as its own.
+      ["status", "--porcelain", "--untracked-files=no", "--", "."],
+      { cwd: root },
+      (error, stdout) => {
+        resolve9(error ? "unknown" : stdout.trim() === "" ? "clean" : "dirty");
+      }
+    );
+  });
+}
+
+// src/lib/project-name.ts
+import { basename as basename3 } from "path";
+async function resolveProjectName(root, config) {
+  if (config.name) {
+    return { name: config.name, source: "config" };
+  }
+  const pkg = await readRootPackageJson(root);
+  const pkgName = typeof pkg?.name === "string" ? pkg.name : void 0;
+  if (pkgName) {
+    return { name: pkgName, source: "package.json" };
+  }
+  return { name: basename3(root), source: "directory" };
+}
+
 // src/lib/merge-plan.ts
 function renderMergePlan(plan) {
   const modules = plan.modules.filter((m) => m.needsMerge);
@@ -7499,6 +7699,17 @@ function renderFile(file) {
       ""
     );
   }
+  if (file.projectOwned) {
+    out.push(
+      "This file is yours: the template ships it once and never writes it again. The template's copy moved, so the change is shown below for you to take what you want from it. Nothing here was written.",
+      ""
+    );
+  } else if (file.adopted) {
+    out.push(
+      "Saasaloy adopted this file rather than writing it, so the hash it records came off your disk and proves nothing about who wrote these bytes. It is treated as edited and was left alone.",
+      ""
+    );
+  }
   if (file.patchedBy && file.patchedBy.length > 0) {
     out.push(
       `Note: \`${file.patchedBy.join("`, `")}\` also applied a config patch to this file. Part of the difference below is that patch rather than an edit anyone made by hand \u2014 keep those lines when you merge.`,
@@ -7611,11 +7822,13 @@ var KNOWN_FLAGS9 = /* @__PURE__ */ new Set([
   "--diff",
   "--yes",
   "-y",
+  "--force",
+  "--abort",
   "--help",
   "-h"
 ]);
 var VALUE_FLAGS2 = /* @__PURE__ */ new Set(["--ref", "--out"]);
-var USAGE9 = "saasaloy update [<module>|base] [--ref <ref>] [--out <path>] [--dry-run] [--diff] [--yes]";
+var USAGE9 = "saasaloy update [<module>|base] [--ref <ref>] [--out <path>] [--dry-run] [--diff] [--force] [--yes] | saasaloy update --abort";
 var HELP9 = {
   name: "update",
   describe: DESCRIPTIONS.update,
@@ -7625,6 +7838,8 @@ var HELP9 = {
     "--out <path>": "write the merge plan to a file instead of stdout",
     "--dry-run": "show the plan and write nothing",
     "--diff": "show a per-file diff and write nothing",
+    "--force": "apply even with uncommitted changes in the working tree",
+    "--abort": "restore the files the last update replaced, then stop",
     "-y, --yes": "skip the confirmation prompt"
   }
 };
@@ -7664,6 +7879,8 @@ function parseArgs9(argv) {
     dryRun: argv.includes("--dry-run"),
     diff: argv.includes("--diff"),
     yes: argv.includes("--yes") || argv.includes("-y"),
+    force: argv.includes("--force"),
+    abort: argv.includes("--abort"),
     unknown
   };
 }
@@ -7824,13 +8041,13 @@ function skipReason(comparison, preview = false) {
     }
   }
 }
-var STATE_FILES = [CONFIG_FILE, LOCK_FILE, MANIFEST_FILE];
+var STATE_FILES2 = [CONFIG_FILE, LOCK_FILE, MANIFEST_FILE];
 async function stateFileRefusal(root, out) {
   if (!out) {
     return void 0;
   }
   const target = await canonicalPath(resolvePlanOut(out));
-  for (const file of STATE_FILES) {
+  for (const file of STATE_FILES2) {
     if (await canonicalPath(resolve8(root, file)) === target) {
       return `Refusing to write the merge plan to ${pc11.cyan(out)} \u2014 that is Saasaloy's own ${pc11.cyan(file)}. Pick another path.`;
     }
@@ -7842,7 +8059,7 @@ async function canonicalPath(path) {
     return await realpath(path);
   } catch {
     try {
-      return join19(await realpath(dirname12(path)), basename4(path));
+      return join20(await realpath(dirname13(path)), basename4(path));
     } catch {
       return path;
     }
@@ -7857,10 +8074,24 @@ async function emitMergePlan(document, out) {
     return;
   }
   const target = resolvePlanOut(out);
-  await mkdir9(dirname12(target), { recursive: true });
-  await writeFile12(target, document, "utf-8");
+  await mkdir10(dirname13(target), { recursive: true });
+  await writeFile13(target, document, "utf-8");
   log7.success(`Merge plan written to ${pc11.cyan(out)}`, TUI_ON_STDERR);
 }
+function backupTargets(plan) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const mod of plan.modules) {
+    for (const file of [...mod.files, ...mod.removals]) {
+      if (!QUIET.has(file.action) && file.action !== "skip") {
+        targets.add(file.target);
+      }
+    }
+    for (const patch of mod.patches) {
+      targets.add(patch.file);
+    }
+  }
+  return [...targets].toSorted();
+}
 function splitSlug2(slug) {
   const [owner, repo, ...rest] = slug.split("/");
   if (!owner || !repo || rest.length > 0) {
@@ -7898,12 +8129,43 @@ async function runUpdate(argv) {
     cancel9(formatFailure(error), TUI_ON_STDERR);
     return exitCodeFor(error);
   }
+  if (opts.abort) {
+    try {
+      const restored = await restoreLatestBackup(root);
+      for (const target of restored.restored) {
+        log7.step(`${pc11.green("restore")}  ${target}`, TUI_ON_STDERR);
+      }
+      for (const target of restored.removed) {
+        log7.step(
+          `${pc11.red("remove")}  ${target} ${pc11.dim("(the update created it)")}`,
+          TUI_ON_STDERR
+        );
+      }
+      outro9(
+        pc11.green(
+          `Restored ${restored.restored.length} file${restored.restored.length === 1 ? "" : "s"} from ${restored.from}.`
+        ),
+        TUI_ON_STDERR
+      );
+      return EXIT_OK;
+    } catch (error) {
+      cancel9(formatFailure(error), TUI_ON_STDERR);
+      return exitCodeFor(error);
+    }
+  }
   const outRefusal = await stateFileRefusal(root, opts.out);
   if (outRefusal) {
     cancel9(outRefusal, TUI_ON_STDERR);
     return EXIT_REFUSED;
   }
   const preview = opts.dryRun || opts.diff;
+  if (!preview && !opts.force && await workingTreeState(root) === "dirty") {
+    cancel9(
+      "The working tree has uncommitted changes. Commit or stash them first, so `git diff` shows what this update did \u2014 or re-run with `--force`. Nothing was written.",
+      TUI_ON_STDERR
+    );
+    return EXIT_REFUSED;
+  }
   if (!opts.yes && !preview && !process.stdin.isTTY) {
     cancel9(
       "No terminal to confirm in \u2014 re-run with `--yes` to apply, or `--dry-run` to preview.",
@@ -7937,12 +8199,20 @@ async function runUpdate(argv) {
     const cliVersion = await readVersion();
     let baseComparison;
     let templateDir;
+    const project = await resolveProjectName(root, config);
     if (wantsBase) {
       templateDir = await baseTemplateDir();
+      if (project.source === "directory") {
+        log7.warn(
+          `No \`name\` in ${CONFIG_FILE} and no root package.json name \u2014 falling back to the directory name ${pc11.cyan(project.name)}. Set \`name\` in ${CONFIG_FILE} if that isn't this project's name.`,
+          TUI_ON_STDERR
+        );
+      }
       if (!isBaseTracked(lock, manifest)) {
         const adoption = await adoptBase({
           root,
           cliVersion,
+          projectName: project.name,
           manifest,
           lock,
           templateDir,
@@ -7950,7 +8220,7 @@ async function runUpdate(argv) {
         });
         const count = adoption.adopted.length;
         const lines = [
-          `${preview ? "Would adopt" : "Adopted"} ${count} base file${count === 1 ? "" : "s"} at CLI ${pc11.cyan(cliVersion)}, each at the hash it has on disk \u2014 your edits are the baseline, not drift.`
+          `${preview ? "Would adopt" : "Adopted"} ${count} base file${count === 1 ? "" : "s"} at CLI ${pc11.cyan(cliVersion)}, each at the hash it has on disk. Those bytes may be yours, so the next update treats every one of them as edited and offers a merge rather than a write.`
         ];
         if (adoption.absent.length > 0) {
           lines.push(
@@ -8066,6 +8336,7 @@ async function runUpdate(argv) {
         lock,
         templateDir,
         cliVersion,
+        projectName: project.name,
         comparison: baseComparison
       });
       cleanups.push(handle.cleanup);
@@ -8250,6 +8521,15 @@ async function runUpdate(argv) {
         return EXIT_OK;
       }
     }
+    const backupDir = await writeBackup({
+      root,
+      targets: backupTargets(plan),
+      cliVersion
+    });
+    log7.info(
+      `Pre-update copies in ${pc11.cyan(backupDir)} ${pc11.dim("\u2014 `saasaloy update --abort` restores them")}`,
+      TUI_ON_STDERR
+    );
     const outcome = await executeUpdatePlan(plan, {
       root,
       config,
@@ -8288,7 +8568,7 @@ async function runUpdate(argv) {
       );
     }
     outro9(summarizeOutcome(plan, result), TUI_ON_STDERR);
-    return EXIT_OK;
+    return plan.needsMerge ? EXIT_MERGE_PENDING : EXIT_OK;
   } catch (error) {
     cancel9(formatFailure(error), TUI_ON_STDERR);
     return exitCodeFor(error);