biomejs · dyc3 · Apr 10, 2026 · Apr 10, 2026 · Apr 10, 2026 · Apr 11, 2026
diff --git a/.changeset/brown-impalas-sniff.md b/.changeset/brown-impalas-sniff.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": minor
+---
+
+Added a migrate quick fix for `biome.json` and `biome.jsonc` in the Biome LSP. Editors can now offer the same native configuration migrations as `biome migrate`, including config structure and rule migration updates, directly from published configuration diagnostics.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/biome_cli/src/execute/migrate.rs b/crates/biome_cli/src/execute/migrate.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::{ActionFilter, AnalysisFilter};
+use biome_analyze::AnalysisFilter;
 use biome_configuration::Configuration;
 use biome_console::fmt::{Display, Formatter};
 use biome_console::{Console, ConsoleExt, markup};
@@ -13,16 +13,13 @@ use biome_diagnostics::{
 };
 use biome_fs::{BiomePath, ConfigName, OpenOptions};
 use biome_json_parser::{JsonParserOptions, parse_json_with_cache};
-use biome_json_syntax::{JsonFileSource, JsonRoot};
-use biome_migrate::{ControlFlow, migrate_configuration};
-use biome_rowan::{AstNode, NodeCache};
+use biome_json_syntax::JsonFileSource;
+use biome_migrate::migrate_configuration_tree;
+use biome_rowan::NodeCache;
 use biome_service::Workspace;
 use biome_service::projects::ProjectKey;
-use biome_service::workspace::{
-    ChangeFileParams, FileContent, FixAction, FormatFileParams, OpenFileParams,
-};
+use biome_service::workspace::{ChangeFileParams, FileContent, FormatFileParams, OpenFileParams};
 use camino::Utf8PathBuf;
-use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::fmt::Debug;
 
