Fco edge case fixes and tests (final push until review)

- folders were getting diffed, added a check to prevent this.
- .roo now excluded from checkpoint diffs
- diffs for FCO now only check line changes vs full diff changes. This is a preventative measure due to search and replace calls rewriting the entire file.
- tests for these edge cases added.

Author: playcations

src/core/checkpoints/index.ts

@@ -160,44 +160,80 @@ export function getCheckpointService(cline: Task) {
 				try {
 					const checkpointFileChangeManager = provider?.getFileChangeManager()
 					if (checkpointFileChangeManager) {
-						// Get the initial baseline (preserve for cumulative diff tracking)
-						let initialBaseline = checkpointFileChangeManager.getChanges().baseCheckpoint
+						// Get the current baseline for cumulative tracking
+						let currentBaseline = checkpointFileChangeManager.getChanges().baseCheckpoint
 
-						// Validate that the baseline exists in the shadow repository before attempting diff
-						// If the baseline doesn't exist (e.g., from a previous task session), fall back to shadow repo base
+						// For cumulative tracking, we want to calculate from baseline to new checkpoint
+						// But if this is the first time or baseline is invalid, update it to fromHash
 						try {
-							await service.getDiff({ from: initialBaseline, to: initialBaseline })
+							await service.getDiff({ from: currentBaseline, to: currentBaseline })
+							log(
+								`[Task#checkpointCreated] Using existing baseline ${currentBaseline} for cumulative tracking`,
+							)
 						} catch (baselineValidationError) {
-							const shadowBase = service.baseHash || toHash
+							// Baseline is invalid, use fromHash as the new baseline for cumulative tracking
 							log(
-								`[Task#checkpointCreated] Initial baseline ${initialBaseline} not found in shadow repo, falling back to shadow base ${shadowBase}`,
+								`[Task#checkpointCreated] Baseline validation failed for ${currentBaseline}: ${baselineValidationError instanceof Error ? baselineValidationError.message : String(baselineValidationError)}`,
 							)
-							initialBaseline = shadowBase
-							// Update FileChangeManager baseline to match shadow repository
-							await checkpointFileChangeManager.updateBaseline(initialBaseline)
+							log(`[Task#checkpointCreated] Updating baseline to fromHash: ${fromHash}`)
+							currentBaseline = fromHash
+							// Update FileChangeManager baseline to match
+							try {
+								await checkpointFileChangeManager.updateBaseline(currentBaseline)
+								log(`[Task#checkpointCreated] Successfully updated baseline to ${currentBaseline}`)
+							} catch (updateError) {
+								log(
+									`[Task#checkpointCreated] Failed to update baseline: ${updateError instanceof Error ? updateError.message : String(updateError)}`,
+								)
+								throw updateError
+							}
 						}
 
 						log(
-							`[Task#checkpointCreated] Calculating cumulative changes from validated baseline ${initialBaseline} to ${toHash}`,
+							`[Task#checkpointCreated] Calculating cumulative changes from baseline ${currentBaseline} to ${toHash}`,
 						)
 
-						// Calculate cumulative diff from validated baseline to new checkpoint using checkpoint service
-						const changes = await service.getDiff({ from: initialBaseline, to: toHash })
+						// Calculate cumulative diff from baseline to new checkpoint using checkpoint service
+						const changes = await service.getDiff({ from: currentBaseline, to: toHash })
 
 						if (changes && changes.length > 0) {
 							// Convert to FileChange format with correct checkpoint references
-							const fileChanges = changes.map((change: any) => ({
-								uri: change.paths.relative,
-								type: (change.paths.newFile
-									? "create"
-									: change.paths.deletedFile
-										? "delete"
-										: "edit") as FileChangeType,
-								fromCheckpoint: initialBaseline, // Always reference initial baseline for cumulative view
-								toCheckpoint: toHash, // Current checkpoint for comparison
-								linesAdded: change.content.after ? change.content.after.split("\n").length : 0,
-								linesRemoved: change.content.before ? change.content.before.split("\n").length : 0,
-							}))
+							const fileChanges = changes.map((change: any) => {
+								const type = (
+									change.paths.newFile ? "create" : change.paths.deletedFile ? "delete" : "edit"
+								) as FileChangeType
+
+								// Calculate actual line differences for the change
+								let linesAdded = 0
+								let linesRemoved = 0
+
+								if (type === "create") {
+									// New file: all lines are added
+									linesAdded = change.content.after ? change.content.after.split("\n").length : 0
+									linesRemoved = 0
+								} else if (type === "delete") {
+									// Deleted file: all lines are removed
+									linesAdded = 0
+									linesRemoved = change.content.before ? change.content.before.split("\n").length : 0
+								} else {
+									// Modified file: use FileChangeManager's improved calculation method
+									const lineDifferences = FileChangeManager.calculateLineDifferences(
+										change.content.before || "",
+										change.content.after || "",
+									)
+									linesAdded = lineDifferences.linesAdded
+									linesRemoved = lineDifferences.linesRemoved
+								}
+
+								return {
+									uri: change.paths.relative,
+									type,
+									fromCheckpoint: currentBaseline, // Reference current baseline for cumulative view
+									toCheckpoint: toHash, // Current checkpoint for comparison
+									linesAdded,
+									linesRemoved,
+								}
+							})
 
 							log(`[Task#checkpointCreated] Found ${fileChanges.length} cumulative file changes`)
 
@@ -228,13 +264,13 @@ export function getCheckpointService(cline: Task) {
 								filesChanged: serializableChangeset,
 							})
 						} else {
-							log(`[Task#checkpointCreated] No changes found between ${initialBaseline} and ${toHash}`)
+							log(`[Task#checkpointCreated] No changes found between ${currentBaseline} and ${toHash}`)
 						}
 
-						// DON'T update the baseline - keep it at initial baseline for cumulative tracking
+						// DON'T update the baseline - keep it at current baseline for cumulative tracking
 						// The baseline should only change when explicitly requested (e.g., checkpoint restore)
 						log(
-							`[Task#checkpointCreated] Keeping FileChangeManager baseline at ${initialBaseline} for cumulative tracking`,
+							`[Task#checkpointCreated] Keeping FileChangeManager baseline at ${currentBaseline} for cumulative tracking`,
 						)
 					}
 				} catch (error) {
@@ -419,12 +455,14 @@ export async function checkpointRestore(cline: Task, { ts, commitHash, mode }: C
 					provider?.log(`[checkpointRestore] Cleared accept/reject state for fresh start`)
 				}
 
-				// Calculate and send current changes (should be empty immediately after restore)
-				const changes = fileChangeManager.getChanges()
-				provider?.postMessageToWebview({
-					type: "filesChanged",
-					filesChanged: changes.files.length > 0 ? changes : undefined,
-				})
+				// Calculate and send current changes with LLM-only filtering (should be empty immediately after restore)
+				if (cline.taskId && cline.fileContextTracker) {
+					const changes = await fileChangeManager.getLLMOnlyChanges(cline.taskId, cline.fileContextTracker)
+					provider?.postMessageToWebview({
+						type: "filesChanged",
+						filesChanged: changes.files.length > 0 ? changes : undefined,
+					})
+				}
 			}
 		} catch (error) {
 			provider?.log(`[checkpointRestore] Failed to update FileChangeManager baseline: ${error}`)

src/services/checkpoints/ShadowCheckpointService.ts

@@ -308,6 +308,17 @@ export abstract class ShadowCheckpointService extends EventEmitter {
 		for (const file of files) {
 			const relPath = file.file
 			const absPath = path.join(cwdPath, relPath)
+
+			// Filter out directories - only include actual files
+			try {
+				const stat = await fs.stat(absPath)
+				if (stat.isDirectory()) {
+					continue // Skip directories
+				}
+			} catch {
+				// If file doesn't exist (deleted files), continue processing
+			}
+
 			const before = await this.git.show([`${from}:${relPath}`]).catch(() => "")
 
 			const after = await this.git.show([`${to ?? "HEAD"}:${relPath}`]).catch(() => "")

src/services/checkpoints/excludes.ts

@@ -198,6 +198,7 @@ const getLfsPatterns = async (workspacePath: string) => {
 
 export const getExcludePatterns = async (workspacePath: string) => [
 	".git/",
+	".roo/",
 	...getBuildArtifactPatterns(),
 	...getMediaFilePatterns(),
 	...getCacheFilePatterns(),

src/services/file-changes/FCOMessageHandler.ts

@@ -44,10 +44,14 @@ export class FCOMessageHandler {
 				if (!fileChangeManager) {
 					fileChangeManager = await this.provider.ensureFileChangeManager()
 				}
-				if (fileChangeManager) {
+				if (fileChangeManager && task?.taskId && task?.fileContextTracker) {
+					const filteredChangeset = await fileChangeManager.getLLMOnlyChanges(
+						task.taskId,
+						task.fileContextTracker,
+					)
 					this.provider.postMessageToWebview({
 						type: "filesChanged",
-						filesChanged: fileChangeManager.getChanges(),
+						filesChanged: filteredChangeset.files.length > 0 ? filteredChangeset : undefined,
 					})
 				}
 				break
@@ -171,15 +175,19 @@ export class FCOMessageHandler {
 	}
 
 	private async handleAcceptFileChange(message: WebviewMessage): Promise<void> {
+		const task = this.provider.getCurrentCline()
 		let acceptFileChangeManager = this.provider.getFileChangeManager()
 		if (!acceptFileChangeManager) {
 			acceptFileChangeManager = await this.provider.ensureFileChangeManager()
 		}
-		if (message.uri && acceptFileChangeManager) {
+		if (message.uri && acceptFileChangeManager && task?.taskId && task?.fileContextTracker) {
 			await acceptFileChangeManager.acceptChange(message.uri)
 
-			// Send updated state
-			const updatedChangeset = acceptFileChangeManager.getChanges()
+			// Send updated state with LLM-only filtering
+			const updatedChangeset = await acceptFileChangeManager.getLLMOnlyChanges(
+				task.taskId,
+				task.fileContextTracker,
+			)
 			this.provider.postMessageToWebview({
 				type: "filesChanged",
 				filesChanged: updatedChangeset.files.length > 0 ? updatedChangeset : undefined,
@@ -225,13 +233,18 @@ export class FCOMessageHandler {
 			// Remove from tracking since the file has been reverted
 			await rejectFileChangeManager.rejectChange(message.uri)
 
-			// Send updated state
-			const updatedChangeset = rejectFileChangeManager.getChanges()
-			console.log(`[FCO] After rejection, sending ${updatedChangeset.files.length} files to webview`)
-			this.provider.postMessageToWebview({
-				type: "filesChanged",
-				filesChanged: updatedChangeset.files.length > 0 ? updatedChangeset : undefined,
-			})
+			// Send updated state with LLM-only filtering
+			if (currentTask?.taskId && currentTask?.fileContextTracker) {
+				const updatedChangeset = await rejectFileChangeManager.getLLMOnlyChanges(
+					currentTask.taskId,
+					currentTask.fileContextTracker,
+				)
+				console.log(`[FCO] After rejection, sending ${updatedChangeset.files.length} LLM-only files to webview`)
+				this.provider.postMessageToWebview({
+					type: "filesChanged",
+					filesChanged: updatedChangeset.files.length > 0 ? updatedChangeset : undefined,
+				})
+			}
 		} catch (error) {
 			console.error(`[FCO] Error reverting file ${message.uri}:`, error)
 			// Fall back to old behavior (just remove from display) if reversion fails
@@ -341,12 +354,17 @@ export class FCOMessageHandler {
 					fileChangeManager.setFiles(fileChanges)
 				}
 
-				// Get filtered changeset and send to webview
-				const filteredChangeset = fileChangeManager.getChanges()
-				this.provider.postMessageToWebview({
-					type: "filesChanged",
-					filesChanged: filteredChangeset.files.length > 0 ? filteredChangeset : undefined,
-				})
+				// Get filtered changeset with LLM-only filtering and send to webview
+				if (task?.taskId && task?.fileContextTracker) {
+					const filteredChangeset = await fileChangeManager.getLLMOnlyChanges(
+						task.taskId,
+						task.fileContextTracker,
+					)
+					this.provider.postMessageToWebview({
+						type: "filesChanged",
+						filesChanged: filteredChangeset.files.length > 0 ? filteredChangeset : undefined,
+					})
+				}
 			} else {
 				this.provider.postMessageToWebview({
 					type: "filesChanged",

src/services/file-changes/FileChangeManager.ts

@@ -145,17 +145,40 @@ export class FileChangeManager {
 
 	/**
 	 * Calculate line differences between two file contents
+	 * Uses a simple line-by-line comparison to count actual changes
 	 */
 	public static calculateLineDifferences(
 		originalContent: string,
 		newContent: string,
 	): { linesAdded: number; linesRemoved: number } {
-		const originalLines = originalContent.split("\n")
-		const newLines = newContent.split("\n")
-
-		// Simple diff calculation
-		const linesAdded = Math.max(0, newLines.length - originalLines.length)
-		const linesRemoved = Math.max(0, originalLines.length - newLines.length)
+		const originalLines = originalContent === "" ? [] : originalContent.split("\n")
+		const newLines = newContent === "" ? [] : newContent.split("\n")
+
+		// For proper diff calculation, we need to compare line by line
+		// This is a simplified approach that works well for most cases
+
+		const maxLines = Math.max(originalLines.length, newLines.length)
+		let linesAdded = 0
+		let linesRemoved = 0
+
+		// Compare each line position
+		for (let i = 0; i < maxLines; i++) {
+			const originalLine = i < originalLines.length ? originalLines[i] : undefined
+			const newLine = i < newLines.length ? newLines[i] : undefined
+
+			if (originalLine === undefined && newLine !== undefined) {
+				// Line was added
+				linesAdded++
+			} else if (originalLine !== undefined && newLine === undefined) {
+				// Line was removed
+				linesRemoved++
+			} else if (originalLine !== newLine) {
+				// Line was modified (count as both removed and added)
+				linesRemoved++
+				linesAdded++
+			}
+			// If lines are identical, no change
+		}
 
 		return { linesAdded, linesRemoved }
 	}

src/services/file-changes/__tests__/FileChangeManager.test.ts

@@ -324,6 +324,76 @@ describe("FileChangeManager (Simplified)", () => {
 			expect(result.linesAdded).toBe(0)
 			expect(result.linesRemoved).toBe(0)
 		})
+
+		it("should handle line modifications (search and replace)", () => {
+			const original = "function test() {\n  return 'old';\n}"
+			const modified = "function test() {\n  return 'new';\n}"
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(1) // Modified line counts as added
+			expect(result.linesRemoved).toBe(1) // Modified line counts as removed
+		})
+
+		it("should handle mixed changes", () => {
+			const original = "line1\nold_line\nline3"
+			const modified = "line1\nnew_line\nline3\nextra_line"
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(2) // 1 modified + 1 added
+			expect(result.linesRemoved).toBe(1) // 1 modified
+		})
+
+		it("should handle empty original file", () => {
+			const original = ""
+			const modified = "line1\nline2\nline3"
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(3)
+			expect(result.linesRemoved).toBe(0)
+		})
+
+		it("should handle empty modified file", () => {
+			const original = "line1\nline2\nline3"
+			const modified = ""
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(0)
+			expect(result.linesRemoved).toBe(3)
+		})
+
+		it("should handle both files empty", () => {
+			const original = ""
+			const modified = ""
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(0)
+			expect(result.linesRemoved).toBe(0)
+		})
+
+		it("should handle single line files", () => {
+			const original = "single line"
+			const modified = "different line"
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(1)
+			expect(result.linesRemoved).toBe(1)
+		})
+
+		it("should handle whitespace-only changes", () => {
+			const original = "line1\n  indented\nline3"
+			const modified = "line1\n    indented\nline3"
+
+			const result = FileChangeManager.calculateLineDifferences(original, modified)
+
+			expect(result.linesAdded).toBe(1) // Whitespace change counts as modification
+			expect(result.linesRemoved).toBe(1)
+		})
 	})
 
 	describe("getLLMOnlyChanges", () => {