feat: add respectGitIgnore setting to control .gitignore filtering across all file listing

Adds a new `codebaseIndexRespectGitIgnore` setting (default: true) that controls
whether .gitignore patterns are respected when listing files. This affects:

- Code indexer scanner (original issue scope)
- list_files tool (AI task file listings)
- Environment details (workspace file context)
- WorkspaceTracker (workspace file tracking)

When disabled (false), only .rooignore is used for filtering, allowing
gitignored files (e.g. external API headers) to be discovered and indexed.

Changes:
- packages/types: Add codebaseIndexRespectGitIgnore to schema and types
- src/services/glob/list-files.ts: Add respectGitIgnore parameter
  - Pass --no-ignore-vcs to ripgrep when false
  - Skip gitignore patterns in createIgnoreInstance when false
- src/services/code-index: Thread setting through manager, factory, scanner
- src/core: Thread setting through ListFilesTool, getEnvironmentDetails
- src/integrations/workspace: Thread setting through WorkspaceTracker
- webview-ui: Add toggle in CodeIndexPopover advanced settings
- i18n: Add English translations for new setting

Closes #11249

packages/types/src/codebase-index.ts

@@ -50,6 +50,8 @@ export const codebaseIndexConfigSchema = z.object({
 	codebaseIndexBedrockProfile: z.string().optional(),
 	// OpenRouter specific fields
 	codebaseIndexOpenRouterSpecificProvider: z.string().optional(),
+	// Gitignore behavior
+	codebaseIndexRespectGitIgnore: z.boolean().optional(),
 })
 
 export type CodebaseIndexConfig = z.infer<typeof codebaseIndexConfigSchema>

packages/types/src/vscode-extension-host.ts

@@ -695,6 +695,7 @@ export interface WebviewMessage {
 		codebaseIndexSearchMaxResults?: number
 		codebaseIndexSearchMinScore?: number
 		codebaseIndexOpenRouterSpecificProvider?: string // OpenRouter provider routing
+		codebaseIndexRespectGitIgnore?: boolean // Whether to respect .gitignore when listing files
 
 		// Secret settings
 		codeIndexOpenAiKey?: string

src/core/environment/getEnvironmentDetails.ts

@@ -270,7 +270,8 @@ export async function getEnvironmentDetails(cline: Task, includeFileDetails: boo
 			if (maxFiles === 0) {
 				details += "(Workspace files context disabled. Use list_files to explore if needed.)"
 			} else {
-				const [files, didHitLimit] = await listFiles(cline.cwd, true, maxFiles)
+				const respectGitIgnore = state?.codebaseIndexConfig?.codebaseIndexRespectGitIgnore ?? true
+				const [files, didHitLimit] = await listFiles(cline.cwd, true, maxFiles, respectGitIgnore)
 				const { showRooIgnoredFiles = false } = state ?? {}
 
 				const result = formatResponse.formatFilesList(

src/core/tools/ListFilesTool.ts

@@ -37,8 +37,10 @@ export class ListFilesTool extends BaseTool<"list_files"> {
 			const absolutePath = path.resolve(task.cwd, relDirPath)
 			const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath)
 
-			const [files, didHitLimit] = await listFiles(absolutePath, recursive || false, 200)
-			const { showRooIgnoredFiles = false } = (await task.providerRef.deref()?.getState()) ?? {}
+			const state = await task.providerRef.deref()?.getState()
+			const respectGitIgnore = state?.codebaseIndexConfig?.codebaseIndexRespectGitIgnore ?? true
+			const [files, didHitLimit] = await listFiles(absolutePath, recursive || false, 200, respectGitIgnore)
+			const { showRooIgnoredFiles = false } = state ?? {}
 
 			const result = formatResponse.formatFilesList(
 				absolutePath,

src/core/webview/ClineProvider.ts

@@ -2211,6 +2211,7 @@ export class ClineProvider
 				codebaseIndexBedrockRegion: codebaseIndexConfig?.codebaseIndexBedrockRegion,
 				codebaseIndexBedrockProfile: codebaseIndexConfig?.codebaseIndexBedrockProfile,
 				codebaseIndexOpenRouterSpecificProvider: codebaseIndexConfig?.codebaseIndexOpenRouterSpecificProvider,
+				codebaseIndexRespectGitIgnore: codebaseIndexConfig?.codebaseIndexRespectGitIgnore,
 			},
 			// Only set mdmCompliant if there's an actual MDM policy
 			// undefined means no MDM policy, true means compliant, false means non-compliant
@@ -2450,6 +2451,7 @@ export class ClineProvider
 				codebaseIndexBedrockProfile: stateValues.codebaseIndexConfig?.codebaseIndexBedrockProfile,
 				codebaseIndexOpenRouterSpecificProvider:
 					stateValues.codebaseIndexConfig?.codebaseIndexOpenRouterSpecificProvider,
+				codebaseIndexRespectGitIgnore: stateValues.codebaseIndexConfig?.codebaseIndexRespectGitIgnore,
 			},
 			profileThresholds: stateValues.profileThresholds ?? {},
 			includeDiagnosticMessages: stateValues.includeDiagnosticMessages ?? true,

src/core/webview/webviewMessageHandler.ts

@@ -2543,6 +2543,7 @@ export const webviewMessageHandler = async (
 					codebaseIndexSearchMaxResults: settings.codebaseIndexSearchMaxResults,
 					codebaseIndexSearchMinScore: settings.codebaseIndexSearchMinScore,
 					codebaseIndexOpenRouterSpecificProvider: settings.codebaseIndexOpenRouterSpecificProvider,
+					codebaseIndexRespectGitIgnore: settings.codebaseIndexRespectGitIgnore,
 				}
 
 				// Save global state first

src/integrations/workspace/WorkspaceTracker.ts

@@ -30,7 +30,14 @@ class WorkspaceTracker {
 			return
 		}
 		const tempCwd = this.cwd
-		const [files, _] = await listFiles(tempCwd, true, MAX_INITIAL_FILES)
+		let respectGitIgnore = true
+		try {
+			const state = await this.providerRef.deref()?.getState()
+			respectGitIgnore = state?.codebaseIndexConfig?.codebaseIndexRespectGitIgnore ?? true
+		} catch {
+			// Fall back to default (respect .gitignore) if state is not available
+		}
+		const [files, _] = await listFiles(tempCwd, true, MAX_INITIAL_FILES, respectGitIgnore)
 		if (this.prevWorkSpacePath !== tempCwd) {
 			return
 		}

src/integrations/workspace/__tests__/WorkspaceTracker.spec.ts

@@ -240,7 +240,7 @@ describe("WorkspaceTracker", () => {
 		vitest.runAllTimers()
 
 		// Should initialize file paths for new workspace
-		expect(listFiles).toHaveBeenCalledWith("/test/new-workspace", true, 1000)
+		expect(listFiles).toHaveBeenCalledWith("/test/new-workspace", true, 1000, true)
 		vitest.runAllTimers()
 	})
 

src/services/code-index/manager.ts

@@ -312,20 +312,31 @@ export class CodeIndexManager {
 			return
 		}
 
-		// Create .gitignore instance
-		const ignorePath = path.join(workspacePath, ".gitignore")
+		// Read the respectGitIgnore setting from the codebaseIndexConfig
+		let respectGitIgnore = true
 		try {
-			const content = await fs.readFile(ignorePath, "utf8")
-			ignoreInstance.add(content)
-			ignoreInstance.add(".gitignore")
-		} catch (error) {
-			// Should never happen: reading file failed even though it exists
-			console.error("Unexpected error loading .gitignore:", error)
-			TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
-				error: error instanceof Error ? error.message : String(error),
-				stack: error instanceof Error ? error.stack : undefined,
-				location: "_recreateServices",
-			})
+			const codebaseIndexConfig = this._configManager!.getContextProxy()?.getGlobalState("codebaseIndexConfig")
+			respectGitIgnore = codebaseIndexConfig?.codebaseIndexRespectGitIgnore ?? true
+		} catch {
+			// Fall back to default (respect .gitignore) if config proxy is not available
+		}
+
+		// Create .gitignore instance (only when respecting .gitignore)
+		if (respectGitIgnore) {
+			const ignorePath = path.join(workspacePath, ".gitignore")
+			try {
+				const content = await fs.readFile(ignorePath, "utf8")
+				ignoreInstance.add(content)
+				ignoreInstance.add(".gitignore")
+			} catch (error) {
+				// Should never happen: reading file failed even though it exists
+				console.error("Unexpected error loading .gitignore:", error)
+				TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
+					error: error instanceof Error ? error.message : String(error),
+					stack: error instanceof Error ? error.stack : undefined,
+					location: "_recreateServices",
+				})
+			}
 		}
 
 		// Create RooIgnoreController instance
@@ -338,6 +349,7 @@ export class CodeIndexManager {
 			this._cacheManager!,
 			ignoreInstance,
 			rooIgnoreController,
+			respectGitIgnore,
 		)
 
 		// Validate embedder configuration before proceeding

src/services/code-index/processors/scanner.ts

@@ -41,6 +41,7 @@ export class DirectoryScanner implements IDirectoryScanner {
 		private readonly cacheManager: CacheManager,
 		private readonly ignoreInstance: Ignore,
 		batchSegmentThreshold?: number,
+		private readonly respectGitIgnore: boolean = true,
 	) {
 		// Get the configurable batch size from VSCode settings, fallback to default
 		// If not provided in constructor, try to get from VSCode settings
@@ -76,8 +77,13 @@ export class DirectoryScanner implements IDirectoryScanner {
 		// Capture workspace context at scan start
 		const scanWorkspace = getWorkspacePathForContext(directoryPath)
 
-		// Get all files recursively (handles .gitignore automatically)
-		const [allPaths, _] = await listFiles(directoryPath, true, MAX_LIST_FILES_LIMIT_CODE_INDEX)
+		// Get all files recursively (handles .gitignore based on respectGitIgnore setting)
+		const [allPaths, _] = await listFiles(
+			directoryPath,
+			true,
+			MAX_LIST_FILES_LIMIT_CODE_INDEX,
+			this.respectGitIgnore,
+		)
 
 		// Filter out directories (marked with trailing '/')
 		const filePaths = allPaths.filter((p) => !p.endsWith("/"))

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

@@ -181,6 +181,7 @@ export class CodeIndexServiceFactory {
 		vectorStore: IVectorStore,
 		parser: ICodeParser,
 		ignoreInstance: Ignore,
+		respectGitIgnore: boolean = true,
 	): DirectoryScanner {
 		// Get the configurable batch size from VSCode settings
 		let batchSize: number
@@ -192,7 +193,15 @@ export class CodeIndexServiceFactory {
 			// In test environment, vscode.workspace might not be available
 			batchSize = BATCH_SEGMENT_THRESHOLD
 		}
-		return new DirectoryScanner(embedder, vectorStore, parser, this.cacheManager, ignoreInstance, batchSize)
+		return new DirectoryScanner(
+			embedder,
+			vectorStore,
+			parser,
+			this.cacheManager,
+			ignoreInstance,
+			batchSize,
+			respectGitIgnore,
+		)
 	}
 
 	/**
@@ -237,6 +246,7 @@ export class CodeIndexServiceFactory {
 		cacheManager: CacheManager,
 		ignoreInstance: Ignore,
 		rooIgnoreController?: RooIgnoreController,
+		respectGitIgnore: boolean = true,
 	): {
 		embedder: IEmbedder
 		vectorStore: IVectorStore
@@ -251,7 +261,7 @@ export class CodeIndexServiceFactory {
 		const embedder = this.createEmbedder()
 		const vectorStore = this.createVectorStore()
 		const parser = codeParser
-		const scanner = this.createDirectoryScanner(embedder, vectorStore, parser, ignoreInstance)
+		const scanner = this.createDirectoryScanner(embedder, vectorStore, parser, ignoreInstance, respectGitIgnore)
 		const fileWatcher = this.createFileWatcher(
 			context,
 			embedder,

src/services/glob/__mocks__/list-files.ts

@@ -28,9 +28,10 @@ const mockResolve = (dirPath: string): string => {
  * @param dirPath - Directory path to list files from
  * @param recursive - Whether to list files recursively
  * @param limit - Maximum number of files to return
+ * @param _respectGitIgnore - Whether to respect .gitignore (ignored in mock)
  * @returns Promise resolving to [file paths, limit reached flag]
  */
-export const listFiles = vi.fn((dirPath: string, _recursive: boolean, limit: number) => {
+export const listFiles = vi.fn((dirPath: string, _recursive: boolean, limit: number, _respectGitIgnore?: boolean) => {
 	// Early return for limit of 0 - matches the actual implementation
 	if (limit === 0) {
 		return Promise.resolve([[], false])

src/services/glob/list-files.ts

@@ -28,9 +28,15 @@ interface ScanContext {
  * @param dirPath - Directory path to list files from
  * @param recursive - Whether to recursively list files in subdirectories
  * @param limit - Maximum number of files to return
+ * @param respectGitIgnore - Whether to respect .gitignore when listing files (default: true)
  * @returns Tuple of [file paths array, whether the limit was reached]
  */
-export async function listFiles(dirPath: string, recursive: boolean, limit: number): Promise<[string[], boolean]> {
+export async function listFiles(
+	dirPath: string,
+	recursive: boolean,
+	limit: number,
+	respectGitIgnore: boolean = true,
+): Promise<[string[], boolean]> {
 	// Early return for limit of 0 - no need to scan anything
 	if (limit === 0) {
 		return [[], false]
@@ -48,8 +54,8 @@ export async function listFiles(dirPath: string, recursive: boolean, limit: numb
 
 	if (!recursive) {
 		// For non-recursive, use the existing approach
-		const files = await listFilesWithRipgrep(rgPath, dirPath, false, limit)
-		const ignoreInstance = await createIgnoreInstance(dirPath)
+		const files = await listFilesWithRipgrep(rgPath, dirPath, false, limit, respectGitIgnore)
+		const ignoreInstance = await createIgnoreInstance(dirPath, respectGitIgnore)
 		// Calculate remaining limit for directories
 		const remainingLimit = Math.max(0, limit - files.length)
 		const directories = await listFilteredDirectories(dirPath, false, ignoreInstance, remainingLimit)
@@ -57,8 +63,8 @@ export async function listFiles(dirPath: string, recursive: boolean, limit: numb
 	}
 
 	// For recursive mode, use the original approach but ensure first-level directories are included
-	const files = await listFilesWithRipgrep(rgPath, dirPath, true, limit)
-	const ignoreInstance = await createIgnoreInstance(dirPath)
+	const files = await listFilesWithRipgrep(rgPath, dirPath, true, limit, respectGitIgnore)
+	const ignoreInstance = await createIgnoreInstance(dirPath, respectGitIgnore)
 	// Calculate remaining limit for directories
 	const remainingLimit = Math.max(0, limit - files.length)
 	const directories = await listFilteredDirectories(dirPath, true, ignoreInstance, remainingLimit)
@@ -202,8 +208,9 @@ async function listFilesWithRipgrep(
 	dirPath: string,
 	recursive: boolean,
 	limit: number,
+	respectGitIgnore: boolean = true,
 ): Promise<string[]> {
-	const rgArgs = buildRipgrepArgs(dirPath, recursive)
+	const rgArgs = buildRipgrepArgs(dirPath, recursive, respectGitIgnore)
 
 	const relativePaths = await execRipgrep(rgPath, rgArgs, limit)
 
@@ -216,25 +223,30 @@ async function listFilesWithRipgrep(
 /**
  * Build appropriate ripgrep arguments based on whether we're doing a recursive search
  */
-function buildRipgrepArgs(dirPath: string, recursive: boolean): string[] {
+function buildRipgrepArgs(dirPath: string, recursive: boolean, respectGitIgnore: boolean = true): string[] {
 	// Base arguments to list files
 	const args = ["--files", "--hidden", "--follow"]
 
+	// When not respecting .gitignore, tell ripgrep to skip VCS ignore files
+	if (!respectGitIgnore) {
+		args.push("--no-ignore-vcs")
+	}
+
 	if (recursive) {
-		return [...args, ...buildRecursiveArgs(dirPath), dirPath]
+		return [...args, ...buildRecursiveArgs(dirPath, respectGitIgnore), dirPath]
 	} else {
-		return [...args, ...buildNonRecursiveArgs(), dirPath]
+		return [...args, ...buildNonRecursiveArgs(respectGitIgnore), dirPath]
 	}
 }
 
 /**
  * Build ripgrep arguments for recursive directory traversal
  */
-function buildRecursiveArgs(dirPath: string): string[] {
+function buildRecursiveArgs(dirPath: string, respectGitIgnore: boolean = true): string[] {
 	const args: string[] = []
 
 	// In recursive mode, respect .gitignore by default
-	// (ripgrep does this automatically)
+	// (ripgrep does this automatically when respectGitIgnore is true)
 
 	// Check if we're explicitly targeting a hidden directory
 	// Normalize the path first to handle edge cases
@@ -295,7 +307,7 @@ function buildRecursiveArgs(dirPath: string): string[] {
 /**
  * Build ripgrep arguments for non-recursive directory listing
  */
-function buildNonRecursiveArgs(): string[] {
+function buildNonRecursiveArgs(respectGitIgnore: boolean = true): string[] {
 	const args: string[] = []
 
 	// For non-recursive, limit to the current directory level
@@ -303,7 +315,8 @@ function buildNonRecursiveArgs(): string[] {
 	args.push("--maxdepth", "1") // ripgrep uses maxdepth, not max-depth
 
 	// Respect .gitignore in non-recursive mode too
-	// (ripgrep respects .gitignore by default)
+	// (ripgrep respects .gitignore by default when respectGitIgnore is true;
+	// --no-ignore-vcs is added at a higher level when respectGitIgnore is false)
 
 	// Apply directory exclusions for non-recursive searches
 	for (const dir of DIRS_TO_IGNORE) {
@@ -326,9 +339,23 @@ function buildNonRecursiveArgs(): string[] {
 /**
  * Create an ignore instance that handles .gitignore files properly
  * This replaces the custom gitignore parsing with the proper ignore library
+ *
+ * @param dirPath - Directory path to create ignore instance for
+ * @param respectGitIgnore - Whether to load .gitignore patterns (default: true).
+ *   When false, returns an empty ignore instance so no gitignore filtering is applied.
  */
-async function createIgnoreInstance(dirPath: string): Promise<ReturnType<typeof ignore>> {
+async function createIgnoreInstance(
+	dirPath: string,
+	respectGitIgnore: boolean = true,
+): Promise<ReturnType<typeof ignore>> {
 	const ignoreInstance = ignore()
+
+	// When not respecting .gitignore, return an empty ignore instance
+	// so no gitignore-based filtering is applied to directories
+	if (!respectGitIgnore) {
+		return ignoreInstance
+	}
+
 	const absolutePath = path.resolve(dirPath)
 
 	// Find all .gitignore files from the target directory up to the root

webview-ui/src/components/chat/CodeIndexPopover.tsx

@@ -81,6 +81,7 @@ interface LocalCodeIndexSettings {
 	codebaseIndexVercelAiGatewayApiKey?: string
 	codebaseIndexOpenRouterApiKey?: string
 	codebaseIndexOpenRouterSpecificProvider?: string
+	codebaseIndexRespectGitIgnore?: boolean
 }
 
 // Validation schema for codebase index settings
@@ -225,6 +226,7 @@ export const CodeIndexPopover: React.FC<CodeIndexPopoverProps> = ({
 		codebaseIndexVercelAiGatewayApiKey: "",
 		codebaseIndexOpenRouterApiKey: "",
 		codebaseIndexOpenRouterSpecificProvider: "",
+		codebaseIndexRespectGitIgnore: true,
 	})
 
 	// Initial settings state - stores the settings when popover opens
@@ -265,6 +267,7 @@ export const CodeIndexPopover: React.FC<CodeIndexPopoverProps> = ({
 				codebaseIndexOpenRouterApiKey: "",
 				codebaseIndexOpenRouterSpecificProvider:
 					codebaseIndexConfig.codebaseIndexOpenRouterSpecificProvider || "",
+				codebaseIndexRespectGitIgnore: codebaseIndexConfig.codebaseIndexRespectGitIgnore ?? true,
 			}
 			setInitialSettings(settings)
 			setCurrentSettings(settings)
@@ -1586,6 +1589,24 @@ export const CodeIndexPopover: React.FC<CodeIndexPopoverProps> = ({
 											</VSCodeButton>
 										</div>
 									</div>
+									{/* Respect .gitignore toggle */}
+									<div className="space-y-2">
+										<div className="flex items-center gap-2">
+											<VSCodeCheckbox
+												checked={currentSettings.codebaseIndexRespectGitIgnore ?? true}
+												onChange={(e: any) =>
+													updateSetting("codebaseIndexRespectGitIgnore", e.target.checked)
+												}>
+												<span className="font-medium">
+													{t("settings:codeIndex.respectGitIgnoreLabel")}
+												</span>
+											</VSCodeCheckbox>
+											<StandardTooltip
+												content={t("settings:codeIndex.respectGitIgnoreDescription")}>
+												<span className="codicon codicon-info text-xs text-vscode-descriptionForeground cursor-help" />
+											</StandardTooltip>
+										</div>
+									</div>
 								</div>
 							)}
 						</div>

webview-ui/src/i18n/locales/en/settings.json

@@ -230,6 +230,8 @@
 		"searchMaxResultsLabel": "Maximum Search Results",
 		"searchMaxResultsDescription": "Maximum number of search results to return when querying the codebase index. Higher values provide more context but may include less relevant results.",
 		"resetToDefault": "Reset to default",
+		"respectGitIgnoreLabel": "Respect .gitignore",
+		"respectGitIgnoreDescription": "When enabled, files listed in .gitignore are excluded from indexing and file listings. When disabled, only .rooignore is used for filtering, allowing gitignored files to be indexed and discovered by Roo Code.",
 		"startIndexingButton": "Start Indexing",
 		"clearIndexDataButton": "Clear Index Data",
 		"unsavedSettingsMessage": "Please save your settings before starting the indexing process.",