feat(glob): bring back ripgrep as fallback

Author: X9VoiD

src/services/glob/__tests__/list-files.integration.spec.ts renamed to src/services/glob/__tests__/list-files.integration.test.ts

@@ -0,0 +1,129 @@
+import { vi, describe, it, expect, beforeEach } from "vitest"
+import * as path from "path"
+
+// Mock ripgrep to avoid filesystem dependencies
+vi.mock("../../ripgrep", () => ({
+	getBinPath: vi.fn().mockResolvedValue("/mock/path/to/rg"),
+}))
+
+// Mock vscode
+vi.mock("vscode", () => ({
+	env: {
+		appRoot: "/mock/app/root",
+	},
+}))
+
+// Mock filesystem operations
+vi.mock("fs", () => ({
+	promises: {
+		access: vi.fn().mockRejectedValue(new Error("Not found")),
+		readFile: vi.fn().mockResolvedValue(""),
+		readdir: vi.fn().mockResolvedValue([]),
+	},
+	existsSync: vi.fn().mockImplementation((path) => {
+		return Promise.resolve(true)
+	}),
+	readFileSync: vi.fn().mockImplementation((path) => {
+		return Promise.resolve("mock content")
+	}),
+}))
+
+vi.mock("child_process", () => ({
+	spawn: vi.fn(),
+}))
+
+vi.mock("../../path", () => ({
+	arePathsEqual: vi.fn().mockReturnValue(false),
+}))
+
+import { listFiles } from "../list-files"
+import * as childProcess from "child_process"
+
+describe("list-files symlink support", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("should include --follow flag in ripgrep arguments", async () => {
+		const mockSpawn = vi.mocked(childProcess.spawn)
+		const mockProcess = {
+			stdout: {
+				on: vi.fn((event, callback) => {
+					if (event === "data") {
+						// Simulate some output to complete the process
+						setTimeout(() => callback("test-file.txt\n"), 10)
+					}
+				}),
+			},
+			stderr: {
+				on: vi.fn(),
+			},
+			on: vi.fn((event, callback) => {
+				if (event === "close") {
+					setTimeout(() => callback(0), 20)
+				}
+				if (event === "error") {
+					// No error simulation
+				}
+			}),
+			kill: vi.fn(),
+		}
+
+		mockSpawn.mockReturnValue(mockProcess as any)
+
+		// Call listFiles to trigger ripgrep execution
+		await listFiles("/test/dir", false, 100)
+
+		// Verify that spawn was called with --follow flag (the critical fix)
+		const [rgPath, args] = mockSpawn.mock.calls[0]
+		expect(rgPath).toBe("/mock/path/to/rg")
+		expect(args).toContain("--files")
+		expect(args).toContain("--hidden")
+		expect(args).toContain("--follow") // This is the critical assertion - the fix should add this flag
+
+		// Platform-agnostic path check - verify the last argument is the resolved path
+		const expectedPath = path.resolve("/test/dir")
+		expect(args[args.length - 1]).toBe(expectedPath)
+	})
+
+	it("should include --follow flag for recursive listings too", async () => {
+		const mockSpawn = vi.mocked(childProcess.spawn)
+		const mockProcess = {
+			stdout: {
+				on: vi.fn((event, callback) => {
+					if (event === "data") {
+						setTimeout(() => callback("test-file.txt\n"), 10)
+					}
+				}),
+			},
+			stderr: {
+				on: vi.fn(),
+			},
+			on: vi.fn((event, callback) => {
+				if (event === "close") {
+					setTimeout(() => callback(0), 20)
+				}
+				if (event === "error") {
+					// No error simulation
+				}
+			}),
+			kill: vi.fn(),
+		}
+
+		mockSpawn.mockReturnValue(mockProcess as any)
+
+		// Call listFiles with recursive=true
+		await listFiles("/test/dir", true, 100)
+
+		// Verify that spawn was called with --follow flag (the critical fix)
+		const [rgPath, args] = mockSpawn.mock.calls[0]
+		expect(rgPath).toBe("/mock/path/to/rg")
+		expect(args).toContain("--files")
+		expect(args).toContain("--hidden")
+		expect(args).toContain("--follow") // This should be present in recursive mode too
+
+		// Platform-agnostic path check - verify the last argument is the resolved path
+		const expectedPath = path.resolve("/test/dir")
+		expect(args[args.length - 1]).toBe(expectedPath)
+	})
+})

src/services/glob/__tests__/ripgrep-utils.test.ts

@@ -6,6 +6,7 @@ import { globSync } from "glob"
 import ignore from "ignore"
 import { arePathsEqual, getWorkspacePath } from "../../utils/path"
 import { isPathInIgnoredDirectory } from "./ignore-utils"
+import { listFilesWithRipgrep } from "./ripgrep-utils"
 
 function normalizePath(p: string): string {
 	return p.replace(/\\/g, "/")
@@ -106,63 +107,60 @@ async function listAllFilesRecursively(
 	} catch (error) {
 		// Fallback to the manual method if git ls-files fails
 		// (e.g., not a git repo, or an error with the command).
-		console.warn("`git ls-files` failed, falling back to manual file search:", error)
-		return listAllFilesRecursivelyWithFs(dir, git, workspacePath, limit)
+		console.warn("`git ls-files` failed, falling back to ripgrep:", error)
+		return listAllFilesRecursivelyWithRipGrep(dir, git, workspacePath, limit)
 	}
 }
 
 /**
- * A fallback recursive file lister that manually walks the filesystem.
- * This is slower but works if Git is not available or fails.
+ * A fallback recursive file lister that uses ripgrep for performance.
+ * This is used if Git is not available or fails.
  */
