Add built-in slash commands

Author: mrubens

src/.vscodeignore

@@ -31,6 +31,7 @@
 !assets/vscode-material-icons/**
 !assets/icons/**
 !assets/images/**
+!assets/built-in-commands/**
 
 # Include .env file for telemetry
 !.env

src/__tests__/command-integration.spec.ts

@@ -15,7 +15,7 @@ describe("Command Integration Tests", () => {
 		commands.forEach((command) => {
 			expect(command.name).toBeDefined()
 			expect(typeof command.name).toBe("string")
-			expect(command.source).toMatch(/^(project|global)$/)
+			expect(command.source).toMatch(/^(project|global|built-in)$/)
 			expect(command.content).toBeDefined()
 			expect(typeof command.content).toBe("string")
 		})
@@ -43,7 +43,7 @@ describe("Command Integration Tests", () => {
 
 			expect(loadedCommand).toBeDefined()
 			expect(loadedCommand?.name).toBe(firstCommand.name)
-			expect(loadedCommand?.source).toMatch(/^(project|global)$/)
+			expect(loadedCommand?.source).toMatch(/^(project|global|built-in)$/)
 			expect(loadedCommand?.content).toBeDefined()
 			expect(typeof loadedCommand?.content).toBe("string")
 		}

src/assets/built-in-commands/create-mode.md

@@ -0,0 +1,5 @@
+---
+description: "Create a custom mode"
+---
+
+TBD

src/assets/built-in-commands/init.md

@@ -0,0 +1,5 @@
+---
+description: "Set up rules for a project"
+---
+
+TBD

src/core/webview/webviewMessageHandler.ts

@@ -2581,6 +2581,7 @@ export const webviewMessageHandler = async (
 					source: command.source,
 					filePath: command.filePath,
 					description: command.description,
+					argumentHint: command.argumentHint,
 				}))
 				await provider.postMessageToWebview({
 					type: "commands",

src/esbuild.mjs

@@ -59,6 +59,14 @@ async function main() {
 						srcDir,
 						buildDir,
 					)
+					// Copy built-in commands to dist directory
+					copyPaths(
+						[
+							["assets/built-in-commands", "assets/built-in-commands"],
+						],
+						srcDir,
+						distDir,
+					)
 				})
 			},
 		},

src/services/command/__tests__/built-in-commands.spec.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest"
+import { getBuiltInCommands, getBuiltInCommand, getBuiltInCommandNames } from "../built-in-commands"
+
+describe("Built-in Commands", () => {
+	describe("getBuiltInCommands", () => {
+		it("should return all built-in commands", async () => {
+			const commands = await getBuiltInCommands()
+
+			expect(commands).toHaveLength(2)
+			expect(commands.map((cmd) => cmd.name)).toEqual(expect.arrayContaining(["init", "create-mode"]))
+
+			// Verify all commands have required properties
+			commands.forEach((command) => {
+				expect(command.name).toBeDefined()
+				expect(typeof command.name).toBe("string")
+				expect(command.content).toBeDefined()
+				expect(typeof command.content).toBe("string")
+				expect(command.source).toBe("built-in")
+				expect(command.filePath).toMatch(/^<built-in:.+>$/)
+				expect(command.description).toBeDefined()
+				expect(typeof command.description).toBe("string")
+			})
+		})
+
+		it("should return commands with proper content", async () => {
+			const commands = await getBuiltInCommands()
+
+			const initCommand = commands.find((cmd) => cmd.name === "init")
+			expect(initCommand).toBeDefined()
+			expect(initCommand!.content).toContain("Initialize Roo Project")
+			expect(initCommand!.content).toContain(".roo/rules/")
+			expect(initCommand!.description).toBe("Initialize a Roo project with recommended rules and configuration")
+
+			const createModeCommand = commands.find((cmd) => cmd.name === "create-mode")
+			expect(createModeCommand).toBeDefined()
+			expect(createModeCommand!.content).toContain("Create a Custom Mode")
+			expect(createModeCommand!.content).toContain("YAML")
+			expect(createModeCommand!.description).toBe("Create a custom mode for specialized AI assistance")
+		})
+	})
+
+	describe("getBuiltInCommand", () => {
+		it("should return specific built-in command by name", async () => {
+			const initCommand = await getBuiltInCommand("init")
+
+			expect(initCommand).toBeDefined()
+			expect(initCommand!.name).toBe("init")
+			expect(initCommand!.source).toBe("built-in")
+			expect(initCommand!.filePath).toBe("<built-in:init>")
+			expect(initCommand!.content).toContain("Initialize Roo Project")
+			expect(initCommand!.description).toBe("Initialize a Roo project with recommended rules and configuration")
+		})
+
+		it("should return create-mode command", async () => {
+			const createModeCommand = await getBuiltInCommand("create-mode")
+
+			expect(createModeCommand).toBeDefined()
+			expect(createModeCommand!.name).toBe("create-mode")
+			expect(createModeCommand!.source).toBe("built-in")
+			expect(createModeCommand!.filePath).toBe("<built-in:create-mode>")
+			expect(createModeCommand!.content).toContain("Create a Custom Mode")
+			expect(createModeCommand!.description).toBe("Create a custom mode for specialized AI assistance")
+		})
+
+		it("should return undefined for non-existent command", async () => {
+			const nonExistentCommand = await getBuiltInCommand("non-existent")
+			expect(nonExistentCommand).toBeUndefined()
+		})
+
+		it("should handle empty string command name", async () => {
+			const emptyCommand = await getBuiltInCommand("")
+			expect(emptyCommand).toBeUndefined()
+		})
+	})
+
+	describe("getBuiltInCommandNames", () => {
+		it("should return all built-in command names", async () => {
+			const names = await getBuiltInCommandNames()
+
+			expect(names).toHaveLength(2)
+			expect(names).toEqual(expect.arrayContaining(["init", "create-mode"]))
+			// Order doesn't matter since it's based on filesystem order
+			expect(names.sort()).toEqual(["create-mode", "init"])
+		})
+
+		it("should return array of strings", async () => {
+			const names = await getBuiltInCommandNames()
+
+			names.forEach((name) => {
+				expect(typeof name).toBe("string")
+				expect(name.length).toBeGreaterThan(0)
+			})
+		})
+	})
+
+	describe("Command Content Validation", () => {
+		it("init command should have comprehensive content", async () => {
+			const command = await getBuiltInCommand("init")
+			const content = command!.content
+
+			// Should contain key sections
+			expect(content).toContain("What this command does:")
+			expect(content).toContain("Recommended starter rules:")
+			expect(content).toContain("Getting Started:")
+			expect(content).toContain("Example rule file structure:")
+
+			// Should mention important concepts
+			expect(content).toContain("code-style.md")
+			expect(content).toContain("project-context.md")
+			expect(content).toContain("testing.md")
+			expect(content).toContain("@rules")
+		})
+
+		it("create-mode command should have comprehensive content", async () => {
+			const command = await getBuiltInCommand("create-mode")
+			const content = command!.content
+
+			// Should contain key sections
+			expect(content).toContain("What are Modes?")
+			expect(content).toContain("Mode Configuration")
+			expect(content).toContain("Mode Properties")
+			expect(content).toContain("Creating Your Mode")
+			expect(content).toContain("Mode Examples")
+			expect(content).toContain("Best Practices")
+
+			// Should mention important concepts
+			expect(content).toContain("YAML")
+			expect(content).toContain("instructions")
+			expect(content).toContain("file_restrictions")
+			expect(content).toContain("tools")
+		})
+	})
+})

src/services/command/built-in-commands.ts

@@ -0,0 +1,113 @@
+import fs from "fs/promises"
+import * as path from "path"
+import matter from "gray-matter"
+import { Command } from "./commands"
+
+/**
+ * Get the path to the built-in commands directory
+ */
+function getBuiltInCommandsDirectory(): string {
+	// Handle both development and compiled extension environments
+	// In development: __dirname = /path/to/src/services/command
+	// In compiled: __dirname = /path/to/src/dist/services/command
+
+	if (__dirname.includes("/dist/")) {
+		// Compiled extension: navigate from dist/services/command to dist/assets/built-in-commands
+		return path.join(__dirname, "..", "..", "assets", "built-in-commands")
+	} else {
+		// Development: navigate from src/services/command to src/assets/built-in-commands
+		return path.join(__dirname, "..", "assets", "built-in-commands")
+	}
+}
+
+/**
+ * Load a built-in command from a markdown file
+ */
+async function loadBuiltInCommandFromFile(filePath: string, name: string): Promise<Command | undefined> {
+	try {
+		const content = await fs.readFile(filePath, "utf-8")
+
+		let parsed
+		let description: string | undefined
+		let argumentHint: string | undefined
+		let commandContent: string
+
+		try {
+			// Try to parse frontmatter with gray-matter
+			parsed = matter(content)
+			description =
+				typeof parsed.data.description === "string" && parsed.data.description.trim()
+					? parsed.data.description.trim()
+					: undefined
+			argumentHint =
+				typeof parsed.data["argument-hint"] === "string" && parsed.data["argument-hint"].trim()
+					? parsed.data["argument-hint"].trim()
+					: undefined
+			commandContent = parsed.content.trim()
+		} catch (frontmatterError) {
+			// If frontmatter parsing fails, treat the entire content as command content
+			description = undefined
+			argumentHint = undefined
+			commandContent = content.trim()
+		}
+
+		return {
+			name,
+			content: commandContent,
+			source: "built-in",
+			filePath: `<built-in:${name}>`,
+			description,
+			argumentHint,
+		}
+	} catch (error) {
+		// File doesn't exist or can't be read
+		return undefined
+	}
+}
+
+/**
+ * Get all built-in commands as Command objects
+ */
+export async function getBuiltInCommands(): Promise<Command[]> {
+	const commands: Command[] = []
+	const builtInCommandsDir = getBuiltInCommandsDirectory()
+
+	try {
+		const entries = await fs.readdir(builtInCommandsDir, { withFileTypes: true })
+
+		for (const entry of entries) {
+			if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+				const commandName = entry.name.slice(0, -3) // Remove .md extension
+				const filePath = path.join(builtInCommandsDir, entry.name)
+
+				const command = await loadBuiltInCommandFromFile(filePath, commandName)
+				if (command) {
+					commands.push(command)
+				}
+			}
+		}
+	} catch (error) {
+		// Directory doesn't exist or can't be read - this is fine, just return empty array
+		console.warn("Built-in commands directory not found or not readable:", error)
+	}
+
+	return commands
+}
+
+/**
+ * Get a specific built-in command by name
+ */
+export async function getBuiltInCommand(name: string): Promise<Command | undefined> {
+	const builtInCommandsDir = getBuiltInCommandsDirectory()
+	const filePath = path.join(builtInCommandsDir, `${name}.md`)
+
+	return await loadBuiltInCommandFromFile(filePath, name)
+}
+
+/**
+ * Get names of all built-in commands
+ */
+export async function getBuiltInCommandNames(): Promise<string[]> {
+	const commands = await getBuiltInCommands()
+	return commands.map((cmd) => cmd.name)
+}

