Code Indexing Support for WSO2 Integrator Copilot by yasithrashan · Pull Request #2263 · wso2/vscode-extensions

yasithrashan · 2026-05-19T06:41:53Z

Purpose

$title

Resolves: https://github.com/wso2-enterprise/integration-engineering/issues/893

key Changes

Introduced CodeMap, a Markdown-based file that provides a high-level summary of artifacts in a Ballerina codebase
Added grep and glob tools for code exploration
Added context retrieval evaluation to the AI test pipeline

Summary by CodeRabbit

New Features
- Code Map endpoints with optional Code Map markdown injected into AI agents.
- New grep and glob search tools for AI-assisted code exploration.
- Text-editor read API now uses line-based ranges (startLine/endLine).
- AI panel displays dependency-pull progress banner.
- Added multiple example/test projects and generated sample services.
AI / Evaluation
- Prompts accept precomputed code-map summaries.
- New context-retrieval LLM evaluation and reporting.
Tests
- Many new unit and integration test suites for tools and evals.

yasithrashan · 2026-05-24T19:04:44Z

@coderabbitai can you review grep.ts file

coderabbitai

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/grep.ts`:
- Around line 212-214: The args.push call in grep.ts currently contains a stray
'--glob' token (args.push('--glob', '!.git/**', '--glob', '--glob',
'!target/**')) which causes the second '--glob' to be used as a glob value and
pushes '!target/**' into ripgrep’s positional PATTERN; remove the extra '--glob'
so each '--glob' is followed by its pattern (i.e., ensure the call passes
'--glob', '!.git/**', '--glob', '!target/**'), then run the grep-related tests
or a quick ripgrep invocation to confirm the target exclusion works as expected.
- Around line 29-39: The grep tool currently treats ripgrep launch failures as
“No matches found”; update the code that calls spawnSync(getRgExecutable(), ...)
to explicitly check for process launch errors (proc.error !== undefined) and
null/undefined proc.status and treat them as failures: when proc.error is set or
proc.status is null/undefined return success: false with an error message
including proc.error or a descriptive message, otherwise keep the existing
checks for status === 1 or empty stdout; reference the spawnSync call and
variables named proc, proc.status and proc.error and the getRgExecutable helper
to locate where to add these additional error branches.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

Push a commit to this branch (recommended)
Create a new PR with the fixes

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: 37af476d-279c-4879-b8df-1f24d4a0fcbb

📥 Commits

Reviewing files that changed from the base of the PR and between d33596d and e07777c.

📒 Files selected for processing (3)

workspaces/ballerina/ballerina-extension/package.json
workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/glob.ts
workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/grep.ts

coderabbitai · 2026-05-24T19:06:17Z

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
cat workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/grep.ts

Length of output: 13941

@yasithrashan Here's a detailed review of grep.ts:

Review of `grep.ts`

The implementation is solid overall — ripgrep integration is clean, output modes are well-designed, and the symlink/path-traversal protection is actually better than in glob.ts. A few issues to address:

🐛 Critical Bug: Malformed glob exclusion args

// Line ~228 — there's an extra dangling `'--glob'` token:
args.push('--glob', '!.git/**', '--glob', '--glob', '!target/**');
//                              ^^^^^^^^^^^^^^^^^^^^
//                              This passes `--glob` as the VALUE of the preceding --glob flag,
//                              meaning ripgrep tries to include files named literally "--glob"

As a result, ripgrep receives:

--glob !.git/** ✅
--glob --glob ❌ (matches files literally named --glob)
!target/** is then treated as a standalone pattern/argument

Fix:

args.push('--glob', '!.git/**', '--glob', '!target/**');

⚠️ `spawnSync` blocks the VS Code event loop

const proc = spawnSync(getRgExecutable(), args, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });

spawnSync is fully synchronous. On a large workspace, this can freeze the extension host thread. Since createGrepExecute returns an async function, consider using execFilePromise or a promisified spawn:

import { execFile } from 'child_process';
import { promisify } from 'util';
const execFileAsync = promisify(execFile);

// Then in the execute function:
const { stdout, stderr } = await execFileAsync(
    getRgExecutable(), args,
    { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
).catch(err => {
    if (err.code === 1) return { stdout: err.stdout ?? '', stderr: '' }; // no matches
    throw err; // code 2 = rg error
});

⚠️ No regex pre-validation

An invalid regex (e.g., pattern: "[") causes ripgrep to exit with code 2, surfacing a raw rg error string. A pre-check gives a cleaner, user-facing message:

try {
    new RegExp(pattern);
} catch (e) {
    const result: GrepResult = { success: false, message: `Invalid regex pattern: ${(e as Error).message}`, error: 'Error: Invalid regex' };
    eventHandler({ type: "tool_result", toolName: GREP_TOOL_NAME, toolOutput: result });
    return result;
}

🔧 Truncation log count is off-by-one

if (truncated) {
    lines = lines.slice(0, effectiveLimit);
    lines.push(`... (results truncated at ${effectiveLimit} lines; ...)`);
}
// ...
console.log(`[GrepTool] ripgrep returned ${lines.length} lines.`);
// ↑ lines.length is now effectiveLimit + 1 (includes the truncation note)

Consider logging before the push, or logging the pre-truncation count separately:

const originalCount = lines.length;
if (truncated) {
    lines = lines.slice(0, effectiveLimit);
    lines.push(`... (results truncated at ${effectiveLimit} of ${originalCount} lines; ...)`);
}
console.log(`[GrepTool] ripgrep returned ${originalCount} lines (shown: ${Math.min(originalCount, effectiveLimit || originalCount)}).`);

🔧 Minor: `node_modules` not excluded

While Ballerina projects don't typically have node_modules, the extension itself runs in a Node.js environment and workspace paths can contain mixed projects. Consider adding it alongside .git and target:

args.push('--glob', '!.git/**', '--glob', '!target/**', '--glob', '!node_modules/**');

✅ What's working well

Path traversal guard: Using path.relative() instead of string prefix matching is much cleaner than glob.ts's approach and correctly handles symlinked tempProjectPath roots — no false-positive risk.
Two-stage symlink detection: path.relative() fast check + realpathSync re-validation is solid defence-in-depth.
Consistent event emission: Every exit path (validation failures, no matches, errors, success) emits tool_result — no leaking branches.
Sensible defaults: DEFAULT_HEAD_LIMIT = 200 and MAX_CONTEXT_LINES = 10 are pragmatic choices.
Ripgrep exit code handling: Correctly distinguishes code 0 (matches), 1 (no matches), 2 (error).
getRgExecutable() fallback: Falling back to system rg in test environments is a nice touch.
Path relativization: Stripping from tempProjectPath (not resolvedPath) so scoped searches still return full relative paths like order_service/file.bal is well thought-out.
Context line capping: Math.min(..., MAX_CONTEXT_LINES) prevents runaway output for heavily matched files.

yasithrashan · 2026-05-25T04:14:30Z

@coderabbitai can you review grep.ts, glob.ts and rg-utils.ts

coderabbitai · 2026-05-25T04:15:04Z

Tip

For best results, initiate chat on the files or code changes.

@yasithrashan Here's a consolidated review of all three files. The codebase has improved significantly since the earlier pass — most of the previously flagged issues are resolved. Remaining findings below:

`rg-utils.ts` — New shared utility (overall: ✅ solid)

⚠️ `getRgExecutable()` is not memoized

getRgExecutable() is called inside the execute closure on every tool invocation. When the bundled binary is absent, this runs spawnSync('which', ['rg']) on every grep/glob call:

// rg-utils.ts — current
export function getRgExecutable(): string {
    if (fs.existsSync(builtinRgPath)) { return builtinRgPath; }
    const result = spawnSync('which', ['rg'], { encoding: 'utf-8' });
    ...
    return builtinRgPath; // fallback even if 'which' failed
}

Consider memoizing the result at module level:

let _rgExecutable: string | undefined;

export function getRgExecutable(): string {
    if (_rgExecutable) return _rgExecutable;
    if (fs.existsSync(builtinRgPath)) {
        return (_rgExecutable = builtinRgPath);
    }
    const result = spawnSync('which', ['rg'], { encoding: 'utf-8' });
    _rgExecutable = (result.status === 0 && result.stdout?.trim())
        ? result.stdout.trim()
        : builtinRgPath;
    return _rgExecutable;
}

🔧 Minor: `which` is Unix-only

which is not available on Windows; the equivalent is where. Since VS Code extensions can run on Windows:

const whichCmd = process.platform === 'win32' ? 'where' : 'which';
const result = spawnSync(whichCmd, ['rg'], { encoding: 'utf-8' });

✅ What's working well in `rg-utils.ts`

resolveProjectRoots() called once at executor-creation time — symlink resolution is never repeated per request.
validateSearchPath() — the two-root check (normalizedRoot + normalizedRawRoot) correctly handles the case where tempProjectPath itself is a symlink without a false-positive, which was the bug in the original glob.ts. Clean fix.
stripRootPrefix() — the edge case for root-level files (bare tempProjectPath + ':') is well handled.

`grep.ts` — Updated (previous critical bug fixed ✅)

🐛 Log count off-by-one after truncation

if (truncated) {
    lines = lines.slice(0, effectiveLimit);
    lines.push(`... (results truncated at ${effectiveLimit} lines; ...)`);
}
// ↓ lines.length is now effectiveLimit + 1 — the truncation note is counted
console.log(`[GrepTool] ripgrep returned ${lines.length} lines.`);

Fix: Log the count before pushing the note, or use a separate variable:

const originalCount = lines.length;
if (truncated) {
    lines = lines.slice(0, effectiveLimit);
    lines.push(`... (results truncated at ${effectiveLimit} of ${originalCount} lines; narrow your search or increase head_limit)`);
}
console.log(`[GrepTool] ripgrep returned ${originalCount} lines (displayed: ${Math.min(originalCount, effectiveLimit || originalCount)}).`);

⚠️ No regex pre-validation

An invalid pattern (e.g., "[") causes ripgrep to exit with code 2 and surfaces a raw rg error string. A pre-check gives a cleaner user-facing message:

try {
    new RegExp(pattern);
} catch (e) {
    return fail(`Invalid regex pattern: ${(e as Error).message}`, 'Error: Invalid regex');
}

🔧 Minor: `node_modules` not excluded

Not common in Ballerina workspaces, but for mixed-project safety:

args.push('--glob', '!.git/**', '--glob', '!target/**', '--glob', '!node_modules/**');

✅ What's fixed since the prior review

Duplicate --glob bug — args.push('--glob', '!.git/**', '--glob', '!target/**') is now correct.
Path traversal — delegated to validateSearchPath() in rg-utils.ts which uses path.relative() + realpathSync, avoiding the false-positive risk.
stripRootPrefix — extracted cleanly into rg-utils.ts.

`glob.ts` — Updated (custom walkDir + regex entirely removed ✅)

🔧 Nit: Grammar in tool description

description: `
Fast file pattern matching tool that work inside the Ballerina projects.
//                                         ^^^^
//                                         should be "works"

