@alessandroraffa/tangyr 1.0.0 → 1.0.2

package/dist/index.js

@@ -17378,21 +17378,33 @@ function collectProjectScopeFindings(projectRoot, tools, options) {
     ) : void 0;
     const probePaths = buildProjectProbes(tool, projectRoot, profile);
     for (const { resolvedPath, description, classification } of probePaths) {
-      if (!fs11.existsSync(resolvedPath)) {
+      let stat;
+      try {
+        stat = fs11.lstatSync(resolvedPath);
+      } catch {
         continue;
       }
-      const stat = fs11.lstatSync(resolvedPath);
+      const type = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "directory" : "file";
+      const ours = type === "file" && carriesTangyrMarker(resolvedPath);
       findings.push({
         path: resolvedPath,
         tool,
-        type: stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "directory" : "file",
-        classification,
-        description
+        type,
+        classification: ours ? "compatible" : classification,
+        description: ours ? `${description} (written by Tangyr)` : description
       });
     }
   }
   return findings;
 }
+function carriesTangyrMarker(filePath) {
+  try {
+    const firstNonEmpty = fs11.readFileSync(filePath, "utf8").split("\n").find((line) => line.trim().length > 0) ?? "";
+    return extractProvenanceMarker(firstNonEmpty) !== null;
+  } catch {
+    return false;
+  }
+}
 function requestedAssessTools(toolFilter) {
   return toolFilter ?? [...DEFAULT_ASSESS_TARGETS];
 }
@@ -21351,6 +21363,19 @@ function writeSharedFile(filePath, parsed, serializer, isFirstWrite, logger) {
       `tangyr: first modification of ${filePath} \u2014 unmanaged data will be preserved but exact whitespace or comments may not be.`
     );
   }
+  let realTarget = null;
+  try {
+    if (fs19.lstatSync(filePath).isSymbolicLink()) {
+      realTarget = fs19.realpathSync(filePath);
+    }
+  } catch {
+    realTarget = null;
+  }
+  if (realTarget && realTarget !== filePath) {
+    logger.warn(
+      `tangyr: ${filePath} is a symlink \u2014 the file being modified is ${realTarget}`
+    );
+  }
   fs19.mkdirSync(path18.dirname(filePath), { recursive: true });
   fs19.writeFileSync(filePath, serialized);
   return true;
@@ -22169,11 +22194,23 @@ async function runUninstallCommand(options, logger) {
   }
   const claudeRoots = scope === "global" && selectedTools.has("claude-code") ? resolveClaudeRootsForUninstall(manifest, runtime) : [];
   let removedCount = 0;
