basically working

Author: liwilliam2021

src/core/webview/webviewMessageHandler.ts

@@ -1899,12 +1899,38 @@ export const webviewMessageHandler = async (
 				// Import the rules generation service
 				const { createRulesGenerationTaskMessage } = await import("../../services/rules/rulesGenerator")
 
+				// Get selected rule types and options from the message
+				const selectedRuleTypes = message.selectedRuleTypes || ["general"]
+				const addToGitignore = message.addToGitignore || false
+				const alwaysAllowWriteProtected = message.alwaysAllowWriteProtected || false
+				const apiConfigName = message.apiConfigName
+
+				// Save current API config to restore later
+				const currentApiConfig = getGlobalState("currentApiConfigName")
+
+				// Temporarily switch to the selected API config if provided
+				if (apiConfigName && apiConfigName !== currentApiConfig) {
+					await updateGlobalState("currentApiConfigName", apiConfigName)
+					await provider.postStateToWebview()
+				}
+
 				// Create a comprehensive message for the rules generation task using existing analysis logic
-				const rulesGenerationMessage = await createRulesGenerationTaskMessage(workspacePath)
+				const rulesGenerationMessage = await createRulesGenerationTaskMessage(
+					workspacePath,
+					selectedRuleTypes,
+					addToGitignore,
+					alwaysAllowWriteProtected,
+				)
 
 				// Spawn a new task in code mode to generate the rules
 				await provider.initClineWithTask(rulesGenerationMessage)
 
+				// Restore the original API config
+				if (apiConfigName && apiConfigName !== currentApiConfig) {
+					await updateGlobalState("currentApiConfigName", currentApiConfig)
+					await provider.postStateToWebview()
+				}
+
 				// Send success message back to webview indicating task was created
 				await provider.postMessageToWebview({
 					type: "rulesGenerationStatus",
@@ -1927,6 +1953,45 @@ export const webviewMessageHandler = async (
 				})
 			}
 			break
+		case "checkExistingRuleFiles":
+			// Check which rule files already exist
+			try {
+				const workspacePath = getWorkspacePath()
+				if (!workspacePath) {
+					break
+				}
+
+				const { fileExistsAtPath } = await import("../../utils/fs")
+				const path = await import("path")
+
+				const ruleTypeToPath: Record<string, string> = {
+					general: path.join(workspacePath, ".roo", "rules", "coding-standards.md"),
+					code: path.join(workspacePath, ".roo", "rules-code", "implementation-rules.md"),
+					architect: path.join(workspacePath, ".roo", "rules-architect", "architecture-rules.md"),
+					debug: path.join(workspacePath, ".roo", "rules-debug", "debugging-rules.md"),
+					"docs-extractor": path.join(
+						workspacePath,
+						".roo",
+						"rules-docs-extractor",
+						"documentation-rules.md",
+					),
+				}
+
+				const existingFiles: string[] = []
+				for (const [type, filePath] of Object.entries(ruleTypeToPath)) {
+					if (await fileExistsAtPath(filePath)) {
+						existingFiles.push(type)
+					}
+				}
+
+				await provider.postMessageToWebview({
+					type: "existingRuleFiles",
+					files: existingFiles,
+				})
+			} catch (error) {
+				// Silently fail - not critical
+			}
+			break
 		case "humanRelayResponse":
 			if (message.requestId && message.text) {
 				vscode.commands.executeCommand(getCommand("handleHumanRelayResponse"), {

src/services/rules/rulesGenerator.ts

@@ -204,19 +204,73 @@ async function generateCodebaseSummary(workspacePath: string, config: ProjectCon
 /**
  * Creates a comprehensive task message for rules generation that can be used with initClineWithTask
  */
-export async function createRulesGenerationTaskMessage(workspacePath: string): Promise<string> {
+export async function createRulesGenerationTaskMessage(
+	workspacePath: string,
+	selectedRuleTypes: string[],
+	addToGitignore: boolean,
+	alwaysAllowWriteProtected: boolean = false,
+): Promise<string> {
 	// Analyze the project to get context
 	const config = await analyzeProjectConfig(workspacePath)
 	const codebaseSummary = await generateCodebaseSummary(workspacePath, config)
 
-	// Ensure .roo/rules directory exists at project root
-	const rooRulesDir = path.join(workspacePath, ".roo", "rules")
-	try {
-		await fs.mkdir(rooRulesDir, { recursive: true })
-	} catch (error) {
-		// Directory might already exist, which is fine
+	// Ensure all necessary directories exist at project root
+	const directoriesToCreate = [
+		path.join(workspacePath, ".roo", "rules"),
+		path.join(workspacePath, ".roo", "rules-code"),
+		path.join(workspacePath, ".roo", "rules-architect"),
+		path.join(workspacePath, ".roo", "rules-debug"),
+		path.join(workspacePath, ".roo", "rules-docs-extractor"),
+	]
+
+	for (const dir of directoriesToCreate) {
+		try {
+			await fs.mkdir(dir, { recursive: true })
+		} catch (error) {
+			// Directory might already exist, which is fine
+		}
 	}
 
+	// Create rule-specific instructions based on selected types
+	interface RuleInstruction {
+		path: string
+		focus: string
+	}
+
+	const ruleInstructions: RuleInstruction[] = selectedRuleTypes
+		.map((type) => {
+			switch (type) {
+				case "general":
+					return {
+						path: ".roo/rules/coding-standards.md",
+						focus: "General coding standards that apply to all modes, including naming conventions, file organization, and general best practices",
+					}
+				case "code":
+					return {
+						path: ".roo/rules-code/implementation-rules.md",
+						focus: "Specific rules for code implementation, focusing on syntax patterns, code structure, error handling, testing approaches, and detailed implementation guidelines",
+					}
+				case "architect":
+					return {
+						path: ".roo/rules-architect/architecture-rules.md",
+						focus: "High-level system design rules, focusing on file layout, module organization, architectural patterns, and system-wide design principles",
+					}
+				case "debug":
+					return {
+						path: ".roo/rules-debug/debugging-rules.md",
+						focus: "Debugging workflow rules, including error investigation approaches, logging strategies, troubleshooting patterns, and debugging best practices",
+					}
+				case "docs-extractor":
+					return {
+						path: ".roo/rules-docs-extractor/documentation-rules.md",
+						focus: "Documentation extraction and formatting rules, including documentation style guides, API documentation patterns, and content organization",
+					}
+				default:
+					return null
+			}
+		})
+		.filter((rule): rule is RuleInstruction => rule !== null)
+
 	// Create a comprehensive message for the rules generation task
 	const taskMessage = `Analyze this codebase and generate comprehensive rules for AI agents working in this repository.
 
@@ -233,18 +287,35 @@ ${codebaseSummary}
    - Project-specific conventions and best practices
    - File organization patterns
 
-3. **Save the rules** to the file at exactly this path: .roo/rules/coding-standards.md
-   - The .roo/rules directory has already been created for you
-   - Always overwrite the existing file if it exists
-   - Use the \`write_to_file\` tool to save the content
+3. **Generate and save the following rule files**:
+${ruleInstructions
+	.map(
+		(rule, index) => `
+   ${index + 1}. **${rule.path}**
+      - Focus: ${rule.focus}
+      - The directory has already been created for you
+      - Always overwrite the existing file if it exists
+      - Use the \`write_to_file\` tool to save the content${alwaysAllowWriteProtected ? "\n       - Note: Auto-approval for protected file writes is enabled, so you can write to .roo directories without manual approval" : ""}`,
+	)
+	.join("\n")}
 
 4. **Open the generated file** in the editor for review
 
 The rules should be about 20-30 lines long and focus on the most important guidelines for this specific project. Make them actionable and specific to help AI agents work effectively in this codebase.
 
 If there are existing rules files (like CLAUDE.md, .cursorrules, .cursor/rules, .github/copilot-instructions.md), incorporate and improve upon them.
 
-Use the \`safeWriteJson\` utility from \`src/utils/safeWriteJson.ts\` for any JSON file operations to ensure atomic writes.`
+Use the \`safeWriteJson\` utility from \`src/utils/safeWriteJson.ts\` for any JSON file operations to ensure atomic writes.
+
+${
+	addToGitignore
+		? `5. **Add the generated files to .gitignore**:
+   - After generating all rule files, add entries to .gitignore to prevent them from being committed
+   - Add each generated file path to .gitignore (e.g., .roo/rules/coding-standards.md)
+   - If .gitignore doesn't exist, create it
+   - If the entries already exist in .gitignore, don't duplicate them`
+		: ""
+}`
 
 	return taskMessage
 }

src/shared/ExtensionMessage.ts

@@ -106,8 +106,10 @@ export interface ExtensionMessage {
 		| "codeIndexSettingsSaved"
 		| "codeIndexSecretStatus"
 		| "rulesGenerationStatus"
+		| "existingRuleFiles"
 	text?: string
 	payload?: any // Add a generic payload for now, can refine later
+	files?: string[] // For existingRuleFiles
 	action?:
 		| "chatButtonClicked"
 		| "mcpButtonClicked"

src/shared/WebviewMessage.ts

@@ -195,6 +195,7 @@ export interface WebviewMessage {
 		| "saveCodeIndexSettingsAtomic"
 		| "requestCodeIndexSecretStatus"
 		| "generateRules"
+		| "checkExistingRuleFiles"
 	text?: string
 	editedMessageContent?: string
 	tab?: "settings" | "history" | "mcp" | "modes" | "chat" | "marketplace" | "account"
@@ -236,6 +237,11 @@ export interface WebviewMessage {
 	visibility?: ShareVisibility // For share visibility
 	hasContent?: boolean // For checkRulesDirectoryResult
 	checkOnly?: boolean // For deleteCustomMode check
+	selectedRuleTypes?: string[] // For generateRules
+	addToGitignore?: boolean // For generateRules
+	alwaysAllowWriteProtected?: boolean // For generateRules
+	apiConfigName?: string // For generateRules
+	files?: string[] // For existingRuleFiles response
 	codeIndexSettings?: {
 		// Global state settings
 		codebaseIndexEnabled: boolean