claudekit-cli 3.9.2 → 3.10.1

package/dist/index.js

@@ -12363,6 +12363,231 @@ var init_install_error_handler = __esm(() => {
   init_logger();
 });
 
+// src/services/package-installer/gemini-mcp-linker.ts
+var exports_gemini_mcp_linker = {};
+__export(exports_gemini_mcp_linker, {
+  processGeminiMcpLinking: () => processGeminiMcpLinking,
+  linkGeminiMcpConfig: () => linkGeminiMcpConfig,
+  findMcpConfigPath: () => findMcpConfigPath,
+  checkExistingGeminiConfig: () => checkExistingGeminiConfig,
+  addGeminiToGitignore: () => addGeminiToGitignore
+});
+import { existsSync as existsSync7, lstatSync, readlinkSync } from "node:fs";
+import { mkdir as mkdir9, readFile as readFile14, symlink as symlink2, writeFile as writeFile12 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname6, join as join25, resolve as resolve3 } from "node:path";
+function getGlobalMcpConfigPath() {
+  return join25(homedir4(), ".claude", ".mcp.json");
+}
+function getLocalMcpConfigPath(projectDir) {
+  return join25(projectDir, ".mcp.json");
+}
+function findMcpConfigPath(projectDir) {
+  const localPath = getLocalMcpConfigPath(projectDir);
+  if (existsSync7(localPath)) {
+    logger.debug(`Found local MCP config: ${localPath}`);
+    return localPath;
+  }
+  const globalPath = getGlobalMcpConfigPath();
+  if (existsSync7(globalPath)) {
+    logger.debug(`Found global MCP config: ${globalPath}`);
+    return globalPath;
+  }
+  logger.debug("No MCP config found (local or global)");
+  return null;
+}
+function checkExistingGeminiConfig(projectDir) {
+  const geminiSettingsPath = join25(projectDir, ".gemini", "settings.json");
+  if (!existsSync7(geminiSettingsPath)) {
+    return { exists: false, isSymlink: false };
+  }
+  try {
+    const stats = lstatSync(geminiSettingsPath);
+    if (stats.isSymbolicLink()) {
+      const target = readlinkSync(geminiSettingsPath);
+      return { exists: true, isSymlink: true, currentTarget: target };
+    }
+    return { exists: true, isSymlink: false };
+  } catch {
+    return { exists: true, isSymlink: false };
+  }
+}
+async function readJsonFile(filePath) {
+  try {
+    const content = await readFile14(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logger.debug(`Failed to read/parse JSON file ${filePath}: ${errorMessage}`);
+    return null;
+  }
+}
+async function createSymlink(targetPath, linkPath, projectDir) {
+  const isWindows5 = process.platform === "win32";
+  const linkDir = dirname6(linkPath);
+  if (!existsSync7(linkDir)) {
+    await mkdir9(linkDir, { recursive: true });
+    logger.debug(`Created directory: ${linkDir}`);
+  }
+  const localMcpPath = join25(projectDir, ".mcp.json");
+  const isLocalConfig = targetPath === localMcpPath;
+  const symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
+  try {
+    await symlink2(symlinkTarget, linkPath, isWindows5 ? "file" : undefined);
+    logger.debug(`Created symlink: ${linkPath} → ${symlinkTarget}`);
+    return { success: true, method: "symlink", targetPath };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      method: "symlink",
+      error: `Failed to create symlink: ${errorMessage}`
+    };
+  }
+}
+async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
+  const linkDir = dirname6(geminiSettingsPath);
+  if (!existsSync7(linkDir)) {
+    await mkdir9(linkDir, { recursive: true });
+    logger.debug(`Created directory: ${linkDir}`);
+  }
+  const mcpConfig = await readJsonFile(mcpConfigPath);
+  if (!mcpConfig) {
+    return { success: false, method: "merge", error: "Failed to read MCP config" };
+  }
+  const mcpServers = mcpConfig.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return { success: false, method: "merge", error: "MCP config has no valid mcpServers object" };
+  }
+  const newSettings = { mcpServers };
+  try {
+    await writeFile12(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
+    logger.debug(`Created new Gemini settings with mcpServers: ${geminiSettingsPath}`);
+    return { success: true, method: "merge", targetPath: mcpConfigPath };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      method: "merge",
+      error: `Failed to write settings: ${errorMessage}`
+    };
+  }
+}
+async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
+  const geminiSettings = await readJsonFile(geminiSettingsPath);
+  if (!geminiSettings) {
+    return { success: false, method: "merge", error: "Failed to read existing Gemini settings" };
+  }
+  const mcpConfig = await readJsonFile(mcpConfigPath);
+  if (!mcpConfig) {
+    return { success: false, method: "merge", error: "Failed to read MCP config" };
+  }
+  const mcpServers = mcpConfig.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return { success: false, method: "merge", error: "MCP config has no valid mcpServers object" };
+  }
+  const mergedSettings = {
+    ...geminiSettings,
+    mcpServers
+  };
+  try {
+    await writeFile12(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+    logger.debug(`Merged mcpServers into: ${geminiSettingsPath}`);
+    return { success: true, method: "merge", targetPath: mcpConfigPath };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      method: "merge",
+      error: `Failed to write merged settings: ${errorMessage}`
+    };
+  }
+}
+async function addGeminiToGitignore(projectDir) {
+  const gitignorePath = join25(projectDir, ".gitignore");
+  const geminiPattern = ".gemini/";
+  try {
+    let content = "";
+    if (existsSync7(gitignorePath)) {
+      content = await readFile14(gitignorePath, "utf-8");
+      const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => !line.startsWith("#"));
+      const geminiPatterns = [".gemini/", ".gemini", "/.gemini/", "/.gemini"];
+      if (lines.some((line) => geminiPatterns.includes(line))) {
+        logger.debug(".gemini/ already in .gitignore");
+        return;
+      }
+    }
+    const newLine = content.endsWith(`
+`) || content === "" ? "" : `
+`;
+    const comment = "# Gemini CLI settings (contains user-specific config)";
+    await writeFile12(gitignorePath, `${content}${newLine}${comment}
+${geminiPattern}
+`, "utf-8");
+    logger.debug(`Added ${geminiPattern} to .gitignore`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logger.warning(`Failed to update .gitignore: ${errorMessage}`);
+  }
+}
+async function linkGeminiMcpConfig(projectDir, options = {}) {
+  const { skipGitignore = false } = options;
+  const resolvedProjectDir = resolve3(projectDir);
+  const geminiSettingsPath = join25(resolvedProjectDir, ".gemini", "settings.json");
+  const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
+  if (!mcpConfigPath) {
+    return {
+      success: false,
+      method: "symlink",
+      error: "No MCP config found. Create .mcp.json or ~/.claude/.mcp.json first."
+    };
+  }
+  const existing = checkExistingGeminiConfig(resolvedProjectDir);
+  let result;
+  if (!existing.exists) {
+    result = await createSymlink(mcpConfigPath, geminiSettingsPath, resolvedProjectDir);
+    if (!result.success && process.platform === "win32") {
+      logger.debug("Symlink failed on Windows, falling back to creating new settings with mcpServers");
+      result = await createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath);
+    }
+  } else if (existing.isSymlink) {
+    logger.debug(`Gemini config already symlinked: ${existing.currentTarget}`);
+    result = { success: true, method: "skipped", targetPath: existing.currentTarget };
+  } else {
+    result = await mergeGeminiSettings(geminiSettingsPath, mcpConfigPath);
+  }
+  if (result.success && !skipGitignore) {
+    await addGeminiToGitignore(resolvedProjectDir);
+  }
+  return result;
+}
+async function processGeminiMcpLinking(projectDir) {
+  logger.info("Setting up Gemini CLI MCP integration...");
+  const result = await linkGeminiMcpConfig(projectDir);
+  if (result.success) {
+    switch (result.method) {
+      case "symlink":
+        logger.success(`Gemini MCP linked: .gemini/settings.json → ${result.targetPath}`);
+        logger.info("MCP servers will auto-sync with your Claude config.");
+        break;
+      case "merge":
+        logger.success("Gemini MCP config updated (merged mcpServers, preserved your settings)");
+        logger.info("Note: Run 'ck init' again to sync MCP config changes.");
+        break;
+      case "skipped":
+        logger.info("Gemini MCP config already configured.");
+        break;
+    }
+  } else {
+    logger.warning(`Gemini MCP setup incomplete: ${result.error}`);
+    logger.info("Manual setup: mkdir -p .gemini && ln -sf .claude/.mcp.json .gemini/settings.json");
+  }
+}
+var init_gemini_mcp_linker = __esm(() => {
+  init_logger();
+});
+
 // src/services/package-installer/package-installer.ts
 var exports_package_installer = {};
 __export(exports_package_installer, {
@@ -12379,10 +12604,10 @@ __export(exports_package_installer, {
   getPackageVersion: () => getPackageVersion
 });
 import { exec as exec5, execFile as execFile2, spawn } from "node:child_process";
-import { join as join25, resolve as resolve3 } from "node:path";
+import { join as join26, resolve as resolve4 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 function executeInteractiveScript(command, args, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options?.cwd,
@@ -12403,7 +12628,7 @@ function executeInteractiveScript(command, args, options) {
       } else if (code2 !== 0) {
         reject(new Error(`Command exited with code ${code2}`));
       } else {
-        resolve4();
+        resolve5();
       }
     });
     child.on("error", (error) => {
@@ -12574,7 +12799,7 @@ async function installOpenCode() {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink5 } = await import("node:fs/promises");
     const { tmpdir: tmpdir3 } = await import("node:os");
-    const tempScriptPath = join25(tmpdir3(), "opencode-install.sh");
+    const tempScriptPath = join26(tmpdir3(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -12618,7 +12843,7 @@ async function installOpenCode() {
 async function installGemini() {
   return installPackageGlobally("@google/gemini-cli", "Google Gemini CLI");
 }
-async function processPackageInstallations(shouldInstallOpenCode, shouldInstallGemini) {
+async function processPackageInstallations(shouldInstallOpenCode, shouldInstallGemini, projectDir) {
   const results = {};
   if (shouldInstallOpenCode) {
     const alreadyInstalled = await isOpenCodeInstalled();
@@ -12643,12 +12868,17 @@ async function processPackageInstallations(shouldInstallOpenCode, shouldInstallG
     } else {
       results.gemini = await installGemini();
     }
+    const geminiAvailable = alreadyInstalled || results.gemini?.success;
+    if (projectDir && geminiAvailable) {
+      const { processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
+      await processGeminiMcpLinking2(projectDir);
+    }
   }
   return results;
 }
 function validateScriptPath(skillsDir, scriptPath) {
-  const skillsDirResolved = resolve3(skillsDir);
-  const scriptPathResolved = resolve3(scriptPath);
+  const skillsDirResolved = resolve4(skillsDir);
+  const scriptPathResolved = resolve4(scriptPath);
   const isWindows5 = process.platform === "win32";
   const skillsDirNormalized = isWindows5 ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows5 ? scriptPathResolved.toLowerCase() : scriptPathResolved;
@@ -12684,11 +12914,11 @@ async function installSkillsDependencies(skillsDir) {
     };
   }
   try {
-    const { existsSync: existsSync7 } = await import("node:fs");
+    const { existsSync: existsSync8 } = await import("node:fs");
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform9 = process.platform;
     const scriptName = platform9 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join25(skillsDir, scriptName);
+    const scriptPath = join26(skillsDir, scriptName);
     try {
       validateScriptPath(skillsDir, scriptPath);
     } catch (error) {
@@ -12700,11 +12930,11 @@ async function installSkillsDependencies(skillsDir) {
         error: `Path validation failed: ${errorMessage}`
       };
     }
-    if (!existsSync7(scriptPath)) {
+    if (!existsSync8(scriptPath)) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join25(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join26(skillsDir, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -12720,8 +12950,8 @@ async function installSkillsDependencies(skillsDir) {
     logger.info(`  Platform: ${platform9 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
     if (logger.isVerbose()) {
       try {
-        const { readFile: readFile14 } = await import("node:fs/promises");
-        const scriptContent = await readFile14(scriptPath, "utf-8");
+        const { readFile: readFile15 } = await import("node:fs/promises");
+        const scriptContent = await readFile15(scriptPath, "utf-8");
         const previewLines = scriptContent.split(`
 `).slice(0, 20);
         logger.verbose("Script preview (first 20 lines):");
@@ -12747,7 +12977,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.info(`  ${platform9 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join25(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  ${join26(skillsDir, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -12848,7 +13078,7 @@ async function installSkillsDependencies(skillsDir) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join25(skillsDir, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join26(skillsDir, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -13524,7 +13754,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -13534,20 +13764,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve7(false);
+        resolve8(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve7(code2 === 0);
+        resolve8(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve7(false);
+        resolve8(false);
       });
     } catch {
-      resolve7(false);
+      resolve8(false);
     }
   });
 }
@@ -13574,16 +13804,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve7();
+          resolve8();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve7();
+        resolve8();
       });
     });
   }
@@ -13841,8 +14071,8 @@ var init_help_interceptor = __esm(() => {
 });
 
 // src/index.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { join as join36 } from "path";
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -14447,7 +14677,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.9.2",
+  version: "3.10.1",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -18291,7 +18521,7 @@ async function doctorCommand(options = {}) {
 }
 
 // src/commands/init.ts
-import { join as join30, resolve as resolve5 } from "node:path";
+import { join as join31, resolve as resolve6 } from "node:path";
 
 // src/domains/config/config-manager.ts
 init_logger();
@@ -27327,30 +27557,75 @@ class SettingsMerger {
     return merged;
   }
   static mergeHookEntries(sourceEntries, destEntries, eventName, result) {
-    const existingCommands = new Set;
-    SettingsMerger.extractCommands(destEntries, existingCommands);
     if (destEntries.length > 0) {
       result.hooksPreserved += destEntries.length;
     }
-    const merged = [...destEntries];
+    const merged = destEntries.map((entry) => SettingsMerger.deepCopyEntry(entry));
+    const matcherIndex = new Map;
+    for (let i = 0;i < merged.length; i++) {
+      const entry = merged[i];
+      if ("matcher" in entry && entry.matcher) {
+        matcherIndex.set(entry.matcher, i);
+      }
+    }
+    const existingCommands = new Set;
+    SettingsMerger.extractCommands(destEntries, existingCommands);
     for (const entry of sourceEntries) {
+      const sourceMatcher = "matcher" in entry ? entry.matcher : undefined;
       const commands = SettingsMerger.getEntryCommands(entry);
-      const isFullyDuplicated = commands.length > 0 && commands.every((cmd) => existingCommands.has(cmd));
-      const duplicateCommands = commands.filter((cmd) => existingCommands.has(cmd));
-      if (duplicateCommands.length > 0) {
-        const summary = duplicateCommands.length === 1 ? `"${SettingsMerger.truncateCommand(duplicateCommands[0])}"` : `${duplicateCommands.length} commands`;
-        result.conflictsDetected.push(`${eventName}: duplicate ${summary}`);
-      }
-      if (!isFullyDuplicated) {
-        merged.push(entry);
-        result.hooksAdded++;
-        for (const cmd of commands) {
-          existingCommands.add(cmd);
+      if (sourceMatcher && matcherIndex.has(sourceMatcher)) {
+        const existingIdx = matcherIndex.get(sourceMatcher);
+        if (existingIdx === undefined)
+          continue;
+        const existingEntry = merged[existingIdx];
+        const newCommands = commands.filter((cmd) => !existingCommands.has(cmd));
+        const duplicateCommands = commands.filter((cmd) => existingCommands.has(cmd));
+        if (duplicateCommands.length > 0) {
+          const summary = duplicateCommands.length === 1 ? `"${SettingsMerger.truncateCommand(duplicateCommands[0])}"` : `${duplicateCommands.length} commands`;
+          result.conflictsDetected.push(`${eventName}: duplicate ${summary}`);
+        }
+        if (newCommands.length > 0 && "hooks" in entry && entry.hooks) {
+          if (!existingEntry.hooks) {
+            existingEntry.hooks = [];
+          }
+          for (const hook of entry.hooks) {
+            if (hook.command && !existingCommands.has(hook.command)) {
+              existingEntry.hooks.push(hook);
+              existingCommands.add(hook.command);
+            }
+          }
+          result.hooksAdded++;
+        }
+      } else {
+        const isFullyDuplicated = commands.length > 0 && commands.every((cmd) => existingCommands.has(cmd));
+        const duplicateCommands = commands.filter((cmd) => existingCommands.has(cmd));
+        if (duplicateCommands.length > 0) {
+          const summary = duplicateCommands.length === 1 ? `"${SettingsMerger.truncateCommand(duplicateCommands[0])}"` : `${duplicateCommands.length} commands`;
+          result.conflictsDetected.push(`${eventName}: duplicate ${summary}`);
+        }
+        if (!isFullyDuplicated) {
+          merged.push(entry);
+          result.hooksAdded++;
+          if (sourceMatcher) {
+            matcherIndex.set(sourceMatcher, merged.length - 1);
+          }
+          for (const cmd of commands) {
+            existingCommands.add(cmd);
+          }
         }
       }
     }
     return merged;
   }
+  static deepCopyEntry(entry) {
+    if ("hooks" in entry) {
+      return {
+        ...entry,
+        hooks: entry.hooks ? [...entry.hooks.map((h2) => ({ ...h2 }))] : undefined
+      };
+    }
+    return { ...entry };
+  }
   static extractCommands(entries, commands) {
     for (const entry of entries) {
       if ("command" in entry && entry.command) {
@@ -31577,7 +31852,7 @@ class PromptsManager {
 
 // src/services/file-operations/file-scanner.ts
 init_logger();
-import { join as join26, relative as relative7, resolve as resolve4 } from "node:path";
+import { join as join27, relative as relative7, resolve as resolve5 } from "node:path";
 var import_fs_extra15 = __toESM(require_lib(), 1);
 
 class FileScanner {
@@ -31594,7 +31869,7 @@ class FileScanner {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join26(dirPath, entry);
+        const fullPath = join27(dirPath, entry);
         if (!FileScanner.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -31629,8 +31904,8 @@ class FileScanner {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join26(destDir, subPath);
-    const sourceSubDir = join26(sourceDir, subPath);
+    const destSubDir = join27(destDir, subPath);
+    const sourceSubDir = join27(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -31658,8 +31933,8 @@ class FileScanner {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve4(basePath);
-    const resolvedTarget = resolve4(targetPath);
+    const resolvedBase = resolve5(basePath);
+    const resolvedTarget = resolve5(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path9) {
@@ -31668,8 +31943,8 @@ class FileScanner {
 }
 
 // src/services/transformers/commands-prefix.ts
-import { lstat as lstat3, mkdir as mkdir9, readdir as readdir11, stat as stat4 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { lstat as lstat3, mkdir as mkdir10, readdir as readdir11, stat as stat4 } from "node:fs/promises";
+import { join as join28 } from "node:path";
 init_logger();
 var import_fs_extra16 = __toESM(require_lib(), 1);
 function stripWindowsDrivePrefix(path9) {
@@ -31710,14 +31985,14 @@ function validatePath4(path9, paramName) {
 class CommandsPrefix {
   static async applyPrefix(extractDir) {
     validatePath4(extractDir, "extractDir");
-    const commandsDir = join27(extractDir, ".claude", "commands");
+    const commandsDir = join28(extractDir, ".claude", "commands");
     if (!await import_fs_extra16.pathExists(commandsDir)) {
       logger.verbose("No commands directory found, skipping prefix application");
       return;
     }
     logger.info("Applying /ck: prefix to slash commands...");
-    const backupDir = join27(extractDir, ".commands-backup");
-    const tempDir = join27(extractDir, ".commands-prefix-temp");
+    const backupDir = join28(extractDir, ".commands-backup");
+    const tempDir = join28(extractDir, ".commands-prefix-temp");
     try {
       const entries = await readdir11(commandsDir);
       if (entries.length === 0) {
@@ -31725,7 +32000,7 @@ class CommandsPrefix {
         return;
       }
       if (entries.length === 1 && entries[0] === "ck") {
-        const ckDir2 = join27(commandsDir, "ck");
+        const ckDir2 = join28(commandsDir, "ck");
         const ckStat = await stat4(ckDir2);
         if (ckStat.isDirectory()) {
           logger.verbose("Commands already have /ck: prefix, skipping");
@@ -31734,18 +32009,18 @@ class CommandsPrefix {
       }
       await import_fs_extra16.copy(commandsDir, backupDir);
       logger.verbose("Created backup of commands directory");
-      await mkdir9(tempDir, { recursive: true });
-      const ckDir = join27(tempDir, "ck");
-      await mkdir9(ckDir, { recursive: true });
+      await mkdir10(tempDir, { recursive: true });
+      const ckDir = join28(tempDir, "ck");
+      await mkdir10(ckDir, { recursive: true });
       let processedCount = 0;
       for (const entry of entries) {
-        const sourcePath = join27(commandsDir, entry);
+        const sourcePath = join28(commandsDir, entry);
         const stats = await lstat3(sourcePath);
         if (stats.isSymbolicLink()) {
           logger.warning(`Skipping symlink for security: ${entry}`);
           continue;
         }
-        const destPath = join27(ckDir, entry);
+        const destPath = join28(ckDir, entry);
         await import_fs_extra16.copy(sourcePath, destPath, {
           overwrite: false,
           errorOnExist: true
@@ -31793,8 +32068,8 @@ class CommandsPrefix {
   static async cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     const { dryRun = false, forceOverwrite = false } = options;
     validatePath4(targetDir, "targetDir");
-    const claudeDir = isGlobal ? targetDir : join27(targetDir, ".claude");
-    const commandsDir = join27(claudeDir, "commands");
+    const claudeDir = isGlobal ? targetDir : join28(targetDir, ".claude");
+    const commandsDir = join28(claudeDir, "commands");
     const result = {
       results: [],
       deletedCount: 0,
@@ -31822,7 +32097,7 @@ class CommandsPrefix {
       return result;
     }
     for (const entry of entries) {
-      const entryPath = join27(commandsDir, entry);
+      const entryPath = join28(commandsDir, entry);
       const stats = await lstat3(entryPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink: ${entry}`);
@@ -31988,7 +32263,7 @@ class CommandsPrefix {
     const files = [];
     const entries = await readdir11(dir);
     for (const entry of entries) {
-      const fullPath = join27(dir, entry);
+      const fullPath = join28(dir, entry);
       const stats = await lstat3(fullPath);
       if (stats.isSymbolicLink()) {
         continue;
@@ -32007,8 +32282,8 @@ class CommandsPrefix {
 init_logger();
 init_types2();
 var import_fs_extra17 = __toESM(require_lib(), 1);
-import { readFile as readFile14, readdir as readdir12, rename as rename3, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join28, relative as relative8 } from "node:path";
+import { readFile as readFile15, readdir as readdir12, rename as rename3, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join29, relative as relative8 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -32054,34 +32329,34 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
   }
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join28(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join29(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra17.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join28(extractDir, folders.docs)
+        to: join29(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join28(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join29(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra17.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join28(extractDir, ".claude", folders.docs)
+        to: join29(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join28(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join29(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra17.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join28(extractDir, folders.plans)
+        to: join29(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join28(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join29(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra17.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join28(extractDir, ".claude", folders.plans)
+        to: join29(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -32118,7 +32393,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
   let replacementsCount = 0;
   const entries = await readdir12(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join28(dir, entry.name);
+    const fullPath = join29(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -32131,7 +32406,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile14(fullPath, "utf-8");
+        const content = await readFile15(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -32147,7 +32422,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative8(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile12(fullPath, newContent, "utf-8");
+            await writeFile13(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative8(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -32227,9 +32502,9 @@ function validateFolderName(name2) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile15, readdir as readdir13, writeFile as writeFile13 } from "node:fs/promises";
+import { readFile as readFile16, readdir as readdir13, writeFile as writeFile14 } from "node:fs/promises";
 import { platform as platform9 } from "node:os";
-import { extname, join as join29 } from "node:path";
+import { extname, join as join30 } from "node:path";
 var IS_WINDOWS2 = platform9() === "win32";
 var HOME_PREFIX = IS_WINDOWS2 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -32321,7 +32596,7 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   async function processDirectory(dir) {
     const entries = await readdir13(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join29(dir, entry.name);
+      const fullPath = join30(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -32329,10 +32604,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile15(fullPath, "utf-8");
+          const content = await readFile16(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile13(fullPath, transformed, "utf-8");
+            await writeFile14(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -32380,9 +32655,9 @@ async function initCommand(options) {
     }
     if (validOptions.global) {
       const globalKitDir = PathResolver.getGlobalKitDir();
-      const cwdResolved = resolve5(process.cwd());
-      const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve5(globalKitDir, "..");
-      const localSettingsPath = join30(process.cwd(), ".claude", "settings.json");
+      const cwdResolved = resolve6(process.cwd());
+      const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve6(globalKitDir, "..");
+      const localSettingsPath = join31(process.cwd(), ".claude", "settings.json");
       if (!isInGlobalDir && await import_fs_extra18.pathExists(localSettingsPath)) {
         if (isNonInteractive2) {
           logger.warning("Local .claude/settings.json detected. Local settings take precedence over global.");
@@ -32394,7 +32669,7 @@ async function initCommand(options) {
             return;
           }
           if (choice === "remove") {
-            const localClaudeDir = join30(process.cwd(), ".claude");
+            const localClaudeDir = join31(process.cwd(), ".claude");
             try {
               await import_fs_extra18.remove(localClaudeDir);
               logger.success("Removed local .claude/ directory");
@@ -32438,12 +32713,12 @@ async function initCommand(options) {
         }
       }
     }
-    const resolvedDir = resolve5(targetDir);
+    const resolvedDir = resolve6(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (!await import_fs_extra18.pathExists(resolvedDir)) {
       if (validOptions.global) {
-        const { mkdir: mkdir10 } = await import("node:fs/promises");
-        await mkdir10(resolvedDir, { recursive: true });
+        const { mkdir: mkdir11 } = await import("node:fs/promises");
+        await mkdir11(resolvedDir, { recursive: true });
         logger.info(`Created global directory: ${resolvedDir}`);
       } else {
         logger.error(`Directory does not exist: ${resolvedDir}`);
@@ -32453,7 +32728,7 @@ async function initCommand(options) {
     }
     if (validOptions.fresh) {
       const prefix = PathResolver.getPathPrefix(validOptions.global);
-      const claudeDir2 = prefix ? join30(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join31(resolvedDir, prefix) : resolvedDir;
       const canProceed = await handleFreshInstallation(claudeDir2, prompts);
       if (!canProceed) {
         return;
@@ -32481,7 +32756,7 @@ async function initCommand(options) {
       logger.info("Fetching available versions...");
       let currentVersion = null;
       try {
-        const metadataPath = validOptions.global ? join30(PathResolver.getGlobalKitDir(), "metadata.json") : join30(resolvedDir, ".claude", "metadata.json");
+        const metadataPath = validOptions.global ? join31(PathResolver.getGlobalKitDir(), "metadata.json") : join31(resolvedDir, ".claude", "metadata.json");
         const metadata = await readClaudeKitMetadata(metadataPath);
         currentVersion = metadata?.version || null;
         if (currentVersion) {
@@ -32606,7 +32881,7 @@ async function initCommand(options) {
       }
     }
     if (!validOptions.fresh) {
-      const newSkillsDir = join30(extractDir, ".claude", "skills");
+      const newSkillsDir = join31(extractDir, ".claude", "skills");
       const currentSkillsDir = PathResolver.buildSkillsPath(resolvedDir, validOptions.global);
       if (await import_fs_extra18.pathExists(newSkillsDir) && await import_fs_extra18.pathExists(currentSkillsDir)) {
         logger.info("Checking for skills directory migration...");
@@ -32631,7 +32906,7 @@ async function initCommand(options) {
     let customClaudeFiles = [];
     if (!validOptions.fresh) {
       logger.info("Scanning for custom .claude files...");
-      const scanSourceDir = validOptions.global ? join30(extractDir, ".claude") : extractDir;
+      const scanSourceDir = validOptions.global ? join31(extractDir, ".claude") : extractDir;
       const scanTargetSubdir = validOptions.global ? "" : ".claude";
       customClaudeFiles = await FileScanner.findCustomFiles(resolvedDir, scanSourceDir, scanTargetSubdir);
     } else {
@@ -32666,7 +32941,7 @@ async function initCommand(options) {
     }
     merger.setGlobalFlag(validOptions.global);
     merger.setForceOverwriteSettings(validOptions.forceOverwriteSettings);
-    const claudeDir = validOptions.global ? resolvedDir : join30(resolvedDir, ".claude");
+    const claudeDir = validOptions.global ? resolvedDir : join31(resolvedDir, ".claude");
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     if (!validOptions.fresh && await import_fs_extra18.pathExists(claudeDir)) {
       const legacyDetection = await LegacyMigration.detectLegacy(claudeDir);
@@ -32688,7 +32963,7 @@ async function initCommand(options) {
         return;
       }
     }
-    const sourceDir = validOptions.global ? join30(extractDir, ".claude") : extractDir;
+    const sourceDir = validOptions.global ? join31(extractDir, ".claude") : extractDir;
     await merger.merge(sourceDir, resolvedDir, false);
     const manifestWriter = new ManifestWriter;
     const installedFiles = merger.getAllInstalledFiles();
@@ -32697,7 +32972,7 @@ async function initCommand(options) {
       if (!validOptions.global && !installedPath.startsWith(".claude/"))
         continue;
       const relativePath = validOptions.global ? installedPath : installedPath.replace(/^\.claude\//, "");
-      const filePath = join30(claudeDir, relativePath);
+      const filePath = join31(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -32718,8 +32993,8 @@ async function initCommand(options) {
     trackingSpinner.succeed(`Tracked ${trackResult.success} files`);
     await manifestWriter.writeManifest(claudeDir, kitConfig.name, release.tag_name, validOptions.global ? "global" : "local");
     if (validOptions.global) {
-      const claudeMdSource = join30(extractDir, "CLAUDE.md");
-      const claudeMdDest = join30(resolvedDir, "CLAUDE.md");
+      const claudeMdSource = join31(extractDir, "CLAUDE.md");
+      const claudeMdDest = join31(resolvedDir, "CLAUDE.md");
       if (await import_fs_extra18.pathExists(claudeMdSource)) {
         if (!await import_fs_extra18.pathExists(claudeMdDest)) {
           await import_fs_extra18.copy(claudeMdSource, claudeMdDest);
@@ -32738,8 +33013,21 @@ async function initCommand(options) {
       const skillsDir = PathResolver.buildSkillsPath(resolvedDir, validOptions.global);
       await handleSkillsInstallation2(skillsDir);
     }
+    if (!isNonInteractive2) {
+      const { isGeminiInstalled: isGeminiInstalled2 } = await Promise.resolve().then(() => (init_package_installer(), exports_package_installer));
+      const { checkExistingGeminiConfig: checkExistingGeminiConfig2, findMcpConfigPath: findMcpConfigPath2, processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
+      const geminiInstalled = await isGeminiInstalled2();
+      const existingConfig = checkExistingGeminiConfig2(resolvedDir);
+      const mcpConfigExists = findMcpConfigPath2(resolvedDir) !== null;
+      if (geminiInstalled && !existingConfig.exists && mcpConfigExists) {
+        const shouldSetupGemini = await prompts.confirm("Gemini CLI detected. Set up MCP integration? (creates .gemini/settings.json symlink)");
+        if (shouldSetupGemini) {
+          await processGeminiMcpLinking2(resolvedDir);
+        }
+      }
+    }
     if (!validOptions.skipSetup && !isNonInteractive2) {
-      const envPath = join30(claudeDir, ".env");
+      const envPath = join31(claudeDir, ".env");
       if (!await import_fs_extra18.pathExists(envPath)) {
         const shouldSetup = await prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
         if (shouldSetup) {
@@ -32770,7 +33058,7 @@ Protected files (.env, etc.) were not modified.`;
 }
 
 // src/commands/new.ts
-import { join as join31, resolve as resolve6 } from "node:path";
+import { join as join32, resolve as resolve7 } from "node:path";
 init_package_installer();
 init_environment();
 init_logger();
@@ -32801,7 +33089,7 @@ async function newCommand(options) {
         targetDir = await prompts.getDirectory(targetDir);
       }
     }
-    const resolvedDir = resolve6(targetDir);
+    const resolvedDir = resolve7(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (await import_fs_extra19.pathExists(resolvedDir)) {
       const files = await import_fs_extra19.readdir(resolvedDir);
@@ -32951,7 +33239,7 @@ async function newCommand(options) {
       await CommandsPrefix.cleanupCommandsDirectory(resolvedDir, false);
     }
     await merger.merge(extractDir, resolvedDir, true);
-    const claudeDir = join31(resolvedDir, ".claude");
+    const claudeDir = join32(resolvedDir, ".claude");
     const manifestWriter = new ManifestWriter;
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     const installedFiles = merger.getAllInstalledFiles();
@@ -32960,7 +33248,7 @@ async function newCommand(options) {
       if (!installedPath.startsWith(".claude/"))
         continue;
       const relativePath = installedPath.replace(/^\.claude\//, "");
-      const filePath = join31(claudeDir, relativePath);
+      const filePath = join32(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -32992,7 +33280,7 @@ async function newCommand(options) {
     if (installOpenCode2 || installGemini2) {
       logger.info("Installing optional packages...");
       try {
-        const installationResults = await processPackageInstallations(installOpenCode2, installGemini2);
+        const installationResults = await processPackageInstallations(installOpenCode2, installGemini2, resolvedDir);
         prompts.showPackageInstallationResults(installationResults);
       } catch (error) {
         logger.warning(`Package installation failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -33013,7 +33301,7 @@ async function newCommand(options) {
 
 // src/commands/uninstall.ts
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname6, join as join32 } from "node:path";
+import { dirname as dirname7, join as join33 } from "node:path";
 init_logger();
 init_types2();
 var import_fs_extra20 = __toESM(require_lib(), 1);
@@ -33075,7 +33363,7 @@ async function confirmUninstall(scope) {
 }
 async function cleanupEmptyDirectories(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname6(filePath);
+  let currentDir = dirname7(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync(currentDir);
@@ -33083,7 +33371,7 @@ async function cleanupEmptyDirectories(filePath, installationRoot) {
         rmSync(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname6(currentDir);
+        currentDir = dirname7(currentDir);
       } else {
         break;
       }
@@ -33106,7 +33394,7 @@ async function analyzeInstallation(installation, forceOverwrite) {
     return result;
   }
   for (const trackedFile of metadata.files) {
-    const filePath = join32(installation.path, trackedFile.path);
+    const filePath = join33(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -33164,7 +33452,7 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join32(installation.path, item.path);
+        const filePath = join33(installation.path, item.path);
         if (await import_fs_extra20.pathExists(filePath)) {
           await import_fs_extra20.remove(filePath);
           removedCount++;
@@ -33405,7 +33693,7 @@ var import_compare_versions2 = __toESM(require_umd(), 1);
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.9.2",
+  version: "3.10.1",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -33712,24 +34000,24 @@ var import_picocolors15 = __toESM(require_picocolors(), 1);
 
 // src/domains/versioning/version-cache.ts
 init_logger();
-import { existsSync as existsSync7 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile16, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { mkdir as mkdir11, readFile as readFile17, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join34 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join33(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join34(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (!existsSync7(cacheFile)) {
+      if (!existsSync8(cacheFile)) {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile16(cacheFile, "utf-8");
+      const content = await readFile17(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -33746,10 +34034,10 @@ class VersionCacheManager {
     const cacheFile = VersionCacheManager.getCacheFile();
     const cacheDir = PathResolver.getCacheDir(false);
     try {
-      if (!existsSync7(cacheDir)) {
-        await mkdir10(cacheDir, { recursive: true, mode: 448 });
+      if (!existsSync8(cacheDir)) {
+        await mkdir11(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile14(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile15(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}`);
@@ -33768,7 +34056,7 @@ class VersionCacheManager {
   static async clear() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (existsSync7(cacheFile)) {
+      if (existsSync8(cacheFile)) {
         const fs12 = await import("node:fs/promises");
         await fs12.unlink(cacheFile);
         logger.debug("Version check cache cleared");
@@ -34231,8 +34519,8 @@ class OutputManager2 {
 var output2 = new OutputManager2;
 
 // src/shared/path-resolver.ts
-import { homedir as homedir4, platform as platform10 } from "node:os";
-import { join as join34, normalize as normalize6 } from "node:path";
+import { homedir as homedir5, platform as platform10 } from "node:os";
+import { join as join35, normalize as normalize6 } from "node:path";
 
 class PathResolver2 {
   static getTestHomeDir() {
@@ -34265,50 +34553,50 @@ class PathResolver2 {
   static getConfigDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join34(testHome, ".config", "claude") : join34(testHome, ".claudekit");
+      return global3 ? join35(testHome, ".config", "claude") : join35(testHome, ".claudekit");
     }
     if (!global3) {
-      return join34(homedir4(), ".claudekit");
+      return join35(homedir5(), ".claudekit");
     }
     const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join34(homedir4(), "AppData", "Local");
-      return join34(localAppData, "claude");
+      const localAppData = process.env.LOCALAPPDATA || join35(homedir5(), "AppData", "Local");
+      return join35(localAppData, "claude");
     }
     const xdgConfigHome = process.env.XDG_CONFIG_HOME;
     if (xdgConfigHome) {
-      return join34(xdgConfigHome, "claude");
+      return join35(xdgConfigHome, "claude");
     }
-    return join34(homedir4(), ".config", "claude");
+    return join35(homedir5(), ".config", "claude");
   }
   static getConfigFile(global3 = false) {
-    return join34(PathResolver2.getConfigDir(global3), "config.json");
+    return join35(PathResolver2.getConfigDir(global3), "config.json");
   }
   static getCacheDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join34(testHome, ".cache", "claude") : join34(testHome, ".claudekit", "cache");
+      return global3 ? join35(testHome, ".cache", "claude") : join35(testHome, ".claudekit", "cache");
     }
     if (!global3) {
-      return join34(homedir4(), ".claudekit", "cache");
+      return join35(homedir5(), ".claudekit", "cache");
     }
     const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join34(homedir4(), "AppData", "Local");
-      return join34(localAppData, "claude", "cache");
+      const localAppData = process.env.LOCALAPPDATA || join35(homedir5(), "AppData", "Local");
+      return join35(localAppData, "claude", "cache");
     }
     const xdgCacheHome = process.env.XDG_CACHE_HOME;
     if (xdgCacheHome) {
-      return join34(xdgCacheHome, "claude");
+      return join35(xdgCacheHome, "claude");
     }
-    return join34(homedir4(), ".cache", "claude");
+    return join35(homedir5(), ".cache", "claude");
   }
   static getGlobalKitDir() {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return join34(testHome, ".claude");
+      return join35(testHome, ".claude");
     }
-    return join34(homedir4(), ".claude");
+    return join35(homedir5(), ".claude");
   }
   static getPathPrefix(global3) {
     return global3 ? "" : ".claude";
@@ -34316,9 +34604,9 @@ class PathResolver2 {
   static buildSkillsPath(baseDir, global3) {
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join34(baseDir, prefix, "skills");
+      return join35(baseDir, prefix, "skills");
     }
-    return join34(baseDir, "skills");
+    return join35(baseDir, "skills");
   }
   static buildComponentPath(baseDir, component, global3) {
     if (!PathResolver2.isPathSafe(component)) {
@@ -34326,9 +34614,9 @@ class PathResolver2 {
     }
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join34(baseDir, prefix, component);
+      return join35(baseDir, prefix, component);
     }
-    return join34(baseDir, component);
+    return join35(baseDir, component);
   }
 }
 
@@ -34360,11 +34648,11 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver2.getGlobalKitDir();
-  const globalMetadataPath = join35(globalKitDir, "metadata.json");
+  const globalMetadataPath = join36(globalKitDir, "metadata.json");
   const prefix = PathResolver2.getPathPrefix(false);
-  const localMetadataPath = prefix ? join35(process.cwd(), prefix, "metadata.json") : join35(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join36(process.cwd(), prefix, "metadata.json") : join36(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync8(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync9(localMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync5(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
@@ -34378,7 +34666,7 @@ async function displayVersion() {
       logger2.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync8(globalMetadataPath)) {
+  if (existsSync9(globalMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync5(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);

package/package.json

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