+  const removedParentDirs = /* @__PURE__ */ new Set();
   for (const file of useManifestPathRemoval ? manifestArtifacts : []) {
     if (isMergeSurfaceKey(file.relativePath)) {
-      logger.verbose(
-        `  left in place (merge surface \u2014 the block is stripped, not the file): ${file.path ?? file.relativePath}`
+      const surfacePath = file.path ?? resolveManifestKeyToPath(
+        file.relativePath,
+        scope,
+        runtime,
+        uninstallProjectRoot
       );
+      if (surfacePath && stripTangyrFromMergeSurface(surfacePath, logger)) {
+        removedParentDirs.add(path24.dirname(surfacePath));
+        removedCount++;
+      } else {
+        logger.verbose(
+          `  left in place (merge surface, nothing of ours in it): ${surfacePath ?? file.relativePath}`
+        );
+      }
       continue;
     }
     const isClaudeGlobal = file.relativePath.startsWith("claude-code/") && scope === "global";
@@ -22186,6 +22223,7 @@ async function runUninstallCommand(options, logger) {
       for (const actualPath of paths) {
         if (actualPath && (fs27.existsSync(actualPath) || isSymlink(actualPath))) {
           removeManagedPath(actualPath);
+          removedParentDirs.add(path24.dirname(actualPath));
           logger.verbose(`  removed: ${actualPath}`);
           removedCount++;
         } else {
@@ -22200,7 +22238,14 @@ async function runUninstallCommand(options, logger) {
         uninstallProjectRoot
       );
       if (actualPath && (fs27.existsSync(actualPath) || isSymlink(actualPath))) {
+        if (!stillMatchesRecord(actualPath, file.hash)) {
+          logger.warn(
+            `  left in place (no longer what was installed): ${actualPath}`
+          );
+          continue;
+        }
         removeManagedPath(actualPath);
+        removedParentDirs.add(path24.dirname(actualPath));
         logger.verbose(`  removed: ${actualPath}`);
         removedCount++;
       } else {
@@ -22228,7 +22273,16 @@ async function runUninstallCommand(options, logger) {
     }
   }
   if (fullUninstall) {
-    for (const backup of manifest.backups) {
+    const newestFirst = [...manifest.backups].reverse();
+    const restored = /* @__PURE__ */ new Set();
+    for (const backup of newestFirst) {
+      if (restored.has(backup.originalPath)) {
+        logger.verbose(
+          `  superseded by a newer backup, not restored: ${backup.backupLocation}`
+        );
+        continue;
+      }
+      restored.add(backup.originalPath);
       try {
         restoreBackup(backup, logger);
       } catch (err) {
@@ -22242,6 +22296,11 @@ async function runUninstallCommand(options, logger) {
       fs27.unlinkSync(manifestPath);
       logger.verbose(`  removed manifest: ${manifestPath}`);
     }
+    pruneEmptyDirs(path24.join(scopePath, "backups"), logger);
+    const pruneBoundary = path24.dirname(scopePath);
+    for (const dir of removedParentDirs) {
+      pruneEmptyAncestors(dir, pruneBoundary, logger);
+    }
     try {
       const remaining = fs27.readdirSync(scopePath);
       if (remaining.length === 0) {
@@ -22621,6 +22680,86 @@ var MERGE_SURFACE_SLOTS = /* @__PURE__ */ new Set([
   "mcp_shared_file",
   "mcp_file"
 ]);
+function stripTangyrFromMergeSurface(filePath, logger) {
+  const parsed = readJsonObject2(filePath);
+  if (!parsed) {
+    return false;
+  }
+  const cleaned = { ...parsed };
+  const hooks = removeManagedClaudeHookEntries(
+    parsed.hooks,
+    (entry) => entry._tangyr === true || entry._proteus === true
+  );
+  if (hooks === void 0) {
+    delete cleaned.hooks;
+  } else {
+    cleaned.hooks = hooks;
+  }
+  if (isRecord(parsed.mcpServers)) {
+    const kept = Object.fromEntries(
+      Object.entries(parsed.mcpServers).filter(
+        ([, server]) => !isRecord(server) || !isRecord(server._tangyr) && !isRecord(server._proteus)
+      )
+    );
+    if (Object.keys(kept).length === 0) {
+      delete cleaned.mcpServers;
+    } else {
+      cleaned.mcpServers = kept;
+    }
+  }
+  delete cleaned._tangyr;
+  delete cleaned._proteus;
+  if (JSON.stringify(cleaned) === JSON.stringify(parsed)) {
+    return false;
+  }
+  writeJsonOrRemove(filePath, cleaned);
+  logger.verbose(`  stripped Tangyr's block from: ${filePath}`);
+  return true;
+}
+function pruneEmptyAncestors(startDir, stopAt, logger) {
+  const boundary = path24.resolve(stopAt);
+  let current = path24.resolve(startDir);
+  while (current !== boundary && current.startsWith(`${boundary}${path24.sep}`)) {
+    try {
+      if (fs27.readdirSync(current).length > 0) {
+        return;
+      }
+      fs27.rmdirSync(current);
+      logger.verbose(`  removed empty directory: ${current}`);
+    } catch {
+      return;
+    }
+    current = path24.dirname(current);
+  }
+}
+function pruneEmptyDirs(dir, logger) {
+  let stat;
+  try {
+    stat = fs27.lstatSync(dir);
+  } catch {
+    return;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    return;
+  }
+  for (const entry of fs27.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory() && !entry.isSymbolicLink()) {
+      pruneEmptyDirs(path24.join(dir, entry.name), logger);
+    }
+  }
+  try {
+    fs27.rmdirSync(dir);
+    logger.verbose(`  removed empty directory: ${dir}`);
+  } catch {
+  }
+}
+function stillMatchesRecord(artifactPath, recorded) {
+  if (isLegacyArtifactState(recorded)) {
+    return true;
+  }
+  const actual = describeArtifactState(artifactPath);
+  return actual === null || actual === recorded;
+}
 function isMergeSurfaceKey(relativePath) {
   const [, ...rest] = relativePath.split("/");
   return MERGE_SURFACE_SLOTS.has(rest.join("/"));
@@ -24952,6 +25091,7 @@ function toConflictPolicy2(value) {
 }
 
 // src/commands/install.ts
+import crypto11 from "crypto";
 import fs43 from "fs";
 import path43 from "path";
 
@@ -26363,6 +26503,12 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   const firstNonEmptyLine = existing.split("\n").find((l) => l.trim().length > 0) ?? "";
   const marker = extractProvenanceMarker(firstNonEmptyLine);
   if (marker !== null && marker.hash === expectedBodyHash) {
+    addArtifactToManifest(manifest, {
+      relativePath: SHIM_MANIFEST_KEY,
+      path: shimPath,
+      hash: expectedBodyHash,
+      origin: "tangyr-managed"
+    });
     logger?.verbose(
       `instructions-shim: already current, skipped -> ${shimPath}`
     );
@@ -30689,20 +30835,25 @@ function parseCommandFile(commandFile) {
 function isBackupablePath(targetPath) {
   try {
     const lstat = fs43.lstatSync(targetPath);
-    if (lstat.isSymbolicLink()) {
-      return false;
-    }
-    return lstat.isFile() || lstat.isDirectory();
+    return lstat.isSymbolicLink() || lstat.isFile() || lstat.isDirectory();
   } catch {
     return false;
   }
 }
 function backupConflictingTarget(targetPath, scopePath) {
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace("T", "T").replace(/\.\d+Z$/u, "Z");
-  const relativeToRoot = path43.relative("/", targetPath).replace(/^\.\.\/+/gu, "");
+  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 });
-  if (fs43.lstatSync(targetPath).isDirectory()) {
+  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
@@ -30918,14 +31069,14 @@ async function runInstallCommand(options, logger) {
     return;
   }
   if (conflictingFindings.length > 0) {
+    const toolsByPath = /* @__PURE__ */ new Map();
+    for (const finding of conflictingFindings) {
+      const tools2 = toolsByPath.get(finding.path) ?? [];
+      tools2.push(finding.tool);
+      toolsByPath.set(finding.path, tools2);
+    }
     if (options.yes) {
       const decidedPaths = /* @__PURE__ */ new Set();
-      const toolsByPath = /* @__PURE__ */ new Map();
-      for (const finding of conflictingFindings) {
-        const tools2 = toolsByPath.get(finding.path) ?? [];
-        tools2.push(finding.tool);
-        toolsByPath.set(finding.path, tools2);
-      }
       const posture = config.onConflict === "ask" ? "skip" : config.onConflict;
       const replaceable = Array.from(toolsByPath.keys()).filter(
         (p) => !foreignSkillsSlots.has(p)
@@ -31004,10 +31155,11 @@ ACCEPTED CONFLICTS (posture: ${posture}; ${replaceable.length} target(s)):`
     } else {
       logger.info(
         `
-Found ${conflictingFindings.length} conflicting target(s). Please choose an action for each:
+Found ${toolsByPath.size} conflicting target(s). Please choose an action for each:
 `
       );
-      for (const finding of conflictingFindings) {
+      for (const [conflictPath, claimingTools] of toolsByPath) {
+        const finding = { path: conflictPath, tool: claimingTools.join(", ") };
         const choice = await dist_default8({
           message: `Conflict: ${finding.path} (${finding.tool})
   Choose an action:`,
@@ -31058,6 +31210,9 @@ SKIPPED CONFLICTS (${skippedTargetPaths.size} target(s) left unchanged):`
   for (const backup of backupsToAdd) {
     manifest.backups.push(backup);
   }
+  if (backupsToAdd.length > 0) {
+    writeManifest(scopePath, manifest);
+  }
   const mappings = loadMappings(kitInfo.path, config, configDir);
   const installLossReport = createLossReport();
   let installedCount = 0;
@@ -32320,7 +32475,7 @@ function commandProbeRows(target, key, command, args) {
 }
 
 // src/commands/status.ts
-import crypto11 from "crypto";
+import crypto12 from "crypto";
 import fs45 from "fs";
 import path46 from "path";
 function runStatusCommand(options, logger) {
@@ -33444,7 +33599,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:${crypto11.createHash("sha256").update(value).digest("hex")}`;
+  return `sha256:${crypto12.createHash("sha256").update(value).digest("hex")}`;
 }
 
 // src/commands/sync.ts

package/package.json

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