feat: Add rooignore implementation with ReclineIgnoreController, tests, and integration

Author: PoliTwit1984

src/core/ignore/ReclineIgnoreController.test.ts

@@ -0,0 +1,59 @@
+import * as fs from "fs/promises"
+import { ReclineIgnoreController } from "./ReclineIgnoreController"
+import { fileExistsAtPath } from "../../utils/fs"
+
+jest.mock("../../utils/fs")
+jest.mock("fs/promises")
+
+const mockedFileExistsAtPath = fileExistsAtPath as jest.Mock
+const mockedReadFile = fs.readFile as jest.Mock
+
+describe("ReclineIgnoreController", () => {
+	const cwd = "/workspace"
+
+	beforeEach(() => {
+		jest.resetAllMocks()
+	})
+
+	test("should load .rooignore and filter files appropriately", async () => {
+		// Simulate that .rooignore exists and contains test patterns.
+		mockedFileExistsAtPath.mockResolvedValue(true)
+		const ignoreContent = "test-ignored.txt\n*.ignored\n"
+		mockedReadFile.mockResolvedValue(ignoreContent)
+
+		const controller = new ReclineIgnoreController(cwd)
+		await controller.initialize()
+
+		// Files matching the ignore patterns should be blocked.
+		expect(controller.validateAccess("test-ignored.txt")).toBe(false)
+		expect(controller.validateAccess("foo.ignored")).toBe(false)
+
+		// Files not matching ignore patterns should be allowed.
+		expect(controller.validateAccess("not-ignored.txt")).toBe(true)
+	})
+
+	test("should filter paths correctly", async () => {
+		mockedFileExistsAtPath.mockResolvedValue(true)
+		const ignoreContent = "ignored.txt\n"
+		mockedReadFile.mockResolvedValue(ignoreContent)
+
+		const controller = new ReclineIgnoreController(cwd)
+		await controller.initialize()
+
+		const files = ["ignored.txt", "keep.txt", "another.txt"]
+		const filtered = controller.filterPaths(files)
+		expect(filtered).toEqual(["keep.txt", "another.txt"])
+	})
+
+	test("should allow file access if .rooignore does not exist", async () => {
+		// Simulate that .rooignore does not exist.
+		mockedFileExistsAtPath.mockResolvedValue(false)
+
+		const controller = new ReclineIgnoreController(cwd)
+		await controller.initialize()
+
+		// Without any ignore rules, all files should be allowed.
+		expect(controller.validateAccess("test-ignored.txt")).toBe(true)
+		expect(controller.validateAccess("anyfile.ignored")).toBe(true)
+	})
+})

src/core/ignore/ReclineIgnoreController.ts

@@ -0,0 +1,69 @@
+import * as vscode from "vscode"
+import * as path from "path"
+import * as fs from "fs/promises"
+import ignore, { Ignore } from "ignore"
+import { fileExistsAtPath } from "../../utils/fs"
+
+export class ReclineIgnoreController {
+	private ignoreInstance: Ignore
+	private disposables: vscode.Disposable[] = []
+	private cwd: string
+
+	constructor(cwd: string) {
+		this.cwd = cwd
+		this.ignoreInstance = ignore()
+		this.setupFileWatcher()
+	}
+
+	public async initialize(): Promise<void> {
+		await this.loadIgnoreFile()
+	}
+
+	private setupFileWatcher(): void {
+		const ignorePattern = new vscode.RelativePattern(this.cwd, ".rooignore")
+		const watcher = vscode.workspace.createFileSystemWatcher(ignorePattern)
+		this.disposables.push(
+			watcher.onDidChange(() => this.loadIgnoreFile()),
+			watcher.onDidCreate(() => this.loadIgnoreFile()),
+			watcher.onDidDelete(() => this.loadIgnoreFile()),
+			watcher,
+		)
+	}
+
+	private async loadIgnoreFile(): Promise<void> {
+		// Reset the ignore instance
+		this.ignoreInstance = ignore()
+		const ignorePath = path.join(this.cwd, ".rooignore")
+		if (await fileExistsAtPath(ignorePath)) {
+			try {
+				const content = await fs.readFile(ignorePath, "utf8")
+				this.ignoreInstance.add(content)
+				// Always ignore the .clineignore file itself.
+				this.ignoreInstance.add(".rooignore")
+			} catch (error) {
+				console.error("Error loading .rooignore:", error)
+				vscode.window.showWarningMessage("Error loading .rooignore file.")
+			}
+		}
+	}
+
+	public validateAccess(filePath: string): boolean {
+		try {
+			const absolutePath = path.resolve(this.cwd, filePath)
+			const relativePath = path.relative(this.cwd, absolutePath).split(path.sep).join(path.posix.sep)
+			return !this.ignoreInstance.ignores(relativePath)
+		} catch (error) {
+			// On error, allow access to avoid accidentally blocking files.
+			return true
+		}
+	}
+
+	public filterPaths(paths: string[]): string[] {
+		return paths.filter((file) => this.validateAccess(file))
+	}
+
+	public dispose(): void {
+		this.disposables.forEach((d) => d.dispose())
+		this.disposables = []
+	}
+}

