fix: remove existing rules folder when importing mode without rules

- Always remove the existing rules folder for a mode during project-level import
- This ensures that if the imported mode has no rules, the folder is cleaned up
- Added tests to verify the behavior works correctly

Author: hannesrudolph

src/core/config/CustomModesManager.ts

@@ -719,11 +719,12 @@ export class CustomModesManager {
 					source: source, // Use the provided source parameter
 				})
 
-				// Only import rules files for project-level imports
-				if (source === "project" && rulesFiles && Array.isArray(rulesFiles)) {
+				// Handle project-level imports
+				if (source === "project") {
 					const workspacePath = getWorkspacePath()
 
-					// First, remove the existing rules folder for this mode if it exists
+					// Always remove the existing rules folder for this mode if it exists
+					// This ensures that if the imported mode has no rules, the folder is cleaned up
 					const rulesFolderPath = path.join(workspacePath, ".roo", `rules-${importMode.slug}`)
 					try {
 						await fs.rm(rulesFolderPath, { recursive: true, force: true })
@@ -733,17 +734,20 @@ export class CustomModesManager {
 						logger.debug(`No existing rules folder to remove for mode ${importMode.slug}`)
 					}
 
-					// Now import the new rules files
-					for (const ruleFile of rulesFiles) {
-						if (ruleFile.relativePath && ruleFile.content) {
-							const targetPath = path.join(workspacePath, ".roo", ruleFile.relativePath)
+					// Only create new rules files if they exist in the import
+					if (rulesFiles && Array.isArray(rulesFiles) && rulesFiles.length > 0) {
+						// Import the new rules files
+						for (const ruleFile of rulesFiles) {
+							if (ruleFile.relativePath && ruleFile.content) {
+								const targetPath = path.join(workspacePath, ".roo", ruleFile.relativePath)
 
-							// Ensure directory exists
-							const targetDir = path.dirname(targetPath)
-							await fs.mkdir(targetDir, { recursive: true })
+								// Ensure directory exists
+								const targetDir = path.dirname(targetPath)
+								await fs.mkdir(targetDir, { recursive: true })
 
-							// Write the file
-							await fs.writeFile(targetPath, ruleFile.content, "utf-8")
+								// Write the file
+								await fs.writeFile(targetPath, ruleFile.content, "utf-8")
+							}
 						}
 					}
 				} else if (source === "global" && rulesFiles && Array.isArray(rulesFiles)) {

src/core/config/__tests__/CustomModesManager.spec.ts

@@ -1034,6 +1034,113 @@ describe("CustomModesManager", () => {
 				expect(result.success).toBe(false)
 				expect(result.error).toContain("Permission denied")
 			})
+
+			it("should remove existing rules folder when importing mode without rules", async () => {
+				const importYaml = yaml.stringify({
+					customModes: [
+						{
+							slug: "test-mode",
+							name: "Test Mode",
+							roleDefinition: "Test Role",
+							groups: ["read"],
+							// No rulesFiles property - this mode has no rules
+						},
+					],
+				})
+
+				let roomodesContent: any = null
+				;(fs.readFile as Mock).mockImplementation(async (path: string) => {
+					if (path === mockSettingsPath) {
+						return yaml.stringify({ customModes: [] })
+					}
+					if (path === mockRoomodes && roomodesContent) {
+						return yaml.stringify(roomodesContent)
+					}
+					throw new Error("File not found")
+				})
+				;(fs.writeFile as Mock).mockImplementation(async (path: string, content: string) => {
+					if (path === mockRoomodes) {
+						roomodesContent = yaml.parse(content)
+					}
+					return Promise.resolve()
+				})
+				;(fs.rm as Mock).mockResolvedValue(undefined)
+
+				const result = await manager.importModeWithRules(importYaml)
+
+				expect(result.success).toBe(true)
+
+				// Verify that fs.rm was called to remove the existing rules folder
+				expect(fs.rm).toHaveBeenCalledWith(expect.stringContaining(path.join(".roo", "rules-test-mode")), {
+					recursive: true,
+					force: true,
+				})
+
+				// Verify mode was imported
+				expect(fs.writeFile).toHaveBeenCalledWith(
+					expect.stringContaining(".roomodes"),
+					expect.stringContaining("test-mode"),
+					"utf-8",
+				)
+			})
+
+			it("should remove existing rules folder and create new ones when importing mode with rules", async () => {
+				const importYaml = yaml.stringify({
+					customModes: [
+						{
+							slug: "test-mode",
+							name: "Test Mode",
+							roleDefinition: "Test Role",
+							groups: ["read"],
+							rulesFiles: [
+								{
+									relativePath: "rules-test-mode/new-rule.md",
+									content: "New rule content",
+								},
+							],
+						},
+					],
+				})
+
+				let roomodesContent: any = null
+				let writtenFiles: Record<string, string> = {}
+				;(fs.readFile as Mock).mockImplementation(async (path: string) => {
+					if (path === mockSettingsPath) {
+						return yaml.stringify({ customModes: [] })
+					}
+					if (path === mockRoomodes && roomodesContent) {
+						return yaml.stringify(roomodesContent)
+					}
+					throw new Error("File not found")
+				})
+				;(fs.writeFile as Mock).mockImplementation(async (path: string, content: string) => {
+					if (path === mockRoomodes) {
+						roomodesContent = yaml.parse(content)
+					} else {
+						writtenFiles[path] = content
+					}
+					return Promise.resolve()
+				})
+				;(fs.rm as Mock).mockResolvedValue(undefined)
+				;(fs.mkdir as Mock).mockResolvedValue(undefined)
+
+				const result = await manager.importModeWithRules(importYaml)
+
+				expect(result.success).toBe(true)
+
+				// Verify that fs.rm was called to remove the existing rules folder
+				expect(fs.rm).toHaveBeenCalledWith(expect.stringContaining(path.join(".roo", "rules-test-mode")), {
+					recursive: true,
+					force: true,
+				})
+
+				// Verify new rules files were created
+				expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining("rules-test-mode"), { recursive: true })
+
+				// Verify file contents
+				const newRulePath = Object.keys(writtenFiles).find((p) => p.includes("new-rule.md"))
+				expect(writtenFiles[newRulePath!]).toBe("New rule content")
+			})
 		})
 	})