feat: add granular checkboxes for re-read after edit settings

- Added reReadAfterEditGranular experiment with individual toggles for each edit operation type
- Updated all file editing tools to check their specific granular setting
- Created new ReReadAfterEditGranularSettings UI component with master toggle and individual checkboxes
- Maintained backward compatibility with legacy reReadAfterEdit setting that overrides granular settings
- Added comprehensive tests for the new granular settings functionality
- Added translations for the new UI elements

This allows users to selectively enable automatic review for specific edit types like:
- Apply Diff (search and replace blocks)
- Multi-file Apply Diff
- Write to File (complete file rewrites)
- Insert Content (add lines to files)
- Search and Replace (find and replace text)

Addresses Issue #8927 - implements the suggestion to have checkboxes for selecting review based on edit type

Author: roomote

packages/types/src/experiment.ts

@@ -13,6 +13,7 @@ export const experimentIds = [
 	"imageGeneration",
 	"runSlashCommand",
 	"reReadAfterEdit",
+	"reReadAfterEditGranular",
 ] as const
 
 export const experimentIdsSchema = z.enum(experimentIds)
@@ -23,13 +24,25 @@ export type ExperimentId = z.infer<typeof experimentIdsSchema>
  * Experiments
  */
 
+// Schema for granular re-read after edit settings
+export const reReadAfterEditGranularSchema = z.object({
+	applyDiff: z.boolean().optional(),
+	multiApplyDiff: z.boolean().optional(),
+	writeToFile: z.boolean().optional(),
+	insertContent: z.boolean().optional(),
+	searchAndReplace: z.boolean().optional(),
+})
+
+export type ReReadAfterEditGranular = z.infer<typeof reReadAfterEditGranularSchema>
+
 export const experimentsSchema = z.object({
 	powerSteering: z.boolean().optional(),
 	multiFileApplyDiff: z.boolean().optional(),
 	preventFocusDisruption: z.boolean().optional(),
 	imageGeneration: z.boolean().optional(),
 	runSlashCommand: z.boolean().optional(),
 	reReadAfterEdit: z.boolean().optional(),
+	reReadAfterEditGranular: reReadAfterEditGranularSchema.optional(),
 })
 
 export type Experiments = z.infer<typeof experimentsSchema>

src/core/tools/applyDiffTool.ts

