refactor(cli): collapse 5 install-X-hook functions behind one strategy

install-git-hook-config-managers.ts had five near-identical functions
(installSimpleGitHooks, installGhooks, installPreCommitNpm,
installPrettyQuick, installPackageJsonPreCommitString) that each:

  1. Read package.json
  2. Walked to or created a specific nested config object
  3. Appended the react-doctor command to a leaf value (newline-joined
     string OR array of strings)
  4. Wrote the file back

The differences were the path ("simple-git-hooks" vs "config.ghooks"
vs "pre-commit" vs "gitHooks"...) and the leaf shape (string vs
array). 100+ lines of copy-pasted boilerplate per manager.

Collapse to one installPackageJsonHook(options, { kind, path,
leafShape }) strategy. Each manager becomes a 5-line config:

  export const installSimpleGitHooks = (options) =>
    installPackageJsonHook(options, {
      kind: GitHookKind.SimpleGitHooks,
      path: ["simple-git-hooks", "pre-commit"],
      leafShape: "string",
    });

Yorkie + GitHooksJs were previously special-cased in
install-git-hook.ts because they reused
installPackageJsonPreCommitString as a parameterized helper. They
now get their own one-liner entry points, which makes the dispatch
table flat (every kind -> its own installer) and removes the
generic helper.

Lefthook / pre-commit / overcommit stay separate because they
write text/YAML files, not JSON.

Co-authored-by: Aiden Bai <aidenybai@users.noreply.github.com>

Author: cursoragent

packages/react-doctor/src/cli/utils/install-git-hook-config-managers.ts

@@ -16,30 +16,6 @@ import {
 } from "./git-hook-types.js";
 import { removeLegacyManagedRunner } from "./install-git-hook-file.js";
 
