@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/formatters.js

@@ -0,0 +1,1351 @@
+import { logExtension } from "./extension-log.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { BoundedLruCache } from "./bounded-cache.js";
+import { createGenerationSource } from "./generation-guard.js";
+import { findNearestContaining, normalizeMapKey } from "./path-utils.js";
+import { resolveToolCwd } from "./tool-cwd.js";
+import { resolveCargoPackageEdition } from "./cargo-manifest.js";
+import { resolveKtfmtGradleStyle } from "./gradle-ktfmt-style.js";
+import { resolvePhpCsFixerConfig } from "./php-cs-fixer-config.js";
+import { TERRAGRUNT_FILENAMES } from "./file-kinds.js";
+import { stripAnsi } from "./sanitize.js";
+import { detectIndentation, hasDetectableIndentation } from "./dispatch/indent-detect.js";
+import { logLatency } from "./latency-logger.js";
+import { compareOrdinal } from "./string-utils.js";
+import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler } from "./dispatch/runners/utils/availability-policy.js";
+import { findGlobalBinary, findLocalBinUpwards, VENDOR_BIN_DIRS, VENV_BIN_DIRS } from "./package-manager.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { establishToolAgreement } from "./tool-agreement.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { probeToolAsync } from "./tool-probe.js";
+import { assertInstallAllowed } from "./project-trust.js";
+import { tryLazyInstallForFormatter } from "./dispatch/runners/utils/lazy-installer.js";
+import { getToolPath } from "./installer/index.js";
+import { findPSScriptAnalyzerConfigPath, getAutoInstallToolIdForFormatter, getFormatterPolicyForFile, getSmartDefaultFormatterName, hasBiomeConfig, hasBlackConfig, hasClangFormatConfig, hasCljfmtConfig, hasCmakeFormatConfig, hasCsharpierConfig, hasFantomasConfig, hasGoogleJavaFormatConfig, hasKtfmtConfig, hasKtlintConfig, hasMixFormatConfig, hasNearestPackageJsonDependency, hasNearestPackageJsonField, hasOcamlformatConfig, hasOrmoluConfig, hasOxfmtConfig, hasOxfmtSvelteConfig, hasPhpCsFixerConfig, hasPrettierConfig, hasPSScriptAnalyzerConfig, hasRubocopConfig, hasRuffConfig, hasSqlfluffConfig, hasStandardrbConfig, hasStyluaConfig, hasSwiftformatConfig, hasTaploConfig, hasTerraformConfig, hasVitePlusConfig, OXFMT_SUPPORTED_EXTENSIONS } from "./tool-policy.js";
+export async function tryLazyInstallFormatterTool(tool, cwd) {
+  const ok = await tryLazyInstallForFormatter(tool, cwd);
+  if (ok)
+    resetWhichLatches();
+  return ok;
+}
+export const SKIP_FORMATTING = "skip-formatting";
+export const FORMATTER_UNAVAILABLE = "formatter-unavailable";
+export const FORMATTER_AGREEMENT_UNAVAILABLE = "formatter-agreement-unavailable";
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findUp(targets, startDir, stopDir = path.parse(startDir).root) {
+  const found = [];
+  let currentDir = startDir;
+  while (currentDir !== stopDir) {
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir);
+    } catch {
+      entries = [];
+    }
+    if (entries.length > 0) {
+      const foldCase = process.platform === "win32" || process.platform === "darwin";
+      const entrySet = new Set(foldCase ? entries.map((e) => e.toLowerCase()) : entries);
+      for (const target of targets) {
+        if (target.includes("/") || target.includes("\\"))
+          continue;
+        if (entrySet.has(foldCase ? target.toLowerCase() : target)) {
+          const candidate = path.join(currentDir, target);
+          if (await fileExists(candidate))
+            found.push(candidate);
+        }
+      }
+    }
+    for (const target of targets) {
+      if (!target.includes("/") && !target.includes("\\"))
+        continue;
+      const candidate = path.join(currentDir, target);
+      if (await fileExists(candidate))
+        found.push(candidate);
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  return found;
+}
+export function _findUpForTests(targets, startDir, stopDir) {
+  return findUp(targets, startDir, stopDir);
+}
+const WHICH_BUDGET_MS = 5000;
+const whichLatchByCommand = new Map;
+const whichTransientCommands = new Set;
+const probedCommandsStorage = new AsyncLocalStorage;
+async function detectCandidate(formatter, cwd) {
+  const probed = new Set;
+  let detected = false;
+  let error;
+  try {
+    detected = await probedCommandsStorage.run(probed, () => formatter.detect(cwd));
+  } catch (err) {
+    error = err;
+  }
+  const stalledCommands = [...probed].filter((command) => whichTransientCommands.has(command));
+  return {
+    detected,
+    ...error !== undefined && { error },
+    outcome: {
+      name: formatter.name,
+      verdict: detected ? "available" : stalledCommands.length > 0 ? "unreachable" : "missing",
+      stalledCommands
+    }
+  };
+}
+function resetWhichLatches() {
+  whichLatchByCommand.clear();
+  whichTransientCommands.clear();
+  cooldownRecordedForRetryAtMs.clear();
+}
+const cooldownRecordedForRetryAtMs = new Map;
+function noteCooldownServedVerdict(command, latch) {
+  if (latch.getOutcome() !== "transient")
+    return;
+  const retryAtMs = latch.getRetryAtMs();
+  if (retryAtMs <= 0)
+    return;
+  if (cooldownRecordedForRetryAtMs.get(command) === retryAtMs)
+    return;
+  cooldownRecordedForRetryAtMs.set(command, retryAtMs);
+  const cause = latch.getCause();
+  if (cause === null) {
+    logExtension({
+      subsystem: "format",
+      message: `which latch: transient outcome with no cause for ${command}; cooldown-served record dropped`,
+      metadata: { tool: command, retryAtMs }
+    });
+    return;
+  }
+  logAvailabilityDecision({
+    tool: command,
+    verdict: "unavailable",
+    outcome: "transient",
+    cause,
+    elapsedMs: 0,
+    latched: false,
+    retryAfterMs: Math.max(1, retryAtMs - Date.now()),
+    budgetMs: WHICH_BUDGET_MS,
+    servedFromCooldown: true,
+    classifiedBy: "caller"
+  });
+}
+async function which(command) {
+  probedCommandsStorage.getStore()?.add(command);
+  let entry = whichLatchByCommand.get(command);
+  if (!entry) {
+    entry = { latch: createAvailabilityLatch(), resolved: null };
+    whichLatchByCommand.set(command, entry);
+  }
+  const memo = entry.latch.read();
+  if (memo !== null) {
+    if (!memo)
+      noteCooldownServedVerdict(command, entry.latch);
+    return memo ? entry.resolved : null;
+  }
+  const stallSampler = startHostStallSampler();
+  const startedAt = Date.now();
+  const result = await safeSpawnAsync(process.platform === "win32" ? "where" : "which", [command], { timeout: WHICH_BUDGET_MS });
+  const hostStallMs = stallSampler.stop();
+  const elapsedMs = Date.now() - startedAt;
+  const resolved = !result.error && result.status === 0 ? result.stdout?.trim().split(/\r?\n/)[0] ?? null : null;
+  if (resolved) {
+    entry.resolved = resolved;
+    entry.latch.noteAvailable();
+    whichTransientCommands.delete(command);
+    cooldownRecordedForRetryAtMs.delete(command);
+    logAvailabilityDecision({
+      tool: command,
+      verdict: "available",
+      outcome: "success",
+      cause: "ok",
+      elapsedMs,
+      latched: true,
+      hostStallMs,
+      budgetMs: WHICH_BUDGET_MS,
+      classifiedBy: "probe"
+    });
+    return resolved;
+  }
+  entry.resolved = null;
+  const proberRan = !result.error;
+  const classified = classifyProbeFailure(result, {
+    hostStallMs,
+    ...proberRan && { unclassifiedFailureOutcome: "missing" }
+  });
+  let { outcome, cause } = classified;
+  let outcomeForced = false;
+  if (!proberRan && outcome !== "transient") {
+    outcome = "transient";
+    cause = "probe-rejected";
+    outcomeForced = true;
+  }
+  const retryAfterMs = entry.latch.noteUnavailable(outcome, cause);
+  if (outcome === "transient")
+    whichTransientCommands.add(command);
+  else
+    whichTransientCommands.delete(command);
+  cooldownRecordedForRetryAtMs.delete(command);
+  logAvailabilityDecision({
+    tool: command,
+    verdict: "unavailable",
+    outcome,
+    cause,
+    elapsedMs,
+    latched: retryAfterMs === 0,
+    hostStallMs,
+    ...retryAfterMs > 0 && { retryAfterMs },
+    budgetMs: WHICH_BUDGET_MS,
+    classifiedBy: outcomeForced ? "caller" : "probe"
+  });
+  return null;
+}
+async function resolveGoFmtBinary() {
+  const inPath = await which("gofmt");
+  if (inPath)
+    return inPath;
+  const goCheck = await probeToolAsync("go", ["env", "GOROOT"], {
+    timeout: 5000
+  });
+  if (goCheck.error || goCheck.status !== 0)
+    return null;
+  const goroot = (goCheck.stdout ?? "").trim();
+  if (!goroot)
+    return null;
+  const binary = path.join(goroot, "bin", process.platform === "win32" ? "gofmt.exe" : "gofmt");
+  return await fileExists(binary) ? binary : null;
+}
+async function findInVenv(binary, cwd) {
+  return findLocalBinUpwards(binary, cwd, {
+    windowsExt: ".exe",
+    binDirs: VENV_BIN_DIRS
+  }) ?? null;
+}
+async function findInVendorBin(binary, cwd) {
+  return findLocalBinUpwards(binary, cwd, {
+    windowsExt: ".bat",
+    binDirs: VENDOR_BIN_DIRS
+  }) ?? null;
+}
+async function findInNodeModules(binary, cwd) {
+  return findLocalBinUpwards(binary, cwd) ?? null;
+}
+async function canUseBundleExec(cwd) {
+  if (await which("bundle") === null)
+    return false;
+  const lockfiles = await findUp(["Gemfile.lock"], cwd);
+  return lockfiles.length > 0;
+}
+async function resolveManagedSmartDefaultCommand(formatterName, filePath, args) {
+  const toolId = getAutoInstallToolIdForFormatter(formatterName);
+  if (!toolId)
+    return FORMATTER_UNAVAILABLE;
+  const { ensureTool } = await import("./installer/index.js");
+  const installed = await ensureTool(toolId);
+  if (!installed) {
+    recordDegradationOnce({
+      kind: "formatter-unavailable",
+      subject: formatterName,
+      reason: "managed formatter lookup and installation returned no executable"
+    });
+    return FORMATTER_UNAVAILABLE;
+  }
+  return [installed, ...args, filePath];
+}
+async function resolveManagedFormatterCommand(toolId, filePath, args, findLocal, cwd) {
+  const local = findLocal && cwd ? await findLocal(toolId, cwd) : null;
+  const installed = local ?? await which(toolId) ?? await getToolPath(toolId);
+  return installed ? [installed, ...args, filePath] : FORMATTER_UNAVAILABLE;
+}
+function managedFormatterResolver(toolId, args, findLocal) {
+  return (filePath, cwd) => resolveManagedFormatterCommand(toolId, filePath, args, findLocal, cwd);
+}
+function managedToolDetect(toolId, configDetect, nativeDetect) {
+  return async (cwd) => {
+    const available = nativeDetect && await nativeDetect(cwd) || Boolean(await getToolPath(toolId));
+    return available && (configDetect ? await configDetect(cwd) : true);
+  };
+}
+const EXPLICIT_FORMATTER_CONFIG_CHECKS = new Map([
+  ["biome", (cwd) => hasBiomeConfig(cwd)],
+  [
+    "prettier",
+    (cwd) => hasPrettierConfig(cwd) || hasNearestPackageJsonField(cwd, "prettier")
+  ],
+  [
+    "oxfmt",
+    (cwd, ext) => ext === ".svelte" ? hasOxfmtSvelteConfig(cwd) : hasOxfmtConfig(cwd) || hasVitePlusConfig(cwd) || hasNearestPackageJsonDependency(cwd, "oxfmt") || hasNearestPackageJsonDependency(cwd, "@oxc-project/oxfmt")
+  ],
+  ["ruff", (cwd) => hasRuffConfig(cwd)],
+  ["black", (cwd) => hasBlackConfig(cwd)],
+  ["sqlfluff", (cwd) => hasSqlfluffConfig(cwd)],
+  ["rubocop", (cwd) => hasRubocopConfig(cwd)],
+  ["standardrb", (cwd) => hasStandardrbConfig(cwd)],
+  ["clang-format", (cwd) => hasClangFormatConfig(cwd)],
+  ["php-cs-fixer", (cwd) => hasPhpCsFixerConfig(cwd)],
+  ["stylua", (cwd) => hasStyluaConfig(cwd)],
+  ["ocamlformat", (cwd) => hasOcamlformatConfig(cwd)],
+  ["google-java-format", (cwd) => hasGoogleJavaFormatConfig(cwd)],
+  ["ktfmt", (cwd) => hasKtfmtConfig(cwd)],
+  ["ktlint", (cwd) => hasKtlintConfig(cwd)],
+  ["cljfmt", (cwd) => hasCljfmtConfig(cwd)],
+  ["cmake-format", (cwd) => hasCmakeFormatConfig(cwd)],
+  ["psscriptanalyzer-format", (cwd) => hasPSScriptAnalyzerConfig(cwd)],
+  ["csharpier", (cwd) => hasCsharpierConfig(cwd)],
+  ["ormolu", (cwd) => hasOrmoluConfig(cwd)],
+  ["taplo", (cwd) => hasTaploConfig(cwd)],
+  ["terraform", (cwd) => hasTerraformConfig(cwd)],
+  ["swiftformat", (cwd) => hasSwiftformatConfig(cwd)],
+  ["fantomas", (cwd) => hasFantomasConfig(cwd)],
+  ["mix", (cwd) => hasMixFormatConfig(cwd)]
+]);
+function hasExplicitFormatterConfig(formatterName, cwd, ext) {
+  return EXPLICIT_FORMATTER_CONFIG_CHECKS.get(formatterName)?.(cwd, ext) ?? false;
+}
+export const FORMATTERS_WITH_EXPLICIT_CONFIG_CHECK = new Set(EXPLICIT_FORMATTER_CONFIG_CHECKS.keys());
+async function hasEditorConfig(cwd) {
+  return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
+}
+async function indentationArgs(filePath, tool, cwd) {
+  if (await hasEditorConfig(cwd) || hasExplicitFormatterConfig(tool, cwd, path.extname(filePath))) {
+    return [];
+  }
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  if (!hasDetectableIndentation(content))
+    return null;
+  const indentation = detectIndentation(content);
+  if (!indentation) {
+    recordDegradationOnce({
+      kind: "formatter-skip",
+      subject: tool,
+      reason: "indentation evidence is ambiguous; formatter style not pinned"
+    });
+    return null;
+  }
+  if (tool === "shfmt")
+    return indentation.style === "tab" ? ["-i", "0"] : ["-i", String(indentation.width)];
+  if (tool === "prettier") {
+    return [
+      indentation.style === "tab" ? "--use-tabs" : "--no-use-tabs",
+      "--tab-width",
+      String(indentation.width)
+    ];
+  }
+  if (tool === "ruff") {
+    return [
+      "--config",
+      `indent-width=${indentation.width}`,
+      "--config",
+      `format.indent-style='${indentation.style}'`
+    ];
+  }
+  return [
+    "--indent-style",
+    indentation.style,
+    "--indent-width",
+    String(indentation.width)
+  ];
+}
+export function resolveFormatterCwd(absolutePath, formatterName, homeDir = os.homedir()) {
+  return resolveToolCwd("formatter", formatterName ?? "unknown", absolutePath, {
+    cwd: path.parse(path.resolve(absolutePath)).root,
+    homeDir
+  }).cwd;
+}
+const BIOME_UNMATCHED_FLAG = "--no-errors-on-unmatched";
+export const biomeFormatter = {
+  name: "biome",
+  command: [
+    "npx",
+    "@biomejs/biome",
+    "format",
+    "--write",
+    BIOME_UNMATCHED_FLAG,
+    "$FILE"
+  ],
+  async resolveCommand(filePath, cwd) {
+    const editorConfigFlag = await hasEditorConfig(cwd) ? ["--use-editorconfig=true"] : [];
+    const styleArgs = await indentationArgs(filePath, "biome", cwd);
+    if (styleArgs === null)
+      return SKIP_FORMATTING;
+    const args = [
+      "format",
+      "--write",
+      BIOME_UNMATCHED_FLAG,
+      ...editorConfigFlag,
+      ...styleArgs
+    ];
+    const local = await findInNodeModules("biome", cwd);
+    if (local)
+      return [local, ...args, filePath];
+    const global = await findGlobalBinary("biome");
+    if (global)
+      return [global, ...args, filePath];
+    const toolId = getAutoInstallToolIdForFormatter("biome");
+    if (!toolId)
+      return null;
+    const { ensureTool } = await import("./installer/index.js");
+    const installed = await ensureTool(toolId);
+    if (installed)
+      return [installed, ...args, filePath];
+    return null;
+  },
+  extensions: [
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".json",
+    ".jsonc",
+    ".css",
+    ".scss",
+    ".sass",
+    ".vue",
+    ".svelte",
+    ".html",
+    ".htm"
+  ],
+  async detect(cwd) {
+    return hasBiomeConfig(cwd) || hasNearestPackageJsonDependency(cwd, "@biomejs/biome");
+  }
+};
+export const prettierFormatter = {
+  name: "prettier",
+  command: ["npx", "prettier", "--write", "$FILE"],
+  async resolveCommand(filePath, cwd) {
+    const styleArgs = await indentationArgs(filePath, "prettier", cwd);
+    if (styleArgs === null)
+      return SKIP_FORMATTING;
+    const args = ["--write", ...styleArgs];
+    const local = await findInNodeModules("prettier", cwd);
+    if (local)
+      return [local, ...args, filePath];
+    const global = await findGlobalBinary("prettier");
+    if (global)
+      return [global, ...args, filePath];
+    return resolveManagedSmartDefaultCommand("prettier", filePath, args);
+  },
+  extensions: [
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".json",
+    ".jsonc",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".vue",
+    ".svelte",
+    ".html",
+    ".htm",
+    ".md",
+    ".mdx",
+    ".yaml",
+    ".yml",
+    ".graphql",
+    ".gql"
+  ],
+  async detect(cwd) {
+    return hasPrettierConfig(cwd) || hasNearestPackageJsonDependency(cwd, "prettier") || hasNearestPackageJsonField(cwd, "prettier");
+  }
+};
+const OXFMT_NO_ERROR_ON_UNMATCHED = "--no-error-on-unmatched-pattern";
+export const oxfmtFormatter = {
+  name: "oxfmt",
+  command: ["oxfmt", OXFMT_NO_ERROR_ON_UNMATCHED, "$FILE"],
+  async resolveCommand(filePath, cwd) {
+    if (hasVitePlusConfig(cwd)) {
+      const localVp = await findInNodeModules("vp", cwd);
+      if (localVp)
+        return [localVp, "fmt", filePath, "--write"];
+      const globalVp = await which("vp");
+      if (globalVp)
+        return [globalVp, "fmt", filePath, "--write"];
+    }
+    const local = await findInNodeModules("oxfmt", cwd);
+    if (local)
+      return [local, OXFMT_NO_ERROR_ON_UNMATCHED, filePath];
+    const found = await which("oxfmt");
+    if (found)
+      return [found, OXFMT_NO_ERROR_ON_UNMATCHED, filePath];
+    return await resolveManagedFormatterCommand("oxfmt", filePath, [OXFMT_NO_ERROR_ON_UNMATCHED], findInNodeModules, cwd) ?? FORMATTER_UNAVAILABLE;
+  },
+  extensions: [...OXFMT_SUPPORTED_EXTENSIONS],
+  async detect(cwd) {
+    return hasOxfmtConfig(cwd) || hasVitePlusConfig(cwd) || hasNearestPackageJsonDependency(cwd, "oxfmt") || hasNearestPackageJsonDependency(cwd, "@oxc-project/oxfmt");
+  }
+};
+export const ruffFormatter = {
+  name: "ruff",
+  command: ["ruff", "format", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async resolveCommand(filePath, cwd) {
+    const styleArgs = await indentationArgs(filePath, "ruff", cwd);
+    if (styleArgs === null)
+      return SKIP_FORMATTING;
+    const args = ["format", ...styleArgs];
+    const venv = await findInVenv("ruff", cwd);
+    if (venv)
+      return [venv, ...args, filePath];
+    const toolId = getAutoInstallToolIdForFormatter("ruff");
+    if (!toolId)
+      return null;
+    const { ensureTool } = await import("./installer/index.js");
+    const installed = await ensureTool(toolId);
+    if (installed)
+      return [installed, ...args, filePath];
+    return FORMATTER_UNAVAILABLE;
+  },
+  async detect(cwd) {
+    if (hasRuffConfig(cwd))
+      return true;
+    return Boolean(await getToolPath("ruff"));
+  }
+};
+export const blackFormatter = {
+  name: "black",
+  command: ["black", "$FILE"],
+  extensions: [".py", ".pyi"],
+  resolveCommand: managedFormatterResolver("black", [], findInVenv),
+  async detect(cwd) {
+    return hasBlackConfig(cwd);
+  }
+};
+export const sqlfluffFormatter = {
+  name: "sqlfluff",
+  command: ["sqlfluff", "fix", "--force", "$FILE"],
+  extensions: [".sql"],
+  lenientExitCode: "lint-autofix: `sqlfluff fix` writes the corrected file and then exits 1 when unfixable violations remain (its documented exit codes are 0 = all clean, 1 = violations remain, 2 = command/config failure), so a nonzero exit routinely accompanies a successful rewrite.",
+  lenientStatuses: [1],
+  async resolveCommand(filePath, cwd) {
+    const venv = await findInVenv("sqlfluff", cwd);
+    if (venv)
+      return [venv, "fix", "--force", filePath];
+    return null;
+  },
+  async detect(cwd) {
+    return hasSqlfluffConfig(cwd);
+  }
+};
+export const gofmtFormatter = {
+  name: "gofmt",
+  command: ["gofmt", "-w", "$FILE"],
+  extensions: [".go"],
+  async resolveCommand(filePath, _cwd) {
+    const gofmtBinary = await resolveGoFmtBinary();
+    if (!gofmtBinary)
+      return null;
+    return [gofmtBinary, "-w", filePath];
+  },
+  async detect(_cwd) {
+    return await resolveGoFmtBinary() !== null;
+  }
+};
+export const rustfmtFormatter = {
+  name: "rustfmt",
+  command: ["rustfmt", "$FILE"],
+  extensions: [".rs"],
+  async resolveCommand(filePath, _cwd) {
+    const edition = await resolveCargoPackageEdition(filePath);
+    if (edition === undefined)
+      return null;
+    return ["rustfmt", "--edition", edition, filePath];
+  },
+  async detect(cwd) {
+    if (await which("rustfmt") !== null)
+      return true;
+    const rustProject = (await findUp(["Cargo.toml"], cwd)).length > 0;
+    if (!rustProject)
+      return false;
+    if (await which("rustup") === null)
+      return false;
+    await tryLazyInstallFormatterTool("rustfmt", cwd);
+    return await which("rustfmt") !== null;
+  }
+};
+export const zigFormatter = {
+  name: "zig",
+  command: ["zig", "fmt", "$FILE"],
+  extensions: [".zig", ".zon"],
+  async detect(_cwd) {
+    return await which("zig") !== null;
+  }
+};
+export const dartFormatter = {
+  name: "dart",
+  command: ["dart", "format", "$FILE"],
+  extensions: [".dart"],
+  async detect(_cwd) {
+    return await which("dart") !== null;
+  }
+};
+export const shfmtFormatter = {
+  name: "shfmt",
+  command: ["shfmt", "-w", "$FILE"],
+  extensions: [".sh", ".bash"],
+  async resolveCommand(filePath, cwd) {
+    const styleArgs = await indentationArgs(filePath, "shfmt", cwd);
+    if (styleArgs === null)
+      return SKIP_FORMATTING;
+    const inPath = await which("shfmt");
+    if (inPath)
+      return [inPath, "-w", ...styleArgs, filePath];
+    return resolveManagedSmartDefaultCommand("shfmt", filePath, [
+      "-w",
+      ...styleArgs
+    ]);
+  },
+  detect: managedToolDetect("shfmt", undefined, async () => await which("shfmt") !== null)
+};
+export const nixfmtFormatter = {
+  name: "nixfmt",
+  command: ["nixfmt", "$FILE"],
+  extensions: [".nix"],
+  async detect(_cwd) {
+    return await which("nixfmt") !== null;
+  }
+};
+export const mixFormatter = {
+  name: "mix",
+  command: ["mix", "format", "$FILE"],
+  extensions: [".ex", ".exs", ".eex", ".heex", ".leex"],
+  async detect(_cwd) {
+    return await which("mix") !== null;
+  }
+};
+export const ocamlformatFormatter = {
+  name: "ocamlformat",
+  command: ["ocamlformat", "-i", "$FILE"],
+  extensions: [".ml", ".mli"],
+  async detect(cwd) {
+    const hasBinary = await which("ocamlformat") !== null;
+    if (!hasBinary)
+      return false;
+    const configs = [".ocamlformat"];
+    const found = await findUp(configs, cwd);
+    return found.length > 0;
+  }
+};
+export const clangFormatFormatter = {
+  name: "clang-format",
+  command: ["clang-format", "-i", "$FILE"],
+  extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".ino"],
+  async detect(cwd) {
+    const hasBinary = await which("clang-format") !== null;
+    if (!hasBinary)
+      return false;
+    const configs = [".clang-format", "_clang-format"];
+    const found = await findUp(configs, cwd);
+    return found.length > 0;
+  }
+};
+export const ktlintFormatter = {
+  name: "ktlint",
+  command: ["ktlint", "-F", "$FILE"],
+  extensions: [".kt", ".kts"],
+  lenientExitCode: "lint-autofix: `ktlint -F` autocorrects what it can and then exits 1 if " + "any lint error remains unfixed — the documented CLI contract (ktlint " + "exits nonzero whenever violations are reported, and -F does not suppress the ones it cannot correct).",
+  lenientStatuses: [1],
+  async resolveCommand(filePath, _cwd) {
+    const inPath = await which("ktlint");
+    if (inPath)
+      return [inPath, "-F", filePath];
+    return resolveManagedSmartDefaultCommand("ktlint", filePath, ["-F"]);
+  },
+  detect: managedToolDetect("ktlint", undefined, async () => await which("ktlint") !== null)
+};
+export const ktfmtFormatter = {
+  name: "ktfmt",
+  command: ["ktfmt", "$FILE"],
+  extensions: [".kt", ".kts"],
+  async resolveCommand(filePath, _cwd) {
+    const styleFlag = await resolveKtfmtGradleStyle(filePath);
+    const inPath = await which("ktfmt");
+    if (inPath)
+      return styleFlag ? [inPath, styleFlag, filePath] : [inPath, filePath];
+    const { ensureTool } = await import("./installer/index.js");
+    const installed = await ensureTool("ktfmt");
+    if (!installed)
+      return FORMATTER_UNAVAILABLE;
+    return styleFlag ? [installed, styleFlag, filePath] : [installed, filePath];
+  },
+  async detect(cwd) {
+    return hasKtfmtConfig(cwd);
+  }
+};
+export const rubocopFormatter = {
+  name: "rubocop",
+  command: ["rubocop", "-a", "--no-color", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  lenientExitCode: "lint-autofix: `rubocop -a` exits 1 whenever ANY offense remains after it has already rewritten the file. Verified locally (rubocop on Ruby 3.4): a file with an unfixable Lint/UselessAssignment exits 1, and even a " + "tidy file exits 1 on an unfixable Style/Documentation offense — nonzero " + "is the normal outcome, not a failure.",
+  lenientStatuses: [1],
+  async resolveCommand(filePath, cwd) {
+    if (await canUseBundleExec(cwd))
+      return ["bundle", "exec", "rubocop", "-a", "--no-color", filePath];
+    return null;
+  },
+  async detect(cwd) {
+    if (!hasRubocopConfig(cwd))
+      return false;
+    if (await which("rubocop") !== null)
+      return true;
+    await tryLazyInstallFormatterTool("rubocop", cwd);
+    return await which("rubocop") !== null;
+  }
+};
+export const standardrbFormatter = {
+  name: "standardrb",
+  command: ["standardrb", "--fix", "$FILE"],
+  extensions: [".rb", ".rake"],
+  lenientExitCode: "lint-autofix: standardrb is a RuboCop wrapper and inherits its exit " + "contract — `--fix` exits 1 when offenses remain after the rewrite.",
+  lenientStatuses: [1],
+  async resolveCommand(filePath, cwd) {
+    if (await canUseBundleExec(cwd))
+      return ["bundle", "exec", "standardrb", "--fix", filePath];
+    return null;
+  },
+  async detect(cwd) {
+    if (!hasStandardrbConfig(cwd))
+      return false;
+    return await which("standardrb") !== null;
+  }
+};
+export const gleamFormatter = {
+  name: "gleam",
+  command: ["gleam", "format", "$FILE"],
+  extensions: [".gleam"],
+  async detect(cwd) {
+    const found = await findUp(["gleam.toml"], cwd);
+    if (found.length > 0)
+      return await which("gleam") !== null;
+    return false;
+  }
+};
+export const typstyleFormatter = {
+  name: "typstyle",
+  command: ["typstyle", "-i", "$FILE"],
+  extensions: [".typ", ".typc"],
+  async resolveCommand(filePath) {
+    const inPath = await which("typstyle");
+    if (inPath)
+      return [inPath, "-i", filePath];
+    return resolveManagedSmartDefaultCommand("typstyle", filePath, ["-i"]);
+  },
+  detect: managedToolDetect("typstyle", undefined, async () => await which("typstyle") !== null)
+};
+export const terraformFormatter = {
+  name: "terraform",
+  command: ["terraform", "fmt", "$FILE"],
+  extensions: [".tf", ".tfvars"],
+  async detect(_cwd) {
+    return await which("terraform") !== null;
+  }
+};
+export const terragruntHclFormatter = {
+  name: "terragrunt-hcl",
+  command: ["terragrunt", "hcl", "fmt", "--file", "$FILE"],
+  extensions: [],
+  filenames: TERRAGRUNT_FILENAMES,
+  async detect(_cwd) {
+    return await which("terragrunt") !== null;
+  }
+};
+export const phpCsFixerFormatter = {
+  name: "php-cs-fixer",
+  command: ["php-cs-fixer", "fix", "$FILE"],
+  extensions: [".php"],
+  async resolveCommand(filePath, cwd) {
+    const configPath = resolvePhpCsFixerConfig(filePath);
+    const binary = await findInVendorBin("php-cs-fixer", cwd) ?? await which("php-cs-fixer");
+    const managed = await resolveManagedFormatterCommand("php-cs-fixer", filePath, [], findInVendorBin, cwd);
+    if (managed === FORMATTER_UNAVAILABLE)
+      return FORMATTER_UNAVAILABLE;
+    const resolved = binary ?? managed[0];
+    if (!resolved)
+      return FORMATTER_UNAVAILABLE;
+    return configPath ? [resolved, "fix", "--config", configPath, filePath] : [resolved, "fix", filePath];
+  },
+  detect: managedToolDetect("php-cs-fixer", async (cwd) => (await findUp([".php-cs-fixer.php", ".php-cs-fixer.dist.php"], cwd)).length > 0, async (cwd) => Boolean(await findInVendorBin("php-cs-fixer", cwd) || await which("php-cs-fixer")))
+};
+export const csharpierFormatter = {
+  name: "csharpier",
+  command: ["csharpier", "format", "$FILE"],
+  extensions: [".cs"],
+  async resolveCommand(filePath, _cwd) {
+    if (await which("csharpier") !== null) {
+      return ["csharpier", "format", filePath];
+    }
+    if (await which("dotnet") !== null) {
+      const legacy = await probeToolAsync("dotnet", ["csharpier", "--version"], { timeout: 5000 });
+      if (!legacy.error && legacy.status === 0) {
+        return ["dotnet", "csharpier", filePath];
+      }
+    }
+    return null;
+  },
+  async detect(_cwd) {
+    if (await which("csharpier") !== null)
+      return true;
+    if (await which("dotnet") === null)
+      return false;
+    const result = await probeToolAsync("dotnet", ["csharpier", "--version"], {
+      timeout: 5000
+    });
+    return !result.error && result.status === 0;
+  }
+};
+export const fantomasFormatter = {
+  name: "fantomas",
+  command: ["fantomas", "$FILE"],
+  extensions: [".fs", ".fsi", ".fsx"],
+  async detect(_cwd) {
+    return await which("fantomas") !== null;
+  }
+};
+export const swiftformatFormatter = {
+  name: "swiftformat",
+  command: ["swiftformat", "$FILE"],
+  extensions: [".swift"],
+  async detect(_cwd) {
+    return await which("swiftformat") !== null;
+  }
+};
+export const styluaFormatter = {
+  name: "stylua",
+  command: ["stylua", "$FILE"],
+  extensions: [".lua"],
+  resolveCommand: managedFormatterResolver("stylua", [], findLocalBinUpwards),
+  detect: managedToolDetect("stylua", async (cwd) => (await findUp(["stylua.toml", ".stylua.toml"], cwd)).length > 0, async (cwd) => Boolean(findLocalBinUpwards("stylua", cwd) || await which("stylua")))
+};
+export const ormoluFormatter = {
+  name: "ormolu",
+  command: ["ormolu", "--mode", "inplace", "$FILE"],
+  extensions: [".hs", ".lhs"],
+  async detect(_cwd) {
+    return await which("ormolu") !== null;
+  }
+};
+export const taploFormatter = {
+  name: "taplo",
+  command: ["taplo", "fmt", "$FILE"],
+  extensions: [".toml"],
+  async resolveCommand(filePath, _cwd) {
+    const inPath = await which("taplo");
+    if (inPath)
+      return [inPath, "fmt", filePath];
+    return resolveManagedSmartDefaultCommand("taplo", filePath, ["fmt"]);
+  },
+  detect: managedToolDetect("taplo", undefined, async () => await which("taplo") !== null)
+};
+export const googleJavaFormatFormatter = {
+  name: "google-java-format",
+  command: ["google-java-format", "--replace", "$FILE"],
+  extensions: [".java"],
+  resolveCommand: managedFormatterResolver("google-java-format", ["--replace"]),
+  detect: managedToolDetect("google-java-format", hasGoogleJavaFormatConfig, async () => await which("google-java-format") !== null)
+};
+export const cljfmtFormatter = {
+  name: "cljfmt",
+  command: ["cljfmt", "fix", "$FILE"],
+  extensions: [".clj", ".cljc", ".cljs"],
+  resolveCommand: managedFormatterResolver("cljfmt", ["fix"]),
+  detect: managedToolDetect("cljfmt", hasCljfmtConfig, async () => await which("cljfmt") !== null)
+};
+export const cmakeFormatFormatter = {
+  name: "cmake-format",
+  command: ["cmake-format", "-i", "$FILE"],
+  extensions: [".cmake"],
+  resolveCommand: managedFormatterResolver("cmake-format", ["-i"]),
+  detect: managedToolDetect("cmake-format", hasCmakeFormatConfig, async () => await which("cmake-format") !== null)
+};
+export const cueFormatter = {
+  name: "cue",
+  command: ["cue", "fmt", "$FILE"],
+  extensions: [".cue"],
+  async detect(_cwd) {
+    return await which("cue") !== null;
+  }
+};
+function psScriptAnalyzerCommand(filePath, settingsPath) {
+  const quoted = filePath.replace(/'/g, "''");
+  const settingsArg = settingsPath ? ` -Settings '${settingsPath.replace(/'/g, "''")}'` : "";
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    `$p = '${quoted}'`,
+    "$content = Get-Content -Raw -LiteralPath $p",
+    "if ([string]::IsNullOrWhiteSpace($content)) { exit 0 }",
+    `$formatted = Invoke-Formatter -ScriptDefinition $content${settingsArg}`,
+    "if ($null -eq $formatted) { throw 'Invoke-Formatter returned no output' }",
+    "Set-Content -LiteralPath $p -Value $formatted"
+  ].join("; ");
+}
+export const psscriptanalyzerFormatFormatter = {
+  name: "psscriptanalyzer-format",
+  command: ["pwsh", "-NoProfile", "-Command", psScriptAnalyzerCommand("$FILE")],
+  extensions: [".ps1", ".psm1", ".psd1"],
+  async resolveCommand(filePath, cwd) {
+    const pwsh = await which("pwsh") ?? await which("powershell");
+    if (!pwsh)
+      return null;
+    const settingsPath = findPSScriptAnalyzerConfigPath(cwd);
+    return [
+      pwsh,
+      "-NoProfile",
+      "-Command",
+      psScriptAnalyzerCommand(filePath, settingsPath)
+    ];
+  },
+  async detect(_cwd) {
+    const pwsh = await which("pwsh") ?? await which("powershell");
+    if (!pwsh)
+      return false;
+    const result = await probeToolAsync(pwsh, [
+      "-NoProfile",
+      "-Command",
+      "Get-Module -ListAvailable PSScriptAnalyzer | Select-Object -First 1 -ExpandProperty Name"
+    ], { timeout: 5000 });
+    return (result.stdout ?? "").includes("PSScriptAnalyzer");
+  }
+};
+export const ALL_FORMATTERS = [
+  biomeFormatter,
+  prettierFormatter,
+  oxfmtFormatter,
+  ruffFormatter,
+  blackFormatter,
+  sqlfluffFormatter,
+  gofmtFormatter,
+  rustfmtFormatter,
+  zigFormatter,
+  dartFormatter,
+  shfmtFormatter,
+  nixfmtFormatter,
+  mixFormatter,
+  ocamlformatFormatter,
+  clangFormatFormatter,
+  ktlintFormatter,
+  ktfmtFormatter,
+  terraformFormatter,
+  terragruntHclFormatter,
+  phpCsFixerFormatter,
+  csharpierFormatter,
+  fantomasFormatter,
+  swiftformatFormatter,
+  styluaFormatter,
+  ormoluFormatter,
+  rubocopFormatter,
+  standardrbFormatter,
+  gleamFormatter,
+  typstyleFormatter,
+  taploFormatter,
+  googleJavaFormatFormatter,
+  cljfmtFormatter,
+  cmakeFormatFormatter,
+  cueFormatter,
+  psscriptanalyzerFormatFormatter
+];
+const FILENAME_FORMATTER_BASENAMES = new Set(ALL_FORMATTERS.flatMap((f) => f.filenames ?? []));
+const detectionCache = new BoundedLruCache(32);
+const formatterSignatureFlights = new BoundedLruCache(32);
+const formatterCacheGeneration = createGenerationSource("formatter-cache");
+const FORMATTER_CONFIG_FILES = [
+  "package.json",
+  "biome.json",
+  "biome.jsonc",
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.yml",
+  ".prettierrc.yaml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs",
+  "prettier.config.ts",
+  "pyproject.toml",
+  "ruff.toml",
+  ".ruff.toml",
+  "black.toml",
+  ".black",
+  "tox.ini",
+  "setup.cfg",
+  "requirements.txt",
+  "Pipfile",
+  ".sqlfluff",
+  ".rubocop.yml",
+  ".rubocop.yaml",
+  "Gemfile",
+  ".clang-format",
+  "_clang-format",
+  ".php-cs-fixer.php",
+  ".php-cs-fixer.dist.php",
+  "stylua.toml",
+  ".stylua.toml",
+  ".ocamlformat",
+  ".editorconfig",
+  ".google-java-format",
+  ".ktfmt",
+  ".ktfmt.kts",
+  "build.gradle.kts",
+  "build.gradle",
+  "settings.gradle.kts",
+  "settings.gradle",
+  ".cljfmt.edn",
+  "cljfmt.edn",
+  ".cljfmt",
+  ".cmake-format",
+  ".cmake-format.yaml",
+  ".cmake-format.yml",
+  ".cmake-format.json",
+  ".cmake-format.py",
+  "cmake-format.py",
+  "cmake-format.yaml",
+  "cmake-format.yml",
+  "oxfmt.toml",
+  ".oxfmtrc.json",
+  "vite-plus.json",
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.cts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cjs",
+  "PSScriptAnalyzerSettings.psd1",
+  "ScriptAnalyzerSettings.psd1",
+  ".csharpierrc",
+  ".csharpierrc.json",
+  ".csharpierrc.yaml",
+  ".csharpierrc.yml",
+  ".ormolu",
+  "taplo.toml",
+  ".taplo.toml",
+  ".terraform.lock.hcl",
+  ".swiftformat",
+  ".fantomasignore",
+  ".formatter.exs"
+];
+async function formatterConfigSignature(cwd) {
+  const paths = await findUp(FORMATTER_CONFIG_FILES, cwd);
+  const parts = await Promise.all(paths.sort(compareOrdinal).map(async (filePath) => {
+    try {
+      const stat = await fs.stat(filePath);
+      return `${filePath}:${stat.mtimeMs}:${stat.size}`;
+    } catch {
+      return `${filePath}:missing`;
+    }
+  }));
+  return parts.join("|");
+}
+async function getFormatterConfigSignature(cwd, normalizedCwd) {
+  const existing = formatterSignatureFlights.get(normalizedCwd);
+  if (existing)
+    return existing.promise;
+  const promise = formatterConfigSignature(cwd).finally(() => {
+    const current = formatterSignatureFlights.get(normalizedCwd);
+    if (current?.promise === promise)
+      formatterSignatureFlights.delete(normalizedCwd);
+  });
+  formatterSignatureFlights.set(normalizedCwd, { promise });
+  return promise;
+}
+export async function getFormattersForFile(filePath, cwd) {
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  const normalizedCwd = normalizeMapKey(cwd);
+  const cacheKey = FILENAME_FORMATTER_BASENAMES.has(base) ? `${normalizedCwd}:${ext}:${base}` : `${normalizedCwd}:${ext}`;
+  let cached = detectionCache.get(normalizedCwd);
+  if (cached?.entries.has(cacheKey)) {
+    const enabledNames = cached.entries.get(cacheKey);
+    const selectedFormatterName = enabledNames && enabledNames.length > 0 ? enabledNames[0] : null;
+    logLatency({
+      type: "phase",
+      phase: "formatter_selected",
+      filePath,
+      durationMs: 0,
+      metadata: {
+        formatter: selectedFormatterName,
+        reason: "cache",
+        cached: true,
+        outcome: "hit",
+        cwd
+      }
+    });
+    if (!enabledNames || enabledNames.length === 0)
+      return [];
+    return ALL_FORMATTERS.filter((f) => enabledNames.includes(f.name));
+  }
+  if (!cached) {
+    const generation = formatterCacheGeneration.capture();
+    const configSignature = await getFormatterConfigSignature(cwd, normalizedCwd);
+    if (!generation.isCurrent()) {
+      return getFormattersForFile(filePath, cwd);
+    }
+    cached = detectionCache.get(normalizedCwd);
+    if (!cached) {
+      cached = { signature: configSignature, entries: new Map };
+      detectionCache.set(normalizedCwd, cached);
+    }
+  }
+  const matching = ALL_FORMATTERS.filter((f) => f.extensions.includes(ext) || f.filenames?.includes(base));
+  const formatterPolicy = getFormatterPolicyForFile(filePath);
+  const smartDefaultFormatterName = getSmartDefaultFormatterName(filePath);
+  const candidateFormatters = formatterPolicy?.formatterNames?.length ? matching.filter((f) => formatterPolicy.formatterNames.includes(f.name)) : matching;
+  let selected;
+  const candidateOutcomes = [];
+  if (formatterPolicy) {
+    const explicitlyConfigured = candidateFormatters.filter((formatter) => hasExplicitFormatterConfig(formatter.name, cwd, ext));
+    if (explicitlyConfigured.length > 0) {
+      selected = formatterPolicy.defaultFormatter ? explicitlyConfigured.find((f) => f.name === formatterPolicy.defaultFormatter) ?? explicitlyConfigured[0] : explicitlyConfigured[0];
+    } else if (smartDefaultFormatterName) {
+      const smartDefaultFormatter = candidateFormatters.find((f) => f.name === smartDefaultFormatterName);
+      if (smartDefaultFormatter) {
+        const autoInstallToolId = getAutoInstallToolIdForFormatter(smartDefaultFormatter.name);
+        if (autoInstallToolId) {
+          selected = smartDefaultFormatter;
+        } else {
+          const { detected, error, outcome } = await detectCandidate(smartDefaultFormatter, cwd);
+          candidateOutcomes.push(outcome);
+          if (error !== undefined)
+            throw error;
+          if (detected)
+            selected = smartDefaultFormatter;
+        }
+      }
+    }
+  } else {
+    for (const formatter of candidateFormatters) {
+      const { detected, error, outcome } = await detectCandidate(formatter, cwd);
+      candidateOutcomes.push(outcome);
+      if (error !== undefined) {
+        logExtension({
+          subsystem: "format",
+          message: `Detection failed for ${formatter.name}: ${error instanceof Error ? error.message : String(error)}`,
+          metadata: { formatter: formatter.name, cwd }
+        });
+        continue;
+      }
+      if (detected) {
+        selected = formatter;
+        break;
+      }
+    }
+  }
+  const enabled = selected ? [selected] : [];
+  const stalledCandidateCommands = [
+    ...new Set(candidateOutcomes.flatMap((outcome) => outcome.stalledCommands))
+  ];
+  const poisonedByTransientProbe = enabled.length === 0 && stalledCandidateCommands.length > 0;
+  const winnerIndex = selected ? candidateOutcomes.findIndex((outcome) => outcome.name === selected.name) : -1;
+  const unreachablePreferred = candidateOutcomes.slice(0, winnerIndex === -1 ? 0 : winnerIndex).filter((outcome) => outcome.verdict === "unreachable").map((outcome) => outcome.name);
+  const degradedSelection = unreachablePreferred.length > 0;
+  let selectionReason;
+  if (poisonedByTransientProbe) {
+    selectionReason = "probe-timeout";
+  } else if (degradedSelection) {
+    selectionReason = "preferred-unreachable";
+  } else if (!selected) {
+    selectionReason = "none";
+  } else if (!formatterPolicy) {
+    selectionReason = "detect";
+  } else {
+    selectionReason = candidateFormatters.some((f) => hasExplicitFormatterConfig(f.name, cwd, ext)) ? "explicit-config" : "smart-default";
+  }
+  const provisional = poisonedByTransientProbe || degradedSelection;
+  logLatency({
+    type: "phase",
+    phase: "formatter_selected",
+    filePath,
+    durationMs: 0,
+    metadata: {
+      formatter: selected?.name ?? null,
+      reason: selectionReason,
+      outcome: "miss",
+      cwd,
+      ...provisional && {
+        cached: false,
+        stalledProbes: stalledCandidateCommands
+      },
+      ...degradedSelection && { unreachablePreferred }
+    }
+  });
+  if (provisional)
+    return enabled;
+  const enabledNames = enabled.map((f) => f.name);
+  if (detectionCache.get(normalizedCwd) === cached) {
+    cached.entries.set(cacheKey, enabledNames);
+  }
+  return enabled;
+}
+export function clearFormatterCache() {
+  formatterCacheGeneration.bump();
+  formatterSignatureFlights.clear();
+  detectionCache.clear();
+  resetWhichLatches();
+}
+const formatterConfigBasenames = new Set(FORMATTER_CONFIG_FILES.map((fileName) => fileName.toLowerCase()));
+export function invalidateFormatterCacheForPath(filePath) {
+  const basename = filePath.includes("\\") ? path.win32.basename(filePath) : path.basename(filePath);
+  if (!formatterConfigBasenames.has(basename.toLowerCase()))
+    return;
+  clearFormatterCache();
+}
+export function _getFormatterResetStateForTests() {
+  return {
+    whichLatchByCommand,
+    whichTransientCommands,
+    cooldownRecordedForRetryAtMs,
+    detectionCache,
+    formatterSignatureFlights
+  };
+}
+export function clearFormatterRuntimeState() {
+  clearFormatterCache();
+}
+const BOX_DRAWING_GLOBAL = /[\u2500-\u257F]/g;
+const DECORATION_RULE = /^[\u2500-\u257F\s]*$/;
+const DECORATION_HEADING = /^\S+[ \t]+[\u2500-\u257F][\u2500-\u257F\s]*$/;
+export function firstDiagnosticLine(text) {
+  for (const raw of (text ?? "").split(`
+`)) {
+    const line = stripAnsi(raw).trimEnd();
+    if (isDecorativeLine(line))
+      continue;
+    return line.replace(BOX_DRAWING_GLOBAL, "").trim().slice(0, 300);
+  }
+  return;
+}
+function isDecorativeLine(line) {
+  return DECORATION_RULE.test(line) || DECORATION_HEADING.test(line);
+}
+const FORMATTER_ERROR_TAIL_LINES = 20;
+export function diagnosticTail(text, maxLines = FORMATTER_ERROR_TAIL_LINES) {
+  const lines = [];
+  for (const raw of (text ?? "").split(`
+`)) {
+    const line = stripAnsi(raw).trimEnd();
+    if (isDecorativeLine(line))
+      continue;
+    lines.push(line.slice(0, 300));
+  }
+  if (lines.length === 0)
+    return;
+  return lines.slice(-maxLines).join(`
+`);
+}
+async function resolveFormatterCommand(formatter, absolutePath, cwd) {
+  const agreement = establishToolAgreement(formatter.name, cwd);
+  if (agreement.decision === "decline") {
+    recordDegradationOnce({
+      kind: "formatter-agreement-unavailable",
+      subject: agreement.subject,
+      reason: agreement.reason
+    });
+    return FORMATTER_AGREEMENT_UNAVAILABLE;
+  }
+  const resolved = formatter.resolveCommand ? await formatter.resolveCommand(absolutePath, cwd) : null;
+  if (resolved === SKIP_FORMATTING)
+    return SKIP_FORMATTING;
+  if (resolved === FORMATTER_UNAVAILABLE)
+    return FORMATTER_UNAVAILABLE;
+  if (resolved !== null)
+    return resolved;
+  const fallback = formatter.command.map((c) => c.replace("$FILE", absolutePath));
+  if (fallback[0] === "npx" && !assertInstallAllowed(`formatter npx fallback: ${formatter.name}`)) {
+    return SKIP_FORMATTING;
+  }
+  return fallback;
+}
+export async function formatFile(filePath, formatter) {
+  try {
+    const absolutePath = path.resolve(filePath);
+    const cwd = path.dirname(absolutePath);
+    const formatterCwd = resolveToolCwd("formatter", formatter.name, absolutePath, { cwd: path.parse(absolutePath).root }).cwd;
+    const contentBefore = await fs.readFile(absolutePath, "utf-8");
+    const cmd = await resolveFormatterCommand(formatter, absolutePath, cwd);
+    if (cmd === SKIP_FORMATTING) {
+      return { success: true, changed: false, outcome: "skipped" };
+    }
+    if (cmd === FORMATTER_UNAVAILABLE) {
+      return {
+        success: true,
+        changed: false,
+        outcome: "unavailable",
+        error: `${formatter.name}: formatter executable not found`
+      };
+    }
+    if (cmd === FORMATTER_AGREEMENT_UNAVAILABLE) {
+      return {
+        success: true,
+        changed: false,
+        outcome: "unavailable",
+        error: `${formatter.name}: project tool agreement could not be established`
+      };
+    }
+    const result = await safeSpawnAsync(cmd[0], cmd.slice(1), {
+      timeout: 15000,
+      cwd: formatterCwd
+    });
+    if (result.spawnFailure?.kind === "tool-not-found") {
+      return {
+        success: true,
+        changed: false,
+        outcome: "unavailable",
+        error: result.spawnFailure.message
+      };
+    }
+    const lenientOk = formatter.lenientExitCode !== undefined && result.status !== null && (formatter.lenientStatuses ?? []).includes(result.status);
+    if (result.error || result.status !== 0 && !lenientOk) {
+      return {
+        success: false,
+        changed: false,
+        outcome: "failed",
+        error: result.error?.message || diagnosticTail(result.stderr) || diagnosticTail(result.stdout) || `${formatter.name} exited with status ${result.status}`
+      };
+    }
+    const contentAfter = await fs.readFile(absolutePath, "utf-8");
+    const changed = contentBefore !== contentAfter;
+    return {
+      success: true,
+      changed,
+      outcome: changed ? "formatted" : "unchanged"
+    };
+  } catch (err) {
+    return {
+      success: false,
+      changed: false,
+      outcome: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+export function listAllFormatters() {
+  return ALL_FORMATTERS.map((f) => f.name);
+}