Generalize duplicated line detection (>=1), use match index, add tests

Author: Ruakij

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

@@ -2748,6 +2748,42 @@ New Appended Content
 Section B`)
 		})
 
+		it("should correctly append content and avoid duplicating multiple lines with nested braces", async () => {
+			const originalContent = `function devConfig() {
+	return {
+		name: "test"
+	};
+}`
+
+			const diffContent = `<<<<<<< SEARCH
+		name: "test"
+=======
+		name: "test"
+	};
+}
+function prodConfig() {
+	return {
+		name: "prod"
+	};
+}
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`function devConfig() {
+	return {
+		name: "test"
+	};
+}
+function prodConfig() {
+	return {
+		name: "prod"
+	};
+}`)
+		})
+
 		it("should not alter behavior when the line after search prefix in REPLACE differs from original line after SEARCH", async () => {
 			const originalContent = `Line 1
 Line 2 (original next)

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

@@ -1,7 +1,15 @@
 import { SearchReplaceContext } from "../multi-search-replace"
 
 export class SuperfluousDuplicatedLineEngine {
-	public static process(originalContent: string, context: SearchReplaceContext): SearchReplaceContext {
+	/**
+	 * Processes a search/replace context to detect superfluous duplicated lines.
+	 *
+	 * @param originalContent The complete original content being modified
+	 * @param context The search/replace context containing startLine, searchContent, and replaceContent
+	 * @returns The number of additional lines from the original content that should be consumed
+	 *          to prevent duplication. Returns 0 if no additional lines should be consumed.
+	 */
+	public static process(originalContent: string, context: SearchReplaceContext): number {
 		const { startLine, searchContent, replaceContent } = context
 
 		// Early detection of superfluous duplicated line pattern
@@ -18,29 +26,38 @@ export class SuperfluousDuplicatedLineEngine {
 			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,
-						}
+				// Check for any number of consecutive matching lines after the search block
+				let matchingLinesCount = 0
+				const searchEndIndex = startLine - 1 + searchLines.length
+				const maxPossibleMatches = Math.min(
+					replaceLines.length - searchLines.length, // Available lines in replace content
+					originalLines.length - searchEndIndex, // Available lines in original content after search
+				)
+
+				for (let i = 0; i < maxPossibleMatches; i++) {
+					const replaceLineIndex = searchLines.length + i
+					const originalLineIndex = searchEndIndex + i
+
+					const lineInReplace = replaceLines[replaceLineIndex]
+					const lineInOriginal = originalLines[originalLineIndex]
+
+					// Check if lines match (trimmed comparison to handle whitespace differences)
+					if (lineInReplace && lineInOriginal && lineInReplace.trim() === lineInOriginal.trim()) {
+						matchingLinesCount++
+					} else {
+						// Stop at the first non-matching line
+						break
 					}
 				}
+
+				// If we found any matching lines, return the count
+				if (matchingLinesCount > 0) {
+					return matchingLinesCount
+				}
 			}
 		}
 
-		// No modification needed, return as-is
-		return context
+		// No additional lines to consume
+		return 0
 	}
 }

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

@@ -401,7 +401,7 @@ Only use a single line of '=======' between search and replacement content, beca
 		let delta = 0
 		let diffResults: DiffResult[] = []
 		let appliedCount = 0
-		const replacements = matches
+		const replacements: SearchReplaceContext[] = matches
 			.map((match) => ({
 				startLine: Number(match[2] ?? 0),
 				searchContent: match[6],
@@ -413,19 +413,6 @@ 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)
@@ -568,6 +555,19 @@ Only use a single line of '=======' between search and replacement content, beca
 				}
 			}
 
+			// --- Start: Replacement Engine Processing ---
+			// Now that we found the match, call the engine with the actual match location
+			const engineContext = {
+				startLine: matchIndex + 1, // Convert back to 1-based index for the engine
+				searchContent: replacement.searchContent,
+				replaceContent: replacement.replaceContent,
+			}
+			const additionalLinesToConsume = SuperfluousDuplicatedLineEngine.process(
+				resultLines.join("\n"),
+				engineContext,
+			)
+			// --- End: Replacement Engine Processing ---
+
 			// Get the matched lines from the original content
 			const matchedLines = resultLines.slice(matchIndex, matchIndex + searchLines.length)
 
@@ -609,7 +609,7 @@ 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
+			let effectiveSearchLinesCount = searchLines.length + additionalLinesToConsume
 
 			// Construct the final content
 			const beforeMatch = resultLines.slice(0, matchIndex)