Find the current mode in the list before switching

Author: mrubens

src/commands/__tests__/mode-switching.test.ts

@@ -0,0 +1,225 @@
+import * as vscode from "vscode"
+import { registerModeSwitchingCommands } from "../mode-switching"
+import { ClineProvider } from "../../core/webview/ClineProvider"
+import { ModeConfig, modes, getAllModes } from "../../shared/modes"
+import { logger } from "../../utils/logging"
+
+// Mock dependencies
+jest.mock("../../core/webview/ClineProvider", () => ({
+	ClineProvider: {
+		getInstance: jest.fn(),
+	},
+}))
+
+jest.mock("../../utils/logging", () => ({
+	logger: {
+		info: jest.fn(),
+		error: jest.fn(),
+	},
+}))
+
+jest.mock("../../shared/modes", () => ({
+	modes: [
+		{ slug: "code", name: "Code", roleDefinition: "Code role" },
+		{ slug: "architect", name: "Architect", roleDefinition: "Architect role" },
+	],
+	getAllModes: jest.fn(),
+}))
+
+// Simple mock for vscode
+jest.mock("vscode", () => ({
+	commands: {
+		registerCommand: jest.fn(),
+	},
+	window: {
+		showErrorMessage: jest.fn(),
+	},
+}))
+
+describe("registerModeSwitchingCommands", () => {
+	// Mock context
+	const mockContext = {
+		subscriptions: [],
+		// Add more required properties
+		workspaceState: { get: jest.fn(), update: jest.fn() },
+		globalState: { get: jest.fn(), update: jest.fn(), keys: jest.fn() },
+		secrets: { get: jest.fn(), store: jest.fn(), delete: jest.fn() },
+		extensionUri: {} as vscode.Uri,
+		extensionPath: "/test/path",
+	} as unknown as vscode.ExtensionContext
+
+	// Get reference to the mocked registerCommand
+	const mockRegisterCommand = vscode.commands.registerCommand as jest.Mock
+
+	beforeEach(() => {
+		// Clear all mocks before each test
+		jest.clearAllMocks()
+
+		// Default mock implementations
+		mockRegisterCommand.mockImplementation((commandId, callback) => {
+			return { dispose: jest.fn() }
+		})
+	})
+
+	it("should register the cycleModes command", () => {
+		// Act
+		registerModeSwitchingCommands(mockContext)
+
+		// Assert
+		expect(mockRegisterCommand).toHaveBeenCalledWith("roo-cline.cycleModes", expect.any(Function))
+		expect(mockContext.subscriptions.length).toBe(1)
+	})
+
+	describe("cycleModes command", () => {
+		// Setup to capture the command callback
+		let cycleModeCallback: Function
+
+		beforeEach(() => {
+			mockRegisterCommand.mockImplementation((commandId, callback) => {
+				if (commandId === "roo-cline.cycleModes") {
+					cycleModeCallback = callback
+				}
+				return { dispose: jest.fn() }
+			})
+
+			// Register commands to capture the callback
+			registerModeSwitchingCommands(mockContext)
+		})
+
+		it("should cycle to the next mode when current mode is found", async () => {
+			// Arrange
+			const allModes = [
+				...modes,
+				{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+			]
+			;(getAllModes as jest.Mock).mockReturnValue(allModes)
+
+			const mockProvider = {
+				getState: jest.fn().mockResolvedValue({
+					mode: "code",
+					customModes: [
+						{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+					],
+				}),
+				postMessageToWebview: jest.fn().mockResolvedValue(undefined),
+			}
+			;(ClineProvider.getInstance as jest.Mock).mockResolvedValue(mockProvider)
+
+			// Find the index of 'code' mode in all modes
+			const codeIndex = allModes.findIndex((mode) => mode.slug === "code")
+			const expectedNextMode = allModes[(codeIndex + 1) % allModes.length]
+
+			// Act
+			await cycleModeCallback()
+
+			// Assert
+			expect(mockProvider.getState).toHaveBeenCalled()
+			expect(getAllModes).toHaveBeenCalledWith([
+				{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+			])
+			expect(mockProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "mode",
+				text: expectedNextMode.slug,
+			})
+		})
+
+		it("should default to first mode when current mode is not found", async () => {
+			// Arrange
+			const customModes = [
+				{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+			]
+			const allModes = [...modes, ...customModes]
+			;(getAllModes as jest.Mock).mockReturnValue(allModes)
+
+			const mockProvider = {
+				getState: jest.fn().mockResolvedValue({
+					mode: "nonexistent-mode",
+					customModes: customModes,
+				}),
+				postMessageToWebview: jest.fn().mockResolvedValue(undefined),
+			}
+			;(ClineProvider.getInstance as jest.Mock).mockResolvedValue(mockProvider)
+
+			// First mode in the list of all modes
+			const expectedNextMode = allModes[0]
+
+			// Act
+			await cycleModeCallback()
+
+			// Assert
+			expect(mockProvider.getState).toHaveBeenCalled()
+			expect(getAllModes).toHaveBeenCalledWith(customModes)
+			expect(mockProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "mode",
+				text: expectedNextMode.slug,
+			})
+		})
+
+		it("should handle errors when provider is not available", async () => {
+			// Arrange
+			;(ClineProvider.getInstance as jest.Mock).mockResolvedValue(null)
+
+			// Act
+			await cycleModeCallback()
+
+			// Assert
+			expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to switch mode"))
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+				expect.stringContaining("Failed to switch mode"),
+			)
+		})
+
+		it("should handle errors in getState", async () => {
+			// Arrange
+			const allModes = [
+				...modes,
+				{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+			]
+			;(getAllModes as jest.Mock).mockReturnValue(allModes)
+
+			const mockProvider = {
+				getState: jest.fn().mockRejectedValue(new Error("State error")),
+				postMessageToWebview: jest.fn().mockResolvedValue(undefined),
+			}
+			;(ClineProvider.getInstance as jest.Mock).mockResolvedValue(mockProvider)
+
+			// Act
+			await cycleModeCallback()
+
+			// Assert
+			expect(mockProvider.getState).toHaveBeenCalled()
+			expect(mockProvider.postMessageToWebview).not.toHaveBeenCalled()
+			expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to switch mode"))
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+				expect.stringContaining("Failed to switch mode"),
+			)
+		})
+
+		it("should handle errors in postMessageToWebview", async () => {
+			// Arrange
+			const customModes = [
+				{ slug: "custom-mode", name: "Custom Mode", roleDefinition: "Custom role", groups: [] },
+			]
+			const allModes = [...modes, ...customModes]
+			;(getAllModes as jest.Mock).mockReturnValue(allModes)
+
+			const mockProvider = {
+				getState: jest.fn().mockResolvedValue({ mode: "code", customModes }),
+				postMessageToWebview: jest.fn().mockRejectedValue(new Error("Webview error")),
+			}
+			;(ClineProvider.getInstance as jest.Mock).mockResolvedValue(mockProvider)
+
+			// Act
+			await cycleModeCallback()
+
+			// Assert
+			expect(mockProvider.getState).toHaveBeenCalled()
+			expect(getAllModes).toHaveBeenCalledWith(customModes)
+			expect(mockProvider.postMessageToWebview).toHaveBeenCalled()
+			expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to switch mode"))
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+				expect.stringContaining("Failed to switch mode"),
+			)
+		})
+	})
+})