⚠️ `spawnSync` still blocks the event loop (both `grep.ts` and `glob.ts`)

Both tools still use spawnSync. For large workspaces this blocks the VS Code extension host thread. Since both execute functions are already async, consider using spawnAsync (or a promisified wrapper):

import { spawn } from 'child_process';

function spawnAsync(cmd: string, args: string[], opts: { maxBuffer: number }): Promise<{ status: number | null; stdout: string; stderr: string }> {
    return new Promise((resolve) => {
        const chunks: Buffer[] = [], errChunks: Buffer[] = [];
        const proc = spawn(cmd, args, { ...opts });
        proc.stdout.on('data', d => chunks.push(d));
        proc.stderr.on('data', d => errChunks.push(d));
        proc.on('close', status => resolve({
            status,
            stdout: Buffer.concat(chunks).toString('utf-8'),
            stderr: Buffer.concat(errChunks).toString('utf-8'),
        }));
    });
}

✅ What's fixed since the prior review

Custom walkDir removed — ripgrep's native glob engine handles matching, eliminating the brace-expansion empty-alternation and ** mid-pattern issues.
MAX_RESULTS = 500 — already added ✅
False-positive path traversal — fixed via rg-utils.ts validateSearchPath() ✅
Result truncation note — properly appended with files.length captured before slicing ✅

