pi-formatter 1.0.1 → 1.1.0

package/README.md

@@ -34,7 +34,7 @@ Formatting modes:
   Use this mode when you want the fewest interruptions and are okay with
   formatting only when the session ends.
 
-Supported file types:
+Built-in supported file types:
 
 - C/C++
 - CMake
@@ -47,6 +47,22 @@ Supported file types:
 For JS/TS and JSON, project-configured tools are preferred first (Biome,
 ESLint), with Prettier as a fallback.
 
+When a project contains `treefmt.toml` or `.treefmt.toml` and `treefmt` is
+installed, `pi-formatter` prefers `treefmt` before the built-in file-type
+runners. This can add support for additional file types declared in the
+project's treefmt config. If treefmt reports that no formatter matches a path,
+`pi-formatter` falls back to the built-in runners.
+
+For flake-based `treefmt-nix` setups, `pi-formatter` detects flake roots that
+contain `treefmt.nix` or `nix/treefmt.nix` and then tries `nix fmt -- <path>`
+before falling back to the built-in runners. These `nix fmt` calls are run with
+`--no-update-lock-file` and `--no-write-lock-file` so formatting does not
+rewrite flake lock files.
+
+When multiple project formatter configs apply, `pi-formatter` uses the nearest
+config root. If `treefmt` and `treefmt-nix` share the same root, `treefmt-nix`
+is tried first.
+
 ## 🎮 Commands
 
 - `/formatter`: open the interactive formatter settings editor and save changes

package/extensions/formatter/context.ts

@@ -27,7 +27,7 @@ function getPatternRegex(pattern: string): RegExp {
   return regex;
 }
 
