feat: add Zoo Code: Show Ripgrep Diagnostic command

Adds a user-triggerable diagnostic for the "Could not find ripgrep
binary" error class. The command runs the same hybrid resolution
that #248 tested — try require("@vscode/ripgrep"), then probe
known appRoot-relative paths — and writes a verbose report to a
dedicated output channel, also copying it to the clipboard.

Motivated by #248: debugging that bug required a custom test build
to inspect resolution state on the user's machine. With this
command shipped, future users hitting weird ripgrep-resolution
behavior can paste the diagnostic into a bug report without us
needing to build instrumented VSIXs.

Reintroduces the @vscode/ripgrep devDep and esbuild external entry
that #248 dropped — the diagnostic needs to call require() to
report what happens. The require attempt also serves as forward-
compat: when VS Code completes the @vscode/ripgrep → @vscode/
ripgrep-universal package-rename migration, it will start
succeeding broadly, and the diagnostic output will be the signal
that we can revisit the require approach in getBinPath itself.

- src/services/ripgrep/diagnostic.ts: new module (data fn + cmd wrapper)
- src/services/ripgrep/internal/loadRipgrep.ts: testable require wrapper
- zoo-code.showRipgrepDiagnostic command wired up in registerCommands.ts
  and contributed via package.json
- Tests for the data function

Author: dennis-shorevapes

pnpm-lock.yaml

@@ -13,6 +13,7 @@ import { handleNewTask } from "./handleTask"
 import { CodeIndexManager } from "../services/code-index/manager"
 import { importSettingsWithFeedback } from "../core/config/importExport"
 import { MdmService } from "../services/mdm/MdmService"