Summary Table

Issue	File	Severity	Status
`getRgExecutable()` not memoized	`rg-utils.ts`	⚠️ Perf	New
`which` Unix-only	`rg-utils.ts`	🔧 Minor	New
Log count off-by-one	`grep.ts`	🐛 Minor	New
No regex pre-validation	`grep.ts`	⚠️ UX	Carry-over
`node_modules` not excluded	`grep.ts`	🔧 Minor	Carry-over
`spawnSync` blocks event loop	`grep.ts`, `glob.ts`	⚠️ Perf	Carry-over
Grammar nit in description	`glob.ts`	🔧 Nit	New
Duplicate `--glob` bug	`grep.ts`	🐛 Fixed	✅
False-positive path traversal	`glob.ts`	🐛 Fixed	✅
Custom `walkDir` / glob regex	`glob.ts`	⚠️ Fixed	✅
`MAX_RESULTS` cap	`glob.ts`	⚠️ Fixed	✅
Two-root symlink protection	`rg-utils.ts`	✅	✅

coderabbitai · 2026-05-25T04:16:11Z

Tip

For best results, initiate chat on the files or code changes.

@yasithrashan Here's a consolidated review of all three files. The refactor into rg-utils.ts is excellent — great shared-utility extraction. glob.ts in particular has been substantially improved.

