@gotgenes/pi-autoformat 0.1.0 → 4.0.3

package/test/helpers/rpc.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared harness for acceptance tests that drive the real `pi` CLI in
+ * `--mode rpc`.
+ *
+ * Resolves the `pi` binary from the locally-installed
+ * `@mariozechner/pi-coding-agent` devDependency rather than the global
+ * PATH so the suite runs whenever `pnpm install` has been done. Tests
+ * that depend on this harness use the `piAvailable` flag to skip when
+ * the binary is missing (e.g. stale `node_modules`).
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+export const PI_BIN = resolve("node_modules/.bin/pi");
+export const piAvailable = existsSync(PI_BIN);
+
+export type RpcResponse = {
+  id?: string;
+  type: string;
+  command?: string;
+  success?: boolean;
+  data?: unknown;
+};
+
+export type RpcEvent = {
+  type: string;
+  [key: string]: unknown;
+};
+
+export type RpcSessionOptions = {
+  cwd: string;
+  commands: object[];
+  /**
+   * Additional `-e <path>` extension entrypoints loaded alongside the
+   * production `src/extension.ts`. Useful for mounting fixture extensions
+   * that drive specific code paths from RPC.
+   */
+  extraExtensions?: string[];
+  timeoutMs?: number;
+  env?: NodeJS.ProcessEnv;
+  /**
+   * Override the production extension path. Defaults to the resolved
+   * absolute path of `src/extension.ts`.
+   */
+  productionExtension?: string;
+};
+
+export type RpcSessionResult = {
+  responses: RpcResponse[];
+  events: RpcEvent[];
+  stderr: string;
+  exitCode: number | null;
+};
+
+const DEFAULT_PRODUCTION_EXTENSION = resolve("src", "extension.ts");
+
+export async function runRpcSession(
+  options: RpcSessionOptions,
+): Promise<RpcSessionResult> {
+  const {
+    cwd,
+    commands,
+    extraExtensions = [],
+    timeoutMs = 10_000,
+    env,
+    productionExtension = DEFAULT_PRODUCTION_EXTENSION,
+  } = options;
+
+  const extensionArgs: string[] = [];
+  for (const path of [productionExtension, ...extraExtensions]) {
+    extensionArgs.push("-e", path);
+  }
+
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(
+      PI_BIN,
+      [
+        "--mode",
+        "rpc",
+        "--no-tools",
+        "--no-extensions",
+        "--no-session",
+        ...extensionArgs,
+      ],
+      {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: env ? { ...process.env, ...env } : process.env,
+      },
+    );
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString("utf-8");
+    });
+
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      rejectPromise(
+        new Error(
+          `pi rpc session timed out after ${timeoutMs}ms\nstdout: ${stdout}\nstderr: ${stderr}`,
+        ),
+      );
+    }, timeoutMs);
+
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      rejectPromise(error);
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const messages = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map(
+          (line) =>
+            JSON.parse(line) as { type: string } & Record<string, unknown>,
+        );
+
+      const responses: RpcResponse[] = [];
+      const events: RpcEvent[] = [];
+      for (const message of messages) {
+        if (message.type === "response") {
+          responses.push(message as RpcResponse);
+        } else {
+          events.push(message as RpcEvent);
+        }
+      }
+      resolvePromise({ responses, events, stderr, exitCode: code });
+    });
+
+    for (const command of commands) {
+      child.stdin.write(`${JSON.stringify(command)}\n`);
+    }
+    child.stdin.end();
+  });
+}

package/test/prompt-autoformatter.test.ts

