pi-formatter 1.0.2 → 1.1.1

package/README.md

@@ -20,6 +20,9 @@ pi install npm:pi-formatter
 `pi-formatter` detects file types and runs the appropriate formatter as
 best-effort post-processing. Formatter failures never block tool results.
 
+Formatting is limited to files inside the current working directory. Paths
+outside the current directory and paths that traverse symlinks are ignored.
+
 Formatting modes:
 
 - `tool`: format immediately after each successful `write` or `edit` tool call.
@@ -34,7 +37,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 +50,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/formatter/path.ts

@@ -1,6 +1,6 @@
-import { access } from "node:fs/promises";
+import { access, lstat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import type { FileKind } from "./types.js";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
@@ -71,6 +71,43 @@ export function getRelativePathOrAbsolute(
   return relPath;
 }
 
+export async function isPathInFormattingScope(
+  filePath: string,
+  cwd: string,
+): Promise<boolean> {
+  const rootPath = resolve(cwd);
+  const candidatePath = resolve(filePath);
+
+  if (!isWithinDirectory(candidatePath, rootPath)) {
+    return false;
+  }
+
+  const relPath = relative(rootPath, candidatePath);
+  if (!relPath || relPath === ".") {
+    return false;
+  }
+
+  let currentPath = rootPath;
+
+  for (const segment of relPath.split(sep)) {
+    if (segment.length === 0 || segment === ".") {
+      continue;
+    }
+
+    currentPath = join(currentPath, segment);
+
+    try {
+      if ((await lstat(currentPath)).isSymbolicLink()) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 export function detectFileKind(filePath: string): FileKind | undefined {
   if (
     /(\.(c|h|cc|hh|cpp|hpp|cxx|hxx|ixx|ipp|inl|tpp)|\.(c|h|cc|hh|cpp|hpp|cxx|hxx)\.in)$/i.test(

package/extensions/index.ts

@@ -20,7 +20,7 @@ import {
 import { type FormatCallSummary, formatFile } from "./formatter/dispatch.js";
 import {
   getRelativePathOrAbsolute,
-  pathExists,
+  isPathInFormattingScope,
   resolveToolPath,
 } from "./formatter/path.js";
 
@@ -154,7 +154,7 @@ export default function (pi: ExtensionAPI) {
     filePath: string,
     ctx: FormatterContext,
   ): Promise<string[]> => {
-    if (!(await pathExists(filePath))) {
+    if (!(await isPathInFormattingScope(filePath, ctx.cwd))) {
       return [];
     }
 
@@ -252,7 +252,7 @@ export default function (pi: ExtensionAPI) {
     }
 
     const filePath = resolveEventPath(event.input.path, ctx.cwd);
-    if (!filePath) {
+    if (!filePath || !(await isPathInFormattingScope(filePath, ctx.cwd))) {
       return;
     }
 

package/package.json

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