@oh-my-pi/pi-coding-agent 6.8.5 → 6.9.69

package/src/core/settings-manager.ts

@@ -98,10 +98,6 @@ export interface BashInterceptorSettings {
 	patterns?: BashInterceptorRule[]; // default: built-in rules
 }
 
-export interface GitSettings {
-	enabled?: boolean; // default: false (structured git tool; use bash for git commands when disabled)
-}
-
 export interface MCPSettings {
 	enableProjectConfig?: boolean; // default: true (load .mcp.json from project root)
 }
@@ -145,15 +141,6 @@ export interface TodoCompletionSettings {
 	maxReminders?: number; // default: 3 - maximum reminders before giving up
 }
 
-export interface VoiceSettings {
-	enabled?: boolean; // default: false
-	transcriptionModel?: string; // default: "whisper-1"
-	transcriptionLanguage?: string; // optional language hint (e.g., "en")
-	ttsModel?: string; // default: "gpt-4o-mini-tts"
-	ttsVoice?: string; // default: "alloy"
-	ttsFormat?: "wav" | "mp3" | "opus" | "aac" | "flac"; // default: "wav"
-}
-
 export type StatusLineSegmentId =
 	| "pi"
 	| "model"
@@ -224,14 +211,12 @@ export interface Settings {
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	exa?: ExaSettings;
 	bashInterceptor?: BashInterceptorSettings;
-	git?: GitSettings;
 	mcp?: MCPSettings;
 	lsp?: LspSettings;
 	python?: PythonSettings;
 	edit?: EditSettings;
 	ttsr?: TtsrSettings;
 	todoCompletion?: TodoCompletionSettings;
-	voice?: VoiceSettings;
 	providers?: ProviderSettings;
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
 	disabledExtensions?: string[]; // Individual extension IDs that are disabled (e.g., "skill:commit")
@@ -252,12 +237,6 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 		tool: "grep",
 		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
 	},
-	{
-		pattern: "^\\s*git(\\s+|$)",
-		tool: "git",
-		message:
-			"Use the `git` tool instead of running git in bash. It provides structured output and safety confirmations.",
-	},
 	{
 		pattern: "^\\s*(find|fd|locate)\\s+.*(-name|-iname|-type|--type|-glob)",
 		tool: "find",
@@ -319,19 +298,11 @@ const DEFAULT_SETTINGS: Settings = {
 		enableWebsets: false,
 	},
 	bashInterceptor: DEFAULT_BASH_INTERCEPTOR_SETTINGS,
-	git: { enabled: false },
 	mcp: { enableProjectConfig: true },
 	lsp: { formatOnWrite: false, diagnosticsOnWrite: true, diagnosticsOnEdit: false },
 	python: { toolMode: "both", kernelMode: "session", sharedGateway: true },
 	edit: { fuzzyMatch: true, fuzzyThreshold: 0.95, streamingAbort: false },
 	ttsr: { enabled: true, contextMode: "discard", repeatMode: "once", repeatGap: 10 },
-	voice: {
-		enabled: false,
-		transcriptionModel: "whisper-1",
-		ttsModel: "gpt-4o-mini-tts",
-		ttsVoice: "alloy",
-		ttsFormat: "wav",
-	},
 	providers: { webSearch: "auto", image: "auto" },
 } satisfies Settings;
 
@@ -1170,10 +1141,6 @@ export class SettingsManager {
 		await this.save();
 	}
 
-	getGitToolEnabled(): boolean {
-		return this.settings.git?.enabled ?? false;
-	}
-
 	getPythonToolMode(): PythonToolMode {
 		return this.settings.python?.toolMode ?? "both";
 	}
@@ -1210,14 +1177,6 @@ export class SettingsManager {
 		await this.save();
 	}
 
-	async setGitToolEnabled(enabled: boolean): Promise<void> {
-		if (!this.globalSettings.git) {
-			this.globalSettings.git = {};
-		}
-		this.globalSettings.git.enabled = enabled;
-		await this.save();
-	}
-
 	getMCPProjectConfigEnabled(): boolean {
 		return this.settings.mcp?.enableProjectConfig ?? true;
 	}
