claudekit-cli 3.41.2 → 3.41.3

package/dist/index.js

@@ -57632,7 +57632,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.2",
+    version: "3.41.3",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -80380,7 +80380,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 };
     }
@@ -91130,6 +91130,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);
@@ -91144,14 +91145,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));
             }
           }
         }
@@ -91171,7 +91172,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,
@@ -91179,8 +91180,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"];
@@ -94073,6 +94074,92 @@ async function removeKitFromManifest(claudeDir2, kit) {
     }
   }
 }
+async function retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
+  const metadataPath = join91(claudeDir2, "metadata.json");
+  if (!await import_fs_extra14.pathExists(metadataPath))
+    return false;
+  const normalizedPaths = new Set(retainedPaths.map((path15) => path15.replace(/\\/g, "/")));
+  if (normalizedPaths.size === 0)
+    return false;
+  let release = null;
+  try {
+    release = await import_proper_lockfile5.lock(metadataPath, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
+      stale: 60000
+    });
+    logger.debug(`Acquired lock on ${metadataPath} for retained metadata update`);
+    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_extra14.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_extra14.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 {
@@ -94240,6 +94327,9 @@ class ManifestWriter {
   static async removeKitFromManifest(claudeDir2, kit) {
     return removeKitFromManifest(claudeDir2, kit);
   }
+  static async retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
+    return retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2);
+  }
 }
 
 // src/domains/migration/legacy-migration.ts
@@ -101259,7 +101349,7 @@ import { join as join124, resolve as resolve31, sep as sep8 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra37 = __toESM(require_lib3(), 1);
+var import_fs_extra38 = __toESM(require_lib3(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
@@ -101267,7 +101357,11 @@ import { readdirSync as readdirSync6, rmSync as rmSync5 } from "node:fs";
 import { dirname as dirname32, join as join123 } from "node:path";
 init_logger();
 init_safe_prompts();
+var import_fs_extra37 = __toESM(require_lib3(), 1);
 var import_picocolors36 = __toESM(require_picocolors(), 1);
+function normalizeTrackedPath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
   if (ownership === "ck") {
     return { action: "delete", reason: deleteReason };
@@ -101304,17 +101398,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_extra37.pathExists(join123(installation.path, relativePath))) {
+          result.retainedManifestPaths.push(relativePath);
+        }
+      }
+    }
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join123(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 = join123(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);
@@ -101322,12 +101429,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;
@@ -101342,18 +101451,23 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join123(installation.path, trackedFile.path);
+    const relativePath = normalizeTrackedPath(trackedFile.path);
+    const filePath = join123(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) {
@@ -101387,7 +101501,7 @@ function displayDryRunPreview(analysis, installationType) {
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory(filePath) {
   try {
-    const stats = await import_fs_extra37.lstat(filePath);
+    const stats = await import_fs_extra38.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -101402,9 +101516,9 @@ async function isPathSafeToRemove(filePath, baseDir) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra37.lstat(filePath);
+    const stats = await import_fs_extra38.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra37.realpath(filePath);
+      const realPath = await import_fs_extra38.realpath(filePath);
       const resolvedReal = resolve31(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep8) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
@@ -101418,6 +101532,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
   }
 }
 async function removeInstallations(installations, options2) {
+  const summaries = [];
   for (const installation of installations) {
     const analysis = await analyzeInstallation(installation, options2.forceOverwrite, options2.kit);
     if (options2.dryRun) {
@@ -101440,22 +101555,25 @@ async function removeInstallations(installations, options2) {
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
         const filePath = join124(installation.path, item.path);
-        if (!await import_fs_extra37.pathExists(filePath))
+        if (!await import_fs_extra38.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_extra37.remove(filePath);
+        await import_fs_extra38.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) {
-        await ManifestWriter.removeKitFromManifest(installation.path, options2.kit);
+      if (analysis.retainedManifestPaths.length > 0) {
+        const retained = await ManifestWriter.retainTrackedFilesInManifest(installation.path, [...new Set(analysis.retainedManifestPaths)], options2.kit && analysis.protectedTrackedPaths.length === 0 ? { excludeKit: options2.kit } : undefined);
+        if (!retained) {
+          throw new Error("Failed to update metadata.json after partial uninstall");
+        }
       }
       try {
         const remaining = readdirSync7(installation.path);
@@ -101473,11 +101591,21 @@ 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`);
       throw new Error(`Failed to remove files from ${installation.path}: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
+  return summaries;
 }
 
 // src/commands/uninstall/uninstall-command.ts
@@ -101626,12 +101754,17 @@ ${import_picocolors37.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) {
     logger.error(error instanceof Error ? error.message : "Unknown error");
@@ -104165,7 +104298,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra38 = __toESM(require_lib3(), 1);
+var import_fs_extra39 = __toESM(require_lib3(), 1);
 import { rmSync as rmSync7 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -104174,7 +104307,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra38.remove(dir);
+      await import_fs_extra39.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",
+	"version": "3.41.3",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {