Codebase indexing and semantic search tool

package.json

@@ -398,6 +398,7 @@
 		"@google/generative-ai": "^0.18.0",
 		"@mistralai/mistralai": "^1.3.6",
 		"@modelcontextprotocol/sdk": "^1.7.0",
+		"@qdrant/js-client-rest": "^1.13.0",
 		"@types/clone-deep": "^4.0.4",
 		"@types/pdf-parse": "^1.1.4",
 		"@types/tmp": "^0.2.6",
@@ -444,6 +445,8 @@
 		"tmp": "^0.2.3",
 		"tree-sitter-wasms": "^0.1.11",
 		"turndown": "^7.2.0",
+		"uuid": "^11.1.0",
+		"uuid5": "^1.0.2",
 		"web-tree-sitter": "^0.22.6",
 		"zod": "^3.23.8"
 	},
@@ -462,6 +465,7 @@
 		"@typescript-eslint/eslint-plugin": "^7.14.1",
 		"@typescript-eslint/parser": "^7.11.0",
 		"@vscode/vsce": "^3.3.2",
+		"async-mutex": "^0.5.0",
 		"esbuild": "^0.24.0",
 		"eslint": "^8.57.0",
 		"execa": "^9.5.2",
@@ -473,6 +477,7 @@
 		"lint-staged": "^15.2.11",
 		"mkdirp": "^3.0.1",
 		"npm-run-all": "^4.1.5",
+		"p-limit": "^6.2.0",
 		"prettier": "^3.4.2",
 		"rimraf": "^6.0.1",
 		"ts-jest": "^29.2.5",

src/__mocks__/vscode.js

@@ -34,6 +34,25 @@ const vscode = {
 			stat: jest.fn(),
 		},
 	},
+	FileSystemError: class FileSystemError extends Error {
+		constructor(message, code) {
+			super(message)
+			this.name = "FileSystemError"
+			this.code = code
+		}
+		static FileNotFound(uri) {
+			return new FileSystemError(`File not found: ${uri}`, "FileNotFound")
+		}
+		static FileExists(uri) {
+			return new FileSystemError(`File already exists: ${uri}`, "FileExists")
+		}
+		static FileNotADirectory(uri) {
+			return new FileSystemError(`Not a directory: ${uri}`, "FileNotADirectory")
+		}
+		static NoPermissions(uri) {
+			return new FileSystemError(`No permissions: ${uri}`, "NoPermissions")
+		}
+	},
 	Disposable: class {
 		dispose() {}
 	},

src/core/Cline.ts

@@ -80,6 +80,7 @@ import { askFollowupQuestionTool } from "./tools/askFollowupQuestionTool"
 import { switchModeTool } from "./tools/switchModeTool"
 import { attemptCompletionTool } from "./tools/attemptCompletionTool"
 import { newTaskTool } from "./tools/newTaskTool"
+import { codebaseSearchTool } from "./tools/codebaseSearchTool"
 
 export type ToolResponse = string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam>
 type UserContent = Array<Anthropic.Messages.ContentBlockParam>
