@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1351 +0,0 @@
-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);
-}