claudekit-cli 3.26.1 → 3.27.1

package/dist/index.js

@@ -16194,7 +16194,7 @@ var init_init_command_help = __esm(() => {
           },
           {
             flags: "--fresh",
-            description: "Completely remove .claude directory before downloading (requires confirmation)"
+            description: "Remove ClaudeKit directories (commands/, agents/, skills/, rules/, hooks/) and reinstall"
           }
         ]
       },
@@ -16592,7 +16592,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -16602,20 +16602,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve10(false);
+        resolve11(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve10(code2 === 0);
+        resolve11(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve10(false);
+        resolve11(false);
       });
     } catch {
-      resolve10(false);
+      resolve11(false);
     }
   });
 }
@@ -16642,16 +16642,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve10) => {
+    await new Promise((resolve11) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve10();
+          resolve11();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve10();
+        resolve11();
       });
     });
   }
@@ -24690,12 +24690,25 @@ async function promptDirectorySelection(global2 = false) {
   }
   return selectedCategories;
 }
-async function promptFreshConfirmation(targetPath) {
-  logger.warning("[!] WARNING: Fresh installation will completely remove the .claude directory!");
+async function promptFreshConfirmation(targetPath, analysis) {
+  logger.warning("[!] Fresh installation will remove ClaudeKit files:");
   logger.info(`Path: ${targetPath}`);
-  logger.info("All custom files, configurations, and modifications will be permanently deleted.");
+  if (analysis?.hasMetadata) {
+    const ckCount = analysis.ckFiles.length + analysis.ckModifiedFiles.length;
+    const userCount = analysis.userFiles.length;
+    logger.info(`  Remove: ${ckCount} CK-owned files`);
+    logger.info(`  Preserve: ${userCount} user-created files`);
+    if (userCount > 0) {
+      const samples = analysis.userFiles.slice(0, 3).map((f3) => f3.path);
+      const remaining = userCount - samples.length;
+      logger.info(`  Examples preserved: ${samples.join(", ")}${remaining > 0 ? ` (+${remaining} more)` : ""}`);
+    }
+  } else {
+    logger.info("  Remove: commands/, agents/, skills/, rules/, hooks/");
+    logger.info("  Preserve: settings.json, Claude Code data");
+  }
   const confirmation = await te({
-    message: "Type 'yes' to confirm complete removal:",
+    message: "Type 'yes' to confirm:",
     placeholder: "yes",
     validate: (value) => {
       if (value.toLowerCase() !== "yes") {
@@ -24893,8 +24906,8 @@ class PromptsManager {
       logger.info("You can install these manually later using npm install -g <package>");
     }
   }
-  async promptFreshConfirmation(targetPath) {
-    return promptFreshConfirmation(targetPath);
+  async promptFreshConfirmation(targetPath, analysis) {
+    return promptFreshConfirmation(targetPath, analysis);
   }
   async promptUpdateMode() {
     return promptUpdateMode();
@@ -26449,7 +26462,7 @@ var import_ignore = __toESM(require_ignore(), 1);
 // src/domains/installation/download/file-downloader.ts
 init_logger();
 init_output_manager();
-import { createWriteStream as createWriteStream2 } from "node:fs";
+import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
 import { mkdir as mkdir9 } from "node:fs/promises";
 import { join as join28 } from "node:path";
 
@@ -26697,11 +26710,29 @@ class FileDownloader {
           downloadedSize += value.length;
           progressBar.update(downloadedSize);
         }
+        if (downloadedSize !== totalSize) {
+          fileStream.end();
+          await new Promise((resolve5) => fileStream.once("close", resolve5));
+          try {
+            rmSync(destPath, { force: true });
+          } catch (cleanupError) {
+            const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
+          }
+          throw new DownloadError(`Incomplete download: received ${formatBytes(downloadedSize)} of ${formatBytes(totalSize)}`);
+        }
         fileStream.end();
         progressBar.complete(`Downloaded ${asset.name}`);
         return destPath;
       } catch (error) {
-        fileStream.close();
+        fileStream.end();
+        await new Promise((resolve5) => fileStream.once("close", resolve5));
+        try {
+          rmSync(destPath, { force: true });
+        } catch (cleanupError) {
+          const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+          logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
+        }
         throw error;
       }
     } catch (error) {
@@ -26751,11 +26782,19 @@ class FileDownloader {
           progressBar.update(downloadedSize);
         }
       }
-      fileStream.end();
       const expectedSize = Number(response.headers.get("content-length"));
       if (expectedSize > 0 && downloadedSize !== expectedSize) {
+        fileStream.end();
+        await new Promise((resolve5) => fileStream.once("close", resolve5));
+        try {
+          rmSync(destPath, { force: true });
+        } catch (cleanupError) {
+          const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+          logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
+        }
         throw new DownloadError(`Incomplete download: received ${formatBytes(downloadedSize)} of ${formatBytes(expectedSize)}`);
       }
+      fileStream.end();
       if (progressBar) {
         progressBar.complete(`Downloaded ${name}`);
       } else {
@@ -26763,7 +26802,14 @@ class FileDownloader {
       }
       return destPath;
     } catch (error) {
-      fileStream.close();
+      fileStream.end();
+      await new Promise((resolve5) => fileStream.once("close", resolve5));
+      try {
+        rmSync(destPath, { force: true });
+      } catch (cleanupError) {
+        const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+        logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
+      }
       throw error;
     }
   }
@@ -34621,15 +34667,24 @@ class SelectiveMerger {
                 conflictInfo: { ...conflictBase, winner: "existing", reason: "no-timestamps" }
               };
             }
+            logger.debug(`Updating shared file (version fallback): ${relativePath} - incoming ${incomingVersion} > installed ${installedVersion}`);
+            return {
+              changed: true,
+              reason: "shared-newer",
+              sourceChecksum: manifestEntry.checksum,
+              destChecksum: installed.checksum,
+              sharedWithKit: installed.ownerKit,
+              conflictInfo: { ...conflictBase, winner: "incoming", reason: "no-timestamps" }
+            };
           }
-          logger.debug(`Updating shared file (version fallback): ${relativePath} - incoming ${incomingVersion} > installed ${installedVersion}`);
+          logger.debug(`Shared file version comparison skipped (non-semver): ${relativePath} - incoming ${incomingVersion}, installed ${installedVersion}`);
           return {
-            changed: true,
-            reason: "shared-newer",
+            changed: false,
+            reason: "shared-older",
             sourceChecksum: manifestEntry.checksum,
             destChecksum: installed.checksum,
             sharedWithKit: installed.ownerKit,
-            conflictInfo: { ...conflictBase, winner: "incoming", reason: "no-timestamps" }
+            conflictInfo: { ...conflictBase, winner: "existing", reason: "no-timestamps" }
           };
         }
       }