`rg-utils.ts` — New shared utility module

🐛 `getRgExecutable()`: Windows incompatibility

which is a Unix-only command and will fail silently on Windows:

const result = spawnSync('which', ['rg'], { encoding: 'utf-8' });

On Windows the equivalent is where. Consider a cross-platform approach:

const whichCmd = process.platform === 'win32' ? 'where' : 'which';
const result = spawnSync(whichCmd, ['rg'], { encoding: 'utf-8' });

🐛 `getRgExecutable()`: Silent fallback to non-existent path

If the bundled binary is missing and system rg lookup fails, the function returns builtinRgPath anyway — which doesn't exist. The downstream spawnSync will then fail with an obscure ENOENT:

// Current:
return builtinRgPath; // ← returned even when fs.existsSync(builtinRgPath) was false!

// Safer:
console.error('[rg-utils] ripgrep binary not found. Install `@vscode/ripgrep` or ensure rg is on PATH.');
throw new Error('ripgrep binary not found');
// or return a sentinel so callers can handle gracefully

✅ `validateSearchPath()` — Symlink false-positive fixed

The path traversal check now correctly tests against both normalizedRoot (real path) and normalizedRawRoot (raw path), which directly addresses the false-positive I flagged in the original glob.ts. Well done.

✅ `resolveProjectRoots()` — Efficient, called once at setup time

Resolving realpathSync at executor creation time rather than per-request is a clear win.

✅ `stripRootPrefix()` — Edge case handling

Correctly handles both the normal (/project/pkg/file.bal:42:...) and root-level file (/project/file.bal:42:...) forms.

`glob.ts` — Major rewrite, previous issues resolved

The complete rewrite to use ripgrep's --files mode instead of a custom walkDir is a significant improvement. Ripgrep's built-in glob engine is battle-tested and eliminates all the edge cases I flagged before (empty brace alternation, foo**bar cross-separator matching, synchronous readdirSync/statSync walk). The MAX_RESULTS = 500 cap is also now in place.

⚠️ mtime-based sorting lost

The original implementation sorted results by descending mtimeMs, which was a useful UX feature for surfacing recently-modified files first. The ripgrep --files output ordering is filesystem-dependent. Ripgrep natively supports modification-time sorting:

const args = [
    '--files',
    '--sortr', 'modified',   // ← most recently modified first
    '--glob', pattern,
    ...
];

⚠️ `spawnSync` still blocks the event loop

createGlobExecute returns an async function but uses spawnSync internally, which blocks the extension host thread. This was flagged before and remains. Since spawnSync is now also used in grep.ts, it may be worth tracking as a follow-up issue to migrate both tools to an async spawn/execFile approach.

`grep.ts` — Key bug fixed, two remaining issues

✅ Double `--glob` bug fixed

The malformed '--glob', '--glob', '!target/**' from the earlier version is now correctly:

args.push('--glob', '!.git/**', '--glob', '!target/**');

⚠️ No regex pre-validation (still)