@@ -365,53 +362,21 @@ fn migrate_file(payload: MigrateFile) -> Result<MigrationFileResult, CliDiagnost
             Ok(result)
         }
         None => {
-            let mut tree = parsed.tree();
-            let mut actions = Vec::new();
             let is_root = workspace.fs().working_directory().is_some_and(|wd| {
                 configuration_file_path.strip_prefix(wd).is_ok_and(|path| {
                     path.starts_with(ConfigName::biome_json())
                         || path.starts_with(ConfigName::biome_jsonc())
                 })
             });
-            loop {
-                let (action, _) = migrate_configuration(
-                    &tree,
-                    AnalysisFilter::default(),
-                    configuration_file_path.as_path(),
-                    is_root,
-                    |signal| {
-                        if let Some(action) = signal.actions(ActionFilter::rule_fix()).next() {
-                            return ControlFlow::Break(action);
-                        }
-                        ControlFlow::Continue(())
-                    },
-                );
-                match action {
-                    Some(action) => {
-                        if let (root, Some((range, _))) =
-                            action.mutation.commit_with_text_range_and_edit(true)
-                        {
-                            tree = match JsonRoot::cast(root) {
-                                Some(tree) => tree,
-                                None => {
-                                    return Err(CliDiagnostic::check_error(category!("migrate")));
-                                }
-                            };
-                            actions.push(FixAction {
-                                rule_name: action.rule_name.map(|(group, rule)| {
-                                    (Cow::Borrowed(group), Cow::Borrowed(rule))
-                                }),
-                                range,
-                            });
-                        }
-                    }
-                    None => {
-                        break;
-                    }
-                }
-            }
-
-            let new_configuration_content = tree.to_string();
+            let new_configuration_content = match migrate_configuration_tree(
+                &parsed.tree(),
+                AnalysisFilter::default(),
+                configuration_file_path.as_path(),
+                is_root,
+            ) {
+                Some(tree) => tree.to_string(),
+                None => biome_config_content.clone(),
+            };
             if biome_config_content != new_configuration_content {
                 if write {
                     let mut configuration_file = biome_config_file;

diff --git a/crates/biome_fs/src/path.rs b/crates/biome_fs/src/path.rs
@@ -135,11 +135,11 @@ impl BiomePath {
     }
 
     /// The priority of the file.
-    /// - `biome.json` and `biome.jsonc` have the highest priority
+    /// - Biome configuration files have the highest priority
     /// - `package.json`, `tsconfig.json`/`jsconfig.json`, `turbo.json`, and `pnpm-workspace.yaml` have the second-highest priority, and they are considered as manifest files
     /// - Other files are considered as files to handle
     fn priority(file_name: &str) -> FileKinds {
-        if file_name == ConfigName::biome_json() || file_name == ConfigName::biome_jsonc() {
+        if ConfigName::file_names().contains(&file_name) {
             FileKinds::Config
         } else if matches!(
             file_name,
@@ -345,6 +345,8 @@ mod test {
         );
         assert_eq!(BiomePath::priority("biome.json"), FileKinds::Config);
         assert_eq!(BiomePath::priority("biome.jsonc"), FileKinds::Config);
+        assert_eq!(BiomePath::priority(".biome.json"), FileKinds::Config);
+        assert_eq!(BiomePath::priority(".biome.jsonc"), FileKinds::Config);
         assert_eq!(BiomePath::priority(".gitignore"), FileKinds::Ignore);
         assert_eq!(BiomePath::priority(".ignore"), FileKinds::Ignore);
     }

diff --git a/crates/biome_lsp/src/capabilities.rs b/crates/biome_lsp/src/capabilities.rs
@@ -10,6 +10,7 @@ use tower_lsp_server::ls_types::{
 
 pub(crate) const DEFAULT_CODE_ACTION_CAPABILITIES: &[&str] = &[
     "quickfix.biome",
+    "quickfix.biome.migrateConfiguration",
     // quickfix.suppressRule
     SUPPRESSION_TOP_LEVEL_ACTION_CATEGORY,
     SUPPRESSION_INLINE_ACTION_CATEGORY,

diff --git a/crates/biome_lsp/src/handlers/analysis.rs b/crates/biome_lsp/src/handlers/analysis.rs
@@ -19,7 +19,7 @@ use biome_service::file_handlers::vue::VueFileHandler;
 use biome_service::workspace::{
     CheckFileSizeParams, FeaturesBuilder, FileFeaturesResult, FixFileMode, FixFileParams,
     GetFileContentParams, IgnoreKind, PathIsIgnoredParams, ProjectKey, PullActionsParams,
-    SupportsFeatureParams,
+    PullConfigurationActionsParams, SupportsFeatureParams,
 };
 use biome_service::{WorkspaceError, extension_error};
 use serde_json::Value;
@@ -34,6 +34,8 @@ use tracing::{debug, info};
 const FIX_ALL_CATEGORY: ActionCategory = ActionCategory::Source(SourceActionKind::FixAll);
 const ORGANIZE_IMPORTS_CATEGORY: ActionCategory =
     ActionCategory::Source(SourceActionKind::OrganizeImports);
+const CONFIG_MIGRATE_QUICKFIX_CATEGORY: ActionCategory =
+    ActionCategory::QuickFix(Cow::Borrowed("migrateConfiguration"));
 
 fn fix_all_kind() -> CodeActionKind {
     match FIX_ALL_CATEGORY.to_str() {
@@ -91,10 +93,6 @@ pub(crate) fn code_actions(
             .build(),
     })?;
 
-    if !file_features.supports_lint() && !file_features.supports_assist() {
-        info!("Linter and assist are disabled.");
-        return Ok(Some(Vec::new()));
-    }
     let mut categories = RuleCategoriesBuilder::default();
     if file_features.supports_lint() {
         categories = categories.with_lint();
@@ -115,6 +113,7 @@ pub(crate) fn code_actions(
     let mut has_organize_imports = false;
     let mut filters = Vec::new();
     if let Some(filter) = &params.context.only {
+        filters.reserve(filter.len());
         for kind in filter {
             let kind = kind.as_str();
             if FIX_ALL_CATEGORY.matches(kind) {
@@ -130,6 +129,20 @@ pub(crate) fn code_actions(
     let position_encoding = session.position_encoding();
 
     let diagnostics = params.context.diagnostics;
+    let migrate_configuration_action = config_migrate_code_action(
+        session,
+        &url,
+        &path,
+        &doc.line_index,
+        position_encoding,
+        &filters,
+        doc.project_key,
+    )?;
+    if !file_features.supports_lint() && !file_features.supports_assist() {
+        info!("Linter and assist are disabled.");
+        return Ok(migrate_configuration_action.map(|action| vec![action]));
+    }
+
     let content = session.workspace.get_file_content(GetFileContentParams {
         project_key: doc.project_key,
         path: path.clone(),
@@ -325,6 +338,7 @@ pub(crate) fn code_actions(
             Some(CodeActionOrCommand::CodeAction(lsp_action))
         })
         .chain(fix_all)
+        .chain(migrate_configuration_action)
         .collect();
 
     // If any actions is marked as fixing a diagnostic, hide other actions
@@ -556,16 +570,6 @@ fn fix_all(
     })?;
     let should_format = file_features.supports_format();
 
-    if session.workspace.is_path_ignored(PathIsIgnoredParams {
-        path: path.clone(),
-        is_dir: false,
-        project_key: doc.project_key,
-        features: analyzer_features,
-        ignore_kind: IgnoreKind::Ancestors,
-    })? {
-        return Ok(None);
-    }
-
     let size_limit_result = session.workspace.check_file_size(CheckFileSizeParams {
         project_key: doc.project_key,
         path: path.clone(),
@@ -701,3 +705,45 @@ fn fix_all(
         data: None,
     })))
 }
+
+fn config_migrate_code_action(
+    session: &Session,
+    url: &Uri,
+    path: &BiomePath,
+    line_index: &LineIndex,
+    position_encoding: biome_lsp_converters::PositionEncoding,
+    filters: &[&str],
+    project_key: biome_service::projects::ProjectKey,
+) -> Result<Option<CodeActionOrCommand>, Error> {
+    if !path.is_config() {
+        return Ok(None);
+    }
+
+    if !filters.is_empty()
+        && !filters
+            .iter()
+            .any(|filter| CONFIG_MIGRATE_QUICKFIX_CATEGORY.matches(filter))
+    {
+        return Ok(None);
+    }
+
+    let Some(action) = session
+        .workspace
+        .pull_configuration_actions(PullConfigurationActionsParams {
+            project_key,
+            path: path.clone(),
+        })?
+        .actions
+        .into_iter()
+        .next()
+    else {
+        return Ok(None);
+    };
+
+    Ok(
+        utils::code_fix_to_lsp(url, line_index, position_encoding, &[], action)
+            .ok()
+            .flatten()
+            .map(CodeActionOrCommand::CodeAction),
+    )
+}
diff --git a/crates/biome_lsp/src/handlers/text_document.rs b/crates/biome_lsp/src/handlers/text_document.rs
@@ -3,15 +3,22 @@ use crate::session::ConfigurationStatus;
 use crate::utils::apply_document_changes;
 use crate::{documents::Document, session::Session};
 use biome_configuration::ConfigurationPathHint;
+use biome_fs::ConfigName;
 use biome_service::workspace::{
     ChangeFileParams, CloseFileParams, DocumentFileSource, FeaturesBuilder, FileContent,
-    GetFileContentParams, IgnoreKind, OpenFileParams, PathIsIgnoredParams, ProjectKey,
+    GetFileContentParams, IgnoreKind, OpenFileParams, OpenProjectParams, OpenProjectResult,
+    PathIsIgnoredParams, ProjectKey, ScanKind,
 };
 use camino::{Utf8Path, Utf8PathBuf};
 use std::sync::Arc;
 use tower_lsp_server::ls_types as lsp;
 use tracing::{debug, error, field, info, trace};
 
+fn is_biome_configuration_file(path: &Utf8PathBuf) -> bool {
+    path.file_name()
+        .is_some_and(|file_name| ConfigName::file_names().contains(&file_name))
+}
+
 /// Handler for `textDocument/didOpen` LSP notification
 #[tracing::instrument(
     level = "debug",
@@ -124,6 +131,33 @@ async fn ensure_project_for_opened_document(
             error!("Could not find project for {path}");
             None
         })
+    } else if is_biome_configuration_file(&path.to_path_buf()) {
+        let project_path = path
+            .parent()
+            .map(|parent| parent.to_path_buf())
+            .unwrap_or_default();
+        let OpenProjectResult { project_key } =
+            match session.workspace.open_project(OpenProjectParams {
+                path: project_path.as_path().into(),
+                open_uninitialized: true,
+            }) {
+                Ok(result) => result,
+                Err(error) => {
+                    error!("Could not open fallback project for {path}: {error}");
+                    return None;
+                }
+            };
+
+        session
+            .insert_and_scan_project(
+                project_key,
+                project_path.into(),
+                ScanKind::KnownFiles,
+                false,
+            )
+            .await;
+
+        Some(project_key)
     } else {
         error!("Configuration could not be loaded for {path}");
         None