Merge pull request #523 from RooVetGit/allow_architect_mode_to_write_markdown

Allow architect and ask modes to write md files

Author: mrubens

src/core/Cline.ts

@@ -1142,17 +1142,25 @@ export class Cline {
 					await this.browserSession.closeBrowser()
 				}
 
-				// Validate tool use before execution
-				const { mode } = (await this.providerRef.deref()?.getState()) ?? {}
-				const { customModes } = (await this.providerRef.deref()?.getState()) ?? {}
-				try {
-					validateToolUse(block.name as ToolName, mode ?? defaultModeSlug, customModes ?? [], {
-						apply_diff: this.diffEnabled,
-					})
-				} catch (error) {
-					this.consecutiveMistakeCount++
-					pushToolResult(formatResponse.toolError(error.message))
-					break
+				// Only validate complete tool uses
+				if (!block.partial) {
+					const { mode } = (await this.providerRef.deref()?.getState()) ?? {}
+					const { customModes } = (await this.providerRef.deref()?.getState()) ?? {}
+					try {
+						validateToolUse(
+							block.name as ToolName,
+							mode ?? defaultModeSlug,
+							customModes ?? [],
+							{
+								apply_diff: this.diffEnabled,
+							},
+							block.params,
+						)
+					} catch (error) {
+						this.consecutiveMistakeCount++
+						pushToolResult(formatResponse.toolError(error.message))
+						break
+					}
 				}
 
 				switch (block.name) {

src/core/config/CustomModesSchema.ts

@@ -5,16 +5,41 @@ import { TOOL_GROUPS, ToolGroup } from "../../shared/tool-groups"
 // Create a schema for valid tool groups using the keys of TOOL_GROUPS
 const ToolGroupSchema = z.enum(Object.keys(TOOL_GROUPS) as [ToolGroup, ...ToolGroup[]])
 
+// Schema for group options with regex validation
+const GroupOptionsSchema = z.object({
+	fileRegex: z
+		.string()
+		.optional()
+		.refine(
+			(pattern) => {
+				if (!pattern) return true // Optional, so empty is valid
+				try {
+					new RegExp(pattern)
+					return true
+				} catch {
+					return false
+				}
+			},
+			{ message: "Invalid regular expression pattern" },
+		),
+	description: z.string().optional(),
+})
+
+// Schema for a group entry - either a tool group string or a tuple of [group, options]
+const GroupEntrySchema = z.union([ToolGroupSchema, z.tuple([ToolGroupSchema, GroupOptionsSchema])])
+
 // Schema for array of groups
 const GroupsArraySchema = z
-	.array(ToolGroupSchema)
+	.array(GroupEntrySchema)
 	.min(1, "At least one tool group is required")
 	.refine(
 		(groups) => {
 			const seen = new Set()
 			return groups.every((group) => {
-				if (seen.has(group)) return false
-				seen.add(group)
+				// For tuples, check the group name (first element)
+				const groupName = Array.isArray(group) ? group[0] : group
+				if (seen.has(groupName)) return false
+				seen.add(groupName)
 				return true
 			})
 		},

src/core/config/__tests__/CustomModesSchema.test.ts

@@ -1,12 +1,12 @@
-import { validateCustomMode } from "../CustomModesSchema"
-import { ModeConfig } from "../../../shared/modes"
 import { ZodError } from "zod"
+import { CustomModeSchema, validateCustomMode } from "../CustomModesSchema"
+import { ModeConfig } from "../../../shared/modes"
 
-describe("CustomModesSchema", () => {
+describe("CustomModeSchema", () => {
 	describe("validateCustomMode", () => {
 		test("accepts valid mode configuration", () => {
 			const validMode = {
-				slug: "123e4567-e89b-12d3-a456-426614174000",
+				slug: "test",
 				name: "Test Mode",
 				roleDefinition: "Test role definition",
 				groups: ["read"] as const,
@@ -17,7 +17,7 @@ describe("CustomModesSchema", () => {
 
 		test("accepts mode with multiple groups", () => {
 			const validMode = {
-				slug: "123e4567-e89b-12d3-a456-426614174000",
+				slug: "test",
 				name: "Test Mode",
 				roleDefinition: "Test role definition",
 				groups: ["read", "edit", "browser"] as const,
@@ -28,7 +28,7 @@ describe("CustomModesSchema", () => {
 
 		test("accepts mode with optional customInstructions", () => {
 			const validMode = {
-				slug: "123e4567-e89b-12d3-a456-426614174000",
+				slug: "test",
 				name: "Test Mode",
 				roleDefinition: "Test role definition",
 				customInstructions: "Custom instructions",
@@ -119,4 +119,76 @@ describe("CustomModesSchema", () => {
 			})
 		})
 	})
+
+	describe("fileRegex", () => {
+		it("validates a mode with file restrictions and descriptions", () => {
+			const modeWithJustRegex = {
+				slug: "markdown-editor",
+				name: "Markdown Editor",
+				roleDefinition: "Markdown editing mode",
+				groups: ["read", ["edit", { fileRegex: "\\.md$" }], "browser"],
+			}
+
+			const modeWithDescription = {
+				slug: "docs-editor",
+				name: "Documentation Editor",
+				roleDefinition: "Documentation editing mode",
+				groups: [
+					"read",
+					["edit", { fileRegex: "\\.(md|txt)$", description: "Documentation files only" }],
+					"browser",
+				],
+			}
+
+			expect(() => CustomModeSchema.parse(modeWithJustRegex)).not.toThrow()
+			expect(() => CustomModeSchema.parse(modeWithDescription)).not.toThrow()
+		})
+
+		it("validates file regex patterns", () => {
+			const validPatterns = ["\\.md$", ".*\\.txt$", "[a-z]+\\.js$"]
+			const invalidPatterns = ["[", "(unclosed", "\\"]
+
+			validPatterns.forEach((pattern) => {
+				const mode = {
+					slug: "test",
+					name: "Test",
+					roleDefinition: "Test",
+					groups: ["read", ["edit", { fileRegex: pattern }]],
+				}
+				expect(() => CustomModeSchema.parse(mode)).not.toThrow()
+			})
+
+			invalidPatterns.forEach((pattern) => {
+				const mode = {
+					slug: "test",
+					name: "Test",
+					roleDefinition: "Test",
+					groups: ["read", ["edit", { fileRegex: pattern }]],
+				}
+				expect(() => CustomModeSchema.parse(mode)).toThrow()
+			})
+		})
+
+		it("prevents duplicate groups", () => {
+			const modeWithDuplicates = {
+				slug: "test",
+				name: "Test",
+				roleDefinition: "Test",
+				groups: ["read", "read", ["edit", { fileRegex: "\\.md$" }], ["edit", { fileRegex: "\\.txt$" }]],
+			}
+
+			expect(() => CustomModeSchema.parse(modeWithDuplicates)).toThrow(/Duplicate groups/)
+		})
+
+		it("requires at least one group", () => {
+			const modeWithNoGroups = {
+				slug: "test",
+				name: "Test",
+				roleDefinition: "Test",
+				groups: [],
+			}
+
+			expect(() => CustomModeSchema.parse(modeWithNoGroups)).toThrow(/At least one tool group is required/)
+		})
+	})
 })

src/core/mode-validator.ts

@@ -1,4 +1,4 @@
-import { Mode, isToolAllowedForMode, getModeConfig, ModeConfig } from "../shared/modes"
+import { Mode, isToolAllowedForMode, getModeConfig, ModeConfig, FileRestrictionError } from "../shared/modes"
 import { ToolName } from "../shared/tool-groups"
 
 export { isToolAllowedForMode }
@@ -9,8 +9,9 @@ export function validateToolUse(
 	mode: Mode,
 	customModes?: ModeConfig[],
 	toolRequirements?: Record<string, boolean>,
+	toolParams?: Record<string, unknown>,
 ): void {
-	if (!isToolAllowedForMode(toolName, mode, customModes ?? [], toolRequirements)) {
+	if (!isToolAllowedForMode(toolName, mode, customModes ?? [], toolRequirements, toolParams)) {
 		throw new Error(`Tool "${toolName}" is not allowed in ${mode} mode.`)
 	}
 }