@gotgenes/pi-autoformat 0.1.0 → 4.0.3

package/test/formatter-output-report.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import type { FormatterOutputReportingConfig } from "../src/formatter-config.js";
+import type { BatchRun } from "../src/formatter-executor.js";
+import { formatRunOutputBlock } from "../src/formatter-output-report.js";
+
+const ENABLED_STDERR: FormatterOutputReportingConfig = {
+  onFailure: "stderr",
+  maxBytes: 4096,
+  maxLines: 40,
+};
+
+const ENABLED_BOTH: FormatterOutputReportingConfig = {
+  onFailure: "both",
+  maxBytes: 4096,
+  maxLines: 40,
+};
+
+const DISABLED: FormatterOutputReportingConfig = {
+  onFailure: "none",
+  maxBytes: 4096,
+  maxLines: 40,
+};
+
+function failedRun(overrides: Partial<BatchRun> = {}): BatchRun {
+  return {
+    formatterName: "prettier",
+    command: ["prettier", "--write", "src/foo.ts"],
+    files: ["src/foo.ts"],
+    success: false,
+    exitCode: 2,
+    ...overrides,
+  };
+}
+
+describe("formatRunOutputBlock", () => {
+  it("returns undefined when onFailure is none", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stderr: "boom\n" }),
+      DISABLED,
+    );
+    expect(block).toBeUndefined();
+  });
+
+  it("returns undefined for successful runs even when enabled", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ success: true, exitCode: 0, stderr: "noisy success" }),
+      ENABLED_BOTH,
+    );
+    expect(block).toBeUndefined();
+  });
+
+  it("returns undefined when both streams are empty / whitespace", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stdout: "  \n  ", stderr: "" }),
+      ENABLED_BOTH,
+    );
+    expect(block).toBeUndefined();
+  });
+
+  it("returns undefined when stderr-only mode has no stderr", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stdout: "lots of stdout" }),
+      ENABLED_STDERR,
+    );
+    expect(block).toBeUndefined();
+  });
+
+  it("renders only stderr under onFailure: stderr", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stdout: "ignored", stderr: "line one\nline two" }),
+      ENABLED_STDERR,
+    );
+    expect(block).toBe(
+      ["  stderr:", "    line one", "    line two"].join("\n"),
+    );
+  });
+
+  it("renders stdout above stderr under onFailure: both", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stdout: "out one\nout two", stderr: "err one" }),
+      ENABLED_BOTH,
+    );
+    expect(block).toBe(
+      [
+        "  stdout:",
+        "    out one",
+        "    out two",
+        "  stderr:",
+        "    err one",
+      ].join("\n"),
+    );
+  });
+
+  it("omits the stdout block when stdout is empty under onFailure: both", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stdout: "", stderr: "err only" }),
+      ENABLED_BOTH,
+    );
+    expect(block).toBe(["  stderr:", "    err only"].join("\n"));
+  });
+
+  it("strips trailing whitespace before rendering", () => {
+    const block = formatRunOutputBlock(
+      failedRun({ stderr: "useful line\n\n   \n" }),
+      ENABLED_STDERR,
+    );
+    expect(block).toBe(["  stderr:", "    useful line"].join("\n"));
+  });
+
+  it("truncates by line count and reports how many earlier lines were dropped", () => {
+    const stderr = Array.from({ length: 50 }, (_, i) => `line${i + 1}`).join(
+      "\n",
+    );
+    const block = formatRunOutputBlock(failedRun({ stderr }), {
+      onFailure: "stderr",
+      maxBytes: 65536,
+      maxLines: 5,
+    });
+    expect(block).toBeDefined();
+    const lines = (block ?? "").split("\n");
+    expect(lines[0]).toBe("  stderr:");
+    expect(lines[1]).toBe("    ... (truncated, 45 earlier lines)");
+    expect(lines.slice(2)).toEqual([
+      "    line46",
+      "    line47",
+      "    line48",
+      "    line49",
+      "    line50",
+    ]);
+  });
+
+  it("truncates by byte cap and snaps forward to a newline boundary", () => {
+    // 10 lines, each 100 bytes -> ~1000 bytes total; cap at 250 bytes.
+    const stderr = Array.from(
+      { length: 10 },
+      (_, i) => `${String(i).padStart(2, "0")}-${"x".repeat(96)}`,
+    ).join("\n");
+    const block = formatRunOutputBlock(failedRun({ stderr }), {
+      onFailure: "stderr",
+      maxBytes: 250,
+      maxLines: 100,
+    });
+    expect(block).toBeDefined();
+    const lines = (block ?? "").split("\n");
+    expect(lines[0]).toBe("  stderr:");
+    expect(lines[1]).toMatch(/^ {4}\.\.\. \(truncated, \d+ earlier bytes\)$/);
+    // Only the tail lines survive; the first line ("00-…") must be gone.
+    expect(block).not.toContain("00-x");
+    expect(block).toContain("09-x");
+  });
+
+  it("does not bisect a multibyte UTF-8 character at the byte boundary", () => {
+    // Each emoji is 4 bytes in UTF-8. Keep last ~10 bytes after a long prefix.
+    const head = "x".repeat(100);
+    const tail = "🌟🌟🌟"; // 12 bytes
+    const stderr = `${head}\n${tail}`;
+    const block = formatRunOutputBlock(failedRun({ stderr }), {
+      onFailure: "stderr",
+      maxBytes: 14,
+      maxLines: 100,
+    });
+    expect(block).toBeDefined();
+    // Whatever survived must be valid UTF-8 (round-tripping through Buffer
+    // preserves bytes; a bisected sequence would render as U+FFFD).
+    expect(block).not.toContain("\uFFFD");
+    expect(block).toContain("🌟");
+  });
+
+  it("leaves output unchanged when both caps are well above the content size", () => {
+    const stderr = "short and tidy";
+    const block = formatRunOutputBlock(failedRun({ stderr }), {
+      onFailure: "stderr",
+      maxBytes: 10_000,
+      maxLines: 100,
+    });
+    expect(block).toBe(["  stderr:", "    short and tidy"].join("\n"));
+  });
+});