src/commands/mode-switching.ts

@@ -1,26 +1,40 @@
 import * as vscode from "vscode"
-import { modes } from "../shared/modes"
+import { ModeConfig, modes, getAllModes } from "../shared/modes"
 import { ClineProvider } from "../core/webview/ClineProvider"
+import { logger } from "../utils/logging"
 
 export function registerModeSwitchingCommands(context: vscode.ExtensionContext) {
-	let currentModeIndex = 0
-
 	context.subscriptions.push(
 		vscode.commands.registerCommand("roo-cline.cycleModes", async () => {
 			try {
-				// Get next mode index
-				currentModeIndex = (currentModeIndex + 1) % modes.length
-				const nextMode = modes[currentModeIndex]
-
-				// Get visible instance and send message
+				// Get provider instance
 				const provider = await ClineProvider.getInstance()
-				if (provider) {
-					await provider.postMessageToWebview({
-						type: "mode",
-						text: nextMode.slug,
-					})
+				if (!provider) {
+					throw new Error("No active Cline provider found")
 				}
+
+				// Get current mode and custom modes from provider state
+				const state = await provider.getState()
+				const currentModeSlug = state.mode
+				const customModes = state.customModes || []
+
+				// Get all modes including custom modes
+				const allModes = getAllModes(customModes)
+
+				// Find current mode index in the combined array
+				const currentModeIndex = allModes.findIndex((mode) => mode.slug === currentModeSlug)
+
+				// Get next mode index, defaulting to first mode if current mode not found
+				const nextModeIndex = (currentModeIndex + 1) % allModes.length
+				const nextMode = allModes[nextModeIndex]
+
+				// Send message to webview to switch mode
+				await provider.postMessageToWebview({
+					type: "mode",
+					text: nextMode.slug,
+				})
 			} catch (error) {
+				logger.error(`Failed to switch mode: ${error}`)
 				vscode.window.showErrorMessage(`Failed to switch mode: ${error}`)
 			}
 		}),