claudekit-cli 3.41.2-dev.3 → 3.41.3-dev.1

package/dist/index.js

@@ -57255,7 +57255,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.2-dev.3",
+    version: "3.41.3-dev.1",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -81441,7 +81441,7 @@ class OwnershipChecker {
       return { path: filePath, ownership: "user", exists: true };
     }
     const relativePath = relative7(claudeDir2, filePath).replace(/\\/g, "/");
-    const tracked = allTrackedFiles.find((f3) => f3.path === relativePath);
+    const tracked = allTrackedFiles.find((f3) => f3.path.replace(/\\/g, "/") === relativePath);
     if (!tracked) {
       return { path: filePath, ownership: "user", exists: true };
     }
@@ -92128,6 +92128,7 @@ async function findFileInInstalledKits(claudeDir2, relativePath, excludeKit) {
   };
 }
 async function getUninstallManifest(claudeDir2, kit) {
+  const normalizeTrackedPath = (relativePath) => relativePath.replace(/\\/g, "/");
   const detection = await detectMetadataFormat(claudeDir2);
   if (detection.format === "multi-kit" && detection.metadata?.kits) {
     const installedKits = Object.keys(detection.metadata.kits);
@@ -92142,14 +92143,14 @@ async function getUninstallManifest(claudeDir2, kit) {
           remainingKits: installedKits.filter((k2) => k2 !== kit)
         };
       }
-      const kitFiles = kitMeta.files.map((f3) => f3.path);
+      const kitFiles = kitMeta.files.map((f3) => normalizeTrackedPath(f3.path));
       const sharedFiles = new Set;
       for (const otherKit of installedKits) {
         if (otherKit !== kit) {
           const otherMeta = detection.metadata.kits[otherKit];
           if (otherMeta?.files) {
             for (const f3 of otherMeta.files) {
-              sharedFiles.add(f3.path);
+              sharedFiles.add(normalizeTrackedPath(f3.path));
             }
           }
         }
@@ -92169,7 +92170,7 @@ async function getUninstallManifest(claudeDir2, kit) {
     }
     const allFiles = getAllTrackedFiles(detection.metadata);
     return {
-      filesToRemove: allFiles.map((f3) => f3.path),
+      filesToRemove: allFiles.map((f3) => normalizeTrackedPath(f3.path)),
       filesToPreserve: USER_CONFIG_PATTERNS,
       hasManifest: true,
       isMultiKit: true,
@@ -92177,8 +92178,8 @@ async function getUninstallManifest(claudeDir2, kit) {
     };
   }
   if (detection.format === "legacy" && detection.metadata) {
-    const legacyFiles2 = detection.metadata.files?.map((f3) => f3.path) || [];
-    const installedFiles = detection.metadata.installedFiles || [];
+    const legacyFiles2 = detection.metadata.files?.map((f3) => normalizeTrackedPath(f3.path)) || [];
+    const installedFiles = (detection.metadata.installedFiles || []).map((path14) => normalizeTrackedPath(path14));
     const hasFiles = legacyFiles2.length > 0 || installedFiles.length > 0;
     if (!hasFiles) {
       const legacyDirs2 = ["commands", "agents", "skills", "rules", "workflows", "hooks", "scripts"];
@@ -95065,6 +95066,90 @@ async function removeKitFromManifest(claudeDir2, kit, options2) {
     }
   }
 }
+async function retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
+  const metadataPath = join95(claudeDir2, "metadata.json");
+  if (!await import_fs_extra17.pathExists(metadataPath))
+    return false;
+  const normalizedPaths = new Set(retainedPaths.map((path15) => path15.replace(/\\/g, "/")));
+  if (normalizedPaths.size === 0)
+    return false;
+  let release = null;
+  try {
+    if (!options2?.lockHeld) {
+      release = await acquireInstallationStateLock(claudeDir2);
+    }
+    const metadata = await readManifest(claudeDir2);
+    if (!metadata)
+      return false;
+    if (metadata.kits) {
+      const retainedKits = Object.entries(metadata.kits).reduce((acc, [kitName, kitMeta]) => {
+        if (kitName === options2?.excludeKit) {
+          return acc;
+        }
+        const keptFiles = (kitMeta.files || []).flatMap((file) => {
+          const normalizedPath = file.path.replace(/\\/g, "/");
+          if (!normalizedPaths.has(normalizedPath)) {
+            return [];
+          }
+          return [
+            {
+              ...file,
+              path: normalizedPath
+            }
+          ];
+        });
+        if (keptFiles.length > 0) {
+          acc[kitName] = {
+            ...kitMeta,
+            files: keptFiles
+          };
+        }
+        return acc;
+      }, {});
+      if (Object.keys(retainedKits).length === 0) {
+        return false;
+      }
+      const retainedFiles2 = Object.values(retainedKits).flatMap((kitMeta) => kitMeta.files || []);
+      const retainedInstalledFiles2 = retainedFiles2.map((file) => file.path);
+      const updated2 = MetadataSchema.parse({
+        ...metadata,
+        kits: retainedKits,
+        files: retainedFiles2.length > 0 ? retainedFiles2 : undefined,
+        installedFiles: retainedInstalledFiles2.length > 0 ? retainedInstalledFiles2 : undefined
+      });
+      await import_fs_extra17.writeFile(metadataPath, JSON.stringify(updated2, null, 2), "utf-8");
+      return true;
+    }
+    const retainedFiles = (metadata.files || []).flatMap((file) => {
+      const normalizedPath = file.path.replace(/\\/g, "/");
+      if (!normalizedPaths.has(normalizedPath)) {
+        return [];
+      }
+      return [
+        {
+          ...file,
+          path: normalizedPath
+        }
+      ];
+    });
+    const retainedInstalledFiles = (metadata.installedFiles || []).filter((path15) => normalizedPaths.has(path15.replace(/\\/g, "/")));
+    if (retainedFiles.length === 0 && retainedInstalledFiles.length === 0) {
+      return false;
+    }
+    const updated = MetadataSchema.parse({
+      ...metadata,
+      files: retainedFiles.length > 0 ? retainedFiles : undefined,
+      installedFiles: retainedInstalledFiles.length > 0 ? retainedInstalledFiles : undefined
+    });
+    await import_fs_extra17.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
+    return true;
+  } finally {
+    if (release) {
+      await release();
+      logger.debug(`Released lock on ${metadataPath}`);
+    }
+  }
+}
 
 // src/services/file-operations/manifest/manifest-tracker.ts
 class ManifestTracker {
@@ -95232,6 +95317,9 @@ class ManifestWriter {
   static async removeKitFromManifest(claudeDir2, kit, options2) {
     return removeKitFromManifest(claudeDir2, kit, options2);
   }
+  static async retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
+    return retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2);
+  }
 }
 
 // src/domains/migration/legacy-migration.ts
