Move to dedicated replacement-engine which is applied at beginning of processing every replacement-block

Author: Ruakij

src/core/diff/strategies/engines/superfluous-duplicated-line.engine.ts

@@ -0,0 +1,46 @@
+import { SearchReplaceContext } from "../multi-search-replace"
+
+export class SuperfluousDuplicatedLineEngine {
+	public static process(originalContent: string, context: SearchReplaceContext): SearchReplaceContext {
+		const { startLine, searchContent, replaceContent } = context
+
+		// Early detection of superfluous duplicated line pattern
+		// Check if replace content has more lines than search content
+		const searchLines = searchContent.split(/\r?\n/)
+		const replaceLines = replaceContent.split(/\r?\n/)
+		const originalLines = originalContent.split(/\r?\n/)
+
+		if (searchLines.length > 0 && replaceLines.length > searchLines.length && startLine > 0) {
+			// Check if the first part of replace content is similar to search content
+			const firstPartOfReplace = replaceLines.slice(0, searchLines.length).join("\n")
+
+			// Simple similarity check (we can make this more sophisticated later)
+			const isFirstPartSimilar = firstPartOfReplace === searchContent
+
+			if (isFirstPartSimilar && replaceLines.length > searchLines.length) {
+				// Get the line that comes after the search block in replace content
+				const lineAfterSearchInReplace = replaceLines[searchLines.length]
+
+				// Get the line that comes after the search block in original content
+				const lineIndexInOriginal = startLine - 1 + searchLines.length
+				if (lineIndexInOriginal < originalLines.length) {
+					const lineAfterSearchInOriginal = originalLines[lineIndexInOriginal]
+
+					// If they match, it's likely a superfluous duplicated line scenario
+					// We can modify the search content to include the extra line
+					if (lineAfterSearchInReplace.trim() === lineAfterSearchInOriginal.trim()) {
+						const modifiedSearchContent = searchContent + "\n" + lineAfterSearchInOriginal
+						return {
+							startLine,
+							searchContent: modifiedSearchContent,
+							replaceContent,
+						}
+					}
+				}
+			}
+		}
+
+		// No modification needed, return as-is
+		return context
+	}
+}

src/core/diff/strategies/multi-search-replace.ts

@@ -7,6 +7,13 @@ import { ToolProgressStatus } from "@roo-code/types"
 import { addLineNumbers, everyLineHasLineNumbers, stripLineNumbers } from "../../../integrations/misc/extract-text"
 import { ToolUse, DiffStrategy, DiffResult } from "../../../shared/tools"
 import { normalizeString } from "../../../utils/text-normalization"
+import { SuperfluousDuplicatedLineEngine } from "./engines/superfluous-duplicated-line.engine"
+
+export interface SearchReplaceContext {
+	startLine: number
+	searchContent: string
+	replaceContent: string
+}
 
 const BUFFER_LINES = 40 // Number of extra context lines to show before and after matches
 
@@ -406,6 +413,19 @@ Only use a single line of '=======' between search and replacement content, beca
 			let { searchContent, replaceContent } = replacement
 			let startLine = replacement.startLine + (replacement.startLine === 0 ? 0 : delta)
 
+			// --- Start: Replacement Engine Processing ---
+			let context = SuperfluousDuplicatedLineEngine.process(originalContent, {
+				startLine,
+				searchContent,
+				replaceContent,
+			})
+
+			// Update variables from engine processing
+			startLine = context.startLine
+			searchContent = context.searchContent
+			replaceContent = context.replaceContent
+			// --- End: Replacement Engine Processing ---
+
 			// First unescape any escaped markers in the content
 			searchContent = this.unescapeMarkers(searchContent)
 			replaceContent = this.unescapeMarkers(replaceContent)
@@ -591,33 +611,6 @@ Only use a single line of '=======' between search and replacement content, beca
 			// Initialize effectiveSearchLinesCount (determines how many lines from original are considered "replaced")
 			let effectiveSearchLinesCount = searchLines.length // Default
 
-			// Heuristic to adjust effectiveSearchLinesCount for superfluous duplicated line pattern
-			if (searchLines.length > 0 && replaceLines.length > searchLines.length) {
-				const searchBlockContent = searchLines.join("\n")
-				// Ensure replaceLines has enough elements before slicing
-				const firstPartOfReplaceBlock = replaceLines.slice(0, searchLines.length).join("\n")
-
-				// Check if the search content is highly similar to the beginning of the replace content
-				if (getSimilarity(searchBlockContent, firstPartOfReplaceBlock) > 0.95) {
-					// Ensure there's a line in replaceLines immediately after the part that matches searchLines
-					if (searchLines.length < replaceLines.length) {
-						const lineInReplaceAfterPrefix = replaceLines[searchLines.length]
-
-						// Ensure there's a line in the original content (resultLines) immediately after the matched search block
-						if (matchIndex + searchLines.length < resultLines.length) {
-							const lineInOriginalAfterMatchedSearch = resultLines[matchIndex + searchLines.length]
-
-							// If the line in the replace block (after the prefix) is identical (ignoring leading/trailing whitespace)
-							// to the line in the original content (after the search match),
-							// it's likely a duplicated line scenario.
-							if (lineInReplaceAfterPrefix.trim() === lineInOriginalAfterMatchedSearch.trim()) {
-								effectiveSearchLinesCount = searchLines.length + 1 // Consume the duplicated line from the original
-							}
-						}
-					}
-				}
-			}
-
 			// Construct the final content
 			const beforeMatch = resultLines.slice(0, matchIndex)
 			// Use effectiveSearchLinesCount here to determine the slice point