⚡ Bolt: Add early-exit bitflag check for fuzzy path matching

[AhmmedSamier]

💡 What:
Added a new parallel typed array itemPathBitflags to the SearchEngine state. This array pre-computes the bitmask of characters available in an item's file path (relativeFilePath). In the hot path fuzzy matching loop (tryFuzzyMatchPath), a fast bitwise operation is performed against the query's bitmask to quickly eliminate items that do not contain all the required characters for a match.

🎯 Why:
The codebase had correctly optimized the fuzzy matching for the name and fullName properties by implementing O(1) early-exit checks (itemNameBitflags, itemFullNameBitflags). However, this optimization was entirely missing for item.filePath. Consequently, the application was executing the expensive Fuzzysort.single() algorithm for file path matching even when the path clearly lacked the required characters to yield a match.

📊 Impact:
Significantly reduces the number of CPU cycles wasted on fuzzysort calculations. For queries that match names but do not match the file path, this eliminates an O(N*M) matching operation in favor of a sub-millisecond O(1) bitwise comparison. This leads to measurably faster overall search times and reduced CPU spikes in the extension host.

🔬 Measurement:
Running bun run test locally on the benchmark and standard test suites verifies the correctness. Performance can be directly measured by capturing a CPU trace while executing broad fuzzy searches (like "abc") and observing a significant reduction in execution time attributed to the tryFuzzyMatchPath function.

---

PR created automatically by Jules for task 16508863692719578225 started by @AhmmedSamier

Summary by CodeRabbit

• Performance
  • Improved file-path fuzzy search by adding a faster early-rejection check before expensive matching.
  • Search processing now reuses cached path-related flags to reduce unnecessary work.
• Bug Fixes
  • File path results now follow the same quick-filter behavior as other searchable fields, making multi-field searches more consistent.

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[coderabbitai]

Warning

Review limit reached

@AhmmedSamier, you've reached your PR review limit, so we couldn't start this review.

Next review available in: 36 minutes

Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available.
You're only billed for reviews past your plan's rate limits ($0.25/file).

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 8f929453-8274-4196-9609-c31ec809561c

📥 Commits

Reviewing files that changed from the base of the PR and between d223eb6 and 4e86eb5.

📒 Files selected for processing (3)

• .github/workflows/ci.yml
• language-server/scripts/copy-ripgrep.ts
• vscode-extension/src/test/suite/reference-code-lens.test.ts

📝 Walkthrough

Walkthrough

Adds a new itemPathBitflags parallel array to SearchEngine, computed via computeItemBitflags for relativeFilePath, and propagated through indexing, cache sizing, search context, and lifecycle operations (add/remove/move/clear). tryFuzzyMatchPath uses it for an O(1) early-exit before fuzzy matching. Documentation note added.

Changes

Path Bitflag Early-Exit

Layer / File(s)	Summary
Bitflags data structure, computation, and array lifecycle language-server/src/core/search-engine.ts	Declares itemPathBitflags, computes pathFlags in computeItemBitflags, stores it in prepareItemAtIndex, and keeps it consistent across setItems, addItems, truncateArrays, moveItem, clear, and getCacheSize.
Search-time context wiring and early-exit matching language-server/src/core/search-engine.ts	Adds itemPathBitflags to prepareSearchContext and applies a bitmask check in tryFuzzyMatchPath to skip fuzzy scoring when path bitflags don't satisfy the query mask.
Documentation note .jules/bolt.md	Documents the pattern of applying the early-exit bitmask check to file path matching.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Sequence Diagram(s)

sequenceDiagram
  participant Indexer as SearchEngine Indexing
  participant Compute as computeItemBitflags
  participant Context as prepareSearchContext
  participant Matcher as tryFuzzyMatchPath
  participant Fuzzy as fuzzysort

  Indexer->>Compute: compute pathFlags from relativeFilePath
  Compute-->>Indexer: store pathFlags in itemPathBitflags
  Context->>Matcher: provide itemPathBitflags, queryBitflags
  Matcher->>Matcher: check bitflags against query mask
  alt mask satisfied
    Matcher->>Fuzzy: run fuzzy match
    Fuzzy-->>Matcher: score result
  else mask not satisfied
    Matcher-->>Context: skip, no fuzzy match
  end

Loading

Possibly related PRs

• AhmmedSamier/DeepLens#519: Both PRs add per-item bitflag arrays computed in computeItemBitflags and threaded through prepareSearchContext to enable O(1) early-exit in fuzzy matchers.
• AhmmedSamier/DeepLens#521: Both PRs plumb new per-property bitflag arrays through computeItemBitflags/prepareItemAtIndex/search-context setup for different fuzzy-match functions.
• AhmmedSamier/DeepLens#428: Both PRs update search-engine.ts to keep parallel index arrays consistent during removals/truncation.

Suggested labels: codex

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly describes the main change: an early-exit bitflag optimization for fuzzy path matching in Bolt.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch bolt-optimize-path-fuzzy-match-16508863692719578225

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}