@@ -1407,6 +1408,8 @@ export class Cline extends EventEmitter<ClineEvents> {
 							return `[${block.name}]`
 						case "switch_mode":
 							return `[${block.name} to '${block.params.mode_slug}'${block.params.reason ? ` because: ${block.params.reason}` : ""}]`
+						case "codebase_search": // Add case for the new tool
+							return `[${block.name} for '${block.params.query}']`
 						case "new_task": {
 							const mode = block.params.mode ?? defaultModeSlug
 							const message = block.params.message ?? "(no message)"
@@ -1592,6 +1595,16 @@ export class Cline extends EventEmitter<ClineEvents> {
 					case "list_files":
 						await listFilesTool(this, block, askApproval, handleError, pushToolResult, removeClosingTag)
 						break
+					case "codebase_search":
+						await codebaseSearchTool(
+							this,
+							block,
+							askApproval,
+							handleError,
+							pushToolResult,
+							removeClosingTag,
+						)
+						break
 					case "list_code_definition_names":
 						await listCodeDefinitionNamesTool(
 							this,

src/core/assistant-message/index.ts

@@ -26,6 +26,7 @@ export const toolUseNames = [
 	"switch_mode",
 	"new_task",
 	"fetch_instructions",
+	"codebase_search",
 ] as const
 
 // Converts array of tool call names into a union type ("execute_command" | "read_file" | ...)
@@ -60,6 +61,8 @@ export const toolParamNames = [
 	"cwd",
 	"follow_up",
 	"task",
+	"query",
+	"limit",
 ] as const
 
 export type ToolParamName = (typeof toolParamNames)[number]
@@ -147,3 +150,9 @@ export interface NewTaskToolUse extends ToolUse {
 	name: "new_task"
 	params: Partial<Pick<Record<ToolParamName, string>, "mode" | "message">>
 }
+
+// Added specific interface for codebase_search
+export interface CodebaseSearchToolUse extends ToolUse {
+	name: "codebase_search"
+	params: Partial<Pick<Record<ToolParamName, string>, "query" | "limit">>
+}

src/core/prompts/system.ts

@@ -26,6 +26,7 @@ import {
 } from "./sections"
 import { loadSystemPromptFile } from "./sections/custom-system-prompt"
 import { formatLanguage } from "../../shared/language"
+import { CodeIndexManager } from "../../services/code-index/manager"
 
 async function generatePrompt(
 	context: vscode.ExtensionContext,
@@ -62,6 +63,8 @@ async function generatePrompt(
 			: Promise.resolve(""),
 	])
 
+	const codeIndexManager = CodeIndexManager.getInstance(context)
+
 	const basePrompt = `${roleDefinition}
 
 ${getSharedToolUseSection()}
@@ -70,6 +73,7 @@ ${getToolDescriptionsForMode(
 	mode,
 	cwd,
 	supportsComputerUse,
+	codeIndexManager,
 	effectiveDiffStrategy,
 	browserViewportSize,
 	mcpHub,

src/core/prompts/tools/codebase-search.ts

@@ -0,0 +1,19 @@
+export function getCodebaseSearchDescription(): string {
+	return `## codebase_search
+Description: Search the codebase for relevant files based on a query. Use this when the user asks a question about the codebase that requires finding specific files or code snippets.
+Parameters:
+- query: (required) The natural language query to search for.
+- limit: (optional) The maximum number of search results to return. Defaults to 10.
+Usage:
+<codebase_search>
+<query>Your natural language query here</query>
+<limit>Number of results (optional)</limit>
+</codebase_search>
+
+Example: Searching for functions related to user authentication
+<codebase_search>
+<query>User login and password hashing</query>
+<limit>5</limit>
+</codebase_search>
+`
+}

src/core/prompts/tools/index.ts

@@ -14,11 +14,13 @@ import { getUseMcpToolDescription } from "./use-mcp-tool"
 import { getAccessMcpResourceDescription } from "./access-mcp-resource"
 import { getSwitchModeDescription } from "./switch-mode"
 import { getNewTaskDescription } from "./new-task"
+import { getCodebaseSearchDescription } from "./codebase-search"
 import { DiffStrategy } from "../../diff/DiffStrategy"
 import { McpHub } from "../../../services/mcp/McpHub"
 import { Mode, ModeConfig, getModeConfig, isToolAllowedForMode, getGroupName } from "../../../shared/modes"
 import { ToolName, TOOL_GROUPS, ALWAYS_AVAILABLE_TOOLS } from "../../../shared/tool-groups"
 import { ToolArgs } from "./types"
+import { CodeIndexManager } from "../../../services/code-index/manager"
 
 // Map of tool names to their description functions
 const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined> = {
@@ -34,6 +36,7 @@ const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined>
 	attempt_completion: () => getAttemptCompletionDescription(),
 	use_mcp_tool: (args) => getUseMcpToolDescription(args),
 	access_mcp_resource: (args) => getAccessMcpResourceDescription(args),
+	codebase_search: () => getCodebaseSearchDescription(),
 	switch_mode: () => getSwitchModeDescription(),
 	new_task: (args) => getNewTaskDescription(args),
 	insert_content: (args) => getInsertContentDescription(args),
@@ -46,6 +49,7 @@ export function getToolDescriptionsForMode(
 	mode: Mode,
 	cwd: string,
 	supportsComputerUse: boolean,
+	codeIndexManager: CodeIndexManager,
 	diffStrategy?: DiffStrategy,
 	browserViewportSize?: string,
 	mcpHub?: McpHub,
@@ -79,6 +83,11 @@ export function getToolDescriptionsForMode(
 	// Add always available tools
 	ALWAYS_AVAILABLE_TOOLS.forEach((tool) => tools.add(tool))
 
+	// Conditionally exclude codebase_search if feature is disabled or not configured
+	if (!(codeIndexManager.isFeatureEnabled && codeIndexManager.isFeatureConfigured)) {
+		tools.delete("codebase_search")
+	}
+
 	// Map tool descriptions for allowed tools
 	const descriptions = Array.from(tools).map((toolName) => {
 		const descriptionFn = toolDescriptionMap[toolName]
@@ -112,4 +121,5 @@ export {
 	getSwitchModeDescription,
 	getInsertContentDescription,
 	getSearchAndReplaceDescription,
+	getCodebaseSearchDescription,
 }

src/core/tools/codebaseSearchTool.ts

@@ -0,0 +1,155 @@
+import * as vscode from "vscode"
+import { Cline } from "../Cline"
+import { ToolUse } from "../assistant-message"
+import { CodeIndexManager } from "../../services/code-index/manager"
+import { getWorkspacePath } from "../../utils/path"
+import { formatResponse } from "../prompts/responses"
+import { t } from "../../i18n"
+import { VectorStoreSearchResult } from "../../services/code-index/interfaces"
+import { AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "./types"
+
+export async function codebaseSearchTool(
+	cline: Cline,
+	block: ToolUse,
+	askApproval: AskApproval,
+	handleError: HandleError,
+	pushToolResult: PushToolResult,
+	removeClosingTag: RemoveClosingTag,
+) {
+	const toolName = "codebase_search"
+	const workspacePath = getWorkspacePath()
+
+	if (!workspacePath) {
+		// This case should ideally not happen if Cline is initialized correctly
+		await handleError(toolName, new Error("Could not determine workspace path."))
+		return
+	}
+
+	// --- Parameter Extraction and Validation ---
+	let query: string | undefined = block.params.query
+	let limitStr: string | undefined = block.params.limit
+	let limit: number = 5 // Default limit
+
+	if (!query) {
+		cline.consecutiveMistakeCount++
+		pushToolResult(await cline.sayAndCreateMissingParamError(toolName, "query"))
+		return
+	}
+	query = removeClosingTag("query", query)
+
+	if (limitStr) {
+		limitStr = removeClosingTag("limit", limitStr)
+		limit = parseInt(limitStr, 10)
+		if (isNaN(limit) || limit <= 0) {
+			cline.consecutiveMistakeCount++
+			await cline.say("text", `Invalid limit value: "${limitStr}". Using default ${10}.`)
+			limit = 10
+		}
+	}
+
+	// Extract optional sendResultsToUI parameter
+
+	// --- Approval ---
+	const translationKey = "chat:codebaseSearch.wantsToSearch"
+	let approvalMessage: string
+
+	approvalMessage = t(translationKey, { query, limit })
+
+	const approvalPayload = {
+		tool: "codebase_search",
+		approvalPrompt: approvalMessage,
+		query: query,
+		limit: limit,
+		isOutsideWorkspace: false,
+	}
+
+	const didApprove = await askApproval("tool", JSON.stringify(approvalPayload))
+	if (!didApprove) {
+		pushToolResult(formatResponse.toolDenied())
+		return
+	}
+
+	cline.consecutiveMistakeCount = 0
+
+	// --- Core Logic ---
+	try {
+		const context = cline.providerRef.deref()?.context
+		if (!context) {
+			throw new Error("Extension context is not available.")
+		}
+
+		const manager = CodeIndexManager.getInstance(context)
+
+		// Check if indexing is enabled and configured (using assumed properties/methods)
+		// @ts-expect-error Accessing private member _isEnabled
+		const isEnabled = manager.isEnabled ?? true // Assume enabled if property doesn't exist
+		// @ts-expect-error Accessing private member _isConfigured
+		const isConfigured = manager.isConfigured ? manager.isConfigured() : true // Assume configured if method doesn't exist
+
+		if (!isEnabled) {
+			throw new Error("Code Indexing is disabled in the settings.")
+		}
+		if (!isConfigured) {
+			throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).")
+		}
+
+		const searchResults: VectorStoreSearchResult[] = await manager.searchIndex(query, limit)
+
+		// 3. Format and push results
+		if (!searchResults || searchResults.length === 0) {
+			pushToolResult(`No relevant code snippets found for the query: "${query}"`) // Use simple string for no results
+			return
+		}
+
+		const jsonResult = {
+			query,
+			results: [],
+		} as {
+			query: string
+			results: Array<{
+				filePath: string
+				score: number
+				startLine: number
+				endLine: number
+				codeChunk: string
+			}>
+		}
+
+		searchResults.forEach((result) => {
+			if (!result.payload) return
+			if (!("filePath" in result.payload)) return
+
+			const relativePath = vscode.workspace.asRelativePath(result.payload.filePath, false)
+
+			jsonResult.results.push({
+				filePath: relativePath,
+				score: result.score,
+				startLine: result.payload.startLine,
+				endLine: result.payload.endLine,
+				codeChunk: result.payload.codeChunk.trim(),
+			})
+		})
+
+		// Send results to UI
+		const payload = { tool: toolName, content: jsonResult }
+		await cline.say("tool", JSON.stringify(payload))
+
+		// Push results to AI
+		const output = `Query: ${query}
+Results:
+
+${jsonResult.results
+	.map(
+		(result) => `File path: ${result.filePath}
+Score: ${result.score}
+Lines: ${result.startLine}-${result.endLine}
+Code Chunk: ${result.codeChunk}
+`,
+	)
+	.join("\n")}`
+
+		pushToolResult(output)
+	} catch (error: any) {
+		await handleError(toolName, error) // Use the standard error handler
+	}
+}