+import { registerRipgrepDiagnosticCommand } from "../services/ripgrep/diagnostic"
 import { t } from "../i18n"
 
 /**
@@ -68,6 +69,8 @@ export const registerCommands = (options: RegisterCommandOptions) => {
 		const command = getCommand(id as CommandId)
 		context.subscriptions.push(vscode.commands.registerCommand(command, callback))
 	}
+
+	context.subscriptions.push(registerRipgrepDiagnosticCommand())
 }
 
 const getCommandsMap = ({ context, outputChannel, provider }: RegisterCommandOptions): Record<CommandId, any> => ({

src/activate/registerCommands.ts

@@ -126,7 +126,7 @@ async function main() {
 		// global-agent must be external because it dynamically patches Node.js http/https modules
 		// which breaks when bundled. It needs access to the actual Node.js module instances.
 		// undici must be bundled because our VSIX is packaged with `--no-dependencies`.
-		external: ["vscode", "esbuild", "global-agent"],
+		external: ["vscode", "esbuild", "global-agent", "@vscode/ripgrep"],
 	}
 
 	/**

src/esbuild.mjs

@@ -160,6 +160,11 @@
 				"title": "%command.acceptInput.title%",
 				"category": "%configuration.title%"
 			},
+			{
+				"command": "zoo-code.showRipgrepDiagnostic",
+				"title": "Show Ripgrep Diagnostic",
+				"category": "%configuration.title%"
+			},
 			{
 				"command": "zoo-code.toggleAutoApprove",
 				"title": "%command.toggleAutoApprove.title%",
@@ -554,6 +559,7 @@
 		"@types/tmp": "^0.2.6",
 		"@types/turndown": "^5.0.5",
 		"@types/vscode": "^1.84.0",
+		"@vscode/ripgrep": "^1.17.0",
 		"@vscode/test-electron": "^2.5.2",
 		"@vscode/vsce": "3.3.2",
 		"ai": "^6.0.75",

src/package.json

@@ -0,0 +1,108 @@
+// npx vitest run src/services/ripgrep/__tests__/diagnostic.spec.ts
+
+import * as path from "path"
+
+import { vi, describe, it, expect, beforeEach } from "vitest"
+
+import { getRipgrepDiagnostic } from "../diagnostic"
+
+const ripgrepMock = vi.hoisted(() => ({
+	value: undefined as { rgPath?: string } | undefined,
+}))
+
+const fsMock = vi.hoisted(() => ({
+	existing: new Set<string>(),
+}))
+
+vi.mock("../internal/loadRipgrep", () => ({
+	loadRipgrep: () => ripgrepMock.value,
+}))
+
+vi.mock("../../../utils/fs", () => ({
+	fileExistsAtPath: (p: string) => Promise.resolve(fsMock.existing.has(p)),
+}))
+
+const APP_ROOT = "/app"
+
+const binName = process.platform.startsWith("win") ? "rg.exe" : "rg"
+const universalRelBin = `bin/${process.platform}-${process.arch}/${binName}`
+
+const expectedCandidates = [
+	path.join(APP_ROOT, "node_modules", "@vscode", "ripgrep", "bin", binName),
+	path.join(APP_ROOT, "node_modules", "vscode-ripgrep", "bin", binName),
+	path.join(APP_ROOT, "node_modules.asar.unpacked", "vscode-ripgrep", "bin", binName),
+	path.join(APP_ROOT, "node_modules.asar.unpacked", "@vscode", "ripgrep", "bin", binName),
+	path.join(APP_ROOT, "node_modules", "@vscode", "ripgrep-universal", ...universalRelBin.split("/")),
+	path.join(APP_ROOT, "node_modules.asar.unpacked", "@vscode", "ripgrep-universal", ...universalRelBin.split("/")),
+]
+
+describe("getRipgrepDiagnostic", () => {
+	beforeEach(() => {
+		ripgrepMock.value = undefined
+		fsMock.existing = new Set<string>()
+	})
+
+	it("includes rgPath and fileExistsAtPath: true when loadRipgrep returns an existing path", async () => {
+		const rgPath = "/some/path"
+		ripgrepMock.value = { rgPath }
+		fsMock.existing = new Set([rgPath])
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		expect(report).toContain("rgPath: /some/path")
+		expect(report).toContain("fileExistsAtPath: true")
+		expect(report).toContain("after .asar→.asar.unpacked: /some/path")
+	})
+
+	it("rewrites node_modules.asar to node_modules.asar.unpacked in the report", async () => {
+		const rgPath = "/app/node_modules.asar/foo/rg"
+		const substituted = "/app/node_modules.asar.unpacked/foo/rg"
+		ripgrepMock.value = { rgPath }
+		fsMock.existing = new Set([substituted])
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		expect(report).toContain(`after .asar→.asar.unpacked: ${substituted}`)
+		expect(report).toContain("fileExistsAtPath: true")
+	})
+
+	it("reports require failure when loadRipgrep returns undefined", async () => {
+		ripgrepMock.value = undefined
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		expect(report).toContain("loadRipgrep() returned undefined (require threw)")
+	})
+
+	it("reports rgPath: (undefined) when loadRipgrep returns an object without rgPath", async () => {
+		ripgrepMock.value = {}
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		expect(report).toContain("rgPath: (undefined)")
+		expect(report).not.toContain("after .asar→.asar.unpacked:")
+	})
+
+	it("marks only the first probe candidate as found when only it exists", async () => {
+		fsMock.existing = new Set([expectedCandidates[0]])
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		const found = expectedCandidates.filter((c) => report.includes(`✓ ${c}`))
+		const missing = expectedCandidates.filter((c) => report.includes(`✗ ${c}`))
+
+		expect(found).toEqual([expectedCandidates[0]])
+		expect(missing).toEqual(expectedCandidates.slice(1))
+	})
+
+	it("marks all probe candidates as missing when none exist", async () => {
+		fsMock.existing = new Set<string>()
+
+		const report = await getRipgrepDiagnostic(APP_ROOT)
+
+		for (const candidate of expectedCandidates) {
+			expect(report).toContain(`✗ ${candidate}`)
+		}
+		expect(report).not.toContain("✓ ")
+	})
+})

src/services/ripgrep/__tests__/diagnostic.spec.ts

@@ -0,0 +1,82 @@
+import * as path from "path"
+import * as vscode from "vscode"
+
+import { fileExistsAtPath } from "../../utils/fs"
+import { loadRipgrep } from "./internal/loadRipgrep"
+
+const binName = process.platform.startsWith("win") ? "rg.exe" : "rg"
+const universalBin = `bin/${process.platform}-${process.arch}/${binName}`
+
+function probeCandidates(vscodeAppRoot: string): readonly string[] {
+	return [
+		path.join(vscodeAppRoot, "node_modules", "@vscode", "ripgrep", "bin", binName),
+		path.join(vscodeAppRoot, "node_modules", "vscode-ripgrep", "bin", binName),
+		path.join(vscodeAppRoot, "node_modules.asar.unpacked", "vscode-ripgrep", "bin", binName),
+		path.join(vscodeAppRoot, "node_modules.asar.unpacked", "@vscode", "ripgrep", "bin", binName),
+		path.join(vscodeAppRoot, "node_modules", "@vscode", "ripgrep-universal", ...universalBin.split("/")),
+		path.join(
+			vscodeAppRoot,
+			"node_modules.asar.unpacked",
+			"@vscode",
+			"ripgrep-universal",
+			...universalBin.split("/"),
+		),
+	]
+}
+
+/**
+ * Produces a textual diagnostic report of how ripgrep would be resolved
+ * for the given VS Code installation. Pure data function — no UI side
+ * effects — so it's fully unit-testable.
+ *
+ * Step 1 tries `loadRipgrep()` (CommonJS require, hits VS Code's
+ * extHost interceptor on builds that have completed the
+ * `@vscode/ripgrep` → `@vscode/ripgrep-universal` migration).
+ * Step 2 probes every known `vscode.env.appRoot`-relative path and
+ * reports which ones exist on disk.
+ */
+export async function getRipgrepDiagnostic(vscodeAppRoot: string): Promise<string> {
+	const lines: string[] = [
+		`Zoo Code Ripgrep Diagnostic (${new Date().toISOString()})`,
+		`vscode.version: ${vscode.version}`,
+		`vscode.env.appRoot: ${vscodeAppRoot}`,
+		`process.platform/arch: ${process.platform}/${process.arch}`,
+		``,
+		`--- step 1: require("@vscode/ripgrep") via loadRipgrep ---`,
+	]
+	const m = loadRipgrep()
+	if (!m) {
+		lines.push(`loadRipgrep() returned undefined (require threw)`)
+	} else {
+		const keys = Object.keys(m).join(",") || "(none)"
+		lines.push(`loadRipgrep() returned object. keys: ${keys}`)
+		lines.push(`rgPath: ${m.rgPath ?? "(undefined)"}`)
+		if (m.rgPath) {
+			const fixed = m.rgPath.replace(/\bnode_modules\.asar\b/, "node_modules.asar.unpacked")
+			lines.push(`after .asar→.asar.unpacked: ${fixed}`)
+			lines.push(`fileExistsAtPath: ${await fileExistsAtPath(fixed)}`)
+		}
+	}
+	lines.push(``)
+	lines.push(`--- step 2: path probe under appRoot ---`)
+	for (const candidate of probeCandidates(vscodeAppRoot)) {
+		lines.push(`  ${(await fileExistsAtPath(candidate)) ? "✓" : "✗"} ${candidate}`)
+	}
+	return lines.join("\n")
+}
+
+/**
+ * Registers the `zoo-code.showRipgrepDiagnostic` command. Thin wrapper —
+ * runs `getRipgrepDiagnostic`, shows the result in an output channel,
+ * copies it to the clipboard, and shows an info toast.
+ */
+export function registerRipgrepDiagnosticCommand(): vscode.Disposable {
+	return vscode.commands.registerCommand("zoo-code.showRipgrepDiagnostic", async () => {
+		const report = await getRipgrepDiagnostic(vscode.env.appRoot)
+		const channel = vscode.window.createOutputChannel("Zoo Code Ripgrep Diagnostic")
+		channel.appendLine(report)
+		channel.show(true)
+		await vscode.env.clipboard.writeText(report)
+		await vscode.window.showInformationMessage("Zoo Code: ripgrep diagnostic copied to clipboard.")
+	})
+}

src/services/ripgrep/diagnostic.ts

@@ -0,0 +1,16 @@
+/**
+ * Loads `@vscode/ripgrep` via CommonJS `require()`. Lives in its own
+ * module so unit tests can `vi.mock` the wrapper — vitest's mock registry
+ * hooks the import graph, not Node's native CJS resolver, and
+ * `@vscode/ripgrep` resolves through the latter at test time because it's
+ * a real devDep installed in `node_modules`.
+ *
+ * Returns `undefined` if the package can't be loaded for any reason.
+ */
+export function loadRipgrep(): { rgPath?: string } | undefined {
+	try {
+		return require("@vscode/ripgrep") as { rgPath?: string }
+	} catch {
+		return undefined
+	}
+}