package/test/formatter-registry.test.ts

@@ -2,74 +2,367 @@ import { describe, expect, it } from "vitest";
 
 import {
   type FormatterConfig,
-  resolveFormatterChainForFile,
+  groupFilesByChain,
+  resolveChain,
+  resolveChainSteps,
 } from "../src/formatter-registry.js";
 
-describe("resolveFormatterChainForFile", () => {
+describe("groupFilesByChain", () => {
+  const config: FormatterConfig = {
+    formatters: {
+      prettier: { command: ["prettier", "--write"] },
+      markdownlint: { command: ["markdownlint-cli2", "--fix"] },
+      biome: { command: ["biome", "format", "--write"] },
+    },
+    chains: {
+      ".md": ["prettier", "markdownlint"],
+      ".markdown": ["prettier", "markdownlint"],
+      ".ts": ["prettier"],
+      ".js": ["prettier"],
+      ".rs": ["biome"],
+    },
+  };
+
+  it("groups files that share a chain into one group", () => {
+    const groups = groupFilesByChain(
+      ["/repo/a.md", "/repo/b.md", "/repo/c.md"],
+      config,
+    );
+
+    expect(groups).toEqual([
+      {
+        chain: ["prettier", "markdownlint"],
+        files: ["/repo/a.md", "/repo/b.md", "/repo/c.md"],
+      },
+    ]);
+  });
+
+  it("creates separate groups for distinct chains", () => {
+    const groups = groupFilesByChain(
+      ["/repo/a.md", "/repo/b.ts", "/repo/c.rs"],
+      config,
+    );
+
+    expect(groups).toEqual([
+      { chain: ["prettier", "markdownlint"], files: ["/repo/a.md"] },
+      { chain: ["prettier"], files: ["/repo/b.ts"] },
+      { chain: ["biome"], files: ["/repo/c.rs"] },
+    ]);
+  });
+
+  it("merges different extensions that resolve to the same chain", () => {
+    const groups = groupFilesByChain(
+      ["/repo/a.md", "/repo/b.markdown", "/repo/c.ts", "/repo/d.js"],
+      config,
+    );
+
+    expect(groups).toEqual([
+      {
+        chain: ["prettier", "markdownlint"],
+        files: ["/repo/a.md", "/repo/b.markdown"],
+      },
+      { chain: ["prettier"], files: ["/repo/c.ts", "/repo/d.js"] },
+    ]);
+  });
+
+  it("drops files with no chain", () => {
+    const groups = groupFilesByChain(
+      ["/repo/a.md", "/repo/logo.png", "/repo/notes.txt"],
+      config,
+    );
+
+    expect(groups).toEqual([
+      { chain: ["prettier", "markdownlint"], files: ["/repo/a.md"] },
+    ]);
+  });
+
+  it("preserves first-seen group order and within-group file order", () => {
+    const groups = groupFilesByChain(
+      ["/repo/x.ts", "/repo/a.md", "/repo/y.ts", "/repo/b.md"],
+      config,
+    );
+
+    expect(groups).toEqual([
+      { chain: ["prettier"], files: ["/repo/x.ts", "/repo/y.ts"] },
+      {
+        chain: ["prettier", "markdownlint"],
+        files: ["/repo/a.md", "/repo/b.md"],
+      },
+    ]);
+  });
+
+  it("returns no groups when given no files", () => {
+    expect(groupFilesByChain([], config)).toEqual([]);
+  });
+
+  describe("with a wildcard chain", () => {
+    const wildcardConfig: FormatterConfig = {
+      formatters: {
+        prettier: { command: ["prettier", "--write"] },
+        markdownlint: { command: ["markdownlint-cli2", "--fix"] },
+      },
+      chains: {
+        "*": ["treefmt"],
+        ".md": ["prettier", "markdownlint"],
+        ".ts": ["prettier"],
+      },
+    };
+
+    it("emits the wildcard group first with every touched file", () => {
+      const groups = groupFilesByChain(
+        ["/repo/a.md", "/repo/b.ts", "/repo/Makefile"],
+        wildcardConfig,
+      );
+      expect(groups[0]).toEqual({
+        chain: ["treefmt"],
+        files: ["/repo/a.md", "/repo/b.ts", "/repo/Makefile"],
+      });
+    });
+
+    it("keeps per-extension groups after the wildcard group", () => {
+      const groups = groupFilesByChain(
+        ["/repo/a.md", "/repo/b.ts"],
+        wildcardConfig,
+      );
+      expect(groups).toEqual([
+        {
+          chain: ["treefmt"],
+          files: ["/repo/a.md", "/repo/b.ts"],
+        },
+        {
+          chain: ["prettier", "markdownlint"],
+          files: ["/repo/a.md"],
+        },
+        {
+          chain: ["prettier"],
+          files: ["/repo/b.ts"],
+        },
+      ]);
+    });
+
+    it("includes extensionless files in the wildcard group only", () => {
+      const groups = groupFilesByChain(
+        ["/repo/Makefile", "/repo/notes"],
+        wildcardConfig,
+      );
+      expect(groups).toEqual([
+        {
+          chain: ["treefmt"],
+          files: ["/repo/Makefile", "/repo/notes"],
+        },
+      ]);
+    });
+
+    it('emits no wildcard group when chains["*"] is absent', () => {
+      const groups = groupFilesByChain(["/repo/a.md"], {
+        formatters: wildcardConfig.formatters,
+        chains: {
+          ".md": ["prettier"],
+        },
+      });
+      expect(groups).toEqual([{ chain: ["prettier"], files: ["/repo/a.md"] }]);
+    });
+  });
+
+  describe("with fallback steps", () => {
+    const fallbackConfig: FormatterConfig = {
+      formatters: {
+        biome: { command: ["biome", "format", "--write"] },
+        prettier: { command: ["prettier", "--write"] },
+        "markdownlint-cli2": {
+          command: ["markdownlint-cli2", "--fix"],
+        },
+      },
+      chains: {
+        ".ts": [{ fallback: ["biome", "prettier"] }],
+        ".tsx": [{ fallback: ["biome", "prettier"] }],
+        ".md": [{ fallback: ["biome", "prettier"] }, "markdownlint-cli2"],
+      },
+    };
+
+    it("keeps the original chain step shape in the returned group", () => {
+      const groups = groupFilesByChain(["/repo/a.ts"], fallbackConfig);
+      expect(groups).toEqual([
+        {
+          chain: [{ fallback: ["biome", "prettier"] }],
+          files: ["/repo/a.ts"],
+        },
+      ]);
+    });
+
+    it("groups identical fallback chains across extensions", () => {
+      const groups = groupFilesByChain(
+        ["/repo/a.ts", "/repo/b.tsx"],
+        fallbackConfig,
+      );
+      expect(groups).toEqual([
+        {
+          chain: [{ fallback: ["biome", "prettier"] }],
+          files: ["/repo/a.ts", "/repo/b.tsx"],
+        },
+      ]);
+    });
+
+    it("groups mixed string + fallback chains", () => {
+      const groups = groupFilesByChain(
+        ["/repo/a.ts", "/repo/b.md", "/repo/c.md"],
+        fallbackConfig,
+      );
+      expect(groups).toHaveLength(2);
+      const md = groups.find((g) => g.files.includes("/repo/b.md"));
+      expect(md?.chain).toEqual([
+        { fallback: ["biome", "prettier"] },
+        "markdownlint-cli2",
+      ]);
+      expect(md?.files).toEqual(["/repo/b.md", "/repo/c.md"]);
+    });
+
+    it("separates groups whose fallback ordering differs", () => {
+      const reorderedConfig: FormatterConfig = {
+        formatters: fallbackConfig.formatters,
+        chains: {
+          ".ts": [{ fallback: ["biome", "prettier"] }],
+          ".js": [{ fallback: ["prettier", "biome"] }],
+        },
+      };
+      const groups = groupFilesByChain(
+        ["/repo/a.ts", "/repo/b.js"],
+        reorderedConfig,
+      );
+      expect(groups).toHaveLength(2);
+    });
+  });
+});
+
+describe("resolveChain", () => {
   const config: FormatterConfig = {
     formatters: {
       prettier: {
-        command: ["prettier", "--write", "$FILE"],
-        extensions: [".ts", ".md"],
+        command: ["prettier", "--write"],
+        environment: { PRETTIERD_DEFAULT_CONFIG: "./.prettierrc" },
       },
       markdownlint: {
-        command: ["markdownlint-cli2", "--fix", "$FILE"],
-        extensions: [".md"],
+        command: ["markdownlint-cli2", "--fix"],
+      },
+      disabled: {
+        command: ["never"],
+        disabled: true,
       },
     },
-    chains: {
-      ".md": ["prettier", "markdownlint"],
-    },
+    chains: {},
   };
 
-  it("resolves explicit chains in declared order", () => {
-    const chain = resolveFormatterChainForFile("/repo/docs/readme.md", config);
+  it("resolves formatters in declared order", () => {
+    const resolved = resolveChain(["prettier", "markdownlint"], config);
 
-    expect(chain.map((entry) => entry.name)).toEqual([
+    expect(resolved.map((entry) => entry.name)).toEqual([
       "prettier",
       "markdownlint",
     ]);
   });
 
-  it("returns an empty chain when no explicit chain exists for the extension", () => {
-    const chain = resolveFormatterChainForFile("/repo/src/index.ts", config);
+  it("returns the configured command verbatim (no $FILE substitution)", () => {
+    const resolved = resolveChain(["prettier"], config);
+
+    expect(resolved[0]?.command).toEqual(["prettier", "--write"]);
+  });
+
+  it("propagates the formatter environment", () => {
+    const resolved = resolveChain(["prettier"], config);
 
-    expect(chain).toEqual([]);
+    expect(resolved[0]?.environment).toEqual({
+      PRETTIERD_DEFAULT_CONFIG: "./.prettierrc",
+    });
   });
 
-  it("substitutes $FILE in formatter commands", () => {
-    const chain = resolveFormatterChainForFile("/repo/docs/readme.md", config);
+  it("skips disabled formatters", () => {
+    const resolved = resolveChain(
+      ["prettier", "disabled", "markdownlint"],
+      config,
+    );
 
-    expect(chain[0]?.command).toEqual([
+    expect(resolved.map((entry) => entry.name)).toEqual([
       "prettier",
-      "--write",
-      "/repo/docs/readme.md",
+      "markdownlint",
     ]);
   });
 
-  it("skips disabled formatters", () => {
-    const withDisabled: FormatterConfig = {
-      ...config,
-      formatters: {
-        ...config.formatters,
-        markdownlint: {
-          ...config.formatters.markdownlint,
-          disabled: true,
-        },
+  it("skips unknown formatter names", () => {
+    const resolved = resolveChain(["prettier", "nonexistent"], config);
+
+    expect(resolved.map((entry) => entry.name)).toEqual(["prettier"]);
+  });
+
+  it("returns an empty array for an empty chain", () => {
+    expect(resolveChain([], config)).toEqual([]);
+  });
+});
+
+describe("resolveChainSteps", () => {
+  const config: FormatterConfig = {
+    formatters: {
+      prettier: { command: ["prettier", "--write"] },
+      biome: { command: ["biome", "format", "--write"] },
+      "markdownlint-cli2": {
+        command: ["markdownlint-cli2", "--fix"],
       },
-    };
+      off: { command: ["never"], disabled: true },
+    },
+    chains: {},
+  };
+
+  it("resolves a single string step to kind 'single'", () => {
+    const resolved = resolveChainSteps(["prettier"], config);
+    expect(resolved).toHaveLength(1);
+    expect(resolved[0]?.kind).toBe("single");
+    if (resolved[0]?.kind === "single") {
+      expect(resolved[0].formatter.name).toBe("prettier");
+      expect(resolved[0].formatter.command).toEqual(["prettier", "--write"]);
+    }
+  });
 
-    const chain = resolveFormatterChainForFile(
-      "/repo/docs/readme.md",
-      withDisabled,
+  it("drops a single step that names an unknown or disabled formatter", () => {
+    expect(resolveChainSteps(["nope"], config)).toEqual([]);
+    expect(resolveChainSteps(["off"], config)).toEqual([]);
+  });
+
+  it("resolves a fallback step to kind 'fallback' with alternatives in order", () => {
+    const resolved = resolveChainSteps(
+      [{ fallback: ["biome", "prettier"] }],
+      config,
     );
+    expect(resolved).toHaveLength(1);
+    expect(resolved[0]?.kind).toBe("fallback");
+    if (resolved[0]?.kind === "fallback") {
+      expect(resolved[0].alternatives.map((a) => a.name)).toEqual([
+        "biome",
+        "prettier",
+      ]);
+    }
+  });
 
-    expect(chain.map((entry) => entry.name)).toEqual(["prettier"]);
+  it("drops disabled and unknown alternatives within a fallback step", () => {
+    const resolved = resolveChainSteps(
+      [{ fallback: ["off", "unknown", "prettier"] }],
+      config,
+    );
+    expect(resolved).toHaveLength(1);
+    if (resolved[0]?.kind === "fallback") {
+      expect(resolved[0].alternatives.map((a) => a.name)).toEqual(["prettier"]);
+    }
   });
 
-  it("returns an empty chain when no formatter matches", () => {
-    const chain = resolveFormatterChainForFile("/repo/assets/logo.png", config);
+  it("drops a fallback step whose alternatives all reduce away", () => {
+    expect(
+      resolveChainSteps([{ fallback: ["off", "unknown"] }], config),
+    ).toEqual([]);
+  });
 
-    expect(chain).toEqual([]);
+  it("resolves mixed string + fallback chains preserving order", () => {
+    const resolved = resolveChainSteps(
+      [{ fallback: ["biome", "prettier"] }, "markdownlint-cli2"],
+      config,
+    );
+    expect(resolved.map((s) => s.kind)).toEqual(["fallback", "single"]);
   });
 });