@gotgenes/pi-autoformat 0.1.0 → 4.0.3

package/test/fallback-acceptance.test.ts

@@ -0,0 +1,98 @@
+/**
+ * End-to-end fallback chain test.
+ *
+ * Exercises the full resolution path: config loader → grouping →
+ * resolveChainSteps → executeChainGroup with a stubbed PATH probe and a
+ * stubbed runner. Validates the issue #13 acceptance scenario: a global
+ * `[{ fallback: ["biome", "prettier"] }]` chain in a repo where biome is
+ * absent and prettier is present produces a single prettier batch run
+ * with fallbackContext.skipped = ["biome"].
+ *
+ * This is the "acceptance" anchor for the fallback feature. It does not
+ * use the real Pi CLI (see acceptance.test.ts for that surface).
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { validateUserFormatterConfig } from "../src/config-loader.js";
+import { createFormatterConfig } from "../src/formatter-config.js";
+import type { CommandRunner } from "../src/formatter-executor.js";
+import { PromptAutoformatter } from "../src/prompt-autoformatter.js";
+
+describe("fallback chain end-to-end", () => {
+  it("falls through from biome to prettier when biome is missing on PATH", async () => {
+    const validated = validateUserFormatterConfig({
+      formatters: {
+        biome: { command: ["biome", "format", "--write"] },
+        prettier: { command: ["prettier", "--write"] },
+      },
+      chains: {
+        ".ts": [{ fallback: ["biome", "prettier"] }],
+      },
+    });
+    expect(validated.issues).toEqual([]);
+
+    const config = createFormatterConfig(validated.config);
+
+    const calls: Array<{ command: string; args: string[] }> = [];
+    const runner: CommandRunner = async (command, args) => {
+      calls.push({ command, args });
+      return { exitCode: 0 };
+    };
+
+    const formatter = new PromptAutoformatter("/repo", config, runner, {
+      // biome absent, prettier present.
+      commandProbe: (cmd) => cmd === "prettier",
+    });
+    formatter.addTouchedPath("/repo/src/a.ts");
+    formatter.addTouchedPath("/repo/src/b.ts");
+
+    const result = await formatter.flushPrompt();
+
+    expect(calls).toEqual([
+      {
+        command: "prettier",
+        args: ["--write", "/repo/src/a.ts", "/repo/src/b.ts"],
+      },
+    ]);
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].runs).toHaveLength(1);
+    expect(result.groups[0].runs[0]).toMatchObject({
+      formatterName: "prettier",
+      success: true,
+      exitCode: 0,
+      files: ["/repo/src/a.ts", "/repo/src/b.ts"],
+      fallbackContext: { skipped: ["biome"] },
+    });
+  });
+
+  it("emits no run when every fallback alternative is missing from PATH", async () => {
+    const validated = validateUserFormatterConfig({
+      formatters: {
+        biome: { command: ["biome", "format", "--write"] },
+        prettier: { command: ["prettier", "--write"] },
+      },
+      chains: {
+        ".ts": [{ fallback: ["biome", "prettier"] }],
+      },
+    });
+    const config = createFormatterConfig(validated.config);
+
+    const calls: string[] = [];
+    const runner: CommandRunner = async (command) => {
+      calls.push(command);
+      return { exitCode: 0 };
+    };
+
+    const formatter = new PromptAutoformatter("/repo", config, runner, {
+      commandProbe: () => false,
+    });
+    formatter.addTouchedPath("/repo/src/a.ts");
+
+    const result = await formatter.flushPrompt();
+
+    expect(calls).toEqual([]);
+    // Group is dropped entirely: no runs and no group emitted.
+    expect(result.groups).toEqual([]);
+  });
+});

package/test/fixtures/event-bus-emitter.ts

@@ -0,0 +1,26 @@
+/**
+ * Fixture extension for the EventBus acceptance test.
+ *
+ * Registers `/emit-touched <path...>` which forwards the supplied paths
+ * onto the `autoformat:touched` channel. Drives the production
+ * extension's pi.events subscription end-to-end without requiring an
+ * LLM-driven tool call.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export default function eventBusEmitter(pi: ExtensionAPI): void {
+  pi.registerCommand("emit-touched", {
+    description: "Emit autoformat:touched for the supplied paths",
+    handler: async (args) => {
+      const paths = args
+        .split(/\s+/)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+      if (paths.length === 0) {
+        return;
+      }
+      pi.events.emit("autoformat:touched", { paths });
+    },
+  });
+}

package/test/fixtures/formatter-recorder.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Test-only "formatter" that records every invocation to a JSONL log
+ * file pointed at by the PI_AUTOFORMAT_RECORDER_LOG env var.
+ *
+ * Each line of the log is a JSON object describing one invocation:
+ *   { argv: string[], cwd: string, env: { ... } }
+ *
+ * `argv` contains the arguments after the script path itself, which —
+ * for our chain config — is the list of files the formatter was told
+ * to process.
+ */
+import { appendFileSync } from "node:fs";
+
+const logFile = process.env.PI_AUTOFORMAT_RECORDER_LOG;
+if (!logFile) {
+  console.error("PI_AUTOFORMAT_RECORDER_LOG is not set");
+  process.exit(2);
+}
+
+const entry = {
+  argv: process.argv.slice(2),
+  cwd: process.cwd(),
+};
+appendFileSync(logFile, `${JSON.stringify(entry)}\n`);