src/extension.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode"
 
 import { ClineProvider } from "./core/webview/ClineProvider"
+import { ReclineIgnoreController } from "./core/ignore/ReclineIgnoreController"
 import { createClineAPI } from "./exports"
 import "./utils/path" // Necessary to have access to String.prototype.toPosix.
 import { CodeActionProvider } from "./core/CodeActionProvider"
@@ -18,14 +19,20 @@ import { McpServerManager } from "./services/mcp/McpServerManager"
 
 let outputChannel: vscode.OutputChannel
 let extensionContext: vscode.ExtensionContext
+let ignoreController: ReclineIgnoreController | undefined
+
+// Export the ignore controller instance
+export function getIgnoreController(): ReclineIgnoreController | undefined {
+	return ignoreController
+}
 
 // This method is called when your extension is activated.
 // Your extension is activated the very first time the command is executed.
 export function activate(context: vscode.ExtensionContext) {
 	extensionContext = context
 	outputChannel = vscode.window.createOutputChannel("Roo-Code")
 	context.subscriptions.push(outputChannel)
-	outputChannel.appendLine("Roo-Code extension activated")
+	outputChannel.appendLine("Roo-Code extension activated with .rooignore functionality")
 
 	// Get default commands from configuration.
 	const defaultCommands = vscode.workspace.getConfiguration("roo-cline").get<string[]>("allowedCommands") || []
@@ -35,6 +42,20 @@ export function activate(context: vscode.ExtensionContext) {
 		context.globalState.update("allowedCommands", defaultCommands)
 	}
 
+	// Initialize the ignore controller
+	const cwd = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+	if (cwd) {
+		ignoreController = new ReclineIgnoreController(cwd)
+		ignoreController
+			.initialize()
+			.then(() => {
+				console.log("Loaded .rooignore file")
+			})
+			.catch((error) => {
+				console.error("Failed to load .rooignore file:", error)
+			})
+		context.subscriptions.push(ignoreController)
+	}
 	const sidebarProvider = new ClineProvider(context, outputChannel)
 
 	context.subscriptions.push(

src/integrations/misc/extract-text.ts

@@ -4,13 +4,28 @@ import pdf from "pdf-parse/lib/pdf-parse"
 import mammoth from "mammoth"
 import fs from "fs/promises"
 import { isBinaryFile } from "isbinaryfile"
+import * as vscode from "vscode"
+import { getIgnoreController } from "../../extension"
 
 export async function extractTextFromFile(filePath: string): Promise<string> {
 	try {
 		await fs.access(filePath)
 	} catch (error) {
 		throw new Error(`File not found: ${filePath}`)
 	}
+
+	// Check if file is ignored by .rooignore
+	const ignoreController = getIgnoreController()
+	if (ignoreController) {
+		const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+		if (workspaceRoot) {
+			const relativePath = path.relative(workspaceRoot, filePath)
+			if (!ignoreController.validateAccess(relativePath)) {
+				throw new Error(`File access blocked by .rooignore: ${filePath}`)
+			}
+		}
+	}
+
 	const fileExtension = path.extname(filePath).toLowerCase()
 	switch (fileExtension) {
 		case ".pdf":

src/integrations/misc/open-file.ts

@@ -2,6 +2,7 @@ import * as path from "path"
 import * as os from "os"
 import * as vscode from "vscode"
 import { arePathsEqual } from "../../utils/path"
+import { getIgnoreController } from "../../extension"
 
 export async function openImage(dataUri: string) {
 	const matches = dataUri.match(/^data:image\/([a-zA-Z]+);base64,(.+)$/)
@@ -38,6 +39,15 @@ export async function openFile(filePath: string, options: OpenFileOptions = {})
 
 		const uri = vscode.Uri.file(fullPath)
 
+		// Check if file is ignored
+		const ignoreController = getIgnoreController()
+		if (ignoreController) {
+			const relativePath = path.relative(workspaceRoot, fullPath)
+			if (!ignoreController.validateAccess(relativePath)) {
+				throw new Error("File access blocked by .rooignore")
+			}
+		}
+
 		// Check if file exists
 		try {
 			await vscode.workspace.fs.stat(uri)