-async function findConfigFileFromPath(
+export async function findConfigFileFromPath(
   filePath: string,
   patterns: readonly string[],
   rootDirectory: string,

package/extensions/formatter/dispatch.ts

@@ -1,8 +1,18 @@
+import { dirname, join } from "node:path";
 import type { ExecResult, ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { FormatRunContext, type FormatWarningReporter } from "./context.js";
-import { detectFileKind } from "./path.js";
+import {
+  FormatRunContext,
+  type FormatWarningReporter,
+  findConfigFileFromPath,
+} from "./context.js";
+import {
+  detectFileKind,
+  getRelativePathOrAbsolute,
+  pathExists,
+} from "./path.js";
 import { FORMAT_PLAN } from "./plan.js";
 import { RUNNERS } from "./runners/index.js";
+import { hasCommand } from "./system.js";
 import {
   isDynamicRunner,
   type ResolvedLauncher,
@@ -12,6 +22,23 @@ import {
   type RunnerLauncher,
 } from "./types.js";
 
+const TREEFMT_CONFIG_PATTERNS = ["treefmt.toml", ".treefmt.toml"] as const;
+const TREEFMT_NIX_CONFIG_PATTERNS = ["treefmt.nix", "nix/treefmt.nix"] as const;
+const FLAKE_CONFIG_PATTERNS = ["flake.nix"] as const;
+
+type ProjectFormatterCandidate =
+  | {
+      kind: "treefmt";
+      runnerId: "treefmt";
+      rootPath: string;
+      configPath: string;
+    }
+  | {
+      kind: "treefmt-nix";
+      runnerId: "treefmt-nix";
+      rootPath: string;
+    };
+
 async function resolveLauncher(
   launcher: RunnerLauncher,
   ctx: RunnerContext,
@@ -172,6 +199,315 @@ function summarizeFailureMessage(result: ExecResult): string | undefined {
     : `${message.slice(0, MAX_FAILURE_MESSAGE_LENGTH - 1)}…`;
 }
 
+function isTreefmtUnmatchedPathFailure(result: ExecResult): boolean {
+  return /\bno formatter for path:/i.test(`${result.stderr}\n${result.stdout}`);
+}
+
+function shouldFallbackFromTreefmtNixFailure(result: ExecResult): boolean {
+  const output = `${result.stderr}\n${result.stdout}`;
+  return (
+    /cannot connect to socket at '.*daemon-socket\/socket'/i.test(output) ||
+    /Refusing to evaluate package .* because it is not available on the requested hostPlatform/i.test(
+      output,
+    ) ||
+    /failed to create walker: error resolving path/i.test(output) ||
+    /\bpath .* not inside the tree root\b/i.test(output)
+  );
+}
+
+async function findConfigFileAtRoot(
+  rootPath: string,
+  patterns: readonly string[],
+): Promise<string | undefined> {
+  for (const pattern of patterns) {
+    const candidatePath = join(rootPath, pattern);
+    if (await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  return undefined;
+}
+
+async function resolveTreefmtCandidate(
+  filePath: string,
+  cwd: string,
+): Promise<ProjectFormatterCandidate | undefined> {
+  const configPath = await findConfigFileFromPath(
+    filePath,
+    TREEFMT_CONFIG_PATTERNS,
+    cwd,
+  );
+
+  if (!configPath) {
+    return undefined;
+  }
+
+  return {
+    kind: "treefmt",
+    runnerId: "treefmt",
+    rootPath: dirname(configPath),
+    configPath,
+  };
+}
+
+async function resolveTreefmtNixCandidate(
+  filePath: string,
+  cwd: string,
+): Promise<ProjectFormatterCandidate | undefined> {
+  const flakePath = await findConfigFileFromPath(
+    filePath,
+    FLAKE_CONFIG_PATTERNS,
+    cwd,
+  );
+
+  if (!flakePath) {
+    return undefined;
+  }
+
+  const flakeRoot = dirname(flakePath);
+  const configPath = await findConfigFileAtRoot(
+    flakeRoot,
+    TREEFMT_NIX_CONFIG_PATTERNS,
+  );
+
+  if (!configPath) {
+    return undefined;
+  }
+
+  return {
+    kind: "treefmt-nix",
+    runnerId: "treefmt-nix",
+    rootPath: flakeRoot,
+  };
+}
+
+function compareProjectFormatterCandidates(
+  a: ProjectFormatterCandidate,
+  b: ProjectFormatterCandidate,
+): number {
+  const rootPathLengthDifference = b.rootPath.length - a.rootPath.length;
+  if (rootPathLengthDifference !== 0) {
+    return rootPathLengthDifference;
+  }
+
+  if (a.kind === b.kind) {
+    return 0;
+  }
+
+  return a.kind === "treefmt-nix" ? -1 : 1;
+}
+
+async function resolveProjectFormatterCandidates(
+  filePath: string,
+  cwd: string,
+): Promise<ProjectFormatterCandidate[]> {
+  const candidates = [
+    await resolveTreefmtCandidate(filePath, cwd),
+    await resolveTreefmtNixCandidate(filePath, cwd),
+  ].filter(
+    (candidate): candidate is ProjectFormatterCandidate => candidate !== undefined,
+  );
+
+  return candidates.sort(compareProjectFormatterCandidates);
+}
+
+function reportProjectFormatterFailure(
+  runnerId: string,
+  result: ExecResult,
+  summaryReporter?: FormatCallSummaryReporter,
+  warningReporter?: FormatWarningReporter,
+): void {
+  const failureMessage = summarizeFailureMessage(result);
+  summaryReporter?.({
+    runnerId,
+    status: "failed",
+    exitCode: result.code,
+    failureMessage,
+  });
+
+  const warningMessage = `${runnerId} failed (${result.code})${
+    failureMessage ? `: ${failureMessage}` : ""
+  }`;
+  if (warningReporter) {
+    warningReporter(warningMessage);
+  } else {
+    console.warn(warningMessage);
+  }
+}
+
+function reportProjectFormatterFallback(
+  runnerId: string,
+  result: ExecResult,
+  warningReporter?: FormatWarningReporter,
+): void {
+  const failureMessage = summarizeFailureMessage(result);
+  const warningMessage = `${runnerId} unavailable, falling back to other formatters${
+    failureMessage ? `: ${failureMessage}` : ""
+  }`;
+
+  if (warningReporter) {
+    warningReporter(warningMessage);
+    return;
+  }
+
+  console.warn(warningMessage);
+}
+
+async function executeTreefmtCandidate(
+  pi: ExtensionAPI,
+  candidate: Extract<ProjectFormatterCandidate, { kind: "treefmt" }>,
+  cwd: string,
+  filePath: string,
+  timeoutMs: number,
+  summaryReporter?: FormatCallSummaryReporter,
+  warningReporter?: FormatWarningReporter,
+): Promise<RunnerOutcome> {
+  if (!(await hasCommand("treefmt"))) {
+    return "skipped";
+  }
+
+  const targetPath = getRelativePathOrAbsolute(filePath, cwd);
+  const result = await pi.exec(
+    "treefmt",
+    [
+      "--quiet",
+      "--no-cache",
+      "--on-unmatched",
+      "fatal",
+      "--config-file",
+      candidate.configPath,
+      targetPath,
+    ],
+    {
+      cwd,
+      timeout: timeoutMs,
+    },
+  );
+
+  if (result.code === 0) {
+    summaryReporter?.({
+      runnerId: candidate.runnerId,
+      status: "succeeded",
+    });
+    return "succeeded";
+  }
+
+  // Treefmt currently reports excluded files as "no formatter for path" too, so
+  // we cannot distinguish an explicit exclude from a genuinely unmatched path
+  // here. In both cases, fall back to the built-in per-language runners.
+  if (isTreefmtUnmatchedPathFailure(result)) {
+    return "skipped";
+  }
+
+  reportProjectFormatterFailure(
+    candidate.runnerId,
+    result,
+    summaryReporter,
+    warningReporter,
+  );
+
+  return "failed";
+}
+
+async function executeTreefmtNixCandidate(
+  pi: ExtensionAPI,
+  candidate: Extract<ProjectFormatterCandidate, { kind: "treefmt-nix" }>,
+  filePath: string,
+  timeoutMs: number,
+  summaryReporter?: FormatCallSummaryReporter,
+  warningReporter?: FormatWarningReporter,
+): Promise<RunnerOutcome> {
+  if (!(await hasCommand("nix"))) {
+    return "skipped";
+  }
+
+  const flakeRoot = candidate.rootPath;
+  const targetPath = getRelativePathOrAbsolute(filePath, flakeRoot);
+  const result = await pi.exec(
+    "nix",
+    [
+      "--extra-experimental-features",
+      "nix-command flakes",
+      "fmt",
+      "--no-update-lock-file",
+      "--no-write-lock-file",
+      "--",
+      targetPath,
+    ],
+    {
+      cwd: flakeRoot,
+      timeout: timeoutMs,
+    },
+  );
+
+  if (result.code === 0) {
+    summaryReporter?.({
+      runnerId: candidate.runnerId,
+      status: "succeeded",
+    });
+    return "succeeded";
+  }
+
+  if (isTreefmtUnmatchedPathFailure(result)) {
+    return "skipped";
+  }
+
+  if (shouldFallbackFromTreefmtNixFailure(result)) {
+    reportProjectFormatterFallback(candidate.runnerId, result, warningReporter);
+    return "skipped";
+  }
+
+  reportProjectFormatterFailure(
+    candidate.runnerId,
+    result,
+    summaryReporter,
+    warningReporter,
+  );
+
+  return "failed";
+}
+
+async function tryProjectFormatters(
+  pi: ExtensionAPI,
+  cwd: string,
+  filePath: string,
+  timeoutMs: number,
+  summaryReporter?: FormatCallSummaryReporter,
+  warningReporter?: FormatWarningReporter,
+): Promise<RunnerOutcome> {
+  for (const candidate of await resolveProjectFormatterCandidates(
+    filePath,
+    cwd,
+  )) {
+    const outcome =
+      candidate.kind === "treefmt"
+        ? await executeTreefmtCandidate(
+            pi,
+            candidate,
+            cwd,
+            filePath,
+            timeoutMs,
+            summaryReporter,
+            warningReporter,
+          )
+        : await executeTreefmtNixCandidate(
+            pi,
+            candidate,
+            filePath,
+            timeoutMs,
+            summaryReporter,
+            warningReporter,
+          );
+
+    if (outcome !== "skipped") {
+      return outcome;
+    }
+  }
+
+  return "skipped";
+}
+
 async function runRunner(
   ctx: RunnerContext,
   runner: RunnerDefinition,
@@ -294,6 +630,19 @@ export async function formatFile(
   summaryReporter?: FormatCallSummaryReporter,
   warningReporter?: FormatWarningReporter,
 ): Promise<void> {
+  if (
+    (await tryProjectFormatters(
+      pi,
+      cwd,
+      filePath,
+      timeoutMs,
+      summaryReporter,
+      warningReporter,
+    )) !== "skipped"
+  ) {
+    return;
+  }
+
   const kind = detectFileKind(filePath);
   if (!kind) {
     return;

package/extensions/index.ts

@@ -135,12 +135,27 @@ export default function (pi: ExtensionAPI) {
     await next;
   };
 
+  const emitSummaryMessages = (
+    messages: string[],
+    ctx: FormatterContext,
+  ): void => {
+    if (
+      !ctx.hasUI ||
+      formatterConfig.hideCallSummariesInTui ||
+      messages.length === 0
+    ) {
+      return;
+    }
+
+    ctx.ui.notify(messages.join("\n"), "info");
+  };
+
   const formatResolvedPath = async (
     filePath: string,
     ctx: FormatterContext,
-  ): Promise<void> => {
+  ): Promise<string[]> => {
     if (!(await pathExists(filePath))) {
-      return;
+      return [];
     }
 
     const showSummaries = !formatterConfig.hideCallSummariesInTui && ctx.hasUI;
@@ -155,6 +170,8 @@ export default function (pi: ExtensionAPI) {
       console.warn(normalizedMessage);
     };
 
+    let summaryMessages: string[] = [];
+
     await enqueueFormat(filePath, async () => {
       const summaries: FormatCallSummary[] = [];
       const summaryReporter = showSummaries
@@ -188,28 +205,37 @@ export default function (pi: ExtensionAPI) {
       }
 
       const fileLabel = getRelativePathOrAbsolute(filePath, ctx.cwd);
-
-      for (const summary of summaries) {
-        ctx.ui.notify(formatCallSummary(summary, fileLabel), "info");
-      }
+      summaryMessages = summaries.map((summary) =>
+        formatCallSummary(summary, fileLabel),
+      );
     });
+
+    return summaryMessages;
   };
 
   const flushPaths = async (
     paths: Set<string>,
     ctx: FormatterContext,
-  ): Promise<void> => {
+  ): Promise<string[]> => {
     const batch = [...paths];
     paths.clear();
 
+    const summaryMessages: string[] = [];
+
     for (const filePath of batch) {
-      await formatResolvedPath(filePath, ctx);
+      summaryMessages.push(...(await formatResolvedPath(filePath, ctx)));
     }
+
+    return summaryMessages;
   };
 
   const flushPendingPaths = async (ctx: FormatterContext): Promise<void> => {
-    await flushPaths(pendingPromptPaths, ctx);
-    await flushPaths(pendingSessionPaths, ctx);
+    const summaryMessages = [
+      ...(await flushPaths(pendingPromptPaths, ctx)),
+      ...(await flushPaths(pendingSessionPaths, ctx)),
+    ];
+
+    emitSummaryMessages(summaryMessages, ctx);
   };
 
   const reloadFormatterConfig = () => {
@@ -231,7 +257,7 @@ export default function (pi: ExtensionAPI) {
     }
 
     if (formatterConfig.formatMode === "tool") {
-      await formatResolvedPath(filePath, ctx);
+      emitSummaryMessages(await formatResolvedPath(filePath, ctx), ctx);
       return;
     }
 
@@ -248,7 +274,7 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    await flushPaths(pendingPromptPaths, ctx);
+    emitSummaryMessages(await flushPaths(pendingPromptPaths, ctx), ctx);
   });
 
   pi.on("session_switch", async (_event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-formatter",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Pi extension that auto-formats files.",
   "type": "module",
   "files": [