feat: implement Daniel's feedback on PR #6118

Author: MuriloFP

src/core/tools/__tests__/codebaseSearchTool.spec.ts

@@ -3,6 +3,8 @@ import { codebaseSearchTool } from "../codebaseSearchTool"
 import { CodeIndexManager } from "../../../services/code-index/manager"
 import { Task } from "../../task/Task"
 import { ToolUse } from "../../../shared/tools"
+import { TelemetryService } from "@roo-code/telemetry"
+import { TelemetryEventName } from "@roo-code/types"
 
 // Mock dependencies
 vi.mock("../../../services/code-index/manager")
@@ -19,6 +21,13 @@ vi.mock("vscode", () => ({
 		asRelativePath: vi.fn((path: string) => path.replace("/test/workspace/", "")),
 	},
 }))
+vi.mock("@roo-code/telemetry", () => ({
+	TelemetryService: {
+		instance: {
+			captureEvent: vi.fn(),
+		},
+	},
+}))
 
 describe("codebaseSearchTool", () => {
 	let mockTask: Task
@@ -274,6 +283,145 @@ describe("codebaseSearchTool", () => {
 				expect.stringContaining("Semantic search is not available yet (currently Standby)"),
 			)
 		})
+
+		it("should track telemetry when indexing is in Standby state", async () => {
+			mockCodeIndexManager.state = "Standby"
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "codebase_search",
+				params: { query: "test query" },
+				partial: false,
+			}
+
+			await codebaseSearchTool(
+				mockTask,
+				block,
+				mockAskApproval,
+				mockHandleError,
+				mockPushToolResult,
+				mockRemoveClosingTag,
+			)
+
+			expect(TelemetryService.instance.captureEvent).toHaveBeenCalledWith(TelemetryEventName.TOOL_USED, {
+				tool: "codebase_search",
+				codeIndexState: "Standby",
+				hasQuery: true,
+				result: "unavailable_not_indexed",
+			})
+		})
+
+		it("should track telemetry when indexing is in progress", async () => {
+			mockCodeIndexManager.state = "Indexing"
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "codebase_search",
+				params: { query: "test query" },
+				partial: false,
+			}
+
+			await codebaseSearchTool(
+				mockTask,
+				block,
+				mockAskApproval,
+				mockHandleError,
+				mockPushToolResult,
+				mockRemoveClosingTag,
+			)
+
+			expect(TelemetryService.instance.captureEvent).toHaveBeenCalledWith(TelemetryEventName.TOOL_USED, {
+				tool: "codebase_search",
+				codeIndexState: "Indexing",
+				hasQuery: true,
+				result: "unavailable_not_indexed",
+			})
+			expect(mockPushToolResult).toHaveBeenCalledWith(
+				expect.stringContaining("Code indexing is currently in progress"),
+			)
+		})
+
+		it("should track telemetry when indexing is in error state", async () => {
+			mockCodeIndexManager.state = "Error"
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "codebase_search",
+				params: { query: "test query" },
+				partial: false,
+			}
+
+			await codebaseSearchTool(
+				mockTask,
+				block,
+				mockAskApproval,
+				mockHandleError,
+				mockPushToolResult,
+				mockRemoveClosingTag,
+			)
+
+			expect(TelemetryService.instance.captureEvent).toHaveBeenCalledWith(TelemetryEventName.TOOL_USED, {
+				tool: "codebase_search",
+				codeIndexState: "Error",
+				hasQuery: true,
+				result: "unavailable_not_indexed",
+			})
+			expect(mockPushToolResult).toHaveBeenCalledWith(
+				expect.stringContaining("Code indexing encountered an error"),
+			)
+		})
+
+		it("should not track telemetry when indexing is complete", async () => {
+			mockCodeIndexManager.state = "Indexed"
+			mockCodeIndexManager.searchIndex.mockResolvedValue([])
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "codebase_search",
+				params: { query: "test query" },
+				partial: false,
+			}
+
+			await codebaseSearchTool(
+				mockTask,
+				block,
+				mockAskApproval,
+				mockHandleError,
+				mockPushToolResult,
+				mockRemoveClosingTag,
+			)
+
+			// Should not capture telemetry event for non-indexed states
+			expect(TelemetryService.instance.captureEvent).not.toHaveBeenCalledWith(
+				TelemetryEventName.TOOL_USED,
+				expect.objectContaining({
+					result: "unavailable_not_indexed",
+				}),
+			)
+		})
+
+		it("should track telemetry with hasQuery false when query is missing", async () => {
+			mockCodeIndexManager.state = "Standby"
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "codebase_search",
+				params: {},
+				partial: false,
+			}
+
+			await codebaseSearchTool(
+				mockTask,
+				block,
+				mockAskApproval,
+				mockHandleError,
+				mockPushToolResult,
+				mockRemoveClosingTag,
+			)
+
+			// Even though query is missing, telemetry should still be tracked before parameter validation
+			expect(mockTask.sayAndCreateMissingParamError).toHaveBeenCalledWith("codebase_search", "query")
+		})
 	})
 
 	describe("parameter validation", () => {

src/core/tools/codebaseSearchTool.ts

@@ -7,6 +7,28 @@ import { formatResponse } from "../prompts/responses"
 import { VectorStoreSearchResult } from "../../services/code-index/interfaces"
 import { AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolUse } from "../../shared/tools"
 import path from "path"
+import { TelemetryService } from "@roo-code/telemetry"
+import { TelemetryEventName } from "@roo-code/types"
+
+type IndexingState = "Standby" | "Indexing" | "Indexed" | "Error"
+
+/**
+ * Get a user-friendly message for the current indexing state
+ * @param state The current indexing state
+ * @returns A descriptive message for the user
+ */
+function getIndexingStateMessage(state: IndexingState): string {
+	switch (state) {
+		case "Standby":
+			return "Code indexing has not started yet. Please wait for the initial indexing to complete."
+		case "Indexing":
+			return "Code indexing is currently in progress. Semantic search will be available once indexing is complete."
+		case "Error":
+			return "Code indexing encountered an error. Please check your configuration and try again."
+		default:
+			return `Code indexing is in an unexpected state: ${state}`
+	}
+}
 
 export async function codebaseSearchTool(
 	cline: Task,
@@ -83,24 +105,20 @@ export async function codebaseSearchTool(
 		}
 
 		// Check indexing state at runtime
-		const indexingState = manager.state
+		const indexingState = manager.state as IndexingState
+
+		// Track telemetry for non-indexed states
+		if (indexingState !== "Indexed") {
+			TelemetryService.instance.captureEvent(TelemetryEventName.TOOL_USED, {
+				tool: toolName,
+				codeIndexState: indexingState,
+				hasQuery: query ? true : false,
+				result: "unavailable_not_indexed",
+			})
+		}
+
 		if (indexingState !== "Indexed") {
-			let stateMessage = ""
-			switch (indexingState) {
-				case "Standby":
-					stateMessage =
-						"Code indexing has not started yet. Please wait for the initial indexing to complete."
-					break
-				case "Indexing":
-					stateMessage =
-						"Code indexing is currently in progress. Semantic search will be available once indexing is complete."
-					break
-				case "Error":
-					stateMessage = "Code indexing encountered an error. Please check your configuration and try again."
-					break
-				default:
-					stateMessage = `Code indexing is in an unexpected state: ${indexingState}`
-			}
+			const stateMessage = getIndexingStateMessage(indexingState)
 
 			// Return informative message instead of throwing error
 			pushToolResult(

src/i18n/locales/en/embeddings.json

@@ -52,5 +52,8 @@
 		"vectorDimensionNotDetermined": "Could not determine vector dimension for model '{{modelId}}' with provider '{{provider}}'. Check model profiles or configuration.",
 		"qdrantUrlMissing": "Qdrant URL missing for vector store creation",
 		"codeIndexingNotConfigured": "Cannot create services: Code indexing is not properly configured"
+	},
+	"codeIndex": {
+		"errorState": "Code index is in error state. Please check your configuration."
 	}
 }

src/services/code-index/search-service.ts

@@ -6,6 +6,7 @@ import { CodeIndexConfigManager } from "./config-manager"
 import { CodeIndexStateManager } from "./state-manager"
 import { TelemetryService } from "@roo-code/telemetry"
 import { TelemetryEventName } from "@roo-code/types"
+import { t } from "../../i18n"
 
 /**
  * Service responsible for searching the code index.
@@ -38,7 +39,7 @@ export class CodeIndexSearchService {
 		// This allows the tool to provide more user-friendly feedback
 		const currentState = this.stateManager.getCurrentStatus().systemStatus
 		if (currentState === "Error") {
-			throw new Error(`Code index is in error state. Please check your configuration.`)
+			throw new Error(t("embeddings:codeIndex.errorState"))
 		}
 
 		try {