feat: add telemetry for slash command usage

- Add SLASH_COMMAND_USED telemetry event type
- Implement slash command detection with regex pattern matching
- Classify commands as mode_switch vs custom types
- Integrate telemetry capture in user input processing
- Add comprehensive test coverage for detection logic and telemetry

Author: roomote

packages/telemetry/src/TelemetryService.ts

@@ -226,6 +226,16 @@ export class TelemetryService {
 		this.captureEvent(TelemetryEventName.TITLE_BUTTON_CLICKED, { button })
 	}
 
+	/**
+	 * Captures a slash command usage event
+	 * @param taskId The task ID where the command was used
+	 * @param commandType The type of command (custom or mode_switch)
+	 * @param commandName The name of the command used
+	 */
+	public captureSlashCommandUsed(taskId: string, commandType: "custom" | "mode_switch", commandName: string): void {
+		this.captureEvent(TelemetryEventName.SLASH_COMMAND_USED, { taskId, commandType, commandName })
+	}
+
 	/**
 	 * Checks if telemetry is currently enabled
 	 * @returns Whether telemetry is enabled

packages/telemetry/src/__tests__/TelemetryService.slashCommands.test.ts

@@ -0,0 +1,117 @@
+// npx vitest run packages/telemetry/src/__tests__/TelemetryService.slashCommands.test.ts
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { TelemetryService } from "../TelemetryService"
+import { TelemetryEventName } from "@roo-code/types"
+
+describe("TelemetryService - Slash Commands", () => {
+	let telemetryService: TelemetryService
+	let mockClient: {
+		capture: ReturnType<typeof vi.fn>
+		setProvider: ReturnType<typeof vi.fn>
+		updateTelemetryState: ReturnType<typeof vi.fn>
+		isTelemetryEnabled: ReturnType<typeof vi.fn>
+		shutdown: ReturnType<typeof vi.fn>
+	}
+
+	beforeEach(() => {
+		// Reset the singleton instance
+		;(TelemetryService as unknown as { _instance: TelemetryService | null })._instance = null
+
+		mockClient = {
+			capture: vi.fn(),
+			setProvider: vi.fn(),
+			updateTelemetryState: vi.fn(),
+			isTelemetryEnabled: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn(),
+		}
+
+		telemetryService = TelemetryService.createInstance([mockClient])
+	})
+
+	afterEach(() => {
+		// Clean up singleton instance after each test
+		;(TelemetryService as unknown as { _instance: TelemetryService | null })._instance = null
+	})
+
+	describe("captureSlashCommandUsed", () => {
+		it("should capture custom slash command usage", () => {
+			const taskId = "test-task-123"
+			const commandType = "custom"
+			const commandName = "deploy"
+
+			telemetryService.captureSlashCommandUsed(taskId, commandType, commandName)
+
+			expect(mockClient.capture).toHaveBeenCalledWith({
+				event: TelemetryEventName.SLASH_COMMAND_USED,
+				properties: {
+					taskId,
+					commandType,
+					commandName,
+				},
+			})
+		})
+
+		it("should capture mode switch slash command usage", () => {
+			const taskId = "test-task-456"
+			const commandType = "mode_switch"
+			const commandName = "code"
+
+			telemetryService.captureSlashCommandUsed(taskId, commandType, commandName)
+
+			expect(mockClient.capture).toHaveBeenCalledWith({
+				event: TelemetryEventName.SLASH_COMMAND_USED,
+				properties: {
+					taskId,
+					commandType,
+					commandName,
+				},
+			})
+		})
+
+		it("should handle multiple slash command captures", () => {
+			const taskId = "test-task-789"
+
+			telemetryService.captureSlashCommandUsed(taskId, "custom", "build")
+			telemetryService.captureSlashCommandUsed(taskId, "mode_switch", "debug")
+			telemetryService.captureSlashCommandUsed(taskId, "custom", "test")
+
+			expect(mockClient.capture).toHaveBeenCalledTimes(3)
+			expect(mockClient.capture).toHaveBeenNthCalledWith(1, {
+				event: TelemetryEventName.SLASH_COMMAND_USED,
+				properties: {
+					taskId,
+					commandType: "custom",
+					commandName: "build",
+				},
+			})
+			expect(mockClient.capture).toHaveBeenNthCalledWith(2, {
+				event: TelemetryEventName.SLASH_COMMAND_USED,
+				properties: {
+					taskId,
+					commandType: "mode_switch",
+					commandName: "debug",
+				},
+			})
+			expect(mockClient.capture).toHaveBeenNthCalledWith(3, {
+				event: TelemetryEventName.SLASH_COMMAND_USED,
+				properties: {
+					taskId,
+					commandType: "custom",
+					commandName: "test",
+				},
+			})
+		})
+
+		it("should not capture when service is not ready", () => {
+			// Reset the instance to test empty service
+			;(TelemetryService as unknown as { _instance: TelemetryService | null })._instance = null
+			const emptyService = TelemetryService.createInstance([])
+
+			emptyService.captureSlashCommandUsed("task-id", "custom", "command")
+
+			// Should not throw and should not call any client methods
+			expect(mockClient.capture).not.toHaveBeenCalled()
+		})
+	})
+})

packages/types/src/telemetry.ts

@@ -66,6 +66,7 @@ export enum TelemetryEventName {
 	SHELL_INTEGRATION_ERROR = "Shell Integration Error",
 	CONSECUTIVE_MISTAKE_ERROR = "Consecutive Mistake Error",
 	CODE_INDEX_ERROR = "Code Index Error",
+	SLASH_COMMAND_USED = "Slash Command Used",
 }
 
 /**
@@ -167,6 +168,7 @@ export const rooCodeTelemetryEventSchema = z.discriminatedUnion("type", [
 			TelemetryEventName.TAB_SHOWN,
 			TelemetryEventName.MODE_SETTINGS_CHANGED,
 			TelemetryEventName.CUSTOM_MODE_CREATED,
+			TelemetryEventName.SLASH_COMMAND_USED,
 		]),
 		properties: telemetryPropertiesSchema,
 	}),

src/core/task/Task.ts

@@ -29,6 +29,9 @@ import {
 import { TelemetryService } from "@roo-code/telemetry"
 import { CloudService } from "@roo-code/cloud"
 
+// utils
+import { detectSlashCommands } from "../../utils/slashCommandDetection"
+
 // api
 import { ApiHandler, ApiHandlerCreateMessageMetadata, buildApiHandler } from "../../api"
 import { ApiStream } from "../../api/transform/stream"
@@ -714,6 +717,14 @@ export class Task extends EventEmitter<ClineEvents> {
 		this.askResponse = askResponse
 		this.askResponseText = text
 		this.askResponseImages = images
+
+		// Detect and track slash command usage
+		if (askResponse === "messageResponse" && text && TelemetryService.hasInstance()) {
+			const slashCommands = detectSlashCommands(text)
+			for (const command of slashCommands) {
+				TelemetryService.instance.captureSlashCommandUsed(this.taskId, command.type, command.commandName)
+			}
+		}
 	}
 
 	async handleTerminalOperation(terminalOperation: "continue" | "abort") {

src/utils/__tests__/slashCommandDetection.spec.ts

@@ -0,0 +1,191 @@
+// npx vitest run src/utils/__tests__/slashCommandDetection.spec.ts
+
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { detectSlashCommands, getFirstSlashCommand } from "../slashCommandDetection"
+
+// Mock the modes module
+vi.mock("../../shared/modes", () => ({
+	modes: [
+		{ slug: "code", name: "Code" },
+		{ slug: "architect", name: "Architect" },
+		{ slug: "debug", name: "Debug" },
+		{ slug: "ask", name: "Ask" },
+	],
+	getModeBySlug: vi.fn((slug: string) => {
+		const modeMap: Record<string, any> = {
+			code: { slug: "code", name: "Code" },
+			architect: { slug: "architect", name: "Architect" },
+			debug: { slug: "debug", name: "Debug" },
+			ask: { slug: "ask", name: "Ask" },
+		}
+		return modeMap[slug]
+	}),
+}))
+
+describe("slashCommandDetection", () => {
+	describe("detectSlashCommands", () => {
+		it("should detect mode switch commands", () => {
+			const text = "Let me switch to /code mode to implement this"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(1)
+			expect(commands[0]).toEqual({
+				fullCommand: "/code",
+				commandName: "code",
+				type: "mode_switch",
+			})
+		})
+
+		it("should detect custom commands", () => {
+			const text = "I'll use /deploy to deploy this application"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(1)
+			expect(commands[0]).toEqual({
+				fullCommand: "/deploy",
+				commandName: "deploy",
+				type: "custom",
+			})
+		})
+
+		it("should detect multiple commands in one text", () => {
+			const text = "First /architect the solution, then /code it, and finally /deploy"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(3)
+			expect(commands[0]).toEqual({
+				fullCommand: "/architect",
+				commandName: "architect",
+				type: "mode_switch",
+			})
+			expect(commands[1]).toEqual({
+				fullCommand: "/code",
+				commandName: "code",
+				type: "mode_switch",
+			})
+			expect(commands[2]).toEqual({
+				fullCommand: "/deploy",
+				commandName: "deploy",
+				type: "custom",
+			})
+		})
+
+		it("should detect commands at the beginning of text", () => {
+			const text = "/debug this issue please"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(1)
+			expect(commands[0]).toEqual({
+				fullCommand: "/debug",
+				commandName: "debug",
+				type: "mode_switch",
+			})
+		})
+
+		it("should detect commands at the beginning of new lines", () => {
+			const text = "First do this:\n/architect the solution\nThen:\n/code the implementation"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(2)
+			expect(commands[0]).toEqual({
+				fullCommand: "/architect",
+				commandName: "architect",
+				type: "mode_switch",
+			})
+			expect(commands[1]).toEqual({
+				fullCommand: "/code",
+				commandName: "code",
+				type: "mode_switch",
+			})
+		})
+
+		it("should handle commands with hyphens and underscores", () => {
+			const text = "Use /my-custom_command to do this"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(1)
+			expect(commands[0]).toEqual({
+				fullCommand: "/my-custom_command",
+				commandName: "my-custom_command",
+				type: "custom",
+			})
+		})
+
+		it("should not detect invalid slash patterns", () => {
+			const text = "This is a file path /home/user/file.txt and a URL https://example.com/path"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(0)
+		})
+
+		it("should not detect slash commands in the middle of words", () => {
+			const text = "The file://path and http://example.com don't contain commands"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(0)
+		})
+
+		it("should handle empty or null input", () => {
+			expect(detectSlashCommands("")).toEqual([])
+			expect(detectSlashCommands(null as any)).toEqual([])
+			expect(detectSlashCommands(undefined as any)).toEqual([])
+		})
+
+		it("should handle text with no commands", () => {
+			const text = "This is just regular text with no slash commands"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toEqual([])
+		})
+
+		it("should detect commands that start with numbers after the slash", () => {
+			const text = "Use /2fa to enable two-factor authentication"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(0) // Should not match as it starts with a number
+		})
+
+		it("should detect commands that contain numbers", () => {
+			const text = "Use /deploy2prod to deploy to production"
+			const commands = detectSlashCommands(text)
+
+			expect(commands).toHaveLength(1)
+			expect(commands[0]).toEqual({
+				fullCommand: "/deploy2prod",
+				commandName: "deploy2prod",
+				type: "custom",
+			})
+		})
+	})
+
+	describe("getFirstSlashCommand", () => {
+		it("should return the first command when multiple exist", () => {
+			const text = "First /architect then /code then /deploy"
+			const command = getFirstSlashCommand(text)
+
+			expect(command).toEqual({
+				fullCommand: "/architect",
+				commandName: "architect",
+				type: "mode_switch",
+			})
+		})
+
+		it("should return null when no commands exist", () => {
+			const text = "No commands here"
+			const command = getFirstSlashCommand(text)
+
+			expect(command).toBeNull()
+		})
+
+		it("should return the single command when only one exists", () => {
+			const text = "Please /debug this issue"
+			const command = getFirstSlashCommand(text)
+
+			expect(command).toEqual({
+				fullCommand: "/debug",
+				commandName: "debug",
+				type: "mode_switch",
+			})
+		})
+	})
+})