package/test/format-scope.test.ts

@@ -0,0 +1,139 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { isInFormatScope, resolveFormatScope } from "../src/format-scope.js";
+
+describe("resolveFormatScope", () => {
+  it("uses repo root when detected", () => {
+    const scope = resolveFormatScope({
+      cwd: "/repo/sub",
+      setting: "repoRoot",
+      detectGitRoot: () => "/repo",
+      platform: "linux",
+    });
+    expect(scope.roots).toEqual(["/repo"]);
+    expect(scope.caseInsensitive).toBe(false);
+  });
+
+  it("falls back to cwd when git fails", () => {
+    const scope = resolveFormatScope({
+      cwd: "/repo/sub",
+      setting: "repoRoot",
+      detectGitRoot: () => undefined,
+      platform: "linux",
+    });
+    expect(scope.roots).toEqual(["/repo/sub"]);
+  });
+
+  it("respects 'cwd' setting", () => {
+    const scope = resolveFormatScope({
+      cwd: "/repo/sub",
+      setting: "cwd",
+      detectGitRoot: () => "/repo",
+      platform: "linux",
+    });
+    expect(scope.roots).toEqual(["/repo/sub"]);
+  });
+
+  it("resolves array roots relative to cwd", () => {
+    const scope = resolveFormatScope({
+      cwd: "/repo",
+      setting: ["packages/a", "/abs/path"],
+      platform: "linux",
+    });
+    expect(scope.roots).toEqual(["/repo/packages/a", "/abs/path"]);
+  });
+
+  it("marks darwin/win32 as case-insensitive", () => {
+    expect(
+      resolveFormatScope({ cwd: "/x", setting: "cwd", platform: "darwin" })
+        .caseInsensitive,
+    ).toBe(true);
+    expect(
+      resolveFormatScope({ cwd: "/x", setting: "cwd", platform: "win32" })
+        .caseInsensitive,
+    ).toBe(true);
+    expect(
+      resolveFormatScope({ cwd: "/x", setting: "cwd", platform: "linux" })
+        .caseInsensitive,
+    ).toBe(false);
+  });
+});
+
+describe("isInFormatScope", () => {
+  it("accepts paths inside the root", () => {
+    const scope = { roots: ["/repo"], caseInsensitive: false };
+    expect(isInFormatScope("/repo/src/index.ts", scope)).toBe(true);
+  });
+
+  it("rejects paths outside the root", () => {
+    const scope = { roots: ["/repo"], caseInsensitive: false };
+    expect(isInFormatScope("/other/file.ts", scope)).toBe(false);
+    expect(isInFormatScope("/tmp/scratch.ts", scope)).toBe(false);
+  });
+
+  it("rejects the root itself", () => {
+    const scope = { roots: ["/repo"], caseInsensitive: false };
+    expect(isInFormatScope("/repo", scope)).toBe(false);
+  });
+
+  it("accepts a candidate under any of multiple roots", () => {
+    const scope = {
+      roots: ["/repo/a", "/repo/b"],
+      caseInsensitive: false,
+    };
+    expect(isInFormatScope("/repo/b/src/x.ts", scope)).toBe(true);
+    expect(isInFormatScope("/repo/c/src/x.ts", scope)).toBe(false);
+  });
+
+  it("honors case-insensitive comparison on darwin/win32", () => {
+    const scope = { roots: ["/Repo"], caseInsensitive: true };
+    expect(isInFormatScope("/repo/src/x.ts", scope)).toBe(true);
+  });
+
+  it("uses realpath to drop symlinked workspace deps that escape the root", () => {
+    // Resolve tmpdir realpath up front so this test exercises the symlink
+    // escape check identically on Linux (where /tmp is real) and macOS
+    // (where /tmp is a symlink to /private/tmp).
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "pi-fmtscope-")));
+    const repo = join(root, "repo");
+    const external = join(root, "external");
+    mkdirSync(join(repo, "node_modules"), { recursive: true });
+    mkdirSync(external, { recursive: true });
+    writeFileSync(join(external, "lib.js"), "");
+    symlinkSync(external, join(repo, "node_modules", "lib"));
+
+    const scope = resolveFormatScope({
+      cwd: repo,
+      setting: "cwd",
+      platform: "linux",
+    });
+    expect(
+      isInFormatScope(join(repo, "node_modules", "lib", "lib.js"), scope),
+    ).toBe(false);
+  });
+
+  it("includes a symlink whose realpath lands inside the root", () => {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "pi-fmtscope-")));
+    const repo = join(root, "repo");
+    mkdirSync(join(repo, "real"), { recursive: true });
+    writeFileSync(join(repo, "real", "x.ts"), "");
+    symlinkSync(join(repo, "real"), join(repo, "link"));
+
+    const scope = resolveFormatScope({
+      cwd: repo,
+      setting: "cwd",
+      platform: "linux",
+    });
+    expect(isInFormatScope(join(repo, "link", "x.ts"), scope)).toBe(true);
+  });
+});