@@ -38293,9 +38348,10 @@ init_logger();
 init_output_manager();
 var import_fs_extra16 = __toESM(require_lib(), 1);
 async function handleMerge(ctx) {
-  if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir || !ctx.kit || !ctx.release || !ctx.kitType) {
+  if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir || !ctx.kit || !ctx.kitType) {
     return ctx;
   }
+  const installedVersion = ctx.release?.tag_name ?? "local";
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
@@ -38347,7 +38403,7 @@ async function handleMerge(ctx) {
     const legacyDetection = await LegacyMigration.detectLegacy(ctx.claudeDir);
     if (legacyDetection.isLegacy && releaseManifest) {
       logger.info("Legacy installation detected - migrating to ownership tracking...");
-      await LegacyMigration.migrate(ctx.claudeDir, releaseManifest, ctx.kit.name, ctx.release.tag_name, !ctx.isNonInteractive);
+      await LegacyMigration.migrate(ctx.claudeDir, releaseManifest, ctx.kit.name, installedVersion, !ctx.isNonInteractive);
       logger.success("Migration complete");
     }
   }
@@ -38375,13 +38431,13 @@ async function handleMerge(ctx) {
     installedFiles,
     claudeDir: ctx.claudeDir,
     releaseManifest,
-    installedVersion: ctx.release.tag_name,
+    installedVersion,
     isGlobal: ctx.options.global
   });
   await trackFilesWithProgress(filesToTrack, {
     claudeDir: ctx.claudeDir,
     kitName: ctx.kit.name,
-    releaseTag: ctx.release.tag_name,
+    releaseTag: installedVersion,
     mode: ctx.options.global ? "global" : "local",
     kitType: ctx.kitType
   });