@@ -1,21 +1,21 @@
-import { describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { BuiltinFormatter } from "../src/builtin-formatters.js";
 import type { CommandRunner } from "../src/formatter-executor.js";
 import type { FormatterConfig } from "../src/formatter-registry.js";
-import {
-  PromptAutoformatter,
-  type PromptAutoformatterResult,
-} from "../src/prompt-autoformatter.js";
+import { PromptAutoformatter } from "../src/prompt-autoformatter.js";
 
 describe("PromptAutoformatter", () => {
   const config: FormatterConfig = {
     formatters: {
       prettier: {
-        command: ["prettier", "--write", "$FILE"],
-        extensions: [".ts", ".md"],
+        command: ["prettier", "--write"],
       },
       markdownlint: {
-        command: ["markdownlint-cli2", "--fix", "$FILE"],
-        extensions: [".md"],
+        command: ["markdownlint-cli2", "--fix"],
       },
     },
     chains: {
@@ -37,10 +37,10 @@ describe("PromptAutoformatter", () => {
     const result = await formatter.flushPrompt();
 
     expect(calls).toEqual([]);
-    expect(result).toEqual({ files: [] });
+    expect(result).toEqual({ groups: [] });
   });
 
-  it("dedupes touched files across prompt tool results", async () => {
+  it("dedupes touched files and runs each chain step once per group", async () => {
     const calls: string[] = [];
     const runner: CommandRunner = async (command, args) => {
       calls.push([command, ...args].join(" "));
@@ -57,16 +57,60 @@ describe("PromptAutoformatter", () => {
       "prettier --write /repo/docs/readme.md",
       "markdownlint-cli2 --fix /repo/docs/readme.md",
     ]);
-    expect(result.files).toHaveLength(1);
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].files).toEqual(["/repo/docs/readme.md"]);
+    expect(result.groups[0].chain).toEqual(["prettier", "markdownlint"]);
   });
 
-  it("returns formatter failures without throwing", async () => {
+  it("batches multiple files that share a chain into a single invocation per step", async () => {
+    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);
+    formatter.recordToolResult("write", { path: "docs/a.md" });
+    formatter.recordToolResult("write", { path: "docs/b.md" });
+
+    const result = await formatter.flushPrompt();
+
+    expect(calls).toEqual([
+      {
+        command: "prettier",
+        args: ["--write", "/repo/docs/a.md", "/repo/docs/b.md"],
+      },
+      {
+        command: "markdownlint-cli2",
+        args: ["--fix", "/repo/docs/a.md", "/repo/docs/b.md"],
+      },
+    ]);
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].files).toEqual([
+      "/repo/docs/a.md",
+      "/repo/docs/b.md",
+    ]);
+  });
+
+  it("produces one group per distinct chain", async () => {
+    const runner: CommandRunner = async () => ({ exitCode: 0 });
+
+    const formatter = new PromptAutoformatter("/repo", config, runner);
+    formatter.recordToolResult("write", { path: "src/index.ts" });
+    formatter.recordToolResult("write", { path: "docs/readme.md" });
+
+    const result = await formatter.flushPrompt();
+
+    expect(result.groups.map((g) => g.chain)).toEqual([
+      ["prettier"],
+      ["prettier", "markdownlint"],
+    ]);
+  });
+
+  it("returns formatter failures per batch without throwing", async () => {
     const runner: CommandRunner = async (command) => {
       if (command === "prettier") {
-        return {
-          exitCode: 2,
-          stderr: "parse error",
-        };
+        return { exitCode: 2, stderr: "parse error" };
       }
       return { exitCode: 0 };
     };
@@ -75,19 +119,268 @@ describe("PromptAutoformatter", () => {
     formatter.recordToolResult("write", { path: "docs/readme.md" });
 
     const result = await formatter.flushPrompt();
-    const firstFile = result
-      .files[0] as PromptAutoformatterResult["files"][number];
+    const group = result.groups[0];
 
-    expect(firstFile.path).toBe("/repo/docs/readme.md");
-    expect(firstFile.runs[0]).toMatchObject({
+    expect(group.files).toEqual(["/repo/docs/readme.md"]);
+    expect(group.runs[0]).toMatchObject({
       formatterName: "prettier",
       success: false,
       exitCode: 2,
+      files: ["/repo/docs/readme.md"],
     });
-    expect(firstFile.runs[1]).toMatchObject({
+    expect(group.runs[1]).toMatchObject({
       formatterName: "markdownlint",
       success: true,
       exitCode: 0,
     });
   });
+
+  it("shares the PATH probe cache across all chain groups in a single flush", async () => {
+    const fallbackConfig: FormatterConfig = {
+      formatters: {
+        biome: { command: ["biome", "format", "--write"] },
+        prettier: { command: ["prettier", "--write"] },
+      },
+      chains: {
+        ".ts": [{ fallback: ["biome", "prettier"] }],
+        ".tsx": [{ fallback: ["biome", "prettier"] }],
+        // Distinct chain so a second group is created.
+        ".js": [{ fallback: ["biome", "prettier"] }, "prettier"],
+      },
+    };
+    const runner: CommandRunner = async () => ({ exitCode: 0 });
+    const probeCalls: string[] = [];
+    const probe = (cmd: string): boolean => {
+      probeCalls.push(cmd);
+      return cmd === "prettier";
+    };
+
+    const formatter = new PromptAutoformatter("/repo", fallbackConfig, runner, {
+      commandProbe: probe,
+    });
+    formatter.addTouchedPath("/repo/a.ts");
+    formatter.addTouchedPath("/repo/b.tsx");
+    formatter.addTouchedPath("/repo/c.js");
+
+    const result = await formatter.flushPrompt();
+    expect(result.groups.length).toBeGreaterThanOrEqual(2);
+    // Each unique command name probed at most once across the whole flush.
+    const counts = probeCalls.reduce<Record<string, number>>((acc, cmd) => {
+      acc[cmd] = (acc[cmd] ?? 0) + 1;
+      return acc;
+    }, {});
+    expect(counts.biome ?? 0).toBeLessThanOrEqual(1);
+    expect(counts.prettier ?? 0).toBeLessThanOrEqual(1);
+  });
+
+  describe("with a wildcard chain", () => {
+    function fakeTreefmt(
+      unhandledPredicate: (file: string) => boolean,
+    ): BuiltinFormatter {
+      return {
+        name: "treefmt",
+        async discoverRoot() {
+          return "/repo";
+        },
+        buildCommand(root, files) {
+          return {
+            command: ["treefmt", "--", ...files],
+            cwd: root,
+          };
+        },
+        partitionUnhandled(_run, files) {
+          const unhandled = files.filter(unhandledPredicate);
+          const handled = files.filter((f) => !unhandledPredicate(f));
+          return { handled, unhandled, treatAsSkip: false };
+        },
+      };
+    }
+
+    it("runs the wildcard chain first across all touched files and skips per-extension chains for handled files", async () => {
+      const calls: Array<{ command: string; args: string[] }> = [];
+      const runner: CommandRunner = async (command, args) => {
+        calls.push({ command, args });
+        return { exitCode: 0 };
+      };
+      const builtinConfig: FormatterConfig = {
+        formatters: {
+          prettier: { command: ["prettier", "--write"] },
+        },
+        chains: {
+          "*": ["treefmt"],
+          ".ts": ["prettier"],
+          ".bin": ["prettier"],
+        },
+      };
+      // Patch the global treefmt built-in's hooks for this test.
+      const { BUILTIN_FORMATTERS } = await import(
+        "../src/builtin-formatters.js"
+      );
+      const original = { ...BUILTIN_FORMATTERS.treefmt };
+      const fake = fakeTreefmt((f) => f.endsWith(".bin"));
+      BUILTIN_FORMATTERS.treefmt.discoverRoot = fake.discoverRoot;
+      BUILTIN_FORMATTERS.treefmt.buildCommand = fake.buildCommand;
+      BUILTIN_FORMATTERS.treefmt.partitionUnhandled = fake.partitionUnhandled;
+      try {
+        const formatter = new PromptAutoformatter(
+          "/repo",
+          builtinConfig,
+          runner,
+        );
+        formatter.addTouchedPath("/repo/a.ts");
+        formatter.addTouchedPath("/repo/b.bin");
+
+        const result = await formatter.flushPrompt();
+
+        // treefmt invoked once with both files; prettier runs only on the
+        // unhandled .bin file (per-ext chain backstops the wildcard skip).
+        expect(calls[0]).toEqual({
+          command: "treefmt",
+          args: ["--", "/repo/a.ts", "/repo/b.bin"],
+        });
+        const prettierCalls = calls.filter((c) => c.command === "prettier");
+        expect(prettierCalls).toHaveLength(1);
+        expect(prettierCalls[0]?.args).toEqual(["--write", "/repo/b.bin"]);
+        // Sanity: groups recorded.
+        expect(result.groups[0].chain).toEqual(["treefmt"]);
+      } finally {
+        Object.assign(BUILTIN_FORMATTERS.treefmt, original);
+      }
+    });
+
+    it("removes wildcard-handled files from per-extension groups entirely", async () => {
+      const calls: Array<{ command: string; args: string[] }> = [];
+      const runner: CommandRunner = async (command, args) => {
+        calls.push({ command, args });
+        return { exitCode: 0 };
+      };
+      const builtinConfig: FormatterConfig = {
+        formatters: {
+          prettier: { command: ["prettier", "--write"] },
+        },
+        chains: {
+          "*": ["treefmt"],
+          ".ts": ["prettier"],
+        },
+      };
+      const { BUILTIN_FORMATTERS } = await import(
+        "../src/builtin-formatters.js"
+      );
+      const original = { ...BUILTIN_FORMATTERS.treefmt };
+      // Mark every .ts file as handled.
+      const fake = fakeTreefmt(() => false);
+      BUILTIN_FORMATTERS.treefmt.discoverRoot = fake.discoverRoot;
+      BUILTIN_FORMATTERS.treefmt.buildCommand = fake.buildCommand;
+      BUILTIN_FORMATTERS.treefmt.partitionUnhandled = fake.partitionUnhandled;
+      try {
+        const formatter = new PromptAutoformatter(
+          "/repo",
+          builtinConfig,
+          runner,
+        );
+        formatter.addTouchedPath("/repo/a.ts");
+        formatter.addTouchedPath("/repo/b.ts");
+
+        await formatter.flushPrompt();
+
+        // treefmt runs once. prettier should NOT run because the wildcard
+        // claimed all files.
+        expect(calls.map((c) => c.command)).toEqual(["treefmt"]);
+      } finally {
+        Object.assign(BUILTIN_FORMATTERS.treefmt, original);
+      }
+    });
+  });
+
+  describe("changedFiles detection", () => {
+    let workDir: string;
+
+    beforeEach(() => {
+      workDir = mkdtempSync(join(tmpdir(), "pi-autoformat-change-"));
+    });
+
+    afterEach(() => {
+      rmSync(workDir, { recursive: true, force: true });
+    });
+
+    it("populates changedFiles when the formatter modifies file content", async () => {
+      const filePath = join(workDir, "a.ts");
+      writeFileSync(filePath, "const   x=1;");
+
+      const runner: CommandRunner = async (_command, args) => {
+        // Simulate a formatter that rewrites the file
+        for (const arg of args) {
+          if (arg.endsWith(".ts")) {
+            writeFileSync(arg, "const x = 1;");
+          }
+        }
+        return { exitCode: 0 };
+      };
+
+      const cfg: FormatterConfig = {
+        formatters: { fmt: { command: ["fmt"] } },
+        chains: { ".ts": ["fmt"] },
+      };
+
+      const formatter = new PromptAutoformatter(workDir, cfg, runner);
+      formatter.addTouchedPath(filePath);
+
+      const result = await formatter.flushPrompt();
+
+      expect(result.groups).toHaveLength(1);
+      expect(result.groups[0].changedFiles).toEqual([filePath]);
+    });
+
+    it("leaves changedFiles empty when the formatter does not change content", async () => {
+      const filePath = join(workDir, "b.ts");
+      writeFileSync(filePath, "const x = 1;");
+
+      const runner: CommandRunner = async () => {
+        // Formatter is a no-op
+        return { exitCode: 0 };
+      };
+
+      const cfg: FormatterConfig = {
+        formatters: { fmt: { command: ["fmt"] } },
+        chains: { ".ts": ["fmt"] },
+      };
+
+      const formatter = new PromptAutoformatter(workDir, cfg, runner);
+      formatter.addTouchedPath(filePath);
+
+      const result = await formatter.flushPrompt();
+
+      expect(result.groups).toHaveLength(1);
+      expect(result.groups[0].changedFiles).toEqual([]);
+    });
+
+    it("excludes deleted files from changedFiles", async () => {
+      const filePath = join(workDir, "c.ts");
+      writeFileSync(filePath, "delete me");
+
+      const runner: CommandRunner = async (_command, args) => {
+        // Simulate formatter that deletes the file
+        const { unlinkSync } = await import("node:fs");
+        for (const arg of args) {
+          if (arg.endsWith(".ts")) {
+            unlinkSync(arg);
+          }
+        }
+        return { exitCode: 0 };
+      };
+
+      const cfg: FormatterConfig = {
+        formatters: { fmt: { command: ["fmt"] } },
+        chains: { ".ts": ["fmt"] },
+      };
+
+      const formatter = new PromptAutoformatter(workDir, cfg, runner);
+      formatter.addTouchedPath(filePath);
+
+      const result = await formatter.flushPrompt();
+
+      expect(result.groups).toHaveLength(1);
+      expect(result.groups[0].changedFiles).toEqual([]);
+    });
+  });
 });

package/test/schema.test.ts

@@ -0,0 +1,149 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+const schemaPath = join(process.cwd(), "schemas", "pi-autoformat.schema.json");
+
+type FormatterOutputSchema = {
+  type?: string;
+  additionalProperties?: boolean;
+  properties?: {
+    onFailure?: { type?: string; enum?: string[] };
+    maxBytes?: { type?: string; minimum?: number };
+    maxLines?: { type?: string; minimum?: number };
+  };
+};
+
+type SchemaShape = {
+  $defs?: {
+    formatterDefinition?: {
+      properties?: Record<string, unknown>;
+    };
+    chainStep?: unknown;
+    formatterOutputReportingConfig?: FormatterOutputSchema;
+  };
+  additionalProperties?: boolean;
+  properties?: {
+    chains?: {
+      propertyNames?: { pattern?: string };
+      additionalProperties?: {
+        type?: string;
+        items?: unknown;
+      };
+    };
+    formatterOutput?: FormatterOutputSchema | { $ref?: string };
+  };
+};
+
+describe("pi-autoformat.schema.json", () => {
+  const schema: SchemaShape = JSON.parse(readFileSync(schemaPath, "utf8"));
+
+  it("does not declare a notifyAgent property", () => {
+    expect(schema.properties).not.toHaveProperty("notifyAgent");
+  });
+
+  it("does not declare an extensions property on formatterDefinition", () => {
+    const properties = schema.$defs?.formatterDefinition?.properties ?? {};
+    expect(properties).not.toHaveProperty("extensions");
+  });
+
+  it("still declares command on formatterDefinition", () => {
+    const properties = schema.$defs?.formatterDefinition?.properties ?? {};
+    expect(properties).toHaveProperty("command");
+  });
+
+  describe("chains key pattern", () => {
+    it("accepts dotted extension keys and the literal '*' wildcard", () => {
+      const pattern = schema.properties?.chains?.propertyNames?.pattern;
+      expect(pattern).toBeDefined();
+      const re = new RegExp(pattern as string);
+      expect(re.test(".md")).toBe(true);
+      expect(re.test(".tsx")).toBe(true);
+      expect(re.test("*")).toBe(true);
+    });
+
+    it("rejects bare names and empty strings", () => {
+      const pattern = schema.properties?.chains?.propertyNames?.pattern;
+      const re = new RegExp(pattern as string);
+      expect(re.test("md")).toBe(false);
+      expect(re.test("")).toBe(false);
+    });
+  });
+
+  describe("chains step shape", () => {
+    it("declares chains items as a oneOf of string and fallback object", () => {
+      const items = schema.properties?.chains?.additionalProperties?.items as
+        | { oneOf?: unknown[] }
+        | undefined;
+      expect(items).toBeDefined();
+      expect(Array.isArray(items?.oneOf)).toBe(true);
+      expect(items?.oneOf?.length).toBe(2);
+    });
+
+    it("includes a string variant for chain steps", () => {
+      const items = schema.properties?.chains?.additionalProperties?.items as
+        | { oneOf?: Array<{ type?: string; minLength?: number }> }
+        | undefined;
+      const stringVariant = items?.oneOf?.find((v) => v?.type === "string");
+      expect(stringVariant).toBeDefined();
+      expect(stringVariant?.minLength).toBe(1);
+    });
+
+    it("includes a fallback object variant with a non-empty string array", () => {
+      const items = schema.properties?.chains?.additionalProperties?.items as
+        | { oneOf?: Array<Record<string, unknown>> }
+        | undefined;
+      const fallbackVariant = items?.oneOf?.find((v) => v?.type === "object") as
+        | {
+            type?: string;
+            additionalProperties?: boolean;
+            required?: string[];
+            properties?: {
+              fallback?: {
+                type?: string;
+                minItems?: number;
+                items?: { type?: string; minLength?: number };
+              };
+            };
+          }
+        | undefined;
+      expect(fallbackVariant).toBeDefined();
+      expect(fallbackVariant?.additionalProperties).toBe(false);
+      expect(fallbackVariant?.required).toEqual(["fallback"]);
+      const fallback = fallbackVariant?.properties?.fallback;
+      expect(fallback?.type).toBe("array");
+      expect(fallback?.minItems).toBe(1);
+      expect(fallback?.items?.type).toBe("string");
+      expect(fallback?.items?.minLength).toBe(1);
+    });
+  });
+
+  describe("formatterOutput", () => {
+    it("declares formatterOutput as a top-level property", () => {
+      expect(schema.properties).toHaveProperty("formatterOutput");
+    });
+
+    it("forbids unknown sub-keys on formatterOutput", () => {
+      const def = schema.$defs?.formatterOutputReportingConfig;
+      expect(def?.type).toBe("object");
+      expect(def?.additionalProperties).toBe(false);
+    });
+
+    it("restricts onFailure to none/stderr/both", () => {
+      const onFailure =
+        schema.$defs?.formatterOutputReportingConfig?.properties?.onFailure;
+      expect(onFailure?.type).toBe("string");
+      expect(onFailure?.enum).toEqual(["none", "stderr", "both"]);
+    });
+
+    it("requires non-negative integer caps for maxBytes and maxLines", () => {
+      const props =
+        schema.$defs?.formatterOutputReportingConfig?.properties ?? {};
+      expect(props.maxBytes?.type).toBe("integer");
+      expect(props.maxBytes?.minimum).toBe(0);
+      expect(props.maxLines?.type).toBe("integer");
+      expect(props.maxLines?.minimum).toBe(0);
+    });
+  });
+});