An invalid regex (e.g., [) makes ripgrep exit with code 2 and returns a raw rg error string to the LLM. A pre-validation step gives a cleaner user-facing message:

try {
    new RegExp(pattern);
} catch (e) {
    return fail(`Invalid regex pattern: ${(e as Error).message}`, 'Error: Invalid regex');
}

🔧 Truncation log count off-by-one (still)

After lines.push(truncationNote), lines.length is effectiveLimit + 1. The log on the next line overstates the count:

console.log(`[GrepTool] ripgrep returned ${lines.length} lines.`);
// ↑ includes the truncation note line itself

A simple fix:

const rawCount = lines.length;
if (truncated) { lines = lines.slice(0, effectiveLimit); lines.push(`...`); }
console.log(`[GrepTool] ripgrep returned ${rawCount} lines (showing ${Math.min(rawCount, effectiveLimit || rawCount)}).`);

Summary

File	Status	Key remaining items
`rg-utils.ts`	✅ Clean extraction	`getRgExecutable` Windows compat + silent fallback
`glob.ts`	✅ Major improvement	mtime sort regression; `spawnSync` async follow-up
`grep.ts`	✅ Double-glob bug fixed	Regex pre-validation; log count nit; `spawnSync` async follow-up

RNViththagan · 2026-05-28T08:57:21Z

+
+    function fail(message: string, error: string): GlobResult {
+        const result: GlobResult = { success: false, message, error };
+        eventHandler({ type: "tool_result", toolName: GLOB_TOOL_NAME, toolOutput: result });


Do we have new ui elements to render these events

RNViththagan · 2026-05-28T08:57:49Z

+        eventHandler({
+            type: "tool_call",


RNViththagan · 2026-05-28T08:58:28Z

+                success: true,
+                message: `No files found matching pattern: "${pattern}"`,
+            };
+            eventHandler({ type: "tool_result", toolName: GLOB_TOOL_NAME, toolOutput: result });


RNViththagan · 2026-05-28T08:58:36Z

+            message: `Found ${files.length} file(s) matching "${pattern}":\n${displayed.join("\n")}${truncationNote}`,
+        };
+
+        eventHandler({ type: "tool_result", toolName: GLOB_TOOL_NAME, toolOutput: result });


RNViththagan · 2026-05-28T08:58:51Z

+
+    function fail(message: string, error: string): GrepResult {
+        const result: GrepResult = { success: false, message, error };
+        eventHandler({ type: "tool_result", toolName: GREP_TOOL_NAME, toolOutput: result });


RNViththagan · 2026-05-28T08:59:59Z

+        eventHandler({
+            type: "tool_call",


RNViththagan · 2026-05-28T09:00:11Z

+        if (proc.status === RgExitCode.Error) {
+            const errMsg = (proc.stderr || "").trim();
+            const result: GrepResult = { success: false, message: `ripgrep error: ${errMsg}`, error: errMsg };
+            eventHandler({ type: "tool_result", toolName: GREP_TOOL_NAME, toolOutput: result });


Ditto, Check other places too

RNViththagan · 2026-05-28T10:18:23Z

+- When the user submits a query, you will receive either **Codebase High Level Summary** or **Complete Structure of the Codebase**. Identify which one you have received before proceeding.
+- If you received Codebase High Level Summary, use it as a navigation map to locate the relevant components for the user query, in the codebase, but the actual source must be read separately when needed.
+- Codebase High Level Summary lists, for each Ballerina file, all of its components (imports, configurables, variables, types, functions, services, listeners, classes) with their signatures and line ranges, but excludes implementation bodies, test files, and resource files.
+- If you receive complete structure of the codebase, it contains the complete source of all .bal files (test and resource files excluded) provided directly in your context.


Test files were included i guess.
please verify

No, we are not including the test files.

RNViththagan · 2026-05-28T10:23:07Z

+            FILE_WRITE_TOOL_NAME,
+        ].join(
+            ", "
+        )} tools. The complete existing source code will be provided in the <existing_code> section of the user prompt.


Do we have this <existing_code> section?

RNViththagan · 2026-05-28T12:09:25Z

+            if (!this.config.chatStorage) {
+                console.log('[AICommandExecutor] Chat storage not configured, skipping initialization');
+                return;
+            }
+


The inner if (!this.config.chatStorage) is unreachable right?

RNViththagan · 2026-05-28T12:11:14Z

        );

+// ==================================
+// bal.md Generation for Agent Context


Shall we use CodeMap

RNViththagan · 2026-05-28T16:35:53Z


 ### Local Connectors
 - If the codebase structure shows connector modules in generated/moduleName, import using: import packageName.moduleName
 - Generated connector files appear under a \`<generated_files>\` block in the codebase structure as path-only entries (e.g. \`<file path="generated/moduleName/client.bal"/>\`) — no source content is included. Use the \`${FILE_READ_TOOL_NAME}\` tool with the listed path to fetch the content when needed.


<generated_files> is invalid for codemap case right?

RNViththagan · 2026-05-28T16:40:07Z

+const DEFAULT_GLOB_ARGS = [
+    "--glob", "*.bal",
+    "--glob", "*.toml",
+    "--glob", "*.md",
+    "--glob", "*.json",
+    "--glob", "*.yaml",
+    "--glob", "*.yml",
+    "--glob", "*.sql",
+];


i think it's better to mention the supported types to the agent. instead of silently ignores other type searches.
Maybe we can add a line to the tool description listing the file types we search by default, so the model knows.

RNViththagan · 2026-05-28T16:46:18Z

+}
+
+/** Paths and files always excluded from search */
+const EXCLUDE_GLOB_ARGS = ["--glob", "!.git/**", "--glob", "!target/**"];


missing Config.toml

In the glob tool, we do not search within the files, and there is no need to ignore them since the tool returns file paths rather than file content.

if we can better to avoid the path too.
optional :)

yasithrashan added 30 commits May 19, 2026 09:38

Add CodeMap API

ea7014b

Save code map bal.md to project's target dir

fa3ed14

Add incremental code map updates

2f7d784

Add grep tool for AI agent

4841157

Add CODEMAP guidelines, read tool & storage guards

6a9bebe

Add context retrieval evaluation to AI test pipeline

a8e2f0b

Remove incremental code map updates

228621d

Add code map context to user prompt

b20fba0

Log code map timing for LS call

d40c4e4

Move code map fetch to generateAgent

aeb8a41

Add workspace support for code map generation

f7d1546

Add code indexing test cases

8eb1e86

Use pre-fetched codeMap; drop pre-turn compaction

57945c4

Add menu_app test fixtures and refine AI prompts

20e897a

Use startLine/endLine instead of offset/limit

bef0e75

Refine code map prompts and read tool guidance

5c1d584

Fix module resolve

6cad851

Update codebase exploration prompt

444969b

Remove codemap updater

ea4eb2f

Fetch the codemap to AI tests

23aabfb

Enable test chat storage and sync paths

8e84375

Return undefined instead of null in addGeneration

89f3807

Include file contents in file_read extraction

027545b

Add gpc_microservices test data and update prompts

c72944e

Fallback to full project when code map absent

c4fd192

Improve Code Map prompts and read tool docs

12937dc

Disable test chat storage; adjust StateMachine sync

849ea1b

Include context retrieval in evaluation reports

2450fe4

Refactor codemap response

182950c

Add codeMapResolveModuleDependencies API

eb7e7a7

Use ripgrep for Grep tool

e07777c

coderabbitai Bot reviewed May 24, 2026

View reviewed changes

Comment thread workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/grep.ts Outdated

Comment thread workspaces/ballerina/ballerina-extension/src/features/ai/agent/tools/grep.ts Outdated

Use ripgrep for glob/grep and add rg utils

8d1f716

yasithrashan added 11 commits May 25, 2026 10:33

Use where/which on Windows and error if rg missing

379c203

Uncomment test cases; clean rg-utils comments

6bcc170

Use type-only event import and refactor tests

44e0b00

Use createFile(ignoreIfExists) and max-range replace

52cc246

Refine AI tool descriptions and exclude Config.toml

1119162

Simplify search path validation and rg utils

d5cb496

Refactor glob and grep tool descriptions

01fcf2e

Rename code map API enums to COPILOT

c829691

Refactor glob/grep tools

290f70b

Remove dependency pull resolution and UI

46b1e6e

Make CodeMapResponse.content required

c8a63a9

yasithrashan force-pushed the feature/code-indexing-bi-copilot branch from 7dac3ed to c8a63a9 Compare May 28, 2026 02:35

yasithrashan added 2 commits May 28, 2026 09:38

Refactor ripgrep tools and improve path handling

67d8047

Format DEFAULT_GLOB_ARGS array entries

08f3ae7

RNViththagan suggested changes May 28, 2026

View reviewed changes

RNViththagan reviewed May 28, 2026

View reviewed changes

yasithrashan added 5 commits May 28, 2026 23:31

Rename Codebase High Level Summary to Overview

a3554b1

Add grep and glob tool icons and displays

535ca7d

Add match/file counts to grep/glob and update UI

86c0278

Rename codebase section and drop chatStorage guard

13cff8d

Restrict grep tool default file types

64c66e1

yasithrashan marked this pull request as draft May 29, 2026 08:10

Uh oh!

Conversation

yasithrashan commented May 19, 2026 • edited by coderabbitai Bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Purpose

key Changes

Summary by CodeRabbit

Uh oh!

yasithrashan commented May 24, 2026

Uh oh!

coderabbitai Bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

coderabbitai Bot commented May 24, 2026

Review of grep.ts

🐛 Critical Bug: Malformed glob exclusion args

⚠️ spawnSync blocks the VS Code event loop

⚠️ No regex pre-validation

🔧 Truncation log count is off-by-one

🔧 Minor: node_modules not excluded

✅ What's working well

Uh oh!

yasithrashan commented May 25, 2026

Uh oh!

coderabbitai Bot commented May 25, 2026

rg-utils.ts — New shared utility (overall: ✅ solid)

⚠️ getRgExecutable() is not memoized

🔧 Minor: which is Unix-only

✅ What's working well in rg-utils.ts

grep.ts — Updated (previous critical bug fixed ✅)

🐛 Log count off-by-one after truncation

⚠️ No regex pre-validation

🔧 Minor: node_modules not excluded

✅ What's fixed since the prior review

glob.ts — Updated (custom walkDir + regex entirely removed ✅)

🔧 Nit: Grammar in tool description

⚠️ spawnSync still blocks the event loop (both grep.ts and glob.ts)

✅ What's fixed since the prior review

Summary Table

Uh oh!

coderabbitai Bot commented May 25, 2026

rg-utils.ts — New shared utility module

🐛 getRgExecutable(): Windows incompatibility

🐛 getRgExecutable(): Silent fallback to non-existent path

✅ validateSearchPath() — Symlink false-positive fixed

✅ resolveProjectRoots() — Efficient, called once at setup time

✅ stripRootPrefix() — Edge case handling

glob.ts — Major rewrite, previous issues resolved

⚠️ mtime-based sorting lost

⚠️ spawnSync still blocks the event loop

grep.ts — Key bug fixed, two remaining issues

✅ Double --glob bug fixed

⚠️ No regex pre-validation (still)

🔧 Truncation log count off-by-one (still)

Summary

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

yasithrashan commented May 19, 2026 •

edited by coderabbitai Bot

Loading

Review of `grep.ts`

⚠️ `spawnSync` blocks the VS Code event loop

🔧 Minor: `node_modules` not excluded

`rg-utils.ts` — New shared utility (overall: ✅ solid)

⚠️ `getRgExecutable()` is not memoized

🔧 Minor: `which` is Unix-only

✅ What's working well in `rg-utils.ts`

`grep.ts` — Updated (previous critical bug fixed ✅)

🔧 Minor: `node_modules` not excluded

`glob.ts` — Updated (custom walkDir + regex entirely removed ✅)

⚠️ `spawnSync` still blocks the event loop (both `grep.ts` and `glob.ts`)

`rg-utils.ts` — New shared utility module

🐛 `getRgExecutable()`: Windows incompatibility

🐛 `getRgExecutable()`: Silent fallback to non-existent path

✅ `validateSearchPath()` — Symlink false-positive fixed

✅ `resolveProjectRoots()` — Efficient, called once at setup time

✅ `stripRootPrefix()` — Edge case handling

`glob.ts` — Major rewrite, previous issues resolved

⚠️ `spawnSync` still blocks the event loop

`grep.ts` — Key bug fixed, two remaining issues

✅ Double `--glob` bug fixed