package/test/formatter-config.test.ts

@@ -7,19 +7,19 @@ import {
 } from "../src/formatter-config.js";
 
 describe("createFormatterConfig", () => {
-  it("includes default formatters by default", () => {
+  it("includes default formatter definitions but no default chains", () => {
     const config = createFormatterConfig();
 
     expect(Object.keys(config.formatters)).toContain("prettier");
     expect(Object.keys(config.formatters)).toContain("markdownlint-cli2");
+    expect(Object.keys(config.chains)).toHaveLength(0);
   });
 
   it("allows overriding builtin formatter commands", () => {
     const userConfig: UserFormatterConfig = {
       formatters: {
         prettier: {
-          command: ["pnpm", "exec", "prettier", "--write", "$FILE"],
-          extensions: [".ts", ".md"],
+          command: ["pnpm", "exec", "prettier", "--write"],
         },
       },
     };
@@ -31,7 +31,6 @@ describe("createFormatterConfig", () => {
       "exec",
       "prettier",
       "--write",
-      "$FILE",
     ]);
   });
 
@@ -50,7 +49,59 @@ describe("createFormatterConfig", () => {
     expect(config.formatters.prettier?.disabled).toBe(true);
   });
 
-  it("merges chain configuration while preserving user order", () => {
+  it("does not include notifyAgent in the default config", () => {
+    const config = createFormatterConfig();
+
+    expect(config).not.toHaveProperty("notifyAgent");
+  });
+
+  it("defaults formatterOutput to disabled with safe truncation caps", () => {
+    const config = createFormatterConfig();
+
+    expect(config.formatterOutput).toEqual({
+      onFailure: "none",
+      maxBytes: 4096,
+      maxLines: 40,
+    });
+  });
+
+  it("exposes formatterOutput defaults on DEFAULT_FORMATTER_CONFIG", () => {
+    expect(DEFAULT_FORMATTER_CONFIG.formatterOutput).toEqual({
+      onFailure: "none",
+      maxBytes: 4096,
+      maxLines: 40,
+    });
+  });
+
+  it("merges a partial formatterOutput user object field-by-field", () => {
+    const userConfig: UserFormatterConfig = {
+      formatterOutput: { onFailure: "stderr" },
+    };
+
+    const config = createFormatterConfig(userConfig);
+
+    expect(config.formatterOutput).toEqual({
+      onFailure: "stderr",
+      maxBytes: 4096,
+      maxLines: 40,
+    });
+  });
+
+  it("allows overriding individual formatterOutput caps", () => {
+    const userConfig: UserFormatterConfig = {
+      formatterOutput: { onFailure: "both", maxBytes: 256, maxLines: 5 },
+    };
+
+    const config = createFormatterConfig(userConfig);
+
+    expect(config.formatterOutput).toEqual({
+      onFailure: "both",
+      maxBytes: 256,
+      maxLines: 5,
+    });
+  });
+
+  it("preserves user-declared chain order", () => {
     const userConfig: UserFormatterConfig = {
       chains: {
         ".md": ["markdownlint-cli2", "prettier"],