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

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);
 	});