@bdsqqq/pi 0.0.1

package/dist/extensions/edit-file.js

@@ -0,0 +1,395 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { formatBoxesWindowed, osc8Link } from "../core/box-format.js";
+import { withFileLock } from "../core/mutex.js";
+import { resolveWithVariants } from "./read.js";
+import { saveChange, simpleDiff } from "../core/file-tracker.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/edit-file/index.ts
+/**
+* edit tool — replaces pi's built-in with enhanced file editing.
+*
+* differences from pi's built-in:
+* - mutex-locked per file path (prevents partial writes from concurrent edits)
+* - replace_all mode for multiple occurrences
+* - escape sequence fallback (\n, \t when exact match fails)
+* - redaction check (rejects edits introducing placeholder markers)
+* - file change tracking for undo_edit via lib/file-tracker
+* - BOM/CRLF preservation
+*
+* shadows pi's built-in `edit` tool via same-name registration.
+* uses model-compatible parameter names (old_str, new_str, replace_all)
+* rather than pi's (oldText, newText) — models produce these param
+* names naturally.
+*/
+function stripBom(content) {
+	return content.startsWith("") ? {
+		bom: "",
+		text: content.slice(1)
+	} : {
+		bom: "",
+		text: content
+	};
+}
+function detectLineEnding(content) {
+	const crlfIdx = content.indexOf("\r\n");
+	const lfIdx = content.indexOf("\n");
+	if (lfIdx === -1 || crlfIdx === -1) return "\n";
+	return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+function normalizeToLF(text) {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function restoreLineEndings(text, ending) {
+	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+/**
+* LLMs sometimes emit literal \n / \t in JSON strings when they mean
+* actual whitespace. the JSON parser produces backslash + letter, not
+* a real newline. this function converts those back.
+*/
+function unescapeStr(s) {
+	return s.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\\\/g, "\\");
+}
+/**
+* trailing whitespace + unicode normalization.
+* mirrors pi's edit-diff.ts normalizeForFuzzyMatch so we get the same
+* fallback behavior the model is used to from the built-in tool.
+*/
+function normalizeForFuzzy(text) {
+	return text.split("\n").map((line) => line.trimEnd()).join("\n").replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, "\"").replace(/[\u2010-\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+/**
+* 3-tier matching: exact → unescaped → fuzzy-normalized.
+* returns the content variant + effective search/replace strings so the
+* caller can apply the replacement in the correct text space.
+*/
+function findMatchStrategy(content, oldStr, newStr) {
+	let idx = content.indexOf(oldStr);
+	if (idx !== -1) return {
+		searchStr: oldStr,
+		replaceStr: newStr,
+		content,
+		index: idx,
+		matchLength: oldStr.length
+	};
+	const unescOld = unescapeStr(oldStr);
+	const unescNew = unescapeStr(newStr);
+	if (unescOld !== oldStr) {
+		idx = content.indexOf(unescOld);
+		if (idx !== -1) return {
+			searchStr: unescOld,
+			replaceStr: unescNew,
+			content,
+			index: idx,
+			matchLength: unescOld.length
+		};
+	}
+	const fuzzyContent = normalizeForFuzzy(content);
+	const fuzzyOld = normalizeForFuzzy(oldStr);
+	idx = fuzzyContent.indexOf(fuzzyOld);
+	if (idx !== -1) return {
+		searchStr: fuzzyOld,
+		replaceStr: newStr,
+		content: fuzzyContent,
+		index: idx,
+		matchLength: fuzzyOld.length
+	};
+	return null;
+}
+function countOccurrences(content, searchStr) {
+	if (searchStr.length === 0) return 0;
+	let count = 0;
+	let pos = 0;
+	while ((pos = content.indexOf(searchStr, pos)) !== -1) {
+		count++;
+		pos += searchStr.length;
+	}
+	return count;
+}
+/**
+* patterns that indicate the LLM replaced real content with a placeholder.
+* checked against new_str only when the pattern is absent from old_str
+* (so legitimate test strings containing these phrases pass through).
+*/
+const REDACTION_PATTERNS = [
+	/\[REDACTED\]/i,
+	/\[\.\.\.omitted.*?\]/i,
+	/\[rest of .{1,40} unchanged\]/i,
+	/\[remaining .{1,40} unchanged\]/i,
+	/\/\/ \.\.\.( rest| remaining)? (of )?(the )?(file|code|content|implementation)( remains?)? (unchanged|the same|as before|omitted)/i,
+	/\/\/ \.\.\. existing (code|content|implementation)/i,
+	/# \.\.\. existing (code|content|implementation)/i
+];
+function hasNewRedactionMarkers(oldStr, newStr) {
+	for (const pattern of REDACTION_PATTERNS) if (pattern.test(newStr) && !pattern.test(oldStr)) return newStr.match(pattern)?.[0] ?? "redaction marker";
+	return null;
+}
+/**
+* parse unified diff output into BoxSection[] for box-format rendering.
+* each hunk becomes a BoxBlock. +/- lines are highlighted, context lines dim.
+*/
+function parseDiffToSections(filename, diffText) {
+	const lines = diffText.split("\n");
+	const blocks = [];
+	let currentLines = [];
+	let oldLine = 0;
+	let newLine = 0;
+	for (const line of lines) {
+		if (line.startsWith("--- ") || line.startsWith("+++ ")) continue;
+		const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+		if (hunkMatch && hunkMatch[1] && hunkMatch[2]) {
+			if (currentLines.length > 0) {
+				blocks.push({ lines: currentLines });
+				currentLines = [];
+			}
+			oldLine = parseInt(hunkMatch[1], 10);
+			newLine = parseInt(hunkMatch[2], 10);
+			continue;
+		}
+		if (line.startsWith("-")) {
+			currentLines.push({
+				gutter: String(oldLine),
+				text: line,
+				highlight: true
+			});
+			oldLine++;
+		} else if (line.startsWith("+")) {
+			currentLines.push({
+				gutter: String(newLine),
+				text: line,
+				highlight: true
+			});
+			newLine++;
+		} else {
+			currentLines.push({
+				gutter: String(oldLine),
+				text: line,
+				highlight: false
+			});
+			oldLine++;
+			newLine++;
+		}
+	}
+	if (currentLines.length > 0) blocks.push({ lines: currentLines });
+	return [{
+		header: filename,
+		blocks
+	}];
+}
+/**
+* compute +added/~modified/-removed from diff lines.
+* adjacent - then + blocks are paired as modifications;
+* the min count is ~modified, excess is pure +/-.
+*/
+function computeDiffStats(sections) {
+	let added = 0;
+	let removed = 0;
+	let modified = 0;
+	for (const section of sections) for (const block of section.blocks) {
+		let i = 0;
+		while (i < block.lines.length) {
+			const line = block.lines[i];
+			if (!line) {
+				i++;
+				continue;
+			}
+			if (line.text.startsWith("-")) {
+				let delCount = 0;
+				while (i < block.lines.length && block.lines[i]?.text.startsWith("-")) {
+					delCount++;
+					i++;
+				}
+				let addCount = 0;
+				while (i < block.lines.length && block.lines[i]?.text.startsWith("+")) {
+					addCount++;
+					i++;
+				}
+				const paired = Math.min(delCount, addCount);
+				modified += paired;
+				removed += delCount - paired;
+				added += addCount - paired;
+			} else if (line.text.startsWith("+")) {
+				added++;
+				i++;
+			} else i++;
+		}
+	}
+	return {
+		added,
+		removed,
+		modified
+	};
+}
+function formatStats(stats, theme) {
+	const parts = [];
+	if (stats.added > 0) parts.push(theme.fg("toolDiffAdded", `+${stats.added}`));
+	if (stats.modified > 0) parts.push(theme.fg("warning", `~${stats.modified}`));
+	if (stats.removed > 0) parts.push(theme.fg("toolDiffRemoved", `-${stats.removed}`));
+	return parts.length > 0 ? parts.join(" ") : theme.fg("dim", "no changes");
+}
+function createEditFileTool() {
+	return {
+		name: "edit",
+		label: "Edit File",
+		description: "Make edits to a text file.\n\nReplaces `old_str` with `new_str` in the given file.\n\nReturns a diff showing the changes made.\n\nThe file specified by `path` MUST exist.\n\n`old_str` MUST exist in the file.\n\n`old_str` and `new_str` MUST be different from each other.\n\nSet `replace_all` to true to replace all occurrences of `old_str` in the file. Otherwise, `old_str` MUST be unique within the file or the edit will fail. Additional lines of context can be added to make the string more unique.\n\nWhen changing an existing file, use this tool. Only use the write tool for files that do not exist yet.",
+		parameters: Type.Object({
+			path: Type.String({ description: "The absolute path to the file (MUST be absolute, not relative). File must exist." }),
+			old_str: Type.String({ description: "Text to search for. Must match exactly." }),
+			new_str: Type.String({ description: "Text to replace old_str with." }),
+			replace_all: Type.Optional(Type.Boolean({
+				description: "Set to true to replace all occurrences of old_str. Otherwise, old_str must be unique.",
+				default: false
+			}))
+		}),
+		renderCall(args, theme) {
+			const filePath = args.path || "...";
+			const home = os.homedir();
+			const shortened = filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+			const linked = filePath.startsWith("/") ? osc8Link(`file://${filePath}`, shortened) : shortened;
+			return new Text(theme.fg("toolTitle", theme.bold("Edit ")) + theme.fg("dim", linked), 0, 0);
+		},
+		async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+			const p = params;
+			const resolved = resolveWithVariants(p.path, ctx.cwd);
+			if (!fs.existsSync(resolved)) return {
+				content: [{
+					type: "text",
+					text: `file not found: ${resolved}`
+				}],
+				isError: true
+			};
+			if (fs.statSync(resolved).isDirectory()) return {
+				content: [{
+					type: "text",
+					text: `${resolved} is a directory, not a file.`
+				}],
+				isError: true
+			};
+			const redactionMarker = hasNewRedactionMarkers(p.old_str, p.new_str);
+			if (redactionMarker) return {
+				content: [{
+					type: "text",
+					text: `rejected: new_str contains a redaction marker ("${redactionMarker}"). provide the actual content instead of placeholders.`
+				}],
+				isError: true
+			};
+			return withFileLock(resolved, async () => {
+				const rawContent = fs.readFileSync(resolved, "utf-8");
+				const { bom, text: bomStripped } = stripBom(rawContent);
+				const originalEnding = detectLineEnding(bomStripped);
+				const normalized = normalizeToLF(bomStripped);
+				const oldStr = normalizeToLF(p.old_str);
+				const newStr = normalizeToLF(p.new_str);
+				if (oldStr === newStr) return {
+					content: [{
+						type: "text",
+						text: "old_str and new_str are identical. no changes needed."
+					}],
+					isError: true
+				};
+				const strategy = findMatchStrategy(normalized, oldStr, newStr);
+				if (!strategy) return {
+					content: [{
+						type: "text",
+						text: `could not find old_str in ${path.basename(resolved)}. the text must match exactly including whitespace and newlines.`
+					}],
+					isError: true
+				};
+				const occurrences = countOccurrences(strategy.content, strategy.searchStr);
+				const replaceAll = p.replace_all ?? false;
+				if (!replaceAll && occurrences > 1) return {
+					content: [{
+						type: "text",
+						text: `found ${occurrences} occurrences of old_str in ${path.basename(resolved)}. set replace_all to true, or add more context to make the match unique.`
+					}],
+					isError: true
+				};
+				let newContent;
+				if (replaceAll) newContent = strategy.content.split(strategy.searchStr).join(strategy.replaceStr);
+				else newContent = strategy.content.substring(0, strategy.index) + strategy.replaceStr + strategy.content.substring(strategy.index + strategy.matchLength);
+				if (strategy.content === newContent) return {
+					content: [{
+						type: "text",
+						text: "no changes made — replacement produced identical content."
+					}],
+					isError: true
+				};
+				const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+				fs.writeFileSync(resolved, finalContent, "utf-8");
+				const sessionId = ctx.sessionManager.getSessionId();
+				const trackingDiff = simpleDiff(resolved, rawContent, finalContent);
+				saveChange(sessionId, toolCallId, {
+					uri: `file://${resolved}`,
+					before: rawContent,
+					after: finalContent,
+					diff: trackingDiff,
+					isNewFile: false,
+					timestamp: Date.now()
+				});
+				return {
+					content: [{
+						type: "text",
+						text: simpleDiff(resolved, strategy.content, newContent)
+					}],
+					details: {
+						filePath: resolved,
+						...replaceAll && occurrences > 1 ? { replaceCount: occurrences } : {}
+					}
+				};
+			});
+		},
+		renderResult(result, { expanded }, theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text(theme.fg("dim", "(no output)"), 0, 0);
+			const diffText = content.text;
+			const filename = diffText.match(/^---\s+(\S+)/m)?.[1] ?? "file";
+			const filePath = result.details?.filePath;
+			const sections = parseDiffToSections(filename, diffText);
+			if (!sections?.length || !sections[0]?.blocks.length) return new Text(theme.fg("dim", "(no changes)"), 0, 0);
+			const statsText = formatStats(computeDiffStats(sections), theme);
+			const replaceCount = result.details?.replaceCount;
+			const replaceNote = replaceCount && replaceCount > 1 ? theme.fg("dim", ` (${replaceCount} replacements)`) : "";
+			/** 25 visual lines per hunk: head 12 + tail 13 */
+			const HUNK_EXCERPTS = [{
+				focus: "head",
+				context: 12
+			}, {
+				focus: "tail",
+				context: 13
+			}];
+			return {
+				render(width) {
+					const lines = [];
+					lines.push(statsText + replaceNote);
+					const displaySections = sections.map((s) => {
+						const blocks = !expanded && s.blocks.length > 1 ? s.blocks.slice(-1) : s.blocks;
+						const header = filePath ? osc8Link(`file://${filePath}`, s.header ?? "") : s.header;
+						return {
+							...s,
+							header,
+							blocks
+						};
+					});
+					const notices = [];
+					if (replaceCount && replaceCount > 1) notices.push(`replaced ${replaceCount} occurrences`);
+					const boxOutput = formatBoxesWindowed(displaySections, {
+						maxSections: expanded ? void 0 : 1,
+						excerpts: HUNK_EXCERPTS
+					}, notices.length > 0 ? notices : void 0, width);
+					lines.push(...boxOutput.split("\n"));
+					return lines;
+				},
+				invalidate() {}
+			};
+		}
+	};
+}
+function edit_file_default(pi) {
+	pi.registerTool(withPromptPatch(createEditFileTool()));
+}
+//#endregion
+export { createEditFileTool, edit_file_default as default };

package/dist/extensions/editor.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/editor/index.d.ts
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { export_default as default };

package/dist/extensions/editor.js

@@ -0,0 +1,2 @@
+import { t as editor_default } from "../editor-BljciPdx.js";
+export { editor_default as default };

package/dist/extensions/finder.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/finder/index.d.ts
+interface FinderConfig {
+  systemPrompt?: string;
+  model?: string;
+  extensionTools?: string[];
+  builtinTools?: string[];
+}
+declare function createFinderTool(config?: FinderConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { FinderConfig, createFinderTool, export_default as default };

package/dist/extensions/finder.js

@@ -0,0 +1,108 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { getExtensionConfig } from "../core/config.js";
+import { piSpawn, resolvePrompt, zeroUsage } from "../core/pi-spawn.js";
+import { getFinalOutput, renderAgentTree, subAgentResult } from "../core/sub-agent-render.js";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/finder/index.ts
+const CONFIG_DEFAULTS = {
+	model: "openrouter/google/gemini-3-flash-preview",
+	extensionTools: [
+		"read",
+		"grep",
+		"find",
+		"ls"
+	],
+	builtinTools: [
+		"read",
+		"grep",
+		"find",
+		"ls"
+	],
+	promptFile: "",
+	promptString: ""
+};
+function createFinderTool(config = {}) {
+	return {
+		name: "finder",
+		label: "Finder",
+		description: "Intelligently search your codebase: Use it for complex, multi-step search tasks where you need to find code based on functionality or concepts rather than exact matches. Anytime you want to chain multiple grep calls you should use this tool.\n\nWHEN TO USE THIS TOOL:\n- You must locate code by behavior or concept\n- You need to run multiple greps in sequence\n- You must correlate or look for connection between several areas of the codebase\n- You must filter broad terms by context\n- You need answers to questions like \"Where do we validate JWT headers?\"\n\nWHEN NOT TO USE THIS TOOL:\n- When you know the exact file path - use Read directly\n- When looking for specific symbols or exact strings - use Find or Grep\n- When you need to create, modify files, or run terminal commands\n\nUSAGE GUIDELINES:\n1. Always spawn multiple search agents in parallel to maximise speed.\n2. Formulate your query as a precise engineering request.\n3. Name concrete artifacts, patterns, or APIs to narrow scope.\n4. State explicit success criteria so the agent knows when to stop.\n5. Never issue vague or exploratory commands.",
+		parameters: Type.Object({ query: Type.String({ description: "The search query describing what to find. Be specific and include technical terms, file types, or expected code patterns." }) }),
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const singleResult = {
+				agent: "finder",
+				task: p.query,
+				exitCode: -1,
+				messages: [],
+				usage: zeroUsage()
+			};
+			const result = await piSpawn({
+				cwd: ctx.cwd,
+				task: p.query,
+				model: config.model ?? CONFIG_DEFAULTS.model,
+				builtinTools: config.builtinTools ?? CONFIG_DEFAULTS.builtinTools,
+				extensionTools: config.extensionTools ?? CONFIG_DEFAULTS.extensionTools,
+				systemPromptBody: config.systemPrompt,
+				signal,
+				sessionId,
+				onUpdate: (partial) => {
+					singleResult.messages = partial.messages;
+					singleResult.usage = partial.usage;
+					singleResult.model = partial.model;
+					singleResult.stopReason = partial.stopReason;
+					singleResult.errorMessage = partial.errorMessage;
+					if (onUpdate) onUpdate({
+						content: [{
+							type: "text",
+							text: getFinalOutput(partial.messages) || "(searching...)"
+						}],
+						details: singleResult
+					});
+				}
+			});
+			singleResult.exitCode = result.exitCode;
+			singleResult.messages = result.messages;
+			singleResult.usage = result.usage;
+			singleResult.model = result.model;
+			singleResult.stopReason = result.stopReason;
+			singleResult.errorMessage = result.errorMessage;
+			const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+			const output = getFinalOutput(result.messages) || "(no output)";
+			if (isError) return subAgentResult(result.errorMessage || result.stderr || output, singleResult, true);
+			return subAgentResult(output, singleResult);
+		},
+		renderCall(args, theme) {
+			const preview = args.query ? args.query.length > 80 ? `${args.query.slice(0, 80)}...` : args.query : "...";
+			return new Text(theme.fg("toolTitle", theme.bold("finder ")) + theme.fg("dim", preview), 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			const details = result.details;
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+			}
+			const container = new Container();
+			renderAgentTree(details, container, expanded, theme, {
+				label: "finder",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function finder_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/finder", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createFinderTool({
+		systemPrompt: resolvePrompt(cfg.promptString, cfg.promptFile),
+		model: cfg.model,
+		extensionTools: cfg.extensionTools,
+		builtinTools: cfg.builtinTools
+	})));
+}
+//#endregion
+export { createFinderTool, finder_default as default };

package/dist/extensions/format-file.d.ts

@@ -0,0 +1,11 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/format-file/index.d.ts
+type FormatFileExtConfig = {
+  preferredFormatter: string;
+  formatterLookupTimeoutMs: number;
+};
+declare function createFormatFileTool(config?: FormatFileExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createFormatFileTool, export_default as default };

package/dist/extensions/format-file.js

@@ -0,0 +1,145 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link, textSection } from "../core/box-format.js";
+import { withFileLock } from "../core/mutex.js";
+import { getExtensionConfig } from "../core/config.js";
+import { resolveWithVariants } from "./read.js";
+import { saveChange, simpleDiff } from "../core/file-tracker.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/format-file/index.ts
+/**
+* format_file tool — runs a code formatter on a file.
+*
+* tries formatters in order: prettier, biome. uses whichever is
+* available on PATH (nix provides these). captures before/after
+* diff and tracks the change for undo_edit.
+*/
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+const CONFIG_DEFAULTS = {
+	preferredFormatter: "auto",
+	formatterLookupTimeoutMs: 3e3
+};
+const FORMATTERS = [{
+	name: "prettier",
+	args: (file) => [
+		"--write",
+		"--log-level",
+		"silent",
+		file
+	]
+}, {
+	name: "biome",
+	args: (file) => [
+		"format",
+		"--write",
+		file
+	]
+}];
+function findFormatter(preferred, timeoutMs) {
+	const ordered = preferred !== "auto" ? [...FORMATTERS].sort((a, b) => a.name === preferred ? -1 : b.name === preferred ? 1 : 0) : FORMATTERS;
+	for (const fmt of ordered) if (spawnSync("which", [fmt.name], {
+		encoding: "utf-8",
+		timeout: timeoutMs
+	}).status === 0) return fmt;
+	return null;
+}
+function createFormatFileTool(config = CONFIG_DEFAULTS) {
+	return {
+		name: "format_file",
+		label: "Format File",
+		description: "Run a code formatter (prettier or biome) on a file.",
+		parameters: Type.Object({ path: Type.String({ description: "The absolute path to the file to format." }) }),
+		renderCall(args, theme) {
+			const filePath = args.path || "...";
+			const home = os.homedir();
+			const shortened = filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+			const linked = filePath.startsWith("/") ? osc8Link(`file://${filePath}`, shortened) : shortened;
+			return new Text(theme.fg("toolTitle", theme.bold("Format ")) + theme.fg("dim", linked), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		},
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const resolved = resolveWithVariants(params.path, ctx.cwd);
+			if (!fs.existsSync(resolved)) return {
+				content: [{
+					type: "text",
+					text: `file not found: ${resolved}`
+				}],
+				isError: true
+			};
+			const formatter = findFormatter(config.preferredFormatter, config.formatterLookupTimeoutMs);
+			if (!formatter) return {
+				content: [{
+					type: "text",
+					text: "no formatter found. install prettier or biome."
+				}],
+				isError: true
+			};
+			return withFileLock(resolved, async () => {
+				const before = fs.readFileSync(resolved, "utf-8");
+				const result = spawnSync(formatter.name, formatter.args(resolved), {
+					encoding: "utf-8",
+					timeout: 3e4,
+					cwd: ctx.cwd
+				});
+				if (result.status !== 0) {
+					const err = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.status}`;
+					return {
+						content: [{
+							type: "text",
+							text: `${formatter.name} failed: ${err}`
+						}],
+						isError: true
+					};
+				}
+				const after = fs.readFileSync(resolved, "utf-8");
+				if (before === after) return {
+					content: [{
+						type: "text",
+						text: `${path.basename(resolved)} is already formatted.`
+					}],
+					details: { header: resolved }
+				};
+				const sessionId = ctx.sessionManager.getSessionId();
+				const diff = simpleDiff(resolved, before, after);
+				saveChange(sessionId, toolCallId, {
+					uri: `file://${resolved}`,
+					before,
+					after,
+					diff,
+					isNewFile: false,
+					timestamp: Date.now()
+				});
+				return {
+					content: [{
+						type: "text",
+						text: `formatted ${path.basename(resolved)} with ${formatter.name}.\n\n${diff}`
+					}],
+					details: { header: resolved }
+				};
+			});
+		}
+	};
+}
+function format_file_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/format-file", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createFormatFileTool(cfg)));
+}
+//#endregion
+export { createFormatFileTool, format_file_default as default };