pi-formatter 0.1.1 → 0.3.0

package/extensions/{format → formatter}/plan.ts

@@ -5,22 +5,22 @@ export const FORMAT_PLAN: Record<FileKind, RunnerGroup[]> = {
   cmake: [{ mode: "all", runnerIds: ["cmake-format"] }],
   markdown: [
     {
-      mode: "all",
-      runnerIds: ["markdownlint-fix", "prettier-markdown"],
+      mode: "fallback",
+      runnerIds: ["prettier", "markdownlint"],
     },
   ],
   json: [
     {
       mode: "fallback",
-      runnerIds: ["biome-check-write", "prettier-config-write"],
+      runnerIds: ["biome", "prettier"],
     },
   ],
   shell: [{ mode: "all", runnerIds: ["shfmt"] }],
-  python: [{ mode: "all", runnerIds: ["ruff-format", "ruff-check-fix"] }],
+  python: [{ mode: "all", runnerIds: ["ruff-format", "ruff-check"] }],
   jsts: [
     {
       mode: "fallback",
-      runnerIds: ["biome-check-write", "eslint-fix", "prettier-config-write"],
+      runnerIds: ["biome", "eslint", "prettier"],
     },
   ],
 };

package/extensions/{format/runners/biome-check-write.ts → formatter/runners/biome.ts}

@@ -1,11 +1,11 @@
-import { defineRunner, direct } from "./helpers.js";
 import { BIOME_CONFIG_PATTERNS } from "./config-patterns.js";
+import { defineRunner, direct } from "./helpers.js";
 
