Fix extension search not respecting category filter

When searching extensions with a category filter (e.g., "Themes") selected,
results could include extensions that don't belong to that category. This
happened because `filter_extension_entries()` only filtered by install status
but not by the `provides_filter` (category). The Cloud API may also bypass
category filtering for exact-match extensions.

Add client-side `provides_filter` checks for both remote and dev extensions
in `filter_extension_entries()`.

Closes #48628

Co-Authored-By: Claude <noreply@anthropic.com>

Author: chenwuji2000-cyber

crates/extensions_ui/src/extensions_ui.rs

@@ -320,6 +320,7 @@ pub struct ExtensionsPage {
     remote_extension_entries: Vec<ExtensionMetadata>,
     dev_extension_entries: Vec<Arc<ExtensionManifest>>,
     filtered_remote_extension_indices: Vec<usize>,
+    filtered_dev_extension_indices: Vec<usize>,
     query_editor: Entity<Editor>,
     query_contains_error: bool,
     provides_filter: Option<ExtensionProvides>,
@@ -381,6 +382,7 @@ impl ExtensionsPage {
                 filter: ExtensionFilter::All,
                 dev_extension_entries: Vec::new(),
                 filtered_remote_extension_indices: Vec::new(),
+                filtered_dev_extension_indices: Vec::new(),
                 remote_extension_entries: Vec::new(),
                 query_contains_error: false,
                 provides_filter,
@@ -487,8 +489,25 @@ impl ExtensionsPage {
                         matches!(status, ExtensionStatus::NotInstalled)
                     }
                 })
+                .filter(|(_, extension)| match self.provides_filter {
+                    Some(provides) => extension.manifest.provides.contains(&provides),
+                    None => true,
+                })
+                .map(|(ix, _)| ix),
+        );
+
+        self.filtered_dev_extension_indices.clear();
+        self.filtered_dev_extension_indices.extend(
+            self.dev_extension_entries
+                .iter()
+                .enumerate()
+                .filter(|(_, manifest)| match self.provides_filter {
+                    Some(provides) => dev_extension_matches_provides(manifest, provides),
+                    None => true,
+                })
                 .map(|(ix, _)| ix),
         );
+
         cx.notify();
     }
 
@@ -597,14 +616,15 @@ impl ExtensionsPage {
         cx: &mut Context<Self>,
     ) -> Vec<ExtensionCard> {
         let dev_extension_entries_len = if self.filter.include_dev_extensions() {
-            self.dev_extension_entries.len()
+            self.filtered_dev_extension_indices.len()
         } else {
             0
         };
         range
             .map(|ix| {
                 if ix < dev_extension_entries_len {
-                    let extension = &self.dev_extension_entries[ix];
+                    let dev_ix = self.filtered_dev_extension_indices[ix];
+                    let extension = &self.dev_extension_entries[dev_ix];
                     self.render_dev_extension(extension, cx)
                 } else {
                     let extension_ix =
@@ -1817,7 +1837,7 @@ impl Render for ExtensionsPage {
             .child(v_flex().px_4().size_full().overflow_y_hidden().map(|this| {
                 let mut count = self.filtered_remote_extension_indices.len();
                 if self.filter.include_dev_extensions() {
-                    count += self.dev_extension_entries.len();
+                    count += self.filtered_dev_extension_indices.len();
                 }
 
                 if count == 0 {
@@ -1864,3 +1884,22 @@ impl Item for ExtensionsPage {
         f(*event)
     }
 }
+
+fn dev_extension_matches_provides(
+    manifest: &ExtensionManifest,
+    provides: ExtensionProvides,
+) -> bool {
+    match provides {
+        ExtensionProvides::Themes => !manifest.themes.is_empty(),
+        ExtensionProvides::IconThemes => !manifest.icon_themes.is_empty(),
+        ExtensionProvides::Languages => !manifest.languages.is_empty(),
+        ExtensionProvides::Grammars => !manifest.grammars.is_empty(),
+        ExtensionProvides::LanguageServers => !manifest.language_servers.is_empty(),
+        ExtensionProvides::ContextServers => !manifest.context_servers.is_empty(),
+        ExtensionProvides::AgentServers => !manifest.agent_servers.is_empty(),
+        ExtensionProvides::SlashCommands => !manifest.slash_commands.is_empty(),
+        ExtensionProvides::IndexedDocsProviders => false,
+        ExtensionProvides::Snippets => manifest.snippets.is_some(),
+        ExtensionProvides::DebugAdapters => !manifest.debug_adapters.is_empty(),
+    }
+}