Pretty-print JSON files in apply-patchset to preserve formatting

Since read-files minifies JSON before sending to the remote workflow,
the patchset content comes back without formatting. This restores
readable indentation when writing JSON files back to disk.

For modify actions, the existing file's indentation style (tabs vs
spaces, indent width) is detected and preserved. For create actions,
a default of 2-space indentation is used. Falls back to raw content
if JSON parsing fails.

Author: MathurAditya724

src/lib/init/local-ops.ts

@@ -37,6 +37,61 @@ import type {
   WizardOptions,
 } from "./types.js";
 
+/** Whitespace characters used for JSON indentation. */
+const Indenter = {
+  SPACE: " ",
+  TAB: "\t",
+} as const;
+
+/** Describes the indentation style of a JSON file. */
+type JsonIndent = {
+  /** The whitespace character used for indentation. */
+  replacer: (typeof Indenter)[keyof typeof Indenter];
+  /** How many times the replacer is repeated per indent level. */
+  length: number;
+};
+
+const DEFAULT_JSON_INDENT: JsonIndent = {
+  replacer: Indenter.SPACE,
+  length: 2,
+};
+
+/** Matches the first indented line in a string to detect whitespace style. */
+const INDENT_PATTERN = /^(\s+)/m;
+
+/**
+ * Detect the indentation style of a JSON string by inspecting the first
+ * indented line. Returns a default of 2 spaces if no indentation is found.
+ */
+function detectJsonIndent(content: string): JsonIndent {
+  const match = content.match(INDENT_PATTERN);
+  if (!match?.[1]) {
+    return DEFAULT_JSON_INDENT;
+  }
+  const indent = match[1];
+  if (indent.includes("\t")) {
+    return { replacer: Indenter.TAB, length: indent.length };
+  }
+  return { replacer: Indenter.SPACE, length: indent.length };
+}
+
+/** Build the third argument for `JSON.stringify` from a `JsonIndent`. */
+function jsonIndentArg(indent: JsonIndent): string {
+  return indent.replacer.repeat(indent.length);
+}
+
+/**
+ * Pretty-print a JSON string using the given indentation style.
+ * Returns the original string if it cannot be parsed as valid JSON.
+ */
+function prettyPrintJson(content: string, indent: JsonIndent): string {
+  try {
+    return `${JSON.stringify(JSON.parse(content), null, jsonIndentArg(indent))}\n`;
+  } catch {
+    return content;
+  }
+}
+
 /**
  * Shell metacharacters that enable chaining, piping, substitution, or redirection.
  * All legitimate install commands are simple single commands that don't need these.
@@ -511,6 +566,28 @@ function applyPatchsetDryRun(payload: ApplyPatchsetPayload): LocalOpResult {
   return { ok: true, data: { applied } };
 }
 
+/**
+ * Resolve the final file content for a patch, pretty-printing JSON files
+ * to preserve readable formatting. For `modify` actions, the existing file's
+ * indentation style is detected and preserved. For `create` actions, a default
+ * of 2-space indentation is used.
+ */
+function resolvePatchContent(
+  absPath: string,
+  filePath: string,
+  rawContent: string,
+  action: string
+): string {
+  if (!filePath.endsWith(".json")) {
+    return rawContent;
+  }
+  if (action === "modify") {
+    const existing = fs.readFileSync(absPath, "utf-8");
+    return prettyPrintJson(rawContent, detectJsonIndent(existing));
+  }
+  return prettyPrintJson(rawContent, DEFAULT_JSON_INDENT);
+}
+
 function applyPatchset(
   payload: ApplyPatchsetPayload,
   dryRun?: boolean
@@ -542,7 +619,13 @@ function applyPatchset(
       case "create": {
         const dir = path.dirname(absPath);
         fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(absPath, patch.patch, "utf-8");
+        const content = resolvePatchContent(
+          absPath,
+          patch.path,
+          patch.patch,
+          patch.action
+        );
+        fs.writeFileSync(absPath, content, "utf-8");
         applied.push({ path: patch.path, action: "create" });
         break;
       }
@@ -554,7 +637,13 @@ function applyPatchset(
             data: { applied },
           };
         }
-        fs.writeFileSync(absPath, patch.patch, "utf-8");
+        const content = resolvePatchContent(
+          absPath,
+          patch.path,
+          patch.patch,
+          patch.action
+        );
+        fs.writeFileSync(absPath, content, "utf-8");
         applied.push({ path: patch.path, action: "modify" });
         break;
       }