-const biomeCheckWriteRunner = defineRunner({
-  id: "biome-check-write",
+const biomeRunner = defineRunner({
+  id: "biome",
   launcher: direct("biome"),
   when: (ctx) => ctx.hasConfig(BIOME_CONFIG_PATTERNS),
   args: ["check", "--write"],
 });
 
-export default biomeCheckWriteRunner;
+export default biomeRunner;

package/extensions/formatter/runners/config-patterns.ts

@@ -0,0 +1,5 @@
+export const BIOME_CONFIG_PATTERNS = ["biome.json", "biome.jsonc"] as const;
+export const ESLINT_CONFIG_PATTERNS = [
+  "eslint.config.*",
+  ".eslintrc*",
+] as const;

package/extensions/{format/runners/eslint-fix.ts → formatter/runners/eslint.ts}

@@ -1,11 +1,11 @@
 import { ESLINT_CONFIG_PATTERNS } from "./config-patterns.js";
 import { defineRunner, direct } from "./helpers.js";
 
-const eslintFixRunner = defineRunner({
-  id: "eslint-fix",
+const eslintRunner = defineRunner({
+  id: "eslint",
   launcher: direct("eslint"),
   when: (ctx) => ctx.hasConfig(ESLINT_CONFIG_PATTERNS),
   args: ["--fix"],
 });
 
-export default eslintFixRunner;
+export default eslintRunner;

package/extensions/{format → formatter}/runners/index.ts

@@ -1,26 +1,24 @@
 import type { RunnerDefinition } from "../types.js";
-import biomeCheckWriteRunner from "./biome-check-write.js";
+import biomeRunner from "./biome.js";
 import clangFormatRunner from "./clang-format.js";
 import cmakeFormatRunner from "./cmake-format.js";
-import eslintFixRunner from "./eslint-fix.js";
-import markdownlintFixRunner from "./markdownlint-fix.js";
-import prettierConfigWriteRunner from "./prettier-config-write.js";
-import prettierMarkdownRunner from "./prettier-markdown.js";
-import ruffCheckFixRunner from "./ruff-check-fix.js";
+import eslintRunner from "./eslint.js";
+import markdownlintRunner from "./markdownlint.js";
+import prettierRunner from "./prettier.js";
+import ruffCheckRunner from "./ruff-check.js";
 import ruffFormatRunner from "./ruff-format.js";
 import shfmtRunner from "./shfmt.js";
 
 export const RUNNER_DEFINITIONS: RunnerDefinition[] = [
   clangFormatRunner,
   cmakeFormatRunner,
-  markdownlintFixRunner,
-  prettierMarkdownRunner,
-  biomeCheckWriteRunner,
-  eslintFixRunner,
-  prettierConfigWriteRunner,
+  markdownlintRunner,
+  biomeRunner,
+  eslintRunner,
+  prettierRunner,
   shfmtRunner,
   ruffFormatRunner,
-  ruffCheckFixRunner,
+  ruffCheckRunner,
 ];
 
 function buildRunnerRegistry(

package/extensions/{format/runners/markdownlint-fix.ts → formatter/runners/markdownlint.ts}

@@ -1,9 +1,9 @@
 import { defineRunner, direct } from "./helpers.js";
 
-const markdownlintFixRunner = defineRunner({
-  id: "markdownlint-fix",
+const markdownlintRunner = defineRunner({
+  id: "markdownlint",
   launcher: direct("markdownlint"),
   args: ["--fix"],
 });
 
-export default markdownlintFixRunner;
+export default markdownlintRunner;

package/extensions/{format/runners/prettier-markdown.ts → formatter/runners/prettier.ts}

@@ -1,9 +1,9 @@
 import { defineRunner, direct } from "./helpers.js";
 
-const prettierMarkdownRunner = defineRunner({
-  id: "prettier-markdown",
+const prettierRunner = defineRunner({
+  id: "prettier",
   launcher: direct("prettier"),
   args: ["--write"],
 });
 
-export default prettierMarkdownRunner;
+export default prettierRunner;

package/extensions/{format/runners/ruff-check-fix.ts → formatter/runners/ruff-check.ts}

@@ -1,9 +1,9 @@
 import { defineRunner, pypi } from "./helpers.js";
 
-const ruffCheckFixRunner = defineRunner({
-  id: "ruff-check-fix",
+const ruffCheckRunner = defineRunner({
+  id: "ruff-check",
   launcher: pypi("ruff"),
   args: ["check", "--fix"],
 });
 
-export default ruffCheckFixRunner;
+export default ruffCheckRunner;

package/extensions/{format → formatter}/types.ts

@@ -1,7 +1,5 @@
 import type { ExecResult } from "@mariozechner/pi-coding-agent";
 
-export type SourceTool = "write" | "edit";
-
 export type FileKind =
   | "cxx"
   | "cmake"
@@ -40,7 +38,6 @@ export interface ResolvedLauncher {
 export interface RunnerContext {
   readonly filePath: string;
   readonly cwd: string;
-  readonly sourceTool: SourceTool;
   readonly kind: FileKind;
 
   hasCommand(command: string): Promise<boolean>;
@@ -48,7 +45,7 @@ export interface RunnerContext {
   findConfigFile(patterns: readonly string[]): Promise<string | undefined>;
   hasEditorConfigInCwd(): Promise<boolean>;
 
-  exec(command: string, args: string[]): Promise<ExecResult | undefined>;
+  exec(command: string, args: string[]): Promise<ExecResult>;
   getChangedLines(): Promise<string[]>;
   getRequiredMajorVersionFromConfig(
     patterns: readonly string[],
@@ -94,8 +91,9 @@ export interface StaticRunnerDefinition extends RunnerBase {
 }
 
 export interface DynamicRunnerDefinition extends RunnerBase {
-  buildArgs:
-    (ctx: RunnerContext) => Promise<string[] | undefined> | string[] | undefined;
+  buildArgs: (
+    ctx: RunnerContext,
+  ) => Promise<string[] | undefined> | string[] | undefined;
 }
 
 export type RunnerDefinition = StaticRunnerDefinition | DynamicRunnerDefinition;

package/extensions/index.ts

@@ -1,15 +1,112 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { commandTimeoutMs } from "./format/config.js";
-import { formatFile } from "./format/dispatch.js";
-import { pathExists, resolveToolPath } from "./format/path.js";
-import type { SourceTool } from "./format/types.js";
+import { basename } from "node:path";
+import {
+  type ExtensionAPI,
+  getSettingsListTheme,
+  isEditToolResult,
+  isWriteToolResult,
+} from "@mariozechner/pi-coding-agent";
+import { Container, type SettingItem, SettingsList, Text } from "@mariozechner/pi-tui";
+import {
+  cloneFormatterConfig,
+  type FormatterConfigSnapshot,
+  getFormatterConfigPath,
+  loadFormatterConfig,
+  writeFormatterConfigSnapshot,
+} from "./formatter/config.js";
+import { type FormatCallSummary, formatFile } from "./formatter/dispatch.js";
+import {
+  getPathForGit,
+  pathExists,
+  resolveToolPath,
+} from "./formatter/path.js";
 
 function formatError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function formatSummaryPath(filePath: string, cwd: string): string {
+  const pathForDisplay = getPathForGit(filePath, cwd);
+  return pathForDisplay.startsWith("/")
+    ? basename(pathForDisplay)
+    : pathForDisplay;
+}
+
+function formatCallSuccessSummary(summary: FormatCallSummary): string {
+  return `✔︎ ${summary.runnerId}`;
+}
+
+function formatCallFailureSummary(summary: FormatCallSummary): string {
+  if (summary.failureMessage) {
+    return `✘ ${summary.runnerId}: ${summary.failureMessage}`;
+  }
+
+  if (summary.exitCode !== undefined) {
+    return `✘ ${summary.runnerId} (exit ${summary.exitCode})`;
+  }
+
+  return `✘ ${summary.runnerId}`;
+}
+
+function resolveEventPath(rawPath: unknown, cwd: string): string | undefined {
+  if (typeof rawPath !== "string" || rawPath.length === 0) {
+    return undefined;
+  }
+
+  return resolveToolPath(rawPath, cwd);
+}
+
+function getFormatterSettingItems(
+  config: FormatterConfigSnapshot,
+): SettingItem[] {
+  const timeoutValues = ["2000", "5000", "10000", "30000", "60000"];
+
+  if (!timeoutValues.includes(String(config.commandTimeoutMs))) {
+    timeoutValues.push(String(config.commandTimeoutMs));
+    timeoutValues.sort(
+      (a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10),
+    );
+  }
+
+  return [
+    {
+      id: "formatMode",
+      label: "Format mode",
+      description:
+        "Choose whether formatting runs after each successful write/edit tool call or once after the agent stops.",
+      currentValue: config.formatMode,
+      values: ["afterEachToolCall", "afterAgentStop"],
+    },
+    {
+      id: "formatOnAbort",
+      label: "Format on abort",
+      description:
+        "When enabled, deferred formatting also runs if the model is interrupted or cancelled.",
+      currentValue: config.formatOnAbort ? "on" : "off",
+      values: ["off", "on"],
+    },
+    {
+      id: "commandTimeoutMs",
+      label: "Command timeout",
+      description: "Maximum runtime per formatter command in milliseconds.",
+      currentValue: String(config.commandTimeoutMs),
+      values: timeoutValues,
+    },
+    {
+      id: "hideCallSummariesInTui",
+      label: "Hide TUI summaries",
+      description:
+        "Hide per-run formatter pass/fail summaries in the interactive UI.",
+      currentValue: config.hideCallSummariesInTui ? "on" : "off",
+      values: ["off", "on"],
+    },
+  ];
+}
+
 export default function (pi: ExtensionAPI) {
+  let formatterConfig = loadFormatterConfig();
   const formatQueueByPath = new Map<string, Promise<void>>();
+  const candidatePaths = new Set<string>();
+  const successfulPaths = new Set<string>();
 
   const enqueueFormat = async (
     filePath: string,
@@ -31,8 +128,87 @@ export default function (pi: ExtensionAPI) {
     await next;
   };
 
-  pi.on("tool_result", async (event, ctx) => {
-    if (event.isError) {
+  const formatResolvedPath = async (
+    filePath: string,
+    ctx: {
+      cwd: string;
+      hasUI: boolean;
+      ui: {
+        notify(message: string, level: "info" | "warning" | "error"): void;
+      };
+    },
+  ): Promise<void> => {
+    if (!(await pathExists(filePath))) {
+      return;
+    }
+
+    const showSummaries = !formatterConfig.hideCallSummariesInTui && ctx.hasUI;
+    const notifyWarning = (message: string) => {
+      const normalizedMessage = message.replace(/\s+/g, " ").trim();
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(normalizedMessage, "warning");
+        return;
+      }
+
+      console.warn(normalizedMessage);
+    };
+
+    await enqueueFormat(filePath, async () => {
+      const summaries: FormatCallSummary[] = [];
+      const summaryReporter = showSummaries
+        ? (summary: FormatCallSummary) => {
+            summaries.push(summary);
+          }
+        : undefined;
+
+      const runnerWarningReporter =
+        showSummaries && ctx.hasUI
+          ? () => {
+              // Summary mode already reports failures compactly.
+            }
+          : notifyWarning;
+
+      try {
+        await formatFile(
+          pi,
+          ctx.cwd,
+          filePath,
+          formatterConfig.commandTimeoutMs,
+          summaryReporter,
+          runnerWarningReporter,
+        );
+      } catch (error) {
+        const fileLabel = formatSummaryPath(filePath, ctx.cwd);
+        notifyWarning(`Failed to format ${fileLabel}: ${formatError(error)}`);
+      }
+
+      if (!showSummaries || summaries.length === 0) {
+        return;
+      }
+
+      for (const summary of summaries) {
+        if (summary.status === "succeeded") {
+          ctx.ui.notify(formatCallSuccessSummary(summary), "info");
+          continue;
+        }
+
+        ctx.ui.notify(formatCallFailureSummary(summary), "info");
+      }
+    });
+  };
+
+  const reloadFormatterConfig = () => {
+    formatterConfig = loadFormatterConfig();
+  };
+
+  pi.on("agent_start", async () => {
+    candidatePaths.clear();
+    successfulPaths.clear();
+  });
+
+  pi.on("tool_call", async (event, ctx) => {
+    if (formatterConfig.formatMode !== "afterAgentStop") {
       return;
     }
 
@@ -40,26 +216,162 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    const rawPath = (event.input as { path?: unknown }).path;
-    if (typeof rawPath !== "string" || rawPath.length === 0) {
+    const filePath = resolveEventPath(event.input.path, ctx.cwd);
+    if (filePath) {
+      candidatePaths.add(filePath);
+    }
+  });
+
+  pi.on("tool_result", async (event, ctx) => {
+    if (!isWriteToolResult(event) && !isEditToolResult(event)) {
+      return;
+    }
+
+    const filePath = resolveEventPath(event.input.path, ctx.cwd);
+    if (!filePath) {
       return;
     }
 
-    const sourceTool = event.toolName as SourceTool;
-    const filePath = resolveToolPath(rawPath, ctx.cwd);
+    if (!event.isError) {
+      successfulPaths.add(filePath);
+    }
 
-    if (!(await pathExists(filePath))) {
+    if (formatterConfig.formatMode !== "afterEachToolCall" || event.isError) {
       return;
     }
 
-    await enqueueFormat(filePath, async () => {
-      try {
-        await formatFile(pi, ctx.cwd, sourceTool, filePath, commandTimeoutMs);
-      } catch (error) {
-        console.warn(
-          `[pi-formatter] Failed to format ${filePath}: ${formatError(error)}`,
-        );
+    await formatResolvedPath(filePath, ctx);
+  });
+
+  pi.on("agent_end", async (event, ctx) => {
+    if (formatterConfig.formatMode !== "afterAgentStop") {
+      candidatePaths.clear();
+      successfulPaths.clear();
+      return;
+    }
+
+    let lastAssistantStopReason: string | undefined;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message.role !== "assistant") {
+        continue;
       }
-    });
+
+      lastAssistantStopReason = message.stopReason;
+      break;
+    }
+
+    const pathsToFormat = new Set<string>();
+    if (lastAssistantStopReason === "aborted") {
+      if (formatterConfig.formatOnAbort) {
+        for (const filePath of candidatePaths) {
+          pathsToFormat.add(filePath);
+        }
+        for (const filePath of successfulPaths) {
+          pathsToFormat.add(filePath);
+        }
+      }
+    } else {
+      for (const filePath of successfulPaths) {
+        pathsToFormat.add(filePath);
+      }
+    }
+
+    candidatePaths.clear();
+    successfulPaths.clear();
+
+    for (const filePath of pathsToFormat) {
+      await formatResolvedPath(filePath, ctx);
+    }
+  });
+
+  pi.registerCommand("formatter", {
+    description: "Configure formatter behavior.",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        console.warn("/formatter requires interactive UI mode");
+        return;
+      }
+
+      const configPath = getFormatterConfigPath();
+      reloadFormatterConfig();
+      const draft = cloneFormatterConfig(formatterConfig);
+
+      await ctx.ui.custom((tui, theme, _kb, done) => {
+        const container = new Container();
+        container.addChild(
+          new Text(theme.fg("accent", theme.bold("Formatter Settings")), 1, 0),
+        );
+        container.addChild(new Text(theme.fg("dim", configPath), 1, 0));
+        container.addChild(new Text("", 0, 0));
+
+        const syncDraftToSettingsList = (settingsList: SettingsList) => {
+          settingsList.updateValue("formatMode", draft.formatMode);
+          settingsList.updateValue(
+            "formatOnAbort",
+            draft.formatOnAbort ? "on" : "off",
+          );
+          settingsList.updateValue(
+            "commandTimeoutMs",
+            String(draft.commandTimeoutMs),
+          );
+          settingsList.updateValue(
+            "hideCallSummariesInTui",
+            draft.hideCallSummariesInTui ? "on" : "off",
+          );
+        };
+
+        const settingsList = new SettingsList(
+          getFormatterSettingItems(draft),
+          8,
+          getSettingsListTheme(),
+          (id, newValue) => {
+            const previous = cloneFormatterConfig(draft);
+
+            if (id === "formatMode") {
+              draft.formatMode = newValue as FormatterConfigSnapshot["formatMode"];
+            } else if (id === "formatOnAbort") {
+              draft.formatOnAbort = newValue === "on";
+            } else if (id === "commandTimeoutMs") {
+              draft.commandTimeoutMs = Number.parseInt(newValue, 10);
+            } else if (id === "hideCallSummariesInTui") {
+              draft.hideCallSummariesInTui = newValue === "on";
+            }
+
+            try {
+              writeFormatterConfigSnapshot(draft);
+              reloadFormatterConfig();
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              draft.commandTimeoutMs = previous.commandTimeoutMs;
+              draft.hideCallSummariesInTui = previous.hideCallSummariesInTui;
+              draft.formatMode = previous.formatMode;
+              draft.formatOnAbort = previous.formatOnAbort;
+              syncDraftToSettingsList(settingsList);
+              ctx.ui.notify(`Failed to save config: ${message}`, "error");
+            }
+          },
+          () => {
+            done(undefined);
+          },
+        );
+
+        container.addChild(settingsList);
+
+        return {
+          render(width: number) {
+            return container.render(width);
+          },
+          invalidate() {
+            container.invalidate();
+          },
+          handleInput(data: string) {
+            settingsList.handleInput?.(data);
+            tui.requestRender();
+          },
+        };
+      });
+    },
   });
 }

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "pi-formatter",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Pi extension that auto-formats files after write/edit tool calls.",
   "type": "module",
   "files": [
     "extensions",
-    "DOCUMENTATION.md",
     "README.md",
     "LICENSE"
   ],