@@ -1430,70 +1389,6 @@ export class SettingsManager {
 		await this.save();
 	}
 
-	getVoiceSettings(): Required<VoiceSettings> {
-		return {
-			enabled: this.settings.voice?.enabled ?? false,
-			transcriptionModel: this.settings.voice?.transcriptionModel ?? "whisper-1",
-			transcriptionLanguage: this.settings.voice?.transcriptionLanguage ?? "",
-			ttsModel: this.settings.voice?.ttsModel ?? "tts-1",
-			ttsVoice: this.settings.voice?.ttsVoice ?? "alloy",
-			ttsFormat: this.settings.voice?.ttsFormat ?? "wav",
-		};
-	}
-
-	async setVoiceSettings(settings: VoiceSettings): Promise<void> {
-		this.globalSettings.voice = { ...this.globalSettings.voice, ...settings };
-		await this.save();
-	}
-
-	getVoiceEnabled(): boolean {
-		return this.settings.voice?.enabled ?? false;
-	}
-
-	async setVoiceEnabled(enabled: boolean): Promise<void> {
-		if (!this.globalSettings.voice) {
-			this.globalSettings.voice = {};
-		}
-		this.globalSettings.voice.enabled = enabled;
-		await this.save();
-	}
-
-	getVoiceTtsModel(): string {
-		return this.settings.voice?.ttsModel ?? "gpt-4o-mini-tts";
-	}
-
-	async setVoiceTtsModel(model: string): Promise<void> {
-		if (!this.globalSettings.voice) {
-			this.globalSettings.voice = {};
-		}
-		this.globalSettings.voice.ttsModel = model;
-		await this.save();
-	}
-
-	getVoiceTtsVoice(): string {
-		return this.settings.voice?.ttsVoice ?? "alloy";
-	}
-
-	async setVoiceTtsVoice(voice: string): Promise<void> {
-		if (!this.globalSettings.voice) {
-			this.globalSettings.voice = {};
-		}
-		this.globalSettings.voice.ttsVoice = voice;
-		await this.save();
-	}
-
-	getVoiceTtsFormat(): "wav" | "mp3" | "opus" | "aac" | "flac" {
-		return this.settings.voice?.ttsFormat ?? "wav";
-	}
-
-	async setVoiceTtsFormat(format: "wav" | "mp3" | "opus" | "aac" | "flac"): Promise<void> {
-		if (!this.globalSettings.voice) {
-			this.globalSettings.voice = {};
-		}
-		this.globalSettings.voice.ttsFormat = format;
-		await this.save();
-	}
-
 	// ═══════════════════════════════════════════════════════════════════════════
 	// Status Line Settings
 	// ═══════════════════════════════════════════════════════════════════════════

package/src/core/tools/bash.ts

@@ -20,9 +20,7 @@ export const BASH_DEFAULT_PREVIEW_LINES = 10;
 const bashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
-	workdir: Type.Optional(
-		Type.String({ description: "Working directory for the command (default: current directory)" }),
-	),
+	cwd: Type.Optional(Type.String({ description: "Working directory for the command (default: current directory)" })),
 });
 
 export interface BashToolDetails {
@@ -53,7 +51,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 
 	public async execute(
 		_toolCallId: string,
-		{ command, timeout, workdir }: { command: string; timeout?: number; workdir?: string },
+		{ command, timeout, cwd }: { command: string; timeout?: number; cwd?: string },
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
@@ -73,7 +71,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			}
 		}
 
