diff --git a/packages/types/src/global-settings.ts b/packages/types/src/global-settings.ts index a30550dce16..e53246b85f9 100644 --- a/packages/types/src/global-settings.ts +++ b/packages/types/src/global-settings.ts @@ -108,6 +108,8 @@ export const globalSettingsSchema = z.object({ rateLimitSeconds: z.number().optional(), diffEnabled: z.boolean().optional(), fuzzyMatchThreshold: z.number().optional(), + autoCloseRooTabs: z.boolean().optional(), + autoCloseAllRooTabs: z.boolean().optional(), experiments: experimentsSchema.optional(), codebaseIndexModels: codebaseIndexModelsSchema.optional(), diff --git a/src/core/webview/webviewMessageHandler.ts b/src/core/webview/webviewMessageHandler.ts index 780d40df891..3abfe65cf0b 100644 --- a/src/core/webview/webviewMessageHandler.ts +++ b/src/core/webview/webviewMessageHandler.ts @@ -1241,6 +1241,14 @@ export const webviewMessageHandler = async ( await updateGlobalState("showRooIgnoredFiles", message.bool ?? true) await provider.postStateToWebview() break + case "autoCloseRooTabs": + await updateGlobalState("autoCloseRooTabs", message.bool ?? false) + await provider.postStateToWebview() + break + case "autoCloseAllRooTabs": + await updateGlobalState("autoCloseAllRooTabs", message.bool ?? false) + await provider.postStateToWebview() + break case "hasOpenedModeSelector": await updateGlobalState("hasOpenedModeSelector", message.bool ?? true) await provider.postStateToWebview() diff --git a/src/integrations/editor/DiffViewProvider.ts b/src/integrations/editor/DiffViewProvider.ts index f4133029c99..a8d6b86488a 100644 --- a/src/integrations/editor/DiffViewProvider.ts +++ b/src/integrations/editor/DiffViewProvider.ts @@ -15,6 +15,7 @@ import { Task } from "../../core/task/Task" import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" import { DecorationController } from "./DecorationController" +import { PostEditBehaviorUtils } from "./PostEditBehaviorUtils" export const DIFF_VIEW_URI_SCHEME = "cline-diff" export const DIFF_VIEW_LABEL_CHANGES = "Original ↔ Roo's Changes" @@ -36,6 +37,7 @@ export class DiffViewProvider { private activeLineController?: DecorationController private streamedLines: string[] = [] private preDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = [] + private rooOpenedTabs: Set = new Set() constructor(private cwd: string) {} @@ -95,6 +97,9 @@ export class DiffViewProvider { this.documentWasOpen = true } + // Track that we opened this file + this.rooOpenedTabs.add(absolutePath) + this.activeDiffEditor = await this.openDiffEditor() this.fadedOverlayController = new DecorationController("fadedOverlay", this.activeDiffEditor) this.activeLineController = new DecorationController("activeLine", this.activeDiffEditor) @@ -181,7 +186,12 @@ export class DiffViewProvider { } } - async saveChanges(diagnosticsEnabled: boolean = true, writeDelayMs: number = DEFAULT_WRITE_DELAY_MS): Promise<{ + async saveChanges( + diagnosticsEnabled: boolean = true, + writeDelayMs: number = DEFAULT_WRITE_DELAY_MS, + autoCloseRooTabs: boolean = false, + autoCloseAllRooTabs: boolean = false, + ): Promise<{ newProblemsMessage: string | undefined userEdits: string | undefined finalContent: string | undefined @@ -201,6 +211,14 @@ export class DiffViewProvider { await vscode.window.showTextDocument(vscode.Uri.file(absolutePath), { preview: false, preserveFocus: true }) await this.closeAllDiffViews() + // Apply post-edit behavior (auto-close tabs if configured) + await PostEditBehaviorUtils.closeRooTabs( + autoCloseRooTabs, + autoCloseAllRooTabs, + this.rooOpenedTabs, + absolutePath, + ) + // Getting diagnostics before and after the file edit is a better approach than // automatically tracking problems in real-time. This method ensures we only // report new problems that are a direct result of this specific edit. @@ -216,22 +234,22 @@ export class DiffViewProvider { // and can address them accordingly. If problems don't change immediately after // applying a fix, won't be notified, which is generally fine since the // initial fix is usually correct and it may just take time for linters to catch up. - + let newProblemsMessage = "" - + if (diagnosticsEnabled) { // Add configurable delay to allow linters time to process and clean up issues // like unused imports (especially important for Go and other languages) // Ensure delay is non-negative const safeDelayMs = Math.max(0, writeDelayMs) - + try { await delay(safeDelayMs) } catch (error) { // Log error but continue - delay failure shouldn't break the save operation console.warn(`Failed to apply write delay: ${error}`) } - + const postDiagnostics = vscode.languages.getDiagnostics() const newProblems = await diagnosticsToProblemsString( @@ -610,5 +628,14 @@ export class DiffViewProvider { this.activeLineController = undefined this.streamedLines = [] this.preDiagnostics = [] + this.rooOpenedTabs.clear() + } + + /** + * Gets the set of file paths that were opened by Roo during the current session + * @returns Set of absolute file paths + */ + getRooOpenedTabs(): Set { + return new Set(this.rooOpenedTabs) } } diff --git a/src/integrations/editor/PostEditBehaviorUtils.ts b/src/integrations/editor/PostEditBehaviorUtils.ts new file mode 100644 index 00000000000..0d584e914f8 --- /dev/null +++ b/src/integrations/editor/PostEditBehaviorUtils.ts @@ -0,0 +1,135 @@ +import * as vscode from "vscode" +import { arePathsEqual } from "../../utils/path" +import { DIFF_VIEW_URI_SCHEME } from "./DiffViewProvider" + +export class PostEditBehaviorUtils { + /** + * Closes Roo-related tabs based on the provided settings and tracked tabs + * @param autoCloseRooTabs - Close only tabs opened during the current task + * @param autoCloseAllRooTabs - Close all Roo tabs regardless of when they were opened + * @param rooOpenedTabs - Set of file paths that were opened by Roo during the current task + * @param editedFilePath - The path of the file that was just edited (to restore focus) + * @returns Promise + */ + static async closeRooTabs( + autoCloseRooTabs: boolean, + autoCloseAllRooTabs: boolean, + rooOpenedTabs: Set, + editedFilePath?: string, + ): Promise { + if (!autoCloseRooTabs && !autoCloseAllRooTabs) { + return + } + + // Get all tabs across all tab groups + const allTabs = vscode.window.tabGroups.all.flatMap((group) => group.tabs) + + // Filter tabs to close based on settings + const tabsToClose = allTabs.filter((tab) => { + // Check if it's a diff view tab + if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) { + return true + } + + // Check if it's a regular text tab + if (tab.input instanceof vscode.TabInputText) { + const tabPath = tab.input.uri.fsPath + + // Don't close the file that was just edited + if (editedFilePath && arePathsEqual(tabPath, editedFilePath)) { + return false + } + + if (autoCloseAllRooTabs) { + // Close all Roo tabs - for now, we consider all tabs that were tracked + // In a more sophisticated implementation, we might check for Roo-specific markers + return rooOpenedTabs.has(tabPath) + } else if (autoCloseRooTabs) { + // Close only tabs opened during the current task + return rooOpenedTabs.has(tabPath) + } + } + + return false + }) + + // Close the tabs + const closePromises = tabsToClose.map((tab) => { + if (!tab.isDirty) { + return vscode.window.tabGroups.close(tab).then( + () => undefined, + (err: any) => { + console.error(`Failed to close tab ${tab.label}:`, err) + }, + ) + } + return Promise.resolve() + }) + + await Promise.all(closePromises) + + // Restore focus to the edited file if provided + if (editedFilePath) { + try { + await vscode.window.showTextDocument(vscode.Uri.file(editedFilePath), { + preview: false, + preserveFocus: false, + }) + } catch (err) { + console.error(`Failed to restore focus to ${editedFilePath}:`, err) + } + } + } + + /** + * Determines which tabs should be closed based on the filter criteria + * @param tabs - Array of tabs to filter + * @param filter - Filter criteria (all Roo tabs or only current task tabs) + * @param rooOpenedTabs - Set of file paths opened by Roo + * @returns Array of tabs that match the filter criteria + */ + static filterTabsToClose( + tabs: readonly vscode.Tab[], + filter: "all" | "current", + rooOpenedTabs: Set, + ): vscode.Tab[] { + return tabs.filter((tab) => { + // Always close diff view tabs + if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) { + return true + } + + // For text tabs, apply the filter + if (tab.input instanceof vscode.TabInputText) { + const tabPath = tab.input.uri.fsPath + + if (filter === "all") { + // In a real implementation, we might have additional checks + // to identify Roo-specific tabs beyond just the tracked set + return true + } else if (filter === "current") { + return rooOpenedTabs.has(tabPath) + } + } + + return false + }) + } + + /** + * Checks if a tab is a Roo-related tab + * @param tab - The tab to check + * @returns true if the tab is Roo-related + */ + static isRooTab(tab: vscode.Tab): boolean { + // Check if it's a diff view tab + if (tab.input instanceof vscode.TabInputTextDiff && tab.input.original.scheme === DIFF_VIEW_URI_SCHEME) { + return true + } + + // Additional checks could be added here to identify other Roo-specific tabs + // For example, checking for specific URI schemes, file patterns, etc. + + return false + } +} diff --git a/src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts b/src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts new file mode 100644 index 00000000000..ad440269b80 --- /dev/null +++ b/src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts @@ -0,0 +1,304 @@ +// npx vitest src/integrations/editor/__tests__/PostEditBehaviorUtils.spec.ts + +import * as vscode from "vscode" +import { PostEditBehaviorUtils } from "../PostEditBehaviorUtils" + +// Mock DecorationController to avoid vscode.window.createTextEditorDecorationType error +vi.mock("../DecorationController", () => ({ + DecorationController: { + instance: { + clearDecorations: vi.fn(), + decorateLines: vi.fn(), + }, + }, +})) + +// Mock vscode module +vi.mock("vscode", () => { + const mockTab = (input: any, isDirty = false) => ({ + input, + isDirty, + group: { close: vi.fn() }, + }) + + const mockTabGroups = { + all: [], + close: vi.fn().mockResolvedValue(true), + } + + return { + window: { + tabGroups: mockTabGroups, + }, + TabInputText: class { + constructor(public uri: any) {} + }, + TabInputTextDiff: class { + constructor( + public original: any, + public modified: any, + ) {} + }, + Uri: { + parse: (str: string) => ({ + scheme: str.split(":")[0], + fsPath: str.replace(/^[^:]+:/, ""), + toString: () => str, + }), + file: (path: string) => ({ + scheme: "file", + fsPath: path, + toString: () => `file:${path}`, + }), + }, + } +}) + +describe("PostEditBehaviorUtils", () => { + let mockTabGroups: any + + beforeEach(() => { + // Reset mocks + vi.clearAllMocks() + mockTabGroups = vi.mocked(vscode.window.tabGroups) + mockTabGroups.all = [] + // Reset the close mock for each test + mockTabGroups.close = vi.fn().mockResolvedValue(true) + }) + + describe("closeRooTabs", () => { + it("should not close any tabs when both settings are false", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"]) + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: vi.fn() }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(false, false, rooOpenedTabs) + + expect(vi.mocked(vscode.window.tabGroups).close).not.toHaveBeenCalled() + }) + + it("should close only tabs opened during current task when autoCloseRooTabs is true", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"]) + const closeMock1 = vi.fn() + const closeMock2 = vi.fn() + const closeMock3 = vi.fn() + + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: closeMock1 }, + }, + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")), + isDirty: false, + group: { close: closeMock2 }, + }, + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file3.ts")), + isDirty: false, + group: { close: closeMock3 }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs) + + // Should close file1 and file2 (in rooOpenedTabs), but not file3 + const closeMock = vi.mocked(vscode.window.tabGroups).close + expect(closeMock).toHaveBeenCalledTimes(2) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[0]) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1]) + }) + + it("should close all Roo tabs when autoCloseAllRooTabs is true", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts"]) + const closeMock1 = vi.fn() + const closeMock2 = vi.fn() + const closeMock3 = vi.fn() + + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: closeMock1 }, + }, + { + input: new vscode.TabInputTextDiff( + vscode.Uri.parse("cline-diff:original"), + vscode.Uri.file("/test/file2.ts"), + ), + isDirty: false, + group: { close: closeMock2 }, + }, + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file3.ts")), + isDirty: false, + group: { close: closeMock3 }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(false, true, rooOpenedTabs) + + // Should close file1 (in rooOpenedTabs) and file2 (diff view), but not file3 + const closeMock = vi.mocked(vscode.window.tabGroups).close + expect(closeMock).toHaveBeenCalledTimes(2) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[0]) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1]) + }) + + it("should not close tabs with unsaved changes", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"]) + const closeMock1 = vi.fn() + const closeMock2 = vi.fn() + + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: true, // Has unsaved changes + group: { close: closeMock1 }, + }, + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")), + isDirty: false, + group: { close: closeMock2 }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs) + + // Should not close file1 (dirty), but should close file2 + const closeMock = vi.mocked(vscode.window.tabGroups).close + expect(closeMock).toHaveBeenCalledTimes(1) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1]) + expect(closeMock).not.toHaveBeenCalledWith(mockTabGroup.tabs[0]) + }) + + it("should not close the edited file when provided", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"]) + const editedFilePath = "/test/file1.ts" + const closeMock1 = vi.fn() + const closeMock2 = vi.fn() + + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: closeMock1 }, + }, + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")), + isDirty: false, + group: { close: closeMock2 }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs, editedFilePath) + + // Should not close file1 (edited file), but should close file2 + const closeMock = vi.mocked(vscode.window.tabGroups).close + expect(closeMock).toHaveBeenCalledTimes(1) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup.tabs[1]) + expect(closeMock).not.toHaveBeenCalledWith(mockTabGroup.tabs[0]) + }) + + it("should handle tabs without input gracefully", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts"]) + const closeMock = vi.fn() + + const mockTabGroup = { + tabs: [ + { + input: undefined, // No input + isDirty: false, + group: { close: closeMock }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs) + + // Should not crash and should not close tabs without input + expect(vi.mocked(vscode.window.tabGroups).close).not.toHaveBeenCalled() + }) + + it("should handle multiple tab groups", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts", "/test/file2.ts"]) + const closeMock1 = vi.fn() + const closeMock2 = vi.fn() + + const mockTabGroup1 = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: closeMock1 }, + }, + ], + } + + const mockTabGroup2 = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file2.ts")), + isDirty: false, + group: { close: closeMock2 }, + }, + ], + } + + mockTabGroups.all = [mockTabGroup1, mockTabGroup2] + + await PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs) + + // Should close tabs from both groups + const closeMock = vi.mocked(vscode.window.tabGroups).close + expect(closeMock).toHaveBeenCalledTimes(2) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup1.tabs[0]) + expect(closeMock).toHaveBeenCalledWith(mockTabGroup2.tabs[0]) + }) + + it("should handle errors gracefully", async () => { + const rooOpenedTabs = new Set(["/test/file1.ts"]) + + // Mock the close method to reject + vi.mocked(vscode.window.tabGroups).close.mockRejectedValueOnce(new Error("Close failed")) + + const mockTabGroup = { + tabs: [ + { + input: new vscode.TabInputText(vscode.Uri.file("/test/file1.ts")), + isDirty: false, + group: { close: vi.fn() }, + }, + ], + } + mockTabGroups.all = [mockTabGroup] + + // Should not throw + await expect(PostEditBehaviorUtils.closeRooTabs(true, false, rooOpenedTabs)).resolves.toBeUndefined() + + expect(vi.mocked(vscode.window.tabGroups).close).toHaveBeenCalled() + }) + }) +}) diff --git a/src/shared/ExtensionMessage.ts b/src/shared/ExtensionMessage.ts index 4f2aa2da159..8afa58cd8f3 100644 --- a/src/shared/ExtensionMessage.ts +++ b/src/shared/ExtensionMessage.ts @@ -218,6 +218,8 @@ export type ExtensionState = Pick< | "diagnosticsEnabled" | "diffEnabled" | "fuzzyMatchThreshold" + | "autoCloseRooTabs" + | "autoCloseAllRooTabs" // | "experiments" // Optional in GlobalSettings, required here. | "language" // | "telemetrySetting" // Optional in GlobalSettings, required here. diff --git a/src/shared/WebviewMessage.ts b/src/shared/WebviewMessage.ts index 1f56829f7b3..8b2fad7cec8 100644 --- a/src/shared/WebviewMessage.ts +++ b/src/shared/WebviewMessage.ts @@ -81,6 +81,8 @@ export interface WebviewMessage { | "allowedMaxRequests" | "alwaysAllowSubtasks" | "alwaysAllowUpdateTodoList" + | "autoCloseRooTabs" + | "autoCloseAllRooTabs" | "autoCondenseContext" | "autoCondenseContextPercent" | "condensingApiConfigId" diff --git a/webview-ui/src/components/settings/FileEditingOptions.tsx b/webview-ui/src/components/settings/FileEditingOptions.tsx new file mode 100644 index 00000000000..113ee953df5 --- /dev/null +++ b/webview-ui/src/components/settings/FileEditingOptions.tsx @@ -0,0 +1,72 @@ +import { HTMLAttributes } from "react" +import { FileEdit } from "lucide-react" + +import { useAppTranslation } from "@/i18n/TranslationContext" +import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react" + +import { SetCachedStateField } from "./types" +import { SectionHeader } from "./SectionHeader" +import { Section } from "./Section" + +type FileEditingOptionsProps = HTMLAttributes & { + autoCloseRooTabs?: boolean + autoCloseAllRooTabs?: boolean + setCachedStateField: SetCachedStateField<"autoCloseRooTabs" | "autoCloseAllRooTabs"> +} + +export const FileEditingOptions = ({ + autoCloseRooTabs, + autoCloseAllRooTabs, + setCachedStateField, + ...props +}: FileEditingOptionsProps) => { + const { t } = useAppTranslation() + + return ( +
+ +
+ +
{t("settings:fileEditing.title")}
+
+ + +
+
+
+ setCachedStateField("autoCloseRooTabs", e.target.checked)} + data-testid="auto-close-roo-tabs-checkbox"> + {t("settings:fileEditing.autoCloseRooTabs.label")} + +
+ {t("settings:fileEditing.autoCloseRooTabs.description")} +
+
+ +
+ setCachedStateField("autoCloseAllRooTabs", e.target.checked)} + data-testid="auto-close-all-roo-tabs-checkbox"> + {t("settings:fileEditing.autoCloseAllRooTabs.label")} + +
+ {t("settings:fileEditing.autoCloseAllRooTabs.description")} +
+
+ + {(autoCloseRooTabs || autoCloseAllRooTabs) && ( +
+
+ + {t("settings:fileEditing.tabClosingInfo")} +
+
+ )} +
+
+
+ ) +} diff --git a/webview-ui/src/components/settings/SettingsView.tsx b/webview-ui/src/components/settings/SettingsView.tsx index 517c1c159d8..33e0592bbb8 100644 --- a/webview-ui/src/components/settings/SettingsView.tsx +++ b/webview-ui/src/components/settings/SettingsView.tsx @@ -22,6 +22,7 @@ import { Globe, Info, MessageSquare, + FileEdit, LucideIcon, } from "lucide-react" @@ -66,6 +67,7 @@ import { About } from "./About" import { Section } from "./Section" import PromptsSettings from "./PromptsSettings" import { cn } from "@/lib/utils" +import { FileEditingOptions } from "./FileEditingOptions" export const settingsTabsContainer = "flex flex-1 overflow-hidden [&.narrow_.tab-label]:hidden" export const settingsTabList = @@ -86,6 +88,7 @@ const sectionNames = [ "notifications", "contextManagement", "terminal", + "fileEditing", "prompts", "experimental", "language", @@ -177,6 +180,8 @@ const SettingsView = forwardRef(({ onDone, t alwaysAllowFollowupQuestions, alwaysAllowUpdateTodoList, followupAutoApproveTimeoutMs, + autoCloseRooTabs, + autoCloseAllRooTabs, } = cachedState const apiConfiguration = useMemo(() => cachedState.apiConfiguration ?? {}, [cachedState.apiConfiguration]) @@ -333,6 +338,8 @@ const SettingsView = forwardRef(({ onDone, t vscode.postMessage({ type: "upsertApiConfiguration", text: currentApiConfigName, apiConfiguration }) vscode.postMessage({ type: "telemetrySetting", text: telemetrySetting }) vscode.postMessage({ type: "profileThresholds", values: profileThresholds }) + vscode.postMessage({ type: "autoCloseRooTabs", bool: autoCloseRooTabs }) + vscode.postMessage({ type: "autoCloseAllRooTabs", bool: autoCloseAllRooTabs }) setChangeDetected(false) } } @@ -409,6 +416,7 @@ const SettingsView = forwardRef(({ onDone, t { id: "notifications", icon: Bell }, { id: "contextManagement", icon: Database }, { id: "terminal", icon: SquareTerminal }, + { id: "fileEditing", icon: FileEdit }, { id: "prompts", icon: MessageSquare }, { id: "experimental", icon: FlaskConical }, { id: "language", icon: Globe }, @@ -688,6 +696,15 @@ const SettingsView = forwardRef(({ onDone, t /> )} + {/* File Editing Section */} + {activeTab === "fileEditing" && ( + + )} + {/* Prompts Section */} {activeTab === "prompts" && ( ({ + VSCodeCheckbox: ({ children, checked, onChange, "data-testid": dataTestId }: any) => ( + + ), +})) + +// Mock lucide-react icons +vi.mock("lucide-react", () => ({ + FileEdit: () => FileEdit Icon, +})) + +// Mock the vscode module +const mockPostMessage = vi.fn() +vi.mock("@/utils/vscode", () => ({ + vscode: { + postMessage: () => mockPostMessage(), + }, +})) + +describe("FileEditingOptions", () => { + let mockSetCachedStateField: ReturnType + + beforeEach(() => { + vi.clearAllMocks() + mockSetCachedStateField = vi.fn() + }) + + const renderFileEditingOptions = (props = {}) => { + const defaultProps = { + autoCloseRooTabs: false, + autoCloseAllRooTabs: false, + setCachedStateField: mockSetCachedStateField, + ...props, + } + + render() + } + + it("renders the component with correct title and icon", () => { + renderFileEditingOptions() + + expect(screen.getByText("settings:fileEditing.title")).toBeInTheDocument() + expect(screen.getByText("settings:fileEditing.description")).toBeInTheDocument() + expect(screen.getByTestId("file-edit-icon")).toBeInTheDocument() + }) + + it("displays both checkboxes with correct labels", () => { + renderFileEditingOptions() + + expect(screen.getByText("settings:fileEditing.autoCloseRooTabs.label")).toBeInTheDocument() + expect(screen.getByText("settings:fileEditing.autoCloseRooTabs.description")).toBeInTheDocument() + expect(screen.getByText("settings:fileEditing.autoCloseAllRooTabs.label")).toBeInTheDocument() + expect(screen.getByText("settings:fileEditing.autoCloseAllRooTabs.description")).toBeInTheDocument() + }) + + it("does not display the info message when both options are false", () => { + renderFileEditingOptions({ + autoCloseRooTabs: false, + autoCloseAllRooTabs: false, + }) + + expect(screen.queryByText("settings:fileEditing.tabClosingInfo")).not.toBeInTheDocument() + }) + + it("displays the info message when autoCloseRooTabs is true", () => { + renderFileEditingOptions({ + autoCloseRooTabs: true, + autoCloseAllRooTabs: false, + }) + + expect(screen.getByText("settings:fileEditing.tabClosingInfo")).toBeInTheDocument() + }) + + it("displays the info message when autoCloseAllRooTabs is true", () => { + renderFileEditingOptions({ + autoCloseRooTabs: false, + autoCloseAllRooTabs: true, + }) + + expect(screen.getByText("settings:fileEditing.tabClosingInfo")).toBeInTheDocument() + }) + + it("reflects the correct initial state from props", () => { + renderFileEditingOptions({ + autoCloseRooTabs: true, + autoCloseAllRooTabs: false, + }) + + const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox") + const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox") + + expect(autoCloseCheckbox).toBeChecked() + expect(autoCloseAllCheckbox).not.toBeChecked() + }) + + it("calls setCachedStateField when autoCloseRooTabs checkbox is toggled", () => { + renderFileEditingOptions({ + autoCloseRooTabs: false, + autoCloseAllRooTabs: false, + }) + + const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox") + + fireEvent.click(autoCloseCheckbox) + + expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseRooTabs", true) + }) + + it("calls setCachedStateField when autoCloseAllRooTabs checkbox is toggled", () => { + renderFileEditingOptions({ + autoCloseRooTabs: false, + autoCloseAllRooTabs: false, + }) + + const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox") + + fireEvent.click(autoCloseAllCheckbox) + + expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseAllRooTabs", true) + }) + + it("handles multiple toggles correctly", () => { + renderFileEditingOptions({ + autoCloseRooTabs: false, + autoCloseAllRooTabs: false, + }) + + const autoCloseCheckbox = screen.getByTestId("auto-close-roo-tabs-checkbox") + const autoCloseAllCheckbox = screen.getByTestId("auto-close-all-roo-tabs-checkbox") + + // Toggle autoCloseRooTabs on + fireEvent.click(autoCloseCheckbox) + expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseRooTabs", true) + + // Toggle autoCloseAllRooTabs on + fireEvent.click(autoCloseAllCheckbox) + expect(mockSetCachedStateField).toHaveBeenCalledWith("autoCloseAllRooTabs", true) + + // Toggle autoCloseRooTabs off (simulating it was already checked) + // Note: Since we're not re-rendering with updated props, we need to manually set the checked state + // In a real scenario, the parent component would re-render with updated props + expect(mockSetCachedStateField).toHaveBeenCalledTimes(2) + }) + + it("renders with proper styling classes", () => { + renderFileEditingOptions() + + // Check for the space-y-4 class on the container + const checkboxContainer = screen.getByTestId("auto-close-roo-tabs-checkbox").closest(".space-y-4") + expect(checkboxContainer).toBeInTheDocument() + + // Check for description styling + const descriptions = screen.getAllByText(/settings:fileEditing.*description/) + descriptions.forEach((desc) => { + expect(desc).toHaveClass("text-vscode-descriptionForeground", "text-sm") + }) + }) + + it("passes additional HTML attributes to the root element", () => { + const { container } = render( + , + ) + + // The root element is the first div + const rootElement = container.firstChild as HTMLElement + expect(rootElement).toHaveClass("custom-class") + expect(rootElement).toHaveAttribute("data-custom", "test") + }) +}) diff --git a/webview-ui/src/context/ExtensionStateContext.tsx b/webview-ui/src/context/ExtensionStateContext.tsx index c970733fbad..e87d9237174 100644 --- a/webview-ui/src/context/ExtensionStateContext.tsx +++ b/webview-ui/src/context/ExtensionStateContext.tsx @@ -134,6 +134,10 @@ export interface ExtensionStateContextType extends ExtensionState { routerModels?: RouterModels alwaysAllowUpdateTodoList?: boolean setAlwaysAllowUpdateTodoList: (value: boolean) => void + autoCloseRooTabs?: boolean + setAutoCloseRooTabs: (value: boolean) => void + autoCloseAllRooTabs?: boolean + setAutoCloseAllRooTabs: (value: boolean) => void } export const ExtensionStateContext = createContext(undefined) @@ -474,6 +478,14 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode setAlwaysAllowUpdateTodoList: (value) => { setState((prevState) => ({ ...prevState, alwaysAllowUpdateTodoList: value })) }, + autoCloseRooTabs: state.autoCloseRooTabs, + setAutoCloseRooTabs: (value) => { + setState((prevState) => ({ ...prevState, autoCloseRooTabs: value })) + }, + autoCloseAllRooTabs: state.autoCloseAllRooTabs, + setAutoCloseAllRooTabs: (value) => { + setState((prevState) => ({ ...prevState, autoCloseAllRooTabs: value })) + }, } return {children} diff --git a/webview-ui/src/i18n/locales/en/settings.json b/webview-ui/src/i18n/locales/en/settings.json index 7e3c2e3fccb..c3fea35f75d 100644 --- a/webview-ui/src/i18n/locales/en/settings.json +++ b/webview-ui/src/i18n/locales/en/settings.json @@ -31,7 +31,8 @@ "prompts": "Prompts", "experimental": "Experimental", "language": "Language", - "about": "About Roo Code" + "about": "About Roo Code", + "fileEditing": "File Editing" }, "prompts": { "description": "Configure support prompts that are used for quick actions like enhancing prompts, explaining code, and fixing issues. These prompts help Roo provide better assistance for common development tasks." @@ -718,5 +719,18 @@ "useCustomArn": "Use custom ARN..." }, "includeMaxOutputTokens": "Include max output tokens", - "includeMaxOutputTokensDescription": "Send max output tokens parameter in API requests. Some providers may not support this." + "includeMaxOutputTokensDescription": "Send max output tokens parameter in API requests. Some providers may not support this.", + "fileEditing": { + "title": "File Editing", + "description": "Configure how Roo handles tabs after editing files.", + "autoCloseRooTabs": { + "label": "Auto-close tabs opened during current task", + "description": "Automatically close tabs that were opened by Roo during the current task after saving changes." + }, + "autoCloseAllRooTabs": { + "label": "Auto-close all Roo tabs", + "description": "Automatically close all tabs that were opened or edited by Roo, regardless of when they were opened." + }, + "tabClosingInfo": "Tab closing happens after file changes are saved. Tabs with unsaved changes will not be closed." + } }