-export const installSimpleGitHooks = (options: InstallGitHookOptions): InstallGitHookResult => {
-  const packageJsonPath = getPackageJsonPath(options.projectRoot);
-  const didHookExist = existsSync(packageJsonPath);
-  const packageJson = readPackageJson(options.projectRoot);
-  const nextPackageJson = isRecord(packageJson) ? { ...packageJson } : {};
-  const existingConfig = nextPackageJson["simple-git-hooks"];
-  const nextConfig = isRecord(existingConfig) ? { ...existingConfig } : {};
-  const existingPreCommit =
-    typeof nextConfig["pre-commit"] === "string" ? nextConfig["pre-commit"] : "";
-  const nextPreCommit = existingPreCommit.includes(REACT_DOCTOR_COMMAND)
-    ? existingPreCommit
-    : [existingPreCommit, NON_BLOCKING_REACT_DOCTOR_COMMAND].filter(Boolean).join("\n");
-  nextConfig["pre-commit"] = nextPreCommit;
-  nextPackageJson["simple-git-hooks"] = nextConfig;
-  writeJsonFile(packageJsonPath, nextPackageJson);
-  removeLegacyManagedRunner(options.projectRoot);
-
-  return {
-    hookPath: packageJsonPath,
-    kind: GitHookKind.SimpleGitHooks,
-    status: didHookExist ? "updated" : "created",
-  };
-};
-
 const appendStringCommand = (existingCommand: unknown): string => {
   const existingCommandText =
     typeof existingCommand === "string"
@@ -63,66 +39,102 @@ const appendArrayCommand = (existingCommands: unknown): string[] => {
     : [...commands, NON_BLOCKING_REACT_DOCTOR_COMMAND];
 };
 
-export const installPackageJsonPreCommitString = (
+interface PackageJsonHookStrategy {
+  readonly kind: GitHookKind;
+  /**
+   * Dotted path of keys into `package.json` to reach the leaf where
+   * the pre-commit command lives. `["simple-git-hooks", "pre-commit"]`
+   * walks `package.json["simple-git-hooks"]["pre-commit"]`. Intermediate
+   * objects are created when missing; non-record intermediates are
+   * replaced with a fresh empty object.
+   */
+  readonly path: ReadonlyArray<string>;
+  /**
+   * Shape of the leaf value the manager expects. `"string"` joins
+   * commands with newlines (the shape simple-git-hooks / ghooks /
+   * yorkie / pretty-quick / git-hooks-js use); `"array"` keeps each
+   * command as a separate string element (the shape pre-commit-npm
+   * uses).
+   */
+  readonly leafShape: "string" | "array";
+}
+
+const installPackageJsonHook = (
   options: InstallGitHookOptions,
-  kind: GitHookKind,
-  configKey: string,
+  strategy: PackageJsonHookStrategy,
 ): InstallGitHookResult => {
   const packageJsonPath = getPackageJsonPath(options.projectRoot);
   const didHookExist = existsSync(packageJsonPath);
   const packageJson = readPackageJson(options.projectRoot);
   const nextPackageJson = isRecord(packageJson) ? { ...packageJson } : {};
-  const existingConfig = nextPackageJson[configKey];
-  const nextConfig = isRecord(existingConfig) ? { ...existingConfig } : {};
-  nextConfig["pre-commit"] = appendStringCommand(nextConfig["pre-commit"]);
-  nextPackageJson[configKey] = nextConfig;
+
+  // Walk down to the parent of the leaf, cloning each intermediate
+  // record so the original package.json shape isn't mutated in place
+  // (writeJsonFile re-serializes the new tree).
+  const parentKeys = strategy.path.slice(0, -1);
+  const leafKey = strategy.path[strategy.path.length - 1];
+  let parent: Record<string, unknown> = nextPackageJson;
+  for (const key of parentKeys) {
+    const existing = parent[key];
+    const cloned = isRecord(existing) ? { ...existing } : {};
+    parent[key] = cloned;
+    parent = cloned;
+  }
+  parent[leafKey] =
+    strategy.leafShape === "array"
+      ? appendArrayCommand(parent[leafKey])
+      : appendStringCommand(parent[leafKey]);
+
   writeJsonFile(packageJsonPath, nextPackageJson);
   removeLegacyManagedRunner(options.projectRoot);
   return {
     hookPath: packageJsonPath,
-    kind,
+    kind: strategy.kind,
     status: didHookExist ? "updated" : "created",
   };
 };
 
-export const installGhooks = (options: InstallGitHookOptions): InstallGitHookResult => {
-  const packageJsonPath = getPackageJsonPath(options.projectRoot);
-  const didHookExist = existsSync(packageJsonPath);
-  const packageJson = readPackageJson(options.projectRoot);
-  const nextPackageJson = isRecord(packageJson) ? { ...packageJson } : {};
-  const existingConfig = nextPackageJson.config;
-  const nextConfig = isRecord(existingConfig) ? { ...existingConfig } : {};
-  const existingGhooks = nextConfig.ghooks;
-  const nextGhooks = isRecord(existingGhooks) ? { ...existingGhooks } : {};
-  nextGhooks["pre-commit"] = appendStringCommand(nextGhooks["pre-commit"]);
-  nextConfig.ghooks = nextGhooks;
-  nextPackageJson.config = nextConfig;
-  writeJsonFile(packageJsonPath, nextPackageJson);
-  removeLegacyManagedRunner(options.projectRoot);
-  return {
-    hookPath: packageJsonPath,
+export const installSimpleGitHooks = (options: InstallGitHookOptions): InstallGitHookResult =>
+  installPackageJsonHook(options, {
+    kind: GitHookKind.SimpleGitHooks,
+    path: ["simple-git-hooks", "pre-commit"],
+    leafShape: "string",
+  });
+
+export const installGhooks = (options: InstallGitHookOptions): InstallGitHookResult =>
+  installPackageJsonHook(options, {
     kind: GitHookKind.Ghooks,
-    status: didHookExist ? "updated" : "created",
-  };
-};
+    path: ["config", "ghooks", "pre-commit"],
+    leafShape: "string",
+  });
 
-export const installPreCommitNpm = (options: InstallGitHookOptions): InstallGitHookResult => {
-  const packageJsonPath = getPackageJsonPath(options.projectRoot);
-  const didHookExist = existsSync(packageJsonPath);
-  const packageJson = readPackageJson(options.projectRoot);
-  const nextPackageJson = isRecord(packageJson) ? { ...packageJson } : {};
-  nextPackageJson["pre-commit"] = appendArrayCommand(nextPackageJson["pre-commit"]);
-  writeJsonFile(packageJsonPath, nextPackageJson);
-  removeLegacyManagedRunner(options.projectRoot);
-  return {
-    hookPath: packageJsonPath,
+export const installPreCommitNpm = (options: InstallGitHookOptions): InstallGitHookResult =>
+  installPackageJsonHook(options, {
     kind: GitHookKind.PreCommitNpm,
-    status: didHookExist ? "updated" : "created",
-  };
-};
+    path: ["pre-commit"],
+    leafShape: "array",
+  });
 
 export const installPrettyQuick = (options: InstallGitHookOptions): InstallGitHookResult =>
-  installPackageJsonPreCommitString(options, GitHookKind.PrettyQuick, "gitHooks");
+  installPackageJsonHook(options, {
+    kind: GitHookKind.PrettyQuick,
+    path: ["gitHooks", "pre-commit"],
+    leafShape: "string",
+  });
+
+export const installYorkie = (options: InstallGitHookOptions): InstallGitHookResult =>
+  installPackageJsonHook(options, {
+    kind: GitHookKind.Yorkie,
+    path: ["gitHooks", "pre-commit"],
+    leafShape: "string",
+  });
+
+export const installGitHooksJs = (options: InstallGitHookOptions): InstallGitHookResult =>
+  installPackageJsonHook(options, {
+    kind: GitHookKind.GitHooksJs,
+    path: ["git-hooks", "pre-commit"],
+    leafShape: "string",
+  });
 
 const appendIndentedBlockToTopLevelSection = (
   content: string,

packages/react-doctor/src/cli/utils/install-git-hook.ts

@@ -27,13 +27,14 @@ import {
 } from "./git-hook-types.js";
 import {
   installGhooks,
+  installGitHooksJs,
   installLefthook,
   installOvercommit,
-  installPackageJsonPreCommitString,
   installPreCommit,
   installPreCommitNpm,
   installPrettyQuick,
   installSimpleGitHooks,
+  installYorkie,
 } from "./install-git-hook-config-managers.js";
 import { installDirectGitHook } from "./install-git-hook-file.js";
 
@@ -213,11 +214,9 @@ export const installReactDoctorGitHook = (options: InstallGitHookOptions): Insta
   if (options.kind === GitHookKind.Lefthook) return installLefthook(options);
   if (options.kind === GitHookKind.PreCommit) return installPreCommit(options);
   if (options.kind === GitHookKind.Overcommit) return installOvercommit(options);
-  if (options.kind === GitHookKind.Yorkie)
-    return installPackageJsonPreCommitString(options, GitHookKind.Yorkie, "gitHooks");
+  if (options.kind === GitHookKind.Yorkie) return installYorkie(options);
   if (options.kind === GitHookKind.Ghooks) return installGhooks(options);
-  if (options.kind === GitHookKind.GitHooksJs)
-    return installPackageJsonPreCommitString(options, GitHookKind.GitHooksJs, "git-hooks");
+  if (options.kind === GitHookKind.GitHooksJs) return installGitHooksJs(options);
   if (options.kind === GitHookKind.PreCommitNpm) return installPreCommitNpm(options);
   if (options.kind === GitHookKind.PrettyQuick) return installPrettyQuick(options);
   return installDirectGitHook(options);