-async function listAllFilesRecursivelyWithFs(
+async function listAllFilesRecursivelyWithRipGrep(
 	dir: string,
 	_git: SimpleGit,
 	workspacePath: string,
 	limit: number,
 ): Promise<string[]> {
-	const result: string[] = []
-	const queue: string[] = [dir]
-
-	// Create ignore instance using all .gitignore files in the workspace
 	const ig = createGitignoreFilter(workspacePath)
 
-	while (queue.length > 0 && result.length < limit) {
-		const currentDir = queue.shift()!
-
-		// Pre-check if the directory itself is ignored by custom ignore logic
-		if (isPathInIgnoredDirectory(path.relative(workspacePath, currentDir))) {
-			continue
-		}
-
-		let entries: fs.Dirent[]
-		try {
-			entries = await fs.promises.readdir(currentDir, { withFileTypes: true })
-		} catch (err) {
-			continue // Skip unreadable directories
-		}
+	let files: string[] = []
+	let usedRipgrep = false
+	try {
+		files = await listFilesWithRipgrep(dir, true, limit)
+		usedRipgrep = true
+	} catch (err) {
+		console.warn("listFilesWithRipgrep failed:", err)
+	}
 
-		for (const entry of entries) {
-			const fullPath = path.join(currentDir, entry.name)
-			const relPath = path.relative(workspacePath, fullPath).replace(/\\/g, "/")
-			if (ig.ignores(relPath)) {
-				if (entry.isDirectory()) {
-					// Still need to recurse into subdirectories to find non-ignored children
-					continue
-				}
+	// If ripgrep failed or returned no files, fallback to manual method
+	if (!files || files.length === 0) {
+		const queue: string[] = [dir]
+		while (queue.length > 0) {
+			const currentDir = queue.shift()!
+			if (isPathInIgnoredDirectory(path.relative(workspacePath, currentDir))) {
 				continue
 			}
-			if (entry.isDirectory()) {
-				queue.push(fullPath)
-			} else {
-				result.push(fullPath)
-				if (result.length >= limit) {
-					break
+			let entries: fs.Dirent[]
+			try {
+				entries = await fs.promises.readdir(currentDir, { withFileTypes: true })
+			} catch (err) {
+				continue
+			}
+			for (const entry of entries) {
+				const fullPath = path.join(currentDir, entry.name)
+				if (entry.isDirectory()) {
+					queue.push(fullPath)
+				} else {
+					files.push(fullPath)
 				}
 			}
 		}
 	}
-	return result
+
+	// Map to relative paths, filter, then map back to absolute
+	const filtered = ig.filter(files.map((f) => path.relative(workspacePath, path.resolve(f)).replace(/\\/g, "/")))
+	return filtered.slice(0, limit).map((rel) => path.join(workspacePath, rel))
 }
 
 /**
@@ -218,18 +216,47 @@ function createGitignoreFilter(rootDir: string) {
 
 /**
  * List only top-level files and directories, filtering out ignored ones.
+ * Uses ripgrep for performance and consistency with recursive listing.
  */
 async function listNonRecursive(dir: string, _git: SimpleGit, workspacePath: string): Promise<string[]> {
-	const entries = await fs.promises.readdir(dir, { withFileTypes: true })
 	const ig = createGitignoreFilter(workspacePath)
 
-	const result: string[] = []
-	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name)
-		const relPath = path.relative(workspacePath, fullPath).replace(/\\/g, "/")
-		if (!ig.ignores(relPath) && !isPathInIgnoredDirectory(relPath)) {
-			result.push(fullPath)
-		}
+	let files: string[] = []
+	try {
+		files = await listFilesWithRipgrep(dir, false, 10000)
+	} catch (err) {
+		console.warn("listFilesWithRipgrep (non-recursive) failed:", err)
+	}
+
+	// If ripgrep failed or returned no files, fallback to manual method
+	if (!files || files.length === 0) {
+		const entries = await fs.promises.readdir(dir, { withFileTypes: true })
+		return entries
+			.map((entry) => path.join(dir, entry.name))
+			.filter((fullPath) => {
+				const relPath = path.relative(workspacePath, fullPath).replace(/\\/g, "/")
+				return !ig.ignores(relPath) && !isPathInIgnoredDirectory(relPath)
+			})
 	}
-	return result
+
+	const filtered = ig.filter(files.map((f) => path.relative(workspacePath, path.resolve(f)).replace(/\\/g, "/")))
+
+	// Ripgrep --files only lists files, not directories. Add top-level directories manually.
+	let dirEntries: string[] = []
+	try {
+		const entries = await fs.promises.readdir(dir, { withFileTypes: true })
+		dirEntries = entries
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => path.join(dir, entry.name))
+			.filter((fullPath) => {
+				const relPath = path.relative(workspacePath, fullPath).replace(/\\/g, "/")
+				return !ig.ignores(relPath) && !isPathInIgnoredDirectory(relPath)
+			})
+	} catch (err) {
+		// ignore
+	}
+
+	// Enforce limit after combining files and directories
+	const combined = [...filtered.map((rel) => path.join(workspacePath, rel)), ...dirEntries]
+	return combined.slice(0, 10000) // 10000 is the same as above, will be sliced by caller
 }