fix(cli): improve code actions filtering (#9627)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: ematipico

.changeset/gentle-comics-win.md

@@ -0,0 +1,9 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#191](https://github.com/biomejs/biome-zed/issues/191): Improved the performance of how the Biome Language Server pulls code actions and diagnostics.
+
+Before, code actions were pulled and computed all at once in one request. This approach couldn't work in big files, and caused Biome to stale and have CPU usage spikes up to 100%.
+
+Now, code actions are pulled and computed lazily, and Biome won't choke anymore in big files.

.changeset/mighty-pillows-count.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed assist diagnostics being invisible when using `--diagnostic-level=error`. Enforced assist violations (e.g. `useSortedKeys`) were filtered out before being promoted to errors, causing `biome check` to incorrectly return success.

.changeset/silly-islands-relate.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed duplicate parse errors in `check` and `ci` output. When a file had syntax errors, the same parse error was printed twice and the error count was inflated.

.changeset/smart-radios-end.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Improved the performance of the commands `lint` and `check` when they are called with `--write`.

.changeset/thirty-breads-beg.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed `--diagnostic-level` not fully filtering diagnostics. Setting `--diagnostic-level=error` now correctly excludes warnings and infos from both the output and the summary counts.

Cargo.lock

@@ -56,7 +56,8 @@ pub use crate::services::{
     ExtendedConfigurationProvider, FromServices, ServiceBag, ServicesDiagnostic,
 };
 pub use crate::signals::{
-    AnalyzerAction, AnalyzerSignal, AnalyzerTransformation, DiagnosticSignal, PluginSignal,
+    ActionFilter, ActionMetadata, AnalyzerAction, AnalyzerSignal, AnalyzerTransformation,
+    DiagnosticSignal, PluginSignal,
 };
 use crate::suppressions::Suppressions;
 pub use crate::syntax::{Ast, SyntaxVisitor};

crates/biome_analyze/src/lib.rs

@@ -2,8 +2,8 @@ use crate::categories::{
     SUPPRESSION_INLINE_ACTION_CATEGORY, SUPPRESSION_TOP_LEVEL_ACTION_CATEGORY,
 };
 use crate::{
-    AnalyzerDiagnostic, AnalyzerOptions, OtherActionCategory, Queryable, RuleDiagnostic, RuleGroup,
-    ServiceBag, SuppressionAction,
+    AnalyzerDiagnostic, AnalyzerOptions, FixKind, GroupCategory, OtherActionCategory, Queryable,
+    RuleCategory, RuleDiagnostic, RuleGroup, ServiceBag, SuppressionAction,
     categories::ActionCategory,
     context::RuleContext,
     registry::{RuleLanguage, RuleRoot},
@@ -12,15 +12,81 @@ use crate::{
 use biome_console::{MarkupBuf, markup};
 use biome_diagnostics::{Applicability, CodeSuggestion, Error, advice::CodeSuggestionAdvice};
 use biome_rowan::{BatchMutation, Language};
+use enumflags2::{BitFlag, BitFlags, bitflags};
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
 use std::vec::IntoIter;
 
+/// Select which action categories should be computed by the analyzer.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct ActionFilter(pub BitFlags<ActionKind>);
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[bitflags]
+#[repr(u8)]
+pub enum ActionKind {
+    RuleFix = 1 << 0,
+    InlineSuppression = 1 << 1,
+    ToplevelSuppression = 1 << 2,
+}
+
+impl ActionFilter {
+    pub fn all() -> Self {
+        let all: BitFlags<ActionKind> = ActionKind::all();
+        Self(all)
+    }
+
+    pub fn rule_fix() -> Self {
+        let mut filter = ActionKind::empty();
+        filter.insert(ActionKind::RuleFix);
+        Self(filter)
+    }
+
+    pub fn inline_suppression() -> Self {
+        let mut filter = ActionKind::empty();
+        filter.insert(ActionKind::InlineSuppression);
+        Self(filter)
+    }
+
+    pub fn toplevel_suppression() -> Self {
+        let mut filter = ActionKind::empty();
+        filter.insert(ActionKind::ToplevelSuppression);
+        Self(filter)
+    }
+
+    pub fn has_actions(&self) -> bool {
+        !self.0.is_empty()
+    }
+
+    pub fn is_rule_fix(&self) -> bool {
+        self.0.contains(ActionKind::RuleFix)
+    }
+
+    pub fn is_inline_suppression(&self) -> bool {
+        self.0.contains(ActionKind::InlineSuppression)
+    }
+    pub fn is_toplevel_suppression(&self) -> bool {
+        self.0.contains(ActionKind::ToplevelSuppression)
+    }
+}
+
+/// Lightweight description of an available action, without the expensive
+/// [`BatchMutation`]. Used by `codeAction/resolve` to defer edit computation.
+#[derive(Debug, Clone)]
+pub struct ActionMetadata {
+    pub rule_name: Option<(&'static str, &'static str)>,
+    pub category: ActionCategory,
+    pub applicability: Applicability,
+}
+
 /// Event raised by the analyzer when a [Rule](crate::Rule)
 /// emits a diagnostic, a code action, or both
 pub trait AnalyzerSignal<L: Language> {
     fn diagnostic(&self) -> Option<AnalyzerDiagnostic>;
-    fn actions(&self) -> AnalyzerActionIter<L>;
+    fn actions(&self, filter: ActionFilter) -> AnalyzerActionIter<L>;
+    /// Returns lightweight metadata about available actions without computing
+    /// mutations. This is cheap — no [`BatchMutation`] or tree clones.
+    fn actions_metadata(&self) -> Vec<ActionMetadata>;
     fn transformations(&self) -> AnalyzerTransformationIter<L>;
 }
 
@@ -84,12 +150,17 @@ where
         Some(AnalyzerDiagnostic::from_error(error))
     }
 
-    fn actions(&self) -> AnalyzerActionIter<L> {
-        if let Some(action) = (self.action)() {
-            AnalyzerActionIter::new([action])
-        } else {
-            AnalyzerActionIter::new(vec![])
+    fn actions(&self, filter: ActionFilter) -> AnalyzerActionIter<L> {
+        if filter.is_rule_fix()
+            && let Some(action) = (self.action)()
+        {
+            return AnalyzerActionIter::new([action]);
         }
+        AnalyzerActionIter::new(vec![])
+    }
+
+    fn actions_metadata(&self) -> Vec<ActionMetadata> {
+        Vec::new()
     }
 
     fn transformations(&self) -> AnalyzerTransformationIter<L> {
@@ -128,10 +199,14 @@ impl<L: Language> AnalyzerSignal<L> for PluginSignal<L> {
         Some(AnalyzerDiagnostic::from(self.diagnostic.clone()))
     }
 
-    fn actions(&self) -> AnalyzerActionIter<L> {
+    fn actions(&self, _filter: ActionFilter) -> AnalyzerActionIter<L> {
         AnalyzerActionIter::new(vec![])
     }
 
+    fn actions_metadata(&self) -> Vec<ActionMetadata> {
+        Vec::new()
+    }
+
     fn transformations(&self) -> AnalyzerTransformationIter<L> {
         AnalyzerTransformationIter::new(vec![])
     }
@@ -429,17 +504,21 @@ where
         })
     }
 
-    fn actions(&self) -> AnalyzerActionIter<RuleLanguage<R>> {
+    fn actions(&self, filter: ActionFilter) -> AnalyzerActionIter<RuleLanguage<R>> {
         let globals = self.options.globals();
 
-        let configured_applicability = if let Some(fix_kind) = self.options.rule_fix_kind::<R>() {
-            match fix_kind {
-                crate::FixKind::None => {
-                    // The action is disabled
-                    return AnalyzerActionIter::new(vec![]);
+        // When fix is set to "none", disable the rule fix but still allow
+        // suppression actions.
+        let fix_disabled = matches!(self.options.rule_fix_kind::<R>(), Some(FixKind::None));
+        let configured_applicability = if filter.is_rule_fix() && !fix_disabled {
+            if let Some(fix_kind) = self.options.rule_fix_kind::<R>() {
+                match fix_kind {
+                    FixKind::None => None,
+                    FixKind::Safe => Some(Applicability::Always),
+                    FixKind::Unsafe => Some(Applicability::MaybeIncorrect),
                 }
-                crate::FixKind::Safe => Some(Applicability::Always),
-                crate::FixKind::Unsafe => Some(Applicability::MaybeIncorrect),
+            } else {
+                None
             }
         } else {
             None
@@ -462,16 +541,21 @@ where
         .ok();
         let mut actions = Vec::new();
         if let Some(ctx) = ctx {
-            if let Some(action) = R::action(&ctx, &self.state) {
+            if filter.is_rule_fix()
+                && !fix_disabled
+                && let Some(action) = R::action(&ctx, &self.state)
+            {
                 actions.push(AnalyzerAction {
                     rule_name: Some((<R::Group as RuleGroup>::NAME, R::METADATA.name)),
                     applicability: configured_applicability.unwrap_or(action.applicability()),
                     category: action.category,
                     mutation: action.mutation,
                     message: action.message,
                 });
-            };
-            if let Some(text_range) = R::text_range(&ctx, &self.state)
+            }
+
+            if filter.is_inline_suppression()
+                && let Some(text_range) = R::text_range(&ctx, &self.state)
                 && let Some(suppression_action) = R::inline_suppression(
                     &ctx,
                     &text_range,
@@ -489,8 +573,9 @@ where
                 actions.push(action);
             }
 
-            if let Some(suppression_action) =
-                R::top_level_suppression(&ctx, self.suppression_action)
+            if filter.is_toplevel_suppression()
+                && let Some(suppression_action) =
+                    R::top_level_suppression(&ctx, self.suppression_action)
             {
                 let action = AnalyzerAction {
                     rule_name: Some((<R::Group as RuleGroup>::NAME, R::METADATA.name)),
@@ -508,6 +593,54 @@ where
         }
     }
 
+    fn actions_metadata(&self) -> Vec<ActionMetadata> {
+        let rule_name = Some((<R::Group as RuleGroup>::NAME, R::METADATA.name));
+        let rule_category = <<R::Group as RuleGroup>::Category as GroupCategory>::CATEGORY;
+        let has_suppression = matches!(
+            rule_category,
+            RuleCategory::Lint | RuleCategory::Action | RuleCategory::Syntax
+        );
+
+        let mut metadata = Vec::new();
+
+        // Rule fix metadata — only if the rule declares a fix
+        let fix_kind = self.options.rule_fix_kind::<R>();
+        let is_disabled = matches!(fix_kind, Some(FixKind::None));
+        if !is_disabled && R::METADATA.fix_kind != FixKind::None {
+            let applicability = match fix_kind {
+                Some(FixKind::Safe) => Applicability::Always,
+                Some(FixKind::Unsafe) => Applicability::MaybeIncorrect,
+                _ => match R::METADATA.fix_kind {
+                    FixKind::Safe => Applicability::Always,
+                    _ => Applicability::MaybeIncorrect,
+                },
+            };
+            let action_category =
+                R::METADATA.action_category(rule_category, <R::Group as RuleGroup>::NAME);
+            metadata.push(ActionMetadata {
+                rule_name,
+                category: action_category,
+                applicability,
+            });
+        }
+
+        // Suppression metadata
+        if has_suppression {
+            metadata.push(ActionMetadata {
+                rule_name,
+                category: ActionCategory::Other(OtherActionCategory::InlineSuppression),
+                applicability: Applicability::Always,
+            });
+            metadata.push(ActionMetadata {
+                rule_name,
+                category: ActionCategory::Other(OtherActionCategory::ToplevelSuppression),
+                applicability: Applicability::Always,
+            });
+        }
+
+        metadata
+    }
+
     fn transformations(&self) -> AnalyzerTransformationIter<RuleLanguage<R>> {
         let globals = self.options.globals();
         let options = self.options.rule_options::<R>().unwrap_or_default();

crates/biome_analyze/src/signals.rs

@@ -12,6 +12,7 @@ use biome_configuration::vcs::VcsConfiguration;
 use biome_configuration::{Configuration, FilesConfiguration};
 use biome_console::{Console, MarkupBuf};
 use biome_deserialize::Merge;
+use biome_diagnostics::Severity;
 use biome_diagnostics::{Category, DiagnosticExt, category};
 use biome_fs::FileSystem;
 use biome_grit_patterns::{GritTargetLanguage, JsTargetLanguage};
@@ -140,6 +141,8 @@ impl ProcessFile for SearchProcessFile {
         ctx: &Ctx,
         workspace_file: &mut WorkspaceFile,
         _features_supported: &FeaturesSupported,
+        _max_diagnostics: u32,
+        _diagnostic_level: Severity,
     ) -> Result<FileStatus, Message>
     where
         Ctx: CrawlerContext,
@@ -175,6 +178,9 @@ impl ProcessFile for SearchProcessFile {
                 .map(|mat| SearchDiagnostic.with_file_span(mat))
                 .collect(),
             skipped_diagnostics: 0,
+            errors: 0,
+            warnings: 0,
+            infos: 0,
         };
 
         Ok(FileStatus::SearchResult(matches_len, search_results))

crates/biome_cli/src/commands/search.rs

@@ -2,7 +2,7 @@ use crate::commands::MigrateSubCommand;
 use crate::diagnostics::MigrationDiagnostic;
 use crate::runner::diagnostics::{ContentDiffAdvice, MigrateDiffDiagnostic};
 use crate::{CliDiagnostic, CliSession};
-use biome_analyze::AnalysisFilter;
+use biome_analyze::{ActionFilter, AnalysisFilter};
 use biome_configuration::Configuration;
 use biome_console::fmt::{Display, Formatter};
 use biome_console::{Console, ConsoleExt, markup};
@@ -375,7 +375,7 @@ fn migrate_file(payload: MigrateFile) -> Result<MigrationFileResult, CliDiagnost
                     configuration_file_path.as_path(),
                     is_root,
                     |signal| {
-                        if let Some(action) = signal.actions().next() {
+                        if let Some(action) = signal.actions(ActionFilter::rule_fix()).next() {
                             return ControlFlow::Break(action);
                         }
                         ControlFlow::Continue(())