claudekit-cli 3.10.0 → 3.10.2

package/dist/index.js

@@ -6895,7 +6895,7 @@ var require_umd = __commonJS((exports, module) => {
 });
 
 // src/shared/environment.ts
-function isCIEnvironment3() {
+function isCIEnvironment() {
   return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
 }
 function isNonInteractive() {
@@ -12368,6 +12368,7 @@ var exports_gemini_mcp_linker = {};
 __export(exports_gemini_mcp_linker, {
   processGeminiMcpLinking: () => processGeminiMcpLinking,
   linkGeminiMcpConfig: () => linkGeminiMcpConfig,
+  getGeminiSettingsPath: () => getGeminiSettingsPath,
   findMcpConfigPath: () => findMcpConfigPath,
   checkExistingGeminiConfig: () => checkExistingGeminiConfig,
   addGeminiToGitignore: () => addGeminiToGitignore
@@ -12396,20 +12397,31 @@ function findMcpConfigPath(projectDir) {
   logger.debug("No MCP config found (local or global)");
   return null;
 }
-function checkExistingGeminiConfig(projectDir) {
-  const geminiSettingsPath = join25(projectDir, ".gemini", "settings.json");
+function getGeminiSettingsPath(projectDir, isGlobal) {
+  if (isGlobal) {
+    return join25(homedir4(), ".gemini", "settings.json");
+  }
+  return join25(projectDir, ".gemini", "settings.json");
+}
+function checkExistingGeminiConfig(projectDir, isGlobal = false) {
+  const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
   if (!existsSync7(geminiSettingsPath)) {
-    return { exists: false, isSymlink: false };
+    return { exists: false, isSymlink: false, settingsPath: geminiSettingsPath };
   }
   try {
     const stats = lstatSync(geminiSettingsPath);
     if (stats.isSymbolicLink()) {
       const target = readlinkSync(geminiSettingsPath);
-      return { exists: true, isSymlink: true, currentTarget: target };
+      return {
+        exists: true,
+        isSymlink: true,
+        currentTarget: target,
+        settingsPath: geminiSettingsPath
+      };
     }
-    return { exists: true, isSymlink: false };
+    return { exists: true, isSymlink: false, settingsPath: geminiSettingsPath };
   } catch {
-    return { exists: true, isSymlink: false };
+    return { exists: true, isSymlink: false, settingsPath: geminiSettingsPath };
   }
 }
 async function readJsonFile(filePath) {
@@ -12422,20 +12434,25 @@ async function readJsonFile(filePath) {
     return null;
   }
 }
-async function createSymlink(targetPath, linkPath, projectDir) {
+async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   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;
+  let symlinkTarget;
+  if (isGlobal) {
+    symlinkTarget = getGlobalMcpConfigPath();
+  } else {
+    const localMcpPath = join25(projectDir, ".mcp.json");
+    const isLocalConfig = targetPath === localMcpPath;
+    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 };
+    return { success: true, method: "symlink", targetPath, geminiSettingsPath: linkPath };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     return {
@@ -12532,9 +12549,9 @@ ${geminiPattern}
   }
 }
 async function linkGeminiMcpConfig(projectDir, options = {}) {
-  const { skipGitignore = false } = options;
+  const { skipGitignore = false, isGlobal = false } = options;
   const resolvedProjectDir = resolve3(projectDir);
-  const geminiSettingsPath = join25(resolvedProjectDir, ".gemini", "settings.json");
+  const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
     return {
@@ -12543,32 +12560,38 @@ async function linkGeminiMcpConfig(projectDir, options = {}) {
       error: "No MCP config found. Create .mcp.json or ~/.claude/.mcp.json first."
     };
   }
-  const existing = checkExistingGeminiConfig(resolvedProjectDir);
+  const existing = checkExistingGeminiConfig(resolvedProjectDir, isGlobal);
   let result;
   if (!existing.exists) {
-    result = await createSymlink(mcpConfigPath, geminiSettingsPath, resolvedProjectDir);
+    result = await createSymlink(mcpConfigPath, geminiSettingsPath, resolvedProjectDir, isGlobal);
     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 };
+    result = {
+      success: true,
+      method: "skipped",
+      targetPath: existing.currentTarget,
+      geminiSettingsPath
+    };
   } else {
     result = await mergeGeminiSettings(geminiSettingsPath, mcpConfigPath);
   }
-  if (result.success && !skipGitignore) {
+  if (result.success && !skipGitignore && !isGlobal) {
     await addGeminiToGitignore(resolvedProjectDir);
   }
   return result;
 }
-async function processGeminiMcpLinking(projectDir) {
+async function processGeminiMcpLinking(projectDir, options = {}) {
   logger.info("Setting up Gemini CLI MCP integration...");
-  const result = await linkGeminiMcpConfig(projectDir);
+  const result = await linkGeminiMcpConfig(projectDir, options);
+  const settingsPath = result.geminiSettingsPath || (options.isGlobal ? "~/.gemini/settings.json" : ".gemini/settings.json");
   if (result.success) {
     switch (result.method) {
       case "symlink":
-        logger.success(`Gemini MCP linked: .gemini/settings.json → ${result.targetPath}`);
+        logger.success(`Gemini MCP linked: ${settingsPath} → ${result.targetPath}`);
         logger.info("MCP servers will auto-sync with your Claude config.");
         break;
       case "merge":
@@ -12581,7 +12604,11 @@ async function processGeminiMcpLinking(projectDir) {
     }
   } else {
     logger.warning(`Gemini MCP setup incomplete: ${result.error}`);
-    logger.info("Manual setup: mkdir -p .gemini && ln -sf .claude/.mcp.json .gemini/settings.json");
+    if (options.isGlobal) {
+      logger.info("Manual setup: mkdir -p ~/.gemini && ln -sf ~/.claude/.mcp.json ~/.gemini/settings.json");
+    } else {
+      logger.info("Manual setup: mkdir -p .gemini && ln -sf ../.mcp.json .gemini/settings.json");
+    }
   }
 }
 var init_gemini_mcp_linker = __esm(() => {
@@ -12671,7 +12698,7 @@ async function isGeminiInstalled() {
 }
 async function isPackageInstalled(packageName) {
   validatePackageName(packageName);
-  if (isCIEnvironment3()) {
+  if (isCIEnvironment()) {
     logger.info(`CI environment detected: skipping network check for ${packageName}`);
     return false;
   }
@@ -12707,7 +12734,7 @@ async function isPackageInstalled(packageName) {
 }
 async function getPackageVersion(packageName) {
   validatePackageName(packageName);
-  if (isCIEnvironment3()) {
+  if (isCIEnvironment()) {
     logger.info(`CI environment detected: skipping version check for ${packageName}`);
     return null;
   }
@@ -12787,7 +12814,7 @@ async function installPackageGlobally(packageName, packageDisplayName) {
 }
 async function installOpenCode() {
   const displayName = "OpenCode CLI";
-  if (isCIEnvironment3()) {
+  if (isCIEnvironment()) {
     logger.info("CI environment detected: skipping OpenCode installation");
     return {
       success: false,
@@ -12896,7 +12923,7 @@ function validateScriptPath(skillsDir, scriptPath) {
 }
 async function installSkillsDependencies(skillsDir) {
   const displayName = "Skills Dependencies";
-  if (isCIEnvironment3()) {
+  if (isCIEnvironment()) {
     logger.info("CI environment detected: skipping skills installation");
     return {
       success: false,
@@ -14677,7 +14704,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.10.0",
+  version: "3.10.2",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -14922,7 +14949,12 @@ init_logger();
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
-var isCIEnvironment = process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+function shouldSkipExpensiveOperations() {
+  if (process.env.CK_TEST_HOME) {
+    return false;
+  }
+  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+}
 function getOSInfo() {
   const platform = process.platform;
   const arch = process.arch;
@@ -14994,7 +15026,7 @@ var DEPENDENCIES = {
   }
 };
 async function commandExists(command) {
-  if (isCIEnvironment) {
+  if (shouldSkipExpensiveOperations()) {
     const supportedCommands = ["node", "python", "python3", "pip", "pip3", "claude"];
     return supportedCommands.includes(command);
   }
@@ -15010,7 +15042,7 @@ async function commandExists(command) {
   }
 }
 async function getCommandPath(command) {
-  if (isCIEnvironment) {
+  if (shouldSkipExpensiveOperations()) {
     const ciPath = getCICommandPath(command);
     if (ciPath)
       return ciPath;
@@ -15029,7 +15061,7 @@ async function getCommandPath(command) {
   }
 }
 async function getCommandVersion(command, versionFlag, versionRegex) {
-  if (isCIEnvironment) {
+  if (shouldSkipExpensiveOperations()) {
     const mockVersions = {
       npm: "10.0.0",
       node: "20.0.0",
@@ -15361,6 +15393,12 @@ function compareVersions2(a, b) {
   }
   return 0;
 }
+function shouldSkipExpensiveOperations2() {
+  if (process.env.CK_TEST_HOME) {
+    return false;
+  }
+  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+}
 
 class SystemChecker {
   group = "system";
@@ -15375,13 +15413,29 @@ class SystemChecker {
       logger.verbose(`SystemChecker: Processing ${dep.name}`);
       results.push(await this.mapDependencyToCheck(dep));
     }
-    logger.verbose("SystemChecker: Checking git");
-    results.push(await this.checkGit());
-    logger.verbose("SystemChecker: Checking GitHub CLI");
-    results.push(await this.checkGitHubCli());
+    if (!shouldSkipExpensiveOperations2()) {
+      logger.verbose("SystemChecker: Checking git");
+      results.push(await this.checkGit());
+      logger.verbose("SystemChecker: Checking GitHub CLI");
+      results.push(await this.checkGitHubCli());
+    } else {
+      logger.verbose("SystemChecker: Skipping git/gh checks in CI");
+      results.push(this.createCISkipResult("git-version", "Git"));
+      results.push(this.createCISkipResult("gh-cli-version", "GitHub CLI"));
+    }
     logger.verbose("SystemChecker: All system checks complete");
     return results;
   }
+  createCISkipResult(id, name) {
+    return {
+      id,
+      name,
+      group: "system",
+      status: "pass",
+      message: "Skipped in CI",
+      autoFixable: false
+    };
+  }
   async mapDependencyToCheck(dep) {
     const isInstalled = dep.installed && dep.meetsRequirements;
     const name = this.formatDependencyName(dep.name);
@@ -16069,6 +16123,12 @@ async function getClaudeKitSetup(projectDir = process.cwd()) {
 // src/domains/health-checks/claudekit-checker.ts
 init_logger();
 var HOOK_EXTENSIONS = [".js", ".cjs", ".mjs", ".ts", ".sh", ".ps1"];
+function shouldSkipExpensiveOperations3() {
+  if (process.env.CK_TEST_HOME) {
+    return false;
+  }
+  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+}
 
 class ClaudekitChecker {
   group = "claudekit";
@@ -16338,6 +16398,18 @@ class ClaudekitChecker {
   }
   async checkGlobalDirReadable() {
     const globalDir = PathResolver.getGlobalKitDir();
+    if (shouldSkipExpensiveOperations3()) {
+      return {
+        id: "ck-global-dir-readable",
+        name: "Global Dir Readable",
+        group: "claudekit",
+        priority: "standard",
+        status: "info",
+        message: "Skipped in CI/test environment",
+        details: globalDir,
+        autoFixable: false
+      };
+    }
     try {
       await access(globalDir, constants.R_OK);
       return {
@@ -16366,6 +16438,18 @@ class ClaudekitChecker {
   }
   async checkGlobalDirWritable() {
     const globalDir = PathResolver.getGlobalKitDir();
+    if (shouldSkipExpensiveOperations3()) {
+      return {
+        id: "ck-global-dir-writable",
+        name: "Global Dir Writable",
+        group: "claudekit",
+        priority: "standard",
+        status: "info",
+        message: "Skipped in CI/test environment",
+        details: globalDir,
+        autoFixable: false
+      };
+    }
     const timestamp = Date.now();
     const random = Math.random().toString(36).substring(2);
     const testFile = join4(globalDir, `.ck-write-test-${timestamp}-${random}`);
@@ -17449,7 +17533,12 @@ Need help? Run with: ck new --verbose`, 404);
 // src/domains/health-checks/auth-checker.ts
 init_logger();
 init_types2();
-var isCIEnvironment2 = process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+function shouldSkipExpensiveOperations4() {
+  if (process.env.CK_TEST_HOME) {
+    return false;
+  }
+  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+}
 
 class AuthChecker {
   group = "auth";
@@ -17533,14 +17622,14 @@ class AuthChecker {
   }
   async checkRepoAccess(kit) {
     const kitConfig = AVAILABLE_KITS[kit];
-    if (isCIEnvironment2) {
-      logger.verbose(`AuthChecker: Skipping repo access check for ${kit} in CI`);
+    if (shouldSkipExpensiveOperations4()) {
+      logger.verbose(`AuthChecker: Skipping repo access check for ${kit} in CI/test`);
       return {
         id: `repo-access-${kit}`,
         name: `Repository Access (${kit})`,
         group: "auth",
         status: "info",
-        message: "Skipped in CI environment",
+        message: "Skipped in CI/test environment",
         autoFixable: false
       };
     }
@@ -17600,6 +17689,12 @@ import { constants as constants2, access as access2, mkdir as mkdir3, readFile a
 import { arch, homedir as homedir3, platform as platform3 } from "node:os";
 import { join as join6, normalize as normalize3 } from "node:path";
 var IS_WINDOWS = platform3() === "win32";
+function shouldSkipExpensiveOperations5() {
+  if (process.env.CK_TEST_HOME) {
+    return false;
+  }
+  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+}
 
 class PlatformChecker {
   group = "platform";
@@ -17698,6 +17793,18 @@ class PlatformChecker {
   }
   async checkGlobalDirAccess() {
     const globalDir = PathResolver.getGlobalKitDir();
+    if (shouldSkipExpensiveOperations5()) {
+      return {
+        id: "global-dir-access",
+        name: "Global Dir Access",
+        group: "platform",
+        priority: "critical",
+        status: "info",
+        message: "Skipped in CI/test environment",
+        details: globalDir,
+        autoFixable: false
+      };
+    }
     const testFile = join6(globalDir, ".ck-doctor-access-test");
     try {
       await mkdir3(globalDir, { recursive: true });
@@ -17771,6 +17878,17 @@ class PlatformChecker {
     };
   }
   async checkLongPathSupport() {
+    if (shouldSkipExpensiveOperations5()) {
+      return {
+        id: "long-path-support",
+        name: "Long Path Support",
+        group: "platform",
+        priority: "extended",
+        status: "info",
+        message: "Skipped in CI/test environment",
+        autoFixable: false
+      };
+    }
     try {
       const { execSync: execSync3 } = await import("node:child_process");
       const result = execSync3('reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" /v LongPathsEnabled', { encoding: "utf-8", timeout: 2000 });
@@ -17798,6 +17916,17 @@ class PlatformChecker {
     }
   }
   async checkSymlinkSupport() {
+    if (shouldSkipExpensiveOperations5()) {
+      return {
+        id: "symlink-support",
+        name: "Symlink Support",
+        group: "platform",
+        priority: "extended",
+        status: "info",
+        message: "Skipped in CI/test environment",
+        autoFixable: false
+      };
+    }
     const testDir = PathResolver.getGlobalKitDir();
     const target = join6(testDir, ".ck-symlink-test-target");
     const link = join6(testDir, ".ck-symlink-test-link");
@@ -27557,30 +27686,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) {
@@ -32972,12 +33146,21 @@ async function initCommand(options) {
       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;
+      const existingConfig = checkExistingGeminiConfig2(resolvedDir, validOptions.global);
+      const mcpConfigPath = findMcpConfigPath2(resolvedDir);
+      const mcpConfigExists = mcpConfigPath !== null;
       if (geminiInstalled && !existingConfig.exists && mcpConfigExists) {
-        const shouldSetupGemini = await prompts.confirm("Gemini CLI detected. Set up MCP integration? (creates .gemini/settings.json symlink)");
+        const geminiPath = validOptions.global ? "~/.gemini/settings.json" : ".gemini/settings.json";
+        const mcpPath = validOptions.global ? "~/.claude/.mcp.json" : ".mcp.json";
+        const promptMessage = [
+          "Gemini CLI detected. Set up MCP integration?",
+          `  → Creates ${geminiPath} symlink to ${mcpPath}`,
+          "  → Gemini CLI will share MCP servers with Claude Code"
+        ].join(`
+`);
+        const shouldSetupGemini = await prompts.confirm(promptMessage);
         if (shouldSetupGemini) {
-          await processGeminiMcpLinking2(resolvedDir);
+          await processGeminiMcpLinking2(resolvedDir, { isGlobal: validOptions.global });
         }
       }
     }
@@ -33648,7 +33831,7 @@ var import_compare_versions2 = __toESM(require_umd(), 1);
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.10.0",
+  version: "3.10.2",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {

package/package.json

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