claudekit-cli 3.3.1 → 3.4.0

package/dist/index.js

@@ -13078,7 +13078,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.3.1",
+  version: "3.4.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -13219,11 +13219,14 @@ var HealingSummarySchema = exports_external.object({
   fixes: exports_external.array(FixAttemptSchema)
 });
 // src/lib/health-checks/check-runner.ts
+init_logger();
+
 class CheckRunner {
   checkers = [];
   options;
   constructor(options = {}) {
     this.options = options;
+    logger.verbose("CheckRunner initialized", { options });
   }
   registerChecker(checker) {
     this.checkers.push(checker);
@@ -13234,8 +13237,13 @@ class CheckRunner {
     }
   }
   async run() {
+    logger.verbose("Starting health check run");
     const filteredCheckers = this.filterCheckersByGroup();
+    logger.verbose(`Running ${filteredCheckers.length} checker(s)`, {
+      groups: filteredCheckers.map((c2) => c2.group)
+    });
     const allResults = await this.executeCheckersInParallel(filteredCheckers);
+    logger.verbose("All checks completed, building summary");
     return this.buildSummary(allResults);
   }
   filterCheckersByGroup() {
@@ -13246,7 +13254,14 @@ class CheckRunner {
     return this.checkers.filter((checker) => allowedGroups.has(checker.group));
   }
   async executeCheckersInParallel(checkers) {
-    const resultsArrays = await Promise.all(checkers.map((checker) => checker.run()));
+    const resultsArrays = await Promise.all(checkers.map(async (checker) => {
+      logger.verbose(`Starting checker: ${checker.group}`);
+      const results = await checker.run();
+      logger.verbose(`Completed checker: ${checker.group}`, {
+        checkCount: results.length
+      });
+      return results;
+    }));
     return resultsArrays.flat();
   }
   buildSummary(checks) {
@@ -13374,9 +13389,12 @@ async function commandExists(command) {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where" : "which";
+    logger.verbose(`Checking if command exists: ${command}`);
     await execAsync(`${whichCmd} ${command}`);
+    logger.verbose(`Command found: ${command}`);
     return true;
   } catch {
+    logger.verbose(`Command not found: ${command}`);
     return false;
   }
 }
@@ -13388,10 +13406,14 @@ async function getCommandPath(command) {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where" : "which";
+    logger.verbose(`Getting path for command: ${command}`);
     const { stdout } = await execAsync(`${whichCmd} ${command}`);
-    return stdout.trim().split(`
+    const path = stdout.trim().split(`
 `)[0] || null;
+    logger.verbose(`Command path resolved: ${command} -> ${path}`);
+    return path;
   } catch {
+    logger.verbose(`Failed to get path for command: ${command}`);
     return null;
   }
 }
@@ -13409,11 +13431,15 @@ async function getCommandVersion(command, versionFlag, versionRegex) {
     return mockVersions[command] || null;
   }
   try {
+    logger.verbose(`Getting version for: ${command} ${versionFlag}`);
     const { stdout, stderr } = await execAsync(`${command} ${versionFlag}`);
     const output = stdout || stderr;
     const match = output.match(versionRegex);
-    return match?.[1] || null;
+    const version = match?.[1] || null;
+    logger.verbose(`Version detected: ${command} -> ${version}`);
+    return version;
   } catch (error) {
+    logger.verbose(`Failed to get version for ${command}: ${error}`);
     logger.debug(`Failed to get version for ${command}: ${error}`);
     return null;
   }
@@ -13432,9 +13458,11 @@ function compareVersions(current, required) {
   return true;
 }
 async function checkDependency(config) {
+  logger.verbose(`Checking dependency: ${config.name}`);
   for (const command of config.commands) {
     const exists = await commandExists(command);
     if (exists) {
+      logger.verbose(`Found ${config.name} via command: ${command}`);
       const path = await getCommandPath(command);
       const version = await getCommandVersion(command, config.versionFlag, config.versionRegex);
       let meetsRequirements = true;
@@ -13465,8 +13493,13 @@ async function checkDependency(config) {
   };
 }
 async function checkAllDependencies() {
+  logger.verbose("Checking all dependencies in parallel");
   const checks = Object.values(DEPENDENCIES).map((config) => checkDependency(config));
-  return Promise.all(checks);
+  const results = await Promise.all(checks);
+  logger.verbose("All dependency checks complete", {
+    count: results.length
+  });
+  return results;
 }
 
 // src/utils/dependency-installer.ts
@@ -13700,18 +13733,27 @@ async function installDependency(dependency, method) {
 }
 
 // src/lib/health-checks/system-checker.ts
+init_logger();
 var execAsync3 = promisify3(exec3);
 
 class SystemChecker {
   group = "system";
   async run() {
+    logger.verbose("SystemChecker: Starting dependency checks");
     const deps = await checkAllDependencies();
+    logger.verbose("SystemChecker: Dependency scan complete", {
+      count: deps.length
+    });
     const results = [];
     for (const dep of deps) {
+      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());
+    logger.verbose("SystemChecker: All system checks complete");
     return results;
   }
   async mapDependencyToCheck(dep) {
@@ -14064,6 +14106,9 @@ async function getClaudeKitSetup(projectDir = process.cwd()) {
   return setup;
 }
 
+// src/lib/health-checks/claudekit-checker.ts
+init_logger();
+
 // src/lib/package-manager-detector.ts
 init_logger();
 import { exec as exec4 } from "node:child_process";
@@ -14079,20 +14124,27 @@ class PackageManagerDetector {
   static CACHE_TTL = 30 * 24 * 60 * 60 * 1000;
   static QUERY_TIMEOUT = 5000;
   static async detect() {
+    logger.verbose("PackageManagerDetector: Starting detection");
     const envPm = PackageManagerDetector.detectFromEnv();
     if (envPm !== "unknown") {
+      logger.verbose(`PackageManagerDetector: Detected from env: ${envPm}`);
       return envPm;
     }
+    logger.verbose("PackageManagerDetector: Checking cache");
     const cachedPm = await PackageManagerDetector.readCachedPm();
     if (cachedPm) {
+      logger.verbose(`PackageManagerDetector: Using cached: ${cachedPm}`);
       logger.debug(`Using cached package manager: ${cachedPm}`);
       return cachedPm;
     }
+    logger.verbose("PackageManagerDetector: Querying package managers");
     const owningPm = await PackageManagerDetector.findOwningPm();
     if (owningPm) {
+      logger.verbose(`PackageManagerDetector: Found owning PM: ${owningPm}`);
       await PackageManagerDetector.saveCachedPm(owningPm);
       return owningPm;
     }
+    logger.verbose("PackageManagerDetector: Defaulting to npm");
     logger.warning("Could not detect package manager that installed claudekit-cli, defaulting to npm");
     return "npm";
   }
@@ -14209,19 +14261,26 @@ class PackageManagerDetector {
         checkFn: (stdout) => stdout.includes("claudekit-cli")
       }
     ];
+    logger.verbose("PackageManagerDetector: Querying all PMs in parallel");
     logger.debug("Querying package managers for claudekit-cli ownership...");
     const results = await Promise.allSettled(queries.map(async ({ pm, cmd, checkFn }) => {
       try {
+        logger.verbose(`PackageManagerDetector: Querying ${pm}`);
         const { stdout } = await execAsync4(cmd, {
           timeout: PackageManagerDetector.QUERY_TIMEOUT
         });
         if (checkFn(stdout)) {
+          logger.verbose(`PackageManagerDetector: Found via ${pm}`);
           logger.debug(`Found claudekit-cli installed via ${pm}`);
           return pm;
         }
-      } catch {}
+        logger.verbose(`PackageManagerDetector: Not found via ${pm}`);
+      } catch {
+        logger.verbose(`PackageManagerDetector: ${pm} query failed or not available`);
+      }
       return null;
     }));
+    logger.verbose("PackageManagerDetector: All PM queries complete");
     for (const result of results) {
       if (result.status === "fulfilled" && result.value) {
         return result.value;
@@ -14304,9 +14363,13 @@ class PackageManagerDetector {
       return null;
     const command = PackageManagerDetector.getVersionCommand(pm);
     try {
+      logger.verbose(`PackageManagerDetector: Getting version for ${pm}`);
       const { stdout } = await execAsync4(command, { timeout: 3000 });
-      return stdout.trim();
+      const version = stdout.trim();
+      logger.verbose(`PackageManagerDetector: ${pm} version: ${version}`);
+      return version;
     } catch {
+      logger.verbose(`PackageManagerDetector: Failed to get ${pm} version`);
       return null;
     }
   }
@@ -14332,15 +14395,27 @@ class ClaudekitChecker {
     this.projectDir = projectDir;
   }
   async run() {
+    logger.verbose("ClaudekitChecker: Scanning ClaudeKit setup", {
+      projectDir: this.projectDir
+    });
     const setup = await getClaudeKitSetup(this.projectDir);
+    logger.verbose("ClaudekitChecker: Setup scan complete");
     const results = [];
+    logger.verbose("ClaudekitChecker: Checking CLI install method");
     results.push(await this.checkCliInstallMethod());
+    logger.verbose("ClaudekitChecker: Checking global install");
     results.push(this.checkGlobalInstall(setup));
+    logger.verbose("ClaudekitChecker: Checking project install");
     results.push(this.checkProjectInstall(setup));
+    logger.verbose("ClaudekitChecker: Checking CLAUDE.md files");
     results.push(...this.checkClaudeMd(setup));
+    logger.verbose("ClaudekitChecker: Checking active plan");
     results.push(this.checkActivePlan());
+    logger.verbose("ClaudekitChecker: Checking skills scripts");
     results.push(...this.checkSkillsScripts(setup));
+    logger.verbose("ClaudekitChecker: Checking component counts");
     results.push(this.checkComponentCounts(setup));
+    logger.verbose("ClaudekitChecker: All checks complete");
     return results;
   }
   async checkCliInstallMethod() {
@@ -14555,6 +14630,7 @@ class ClaudekitChecker {
 }
 // src/lib/health-checks/auth-checker.ts
 init_types2();
+init_logger();
 import { execSync as execSync2 } from "node:child_process";
 
 // src/lib/auth.ts
@@ -15276,21 +15352,28 @@ class AuthChecker {
     this.kits = kits;
   }
   async run() {
+    logger.verbose("AuthChecker: Starting authentication checks");
     const results = [];
+    logger.verbose("AuthChecker: Checking GitHub CLI auth status");
     results.push(await this.checkGhAuth());
+    logger.verbose("AuthChecker: Checking GitHub token");
     results.push(await this.checkGhToken());
     for (const kit of this.kits) {
+      logger.verbose(`AuthChecker: Checking repo access for kit: ${kit}`);
       results.push(await this.checkRepoAccess(kit));
     }
+    logger.verbose("AuthChecker: All auth checks complete");
     return results;
   }
   async checkGhAuth() {
     if (false) {}
     try {
+      logger.verbose("AuthChecker: Running 'gh auth status' command");
       execSync2("gh auth status", {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 5000
       });
+      logger.verbose("AuthChecker: gh auth status succeeded");
       return {
         id: "gh-auth-status",
         name: "GitHub CLI Auth",
@@ -15314,7 +15397,9 @@ class AuthChecker {
   }
   async checkGhToken() {
     try {
+      logger.verbose("AuthChecker: Getting GitHub token via AuthManager");
       const { token } = await AuthManager.getToken();
+      logger.verbose("AuthChecker: Token retrieved successfully");
       const maskedToken = `${token.substring(0, 8)}...`;
       return {
         id: "gh-token",
@@ -15342,6 +15427,7 @@ class AuthChecker {
   async checkRepoAccess(kit) {
     const kitConfig = AVAILABLE_KITS[kit];
     if (isCIEnvironment2) {
+      logger.verbose(`AuthChecker: Skipping repo access check for ${kit} in CI`);
       return {
         id: `repo-access-${kit}`,
         name: `Repository Access (${kit})`,
@@ -15352,8 +15438,10 @@ class AuthChecker {
       };
     }
     try {
+      logger.verbose(`AuthChecker: Checking access to ${kitConfig.owner}/${kitConfig.repo}`);
       const client = new GitHubClient;
       const hasAccess = await client.checkAccess(kitConfig);
+      logger.verbose(`AuthChecker: Repo access check complete for ${kit}`, { hasAccess });
       if (hasAccess) {
         return {
           id: `repo-access-${kit}`,
@@ -32171,7 +32259,7 @@ import { promisify as promisify6 } from "node:util";
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.3.1",
+  version: "3.4.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {

package/package.json

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