@@ -40339,7 +40395,7 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 }
 // src/commands/init/phases/selection-handler.ts
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join66, resolve as resolve7 } from "node:path";
+import { join as join66, resolve as resolve8 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -40466,38 +40522,196 @@ async function runPreflightChecks() {
 }
 
 // src/domains/installation/fresh-installer.ts
+import { existsSync as existsSync19, readdirSync, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname9, join as join65, resolve as resolve7 } from "node:path";
 init_logger();
-import { join as join65 } from "node:path";
 var import_fs_extra29 = __toESM(require_lib(), 1);
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
+async function analyzeFreshInstallation(claudeDir) {
+  const metadata = await readManifest(claudeDir);
+  if (!metadata) {
+    return {
+      ckFiles: [],
+      ckModifiedFiles: [],
+      userFiles: [],
+      hasMetadata: false
+    };
+  }
+  const allFiles = getAllTrackedFiles(metadata);
+  if (allFiles.length === 0) {
+    return {
+      ckFiles: [],
+      ckModifiedFiles: [],
+      userFiles: [],
+      hasMetadata: false
+    };
+  }
+  const ckFiles = [];
+  const ckModifiedFiles = [];
+  const userFiles = [];
+  for (const file of allFiles) {
+    switch (file.ownership) {
+      case "ck":
+        ckFiles.push(file);
+        break;
+      case "ck-modified":
+        ckModifiedFiles.push(file);
+        break;
+      case "user":
+        userFiles.push(file);
+        break;
+    }
+  }
+  return {
+    ckFiles,
+    ckModifiedFiles,
+    userFiles,
+    hasMetadata: true
+  };
+}
+function cleanupEmptyDirectories(filePath, claudeDir) {
+  const normalizedClaudeDir = resolve7(claudeDir);
+  let currentDir = resolve7(dirname9(filePath));
+  while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
+    try {
+      const entries = readdirSync(currentDir);
+      if (entries.length === 0) {
+        rmdirSync(currentDir);
+        logger.debug(`Removed empty directory: ${currentDir}`);
+        currentDir = resolve7(dirname9(currentDir));
+      } else {
+        break;
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.debug(`Could not remove directory ${currentDir}: ${errorMsg}`);
+      break;
+    }
+  }
+}
+async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
+  const removedFiles = [];
+  const preservedFiles = [];
+  const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
+  const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
+  for (const file of filesToRemove) {
+    const fullPath = join65(claudeDir, file.path);
+    try {
+      if (existsSync19(fullPath)) {
+        unlinkSync3(fullPath);
+        removedFiles.push(file.path);
+        logger.debug(`Removed: ${file.path}`);
+        cleanupEmptyDirectories(fullPath, claudeDir);
+      }
+    } catch (error) {
+      logger.debug(`Failed to remove ${file.path}: ${error}`);
+    }
+  }
+  for (const file of filesToPreserve) {
+    preservedFiles.push(file.path);
+  }
+  await updateMetadataAfterFresh(claudeDir, removedFiles);
+  return {
+    success: true,
+    removedCount: removedFiles.length,
+    preservedCount: preservedFiles.length,
+    removedFiles,
+    preservedFiles
+  };
+}
+async function updateMetadataAfterFresh(claudeDir, removedFiles) {
+  const metadataPath = join65(claudeDir, "metadata.json");
+  if (!await import_fs_extra29.pathExists(metadataPath)) {
+    return;
+  }
+  let content;
+  try {
+    content = await import_fs_extra29.readFile(metadataPath, "utf-8");
+  } catch (readError) {
+    logger.warning(`Failed to read metadata.json: ${readError instanceof Error ? readError.message : String(readError)}`);
+    return;
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(content);
+  } catch (parseError) {
+    logger.warning(`Failed to parse metadata.json: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    logger.info("Recommendation: Run 'ck init' to rebuild metadata");
+    return;
+  }
+  const removedSet = new Set(removedFiles);
+  if (metadata.kits) {
+    for (const kitName of Object.keys(metadata.kits)) {
+      const kit = metadata.kits[kitName];
+      if (kit?.files) {
+        kit.files = kit.files.filter((f3) => !removedSet.has(f3.path));
+      }
+    }
+  }
+  if (metadata.files) {
+    metadata.files = metadata.files.filter((f3) => !removedSet.has(f3.path));
+  }
+  try {
+    await import_fs_extra29.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    logger.debug(`Updated metadata.json, removed ${removedFiles.length} file entries`);
+  } catch (writeError) {
+    logger.warning(`Failed to write metadata.json: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+    logger.info("Recommendation: Check file permissions and run 'ck init' to rebuild metadata");
+  }
+}
+async function removeSubdirectoriesFallback(claudeDir) {
+  const removedFiles = [];
+  let removedDirCount = 0;
+  for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
+    const subdirPath = join65(claudeDir, subdir);
+    if (await import_fs_extra29.pathExists(subdirPath)) {
+      rmSync2(subdirPath, { recursive: true, force: true });
+      removedDirCount++;
+      removedFiles.push(`${subdir}/ (entire directory)`);
+      logger.debug(`Removed subdirectory: ${subdir}/`);
+    }
+  }
+  const metadataPath = join65(claudeDir, "metadata.json");
+  if (await import_fs_extra29.pathExists(metadataPath)) {
+    unlinkSync3(metadataPath);
+    removedFiles.push("metadata.json");
+  }
+  return {
+    success: true,
+    removedCount: removedDirCount,
+    preservedCount: 0,
+    removedFiles,
+    preservedFiles: []
+  };
+}
 async function handleFreshInstallation(claudeDir, prompts) {
   if (!await import_fs_extra29.pathExists(claudeDir)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
-  const confirmed = await prompts.promptFreshConfirmation(claudeDir);
+  const analysis = await analyzeFreshInstallation(claudeDir);
+  const confirmed = await prompts.promptFreshConfirmation(claudeDir, analysis);
   if (!confirmed) {
     logger.info("Fresh installation cancelled");
     return false;
   }
-  logger.info("Removing ClaudeKit-managed subdirectories...");
-  const spinner = createSpinner("Removing ClaudeKit subdirectories...").start();
+  const spinner = createSpinner("Removing ClaudeKit files...").start();
   try {
-    const { rmSync } = await import("node:fs");
-    let removedCount = 0;
-    for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-      const subdirPath = join65(claudeDir, subdir);
-      if (await import_fs_extra29.pathExists(subdirPath)) {
-        rmSync(subdirPath, { recursive: true, force: true });
-        removedCount++;
-        logger.debug(`Removed subdirectory: ${subdir}/`);
-      }
+    let result;
+    if (analysis.hasMetadata && (analysis.ckFiles.length > 0 || analysis.ckModifiedFiles.length > 0)) {
+      result = await removeFilesByOwnership(claudeDir, analysis, true);
+      spinner.succeed(`Removed ${result.removedCount} CK files, preserved ${result.preservedCount} user files`);
+    } else {
+      result = await removeSubdirectoriesFallback(claudeDir);
+      spinner.succeed(`Removed ${result.removedCount} ClaudeKit directories`);
+    }
+    if (result.preservedCount > 0) {
+      logger.verbose(`Preserved user files: ${result.preservedFiles.slice(0, 5).join(", ")}${result.preservedFiles.length > 5 ? ` and ${result.preservedFiles.length - 5} more` : ""}`);
     }
-    spinner.succeed(`Successfully removed ${removedCount} ClaudeKit subdirectories (preserving user configs)`);
     return true;
   } catch (error) {
-    spinner.fail("Failed to remove ClaudeKit subdirectories");
-    throw new Error(`Failed to remove subdirectories: ${error instanceof Error ? error.message : "Unknown error"}`);
+    spinner.fail("Failed to remove ClaudeKit files");
+    throw new Error(`Failed to remove files: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
 
@@ -40526,6 +40740,18 @@ async function handleSelection(ctx) {
       release: release2
     };
   }
+  const downloadMethods = [];
+  if (ctx.options.useGit)
+    downloadMethods.push("--use-git");
+  if (ctx.options.archive)
+    downloadMethods.push("--archive");
+  if (ctx.options.kitPath)
+    downloadMethods.push("--kit-path");
+  if (downloadMethods.length > 1) {
+    logger.error(`Mutually exclusive download methods: ${downloadMethods.join(", ")}`);
+    logger.info("Use only one of: --use-git, --archive, or --kit-path");
+    return { ...ctx, cancelled: true };
+  }
   const config = await ConfigManager.get();
   let accessibleKits;
   if (!ctx.options.useGit && !ctx.options.kitPath && !ctx.options.archive) {
@@ -40661,7 +40887,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve7(targetDir);
+  const resolvedDir = resolve8(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (!ctx.options.global && PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're at HOME directory. Installing here modifies your GLOBAL ClaudeKit.");
@@ -40733,15 +40959,16 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const github = new GitHubClient;
+  const isOfflineMode = !!(ctx.options.kitPath || ctx.options.archive);
+  const github = isOfflineMode ? null : new GitHubClient;
   let selectedVersion = ctx.options.release;
-  if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes) {
+  if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes && !isOfflineMode) {
     throw new Error("Non-interactive mode requires either: --release <tag> OR --yes (uses latest)");
   }
-  if (!selectedVersion && ctx.options.yes) {
+  if (!selectedVersion && ctx.options.yes && !isOfflineMode) {
     logger.info("Using latest stable version (--yes flag)");
   }
-  if (!selectedVersion && !ctx.isNonInteractive) {
+  if (!selectedVersion && !ctx.isNonInteractive && !isOfflineMode) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
@@ -40774,7 +41001,13 @@ async function handleSelection(ctx) {
     }
   }
   let release;
-  if (ctx.options.useGit && selectedVersion) {
+  if (isOfflineMode) {
+    release = undefined;
+    logger.verbose("Offline mode - skipping release fetch", {
+      kitPath: ctx.options.kitPath,
+      archive: ctx.options.archive
+    });
+  } else if (ctx.options.useGit && selectedVersion) {
     release = {
       id: 0,
       tag_name: selectedVersion,
@@ -40786,9 +41019,9 @@ async function handleSelection(ctx) {
       assets: []
     };
     logger.verbose("Using git clone mode with tag", { tag: selectedVersion });
-  } else if (selectedVersion) {
+  } else if (selectedVersion && github) {
     release = await github.getReleaseByTag(kit, selectedVersion);
-  } else {
+  } else if (github) {
     if (ctx.options.beta) {
       logger.info("Fetching latest beta release...");
     } else {
@@ -40813,8 +41046,8 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname9, join as join67, resolve as resolve8 } from "node:path";
+import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname10, join as join67, resolve as resolve9 } from "node:path";
 init_logger();
 var import_fs_extra31 = __toESM(require_lib(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
@@ -40822,7 +41055,7 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve8(ctx.options.dir || ".");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve9(ctx.options.dir || ".");
   const claudeDir = ctx.options.global ? resolvedDir : join67(resolvedDir, ".claude");
   if (!await import_fs_extra31.pathExists(claudeDir)) {
     logger.error("Cannot sync: no .claude directory found");
@@ -40932,7 +41165,7 @@ async function acquireSyncLock(global3) {
   const lockPath = join67(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir21(dirname9(lockPath), { recursive: true });
+  await mkdir21(dirname10(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open(lockPath, "wx");
@@ -40956,7 +41189,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve9) => setTimeout(resolve9, 100));
+        await new Promise((resolve10) => setTimeout(resolve10, 100));
         continue;
       }
       throw err;
@@ -41075,7 +41308,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile19(tempPath, result.result, "utf-8");
+            await writeFile20(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -41261,7 +41494,7 @@ async function renameFolders(dirsToRename, extractDir, options) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile23, readdir as readdir23, writeFile as writeFile20 } from "node:fs/promises";
+import { readFile as readFile24, readdir as readdir23, writeFile as writeFile21 } from "node:fs/promises";
 import { join as join69, relative as relative13 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
@@ -41328,7 +41561,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile23(fullPath, "utf-8");
+        const content = await readFile24(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -41344,7 +41577,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile20(fullPath, newContent, "utf-8");
+            await writeFile21(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -41450,7 +41683,7 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile24, readdir as readdir24, writeFile as writeFile21 } from "node:fs/promises";
+import { readFile as readFile25, readdir as readdir24, writeFile as writeFile22 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
 import { extname as extname3, join as join70 } from "node:path";
 var IS_WINDOWS4 = platform12() === "win32";
@@ -41570,10 +41803,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile24(fullPath, "utf-8");
+          const content = await readFile25(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile21(fullPath, transformed, "utf-8");
+            await writeFile22(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -41828,7 +42061,7 @@ init_types2();
 var import_picocolors20 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 init_logger();
 init_types2();
 var import_fs_extra33 = __toESM(require_lib(), 1);
@@ -41912,7 +42145,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve9(targetDir);
+  const resolvedDir = resolve10(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -42253,14 +42486,14 @@ async function detectInstallations() {
 }
 
 // src/commands/uninstall/removal-handler.ts
-import { readdirSync as readdirSync2, rmSync as rmSync2 } from "node:fs";
+import { readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
 import { join as join74 } from "node:path";
 init_logger();
 var import_fs_extra35 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
-import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname10, join as join73 } from "node:path";
+import { readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { dirname as dirname11, join as join73 } from "node:path";
 init_logger();
 var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -42275,17 +42508,17 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
   }
   return { action: "preserve", reason: "user-created" };
 }
-async function cleanupEmptyDirectories(filePath, installationRoot) {
+async function cleanupEmptyDirectories2(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname10(filePath);
+  let currentDir = dirname11(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
-      const entries = readdirSync(currentDir);
+      const entries = readdirSync2(currentDir);
       if (entries.length === 0) {
-        rmSync(currentDir, { recursive: true });
+        rmSync3(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname10(currentDir);
+        currentDir = dirname11(currentDir);
       } else {
         break;
       }
@@ -42402,16 +42635,16 @@ async function removeInstallations(installations, options) {
           await import_fs_extra35.remove(filePath);
           removedCount++;
           logger.debug(`Removed: ${item.path}`);
-          cleanedDirs += await cleanupEmptyDirectories(filePath, installation.path);
+          cleanedDirs += await cleanupEmptyDirectories2(filePath, installation.path);
         }
       }
       if (options.kit && analysis.remainingKits.length > 0) {
         await ManifestWriter.removeKitFromManifest(installation.path, options.kit);
       }
       try {
-        const remaining = readdirSync2(installation.path);
+        const remaining = readdirSync3(installation.path);
         if (remaining.length === 0) {
-          rmSync2(installation.path, { recursive: true });
+          rmSync4(installation.path, { recursive: true });
           logger.debug(`Removed empty installation directory: ${installation.path}`);
         }
       } catch {}
@@ -42715,7 +42948,7 @@ var import_fs_extra36 = __toESM(require_lib(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.26.1",
+  version: "3.27.1",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -43193,7 +43426,7 @@ function registerCommands(cli) {
 }
 
 // src/cli/version-display.ts
-import { existsSync as existsSync20, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync7 } from "node:fs";
 import { join as join77 } from "node:path";
 
 // src/domains/versioning/checking/version-utils.ts
@@ -43219,8 +43452,8 @@ init_types2();
 
 // src/domains/versioning/version-cache.ts
 init_logger();
-import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile26, writeFile as writeFile22 } from "node:fs/promises";
+import { existsSync as existsSync20 } from "node:fs";
+import { mkdir as mkdir22, readFile as readFile27, writeFile as writeFile23 } from "node:fs/promises";
 import { join as join76 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
@@ -43232,11 +43465,11 @@ class VersionCacheManager {
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (!existsSync19(cacheFile)) {
+      if (!existsSync20(cacheFile)) {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile26(cacheFile, "utf-8");
+      const content = await readFile27(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -43253,10 +43486,10 @@ class VersionCacheManager {
     const cacheFile = VersionCacheManager.getCacheFile();
     const cacheDir = PathResolver.getCacheDir(false);
     try {
-      if (!existsSync19(cacheDir)) {
+      if (!existsSync20(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile22(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile23(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -43275,7 +43508,7 @@ class VersionCacheManager {
   static async clear() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (existsSync19(cacheFile)) {
+      if (existsSync20(cacheFile)) {
         const fs14 = await import("node:fs/promises");
         await fs14.unlink(cacheFile);
         logger.debug("Version check cache cleared");
@@ -43498,7 +43731,7 @@ async function displayVersion() {
   const prefix = PathResolver.getPathPrefix(false);
   const localMetadataPath = prefix ? join77(process.cwd(), prefix, "metadata.json") : join77(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync20(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync21(localMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync7(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
@@ -43512,7 +43745,7 @@ async function displayVersion() {
       logger.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync20(globalMetadataPath)) {
+  if (existsSync21(globalMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync7(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.26.1",
+	"version": "3.27.1",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {