claudekit-cli 3.37.0-dev.3 → 3.37.0-dev.4

package/dist/index.js

@@ -49851,17 +49851,22 @@ var init_config_discovery = __esm(() => {
 // src/commands/portable/hooks-settings-merger.ts
 import { existsSync as existsSync22, mkdirSync, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { basename as basename8, dirname as dirname9, join as join32 } from "node:path";
-async function readHooksFromSettings(settingsPath) {
+async function inspectHooksSettings(settingsPath) {
   try {
-    if (!existsSync22(settingsPath))
-      return null;
+    if (!existsSync22(settingsPath)) {
+      return { status: "missing-file" };
+    }
     const raw = await Bun.file(settingsPath).text();
     const parsed = JSON.parse(raw);
-    if (!parsed.hooks || typeof parsed.hooks !== "object")
-      return null;
-    return parsed.hooks;
-  } catch {
-    return null;
+    if (!parsed.hooks || typeof parsed.hooks !== "object") {
+      return { status: "missing-hooks" };
+    }
+    return { status: "ok", hooks: parsed.hooks };
+  } catch (error) {
+    return {
+      status: "invalid-json",
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
 }
 function rewriteHookPaths(hooks, sourceHooksDir, targetHooksDir) {
@@ -49980,33 +49985,99 @@ function deduplicateMerge(existing, incoming) {
 async function migrateHooksSettings(options2) {
   const { sourceProvider, targetProvider, installedHookFiles, global: isGlobal } = options2;
   if (installedHookFiles.length === 0) {
-    return { success: true, backupPath: null, hooksRegistered: 0 };
+    return {
+      status: "no-installed-files",
+      success: true,
+      backupPath: null,
+      hooksRegistered: 0,
+      sourceSettingsPath: null,
+      targetSettingsPath: null
+    };
   }
   const sourceConfig = providers[sourceProvider];
   const targetConfig = providers[targetProvider];
   if (!sourceConfig.settingsJsonPath) {
     return {
+      status: "unsupported-source",
       success: true,
       backupPath: null,
       hooksRegistered: 0,
-      message: `Hook settings migration from ${sourceProvider} not supported (no hooks configuration)`
+      message: `Hook settings migration from ${sourceProvider} not supported (no hooks configuration)`,
+      sourceSettingsPath: null,
+      targetSettingsPath: null
     };
   }
   const sourceSettingsPath = isGlobal ? sourceConfig.settingsJsonPath?.globalPath : sourceConfig.settingsJsonPath?.projectPath;
   const targetSettingsPath = isGlobal ? targetConfig.settingsJsonPath?.globalPath : targetConfig.settingsJsonPath?.projectPath;
-  if (!sourceSettingsPath || !targetSettingsPath) {
+  if (!sourceSettingsPath) {
     return {
+      status: "unsupported-source",
+      success: true,
+      backupPath: null,
+      hooksRegistered: 0,
+      message: `Hook settings migration from ${sourceProvider} not supported for ${isGlobal ? "global" : "project"} scope`,
+      sourceSettingsPath: null,
+      targetSettingsPath: targetSettingsPath ?? null
+    };
+  }
+  if (!targetSettingsPath) {
+    return {
+      status: "unsupported-target",
       success: false,
       backupPath: null,
       hooksRegistered: 0,
-      error: `Provider ${!sourceSettingsPath ? sourceProvider : targetProvider} does not support hooks settings.json`
+      error: `Provider ${targetProvider} does not support hook registration for ${isGlobal ? "global" : "project"} scope`,
+      sourceSettingsPath,
+      targetSettingsPath: null
     };
   }
   const resolvedSourcePath = isGlobal ? sourceSettingsPath : join32(process.cwd(), sourceSettingsPath);
   const resolvedTargetPath = isGlobal ? targetSettingsPath : join32(process.cwd(), targetSettingsPath);
-  const sourceHooks = await readHooksFromSettings(resolvedSourcePath);
+  const sourceHooksResult = await inspectHooksSettings(resolvedSourcePath);
+  if (sourceHooksResult.status === "missing-file") {
+    return {
+      status: "source-settings-missing",
+      success: true,
+      backupPath: null,
+      hooksRegistered: 0,
+      message: `Hook files were copied, but source hook registrations were not found at ${resolvedSourcePath}; ${resolvedTargetPath} was not updated.`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
+  }
+  if (sourceHooksResult.status === "missing-hooks") {
+    return {
+      status: "source-hooks-missing",
+      success: true,
+      backupPath: null,
+      hooksRegistered: 0,
+      message: `Hook files were copied, but ${resolvedSourcePath} does not define a hooks section; ${resolvedTargetPath} was not updated.`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
+  }
+  if (sourceHooksResult.status === "invalid-json") {
+    return {
+      status: "source-settings-invalid",
+      success: false,
+      backupPath: null,
+      hooksRegistered: 0,
+      error: `Hook files were copied, but source hook registrations could not be read from ${resolvedSourcePath}: ${sourceHooksResult.error || "invalid JSON"}. ${resolvedTargetPath} was not updated.`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
+  }
+  const sourceHooks = sourceHooksResult.hooks;
   if (!sourceHooks) {
-    return { success: true, backupPath: null, hooksRegistered: 0 };
+    return {
+      status: "source-settings-invalid",
+      success: false,
+      backupPath: null,
+      hooksRegistered: 0,
+      error: `Hook files were copied, but source hook registrations could not be read from ${resolvedSourcePath}. ${resolvedTargetPath} was not updated.`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
   }
   const sourceHooksDir = isGlobal ? sourceConfig.hooks?.globalPath ?? "" : sourceConfig.hooks?.projectPath ?? "";
   const targetHooksDir = isGlobal ? targetConfig.hooks?.globalPath ?? "" : targetConfig.hooks?.projectPath ?? "";
@@ -50019,17 +50090,35 @@ async function migrateHooksSettings(options2) {
     }
   }
   if (hooksRegistered === 0) {
-    return { success: true, backupPath: null, hooksRegistered: 0 };
+    return {
+      status: "no-matching-hooks",
+      success: true,
+      backupPath: null,
+      hooksRegistered: 0,
+      message: `Hook files were copied, but none of the installed hooks matched registrations from ${resolvedSourcePath}; ${resolvedTargetPath} was not updated.`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
   }
   try {
     const { backupPath } = await mergeHooksIntoSettings(resolvedTargetPath, rewritten);
-    return { success: true, backupPath, hooksRegistered };
+    return {
+      status: "registered",
+      success: true,
+      backupPath,
+      hooksRegistered,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
+    };
   } catch (err) {
     return {
+      status: "merge-failed",
       success: false,
       backupPath: null,
       hooksRegistered: 0,
-      error: `Failed to merge hooks into settings.json: ${err instanceof Error ? err.message : String(err)}`
+      error: `Failed to merge hook registrations into ${resolvedTargetPath}: ${err instanceof Error ? err.message : String(err)}`,
+      sourceSettingsPath: resolvedSourcePath,
+      targetSettingsPath: resolvedTargetPath
     };
   }
 }
@@ -52977,6 +53066,46 @@ function tagResults(results, portableType, itemName) {
     }
   }
 }
+function isHookRegistrationFailure(status) {
+  return status === "source-settings-invalid" || status === "unsupported-target" || status === "merge-failed";
+}
+function createHookRegistrationFeedbackResult(provider, mergeResult) {
+  if (mergeResult.status === "registered" || mergeResult.status === "no-installed-files") {
+    return null;
+  }
+  const message = mergeResult.error || mergeResult.message;
+  if (!message)
+    return null;
+  const failed = isHookRegistrationFailure(mergeResult.status);
+  return {
+    provider,
+    providerDisplayName: providers[provider]?.displayName || provider,
+    success: !failed,
+    skipped: !failed,
+    path: mergeResult.targetSettingsPath ?? "",
+    error: failed ? message : undefined,
+    skipReason: failed ? undefined : message,
+    portableType: "hooks",
+    itemName: "hook registration"
+  };
+}
+function recordHookRegistrationOutcome(provider, mergeResult, warnings, feedbackResults) {
+  if (mergeResult.success && mergeResult.hooksRegistered > 0) {
+    console.info(`[migrate] Registered ${mergeResult.hooksRegistered} hook(s) in ${provider} settings.json`);
+    return;
+  }
+  const message = mergeResult.error || mergeResult.message;
+  if (message && !warnings.includes(message)) {
+    warnings.push(message);
+  }
+  if (message) {
+    console.warn(`[migrate] ${message}`);
+  }
+  const feedback = createHookRegistrationFeedbackResult(provider, mergeResult);
+  if (feedback) {
+    feedbackResults.push(feedback);
+  }
+}
 async function discoverMigrationItems(include, configSource) {
   const agentsSource = include.agents ? getAgentSourcePath() : null;
   const commandsSource = include.commands ? getCommandSourcePath() : null;
@@ -53356,7 +53485,9 @@ function registerMigrationRoutes(app) {
         const ruleByName = new Map(discovered2.ruleItems.map((item) => [item.name, item]));
         const hookByName = new Map(discovered2.hookItems.map((item) => [item.name, item]));
         const allResults = [];
-        const successfulHookFiles = new Map;
+        const warnings2 = [];
+        const hookRegistrationResults2 = [];
+        const successfulHookFiles2 = new Map;
         for (const action of execActions) {
           const provider = action.provider;
           const installOpts = { global: action.global };
@@ -53420,16 +53551,16 @@ function registerMigrationRoutes(app) {
             tagResults(batch, "hooks", action.item);
             allResults.push(...batch);
             for (const r2 of batch.filter((r3) => r3.success && !r3.skipped)) {
-              const entry = successfulHookFiles.get(provider) ?? {
+              const entry = successfulHookFiles2.get(provider) ?? {
                 files: [],
                 global: action.global
               };
               entry.files.push(basename9(r2.path));
-              successfulHookFiles.set(provider, entry);
+              successfulHookFiles2.set(provider, entry);
             }
           }
         }
-        for (const [hooksProvider, entry] of successfulHookFiles) {
+        for (const [hooksProvider, entry] of successfulHookFiles2) {
           if (entry.files.length === 0)
             continue;
           const mergeResult = await migrateHooksSettings({
@@ -53438,11 +53569,7 @@ function registerMigrationRoutes(app) {
             installedHookFiles: entry.files,
             global: entry.global
           });
-          if (mergeResult.success && mergeResult.hooksRegistered > 0) {
-            console.info(`[migrate] Registered ${mergeResult.hooksRegistered} hook(s) in ${hooksProvider} settings.json`);
-          } else if (!mergeResult.success) {
-            console.warn(`[migrate] Failed to register hooks in ${hooksProvider} settings.json: ${mergeResult.error}`);
-          }
+          recordHookRegistrationOutcome(hooksProvider, mergeResult, warnings2, hookRegistrationResults2);
         }
         const allPlanProviders = getProvidersFromPlan(plan);
         const plannedSkillActions = execActions.filter((a3) => a3.type === "skill").length;
@@ -53499,7 +53626,8 @@ function registerMigrationRoutes(app) {
             await updateAppliedManifestVersion(manifest.cliVersion);
           }
         } catch {}
-        const sortedResults2 = sortPortableInstallResults(allResults);
+        const responseResults2 = [...allResults, ...hookRegistrationResults2];
+        const sortedResults2 = sortPortableInstallResults(responseResults2);
         const counts2 = toExecutionCounts(sortedResults2);
         const planScopes = [
           ...new Set(plan.actions.map((a3) => a3.global).filter((s) => s !== undefined))
@@ -53508,9 +53636,9 @@ function registerMigrationRoutes(app) {
         annotateResultsWithCollisions(sortedResults2, providerCollisions2);
         res.status(200).json({
           results: sortedResults2,
-          warnings: [],
+          warnings: warnings2,
           counts: counts2,
-          discovery: toDiscoveryCounts(sortedResults2),
+          discovery: toDiscoveryCounts(allResults),
           providerCollisions: providerCollisions2
         });
         return;
@@ -53568,6 +53696,8 @@ function registerMigrationRoutes(app) {
       }
       const installOptions = { global: effectiveGlobal };
       const results = [];
+      const hookRegistrationResults = [];
+      const successfulHookFiles = new Map;
       const unsupportedByType = {
         agents: include.agents ? selectedProviders.filter((provider) => !getProvidersSupporting("agents").includes(provider)) : [],
         commands: include.commands ? selectedProviders.filter((provider) => !getProvidersSupporting("commands").includes(provider)) : [],
@@ -53642,6 +53772,11 @@ function registerMigrationRoutes(app) {
           const batches = await Promise.all(discovered.hookItems.map(async (hook) => {
             const batch = await installPortableItems([hook], providersForType, "hooks", installOptions);
             tagResults(batch, "hooks", hook.name);
+            for (const result of batch.filter((entry) => entry.success && !entry.skipped)) {
+              const existing = successfulHookFiles.get(result.provider) ?? [];
+              existing.push(basename9(result.path));
+              successfulHookFiles.set(result.provider, existing);
+            }
             return batch;
           }));
           for (const batch of batches) {
@@ -53649,7 +53784,19 @@ function registerMigrationRoutes(app) {
           }
         }
       }
-      const sortedResults = sortPortableInstallResults(results);
+      for (const [provider, files] of successfulHookFiles) {
+        if (files.length === 0)
+          continue;
+        const mergeResult = await migrateHooksSettings({
+          sourceProvider: "claude-code",
+          targetProvider: provider,
+          installedHookFiles: files,
+          global: effectiveGlobal
+        });
+        recordHookRegistrationOutcome(provider, mergeResult, warnings, hookRegistrationResults);
+      }
+      const responseResults = [...results, ...hookRegistrationResults];
+      const sortedResults = sortPortableInstallResults(responseResults);
       const counts = toExecutionCounts(sortedResults);
       const providerCollisions = detectProviderPathCollisions(selectedProviders, installOptions);
       annotateResultsWithCollisions(sortedResults, providerCollisions);
@@ -53658,7 +53805,7 @@ function registerMigrationRoutes(app) {
         warnings,
         effectiveGlobal,
         counts,
-        discovery: toDiscoveryCounts(sortedResults),
+        discovery: toDiscoveryCounts(results),
         unsupportedByType,
         providerCollisions
       });
@@ -56844,7 +56991,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.37.0-dev.3",
+    version: "3.37.0-dev.4",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -98382,8 +98529,11 @@ async function migrateCommand(options2) {
       });
       if (mergeResult.success && mergeResult.hooksRegistered > 0) {
         logger.verbose(`Registered ${mergeResult.hooksRegistered} hook(s) in ${hooksProvider} settings.json`);
-      } else if (!mergeResult.success) {
-        f2.warn(`Failed to register hooks in ${hooksProvider} settings.json: ${mergeResult.error}`);
+      } else {
+        const feedbackMessage = mergeResult.error ?? mergeResult.message;
+        if (feedbackMessage) {
+          f2.warn(feedbackMessage);
+        }
       }
     }
     const plannedSkillActions = plannedExecActions.filter((action) => action.type === "skill").length;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.37.0-dev.3",
+	"version": "3.37.0-dev.4",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {