@gotgenes/pi-autoformat 0.1.0

package/src/touched-files-queue.ts

@@ -0,0 +1,46 @@
+import path from "node:path";
+
+type ToolResultPayload = {
+  path?: unknown;
+};
+
+const MUTATION_TOOLS = new Set(["write", "edit"]);
+
+export class TouchedFilesQueue {
+  private readonly cwd: string;
+  private readonly touchedFiles = new Set<string>();
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+  }
+
+  recordToolResult(toolName: string, payload: unknown): void {
+    if (!MUTATION_TOOLS.has(toolName)) {
+      return;
+    }
+
+    if (!isToolResultPayload(payload) || typeof payload.path !== "string") {
+      return;
+    }
+
+    this.touchedFiles.add(normalizePath(this.cwd, payload.path));
+  }
+
+  flush(): string[] {
+    const files = [...this.touchedFiles];
+    this.touchedFiles.clear();
+    return files;
+  }
+}
+
+function isToolResultPayload(value: unknown): value is ToolResultPayload {
+  return typeof value === "object" && value !== null;
+}
+
+function normalizePath(cwd: string, filePath: string): string {
+  if (path.isAbsolute(filePath)) {
+    return path.normalize(filePath);
+  }
+
+  return path.normalize(path.resolve(cwd, filePath));
+}

package/test/config-loader.test.ts

