fix(ghost): process deletes before inserts when applying edits

We need to compute the Inserts and Deletes from the all operations before each group. Now we pass in `initialLineOffset` to account for previously applied group line offsets

Author: Chris Hasson

src/services/ghost/GhostWorkspaceEdit.ts

@@ -5,7 +5,11 @@ import { GhostSuggestionsState } from "./GhostSuggestions"
 export class GhostWorkspaceEdit {
 	private locked: boolean = false
 
-	private async applyOperations(documentUri: vscode.Uri, operations: GhostSuggestionEditOperation[]) {
+	private async applyOperations(
+		documentUri: vscode.Uri,
+		operations: GhostSuggestionEditOperation[],
+		initialLineOffset: number = 0,
+	) {
 		const workspaceEdit = new vscode.WorkspaceEdit()
 		if (operations.length === 0) {
 			return // No operations to apply
@@ -16,34 +20,30 @@ export class GhostWorkspaceEdit {
 			console.log(`Could not open document: ${documentUri.toString()}`)
 			return
 		}
-		const deleteOps = operations.filter((op) => op.type === "-")
-		const insertOps = operations.filter((op) => op.type === "+")
 
-		let delPtr = 0
-		let insPtr = 0
-		let lineOffset = 0
+		// Process all deletes first, then all inserts
+		const deleteOps = operations.filter((op) => op.type === "-").sort((a, b) => b.line - a.line) // Sort deletes in reverse order
+		const insertOps = operations.filter((op) => op.type === "+").sort((a, b) => a.line - b.line) // Sort inserts in forward order
 
-		while (delPtr < deleteOps.length || insPtr < insertOps.length) {
-			const nextDeleteOriginalLine = deleteOps[delPtr]?.line ?? Infinity
-			const nextInsertOriginalLine = (insertOps[insPtr]?.line ?? Infinity) - lineOffset
-
-			if (nextDeleteOriginalLine <= nextInsertOriginalLine) {
-				// Process the deletion next
-				const op = deleteOps[delPtr]
-				const range = document.lineAt(op.line).rangeIncludingLineBreak
+		// Process all deletions first (in reverse line order to avoid line number shifts)
+		let currentLineOffset = initialLineOffset
+		for (const op of deleteOps) {
+			const adjustedLine = op.line + currentLineOffset
+			if (adjustedLine >= 0 && adjustedLine < document.lineCount) {
+				const range = document.lineAt(adjustedLine).rangeIncludingLineBreak
 				workspaceEdit.delete(documentUri, range)
+				currentLineOffset-- // Each deletion shifts subsequent lines up
+			}
+		}
 
-				lineOffset--
-				delPtr++
-			} else {
-				// Process the insertion next
-				const op = insertOps[insPtr]
-				const position = new vscode.Position(nextInsertOriginalLine, 0)
+		// Process all insertions (in forward line order)
+		for (const op of insertOps) {
+			const adjustedLine = op.line + currentLineOffset
+			if (adjustedLine >= 0) {
+				const position = new vscode.Position(adjustedLine, 0)
 				const textToInsert = (op.content || "") + "\n"
 				workspaceEdit.insert(documentUri, position, textToInsert)
-
-				lineOffset++
-				insPtr++
+				currentLineOffset++ // Each insertion shifts subsequent lines down
 			}
 		}
 
@@ -67,18 +67,22 @@ export class GhostWorkspaceEdit {
 		await vscode.workspace.applyEdit(workspaceEdit)
 	}
 
-	private async applyOperationsPlaceholders(documentUri: vscode.Uri, operations: GhostSuggestionEditOperation[]) {
+	private async applyOperationsPlaceholders(
+		documentUri: vscode.Uri,
+		operations: GhostSuggestionEditOperation[],
+		lineOffset: number = 0,
+	) {
 		const workspaceEdit = new vscode.WorkspaceEdit()
 		const document = await vscode.workspace.openTextDocument(documentUri)
 		if (!document) {
 			console.log(`Could not open document: ${documentUri.toString()}`)
 			return
 		}
 
-		let lineOffset = 0
+		let currentLineOffset = lineOffset
 		for (const op of operations) {
 			// Calculate the equivalent line in the *original* document.
-			const originalLine = op.line - lineOffset
+			const originalLine = op.line - currentLineOffset
 
 			// A quick guard against invalid operations.
 			if (originalLine < 0) {
@@ -89,15 +93,15 @@ export class GhostWorkspaceEdit {
 				const position = new vscode.Position(originalLine, 0)
 				const textToInsert = "\n"
 				workspaceEdit.insert(documentUri, position, textToInsert)
-				lineOffset++
+				currentLineOffset++
 			}
 
 			if (op.type === "-") {
 				// Guard against deleting a line that doesn't exist.
 				if (originalLine >= document.lineCount) {
 					continue
 				}
-				lineOffset--
+				currentLineOffset--
 			}
 		}