@alessandroraffa/tangyr 1.0.3 → 2.0.0

package/README.md

@@ -342,9 +342,9 @@ In `tangyr-kit.yaml`, `discipline` is optional: declare it to opt into the corpu
 
 ## Conflict policy
 
-Before writing, each destination is classified and resolved according to `onConflict` in `tangyr.config.yaml`: `ask` (default; prompts, and resolves to backup-and-replace in a non-interactive run), `skip`, `backup`, or `overwrite`.
+Before writing, each destination is classified and resolved according to `onConflict` in `tangyr.config.yaml`: `ask` (default; prompts, and resolves to **skip** when there is no one to ask), `skip`, `backup`, or `overwrite`.
 
-`--yes` supplies the confirmation a non-interactive run needs; it does **not** override the posture. Under `--yes`, `skip` leaves conflicting destinations unchanged and says which, `overwrite` replaces without a backup, and `backup` copies the existing file — or the existing directory, recursively — into `.tangyr/backups/<timestamp>/` and records it in the manifest so `uninstall` can put it back. A symlink is replaced without a backup: what it points at is untouched.
+`--yes` supplies the confirmation a non-interactive run needs; it does **not** override the posture. Under `--yes`, `skip` leaves conflicting destinations unchanged and says which, `overwrite` replaces without a backup, `ask` leaves the destination alone and names the postures that replace, and `backup` copies the existing file — or the existing directory, recursively — into `.tangyr/backups/<timestamp>/` and records it in the manifest so `uninstall` can put it back. A symlink is backed up as a symlink and restored as one: its target is untouched either way, but the link itself is the operator's artifact — often the one committed with the project — so replacing it without a record left nothing to put back.
 
 One decision is taken per destination, not per target, so a file several targets write — `AGENTS.md` is claimed by four — is backed up once.
 

package/dist/index.js

@@ -16052,22 +16052,53 @@ function isArtifactManifestPath(relativePath) {
   const [tool] = relativePath.split("/");
   return artifactManifestPrefixes.has(tool);
 }