@@ -0,0 +1,199 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  loadAutoformatConfig,
+  validateUserFormatterConfig,
+} from "../src/config-loader.js";
+
+describe("validateUserFormatterConfig", () => {
+  it("accepts $schema and known config fields", () => {
+    const result = validateUserFormatterConfig({
+      $schema: "https://example.com/schema.json",
+      formatMode: "prompt",
+      commandTimeoutMs: 5000,
+      hideSummariesInTui: true,
+      formatters: {
+        prettier: {
+          command: ["prettier", "--write", "$FILE"],
+          extensions: [".TS", ".md"],
+        },
+      },
+      chains: {
+        ".MD": ["prettier"],
+      },
+    });
+
+    expect(result.issues).toEqual([]);
+    expect(result.config).toEqual({
+      formatMode: "prompt",
+      commandTimeoutMs: 5000,
+      hideSummariesInTui: true,
+      formatters: {
+        prettier: {
+          command: ["prettier", "--write", "$FILE"],
+          extensions: [".ts", ".md"],
+        },
+      },
+      chains: {
+        ".md": ["prettier"],
+      },
+    });
+  });
+
+  it("reports invalid fields and returns only valid fragments", () => {
+    const result = validateUserFormatterConfig({
+      formatMode: "later",
+      commandTimeoutMs: 0,
+      unexpected: true,
+      formatters: {
+        prettier: {
+          command: ["prettier", "--write", "$FILE"],
+        },
+      },
+    });
+
+    expect(result.config).toEqual({
+      formatters: {},
+    });
+    expect(result.issues.map((issue) => issue.path)).toEqual([
+      "formatMode",
+      "commandTimeoutMs",
+      "unexpected",
+      "formatters.prettier.extensions",
+    ]);
+  });
+});
+
+describe("loadAutoformatConfig", () => {
+  it("uses default config when no files exist", () => {
+    const root = mkdtempSync(join(tmpdir(), "pi-autoformat-config-"));
+    const cwd = join(root, "project");
+    const agentDir = join(root, "agent");
+    mkdirSync(cwd, { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
+
+    const result = loadAutoformatConfig({ cwd, agentDir });
+
+    expect(result.config.formatMode).toBe("prompt");
+    expect(result.config.commandTimeoutMs).toBe(10000);
+    expect(result.config.hideSummariesInTui).toBe(false);
+    expect(result.issues).toEqual([]);
+  });
+
+  it("merges global and project config with project precedence", () => {
+    const root = mkdtempSync(join(tmpdir(), "pi-autoformat-config-"));
+    const cwd = join(root, "project");
+    const agentDir = join(root, "agent");
+    mkdirSync(cwd, { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
+
+    mkdirSync(join(agentDir, "extensions", "pi-autoformat"), {
+      recursive: true,
+    });
+    writeFileSync(
+      getGlobalConfigPath(agentDir),
+      JSON.stringify(
+        {
+          formatMode: "tool",
+          commandTimeoutMs: 5000,
+          formatters: {
+            prettier: {
+              command: ["pnpm", "exec", "prettier", "--write", "$FILE"],
+              extensions: [".ts", ".md"],
+            },
+          },
+          chains: {
+            ".md": ["prettier"],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    mkdirSync(join(cwd, ".pi", "extensions", "pi-autoformat"), {
+      recursive: true,
+    });
+    writeFileSync(
+      getProjectConfigPath(cwd),
+      JSON.stringify(
+        {
+          formatMode: "prompt",
+          hideSummariesInTui: true,
+          formatters: {
+            "markdownlint-cli2": {
+              command: ["pnpm", "exec", "markdownlint-cli2", "--fix", "$FILE"],
+              extensions: [".md"],
+            },
+          },
+          chains: {
+            ".md": ["prettier", "markdownlint-cli2"],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const result = loadAutoformatConfig({ cwd, agentDir });
+
+    expect(result.config.formatMode).toBe("prompt");
+    expect(result.config.commandTimeoutMs).toBe(5000);
+    expect(result.config.hideSummariesInTui).toBe(true);
+    expect(result.config.formatters.prettier?.command).toEqual([
+      "pnpm",
+      "exec",
+      "prettier",
+      "--write",
+      "$FILE",
+    ]);
+    expect(result.config.formatters["markdownlint-cli2"]?.command).toEqual([
+      "pnpm",
+      "exec",
+      "markdownlint-cli2",
+      "--fix",
+      "$FILE",
+    ]);
+    expect(result.config.chains[".md"]).toEqual([
+      "prettier",
+      "markdownlint-cli2",
+    ]);
+    expect(result.issues).toEqual([]);
+  });
+
+  it("reports parse and validation errors without throwing", () => {
+    const root = mkdtempSync(join(tmpdir(), "pi-autoformat-config-"));
+    const cwd = join(root, "project");
+    const agentDir = join(root, "agent");
+    mkdirSync(cwd, { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
+
+    mkdirSync(join(agentDir, "extensions", "pi-autoformat"), {
+      recursive: true,
+    });
+    writeFileSync(getGlobalConfigPath(agentDir), "{not json\n");
+
+    mkdirSync(join(cwd, ".pi", "extensions", "pi-autoformat"), {
+      recursive: true,
+    });
+    writeFileSync(
+      getProjectConfigPath(cwd),
+      JSON.stringify({
+        hideSummariesInTui: "yes",
+      }),
+    );
+
+    const result = loadAutoformatConfig({ cwd, agentDir });
+
+    expect(result.config.hideSummariesInTui).toBe(false);
+    expect(result.issues).toHaveLength(2);
+    expect(result.issues[0]?.sourcePath).toBe(getGlobalConfigPath(agentDir));
+    expect(result.issues[1]?.path).toBe("hideSummariesInTui");
+  });
+});

package/test/extension.test.ts

@@ -0,0 +1,364 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { LoadConfigResult } from "../src/config-loader.js";
+import { createAutoformatExtension } from "../src/extension.js";
+import { createFormatterConfig } from "../src/formatter-config.js";
+import type { PromptAutoformatterResult } from "../src/prompt-autoformatter.js";
+
+type Handler = (event: unknown, ctx: TestContext) => void | Promise<void>;
+
+type EventName =
+  | "session_start"
+  | "tool_result"
+  | "agent_end"
+  | "session_shutdown";
+
+type TestContext = {
+  cwd: string;
+  hasUI: boolean;
+  ui: {
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+  };
+};
+
+class TestPi {
+  private readonly handlers = new Map<EventName, Handler[]>();
+
+  on(eventName: EventName, handler: Handler): void {
+    const existing = this.handlers.get(eventName) ?? [];
+    existing.push(handler);
+    this.handlers.set(eventName, existing);
+  }
+
+  async emit(
+    eventName: EventName,
+    event: unknown,
+    ctx: TestContext,
+  ): Promise<void> {
+    for (const handler of this.handlers.get(eventName) ?? []) {
+      await handler(event, ctx);
+    }
+  }
+}
+
+function createLoadResult(
+  formatMode: "tool" | "prompt" | "session",
+): LoadConfigResult {
+  return {
+    config: createFormatterConfig({ formatMode }),
+    globalConfigPath: "/global/config.json",
+    projectConfigPath: "/project/config.json",
+    issues: [],
+  };
+}
+
+function createContext(overrides?: Partial<TestContext>): TestContext {
+  return {
+    cwd: "/repo",
+    hasUI: true,
+    ui: {
+      notify: vi.fn(),
+    },
+    ...overrides,
+  };
+}
+
+function createFlushResult(): PromptAutoformatterResult {
+  return {
+    files: [
+      {
+        path: "/repo/src/example.ts",
+        runs: [],
+      },
+    ],
+  };
+}
+
+describe("createAutoformatExtension", () => {
+  it("reports interactive success summaries with touched file paths", async () => {
+    const pi = new TestPi();
+    const notify = vi.fn();
+    const ctx = createContext({
+      ui: {
+        notify,
+      },
+    });
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue(createLoadResult("prompt")),
+      createAutoformatter: vi.fn().mockReturnValue({
+        recordToolResult: vi.fn(),
+        flushPrompt: vi.fn().mockResolvedValue({
+          files: [
+            {
+              path: "/repo/src/example.ts",
+              runs: [
+                {
+                  formatterName: "prettier",
+                  command: [],
+                  success: true,
+                  exitCode: 0,
+                },
+              ],
+            },
+            {
+              path: "/repo/README.md",
+              runs: [
+                {
+                  formatterName: "prettier",
+                  command: [],
+                  success: true,
+                  exitCode: 0,
+                },
+              ],
+            },
+          ],
+        }),
+      }),
+    });
+
+    await pi.emit("session_start", {}, ctx);
+    await pi.emit("agent_end", {}, ctx);
+
+    expect(notify).toHaveBeenCalledWith(
+      "Autoformatted 2 files: /repo/src/example.ts, /repo/README.md",
+      "info",
+    );
+  });
+
+  it("hides interactive success summaries when configured", async () => {
+    const pi = new TestPi();
+    const notify = vi.fn();
+    const ctx = createContext({
+      ui: {
+        notify,
+      },
+    });
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue({
+        ...createLoadResult("prompt"),
+        config: createFormatterConfig({
+          formatMode: "prompt",
+          hideSummariesInTui: true,
+        }),
+      }),
+      createAutoformatter: vi.fn().mockReturnValue({
+        recordToolResult: vi.fn(),
+        flushPrompt: vi.fn().mockResolvedValue(createFlushResult()),
+      }),
+    });
+
+    await pi.emit("session_start", {}, ctx);
+    await pi.emit("agent_end", {}, ctx);
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  it("reports non-interactive formatter failures via console warnings", async () => {
+    const pi = new TestPi();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const ctx = createContext({ hasUI: false });
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue(createLoadResult("prompt")),
+      createAutoformatter: vi.fn().mockReturnValue({
+        recordToolResult: vi.fn(),
+        flushPrompt: vi.fn().mockResolvedValue({
+          files: [
+            {
+              path: "/repo/README.md",
+              runs: [
+                {
+                  formatterName: "prettier",
+                  command: ["prettier", "--write", "/repo/README.md"],
+                  success: false,
+                  exitCode: 2,
+                },
+                {
+                  formatterName: "markdownlint-cli2",
+                  command: ["markdownlint-cli2", "--fix", "/repo/README.md"],
+                  success: false,
+                  exitCode: 1,
+                },
+              ],
+            },
+          ],
+        }),
+      }),
+    });
+
+    await pi.emit("session_start", {}, ctx);
+    await pi.emit("agent_end", {}, ctx);
+
+    expect(warn).toHaveBeenCalledWith(
+      "[pi-autoformat] Formatter failures in 1 file (2 failed runs):\n/repo/README.md: prettier (exit 2), markdownlint-cli2 (exit 1)",
+    );
+    expect(log).not.toHaveBeenCalled();
+
+    warn.mockRestore();
+    log.mockRestore();
+  });
+
+  it("reports non-interactive config issues via console warnings", async () => {
+    const pi = new TestPi();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const ctx = createContext({ hasUI: false });
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue({
+        ...createLoadResult("prompt"),
+        issues: [
+          {
+            path: "formatMode",
+            message: "Expected a valid mode.",
+            sourcePath: "/repo/.pi/extensions/pi-autoformat/config.json",
+          },
+        ],
+      }),
+      createAutoformatter: vi.fn().mockReturnValue({
+        recordToolResult: vi.fn(),
+        flushPrompt: vi.fn().mockResolvedValue({ files: [] }),
+      }),
+    });
+
+    await pi.emit("session_start", {}, ctx);
+
+    expect(warn).toHaveBeenCalledWith(
+      "[pi-autoformat] Configuration issues detected:\n/repo/.pi/extensions/pi-autoformat/config.json formatMode: Expected a valid mode.",
+    );
+
+    warn.mockRestore();
+  });
+
+  it("records successful tool results and flushes at prompt end in prompt mode", async () => {
+    const pi = new TestPi();
+    const ctx = createContext();
+    const autoformatter = {
+      recordToolResult: vi.fn(),
+      flushPrompt: vi.fn().mockResolvedValue(createFlushResult()),
+    };
+    const reportFlushResult = vi.fn();
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue(createLoadResult("prompt")),
+      createAutoformatter: vi.fn().mockReturnValue(autoformatter),
+      reportFlushResult,
+    });
+
+    await pi.emit("session_start", {}, ctx);
+    await pi.emit(
+      "tool_result",
+      {
+        toolName: "write",
+        input: { path: "src/example.ts", content: "export {};" },
+        isError: false,
+      },
+      ctx,
+    );
+    await pi.emit("agent_end", {}, ctx);
+
+    expect(autoformatter.recordToolResult).toHaveBeenCalledWith("write", {
+      path: "src/example.ts",
+      content: "export {};",
+    });
+    expect(autoformatter.flushPrompt).toHaveBeenCalledTimes(1);
+    expect(reportFlushResult).toHaveBeenCalledTimes(1);
+  });
+
+  it("flushes immediately in tool mode", async () => {
+    const pi = new TestPi();
+    const ctx = createContext();
+    const autoformatter = {
+      recordToolResult: vi.fn(),
+      flushPrompt: vi.fn().mockResolvedValue({ files: [] }),
+    };
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue(createLoadResult("tool")),
+      createAutoformatter: vi.fn().mockReturnValue(autoformatter),
+      reportFlushResult: vi.fn(),
+    });
+
+    await pi.emit(
+      "tool_result",
+      {
+        toolName: "edit",
+        input: { path: "src/example.ts", edits: [] },
+        isError: false,
+      },
+      ctx,
+    );
+
+    expect(autoformatter.recordToolResult).toHaveBeenCalledTimes(1);
+    expect(autoformatter.flushPrompt).toHaveBeenCalledTimes(1);
+  });
+
+  it("flushes on session shutdown in session mode and ignores failed tool results", async () => {
+    const pi = new TestPi();
+    const ctx = createContext();
+    const autoformatter = {
+      recordToolResult: vi.fn(),
+      flushPrompt: vi.fn().mockResolvedValue({ files: [] }),
+    };
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue(createLoadResult("session")),
+      createAutoformatter: vi.fn().mockReturnValue(autoformatter),
+      reportFlushResult: vi.fn(),
+    });
+
+    await pi.emit("session_start", {}, ctx);
+    await pi.emit(
+      "tool_result",
+      {
+        toolName: "write",
+        input: { path: "src/example.ts", content: "" },
+        isError: true,
+      },
+      ctx,
+    );
+    await pi.emit("session_shutdown", {}, ctx);
+
+    expect(autoformatter.recordToolResult).not.toHaveBeenCalled();
+    expect(autoformatter.flushPrompt).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports config issues on session start", async () => {
+    const pi = new TestPi();
+    const ctx = createContext();
+    const reportConfigIssues = vi.fn();
+
+    createAutoformatExtension(pi, {
+      loadConfig: vi.fn().mockReturnValue({
+        ...createLoadResult("prompt"),
+        issues: [
+          {
+            path: "formatMode",
+            message: "Expected a valid mode.",
+            sourcePath: "/repo/.pi/extensions/pi-autoformat/config.json",
+          },
+        ],
+      }),
+      createAutoformatter: vi.fn().mockReturnValue({
+        recordToolResult: vi.fn(),
+        flushPrompt: vi.fn().mockResolvedValue({ files: [] }),
+      }),
+      reportConfigIssues,
+    });
+
+    await pi.emit("session_start", {}, ctx);
+
+    expect(reportConfigIssues).toHaveBeenCalledWith(
+      [
+        {
+          path: "formatMode",
+          message: "Expected a valid mode.",
+          sourcePath: "/repo/.pi/extensions/pi-autoformat/config.json",
+        },
+      ],
+      { ctx },
+    );
+  });
+});

package/test/formatter-config.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createFormatterConfig,
+  DEFAULT_FORMATTER_CONFIG,
+  type UserFormatterConfig,
+} from "../src/formatter-config.js";
+
+describe("createFormatterConfig", () => {
+  it("includes default formatters by default", () => {
+    const config = createFormatterConfig();
+
+    expect(Object.keys(config.formatters)).toContain("prettier");
+    expect(Object.keys(config.formatters)).toContain("markdownlint-cli2");
+  });
+
+  it("allows overriding builtin formatter commands", () => {
+    const userConfig: UserFormatterConfig = {
+      formatters: {
+        prettier: {
+          command: ["pnpm", "exec", "prettier", "--write", "$FILE"],
+          extensions: [".ts", ".md"],
+        },
+      },
+    };
+
+    const config = createFormatterConfig(userConfig);
+
+    expect(config.formatters.prettier?.command).toEqual([
+      "pnpm",
+      "exec",
+      "prettier",
+      "--write",
+      "$FILE",
+    ]);
+  });
+
+  it("allows disabling builtin formatters", () => {
+    const userConfig: UserFormatterConfig = {
+      formatters: {
+        prettier: {
+          ...DEFAULT_FORMATTER_CONFIG.formatters.prettier,
+          disabled: true,
+        },
+      },
+    };
+
+    const config = createFormatterConfig(userConfig);
+
+    expect(config.formatters.prettier?.disabled).toBe(true);
+  });
+
+  it("merges chain configuration while preserving user order", () => {
+    const userConfig: UserFormatterConfig = {
+      chains: {
+        ".md": ["markdownlint-cli2", "prettier"],
+      },
+    };
+
+    const config = createFormatterConfig(userConfig);
+
+    expect(config.chains[".md"]).toEqual(["markdownlint-cli2", "prettier"]);
+  });
+});