-		const commandCwd = workdir ? resolveToCwd(workdir, this.session.cwd) : this.session.cwd;
+		const commandCwd = cwd ? resolveToCwd(cwd, this.session.cwd) : this.session.cwd;
 		let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
 		try {
 			cwdStat = await Bun.file(commandCwd).stat();
@@ -143,7 +141,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 interface BashRenderArgs {
 	command?: string;
 	timeout?: number;
-	workdir?: string;
+	cwd?: string;
 }
 
 interface BashRenderContext {
@@ -166,7 +164,7 @@ export const bashToolRenderer = {
 		const command = args.command || uiTheme.format.ellipsis;
 		const prompt = uiTheme.fg("accent", "$");
 		const cwd = process.cwd();
-		let displayWorkdir = args.workdir;
+		let displayWorkdir = args.cwd;
 
 		if (displayWorkdir) {
 			const resolvedCwd = resolve(cwd);

package/src/core/tools/index.ts

@@ -7,7 +7,6 @@ export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
 export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
-export { GitTool, type GitToolDetails } from "./git";
 export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolOptions } from "./grep";
 export { type LsOperations, LsTool, type LsToolDetails, type LsToolOptions } from "./ls";
 export {
@@ -72,7 +71,6 @@ import { BashTool } from "./bash";
 import { CalculatorTool } from "./calculator";
 import { CompleteTool } from "./complete";
 import { FindTool } from "./find";
-import { GitTool } from "./git";
 import { GrepTool } from "./grep";
 import { LsTool } from "./ls";
 import { LspTool } from "./lsp/index";
@@ -132,7 +130,6 @@ export interface ToolSession {
 		getEditFuzzyMatch(): boolean;
 		getEditFuzzyThreshold?(): number;
 		getEditPatchMode?(): boolean;
-		getGitToolEnabled(): boolean;
 		getBashInterceptorEnabled(): boolean;
 		getBashInterceptorSimpleLsEnabled(): boolean;
 		getBashInterceptorRules(): BashInterceptorRule[];
@@ -152,7 +149,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ssh: loadSshTool,
 	edit: (s) => new EditTool(s),
 	find: (s) => new FindTool(s),
-	git: GitTool.createIf,
 	grep: (s) => new GrepTool(s),
 	ls: (s) => new LsTool(s),
 	lsp: LspTool.createIf,
@@ -225,7 +221,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			});
 		} else if (!isTestEnv && getPreludeDocs().length === 0) {
 			const sessionFile = session.getSessionFile?.() ?? undefined;
-			const warmSessionId = sessionFile ? `session:${sessionFile}:workdir:${session.cwd}` : `cwd:${session.cwd}`;
+			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
 			void warmPythonEnvironment(session.cwd, warmSessionId, session.settings?.getPythonSharedGateway?.()).catch(
 				(err) => {
 					logger.warn("Failed to warm Python environment", {

package/src/core/tools/patch/applicator.ts

@@ -11,6 +11,7 @@ import { resolveToCwd } from "../path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch, seekSequence } from "./fuzzy";
 import {
 	adjustIndentation,
+	convertLeadingTabsToSpaces,
 	countLeadingWhitespace,
 	detectLineEnding,
 	getLeadingWhitespace,
@@ -82,6 +83,34 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		return newLines;
 	}
 
+	// If pattern already matches actual exactly (including indentation), preserve agent's intended changes
+	if (patternLines.length === actualLines.length) {
+		let exactMatch = true;
+		for (let i = 0; i < patternLines.length; i++) {
+			if (patternLines[i] !== actualLines[i]) {
+				exactMatch = false;
+				break;
+			}
+		}
+		if (exactMatch) {
+			return newLines;
+		}
+	}
+
+	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
+	if (patternLines.length === newLines.length) {
+		let indentationOnly = true;
+		for (let i = 0; i < patternLines.length; i++) {
+			if (patternLines[i].trim() !== newLines[i].trim()) {
+				indentationOnly = false;
+				break;
+			}
+		}
+		if (indentationOnly) {
+			return newLines;
+		}
+	}
+
 	// Detect indent character from actual content
 	let indentChar = " ";
 	for (const line of actualLines) {
@@ -92,6 +121,55 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 	}
 
+	let patternTabOnly = true;
+	let actualSpaceOnly = true;
+	let patternMixed = false;
+	let actualMixed = false;
+
+	for (const line of patternLines) {
+		if (line.trim().length === 0) continue;
+		const ws = getLeadingWhitespace(line);
+		if (ws.includes(" ")) patternTabOnly = false;
+		if (ws.includes(" ") && ws.includes("\t")) patternMixed = true;
+	}
+
+	for (const line of actualLines) {
+		if (line.trim().length === 0) continue;
+		const ws = getLeadingWhitespace(line);
+		if (ws.includes("\t")) actualSpaceOnly = false;
+		if (ws.includes(" ") && ws.includes("\t")) actualMixed = true;
+	}
+
+	if (!patternMixed && !actualMixed && patternTabOnly && actualSpaceOnly) {
+		let ratio: number | undefined;
+		const lineCount = Math.min(patternLines.length, actualLines.length);
+		let consistent = true;
+		for (let i = 0; i < lineCount; i++) {
+			const patternLine = patternLines[i];
+			const actualLine = actualLines[i];
+			if (patternLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+			const patternIndent = countLeadingWhitespace(patternLine);
+			const actualIndent = countLeadingWhitespace(actualLine);
+			if (patternIndent === 0) continue;
+			if (actualIndent % patternIndent !== 0) {
+				consistent = false;
+				break;
+			}
+			const nextRatio = actualIndent / patternIndent;
+			if (!ratio) {
+				ratio = nextRatio;
+			} else if (ratio !== nextRatio) {
+				consistent = false;
+				break;
+			}
+		}
+
+		if (consistent && ratio) {
+			const converted = convertLeadingTabsToSpaces(newLines.join("\n"), ratio).split("\n");
+			return converted;
+		}
+	}
+
 	// Build a map from trimmed content to actual lines (by content, not position)
 	// This handles fuzzy matches where pattern and actual may not be positionally aligned
 	const contentToActualLines = new Map<string, string[]>();
@@ -106,18 +184,29 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 	}
 
-	// Compute fallback delta from all non-empty lines (for truly new lines)
-	let totalDelta = 0;
-	let deltaCount = 0;
+	let patternMin = Infinity;
+	for (const line of patternLines) {
+		if (line.trim().length === 0) continue;
+		patternMin = Math.min(patternMin, countLeadingWhitespace(line));
+	}
+	if (patternMin === Infinity) {
+		patternMin = 0;
+	}
+
+	let delta: number | undefined;
+	const deltas: number[] = [];
 	for (let i = 0; i < Math.min(patternLines.length, actualLines.length); i++) {
-		if (patternLines[i].trim().length > 0 && actualLines[i].trim().length > 0) {
-			const pIndent = countLeadingWhitespace(patternLines[i]);
-			const aIndent = countLeadingWhitespace(actualLines[i]);
-			totalDelta += aIndent - pIndent;
-			deltaCount++;
-		}
+		const patternLine = patternLines[i];
+		const actualLine = actualLines[i];
+		if (patternLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+		const pIndent = countLeadingWhitespace(patternLine);
+		const aIndent = countLeadingWhitespace(actualLine);
+		deltas.push(aIndent - pIndent);
+	}
+
+	if (deltas.length > 0 && deltas.every((value) => value === deltas[0])) {
+		delta = deltas[0];
 	}
-	const avgDelta = deltaCount > 0 ? Math.round(totalDelta / deltaCount) : 0;
 
 	// Track which actual lines we've used to handle duplicate content correctly
 	const usedActualLines = new Map<string, number>(); // trimmed content -> count used
@@ -132,6 +221,12 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 
 		// Check if this is a context line (same trimmed content exists in actual)
 		if (matchingActualLines && matchingActualLines.length > 0) {
+			if (matchingActualLines.length === 1) {
+				return matchingActualLines[0];
+			}
+			if (matchingActualLines.includes(newLine)) {
+				return newLine;
+			}
 			const usedCount = usedActualLines.get(trimmed) ?? 0;
 			if (usedCount < matchingActualLines.length) {
 				usedActualLines.set(trimmed, usedCount + 1);
@@ -140,13 +235,16 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 			}
 		}
 
-		// This is a new/added line - apply average delta
-		if (avgDelta > 0) {
-			return indentChar.repeat(avgDelta) + newLine;
-		}
-		if (avgDelta < 0) {
-			const toRemove = Math.min(-avgDelta, countLeadingWhitespace(newLine));
-			return newLine.slice(toRemove);
+		// This is a new/added line - apply consistent delta if safe
+		if (delta && delta !== 0) {
+			const newIndent = countLeadingWhitespace(newLine);
+			if (newIndent === patternMin) {
+				if (delta > 0) {
+					return indentChar.repeat(delta) + newLine;
+				}
+				const toRemove = Math.min(-delta, newIndent);
+				return newLine.slice(toRemove);
+			}
 		}
 		return newLine;
 	});

package/src/core/tools/patch/index.ts

@@ -48,7 +48,7 @@ export { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch as findEditMatch, f
 
 // Normalization
 export {
-	adjustIndentation as adjustNewTextIndentation,
+	adjustIndentation,
 	detectLineEnding,
 	normalizeToLF,
 	restoreLineEndings,

package/src/core/tools/patch/normalize.ts

@@ -92,6 +92,114 @@ export function detectIndentChar(text: string): string {
 	return " ";
 }
 
+function gcd(a: number, b: number): number {
+	let x = Math.abs(a);
+	let y = Math.abs(b);
+	while (y !== 0) {
+		const temp = y;
+		y = x % y;
+		x = temp;
+	}
+	return x;
+}
+
+interface IndentProfile {
+	lines: string[];
+	indentStrings: string[];
+	indentCounts: number[];
+	min: number;
+	char: " " | "\t" | undefined;
+	spaceOnly: boolean;
+	tabOnly: boolean;
+	mixed: boolean;
+	unit: number;
+	nonEmptyCount: number;
+}
+
+function buildIndentProfile(text: string): IndentProfile {
+	const lines = text.split("\n");
+	const indentStrings: string[] = [];
+	const indentCounts: number[] = [];
+	let min = Infinity;
+	let char: " " | "\t" | undefined;
+	let spaceOnly = true;
+	let tabOnly = true;
+	let mixed = false;
+	let nonEmptyCount = 0;
+	let unit = 0;
+
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		nonEmptyCount++;
+		const indent = getLeadingWhitespace(line);
+		indentStrings.push(indent);
+		indentCounts.push(indent.length);
+		min = Math.min(min, indent.length);
+		if (indent.includes(" ")) {
+			tabOnly = false;
+		}
+		if (indent.includes("\t")) {
+			spaceOnly = false;
+		}
+		if (indent.includes(" ") && indent.includes("\t")) {
+			mixed = true;
+		}
+		if (indent.length > 0) {
+			const currentChar = indent[0] as " " | "\t";
+			if (!char) {
+				char = currentChar;
+			} else if (char !== currentChar) {
+				mixed = true;
+			}
+		}
+	}
+
+	if (min === Infinity) {
+		min = 0;
+	}
+
+	if (spaceOnly && nonEmptyCount > 0) {
+		let current = 0;
+		for (const count of indentCounts) {
+			if (count === 0) continue;
+			current = current === 0 ? count : gcd(current, count);
+		}
+		unit = current;
+	}
+
+	if (tabOnly && nonEmptyCount > 0) {
+		unit = 1;
+	}
+
+	return {
+		lines,
+		indentStrings,
+		indentCounts,
+		min,
+		char,
+		spaceOnly,
+		tabOnly,
+		mixed,
+		unit,
+		nonEmptyCount,
+	};
+}
+
+export function convertLeadingTabsToSpaces(text: string, spacesPerTab: number): string {
+	if (spacesPerTab <= 0) return text;
+	return text
+		.split("\n")
+		.map((line) => {
+			const trimmed = line.trimStart();
+			if (trimmed.length === 0) return line;
+			const leading = getLeadingWhitespace(line);
+			if (!leading.includes("\t") || leading.includes(" ")) return line;
+			const converted = " ".repeat(leading.length * spacesPerTab);
+			return converted + trimmed;
+		})
+		.join("\n");
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Unicode Normalization
 // ═══════════════════════════════════════════════════════════════════════════
@@ -191,27 +299,94 @@ export function normalizeForFuzzy(line: string): string {
  * to each line in newText.
  */
 export function adjustIndentation(oldText: string, actualText: string, newText: string): string {
-	const oldMin = minIndent(oldText);
-	const actualMin = minIndent(actualText);
-	const delta = actualMin - oldMin;
+	// If old text already matches actual text exactly, preserve agent's intended indentation
+	if (oldText === actualText) {
+		return newText;
+	}
+
+	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
+	const oldLines = oldText.split("\n");
+	const newLines = newText.split("\n");
+	if (oldLines.length === newLines.length) {
+		let indentationOnly = true;
+		for (let i = 0; i < oldLines.length; i++) {
+			if (oldLines[i].trim() !== newLines[i].trim()) {
+				indentationOnly = false;
+				break;
+			}
+		}
+		if (indentationOnly) {
+			return newText;
+		}
+	}
+
+	const oldProfile = buildIndentProfile(oldText);
+	const actualProfile = buildIndentProfile(actualText);
+	const newProfile = buildIndentProfile(newText);
+
+	if (newProfile.nonEmptyCount === 0 || oldProfile.nonEmptyCount === 0 || actualProfile.nonEmptyCount === 0) {
+		return newText;
+	}
+
+	if (oldProfile.mixed || actualProfile.mixed || newProfile.mixed) {
+		return newText;
+	}
+
+	if (oldProfile.char && actualProfile.char && oldProfile.char !== actualProfile.char) {
+		if (actualProfile.spaceOnly && oldProfile.tabOnly && newProfile.tabOnly && actualProfile.unit > 0) {
+			let consistent = true;
+			const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+			for (let i = 0; i < lineCount; i++) {
+				const oldLine = oldProfile.lines[i];
+				const actualLine = actualProfile.lines[i];
+				if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+				const oldIndent = getLeadingWhitespace(oldLine);
+				const actualIndent = getLeadingWhitespace(actualLine);
+				if (oldIndent.length === 0) continue;
+				if (actualIndent.length !== oldIndent.length * actualProfile.unit) {
+					consistent = false;
+					break;
+				}
+			}
+			return consistent ? convertLeadingTabsToSpaces(newText, actualProfile.unit) : newText;
+		}
+		return newText;
+	}
+
+	const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+	const deltas: number[] = [];
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldProfile.lines[i];
+		const actualLine = actualProfile.lines[i];
+		if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+		deltas.push(countLeadingWhitespace(actualLine) - countLeadingWhitespace(oldLine));
+	}
+
+	if (deltas.length === 0) {
+		return newText;
+	}
+
+	const delta = deltas[0];
+	if (!deltas.every((value) => value === delta)) {
+		return newText;
+	}
 
 	if (delta === 0) {
 		return newText;
 	}
 
-	const indentChar = detectIndentChar(actualText);
-	const lines = newText.split("\n");
+	if (newProfile.char && actualProfile.char && newProfile.char !== actualProfile.char) {
+		return newText;
+	}
 
-	const adjusted = lines.map((line) => {
+	const indentChar = actualProfile.char ?? oldProfile.char ?? detectIndentChar(actualText);
+	const adjusted = newText.split("\n").map((line) => {
 		if (line.trim().length === 0) {
-			return line; // Preserve empty/whitespace-only lines as-is
+			return line;
 		}
-
 		if (delta > 0) {
 			return indentChar.repeat(delta) + line;
 		}
-
-		// Remove indentation (delta < 0)
 		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
 		return line.slice(toRemove);
 	});