@@ -238,11 +238,8 @@ export async function applyDiffToolLegacy(
 					? "\n<notice>Making multiple related changes in a single apply_diff is more efficient. If other changes are needed in this file, please include them as additional SEARCH/REPLACE blocks.</notice>"
 					: ""
 
-			// Check if RE_READ_AFTER_EDIT experiment is enabled
-			const isReReadAfterEditEnabled = experiments.isEnabled(
-				state?.experiments ?? {},
-				EXPERIMENT_IDS.RE_READ_AFTER_EDIT,
-			)
+			// Check if RE_READ_AFTER_EDIT experiment is enabled for applyDiff
+			const isReReadAfterEditEnabled = experiments.isReReadAfterEditEnabled(state?.experiments ?? {}, "applyDiff")
 
 			const reReadSuggestion = isReReadAfterEditEnabled
 				? `\n\n<review_suggestion>The file has been edited. Consider using the read_file tool to review the changes and ensure they are correct and complete.</review_suggestion>`

src/core/tools/insertContentTool.ts

@@ -184,11 +184,8 @@ export async function insertContentTool(
 		// Get the formatted response message
 		const message = await cline.diffViewProvider.pushToolWriteResult(cline, cline.cwd, !fileExists)
 
-		// Check if RE_READ_AFTER_EDIT experiment is enabled
-		const isReReadAfterEditEnabled = experiments.isEnabled(
-			state?.experiments ?? {},
-			EXPERIMENT_IDS.RE_READ_AFTER_EDIT,
-		)
+		// Check if RE_READ_AFTER_EDIT experiment is enabled for insertContent
+		const isReReadAfterEditEnabled = experiments.isReReadAfterEditEnabled(state?.experiments ?? {}, "insertContent")
 
 		const reReadSuggestion = isReReadAfterEditEnabled
 			? `\n\n<review_suggestion>Content has been inserted into the file. Consider using the read_file tool to review the changes and ensure they are correct and complete.</review_suggestion>`

src/core/tools/multiApplyDiffTool.ts

@@ -676,12 +676,12 @@ ${errorDetails ? `\nTechnical details:\n${errorDetails}\n` : ""}
 				? "\n<notice>Making multiple related changes in a single apply_diff is more efficient. If other changes are needed in this file, please include them as additional SEARCH/REPLACE blocks.</notice>"
 				: ""
 
-		// Check if RE_READ_AFTER_EDIT experiment is enabled
+		// Check if RE_READ_AFTER_EDIT experiment is enabled for multiApplyDiff
 		const provider = cline.providerRef.deref()
 		const state = await provider?.getState()
-		const isReReadAfterEditEnabled = experiments.isEnabled(
+		const isReReadAfterEditEnabled = experiments.isReReadAfterEditEnabled(
 			state?.experiments ?? {},
-			EXPERIMENT_IDS.RE_READ_AFTER_EDIT,
+			"multiApplyDiff",
 		)
 
 		// Count how many files were successfully edited

src/core/tools/searchAndReplaceTool.ts

@@ -258,10 +258,10 @@ export async function searchAndReplaceTool(
 			false, // Always false for search_and_replace
 		)
 
-		// Check if RE_READ_AFTER_EDIT experiment is enabled
-		const isReReadAfterEditEnabled = experiments.isEnabled(
+		// Check if RE_READ_AFTER_EDIT experiment is enabled for searchAndReplace
+		const isReReadAfterEditEnabled = experiments.isReReadAfterEditEnabled(
 			state?.experiments ?? {},
-			EXPERIMENT_IDS.RE_READ_AFTER_EDIT,
+			"searchAndReplace",
 		)
 
 		const reReadSuggestion = isReReadAfterEditEnabled

src/core/tools/writeToFileTool.ts

@@ -304,10 +304,10 @@ export async function writeToFileTool(
 			// Get the formatted response message
 			const message = await cline.diffViewProvider.pushToolWriteResult(cline, cline.cwd, !fileExists)
 
-			// Check if RE_READ_AFTER_EDIT experiment is enabled
-			const isReReadAfterEditEnabled = experiments.isEnabled(
+			// Check if RE_READ_AFTER_EDIT experiment is enabled for writeToFile
+			const isReReadAfterEditEnabled = experiments.isReReadAfterEditEnabled(
 				state?.experiments ?? {},
-				EXPERIMENT_IDS.RE_READ_AFTER_EDIT,
+				"writeToFile",
 			)
 
 			const reReadSuggestion = isReReadAfterEditEnabled

src/shared/__tests__/experiments-granular.spec.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from "vitest"
+import type { Experiments, ReReadAfterEditGranular } from "@roo-code/types"
+import { experiments } from "../experiments"
+
+describe("granular re-read after edit experiment", () => {
+	describe("isReReadAfterEditEnabled", () => {
+		it("should return true when legacy reReadAfterEdit is enabled", () => {
+			const config: Experiments = {
+				reReadAfterEdit: true,
+			}
+
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(true)
+		})
+
+		it("should return false when legacy reReadAfterEdit is disabled and no granular settings", () => {
+			const config: Experiments = {
+				reReadAfterEdit: false,
+			}
+
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(false)
+		})
+
+		it("should return true for specific edit types when granular settings are enabled", () => {
+			const config: Experiments = {
+				reReadAfterEdit: false,
+				reReadAfterEditGranular: {
+					applyDiff: true,
+					multiApplyDiff: false,
+					writeToFile: true,
+					insertContent: false,
+					searchAndReplace: true,
+				},
+			}
+
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(true)
+		})
+
+		it("should prioritize legacy setting over granular when both are present", () => {
+			const config: Experiments = {
+				reReadAfterEdit: true, // Legacy enabled
+				reReadAfterEditGranular: {
+					applyDiff: false, // Granular disabled
+					multiApplyDiff: false,
+					writeToFile: false,
+					insertContent: false,
+					searchAndReplace: false,
+				},
+			}
+
+			// Legacy setting should override granular settings
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(true)
+		})
+
+		it("should handle partial granular settings", () => {
+			const config: Experiments = {
+				reReadAfterEdit: false,
+				reReadAfterEditGranular: {
+					applyDiff: true,
+					// Other fields undefined
+				} as ReReadAfterEditGranular,
+			}
+
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(true)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(false)
+		})
+
+		it("should return false when no experiments config is provided", () => {
+			const config: Experiments = {}
+
+			expect(experiments.isReReadAfterEditEnabled(config, "applyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "multiApplyDiff")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "writeToFile")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "insertContent")).toBe(false)
+			expect(experiments.isReReadAfterEditEnabled(config, "searchAndReplace")).toBe(false)
+		})
+	})
+})

src/shared/__tests__/experiments.spec.ts

@@ -1,6 +1,6 @@
 // npx vitest run src/shared/__tests__/experiments.spec.ts
 
-import type { ExperimentId } from "@roo-code/types"
+import type { ExperimentId, Experiments as ExperimentsType } from "@roo-code/types"
 
 import { EXPERIMENT_IDS, experimentConfigsMap, experiments as Experiments } from "../experiments"
 
@@ -25,39 +25,51 @@ describe("experiments", () => {
 
 	describe("isEnabled", () => {
 		it("returns false when POWER_STEERING experiment is not enabled", () => {
-			const experiments: Record<ExperimentId, boolean> = {
+			const experiments: ExperimentsType = {
 				powerSteering: false,
 				multiFileApplyDiff: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
 				runSlashCommand: false,
 				reReadAfterEdit: false,
+				reReadAfterEditGranular: undefined,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(false)
 		})
 
 		it("returns true when experiment POWER_STEERING is enabled", () => {
-			const experiments: Record<ExperimentId, boolean> = {
+			const experiments: ExperimentsType = {
 				powerSteering: true,
 				multiFileApplyDiff: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
 				runSlashCommand: false,
 				reReadAfterEdit: false,
+				reReadAfterEditGranular: undefined,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(true)
 		})
 
 		it("returns false when experiment is not present", () => {
-			const experiments: Record<ExperimentId, boolean> = {
+			const experiments: ExperimentsType = {
 				powerSteering: false,
 				multiFileApplyDiff: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
 				runSlashCommand: false,
 				reReadAfterEdit: false,
+				reReadAfterEditGranular: undefined,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(false)
 		})
 	})
+
+	describe("RE_READ_AFTER_EDIT_GRANULAR", () => {
+		it("is configured correctly", () => {
+			expect(EXPERIMENT_IDS.RE_READ_AFTER_EDIT_GRANULAR).toBe("reReadAfterEditGranular")
+			expect(experimentConfigsMap.RE_READ_AFTER_EDIT_GRANULAR).toMatchObject({
+				enabled: false,
+			})
+		})
+	})
 })

src/shared/experiments.ts

@@ -1,4 +1,12 @@
-import type { AssertEqual, Equals, Keys, Values, ExperimentId, Experiments } from "@roo-code/types"
+import type {
+	AssertEqual,
+	Equals,
+	Keys,
+	Values,
+	ExperimentId,
+	Experiments,
+	ReReadAfterEditGranular,
+} from "@roo-code/types"
 
 export const EXPERIMENT_IDS = {
 	MULTI_FILE_APPLY_DIFF: "multiFileApplyDiff",
@@ -7,14 +15,15 @@ export const EXPERIMENT_IDS = {
 	IMAGE_GENERATION: "imageGeneration",
 	RUN_SLASH_COMMAND: "runSlashCommand",
 	RE_READ_AFTER_EDIT: "reReadAfterEdit",
+	RE_READ_AFTER_EDIT_GRANULAR: "reReadAfterEditGranular",
 } as const satisfies Record<string, ExperimentId>
 
 type _AssertExperimentIds = AssertEqual<Equals<ExperimentId, Values<typeof EXPERIMENT_IDS>>>
 
 type ExperimentKey = Keys<typeof EXPERIMENT_IDS>
 
 interface ExperimentConfig {
-	enabled: boolean
+	enabled: boolean | ReReadAfterEditGranular
 }
 
 export const experimentConfigsMap: Record<ExperimentKey, ExperimentConfig> = {
@@ -24,16 +33,39 @@ export const experimentConfigsMap: Record<ExperimentKey, ExperimentConfig> = {
 	IMAGE_GENERATION: { enabled: false },
 	RUN_SLASH_COMMAND: { enabled: false },
 	RE_READ_AFTER_EDIT: { enabled: false },
+	RE_READ_AFTER_EDIT_GRANULAR: {
+		enabled: {
+			applyDiff: false,
+			multiApplyDiff: false,
+			writeToFile: false,
+			insertContent: false,
+			searchAndReplace: false,
+		},
+	},
 }
 
 export const experimentDefault = Object.fromEntries(
 	Object.entries(experimentConfigsMap).map(([_, config]) => [
 		EXPERIMENT_IDS[_ as keyof typeof EXPERIMENT_IDS] as ExperimentId,
 		config.enabled,
 	]),
-) as Record<ExperimentId, boolean>
+) as Experiments
 
 export const experiments = {
 	get: (id: ExperimentKey): ExperimentConfig | undefined => experimentConfigsMap[id],
 	isEnabled: (experimentsConfig: Experiments, id: ExperimentId) => experimentsConfig[id] ?? experimentDefault[id],
+	isReReadAfterEditEnabled: (experimentsConfig: Experiments, editType: keyof ReReadAfterEditGranular): boolean => {
+		// If the legacy RE_READ_AFTER_EDIT is enabled, it applies to all edit types
+		if (experimentsConfig.reReadAfterEdit) {
+			return true
+		}
+
+		// Check if granular settings are enabled and if the specific edit type is enabled
+		const granularSettings = experimentsConfig.reReadAfterEditGranular
+		if (granularSettings && granularSettings[editType]) {
+			return true
+		}
+
+		return false
+	},
 } as const