@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/lsp/clients/biome-client.ts

@@ -3,6 +3,7 @@
  * Uses Biome's CLI with JSON output instead of LSP (which has stale diagnostics issues).
  */
 import path from "node:path";
+import { logger } from "@prometheus-ai/utils";
 import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../../lsp/types";
 
 // =============================================================================
@@ -29,17 +30,23 @@ interface BiomeDiagnostic {
 // =============================================================================
 
 /**
- * Convert byte offset to line:column using source code.
+ * Convert byte offsets to line:column positions in a single pass over the source.
  */
-function offsetToPosition(source: string, offset: number): { line: number; column: number } {
+function offsetsToPositions(source: string, offsets: number[]): Map<number, { line: number; column: number }> {
+	const sorted = [...new Set(offsets)].sort((a, b) => a - b);
+	const result = new Map<number, { line: number; column: number }>();
 	let line = 1;
 	let column = 1;
 	let byteIndex = 0;
+	let next = 0;
 
 	for (const ch of source) {
-		const byteLen = Buffer.byteLength(ch);
-		if (byteIndex + byteLen > offset) {
-			break;
+		if (next >= sorted.length) break;
+		const cp = ch.codePointAt(0) as number;
+		const byteLen = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+		while (next < sorted.length && byteIndex + byteLen > sorted[next]) {
+			result.set(sorted[next], { line, column });
+			next++;
 		}
 		if (ch === "\n") {
 			line++;
@@ -50,7 +57,13 @@ function offsetToPosition(source: string, offset: number): { line: number; colum
 		byteIndex += byteLen;
 	}
 
-	return { line, column };
+	// Offsets at or past end-of-file map to the final position.
+	while (next < sorted.length) {
+		result.set(sorted[next], { line, column });
+		next++;
+	}
+
+	return result;
 }
 
 /**
@@ -98,6 +111,16 @@ async function runBiome(
 	}
 }
 
+// Surface broken-binary / CLI failures once instead of silently reporting
+// "no diagnostics" forever (and instead of spamming every writethrough).
+const reportedBiomeFailures = new Set<string>();
+
+function warnBiomeOnce(key: string, message: string, meta: Record<string, unknown>): void {
+	if (reportedBiomeFailures.has(key)) return;
+	reportedBiomeFailures.add(key);
+	logger.warn(message, meta);
+}
+
 // =============================================================================
 // Biome Client
 // =============================================================================
@@ -137,6 +160,16 @@ export class BiomeClient implements LinterClient {
 		// Run biome lint with JSON reporter
 		const result = await runBiome(["lint", "--reporter=json", filePath], this.cwd, this.config.resolvedCommand);
 
+		// Biome exits non-zero when diagnostics are found, so only an empty
+		// stdout signals an actual run failure (missing binary, CLI error).
+		if (!result.success && result.stdout.trim().length === 0) {
+			warnBiomeOnce(`run:${this.cwd}`, "Biome lint failed; reporting no diagnostics", {
+				cwd: this.cwd,
+				stderr: result.stderr.slice(0, 500),
+			});
+			return [];
+		}
+
 		return this.#parseJsonOutput(result.stdout, filePath);
 	}
 
@@ -146,51 +179,80 @@ export class BiomeClient implements LinterClient {
 	#parseJsonOutput(jsonOutput: string, targetFile: string): Diagnostic[] {
 		const diagnostics: Diagnostic[] = [];
 
+		let parsed: BiomeJsonOutput;
 		try {
-			const parsed: BiomeJsonOutput = JSON.parse(jsonOutput);
+			parsed = JSON.parse(jsonOutput);
+		} catch {
+			warnBiomeOnce(`parse:${this.cwd}`, "Failed to parse Biome JSON output; reporting no diagnostics", {
+				cwd: this.cwd,
+				file: targetFile,
+			});
+			return diagnostics;
+		}
 
-			for (const diag of parsed.diagnostics) {
-				const location = diag.location;
-				if (!location?.path?.file) continue;
+		const target = path.resolve(targetFile);
+		const relevant: BiomeDiagnostic[] = [];
+		// Batch all span offsets per source text so each source is scanned once
+		// instead of twice per diagnostic.
+		const offsetsBySource = new Map<string, number[]>();
+		for (const diag of parsed.diagnostics ?? []) {
+			const location = diag.location;
+			if (!location?.path?.file) continue;
 
-				// Resolve file path
-				const diagFile = path.isAbsolute(location.path.file)
-					? location.path.file
-					: path.join(this.cwd, location.path.file);
+			// Resolve file path
+			const diagFile = path.isAbsolute(location.path.file)
+				? location.path.file
+				: path.join(this.cwd, location.path.file);
 
-				// Only include diagnostics for the target file
-				if (path.resolve(diagFile) !== path.resolve(targetFile)) {
-					continue;
-				}
+			// Only include diagnostics for the target file
+			if (path.resolve(diagFile) !== target) {
+				continue;
+			}
+
+			relevant.push(diag);
+			if (location.span && location.sourceCode) {
+				const offsets = offsetsBySource.get(location.sourceCode);
+				if (offsets) offsets.push(location.span[0], location.span[1]);
+				else offsetsBySource.set(location.sourceCode, [location.span[0], location.span[1]]);
+			}
+		}
+
+		const positionsBySource = new Map<string, Map<number, { line: number; column: number }>>();
+		for (const [source, offsets] of offsetsBySource) {
+			positionsBySource.set(source, offsetsToPositions(source, offsets));
+		}
 
-				// Convert byte offset to line:column
-				let startLine = 1;
-				let startColumn = 1;
-				let endLine = 1;
-				let endColumn = 1;
+		for (const diag of relevant) {
+			const location = diag.location;
+			let startLine = 1;
+			let startColumn = 1;
+			let endLine = 1;
+			let endColumn = 1;
 
-				if (location.span && location.sourceCode) {
-					const startPos = offsetToPosition(location.sourceCode, location.span[0]);
-					const endPos = offsetToPosition(location.sourceCode, location.span[1]);
+			if (location?.span && location.sourceCode) {
+				const positions = positionsBySource.get(location.sourceCode);
+				const startPos = positions?.get(location.span[0]);
+				const endPos = positions?.get(location.span[1]);
+				if (startPos) {
 					startLine = startPos.line;
 					startColumn = startPos.column;
+				}
+				if (endPos) {
 					endLine = endPos.line;
 					endColumn = endPos.column;
 				}
-
-				diagnostics.push({
-					range: {
-						start: { line: startLine - 1, character: startColumn - 1 },
-						end: { line: endLine - 1, character: endColumn - 1 },
-					},
-					severity: parseSeverity(diag.severity),
-					message: diag.description,
-					source: "biome",
-					code: diag.category,
-				});
 			}
-		} catch {
-			// JSON parse failed, return empty
+
+			diagnostics.push({
+				range: {
+					start: { line: startLine - 1, character: startColumn - 1 },
+					end: { line: endLine - 1, character: endColumn - 1 },
+				},
+				severity: parseSeverity(diag.severity),
+				message: diag.description,
+				source: "biome",
+				code: diag.category,
+			});
 		}
 
 		return diagnostics;

package/src/lsp/clients/lsp-linter-client.ts

@@ -4,18 +4,10 @@
  */
 import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "../../lsp/client";
 import { applyTextEditsToString } from "../../lsp/edits";
+import { resolveFormatOptions } from "../../lsp/format-options";
 import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "../../lsp/types";
 import { fileToUri } from "../../lsp/utils";
 
-/** Default formatting options for LSP */
-const DEFAULT_FORMAT_OPTIONS = {
-	tabSize: 3,
-	insertSpaces: true,
-	trimTrailingWhitespace: true,
-	insertFinalNewline: true,
-	trimFinalNewlines: true,
-};
-
 /**
  * LSP-based linter client implementation.
  * Wraps the existing LSP client infrastructure.
@@ -56,7 +48,7 @@ export class LspLinterClient implements LinterClient {
 		// Request formatting
 		const edits = (await sendRequest(client, "textDocument/formatting", {
 			textDocument: { uri },
-			options: DEFAULT_FORMAT_OPTIONS,
+			options: resolveFormatOptions(filePath, content),
 		})) as TextEdit[] | null;
 
 		if (!edits || edits.length === 0) {

package/src/lsp/config.ts

@@ -322,7 +322,7 @@ function getConfigSources(cwd: string): ConfigSource[] {
 		sources.push(fileConfigSource(path.join(cwd, filename)));
 	}
 
-	// Project config directories (.prometheus/, .claude/, .codex/, .gemini/)
+	// Project config directories (.prometheus/, .claude/)
 	const projectDirs = getConfigDirPaths("", { user: false, project: true, cwd });
 	for (const dir of projectDirs) {
 		for (const filename of filenames) {
@@ -330,7 +330,7 @@ function getConfigSources(cwd: string): ConfigSource[] {
 		}
 	}
 
-	// User config directories (~/.prometheus/agent/, ~/.claude/, ~/.codex/, ~/.gemini/)
+	// User config directories (~/.prometheus/agent/, ~/.claude/)
 	const userDirs = getConfigDirPaths("", { user: true, project: false });
 	for (const dir of userDirs) {
 		for (const filename of filenames) {
@@ -360,8 +360,8 @@ function getConfigSources(cwd: string): ConfigSource[] {
  *
  * Priority (highest to lowest):
  * 1. Project root: lsp.json/.lsp.json/lsp.yml/.lsp.yml/lsp.yaml/.lsp.yaml
- * 2. Project config dirs: .prometheus/lsp.*, .claude/lsp.*, .codex/lsp.*, .gemini/lsp.* (+ hidden variants)
- * 3. User config dirs: ~/.prometheus/agent/lsp.*, ~/.claude/lsp.*, ~/.codex/lsp.*, ~/.gemini/lsp.* (+ hidden variants)
+ * 2. Project config dirs: .prometheus and .claude LSP config files (+ hidden variants)
+ * 3. User config dirs: ~/.prometheus/agent and ~/.claude LSP config files (+ hidden variants)
  * 4. User home root: ~/lsp.*, ~/.lsp.*
  * 5. Auto-detect from project markers + available binaries
  *
@@ -450,13 +450,23 @@ export function loadConfig(cwd: string): LspConfig {
  */
 export function getServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]> {
 	const ext = path.extname(filePath).toLowerCase();
+	const extNoDot = ext.startsWith(".") ? ext.slice(1) : ext;
 	const fileName = path.basename(filePath).toLowerCase();
 	const matches: Array<[string, ServerConfig]> = [];
 
 	for (const [name, serverConfig] of Object.entries(config.servers)) {
 		const supportsFile = serverConfig.fileTypes.some(fileType => {
+			// Accept both `.ts` and `ts` forms in user config / fixtures so a
+			// missing dot in `fileTypes` doesn't silently exclude the server
+			// from extension-based routing (e.g. rename_file's relevance filter).
 			const normalized = fileType.toLowerCase();
-			return normalized === ext || normalized === fileName;
+			const normalizedNoDot = normalized.startsWith(".") ? normalized.slice(1) : normalized;
+			return (
+				normalized === ext ||
+				normalized === fileName ||
+				normalizedNoDot === extNoDot ||
+				normalizedNoDot === fileName
+			);
 		});
 
 		if (supportsFile) {

package/src/lsp/defaults.json

@@ -248,6 +248,12 @@
 			}
 		}
 	},
+	"expert": {
+		"command": "expert",
+		"args": ["--stdio"],
+		"fileTypes": [".ex", ".exs", ".heex", ".eex"],
+		"rootMarkers": ["mix.exs", "mix.lock"]
+	},
 	"erlangls": {
 		"command": "erlang_ls",
 		"args": [],

package/src/lsp/edits.ts

@@ -24,27 +24,7 @@ import { uriToFile } from "./utils";
  */
 export function applyTextEditsToString(content: string, edits: TextEdit[]): string {
 	const lines = content.split("\n");
-
-	// Sort edits in reverse order (bottom-to-top, right-to-left)
-	const sortedEdits = [...edits].sort((a, b) => {
-		if (a.range.start.line !== b.range.start.line) {
-			return b.range.start.line - a.range.start.line;
-		}
-		return b.range.start.character - a.range.start.character;
-	});
-
-	// Detect overlapping ranges: in reverse-sorted order, each edit's start
-	// must be >= the next edit's end. If not, the edits would clobber each other
-	// once applied bottom-up (typically a multi-server rename with stale positions).
-	for (let i = 0; i < sortedEdits.length - 1; i++) {
-		const later = sortedEdits[i].range;
-		const earlier = sortedEdits[i + 1].range;
-		if (comparePosition(earlier.end, later.start) > 0) {
-			throw new ToolError(
-				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
-			);
-		}
-	}
+	const sortedEdits = sortAndValidateTextEdits(edits);
 
 	for (const edit of sortedEdits) {
 		const { start, end } = edit.range;
@@ -78,6 +58,42 @@ export function rangesOverlap(a: Range, b: Range): boolean {
 	return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
 }
 
+/**
+ * Sort edits bottom-to-top for in-place application and reject overlaps.
+ * Equal start positions tiebreak by original array index descending so that,
+ * applied bottom-up, inserts at the same position land in array order
+ * (LSP spec: the order of edits in the array defines the order in the result).
+ */
+export function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[] {
+	const sorted = edits
+		.map((edit, index) => ({ edit, index }))
+		.sort((a, b) => {
+			if (a.edit.range.start.line !== b.edit.range.start.line) {
+				return b.edit.range.start.line - a.edit.range.start.line;
+			}
+			if (a.edit.range.start.character !== b.edit.range.start.character) {
+				return b.edit.range.start.character - a.edit.range.start.character;
+			}
+			return b.index - a.index;
+		})
+		.map(entry => entry.edit);
+
+	// Detect overlapping ranges: in reverse-sorted order, each edit's start
+	// must be >= the next edit's end. If not, the edits would clobber each other
+	// once applied bottom-up (typically a multi-server rename with stale positions).
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const later = sorted[i].range;
+		const earlier = sorted[i + 1].range;
+		if (comparePosition(earlier.end, later.start) > 0) {
+			throw new ToolError(
+				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
+			);
+		}
+	}
+
+	return sorted;
+}
+
 /**
  * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
  * Resource operations (create/rename/delete) are ignored — callers handle them separately.
@@ -120,92 +136,124 @@ export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promi
 // Workspace Edit Application
 // =============================================================================
 
+type WorkspaceEditOp =
+	| { kind: "text"; uri: string; edits: TextEdit[] }
+	| { kind: "create"; uri: string }
+	| { kind: "rename"; oldUri: string; newUri: string }
+	| { kind: "delete"; uri: string };
+
+/**
+ * Flatten documentChanges into an ordered op list. Text edits are accumulated
+ * per-URI and flushed before any resource op that touches the same URI (or,
+ * for folder rename/delete, any descendant URI) so that renames, creates, and
+ * deletes always see the correct prior file state.
+ */
+function planDocumentChanges(documentChanges: NonNullable<WorkspaceEdit["documentChanges"]>): WorkspaceEditOp[] {
+	const ops: WorkspaceEditOp[] = [];
+	const pending = new Map<string, TextEdit[]>();
+
+	const flushUri = (uri: string) => {
+		const edits = pending.get(uri);
+		if (!edits) return;
+		pending.delete(uri);
+		ops.push({ kind: "text", uri, edits });
+	};
+
+	// Flush the exact URI plus every pending descendant (for folder-level
+	// resource ops where the queued edits target child files of the target).
+	const flushSubtree = (uri: string) => {
+		const prefix = uri.endsWith("/") ? uri : `${uri}/`;
+		const matches: string[] = [];
+		for (const candidate of pending.keys()) {
+			if (candidate === uri || candidate.startsWith(prefix)) matches.push(candidate);
+		}
+		for (const target of matches) {
+			flushUri(target);
+		}
+	};
+
+	for (const change of documentChanges) {
+		if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
+			const tdc = change as TextDocumentEdit;
+			const uri = tdc.textDocument.uri;
+			const textEdits = tdc.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
+			if (textEdits.length > 0) {
+				const prev = pending.get(uri);
+				if (prev) prev.push(...textEdits);
+				else pending.set(uri, [...textEdits]);
+			}
+		} else if ("kind" in change && change.kind) {
+			if (change.kind === "create") {
+				const createOp = change as CreateFile;
+				flushUri(createOp.uri);
+				ops.push({ kind: "create", uri: createOp.uri });
+			} else if (change.kind === "rename") {
+				const renameOp = change as RenameFile;
+				// Per LSP §3.16.2 documentChanges are applied in declared order.
+				// Flush both the source subtree (so prior edits land before the move)
+				// AND the destination subtree (so prior edits land on whatever exists
+				// at newUri before the rename overwrites/replaces it — relevant under
+				// `options.overwrite` and `options.ignoreIfExists`).
+				flushSubtree(renameOp.oldUri);
+				flushSubtree(renameOp.newUri);
+				ops.push({ kind: "rename", oldUri: renameOp.oldUri, newUri: renameOp.newUri });
+			} else if (change.kind === "delete") {
+				const deleteOp = change as DeleteFile;
+				flushSubtree(deleteOp.uri);
+				ops.push({ kind: "delete", uri: deleteOp.uri });
+			}
+		}
+	}
+
+	// Flush text edits not followed by a resource op.
+	for (const uri of [...pending.keys()]) {
+		flushUri(uri);
+	}
+
+	return ops;
+}
+
 /**
  * Apply a workspace edit (collection of file changes).
+ * All text-edit batches are overlap-validated before anything is written so a
+ * conflict throws without leaving the workspace half-applied.
  * Returns array of applied change descriptions.
  */
 export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Promise<string[]> {
 	const applied: string[] = [];
 
 	if (edit.documentChanges) {
-		// Walk documentChanges in original order. Accumulate text edits per-URI and
-		// flush them before any resource op that touches the same URI (or, for folder
-		// rename/delete, any descendant URI) so that renames, creates, and deletes
-		// always see the correct prior file state.
-		const pending = new Map<string, TextEdit[]>();
-
-		const flushUri = async (uri: string) => {
-			const edits = pending.get(uri);
-			if (!edits) return;
-			pending.delete(uri);
-			const filePath = uriToFile(uri);
-			await applyTextEdits(filePath, edits);
-			applied.push(`Applied ${edits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
-		};
-
-		// Flush the exact URI plus every pending descendant (for folder-level
-		// resource ops where the queued edits target child files of the target).
-		const flushSubtree = async (uri: string) => {
-			const prefix = uri.endsWith("/") ? uri : `${uri}/`;
-			const matches: string[] = [];
-			for (const candidate of pending.keys()) {
-				if (candidate === uri || candidate.startsWith(prefix)) matches.push(candidate);
-			}
-			for (const target of matches) {
-				await flushUri(target);
-			}
-		};
-
-		for (const change of edit.documentChanges) {
-			if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
-				const tdc = change as TextDocumentEdit;
-				const uri = tdc.textDocument.uri;
-				const textEdits = tdc.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
-				if (textEdits.length > 0) {
-					const prev = pending.get(uri);
-					if (prev) prev.push(...textEdits);
-					else pending.set(uri, [...textEdits]);
-				}
-			} else if ("kind" in change && change.kind) {
-				if (change.kind === "create") {
-					const createOp = change as CreateFile;
-					await flushUri(createOp.uri);
-					const filePath = uriToFile(createOp.uri);
-					await Bun.write(filePath, "");
-					applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
-				} else if (change.kind === "rename") {
-					const renameOp = change as RenameFile;
-					// Per LSP §3.16.2 documentChanges are applied in declared order.
-					// Flush both the source subtree (so prior edits land before the move)
-					// AND the destination subtree (so prior edits land on whatever exists
-					// at newUri before the rename overwrites/replaces it — relevant under
-					// `options.overwrite` and `options.ignoreIfExists`).
-					await flushSubtree(renameOp.oldUri);
-					await flushSubtree(renameOp.newUri);
-					const oldPath = uriToFile(renameOp.oldUri);
-					const newPath = uriToFile(renameOp.newUri);
-					await fs.mkdir(path.dirname(newPath), { recursive: true });
-					await fs.rename(oldPath, newPath);
-					applied.push(
-						`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`,
-					);
-				} else if (change.kind === "delete") {
-					const deleteOp = change as DeleteFile;
-					await flushSubtree(deleteOp.uri);
-					const filePath = uriToFile(deleteOp.uri);
-					await fs.rm(filePath, { recursive: true });
-					applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
-				}
-			}
+		const ops = planDocumentChanges(edit.documentChanges);
+		for (const op of ops) {
+			if (op.kind === "text") sortAndValidateTextEdits(op.edits);
 		}
-
-		// Flush text edits not followed by a resource op.
-		for (const [uri] of pending) {
-			await flushUri(uri);
+		for (const op of ops) {
+			if (op.kind === "text") {
+				const filePath = uriToFile(op.uri);
+				await applyTextEdits(filePath, op.edits);
+				applied.push(`Applied ${op.edits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
+			} else if (op.kind === "create") {
+				const filePath = uriToFile(op.uri);
+				await Bun.write(filePath, "");
+				applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
+			} else if (op.kind === "rename") {
+				const oldPath = uriToFile(op.oldUri);
+				const newPath = uriToFile(op.newUri);
+				await fs.mkdir(path.dirname(newPath), { recursive: true });
+				await fs.rename(oldPath, newPath);
+				applied.push(`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`);
+			} else {
+				const filePath = uriToFile(op.uri);
+				await fs.rm(filePath, { recursive: true });
+				applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
+			}
 		}
 	} else if (edit.changes) {
-		// Legacy changes-map path: apply all text edits in one pass.
+		// Legacy changes-map path: validate every file's edits before writing any.
 		const changes = edit.changes;
+		for (const uri in changes) {
+			sortAndValidateTextEdits(changes[uri]);
+		}
 		for (const uri in changes) {
 			const textEdits = changes[uri];
 			if (textEdits.length === 0) continue;

package/src/lsp/format-options.ts

@@ -0,0 +1,119 @@
+/**
+ * Per-file LSP `FormattingOptions` resolution.
+ *
+ * Replaces the historical hardcoded `{ tabSize: 3, insertSpaces: true }` default
+ * that fed every `textDocument/formatting` request — it silently re-indented
+ * 2-space YAML (and any LSP-formatted file) on every write/edit (issue #2329).
+ *
+ * Precedence, highest to lowest:
+ *   1. `.editorconfig` in the file's chain (`indent_style`, `indent_size`, `tab_width`).
+ *   2. Indent detected from the file content the agent is about to write.
+ *   3. Hardcoded fallback — 2 spaces, matching the dominant convention for YAML,
+ *      JSON, JS/TS, Python (PEP 8 is 4 but most LSP servers honour their own
+ *      defaults when ours don't disagree), and most config formats. The previous
+ *      `3` default was an unusual stride that actively damaged every file with
+ *      a 2/4-space convention.
+ */
+import { getEditorConfigFormatting } from "@prometheus-ai/utils";
+
+/** Subset of the LSP `FormattingOptions` we send. */
+export interface LspFormattingOptions {
+	tabSize: number;
+	insertSpaces: boolean;
+	trimTrailingWhitespace: boolean;
+	insertFinalNewline: boolean;
+	trimFinalNewlines: boolean;
+}
+
+/** Sensible fallback when neither `.editorconfig` nor file content pins the indent. */
+const FALLBACK_TAB_SIZE = 2;
+const FALLBACK_INSERT_SPACES = true;
+
+/** Static flags we always pass — these have no per-file analogue and match common formatter expectations. */
+const TRIM_OPTIONS = {
+	trimTrailingWhitespace: true,
+	insertFinalNewline: true,
+	trimFinalNewlines: true,
+} as const;
+
+interface DetectedIndent {
+	tabSize?: number;
+	insertSpaces?: boolean;
+}
+
+/**
+ * Sniff `insertSpaces` and the indent unit from `content`.
+ *
+ * Walks the buffer once: the first indented line decides spaces vs tabs; for
+ * space indents, the GCD of all space-indent widths gives the stride (so a
+ * 2/4/6 file reports `2`, a 4/8 file reports `4`). Returns `undefined` for any
+ * field the content does not pin so a higher-precedence override (editorconfig)
+ * can win without being overwritten by sniffing noise.
+ */
+export function detectIndentFromContent(content: string): DetectedIndent {
+	if (content.length === 0) return {};
+
+	let insertSpaces: boolean | undefined;
+	let unit = 0;
+
+	// Split is the cheapest reliable line walk on arbitrary text; the
+	// per-line regex matches are O(leading whitespace) so total cost is
+	// linear in the file's indented prefix bytes.
+	for (const line of content.split("\n")) {
+		// Skip blank/whitespace-only lines — they carry no indent signal.
+		if (line.length === 0 || line.trim().length === 0) continue;
+
+		const first = line[0];
+		if (first !== " " && first !== "\t") continue;
+
+		if (insertSpaces === undefined) {
+			insertSpaces = first === " ";
+		}
+
+		// Tab-indented file: the unit is one tab per level; tabSize is a
+		// display concern, leave it to caller defaults / editorconfig.
+		if (first === "\t") continue;
+
+		// Space-indented: count the leading spaces (stop at first tab to avoid
+		// mixing). GCD across non-zero widths converges on the stride.
+		let n = 0;
+		while (n < line.length && line[n] === " ") n++;
+		if (n === 0) continue;
+		unit = unit === 0 ? n : gcd(unit, n);
+	}
+
+	const result: DetectedIndent = {};
+	if (insertSpaces !== undefined) result.insertSpaces = insertSpaces;
+	if (unit > 0 && insertSpaces === true) result.tabSize = unit;
+	return result;
+}
+
+function gcd(a: number, b: number): number {
+	let x = a;
+	let y = b;
+	while (y !== 0) {
+		const t = y;
+		y = x % y;
+		x = t;
+	}
+	return x;
+}
+
+/**
+ * Resolve the `FormattingOptions` payload for a `textDocument/formatting` request
+ * targeting `filePath` with `content`.
+ *
+ * The two fields that actually affect on-disk bytes (`tabSize`, `insertSpaces`)
+ * are layered: editorconfig wins, then content sniffing, then the fallback.
+ * Trim/final-newline flags are static.
+ */
+export function resolveFormatOptions(filePath: string, content: string): LspFormattingOptions {
+	const fromConfig = getEditorConfigFormatting(filePath);
+	const detected = detectIndentFromContent(content);
+
+	return {
+		tabSize: fromConfig.tabSize ?? detected.tabSize ?? FALLBACK_TAB_SIZE,
+		insertSpaces: fromConfig.insertSpaces ?? detected.insertSpaces ?? FALLBACK_INSERT_SPACES,
+		...TRIM_OPTIONS,
+	};
+}