src/services/command/commands.ts

@@ -2,27 +2,35 @@ import fs from "fs/promises"
 import * as path from "path"
 import matter from "gray-matter"
 import { getGlobalRooDirectory, getProjectRooDirectoryForCwd } from "../roo-config"
+import { getBuiltInCommands, getBuiltInCommand } from "./built-in-commands"
 
 export interface Command {
 	name: string
 	content: string
-	source: "global" | "project"
+	source: "global" | "project" | "built-in"
 	filePath: string
 	description?: string
 	argumentHint?: string
 }
 
 /**
- * Get all available commands from both global and project directories
+ * Get all available commands from built-in, global, and project directories
+ * Priority order: project > global > built-in (later sources override earlier ones)
  */
 export async function getCommands(cwd: string): Promise<Command[]> {
 	const commands = new Map<string, Command>()
 
-	// Scan global commands first
+	// Add built-in commands first (lowest priority)
+	const builtInCommands = await getBuiltInCommands()
+	for (const command of builtInCommands) {
+		commands.set(command.name, command)
+	}
+
+	// Scan global commands (override built-in)
 	const globalDir = path.join(getGlobalRooDirectory(), "commands")
 	await scanCommandDirectory(globalDir, "global", commands)
 
-	// Scan project commands (these override global ones)
+	// Scan project commands (highest priority - override both global and built-in)
 	const projectDir = path.join(getProjectRooDirectoryForCwd(cwd), "commands")
 	await scanCommandDirectory(projectDir, "project", commands)
 
@@ -31,21 +39,27 @@ export async function getCommands(cwd: string): Promise<Command[]> {
 
 /**
  * Get a specific command by name (optimized to avoid scanning all commands)
+ * Priority order: project > global > built-in
  */
 export async function getCommand(cwd: string, name: string): Promise<Command | undefined> {
 	// Try to find the command directly without scanning all commands
 	const projectDir = path.join(getProjectRooDirectoryForCwd(cwd), "commands")
 	const globalDir = path.join(getGlobalRooDirectory(), "commands")
 
-	// Check project directory first (project commands override global ones)
+	// Check project directory first (highest priority)
 	const projectCommand = await tryLoadCommand(projectDir, name, "project")
 	if (projectCommand) {
 		return projectCommand
 	}
 
 	// Check global directory if not found in project
 	const globalCommand = await tryLoadCommand(globalDir, name, "global")
-	return globalCommand
+	if (globalCommand) {
+		return globalCommand
+	}
+
+	// Check built-in commands if not found in project or global (lowest priority)
+	return await getBuiltInCommand(name)
 }
 
 /**

src/shared/ExtensionMessage.ts

@@ -22,7 +22,7 @@ import type { MarketplaceItem } from "@roo-code/types"
 // Command interface for frontend/backend communication
 export interface Command {
 	name: string
-	source: "global" | "project"
+	source: "global" | "project" | "built-in"
 	filePath?: string
 	description?: string
 	argumentHint?: string