-function backupFile(originalPath, manifest) {
-  const priorSuffixes = manifest.backups.filter((b) => b.originalPath === originalPath).map((b) => b.integerSuffix);
-  const suffix = priorSuffixes.length > 0 ? Math.max(...priorSuffixes) + 1 : 1;
-  const backupPath = `${originalPath}.bak.${suffix}`;
+function resolveBackupPath(originalPath, scopePath) {
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\.\d+Z$/u, "Z");
+  const scopeRoot = path6.dirname(scopePath);
+  let relativeToRoot = path6.relative(scopeRoot, originalPath);
+  if (relativeToRoot.startsWith("..") || path6.isAbsolute(relativeToRoot)) {
+    const digest = crypto2.createHash("sha256").update(path6.dirname(originalPath)).digest("hex").slice(0, 12);
+    relativeToRoot = path6.join(
+      `_outside-${digest}`,
+      path6.basename(originalPath)
+    );
+  }
+  const base = path6.join(scopePath, "backups", ts2, relativeToRoot);
+  let candidate = base;
+  for (let n7 = 2; fs6.existsSync(candidate) || isPresentLink(candidate); n7++) {
+    candidate = `${base}-${String(n7)}`;
+  }
+  return candidate;
+}
+function isPresentLink(p) {
+  try {
+    return fs6.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function copyForBackup(originalPath, backupPath) {
+  fs6.mkdirSync(path6.dirname(backupPath), { recursive: true });
   const stat = fs6.lstatSync(originalPath);
   if (stat.isSymbolicLink()) {
     fs6.symlinkSync(fs6.readlinkSync(originalPath), backupPath);
   } else if (stat.isDirectory()) {
     fs6.cpSync(originalPath, backupPath, {
       recursive: true,
+      // Preserve links as links: following them would copy the kit into the
+      // backup and, worse, make the backup look like the operator's content.
       dereference: false,
       verbatimSymlinks: true
     });
   } else {
     fs6.copyFileSync(originalPath, backupPath);
   }
+}
+function backupFile(originalPath, manifest, scopePath) {
+  const priorSuffixes = manifest.backups.filter((b) => b.originalPath === originalPath).map((b) => b.integerSuffix);
+  const suffix = priorSuffixes.length > 0 ? Math.max(...priorSuffixes) + 1 : 1;
+  const backupPath = resolveBackupPath(originalPath, scopePath);
+  copyForBackup(originalPath, backupPath);
   manifest.backups.push({
     originalPath,
     backupLocation: backupPath,
@@ -22273,13 +22304,11 @@ async function runUninstallCommand(options, logger) {
     }
   }
   if (fullUninstall) {
-    const newestFirst = [...manifest.backups].reverse();
     const restored = /* @__PURE__ */ new Set();
-    for (const backup of newestFirst) {
+    const kept = [];
+    for (const backup of manifest.backups) {
       if (restored.has(backup.originalPath)) {
-        logger.verbose(
-          `  superseded by a newer backup, not restored: ${backup.backupLocation}`
-        );
+        kept.push(backup);
         continue;
       }
       restored.add(backup.originalPath);
@@ -22291,6 +22320,19 @@ async function runUninstallCommand(options, logger) {
         );
       }
     }
+    if (kept.length > 0) {
+      logger.warn(
+        `
+${String(kept.length)} later backup(s) were NOT restored: the earliest copy of each location is the one that comes back, because it is the content from before the first install.`
+      );
+      for (const backup of kept) {
+        logger.warn(`  ${backup.originalPath}`);
+        logger.warn(`    later copy left at: ${backup.backupLocation}`);
+      }
+      logger.warn(
+        "  The manifest is removed below, so nothing will reference these copies afterwards. Move what you need out of the backups directory now."
+      );
+    }
     const manifestPath = path24.join(scopePath, "manifest.json");
     if (fs27.existsSync(manifestPath)) {
       fs27.unlinkSync(manifestPath);
@@ -25091,7 +25133,6 @@ function toConflictPolicy2(value) {
 }
 
 // src/commands/install.ts
-import crypto11 from "crypto";
 import fs43 from "fs";
 import path43 from "path";
 
@@ -26487,7 +26528,7 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   const shimContent = buildAgentsMdShim(shimPath, agentsMdPath, "claude-code");
   const shimLink = lstatOrNull(shimPath);
   if (shimLink?.isSymbolicLink()) {
-    backupFile(shimPath, manifest);
+    backupFile(shimPath, manifest, scopePath);
     writeManifest(scopePath, manifest);
     fs36.unlinkSync(shimPath);
     logger?.verbose(
@@ -26522,7 +26563,7 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
     );
     return;
   }
-  backupFile(shimPath, manifest);
+  backupFile(shimPath, manifest, scopePath);
   writeManifest(scopePath, manifest);
   fs36.writeFileSync(shimPath, shimContent);
   addArtifactToManifest(manifest, {
@@ -26710,7 +26751,7 @@ function handleConflict(destination, config, options, logger, manifest, scopePat
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs36.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -28606,7 +28647,7 @@ function handleConflict2(destination, config, options, logger, manifest, scopePa
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs38.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -29187,7 +29228,7 @@ function handleConflict3(destination, config, options, logger, manifest, scopePa
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs39.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -29813,7 +29854,7 @@ function handleConflict4(destination, config, options, logger, manifest, scopePa
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs40.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -30288,7 +30329,7 @@ function handleConflict5(destination, config, options, logger, manifest, scopePa
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs41.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -30781,7 +30822,7 @@ function handleConflict6(destination, config, options, logger, manifest, scopePa
   }
   if (config.onConflict === "backup") {
     if (manifest && scopePath) {
-      backupFile(destination, manifest);
+      backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
       fs42.rmSync(destination, { recursive: true, force: true });
     } else {
@@ -30849,29 +30890,8 @@ function isBackupablePath(targetPath) {
   }
 }
 function backupConflictingTarget(targetPath, scopePath) {
-  const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace("T", "T").replace(/\.\d+Z$/u, "Z");
-  const scopeRoot = path43.dirname(scopePath);
-  let relativeToRoot = path43.relative(scopeRoot, targetPath);
-  if (relativeToRoot.startsWith("..") || path43.isAbsolute(relativeToRoot)) {
-    const digest = crypto11.createHash("sha256").update(path43.dirname(targetPath)).digest("hex").slice(0, 12);
-    relativeToRoot = path43.join(`_outside-${digest}`, path43.basename(targetPath));
-  }
-  const backupPath = path43.join(scopePath, "backups", ts2, relativeToRoot);
-  fs43.mkdirSync(path43.dirname(backupPath), { recursive: true });
-  const stat = fs43.lstatSync(targetPath);
-  if (stat.isSymbolicLink()) {
-    fs43.symlinkSync(fs43.readlinkSync(targetPath), backupPath);
-  } else if (stat.isDirectory()) {
-    fs43.cpSync(targetPath, backupPath, {
-      recursive: true,
-      // Preserve links as links: following them would copy the kit into the
-      // backup and, worse, make the backup look like the user's own content.
-      dereference: false,
-      verbatimSymlinks: true
-    });
-  } else {
-    fs43.copyFileSync(targetPath, backupPath);
-  }
+  const backupPath = resolveBackupPath(targetPath, scopePath);
+  copyForBackup(targetPath, backupPath);
   return backupPath;
 }
 async function runInstallCommand(options, logger) {
@@ -32488,7 +32508,7 @@ function commandProbeRows(target, key, command, args) {
 }
 
 // src/commands/status.ts
-import crypto12 from "crypto";
+import crypto11 from "crypto";
 import fs45 from "fs";
 import path46 from "path";
 function runStatusCommand(options, logger) {
@@ -33612,7 +33632,7 @@ function containsTangyrSource(value) {
   return typeof value._tangyr_source === "string" || typeof value._proteus_source === "string" || Object.values(value).some((entry) => containsTangyrSource(entry));
 }
 function hashString6(value) {
-  return `sha256:${crypto12.createHash("sha256").update(value).digest("hex")}`;
+  return `sha256:${crypto11.createHash("sha256").update(value).digest("hex")}`;
 }
 
 // src/commands/sync.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alessandroraffa/tangyr",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "CLI for the Tangyr discipline — install and manage operating kits for AI coding tools",
   "license": "MIT",
   "engines": {