@alessandroraffa/tangyr 1.0.1 → 1.0.3

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];
 }
@@ -22182,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";
@@ -22199,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 {
@@ -22220,6 +22245,7 @@ async function runUninstallCommand(options, logger) {
           continue;
         }
         removeManagedPath(actualPath);
+        removedParentDirs.add(path24.dirname(actualPath));
         logger.verbose(`  removed: ${actualPath}`);
         removedCount++;
       } else {
@@ -22270,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) {
@@ -22649,6 +22680,79 @@ 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;
@@ -24987,6 +25091,7 @@ function toConflictPolicy2(value) {
 }
 
 // src/commands/install.ts
+import crypto11 from "crypto";
 import fs43 from "fs";
 import path43 from "path";
 
@@ -26127,7 +26232,11 @@ function resolveInstructionsSource(kitRoot, config) {
         "source.instructions in tangyr.config.yaml"
       );
     }
-    return { file, label: normalizeLabel(kitRoot, file), origin: "config-override" };
+    return {
+      file,
+      label: normalizeLabel(kitRoot, file),
+      origin: "config-override"
+    };
   }
   const declared = resolveKitEntrypointName(kitRoot);
   if (declared !== void 0) {
@@ -26139,7 +26248,11 @@ function resolveInstructionsSource(kitRoot, config) {
         "entrypoint in tangyr-kit.yaml"
       );
     }
-    return { file, label: normalizeLabel(kitRoot, file), origin: "manifest-entrypoint" };
+    return {
+      file,
+      label: normalizeLabel(kitRoot, file),
+      origin: "manifest-entrypoint"
+    };
   }
   for (const name of [DEFAULT_ENTRYPOINT, PORTABLE_INSTRUCTIONS_NAME]) {
     const file = path33.resolve(kitRoot, name);
@@ -26398,6 +26511,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}`
     );
@@ -30731,7 +30850,12 @@ function isBackupablePath(targetPath) {
 }
 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 });
   const stat = fs43.lstatSync(targetPath);
@@ -30953,14 +31077,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)
@@ -31039,10 +31163,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:`,
@@ -31440,7 +31565,12 @@ function installClaudeCodeAdapterSlots(args) {
       if (outcome.status !== "success" && outcome.status !== "skipped-current") {
         continue;
       }
-      const key = claudeCodeOutcomeToManifestKey(profile, outcome, scope, projectRoot);
+      const key = claudeCodeOutcomeToManifestKey(
+        profile,
+        outcome,
+        scope,
+        projectRoot
+      );
       if (!key) {
         continue;
       }
@@ -32358,7 +32488,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) {
@@ -33482,7 +33612,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
@@ -34020,10 +34150,7 @@ async function runSyncCommand(options, logger) {
   }
   options.kitPath = kitPathOverride;
   options.kit = kitName;
-  const { config, configDir, configSource, sourceRoot, kitInfo } = resolveRuntime(
-    options,
-    import.meta.url
-  );
+  const { config, configDir, configSource, sourceRoot, kitInfo } = resolveRuntime(options, import.meta.url);
   const syncOptions = toSyncOptions(options, config, configDir, configSource);
   const targets = activeTargets(config, options.target);
   const results = [];

package/package.json

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