@@ -102307,7 +102395,7 @@ import { basename as basename22, join as join128, resolve as resolve35, sep as s
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra40 = __toESM(require_lib(), 1);
+var import_fs_extra41 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
@@ -102315,7 +102403,11 @@ import { readdirSync as readdirSync7, rmSync as rmSync5 } from "node:fs";
 import { dirname as dirname33, join as join127 } from "node:path";
 init_logger();
 init_safe_prompts();
+var import_fs_extra40 = __toESM(require_lib(), 1);
 var import_picocolors37 = __toESM(require_picocolors(), 1);
+function normalizeTrackedPath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
   if (ownership === "ck") {
     return { action: "delete", reason: deleteReason };
@@ -102352,17 +102444,30 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   const result = {
     toDelete: [],
     toPreserve: [],
+    retainedManifestPaths: [],
+    protectedTrackedPaths: [],
     remainingKits: []
   };
   const metadata = await ManifestWriter.readManifest(installation.path);
   const uninstallManifest = await ManifestWriter.getUninstallManifest(installation.path, kit);
   result.remainingKits = uninstallManifest.remainingKits;
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
+    const preservedPaths = new Set(uninstallManifest.filesToPreserve.map((filePath) => normalizeTrackedPath(filePath)));
+    for (const remainingKit of result.remainingKits) {
+      const remainingFiles = metadata.kits?.[remainingKit]?.files || [];
+      for (const file of remainingFiles) {
+        const relativePath = normalizeTrackedPath(file.path);
+        if (await import_fs_extra40.pathExists(join127(installation.path, relativePath))) {
+          result.retainedManifestPaths.push(relativePath);
+        }
+      }
+    }
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join127(installation.path, trackedFile.path);
-      if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
-        result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
+      const relativePath = normalizeTrackedPath(trackedFile.path);
+      const filePath = join127(installation.path, relativePath);
+      if (preservedPaths.has(relativePath)) {
+        result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
       }
       const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
@@ -102370,12 +102475,14 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
         continue;
       const classification = classifyFileByOwnership(ownershipResult.ownership, forceOverwrite, `${kit} kit (pristine)`);
       if (classification.action === "delete") {
-        result.toDelete.push({ path: trackedFile.path, reason: classification.reason });
+        result.toDelete.push({ path: relativePath, reason: classification.reason });
       } else {
-        result.toPreserve.push({ path: trackedFile.path, reason: classification.reason });
+        result.toPreserve.push({ path: relativePath, reason: classification.reason });
+        result.protectedTrackedPaths.push(relativePath);
+        result.retainedManifestPaths.push(relativePath);
       }
     }
-    if (result.remainingKits.length === 0) {
+    if (result.retainedManifestPaths.length === 0) {
       result.toDelete.push({ path: "metadata.json", reason: "metadata file" });
     }
     return result;
@@ -102390,18 +102497,23 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join127(installation.path, trackedFile.path);
+    const relativePath = normalizeTrackedPath(trackedFile.path);
+    const filePath = join127(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
     const classification = classifyFileByOwnership(ownershipResult.ownership, forceOverwrite, "CK-owned (pristine)");
     if (classification.action === "delete") {
-      result.toDelete.push({ path: trackedFile.path, reason: classification.reason });
+      result.toDelete.push({ path: relativePath, reason: classification.reason });
     } else {
-      result.toPreserve.push({ path: trackedFile.path, reason: classification.reason });
+      result.toPreserve.push({ path: relativePath, reason: classification.reason });
+      result.protectedTrackedPaths.push(relativePath);
+      result.retainedManifestPaths.push(relativePath);
     }
   }
-  result.toDelete.push({ path: "metadata.json", reason: "metadata file" });
+  if (result.retainedManifestPaths.length === 0) {
+    result.toDelete.push({ path: "metadata.json", reason: "metadata file" });
+  }
   return result;
 }
 function displayDryRunPreview(analysis, installationType) {
@@ -102435,7 +102547,7 @@ function displayDryRunPreview(analysis, installationType) {
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory(filePath) {
   try {
-    const stats = await import_fs_extra40.lstat(filePath);
+    const stats = await import_fs_extra41.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -102443,7 +102555,7 @@ async function isDirectory(filePath) {
   }
 }
 function getUninstallMutatePaths(options2) {
-  if (options2.kit && options2.remainingKits.length > 0) {
+  if (options2.retainedManifestPaths.length > 0) {
     return ["metadata.json"];
   }
   return [];
@@ -102466,9 +102578,9 @@ async function isPathSafeToRemove(filePath, baseDir) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra40.lstat(filePath);
+    const stats = await import_fs_extra41.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra40.realpath(filePath);
+      const realPath = await import_fs_extra41.realpath(filePath);
       const resolvedReal = resolve35(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep10) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
@@ -102482,6 +102594,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
   }
 }
 async function removeInstallations(installations, options2) {
+  const summaries = [];
   for (const installation of installations) {
     let releaseInstallationLock = null;
     try {
@@ -102500,8 +102613,7 @@ async function removeInstallations(installations, options2) {
         continue;
       }
       const mutatePaths = getUninstallMutatePaths({
-        kit: options2.kit,
-        remainingKits: analysis.remainingKits
+        retainedManifestPaths: analysis.retainedManifestPaths
       });
       let backup = null;
       if (analysis.toDelete.length > 0 || mutatePaths.length > 0) {
@@ -102530,26 +102642,27 @@ async function removeInstallations(installations, options2) {
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
           const filePath = join128(installation.path, item.path);
-          if (!await import_fs_extra40.pathExists(filePath))
+          if (!await import_fs_extra41.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
             logger.debug(`Skipping unsafe path: ${item.path}`);
             continue;
           }
           const isDir = await isDirectory(filePath);
-          await import_fs_extra40.remove(filePath);
+          await import_fs_extra41.remove(filePath);
           removedCount++;
           logger.debug(`Removed ${isDir ? "directory" : "file"}: ${item.path}`);
           if (!isDir) {
             cleanedDirs += await cleanupEmptyDirectories3(filePath, installation.path);
           }
         }
-        if (options2.kit && analysis.remainingKits.length > 0) {
-          const removed = await ManifestWriter.removeKitFromManifest(installation.path, options2.kit, {
+        if (analysis.retainedManifestPaths.length > 0) {
+          const retained = await ManifestWriter.retainTrackedFilesInManifest(installation.path, [...new Set(analysis.retainedManifestPaths)], {
+            excludeKit: options2.kit && analysis.protectedTrackedPaths.length === 0 ? options2.kit : undefined,
             lockHeld: true
           });
-          if (!removed) {
-            throw new Error(`Failed to update metadata.json for ${options2.kit} kit uninstall`);
+          if (!retained) {
+            throw new Error("Failed to update metadata.json after partial uninstall");
           }
         }
         try {
@@ -102568,6 +102681,15 @@ async function removeInstallations(installations, options2) {
             log.message(`  ... and ${analysis.toPreserve.length - 5} more`);
           }
         }
+        if (analysis.protectedTrackedPaths.length > 0) {
+          log.warn("Protected ClaudeKit files were preserved. Metadata was retained so this installation does not fall back to legacy detection.");
+          log.info("Use --force-overwrite to remove those files on the next uninstall run.");
+        }
+        summaries.push({
+          path: installation.path,
+          preservedCustomizations: analysis.toPreserve.length,
+          protectedTrackedPaths: [...analysis.protectedTrackedPaths]
+        });
       } catch (error) {
         spinner.fail(`Failed to remove ${installation.type} installation`);
         if (backup) {
@@ -102581,6 +102703,7 @@ async function removeInstallations(installations, options2) {
       }
     }
   }
+  return summaries;
 }
 
 // src/commands/uninstall/uninstall-command.ts
@@ -102730,12 +102853,17 @@ ${import_picocolors38.default.yellow("User modifications will be permanently del
           return;
         }
       }
-      await removeInstallations(installations, {
+      const results = await removeInstallations(installations, {
         dryRun: false,
         forceOverwrite: validOptions.forceOverwrite,
         kit: validOptions.kit
       });
+      const hasProtectedFiles = results.some((result) => result.protectedTrackedPaths.length > 0);
       const kitMsg = validOptions.kit ? ` (${validOptions.kit} kit)` : "";
+      if (hasProtectedFiles) {
+        prompts.outro(`ClaudeKit${kitMsg} uninstall completed with preserved customizations. Use --force-overwrite for full removal.`);
+        return;
+      }
       prompts.outro(`ClaudeKit${kitMsg} uninstalled successfully!`);
     });
   } catch (error) {
@@ -105278,7 +105406,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra41 = __toESM(require_lib(), 1);
+var import_fs_extra42 = __toESM(require_lib(), 1);
 import { rmSync as rmSync7 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -105287,7 +105415,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra41.remove(dir);
+      await import_fs_extra42.remove(dir);
       logger.debug(`Cleaned up temp directory: ${dir}`);
     } catch (error) {
       logger.debug(`Failed to clean temp directory ${dir}: ${error}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.41.2-dev.3",
+	"version": "3.41.3-dev.1",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {