Enhance MultiSearchReplaceDiffStrategy to handle line duplication heuristics in applyDiff method

Author: Ruakij

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

@@ -2686,4 +2686,167 @@ function two() {
 			expect(result.error).toContain(":start_line:5    <-- Invalid location")
 		})
 	})
+
+	describe("Generalized line duplication heuristic", () => {
+		let strategy: MultiSearchReplaceDiffStrategy
+
+		beforeEach(() => {
+			strategy = new MultiSearchReplaceDiffStrategy()
+		})
+
+		it("should correctly append content and avoid duplicating a closing brace", async () => {
+			const originalContent = `function test() {
+	console.log("original");
+}`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:2
+-------
+	console.log("original");
+=======
+	console.log("original");
+}
+function newFunction() {
+	console.log("appended");
+}
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`function test() {
+	console.log("original");
+}
+function newFunction() {
+	console.log("appended");
+}`)
+		})
+
+		it("should correctly append content and avoid duplicating a common line", async () => {
+			const originalContent = `Section A
+Common Line to keep
+Section B`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:1
+-------
+Section A
+=======
+Section A
+Common Line to keep
+New Appended Content
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`Section A
+Common Line to keep
+New Appended Content
+Section B`)
+		})
+
+		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)
+Line 3`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:1
+-------
+Line 1
+=======
+Line 1
+Line X (different next in replace)
+Appended Content
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`Line 1
+Line X (different next in replace)
+Appended Content
+Line 2 (original next)
+Line 3`)
+		})
+
+		it("should not trigger heuristic if SEARCH content is not a prefix of REPLACE content", async () => {
+			const originalContent = `Alpha
+Bravo
+Charlie`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:1
+-------
+Alpha
+=======
+Completely New Content
+Even More New Content
+Bravo
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`Completely New Content
+Even More New Content
+Bravo
+Bravo
+Charlie`)
+		})
+
+		it("should handle edge case where heuristic conditions are met but no line follows search in original", async () => {
+			const originalContent = `Last Line`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:1
+-------
+Last Line
+=======
+Last Line
+New Line
+Added Content
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			if (result.success)
+				expect(result.content).toBe(`Last Line
+New Line
+Added Content`)
+		})
+
+		it("should handle case where similarity threshold is not met", async () => {
+			const originalContent = `Original Content
+Next Line
+Final Line`
+
+			const diffContent = `<<<<<<< SEARCH
+:start_line:1
+-------
+Original Content
+=======
+Completely Different Content
+Next Line
+Appended Content
+>>>>>>> REPLACE`
+
+			const result = await strategy.applyDiff(originalContent, diffContent)
+
+			expect(result.success).toBe(true)
+			// Should behave as normal replacement since similarity < 0.95
+			if (result.success)
+				expect(result.content).toBe(`Completely Different Content
+Next Line
+Appended Content
+Next Line
+Final Line`)
+		})
+	})
 })

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

@@ -588,11 +588,44 @@ Only use a single line of '=======' between search and replacement content, beca
 				return finalIndent + line.trim()
 			})
 
+			// 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)
-			const afterMatch = resultLines.slice(matchIndex + searchLines.length)
+			// Use effectiveSearchLinesCount here to determine the slice point
+			const afterMatch = resultLines.slice(matchIndex + effectiveSearchLinesCount)
+
 			resultLines = [...beforeMatch, ...indentedReplaceLines, ...afterMatch]
-			delta = delta - matchedLines.length + replaceLines.length
+			// Use effectiveSearchLinesCount for delta calculation
+			delta = delta - effectiveSearchLinesCount + replaceLines.length
 			appliedCount++
 		}
 		const finalContent = resultLines.join(lineEnding)