diff --git a/.gitignore b/.gitignore
index 15a86b6aa4e..5fdead1c773 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@ Profile-*.json
 # Ignore third-party files
 **/node_modules
 **/dist
+**/build
 npm/cli-*
 .pnpm-debug.log
 
diff --git a/Cargo.lock b/Cargo.lock
index a113a247030..3c468fb1d54 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1654,6 +1654,7 @@ dependencies = [
  "crossbeam",
  "dashmap",
  "hdrhistogram",
+ "indexmap",
  "insta",
  "lazy_static",
  "libc",
@@ -1828,6 +1829,7 @@ dependencies = [
  "indexmap",
  "parking_lot",
  "rayon",
+ "rome_console",
  "rome_diagnostics",
  "schemars",
  "serde",
diff --git a/crates/rome_cli/Cargo.toml b/crates/rome_cli/Cargo.toml
index 8130a884ddc..841c81c52e8 100644
--- a/crates/rome_cli/Cargo.toml
+++ b/crates/rome_cli/Cargo.toml
@@ -41,6 +41,7 @@ rome_json_formatter = { path = "../rome_json_formatter" }
 rome_json_syntax = { path = "../rome_json_syntax" }
 rome_migrate = { path = "../rome_migrate" }
 rome_rowan = { path = "../rome_rowan" }
+indexmap = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.127"
diff --git a/crates/rome_cli/src/commands/check.rs b/crates/rome_cli/src/commands/check.rs
index 01cfa41205b..7d89826082f 100644
--- a/crates/rome_cli/src/commands/check.rs
+++ b/crates/rome_cli/src/commands/check.rs
@@ -1,5 +1,8 @@
 use crate::configuration::load_configuration;
-use crate::parse_arguments::{apply_files_settings_from_cli, apply_format_settings_from_cli};
+use crate::parse_arguments::{
+    apply_files_settings_from_cli, apply_format_settings_from_cli, apply_vcs_settings_from_cli,
+};
+use crate::vcs::store_path_to_ignore_from_vcs;
 use crate::{execute_mode, CliDiagnostic, CliSession, Execution, TraversalMode};
 use rome_console::{markup, ConsoleExt};
 use rome_diagnostics::{DiagnosticExt, PrintDiagnostic, Severity};
@@ -7,7 +10,8 @@ use rome_service::workspace::{FixFileMode, UpdateSettingsParams};
 
 /// Handler for the "check" command of the Rome CLI
 pub(crate) fn check(mut session: CliSession) -> Result<(), CliDiagnostic> {
-    let (mut configuration, diagnostics, _) = load_configuration(&mut session)?.consume();
+    let (mut configuration, diagnostics, configuration_path) =
+        load_configuration(&mut session)?.consume();
     if !diagnostics.is_empty() {
         let console = &mut session.app.console;
         console.log(markup!{
@@ -22,6 +26,11 @@ pub(crate) fn check(mut session: CliSession) -> Result<(), CliDiagnostic> {
     }
     apply_files_settings_from_cli(&mut session, &mut configuration)?;
     apply_format_settings_from_cli(&mut session, &mut configuration)?;
+    apply_vcs_settings_from_cli(&mut session, &mut configuration)?;
+
+    // check if support of git ignore files is enabled
+    let vcs_base_path = configuration_path.or(session.app.fs.working_directory());
+    store_path_to_ignore_from_vcs(&mut session, &mut configuration, vcs_base_path)?;
 
     session
         .app
diff --git a/crates/rome_cli/src/commands/ci.rs b/crates/rome_cli/src/commands/ci.rs
index fcb4d9b5d66..010c72029c8 100644
--- a/crates/rome_cli/src/commands/ci.rs
+++ b/crates/rome_cli/src/commands/ci.rs
@@ -1,4 +1,7 @@
-use crate::parse_arguments::{apply_files_settings_from_cli, apply_format_settings_from_cli};
+use crate::parse_arguments::{
+    apply_files_settings_from_cli, apply_format_settings_from_cli, apply_vcs_settings_from_cli,
+};
+use crate::vcs::store_path_to_ignore_from_vcs;
 use crate::{
     configuration::load_configuration, execute_mode, CliDiagnostic, CliSession, Execution,
     TraversalMode,
@@ -11,7 +14,8 @@ use rome_service::workspace::UpdateSettingsParams;
 
 /// Handler for the "ci" command of the Rome CLI
 pub(crate) fn ci(mut session: CliSession) -> Result<(), CliDiagnostic> {
-    let (mut configuration, diagnostics, _) = load_configuration(&mut session)?.consume();
+    let (mut configuration, diagnostics, configuration_path) =
+        load_configuration(&mut session)?.consume();
 
     if !diagnostics.is_empty() {
         let console = &mut session.app.console;
@@ -77,6 +81,12 @@ pub(crate) fn ci(mut session: CliSession) -> Result<(), CliDiagnostic> {
         apply_format_settings_from_cli(&mut session, &mut configuration)?;
     }
 
+    apply_vcs_settings_from_cli(&mut session, &mut configuration)?;
+
+    // check if support of git ignore files is enabled
+    let vcs_base_path = configuration_path.or(session.app.fs.working_directory());
+    store_path_to_ignore_from_vcs(&mut session, &mut configuration, vcs_base_path)?;
+
     session
         .app
         .workspace
diff --git a/crates/rome_cli/src/commands/format.rs b/crates/rome_cli/src/commands/format.rs
index f467942d1bb..f8843bbce12 100644
--- a/crates/rome_cli/src/commands/format.rs
+++ b/crates/rome_cli/src/commands/format.rs
@@ -1,6 +1,9 @@
 use crate::configuration::load_configuration;
 use crate::execute::ReportMode;
-use crate::parse_arguments::{apply_files_settings_from_cli, apply_format_settings_from_cli};
+use crate::parse_arguments::{
+    apply_files_settings_from_cli, apply_format_settings_from_cli, apply_vcs_settings_from_cli,
+};
+use crate::vcs::store_path_to_ignore_from_vcs;
 use crate::{execute_mode, CliDiagnostic, CliSession, Execution, TraversalMode};
 use rome_console::{markup, ConsoleExt};
 use rome_diagnostics::{DiagnosticExt, PrintDiagnostic, Severity};
@@ -9,7 +12,8 @@ use std::path::PathBuf;
 
 /// Handler for the "format" command of the Rome CLI
 pub(crate) fn format(mut session: CliSession) -> Result<(), CliDiagnostic> {
-    let (mut configuration, diagnostics, _) = load_configuration(&mut session)?.consume();
+    let (mut configuration, diagnostics, configuration_path) =
+        load_configuration(&mut session)?.consume();
     if !diagnostics.is_empty() {
         let console = &mut session.app.console;
         console.log(markup!{
@@ -25,7 +29,11 @@ pub(crate) fn format(mut session: CliSession) -> Result<(), CliDiagnostic> {
 
     apply_files_settings_from_cli(&mut session, &mut configuration)?;
     apply_format_settings_from_cli(&mut session, &mut configuration)?;
+    apply_vcs_settings_from_cli(&mut session, &mut configuration)?;
 
+    // check if support of git ignore files is enabled
+    let vcs_base_path = configuration_path.or(session.app.fs.working_directory());
+    store_path_to_ignore_from_vcs(&mut session, &mut configuration, vcs_base_path)?;
     session
         .app
         .workspace
diff --git a/crates/rome_cli/src/commands/help.rs b/crates/rome_cli/src/commands/help.rs
index 55149021740..b66cbec457c 100644
--- a/crates/rome_cli/src/commands/help.rs
+++ b/crates/rome_cli/src/commands/help.rs
@@ -22,8 +22,8 @@ const MAIN: Markup = markup! {
     "<Dim>"--colors=<off|force>"</Dim>"     Set the formatting mode for markup: \"off\" prints everything as plain text, \"force\" forces the formatting of markup using ANSI even if the console output is determined to be incompatible
     "<Dim>"--use-server"</Dim>"             Connect to a running instance of the Rome daemon server
     "<Dim>"--version"</Dim>"                Show the Rome version information and quit
-    "<Dim>"--files-max-size"</Dim>"         The maximum allowed size for source code files in bytes (default: 1MB)
-"
+    "<Dim>"--files-max-size"</Dim>"         The maximum allowed size for source code files in bytes (default: 1MB)"
+{VCS_OPTIONS}
 };
 
 const CHECK: Markup = markup! {
@@ -46,6 +46,7 @@ const CHECK: Markup = markup! {
     "<Dim>"--config-path"</Dim>"                 Set the filesystem path to the directory of the rome.json configuration file
     "<Dim>"--verbose"</Dim>"                     Print additional verbose advices on diagnostics
 "
+    {VCS_OPTIONS}
 };
 
 const FORMAT_OPTIONS: Markup = markup! {
@@ -60,6 +61,16 @@ const FORMAT_OPTIONS: Markup = markup! {
     "
 };
 
+const VCS_OPTIONS: Markup = markup! {
+    "
+    "<Dim>"--vcs-enabled <true|false>"</Dim>"              Whether Rome should integrate itself with the VCS client
+    "<Dim>"--vcs-client-kind <git>"</Dim>"                 The name of the client
+    "<Dim>"--vcs-use-ignore-file <true|false>"</Dim>"      Whether Rome should ignore the paths inside the ignore file
+    "<Dim>"--vcs-root <string>"</Dim>"                     Where Rome should look for VCS files. If a rome.json is present, Rome will append this root to the path of where
+rome.json is.
+    "
+};
+
 const CI: Markup = markup! {
 "Rome CI: Run the linter and formatter check on a set of files
 
@@ -74,13 +85,14 @@ const CI: Markup = markup! {
     rome ci ./src ./internal ./scripts
 
 "<Emphasis>"OPTIONS:"</Emphasis>"
-    "<Dim>"--formatter-enabled"</Dim>"                      Allow to enable or disable the formatter check. (default: true)
-    "<Dim>"--linter-enabled"</Dim>"                         Allow to enable or disable the linter check. (default: true)
-    "<Dim>"--organize-imports-enabled"</Dim>"               Allow to enable or disable the organize imports. (default: true)
+    "<Dim>"--formatter-enabled <true|false>"</Dim>"                      Allow to enable or disable the formatter check. (default: true)
+    "<Dim>"--linter-enabled <true|false>"</Dim>"                         Allow to enable or disable the linter check. (default: true)
+    "<Dim>"--organize-imports-enabled <true|false>"</Dim>"               Allow to enable or disable the organize imports. (default: true)
     "<Dim>"--max-diagnostics"</Dim>"                        Cap the amount of diagnostics displayed (default: 50)
     "<Dim>"--config-path"</Dim>"                            Set the filesystem path to the directory of the rome.json configuration file
     "<Dim>"--verbose"</Dim>"                                Print additional verbose advices on diagnostics"
     {FORMAT_OPTIONS}
+    {VCS_OPTIONS}
 };
 
 const FORMAT: Markup = markup! {
@@ -101,10 +113,10 @@ const FORMAT: Markup = markup! {
     "<Dim>"--skip-errors"</Dim>"                            Skip over files containing syntax errors instead of emitting an error diagnostic.
     "<Dim>"--max-diagnostics"</Dim>"                        Cap the amount of diagnostics displayed (default: 50)
     "<Dim>"--config-path"</Dim>"                            Set the filesystem path to the directory of the rome.json configuration file
-    "<Dim>"--verbose"</Dim>"                                Print additional verbose advices on diagnostics"
+    "<Dim>"--verbose"</Dim>"                                Print additional verbose advices on diagnostics
+    "<Dim>"--stdin-file-path <string>"</Dim>"               A file name with its extension to pass when reading from standard in, e.g. echo 'let a;' | rome format --stdin-file-path file.js"
     {FORMAT_OPTIONS}
-   ""<Dim>"--stdin-file-path <string>"</Dim>"               A file name with its extension to pass when reading from standard in, e.g. echo 'let a;' | rome format --stdin-file-path file.js
-"
+    {VCS_OPTIONS}
 };
 
 const INIT: Markup = markup! {
diff --git a/crates/rome_cli/src/commands/migrate.rs b/crates/rome_cli/src/commands/migrate.rs
index df799dca695..6be64cc484d 100644
--- a/crates/rome_cli/src/commands/migrate.rs
+++ b/crates/rome_cli/src/commands/migrate.rs
@@ -6,11 +6,12 @@ use crate::{CliDiagnostic, CliSession};
 /// Handler for the "check" command of the Rome CLI
 pub(crate) fn migrate(mut session: CliSession) -> Result<(), CliDiagnostic> {
     let (_, _, path) = load_configuration(&mut session)?.consume();
+    let config_name = session.app.fs.config_name();
     if let Some(path) = path {
         execute_mode(
             Execution::new(TraversalMode::Migrate {
                 write: session.args.contains("--dry-run"),
-                configuration_path: path,
+                configuration_path: path.join(config_name),
             }),
             session,
         )
diff --git a/crates/rome_cli/src/commands/rage.rs b/crates/rome_cli/src/commands/rage.rs
index 4bccfb0397b..ed980e33e09 100644
--- a/crates/rome_cli/src/commands/rage.rs
+++ b/crates/rome_cli/src/commands/rage.rs
@@ -187,6 +187,7 @@ impl Display for RageConfiguration<'_, '_> {
                     {KeyValuePair("Formatter disabled", markup!({DebugDisplay(configuration.is_formatter_disabled())}))}
                     {KeyValuePair("Linter disabled", markup!({DebugDisplay(configuration.is_linter_disabled())}))}
                     {KeyValuePair("Organize imports disabled", markup!({DebugDisplay(configuration.is_organize_imports_disabled())}))}
+                    {KeyValuePair("VCS disabled", markup!({DebugDisplay(configuration.is_vcs_disabled())}))}
                 ).fmt(fmt)?
             }
             Err(err) => markup! (
diff --git a/crates/rome_cli/src/diagnostics.rs b/crates/rome_cli/src/diagnostics.rs
index ae0a8a99587..19f1962661a 100644
--- a/crates/rome_cli/src/diagnostics.rs
+++ b/crates/rome_cli/src/diagnostics.rs
@@ -54,6 +54,8 @@ pub enum CliDiagnostic {
     NoFilesWereProcessed(NoFilesWereProcessed),
     /// Errors thrown when running the `rome migrate` command
     MigrateError(MigrationDiagnostic),
+    /// When the VCS folder couldn't be found
+    NoVcsFolderFound(NoVcsFolderFound),
 }
 
 #[derive(Debug, Diagnostic)]
@@ -273,6 +275,31 @@ pub struct MigrationDiagnostic {
     pub reason: String,
 }
 
+#[derive(Debug, Diagnostic)]
+#[diagnostic(
+    category = "internalError/fs",
+    severity = Error,
+    message(
+		description = "Rome couldn't find the VCS folder at the following path: {path}",
+		message("Rome couldn't find the VCS folder at the following path: "<Emphasis>{self.path}</Emphasis>),
+	)
+)]
+pub struct NoVcsFolderFound {
+    #[location(resource)]
+    pub path: String,
+
+    #[source]
+    pub source: Option<Error>,
+}
+
+#[derive(Debug, Diagnostic)]
+#[diagnostic(
+	category = "internalError/fs",
+	severity = Warning,
+	message = "Rome couldn't determine a directory for the VCS integration. VCS integration will be disabled."
+)]
+pub struct DisabledVcs {}
+
 /// Advices for the [CliDiagnostic]
 #[derive(Debug, Default)]
 struct CliAdvice {
@@ -438,6 +465,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.category(),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.category(),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.category(),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.category(),
         }
     }
 
@@ -459,6 +487,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.tags(),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.tags(),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.tags(),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.tags(),
         }
     }
 
@@ -480,6 +509,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.severity(),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.severity(),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.severity(),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.severity(),
         }
     }
 
@@ -501,6 +531,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.location(),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.location(),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.location(),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.location(),
         }
     }
 
@@ -522,6 +553,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.message(fmt),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.message(fmt),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.message(fmt),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.message(fmt),
         }
     }
 
@@ -543,6 +575,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.description(fmt),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.description(fmt),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.description(fmt),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.description(fmt),
         }
     }
 
@@ -564,6 +597,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.advices(visitor),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.advices(visitor),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.advices(visitor),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.advices(visitor),
         }
     }
 
@@ -589,6 +623,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.verbose_advices(visitor),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.verbose_advices(visitor),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.verbose_advices(visitor),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.verbose_advices(visitor),
         }
     }
 
@@ -610,6 +645,7 @@ impl Diagnostic for CliDiagnostic {
             CliDiagnostic::NoFilesWereProcessed(diagnostic) => diagnostic.source(),
             CliDiagnostic::FileCheckApply(diagnostic) => diagnostic.source(),
             CliDiagnostic::MigrateError(diagnostic) => diagnostic.source(),
+            CliDiagnostic::NoVcsFolderFound(diagnostic) => diagnostic.source(),
         }
     }
 }
diff --git a/crates/rome_cli/src/lib.rs b/crates/rome_cli/src/lib.rs
index 506850d4544..9afbe98380e 100644
--- a/crates/rome_cli/src/lib.rs
+++ b/crates/rome_cli/src/lib.rs
@@ -22,6 +22,7 @@ mod panic;
 mod parse_arguments;
 mod reports;
 mod service;
+mod vcs;
 
 pub use diagnostics::CliDiagnostic;
 pub(crate) use execute::{execute_mode, Execution, TraversalMode};
diff --git a/crates/rome_cli/src/parse_arguments.rs b/crates/rome_cli/src/parse_arguments.rs
index 1e4b8ab9538..b16542592c8 100644
--- a/crates/rome_cli/src/parse_arguments.rs
+++ b/crates/rome_cli/src/parse_arguments.rs
@@ -1,5 +1,6 @@
 use crate::{CliDiagnostic, CliSession};
 use rome_formatter::IndentStyle;
+use rome_service::configuration::vcs::{VcsClientKind, VcsConfiguration};
 use rome_service::configuration::{
     FormatterConfiguration, JavascriptConfiguration, JavascriptFormatter, PlainIndentStyle,
 };
@@ -107,3 +108,46 @@ pub(crate) fn apply_files_settings_from_cli(
 
     Ok(())
 }
+
+pub(crate) fn apply_vcs_settings_from_cli(
+    session: &mut CliSession,
+    configuration: &mut Configuration,
+) -> Result<(), CliDiagnostic> {
+    let vcs = configuration
+        .vcs
+        .get_or_insert_with(VcsConfiguration::default);
+
+    let enabled = session
+        .args
+        .opt_value_from_str("--vcs-enabled")
+        .map_err(|source| CliDiagnostic::parse_error("--vcs-enabled", source))?;
+    let client_kind = session
+        .args
+        .opt_value_from_str("--vcs-client-kind")
+        .map_err(|source| CliDiagnostic::parse_error("--vcs-client-kind", source))?;
+
+    let use_ignore_file = session
+        .args
+        .opt_value_from_str("--vcs-use-ignore-file")
+        .map_err(|source| CliDiagnostic::parse_error("--vcs-use-ignore-file", source))?;
+    let root = session
+        .args
+        .opt_value_from_str("--vcs-root")
+        .map_err(|source| CliDiagnostic::parse_error("--vcs-root", source))?;
+
+    if let Some(enabled) = enabled {
+        vcs.enabled = enabled;
+    }
+
+    match client_kind {
+        None => {}
+        Some(VcsClientKind::Git) => {
+            vcs.client_kind = Some(VcsClientKind::Git);
+        }
+    }
+
+    vcs.use_ignore_file = use_ignore_file;
+    vcs.root = root;
+
+    Ok(())
+}
diff --git a/crates/rome_cli/src/vcs.rs b/crates/rome_cli/src/vcs.rs
new file mode 100644
index 00000000000..32f46047d5c
--- /dev/null
+++ b/crates/rome_cli/src/vcs.rs
@@ -0,0 +1,98 @@
+use crate::diagnostics::{DisabledVcs, NoVcsFolderFound};
+use crate::{CliDiagnostic, CliSession};
+use indexmap::IndexSet;
+use rome_console::{markup, ConsoleExt};
+use rome_diagnostics::PrintDiagnostic;
+use rome_service::configuration::vcs::{VcsClientKind, VcsConfiguration};
+use rome_service::configuration::FilesConfiguration;
+use rome_service::{Configuration, WorkspaceError};
+use std::path::PathBuf;
+
+/// This function will check if the configuration is set to use the VCS integration and try to
+/// read the ignored files.
+pub(crate) fn store_path_to_ignore_from_vcs(
+    session: &mut CliSession,
+    configuration: &mut Configuration,
+    vcs_base_path: Option<PathBuf>,
+) -> Result<(), CliDiagnostic> {
+    let verbose = session.args.contains("--verbose");
+    let Some(vcs) = &configuration.vcs else {
+		return Ok(())
+	};
+    if vcs.enabled {
+        let vcs_base_path = match (vcs_base_path, &vcs.root) {
+            (Some(vcs_base_path), Some(root)) => vcs_base_path.join(root),
+            (None, Some(root)) => PathBuf::from(root),
+            (Some(vcs_base_path), None) => vcs_base_path,
+            (None, None) => {
+                let console = &mut session.app.console;
+                let diagnostic = DisabledVcs {};
+                console.error(markup! {
+					{if verbose { PrintDiagnostic::verbose(&diagnostic) } else { PrintDiagnostic::simple(&diagnostic) }}
+                });
+                return Ok(());
+            }
+        };
+
+        let files_to_ignore = read_vcs_ignore_file(session, vcs_base_path, vcs)?;
+
+        if !files_to_ignore.is_empty() {
+            let files = configuration
+                .files
+                .get_or_insert_with(FilesConfiguration::default);
+            let ignored_files = files.ignore.get_or_insert_with(IndexSet::new);
+            ignored_files.extend(files_to_ignore.into_iter());
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn read_vcs_ignore_file(
+    session: &mut CliSession,
+    current_directory: PathBuf,
+    configuration: &VcsConfiguration,
+) -> Result<Vec<String>, CliDiagnostic> {
+    if !configuration.enabled {
+        return Ok(vec![]);
+    }
+    let file_system = &session.app.fs;
+
+    if let Some(client_kind) = &configuration.client_kind {
+        match client_kind {
+            VcsClientKind::Git => {
+                let git_folder = current_directory.join(".git");
+
+                if !file_system.path_exists(git_folder.as_path()) {
+                    return Err(CliDiagnostic::NoVcsFolderFound(NoVcsFolderFound {
+                        path: git_folder.display().to_string(),
+                        source: None,
+                    }));
+                }
+            }
+        }
+        if !configuration.ignore_file_disabled() {
+            let buffer = file_system
+                .auto_search(current_directory, client_kind.ignore_file(), false)
+                .map_err(WorkspaceError::from)?;
+
+            if let Some((buffer, _)) = buffer {
+                return Ok(buffer
+                    .split('\n')
+                    // remove empty lines
+                    .filter(|line| !line.is_empty())
+                    .filter_map(|item| {
+                        let line = item.to_string();
+                        // remove comments
+                        if !line.starts_with('#') {
+                            Some(line)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<String>>());
+            }
+        }
+    }
+
+    Ok(vec![])
+}
diff --git a/crates/rome_cli/tests/commands/check.rs b/crates/rome_cli/tests/commands/check.rs
index 6d4112d350b..9a147c7873a 100644
--- a/crates/rome_cli/tests/commands/check.rs
+++ b/crates/rome_cli/tests/commands/check.rs
@@ -1777,3 +1777,113 @@ fn ignore_configured_globals() {
         result,
     ));
 }
+
+#[test]
+fn ignore_vcs_ignored_file() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let rome_json = r#"{
+        "vcs": {
+            "enabled": true,
+            "clientKind": "git",
+            "useIgnoreFile": true
+        }
+    }"#;
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call(); bar.call();"#;
+    let code1 = r#"array.map(sentence => sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // configuration
+    let config_path = Path::new("rome.json");
+    fs.insert(config_path.into(), rome_json.as_bytes());
+
+    // git folder
+    let git_folder = Path::new(".git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new(".gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("check"),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn ignore_vcs_ignored_file_via_cli() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call(); bar.call();"#;
+    let code1 = r#"array.map(sentence => sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // git folder
+    let git_folder = Path::new("./.git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new("./.gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("check"),
+            OsString::from("--vcs-enabled=true"),
+            OsString::from("--vcs-client-kind=git"),
+            OsString::from("--vcs-use-ignore-file=true"),
+            OsString::from("--vcs-root=."),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file_via_cli",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/commands/ci.rs b/crates/rome_cli/tests/commands/ci.rs
index de02ec26810..e24f138553b 100644
--- a/crates/rome_cli/tests/commands/ci.rs
+++ b/crates/rome_cli/tests/commands/ci.rs
@@ -744,3 +744,116 @@ something( )
         result,
     ));
 }
+
+#[test]
+fn ignore_vcs_ignored_file() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let rome_json = r#"{
+        "vcs": {
+            "enabled": true,
+            "clientKind": "git",
+            "useIgnoreFile": true
+        }
+    }"#;
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call(); bar.call();"#;
+    let code1 = r#"array.map(sentence => sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // configuration
+    let config_path = Path::new("rome.json");
+    fs.insert(config_path.into(), rome_json.as_bytes());
+
+    // git folder
+    let git_folder = Path::new(".git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new(".gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("ci"),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn ignore_vcs_ignored_file_via_cli() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call();
+
+
+	bar.call();"#;
+    let code1 = r#"array.map(sentence => sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // git folder
+    let git_folder = Path::new("./.git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new("./.gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("ci"),
+            OsString::from("--vcs-enabled=true"),
+            OsString::from("--vcs-client-kind=git"),
+            OsString::from("--vcs-use-ignore-file=true"),
+            OsString::from("--vcs-root=."),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file_via_cli",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/commands/format.rs b/crates/rome_cli/tests/commands/format.rs
index 2792c456a3c..590c20f0580 100644
--- a/crates/rome_cli/tests/commands/format.rs
+++ b/crates/rome_cli/tests/commands/format.rs
@@ -1535,3 +1535,127 @@ fn print_verbose() {
         result,
     ));
 }
+
+#[test]
+fn ignore_vcs_ignored_file() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let rome_json = r#"{
+        "vcs": {
+            "enabled": true,
+            "clientKind": "git",
+            "useIgnoreFile": true
+        }
+    }"#;
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call();
+
+
+	bar.call();"#;
+    let code1 = r#"array.map(sentence =>
+
+
+	sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // configuration
+    let config_path = Path::new("rome.json");
+    fs.insert(config_path.into(), rome_json.as_bytes());
+
+    // git folder
+    let git_folder = Path::new(".git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new(".gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("format"),
+            OsString::from("--write"),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn ignore_vcs_ignored_file_via_cli() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let git_ignore = r#"
+file2.js
+"#;
+
+    let code2 = r#"foo.call();
+
+
+	bar.call();"#;
+    let code1 = r#"array.map(sentence =>
+
+
+	sentence.split(' ')).flat();"#;
+
+    // ignored files
+    let file_path1 = Path::new("file1.js");
+    fs.insert(file_path1.into(), code1.as_bytes());
+    let file_path2 = Path::new("file2.js");
+    fs.insert(file_path2.into(), code2.as_bytes());
+
+    // git folder
+    let git_folder = Path::new("./.git");
+    fs.insert(git_folder.into(), "".as_bytes());
+
+    // git ignore file
+    let ignore_file = Path::new("./.gitignore");
+    fs.insert(ignore_file.into(), git_ignore.as_bytes());
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("format"),
+            OsString::from("--vcs-enabled=true"),
+            OsString::from("--vcs-client-kind=git"),
+            OsString::from("--vcs-use-ignore-file=true"),
+            OsString::from("--vcs-root=."),
+            OsString::from("--write"),
+            file_path1.as_os_str().into(),
+            file_path2.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "ignore_vcs_ignored_file_via_cli",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file.snap b/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file.snap
new file mode 100644
index 00000000000..2f31e89ec92
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file.snap
@@ -0,0 +1,76 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `rome.json`
+
+```json
+{
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  }
+}
+```
+
+## `.git`
+
+```git
+
+```
+
+## `.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map(sentence => sentence.split(' ')).flat();
+```
+
+## `file2.js`
+
+```js
+foo.call(); bar.call();
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file1.js:1:1 lint/complexity/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The call chain .map().flat() can be replaced with a single .flatMap() call.
+  
+  > 1 │ array.map(sentence => sentence.split(' ')).flat();
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+  i Safe fix: Replace the chain with .flatMap().
+  
+  - array.map(sentence·=>·sentence.split('·')).flat();
+  + array.flatMap(sentence·=>·sentence.split('·'));
+  
+
+```
+
+```block
+Checked 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file_via_cli.snap b/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file_via_cli.snap
new file mode 100644
index 00000000000..eb29b67f1e6
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_check/ignore_vcs_ignored_file_via_cli.snap
@@ -0,0 +1,64 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `./.git`
+
+```git
+
+```
+
+## `./.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map(sentence => sentence.split(' ')).flat();
+```
+
+## `file2.js`
+
+```js
+foo.call(); bar.call();
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file1.js:1:1 lint/complexity/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The call chain .map().flat() can be replaced with a single .flatMap() call.
+  
+  > 1 │ array.map(sentence => sentence.split(' ')).flat();
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+  i Safe fix: Replace the chain with .flatMap().
+  
+  - array.map(sentence·=>·sentence.split('·')).flat();
+  + array.flatMap(sentence·=>·sentence.split('·'));
+  
+
+```
+
+```block
+Checked 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file.snap b/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file.snap
new file mode 100644
index 00000000000..2f31e89ec92
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file.snap
@@ -0,0 +1,76 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `rome.json`
+
+```json
+{
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  }
+}
+```
+
+## `.git`
+
+```git
+
+```
+
+## `.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map(sentence => sentence.split(' ')).flat();
+```
+
+## `file2.js`
+
+```js
+foo.call(); bar.call();
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file1.js:1:1 lint/complexity/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The call chain .map().flat() can be replaced with a single .flatMap() call.
+  
+  > 1 │ array.map(sentence => sentence.split(' ')).flat();
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+  i Safe fix: Replace the chain with .flatMap().
+  
+  - array.map(sentence·=>·sentence.split('·')).flat();
+  + array.flatMap(sentence·=>·sentence.split('·'));
+  
+
+```
+
+```block
+Checked 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file_via_cli.snap b/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file_via_cli.snap
new file mode 100644
index 00000000000..58ebf3be5e5
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_ci/ignore_vcs_ignored_file_via_cli.snap
@@ -0,0 +1,67 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `./.git`
+
+```git
+
+```
+
+## `./.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map(sentence => sentence.split(' ')).flat();
+```
+
+## `file2.js`
+
+```js
+foo.call();
+
+
+	bar.call();
+```
+
+# Termination Message
+
+```block
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file1.js:1:1 lint/complexity/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The call chain .map().flat() can be replaced with a single .flatMap() call.
+  
+  > 1 │ array.map(sentence => sentence.split(' ')).flat();
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+  i Safe fix: Replace the chain with .flatMap().
+  
+  - array.map(sentence·=>·sentence.split('·')).flat();
+  + array.flatMap(sentence·=>·sentence.split('·'));
+  
+
+```
+
+```block
+Checked 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file.snap b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file.snap
new file mode 100644
index 00000000000..51687473457
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file.snap
@@ -0,0 +1,53 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `rome.json`
+
+```json
+{
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  }
+}
+```
+
+## `.git`
+
+```git
+
+```
+
+## `.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map((sentence) => sentence.split(" ")).flat();
+
+```
+
+## `file2.js`
+
+```js
+foo.call();
+
+
+	bar.call();
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file_via_cli.snap b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file_via_cli.snap
new file mode 100644
index 00000000000..eec0661b0f8
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_vcs_ignored_file_via_cli.snap
@@ -0,0 +1,41 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `./.git`
+
+```git
+
+```
+
+## `./.gitignore`
+
+```gitignore
+
+file2.js
+
+```
+
+## `file1.js`
+
+```js
+array.map((sentence) => sentence.split(" ")).flat();
+
+```
+
+## `file2.js`
+
+```js
+foo.call();
+
+
+	bar.call();
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/invalid_config_file_path.snap b/crates/rome_cli/tests/snapshots/main_commands_format/invalid_config_file_path.snap
index 24c239b348a..42178ae1d4d 100644
--- a/crates/rome_cli/tests/snapshots/main_commands_format/invalid_config_file_path.snap
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/invalid_config_file_path.snap
@@ -13,7 +13,7 @@ content
 ```block
 test/rome.json internalError/fs ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Rome couldn't read the following file, maybe for permissions reasons or it doesn't exists: test/rome.json
+  × Rome couldn't read the file
   
 
 
diff --git a/crates/rome_cli/tests/snapshots/main_commands_rage/with_configuration.snap b/crates/rome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
index c719ef4d9e3..5dc79bc8838 100644
--- a/crates/rome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
+++ b/crates/rome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
@@ -36,6 +36,7 @@ Rome Configuration:
   Formatter disabled:           true
   Linter disabled:              false
   Organize imports disabled:    true
+  VCS disabled:                 true
 
 Server:
   Version:                      0.0.0
diff --git a/crates/rome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap b/crates/rome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
index 8d4bafc5e2b..0b26a9a55a4 100644
--- a/crates/rome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
+++ b/crates/rome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
@@ -37,6 +37,7 @@ Rome Configuration:
   Formatter disabled:           false
   Linter disabled:              false
   Organize imports disabled:    true
+  VCS disabled:                 true
 
 Server:
   Version:                      0.0.0
diff --git a/crates/rome_cli/tests/snapshots/main_configuration/incorrect_globals.snap b/crates/rome_cli/tests/snapshots/main_configuration/incorrect_globals.snap
index f4d3be7382c..ddf502e434a 100644
--- a/crates/rome_cli/tests/snapshots/main_configuration/incorrect_globals.snap
+++ b/crates/rome_cli/tests/snapshots/main_configuration/incorrect_globals.snap
@@ -35,7 +35,7 @@ Found errors in the configuration file, Rome will use its defaults for the secti
 ```block
 rome.json:6:17 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  ! Incorrect type, expected a string
+  ! Incorrect type, expected a string.
   
     4 │   },
     5 │   "javascript": {
diff --git a/crates/rome_cli/tests/snapshots/main_configuration/incorrect_rule_name.snap b/crates/rome_cli/tests/snapshots/main_configuration/incorrect_rule_name.snap
index a3632d7991e..13809491897 100644
--- a/crates/rome_cli/tests/snapshots/main_configuration/incorrect_rule_name.snap
+++ b/crates/rome_cli/tests/snapshots/main_configuration/incorrect_rule_name.snap
@@ -40,7 +40,7 @@ Found errors in the configuration file, Rome will use its defaults for the secti
 ```block
 rome.json:6:13 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  ! Found an unknown key `foo_rule`
+  ! Found an unknown key `foo_rule`.
   
     4 │     "rules": {
     5 │         "correctness": {
diff --git a/crates/rome_deserialize/src/diagnostics.rs b/crates/rome_deserialize/src/diagnostics.rs
index 0a5a5ae86dd..b4d44046ec9 100644
--- a/crates/rome_deserialize/src/diagnostics.rs
+++ b/crates/rome_deserialize/src/diagnostics.rs
@@ -1,16 +1,13 @@
 use rome_console::fmt::Display;
 use rome_console::{markup, MarkupBuf};
 use rome_diagnostics::location::AsSpan;
-use rome_diagnostics::{Advices, Diagnostic, LogCategory, MessageAndDescription, Visit};
+use rome_diagnostics::{Advices, Diagnostic, LogCategory, MessageAndDescription, Severity, Visit};
 use rome_rowan::{SyntaxError, TextRange};
 use serde::{Deserialize, Serialize};
 
 /// Diagnostic emitted during the deserialization
 #[derive(Debug, Serialize, Clone, Deserialize, Diagnostic)]
-#[diagnostic(
-    category = "deserialize",
-    severity = Error
-)]
+#[diagnostic(category = "deserialize")]
 pub struct DeserializationDiagnostic {
     #[message]
     #[description]
@@ -19,6 +16,8 @@ pub struct DeserializationDiagnostic {
     range: Option<TextRange>,
     #[advice]
     deserialization_advice: DeserializationAdvice,
+    #[severity]
+    severity: Severity,
 }
 
 impl DeserializationDiagnostic {
@@ -27,6 +26,7 @@ impl DeserializationDiagnostic {
             reason: markup! {{reason}}.to_owned().into(),
             range: None,
             deserialization_advice: DeserializationAdvice::default(),
+            severity: Severity::Error,
         }
     }
 
@@ -37,14 +37,14 @@ impl DeserializationDiagnostic {
         range: impl AsSpan,
     ) -> Self {
         Self::new(markup! {
-                "The value of key "<Emphasis>{{key_name}}</Emphasis>" is incorrect. Expected "<Emphasis>{{expected_type}}</Emphasis>
+                "The value of key "<Emphasis>{{key_name}}</Emphasis>" is incorrect. Expected a "<Emphasis>{{expected_type}}"."</Emphasis>
             }).with_range(range)
     }
 
     /// Emitted when a generic node has an incorrect type
     pub fn new_incorrect_type(expected_type: impl Display, range: impl AsSpan) -> Self {
         Self::new(markup! {
-            "Incorrect type, expected a "<Emphasis>{{expected_type}}</Emphasis>
+            "Incorrect type, expected a "<Emphasis>{{expected_type}}"."</Emphasis>
         })
         .with_range(range)
     }
@@ -55,7 +55,7 @@ impl DeserializationDiagnostic {
         range: impl AsSpan,
         known_members: &[&str],
     ) -> Self {
-        Self::new(markup!("Found an unknown key `"<Emphasis>{{ key_name }}</Emphasis>"`" ))
+        Self::new(markup!("Found an unknown key `"<Emphasis>{{ key_name }}</Emphasis>"`." ))
             .with_range(range)
             .note_with_list("Accepted keys", known_members)
     }
@@ -66,9 +66,9 @@ impl DeserializationDiagnostic {
         range: impl AsSpan,
         known_variants: &[&str],
     ) -> Self {
-        Self::new(markup! {"Found an unknown value `"<Emphasis>{{ variant_name }}</Emphasis>"`"})
+        Self::new(markup! {"Found an unknown value `"<Emphasis>{{ variant_name }}</Emphasis>"`."})
             .with_range(range)
-            .note_with_list("Accepted values", known_variants)
+            .note_with_list("Accepted values:", known_variants)
     }
 
     /// Adds a range to the diagnostic
@@ -85,6 +85,12 @@ impl DeserializationDiagnostic {
         self
     }
 
+    /// Changes the severity of the diagnostic
+    pub fn with_custom_severity(mut self, severity: Severity) -> Self {
+        self.severity = severity;
+        self
+    }
+
     /// Adds a note with a list of strings
     pub fn note_with_list(mut self, message: impl Display, list: &[impl Display]) -> Self {
         self.deserialization_advice.notes.push((
diff --git a/crates/rome_deserialize/src/json.rs b/crates/rome_deserialize/src/json.rs
index e7de2ea1c58..b050ba54089 100644
--- a/crates/rome_deserialize/src/json.rs
+++ b/crates/rome_deserialize/src/json.rs
@@ -100,7 +100,7 @@ pub trait VisitJsonNode: VisitNode<JsonLanguage> {
         diagnostics: &mut Vec<DeserializationDiagnostic>,
     ) -> Option<String> {
         JsonStringValue::cast_ref(value.syntax())
-            .map(|node| node.text())
+            .and_then(|node| Some(node.inner_string_text().ok()?.to_string()))
             .or_else(|| {
                 diagnostics.push(DeserializationDiagnostic::new_incorrect_type_for_value(
                     name,
diff --git a/crates/rome_fs/Cargo.toml b/crates/rome_fs/Cargo.toml
index 4e68eab99e2..8f49c116442 100644
--- a/crates/rome_fs/Cargo.toml
+++ b/crates/rome_fs/Cargo.toml
@@ -10,6 +10,7 @@ license = { workspace = true }
 
 [dependencies]
 rome_diagnostics = { path = "../rome_diagnostics" }
+rome_console = { path = "../rome_console" }
 indexmap = { workspace = true }
 parking_lot = { version = "0.12.0", features = ["arc_lock"] }
 rayon = "1.5.1"
diff --git a/crates/rome_fs/src/fs.rs b/crates/rome_fs/src/fs.rs
index c7a209a48e1..a0ae01c3f65 100644
--- a/crates/rome_fs/src/fs.rs
+++ b/crates/rome_fs/src/fs.rs
@@ -1,17 +1,18 @@
+use crate::{PathInterner, RomePath};
+pub use memory::{ErrorEntry, MemoryFileSystem};
+pub use os::OsFileSystem;
+use rome_diagnostics::{console, Advices, Diagnostic, LogCategory, Visit};
+use rome_diagnostics::{Error, Severity};
+use serde::{Deserialize, Serialize};
 use std::io;
 use std::panic::RefUnwindSafe;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-
-use crate::{PathInterner, RomePath};
-use rome_diagnostics::{console, Advices, Diagnostic, LogCategory, Visit};
+use tracing::{error, info};
 
 mod memory;
 mod os;
 
-pub use memory::{ErrorEntry, MemoryFileSystem};
-pub use os::OsFileSystem;
-use rome_diagnostics::Error;
 pub const CONFIG_NAME: &str = "rome.json";
 
 pub trait FileSystem: Send + Sync + RefUnwindSafe {
@@ -31,6 +32,83 @@ pub trait FileSystem: Send + Sync + RefUnwindSafe {
 
     /// Return the path to the working directory
     fn working_directory(&self) -> Option<PathBuf>;
+
+    /// Checks if the given path exists in the file system
+    fn path_exists(&self, path: &Path) -> bool;
+
+    fn auto_search(
+        &self,
+        mut file_path: PathBuf,
+        file_name: &str,
+        should_error_if_file_not_found: bool,
+    ) -> Result<Option<(String, PathBuf)>, FileSystemDiagnostic> {
+        let mut from_parent = false;
+        let mut file_directory_path = file_path.join(file_name);
+        loop {
+            let options = OpenOptions::default().read(true);
+            let file = self.open_with_options(&file_directory_path, options);
+            return match file {
+                Ok(mut file) => {
+                    let mut buffer = String::new();
+                    file.read_to_string(&mut buffer)
+                        .map_err(|_| FileSystemDiagnostic {
+                            path: file_directory_path.display().to_string(),
+                            severity: Severity::Error,
+                            error_kind: ErrorKind::CantReadFile(
+                                file_directory_path.display().to_string(),
+                            ),
+                        })?;
+
+                    if from_parent {
+                        info!(
+                        "Rome auto discovered the file at following path that wasn't in the working directory: {}",
+                        file_path.display()
+                    );
+                    }
+
+                    return Ok(Some((buffer, file_path)));
+                }
+                Err(err) => {
+                    // base paths from users are not eligible for auto discovery
+                    if !should_error_if_file_not_found {
+                        let parent_directory = if let Some(path) = file_path.parent() {
+                            if path.is_dir() {
+                                Some(PathBuf::from(path))
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        };
+                        if let Some(parent_directory) = parent_directory {
+                            file_path = parent_directory;
+                            file_directory_path = file_path.join(file_name);
+                            from_parent = true;
+                            continue;
+                        }
+                    }
+                    // We skip the error when the configuration file is not found.
+                    // Not having a configuration file is only an error when the `base_path` is
+                    // set to `BasePath::FromUser`.
+                    if should_error_if_file_not_found || err.kind() != io::ErrorKind::NotFound {
+                        return Err(FileSystemDiagnostic {
+                            path: file_directory_path.display().to_string(),
+                            severity: Severity::Error,
+                            error_kind: ErrorKind::CantReadFile(
+                                file_directory_path.display().to_string(),
+                            ),
+                        });
+                    }
+                    error!(
+                        "Could not read the file from {:?}, reason:\n {}",
+                        file_directory_path.display(),
+                        err
+                    );
+                    Ok(None)
+                }
+            };
+        }
+    }
 }
 
 pub trait File {
@@ -175,21 +253,29 @@ where
     fn working_directory(&self) -> Option<PathBuf> {
         T::working_directory(self)
     }
+
+    fn path_exists(&self, path: &Path) -> bool {
+        T::path_exists(self, path)
+    }
 }
 
-#[derive(Debug, Diagnostic)]
-#[diagnostic(severity = Warning, category = "internalError/fs")]
-struct FileSystemDiagnostic {
+#[derive(Debug, Diagnostic, Deserialize, Serialize)]
+#[diagnostic(category = "internalError/fs")]
+pub struct FileSystemDiagnostic {
+    #[severity]
+    pub severity: Severity,
     #[location(resource)]
-    path: String,
+    pub path: String,
     #[message]
     #[description]
     #[advice]
-    error_kind: ErrorKind,
+    pub error_kind: ErrorKind,
 }
 
-#[derive(Clone, Debug)]
-enum ErrorKind {
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum ErrorKind {
+    /// File not found
+    CantReadFile(String),
     /// Unknown file type
     UnknownFileType,
     /// Dereferenced (broken) symbolic link
@@ -201,6 +287,7 @@ enum ErrorKind {
 impl console::fmt::Display for ErrorKind {
     fn fmt(&self, fmt: &mut console::fmt::Formatter) -> io::Result<()> {
         match self {
+            ErrorKind::CantReadFile(_) => fmt.write_str("Rome couldn't read the file"),
             ErrorKind::UnknownFileType => fmt.write_str("Unknown file type"),
             ErrorKind::DereferencedSymlink(_) => fmt.write_str("Dereferenced symlink"),
             ErrorKind::InfiniteSymlinkExpansion(_) => fmt.write_str("Infinite symlink expansion"),
@@ -211,6 +298,7 @@ impl console::fmt::Display for ErrorKind {
 impl std::fmt::Display for ErrorKind {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            ErrorKind::CantReadFile(_) => fmt.write_str("Rome couldn't read the file"),
             ErrorKind::UnknownFileType => write!(fmt, "Unknown file type"),
             ErrorKind::DereferencedSymlink(_) => write!(fmt, "Dereferenced symlink"),
             ErrorKind::InfiniteSymlinkExpansion(_) => write!(fmt, "Infinite symlink expansion"),
@@ -221,6 +309,11 @@ impl std::fmt::Display for ErrorKind {
 impl Advices for ErrorKind {
     fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
         match self {
+			ErrorKind::CantReadFile(path) => visitor.record_log(
+		LogCategory::Error,
+			&format!("Rome couldn't read the following file, maybe for permissions reasons or it doesn't exists: {}", path)
+			),
+
             ErrorKind::UnknownFileType => visitor.record_log(
                 LogCategory::Info,
                 &"Rome encountered a file system entry that's neither a file, directory or symbolic link",
diff --git a/crates/rome_fs/src/fs/memory.rs b/crates/rome_fs/src/fs/memory.rs
index b7aa058d798..ff5acfadc1b 100644
--- a/crates/rome_fs/src/fs/memory.rs
+++ b/crates/rome_fs/src/fs/memory.rs
@@ -7,7 +7,7 @@ use std::str;
 use std::sync::Arc;
 
 use parking_lot::{lock_api::ArcMutexGuard, Mutex, RawMutex, RwLock};
-use rome_diagnostics::Error;
+use rome_diagnostics::{Error, Severity};
 
 use crate::fs::OpenOptions;
 use crate::{FileSystem, RomePath, TraversalContext, TraversalScope};
@@ -161,6 +161,11 @@ impl FileSystem for MemoryFileSystem {
     fn working_directory(&self) -> Option<PathBuf> {
         None
     }
+
+    fn path_exists(&self, path: &Path) -> bool {
+        let files = self.files.0.read();
+        files.get(path).is_some()
+    }
 }
 
 struct MemoryFile {
@@ -253,6 +258,7 @@ impl<'scope> TraversalScope<'scope> for MemoryTraversalScope<'scope> {
                             ErrorKind::InfiniteSymlinkExpansion(path.to_string_lossy().to_string())
                         }
                     },
+                    severity: Severity::Warning,
                 }));
             }
         }
diff --git a/crates/rome_fs/src/fs/os.rs b/crates/rome_fs/src/fs/os.rs
index 172b12a130b..3108133271c 100644
--- a/crates/rome_fs/src/fs/os.rs
+++ b/crates/rome_fs/src/fs/os.rs
@@ -6,7 +6,7 @@ use crate::{
     FileSystem, RomePath,
 };
 use rayon::{scope, Scope};
-use rome_diagnostics::{adapters::IoError, DiagnosticExt, Error};
+use rome_diagnostics::{adapters::IoError, DiagnosticExt, Error, Severity};
 use std::fs::DirEntry;
 use std::{
     env,
@@ -41,6 +41,10 @@ impl FileSystem for OsFileSystem {
     fn working_directory(&self) -> Option<PathBuf> {
         env::current_dir().ok()
     }
+
+    fn path_exists(&self, path: &Path) -> bool {
+        path.exists()
+    }
 }
 
 struct OsFile {
@@ -129,6 +133,7 @@ impl<'scope> TraversalScope<'scope> for OsTraversalScope<'scope> {
                     ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
                         path: path.clone(),
                         error_kind: ErrorKind::DereferencedSymlink(path),
+                        severity: Severity::Warning,
                     }));
                 } else {
                     ctx.push_diagnostic(
@@ -160,6 +165,7 @@ impl<'scope> TraversalScope<'scope> for OsTraversalScope<'scope> {
         ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
             path: path.to_string_lossy().to_string(),
             error_kind: ErrorKind::from(file_type),
+            severity: Severity::Warning,
         }));
     }
 }
@@ -244,6 +250,7 @@ fn handle_dir_entry<'scope>(
                     ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
                         path: path.clone(),
                         error_kind: ErrorKind::DereferencedSymlink(path),
+                        severity: Severity::Warning,
                     }));
                 } else {
                     ctx.push_diagnostic(
@@ -270,6 +277,7 @@ fn handle_dir_entry<'scope>(
         ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
             path: path.clone(),
             error_kind: ErrorKind::InfiniteSymlinkExpansion(path),
+            severity: Severity::Warning,
         }));
         return;
     }
@@ -301,6 +309,7 @@ fn handle_dir_entry<'scope>(
                 ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
                     path: path.to_string_lossy().to_string(),
                     error_kind: ErrorKind::UnknownFileType,
+                    severity: Severity::Warning,
                 }));
                 return;
             }
@@ -326,6 +335,7 @@ fn handle_dir_entry<'scope>(
     ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
         path: path.to_string_lossy().to_string(),
         error_kind: ErrorKind::from(file_type),
+        severity: Severity::Warning,
     }));
 }
 
diff --git a/crates/rome_fs/src/lib.rs b/crates/rome_fs/src/lib.rs
index fcceb6f3cb6..69d9122ce9c 100644
--- a/crates/rome_fs/src/lib.rs
+++ b/crates/rome_fs/src/lib.rs
@@ -3,8 +3,8 @@ mod interner;
 mod path;
 
 pub use fs::{
-    ErrorEntry, File, FileSystem, FileSystemExt, MemoryFileSystem, OpenOptions, OsFileSystem,
-    TraversalContext, TraversalScope, CONFIG_NAME,
+    ErrorEntry, File, FileSystem, FileSystemDiagnostic, FileSystemExt, MemoryFileSystem,
+    OpenOptions, OsFileSystem, TraversalContext, TraversalScope, CONFIG_NAME,
 };
 pub use interner::PathInterner;
 pub use path::RomePath;
diff --git a/crates/rome_js_analyze/tests/specs/nursery/useExhaustiveDependencies/malformedOptions.js.snap b/crates/rome_js_analyze/tests/specs/nursery/useExhaustiveDependencies/malformedOptions.js.snap
index a27c7d8e865..8e96baed153 100644
--- a/crates/rome_js_analyze/tests/specs/nursery/useExhaustiveDependencies/malformedOptions.js.snap
+++ b/crates/rome_js_analyze/tests/specs/nursery/useExhaustiveDependencies/malformedOptions.js.snap
@@ -11,7 +11,7 @@ expression: malformedOptions.js
 ```
 malformedOptions.js:2:5 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown key `hook`
+  × Found an unknown key `hook`.
   
     1 │ {
   > 2 │     "hook": [
diff --git a/crates/rome_lsp/tests/server.rs b/crates/rome_lsp/tests/server.rs
index 4f5397ac7d8..09fc60be8fc 100644
--- a/crates/rome_lsp/tests/server.rs
+++ b/crates/rome_lsp/tests/server.rs
@@ -826,7 +826,7 @@ async fn pull_diagnostics_for_rome_json() -> Result<()> {
                     code: Some(lsp::NumberOrString::String(String::from("deserialize",))),
                     code_description: None,
                     source: Some(String::from("rome")),
-                    message: String::from("Found an unknown value `magic`",),
+                    message: String::from("Found an unknown value `magic`.",),
                     related_information: None,
                     tags: None,
                     data: None,
diff --git a/crates/rome_service/src/configuration/mod.rs b/crates/rome_service/src/configuration/mod.rs
index d9a58b06673..b3d3eaff3b9 100644
--- a/crates/rome_service/src/configuration/mod.rs
+++ b/crates/rome_service/src/configuration/mod.rs
@@ -14,7 +14,6 @@ use std::io::ErrorKind;
 use std::marker::PhantomData;
 use std::num::NonZeroU64;
 use std::path::{Path, PathBuf};
-use tracing::{error, info};
 
 pub mod diagnostics;
 mod formatter;
@@ -23,10 +22,12 @@ mod javascript;
 pub mod linter;
 pub mod organize_imports;
 mod parse;
+pub mod vcs;
 
 pub use crate::configuration::diagnostics::ConfigurationDiagnostic;
 use crate::configuration::generated::push_to_analyzer_rules;
 use crate::configuration::organize_imports::OrganizeImports;
+use crate::configuration::vcs::VcsConfiguration;
 use crate::settings::{LanguagesSettings, LinterSettings};
 pub use formatter::{FormatterConfiguration, PlainIndentStyle};
 pub use javascript::{JavascriptConfiguration, JavascriptFormatter};
@@ -47,6 +48,11 @@ pub struct Configuration {
     #[serde(rename(serialize = "$schema", deserialize = "$schema"))]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub schema: Option<String>,
+
+    /// The configuration of the filesystem
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vcs: Option<VcsConfiguration>,
+
     /// The configuration of the filesystem
     #[serde(skip_serializing_if = "Option::is_none")]
     pub files: Option<FilesConfiguration>,
@@ -80,12 +86,14 @@ impl Default for Configuration {
             formatter: None,
             javascript: None,
             schema: None,
+            vcs: None,
         }
     }
 }
 
 impl Configuration {
     const KNOWN_KEYS: &'static [&'static str] = &[
+        "vcs",
         "files",
         "linter",
         "formatter",
@@ -110,6 +118,10 @@ impl Configuration {
             .map(|f| !f.enabled)
             .unwrap_or(false)
     }
+
+    pub fn is_vcs_disabled(&self) -> bool {
+        self.vcs.as_ref().map(|f| !f.enabled).unwrap_or(true)
+    }
 }
 
 /// The configuration of the filesystem
@@ -175,7 +187,7 @@ pub fn load_config(
 ) -> LoadConfig {
     let config_name = file_system.config_name();
     let working_directory = file_system.working_directory();
-    let mut configuration_directory = match base_path {
+    let configuration_directory = match base_path {
         ConfigurationBasePath::Lsp(ref path) | ConfigurationBasePath::FromUser(ref path) => {
             path.clone()
         }
@@ -184,71 +196,17 @@ pub fn load_config(
             None => PathBuf::new(),
         },
     };
-    let mut configuration_path = configuration_directory.join(config_name);
+    let configuration_file_path = configuration_directory.join(config_name);
     let should_error = base_path.is_from_user();
-    info!(
-        "Attempting to read the configuration file from {}",
-        configuration_path.display()
-    );
-
-    let mut from_parent = false;
-    loop {
-        let options = OpenOptions::default().read(true);
-        let file = file_system.open_with_options(&configuration_path, options);
-        return match file {
-            Ok(mut file) => {
-                let mut buffer = String::new();
-                file.read_to_string(&mut buffer).map_err(|_| {
-                    WorkspaceError::cant_read_file(format!("{}", configuration_path.display()))
-                })?;
-
-                if from_parent {
-                    info!(
-                        "Rome auto discovered a configuration file at following path that wasn't in the working directory: {}",
-                        configuration_path.display()
-                    );
-                }
-
-                let deserialized = deserialize_from_json_str::<Configuration>(&buffer)
-                    .with_file_path(&configuration_path.display().to_string());
-                Ok(Some((deserialized, configuration_path)))
-            }
-            Err(err) => {
-                // base paths from users are not eligible for auto discovery
-                if !base_path.is_from_user() {
-                    let parent_directory = if let Some(path) = configuration_directory.parent() {
-                        if path.is_dir() {
-                            Some(PathBuf::from(path))
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    };
-                    if let Some(parent_directory) = parent_directory {
-                        configuration_directory = parent_directory;
-                        configuration_path = configuration_directory.join(config_name);
-                        from_parent = true;
-                        continue;
-                    }
-                }
-                // We skip the error when the configuration file is not found.
-                // Not having a configuration file is only an error when the `base_path` is
-                // set to `BasePath::FromUser`.
-                if should_error || err.kind() != ErrorKind::NotFound {
-                    return Err(WorkspaceError::cant_read_file(format!(
-                        "{}",
-                        configuration_path.display()
-                    )));
-                }
-                error!(
-                    "Could not read the configuration file from {:?}, reason:\n {}",
-                    configuration_path.display(),
-                    err
-                );
-                Ok(None)
-            }
-        };
+
+    let result = file_system.auto_search(configuration_directory, config_name, should_error)?;
+
+    if let Some((buffer, configuration_path)) = result {
+        let deserialized = deserialize_from_json_str::<Configuration>(&buffer)
+            .with_file_path(&configuration_file_path.display().to_string());
+        Ok(Some((deserialized, configuration_path)))
+    } else {
+        Ok(None)
     }
 }
 
diff --git a/crates/rome_service/src/configuration/parse/json.rs b/crates/rome_service/src/configuration/parse/json.rs
index 2390d2567a6..7ad7f02e55b 100644
--- a/crates/rome_service/src/configuration/parse/json.rs
+++ b/crates/rome_service/src/configuration/parse/json.rs
@@ -2,11 +2,13 @@
 //!
 
 mod configuration;
+mod files;
 mod formatter;
 mod javascript;
 mod linter;
 mod organize_imports;
 mod rules;
+mod vcs;
 
 use crate::Configuration;
 use rome_deserialize::json::{JsonDeserialize, VisitJsonNode};
diff --git a/crates/rome_service/src/configuration/parse/json/configuration.rs b/crates/rome_service/src/configuration/parse/json/configuration.rs
index c9d967f9ab1..982bfb4940d 100644
--- a/crates/rome_service/src/configuration/parse/json/configuration.rs
+++ b/crates/rome_service/src/configuration/parse/json/configuration.rs
@@ -1,4 +1,6 @@
 use crate::configuration::organize_imports::OrganizeImports;
+use crate::configuration::parse::json::vcs::validate_vcs_configuration;
+use crate::configuration::vcs::VcsConfiguration;
 use crate::configuration::{
     FilesConfiguration, FormatterConfiguration, JavascriptConfiguration, LinterConfiguration,
 };
@@ -7,40 +9,6 @@ use rome_deserialize::json::{has_only_known_keys, VisitJsonNode};
 use rome_deserialize::{DeserializationDiagnostic, VisitNode};
 use rome_json_syntax::{JsonLanguage, JsonSyntaxNode};
 use rome_rowan::SyntaxNode;
-use std::num::NonZeroU64;
-
-impl VisitJsonNode for FilesConfiguration {}
-
-impl VisitNode<JsonLanguage> for FilesConfiguration {
-    fn visit_member_name(
-        &mut self,
-        node: &SyntaxNode<JsonLanguage>,
-        diagnostics: &mut Vec<DeserializationDiagnostic>,
-    ) -> Option<()> {
-        has_only_known_keys(node, FilesConfiguration::KNOWN_KEYS, diagnostics)
-    }
-
-    fn visit_map(
-        &mut self,
-        key: &SyntaxNode<JsonLanguage>,
-        value: &SyntaxNode<JsonLanguage>,
-        diagnostics: &mut Vec<DeserializationDiagnostic>,
-    ) -> Option<()> {
-        let (name, value) = self.get_key_and_value(key, value, diagnostics)?;
-        let name_text = name.text();
-        match name_text {
-            "maxSize" => {
-                self.max_size =
-                    NonZeroU64::new(self.map_to_u64(&value, name_text, u64::MAX, diagnostics)?);
-            }
-            "ignore" => {
-                self.ignore = self.map_to_index_set_string(&value, name_text, diagnostics);
-            }
-            _ => {}
-        }
-        Some(())
-    }
-}
 
 impl VisitJsonNode for Configuration {}
 
@@ -70,6 +38,12 @@ impl VisitNode<JsonLanguage> for Configuration {
                 self.map_to_object(&value, name_text, &mut files, diagnostics)?;
                 self.files = Some(files);
             }
+            "vcs" => {
+                let mut vcs = VcsConfiguration::default();
+                self.map_to_object(&value, name_text, &mut vcs, diagnostics)?;
+                validate_vcs_configuration(&value, &mut vcs, diagnostics);
+                self.vcs = Some(vcs);
+            }
             "formatter" => {
                 let mut formatter = FormatterConfiguration::default();
                 self.map_to_object(&value, name_text, &mut formatter, diagnostics)?;
diff --git a/crates/rome_service/src/configuration/parse/json/files.rs b/crates/rome_service/src/configuration/parse/json/files.rs
new file mode 100644
index 00000000000..03beb4774e5
--- /dev/null
+++ b/crates/rome_service/src/configuration/parse/json/files.rs
@@ -0,0 +1,39 @@
+use crate::configuration::FilesConfiguration;
+use rome_deserialize::json::{has_only_known_keys, VisitJsonNode};
+use rome_deserialize::{DeserializationDiagnostic, VisitNode};
+use rome_json_syntax::JsonLanguage;
+use rome_rowan::SyntaxNode;
+use std::num::NonZeroU64;
+
+impl VisitJsonNode for FilesConfiguration {}
+
+impl VisitNode<JsonLanguage> for FilesConfiguration {
+    fn visit_member_name(
+        &mut self,
+        node: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        has_only_known_keys(node, FilesConfiguration::KNOWN_KEYS, diagnostics)
+    }
+
+    fn visit_map(
+        &mut self,
+        key: &SyntaxNode<JsonLanguage>,
+        value: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        let (name, value) = self.get_key_and_value(key, value, diagnostics)?;
+        let name_text = name.text();
+        match name_text {
+            "maxSize" => {
+                self.max_size =
+                    NonZeroU64::new(self.map_to_u64(&value, name_text, u64::MAX, diagnostics)?);
+            }
+            "ignore" => {
+                self.ignore = self.map_to_index_set_string(&value, name_text, diagnostics);
+            }
+            _ => {}
+        }
+        Some(())
+    }
+}
diff --git a/crates/rome_service/src/configuration/parse/json/vcs.rs b/crates/rome_service/src/configuration/parse/json/vcs.rs
new file mode 100644
index 00000000000..dfb5fa85eda
--- /dev/null
+++ b/crates/rome_service/src/configuration/parse/json/vcs.rs
@@ -0,0 +1,80 @@
+use crate::configuration::vcs::{VcsClientKind, VcsConfiguration};
+use rome_console::markup;
+use rome_deserialize::json::{has_only_known_keys, with_only_known_variants, VisitJsonNode};
+use rome_deserialize::{DeserializationDiagnostic, VisitNode};
+use rome_json_syntax::{AnyJsonValue, JsonLanguage};
+use rome_rowan::{AstNode, SyntaxNode};
+
+impl VisitJsonNode for VcsConfiguration {}
+
+impl VisitNode<JsonLanguage> for VcsConfiguration {
+    fn visit_member_name(
+        &mut self,
+        node: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        has_only_known_keys(node, VcsConfiguration::KNOWN_KEYS, diagnostics)
+    }
+
+    fn visit_map(
+        &mut self,
+        key: &SyntaxNode<JsonLanguage>,
+        value: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        let (name, value) = self.get_key_and_value(key, value, diagnostics)?;
+        let name_text = name.text();
+        match name_text {
+            "clientKind" => {
+                let mut client_kind = VcsClientKind::default();
+                self.map_to_known_string(&value, name_text, &mut client_kind, diagnostics)?;
+                self.client_kind = Some(client_kind);
+            }
+            "enabled" => {
+                self.enabled = self.map_to_boolean(&value, name_text, diagnostics)?;
+            }
+            "useIgnoreFile" => {
+                self.use_ignore_file = self.map_to_boolean(&value, name_text, diagnostics);
+            }
+
+            "root" => {
+                self.root = self.map_to_string(&value, name_text, diagnostics);
+            }
+            _ => {}
+        }
+        Some(())
+    }
+}
+
+impl VisitJsonNode for VcsClientKind {}
+
+impl VisitNode<JsonLanguage> for VcsClientKind {
+    fn visit_member_value(
+        &mut self,
+        node: &SyntaxNode<JsonLanguage>,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<()> {
+        let node = with_only_known_variants(node, VcsClientKind::KNOWN_VALUES, diagnostics)?;
+        if node.inner_string_text().ok()?.text() == "git" {
+            *self = VcsClientKind::Git;
+        }
+        Some(())
+    }
+}
+
+pub(crate) fn validate_vcs_configuration(
+    node: &AnyJsonValue,
+    configuration: &mut VcsConfiguration,
+    diagnostics: &mut Vec<DeserializationDiagnostic>,
+) {
+    if configuration.client_kind.is_none() && configuration.enabled {
+        diagnostics.push(
+            DeserializationDiagnostic::new(markup! {
+                "You enabled the VCS integration, but you didn't specify a client."
+            })
+            .with_range(node.range())
+            .with_note("Rome will disable the VCS integration until the issue is fixed."),
+        );
+        configuration.enabled = false;
+    }
+}
diff --git a/crates/rome_service/src/configuration/vcs.rs b/crates/rome_service/src/configuration/vcs.rs
new file mode 100644
index 00000000000..2ff25ff4055
--- /dev/null
+++ b/crates/rome_service/src/configuration/vcs.rs
@@ -0,0 +1,70 @@
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+
+const GIT_IGNORE_FILE_NAME: &str = ".gitignore";
+
+/// Set
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct VcsConfiguration {
+    /// The kind of client.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_kind: Option<VcsClientKind>,
+
+    /// Whether Rome should integrate itself with the VCS client
+    pub enabled: bool,
+
+    /// Whether Rome should use the VCS ignore file. When [true], Rome will ignore the files
+    /// specified in the ignore file.
+    pub use_ignore_file: Option<bool>,
+
+    /// The folder where Rome should check for VCS files. By default, Rome will use the same
+    /// folder where `rome.json` was found.
+    ///
+    /// If Rome can't fine the configuration, it will attempt to use the current working directory.
+    /// If no current working directory can't be found, Rome won't use the VCS integration.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub root: Option<String>,
+}
+
+impl VcsConfiguration {
+    pub const fn ignore_file_disabled(&self) -> bool {
+        matches!(self.use_ignore_file, Some(false))
+    }
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase")]
+pub enum VcsClientKind {
+    #[default]
+    /// Integration with the git client as VCS
+    Git,
+}
+
+impl VcsClientKind {
+    pub const KNOWN_VALUES: &'static [&'static str] = &["git"];
+
+    pub const fn ignore_file(&self) -> &'static str {
+        match self {
+            VcsClientKind::Git => GIT_IGNORE_FILE_NAME,
+        }
+    }
+}
+
+impl FromStr for VcsClientKind {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "git" => Ok(Self::Git),
+            _ => Err("Value not supported for VcsClientKind"),
+        }
+    }
+}
+
+impl VcsConfiguration {
+    pub const KNOWN_KEYS: &'static [&'static str] =
+        &["clientKind", "enabled", "useIgnoreFile", "root"];
+}
diff --git a/crates/rome_service/src/diagnostics.rs b/crates/rome_service/src/diagnostics.rs
index 9d4ac081dad..a22acab5f25 100644
--- a/crates/rome_service/src/diagnostics.rs
+++ b/crates/rome_service/src/diagnostics.rs
@@ -4,6 +4,7 @@ use rome_console::fmt::Bytes;
 use rome_console::markup;
 use rome_diagnostics::{category, Category, Diagnostic, DiagnosticTags, Location, Severity};
 use rome_formatter::{FormatError, PrintError};
+use rome_fs::FileSystemDiagnostic;
 use rome_js_analyze::utils::rename::RenameError;
 use rome_js_analyze::RuleError;
 use serde::{Deserialize, Serialize};
@@ -46,6 +47,8 @@ pub enum WorkspaceError {
     FileIgnored(FileIgnored),
     /// Emitted when a file could not be parsed because it's larger than the size limit
     FileTooLarge(FileTooLarge),
+    /// Diagnostics emitted when querying the file system
+    FileSystem(FileSystemDiagnostic),
 }
 
 impl WorkspaceError {
@@ -126,6 +129,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.category(),
             WorkspaceError::FileIgnored(error) => error.category(),
             WorkspaceError::FileTooLarge(error) => error.category(),
+            WorkspaceError::FileSystem(error) => error.category(),
         }
     }
 
@@ -146,6 +150,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.description(fmt),
             WorkspaceError::FileIgnored(error) => error.description(fmt),
             WorkspaceError::FileTooLarge(error) => error.description(fmt),
+            WorkspaceError::FileSystem(error) => error.description(fmt),
         }
     }
 
@@ -166,6 +171,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.message(fmt),
             WorkspaceError::FileIgnored(error) => error.message(fmt),
             WorkspaceError::FileTooLarge(error) => error.message(fmt),
+            WorkspaceError::FileSystem(error) => error.message(fmt),
         }
     }
 
@@ -186,6 +192,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.severity(),
             WorkspaceError::FileIgnored(error) => error.severity(),
             WorkspaceError::FileTooLarge(error) => error.severity(),
+            WorkspaceError::FileSystem(error) => error.severity(),
         }
     }
 
@@ -206,6 +213,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.tags(),
             WorkspaceError::FileIgnored(error) => error.tags(),
             WorkspaceError::FileTooLarge(error) => error.tags(),
+            WorkspaceError::FileSystem(error) => error.tags(),
         }
     }
 
@@ -226,6 +234,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => error.location(),
             WorkspaceError::FileIgnored(error) => error.location(),
             WorkspaceError::FileTooLarge(error) => error.location(),
+            WorkspaceError::FileSystem(error) => error.location(),
         }
     }
 
@@ -246,6 +255,7 @@ impl Diagnostic for WorkspaceError {
             WorkspaceError::CantReadFile(error) => Diagnostic::source(error),
             WorkspaceError::FileIgnored(error) => Diagnostic::source(error),
             WorkspaceError::FileTooLarge(error) => Diagnostic::source(error),
+            WorkspaceError::FileSystem(error) => Diagnostic::source(error),
         }
     }
 }
@@ -268,6 +278,12 @@ impl From<PrintError> for WorkspaceError {
     }
 }
 
+impl From<FileSystemDiagnostic> for WorkspaceError {
+    fn from(err: FileSystemDiagnostic) -> Self {
+        Self::FileSystem(err)
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Diagnostic)]
 #[diagnostic(
     category = "internalError/fs",
diff --git a/crates/rome_service/tests/invalid/files_extraneous_field.json.snap b/crates/rome_service/tests/invalid/files_extraneous_field.json.snap
index 7925319b311..0d7d609cc94 100644
--- a/crates/rome_service/tests/invalid/files_extraneous_field.json.snap
+++ b/crates/rome_service/tests/invalid/files_extraneous_field.json.snap
@@ -4,7 +4,7 @@ expression: files_extraneous_field.json
 ---
 files_extraneous_field.json:3:3 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown key `foo`
+  × Found an unknown key `foo`.
   
     1 │ {
     2 │ 	"files": {
diff --git a/crates/rome_service/tests/invalid/files_ignore_incorrect_type.json.snap b/crates/rome_service/tests/invalid/files_ignore_incorrect_type.json.snap
index 8a9a318164e..b1745adac35 100644
--- a/crates/rome_service/tests/invalid/files_ignore_incorrect_type.json.snap
+++ b/crates/rome_service/tests/invalid/files_ignore_incorrect_type.json.snap
@@ -4,7 +4,7 @@ expression: files_ignore_incorrect_type.json
 ---
 files_ignore_incorrect_type.json:3:13 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key ignore is incorrect. Expected array
+  × The value of key ignore is incorrect. Expected a array.
   
     1 │ {
     2 │ 	"files": {
diff --git a/crates/rome_service/tests/invalid/files_ignore_incorrect_value.json.snap b/crates/rome_service/tests/invalid/files_ignore_incorrect_value.json.snap
index ea839f249a1..2daf797a348 100644
--- a/crates/rome_service/tests/invalid/files_ignore_incorrect_value.json.snap
+++ b/crates/rome_service/tests/invalid/files_ignore_incorrect_value.json.snap
@@ -4,7 +4,7 @@ expression: files_ignore_incorrect_value.json
 ---
 files_ignore_incorrect_value.json:3:25 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Incorrect type, expected a string
+  × Incorrect type, expected a string.
   
     1 │ {
     2 │ 	"files": {
diff --git a/crates/rome_service/tests/invalid/files_incorrect_type.json.snap b/crates/rome_service/tests/invalid/files_incorrect_type.json.snap
index 91b5296f6d6..3e15de13390 100644
--- a/crates/rome_service/tests/invalid/files_incorrect_type.json.snap
+++ b/crates/rome_service/tests/invalid/files_incorrect_type.json.snap
@@ -4,7 +4,7 @@ expression: files_incorrect_type.json
 ---
 files_incorrect_type.json:2:11 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key files is incorrect. Expected object
+  × The value of key files is incorrect. Expected a object.
   
     1 │ {
   > 2 │ 	"files": "wrong"
diff --git a/crates/rome_service/tests/invalid/files_incorrect_type_for_value.json.snap b/crates/rome_service/tests/invalid/files_incorrect_type_for_value.json.snap
index 1c9fe5c417a..218a58be956 100644
--- a/crates/rome_service/tests/invalid/files_incorrect_type_for_value.json.snap
+++ b/crates/rome_service/tests/invalid/files_incorrect_type_for_value.json.snap
@@ -4,7 +4,7 @@ expression: files_incorrect_type_for_value.json
 ---
 files_incorrect_type_for_value.json:3:14 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key maxSize is incorrect. Expected number
+  × The value of key maxSize is incorrect. Expected a number.
   
     1 │ {
     2 │ 	"files": {
diff --git a/crates/rome_service/tests/invalid/formatter_extraneous_field.json.snap b/crates/rome_service/tests/invalid/formatter_extraneous_field.json.snap
index 9d8742d1520..bee33f6504b 100644
--- a/crates/rome_service/tests/invalid/formatter_extraneous_field.json.snap
+++ b/crates/rome_service/tests/invalid/formatter_extraneous_field.json.snap
@@ -4,7 +4,7 @@ expression: formatter_extraneous_field.json
 ---
 formatter_extraneous_field.json:3:3 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown key `foo`
+  × Found an unknown key `foo`.
   
     1 │ {
     2 │ 	"formatter": {
diff --git a/crates/rome_service/tests/invalid/formatter_format_with_errors_incorrect_type.json.snap b/crates/rome_service/tests/invalid/formatter_format_with_errors_incorrect_type.json.snap
index 3c126c7c321..bac3dc93eb4 100644
--- a/crates/rome_service/tests/invalid/formatter_format_with_errors_incorrect_type.json.snap
+++ b/crates/rome_service/tests/invalid/formatter_format_with_errors_incorrect_type.json.snap
@@ -4,7 +4,7 @@ expression: formatter_format_with_errors_incorrect_type.json
 ---
 formatter_format_with_errors_incorrect_type.json:3:23 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key formatWithErrors is incorrect. Expected boolean
+  × The value of key formatWithErrors is incorrect. Expected a boolean.
   
     1 │ {
     2 │ 	"formatter": {
diff --git a/crates/rome_service/tests/invalid/formatter_incorrect_type.json.snap b/crates/rome_service/tests/invalid/formatter_incorrect_type.json.snap
index c1cbab1dbda..b5084cf2ab2 100644
--- a/crates/rome_service/tests/invalid/formatter_incorrect_type.json.snap
+++ b/crates/rome_service/tests/invalid/formatter_incorrect_type.json.snap
@@ -4,7 +4,7 @@ expression: formatter_incorrect_type.json
 ---
 formatter_incorrect_type.json:2:15 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key formatter is incorrect. Expected object
+  × The value of key formatter is incorrect. Expected a object.
   
     1 │ {
   > 2 │ 	"formatter": "string"
diff --git a/crates/rome_service/tests/invalid/javascript_formatter_quote_properties.json.snap b/crates/rome_service/tests/invalid/javascript_formatter_quote_properties.json.snap
index cf09741a2e2..2288cae3a02 100644
--- a/crates/rome_service/tests/invalid/javascript_formatter_quote_properties.json.snap
+++ b/crates/rome_service/tests/invalid/javascript_formatter_quote_properties.json.snap
@@ -4,7 +4,7 @@ expression: javascript_formatter_quote_properties.json
 ---
 javascript_formatter_quote_properties.json:4:23 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown value `wrong`
+  × Found an unknown value `wrong`.
   
     2 │ 	"javascript": {
     3 │ 		"formatter": {
@@ -13,7 +13,7 @@ javascript_formatter_quote_properties.json:4:23 deserialize ━━━━━━
     5 │ 		}
     6 │ 	}
   
-  i Accepted values
+  i Accepted values:
   
   - preserve
   - asNeeded
diff --git a/crates/rome_service/tests/invalid/javascript_formatter_quote_style.json.snap b/crates/rome_service/tests/invalid/javascript_formatter_quote_style.json.snap
index 6ee0d3ffdc2..9a2048e9b9e 100644
--- a/crates/rome_service/tests/invalid/javascript_formatter_quote_style.json.snap
+++ b/crates/rome_service/tests/invalid/javascript_formatter_quote_style.json.snap
@@ -4,7 +4,7 @@ expression: javascript_formatter_quote_style.json
 ---
 javascript_formatter_quote_style.json:4:18 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown value `wrong`
+  × Found an unknown value `wrong`.
   
     2 │ 	"javascript": {
     3 │ 		"formatter": {
@@ -13,7 +13,7 @@ javascript_formatter_quote_style.json:4:18 deserialize ━━━━━━━━
     5 │ 		}
     6 │ 	}
   
-  i Accepted values
+  i Accepted values:
   
   - double
   - single
diff --git a/crates/rome_service/tests/invalid/javascript_formatter_semicolons.json.snap b/crates/rome_service/tests/invalid/javascript_formatter_semicolons.json.snap
index c530cbad681..b57c93ebef1 100644
--- a/crates/rome_service/tests/invalid/javascript_formatter_semicolons.json.snap
+++ b/crates/rome_service/tests/invalid/javascript_formatter_semicolons.json.snap
@@ -4,7 +4,7 @@ expression: javascript_formatter_semicolons.json
 ---
 javascript_formatter_semicolons.json:4:18 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown value `lorem`
+  × Found an unknown value `lorem`.
   
     2 │ 	"javascript": {
     3 │ 		"formatter": {
@@ -13,7 +13,7 @@ javascript_formatter_semicolons.json:4:18 deserialize ━━━━━━━━
     5 │ 		}
     6 │ 	}
   
-  i Accepted values
+  i Accepted values:
   
   - always
   - asNeeded
diff --git a/crates/rome_service/tests/invalid/javascript_formatter_trailing_comma.json.snap b/crates/rome_service/tests/invalid/javascript_formatter_trailing_comma.json.snap
index 70e2424d4e2..0aeb17617cf 100644
--- a/crates/rome_service/tests/invalid/javascript_formatter_trailing_comma.json.snap
+++ b/crates/rome_service/tests/invalid/javascript_formatter_trailing_comma.json.snap
@@ -4,7 +4,7 @@ expression: javascript_formatter_trailing_comma.json
 ---
 javascript_formatter_trailing_comma.json:4:21 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown value `wrong`
+  × Found an unknown value `wrong`.
   
     2 │ 	"javascript": {
     3 │ 		"formatter": {
@@ -13,7 +13,7 @@ javascript_formatter_trailing_comma.json:4:21 deserialize ━━━━━━━
     5 │ 		}
     6 │ 	}
   
-  i Accepted values
+  i Accepted values:
   
   - all
   - es5
diff --git a/crates/rome_service/tests/invalid/organize_imports.json.snap b/crates/rome_service/tests/invalid/organize_imports.json.snap
index b73457bf0e1..deec07fcc8d 100644
--- a/crates/rome_service/tests/invalid/organize_imports.json.snap
+++ b/crates/rome_service/tests/invalid/organize_imports.json.snap
@@ -4,7 +4,7 @@ expression: organize_imports.json
 ---
 organize_imports.json:3:14 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key enabled is incorrect. Expected boolean
+  × The value of key enabled is incorrect. Expected a boolean.
   
     1 │ {
     2 │ 	"organizeImports": {
diff --git a/crates/rome_service/tests/invalid/schema.json.snap b/crates/rome_service/tests/invalid/schema.json.snap
index c1fe71fb388..419674e5063 100644
--- a/crates/rome_service/tests/invalid/schema.json.snap
+++ b/crates/rome_service/tests/invalid/schema.json.snap
@@ -4,7 +4,7 @@ expression: schema.json
 ---
 schema.json:2:13 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × The value of key $schema is incorrect. Expected string
+  × The value of key $schema is incorrect. Expected a string.
   
     1 │ {
   > 2 │ 	"$schema": false
diff --git a/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap b/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
index e08a12af235..3802794bf83 100644
--- a/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
+++ b/crates/rome_service/tests/invalid/top_level_extraneous_field.json.snap
@@ -4,7 +4,7 @@ expression: top_level_extraneous_field.json
 ---
 top_level_extraneous_field.json:2:2 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found an unknown key `foo_bar`
+  × Found an unknown key `foo_bar`.
   
     1 │ {
   > 2 │ 	"foo_bar": {
@@ -14,6 +14,7 @@ top_level_extraneous_field.json:2:2 deserialize ━━━━━━━━━━
   
   i Accepted keys
   
+  - vcs
   - files
   - linter
   - formatter
diff --git a/crates/rome_service/tests/invalid/vcs_incorrect_type.json b/crates/rome_service/tests/invalid/vcs_incorrect_type.json
new file mode 100644
index 00000000000..e0dca56d9cd
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_incorrect_type.json
@@ -0,0 +1,7 @@
+{
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": "false"
+	}
+}
diff --git a/crates/rome_service/tests/invalid/vcs_incorrect_type.json.snap b/crates/rome_service/tests/invalid/vcs_incorrect_type.json.snap
new file mode 100644
index 00000000000..21736f43fde
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_incorrect_type.json.snap
@@ -0,0 +1,17 @@
+---
+source: crates/rome_service/tests/spec_tests.rs
+expression: vcs_incorrect_type.json
+---
+vcs_incorrect_type.json:5:20 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The value of key useIgnoreFile is incorrect. Expected a boolean.
+  
+    3 │ 		"enabled": true,
+    4 │ 		"clientKind": "git",
+  > 5 │ 		"useIgnoreFile": "false"
+      │ 		                 ^^^^^^^
+    6 │ 	}
+    7 │ }
+  
+
+
diff --git a/crates/rome_service/tests/invalid/vcs_missing_client.json b/crates/rome_service/tests/invalid/vcs_missing_client.json
new file mode 100644
index 00000000000..eeb6659d06d
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_missing_client.json
@@ -0,0 +1,6 @@
+{
+	"vcs": {
+		"enabled": true,
+		"useIgnoreFile": "false"
+	}
+}
diff --git a/crates/rome_service/tests/invalid/vcs_missing_client.json.snap b/crates/rome_service/tests/invalid/vcs_missing_client.json.snap
new file mode 100644
index 00000000000..91518848ff5
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_missing_client.json.snap
@@ -0,0 +1,36 @@
+---
+source: crates/rome_service/tests/spec_tests.rs
+expression: vcs_missing_client.json
+---
+vcs_missing_client.json:4:20 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The value of key useIgnoreFile is incorrect. Expected a boolean.
+  
+    2 │ 	"vcs": {
+    3 │ 		"enabled": true,
+  > 4 │ 		"useIgnoreFile": "false"
+      │ 		                 ^^^^^^^
+    5 │ 	}
+    6 │ }
+  
+
+
+
+vcs_missing_client.json:2:9 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × You enabled the VCS integration, but you didn't specify a client.
+  
+    1 │ {
+  > 2 │ 	"vcs": {
+      │ 	       ^
+  > 3 │ 		"enabled": true,
+  > 4 │ 		"useIgnoreFile": "false"
+  > 5 │ 	}
+      │ 	^
+    6 │ }
+    7 │ 
+  
+  i Rome will disable the VCS integration until the issue is fixed.
+  
+
+
diff --git a/crates/rome_service/tests/invalid/vcs_wrong_client.json b/crates/rome_service/tests/invalid/vcs_wrong_client.json
new file mode 100644
index 00000000000..5dddd135c54
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_wrong_client.json
@@ -0,0 +1,6 @@
+{
+	"vcs": {
+		"enabled": true,
+		"clientKind": "gitgit"
+	}
+}
diff --git a/crates/rome_service/tests/invalid/vcs_wrong_client.json.snap b/crates/rome_service/tests/invalid/vcs_wrong_client.json.snap
new file mode 100644
index 00000000000..047a9968deb
--- /dev/null
+++ b/crates/rome_service/tests/invalid/vcs_wrong_client.json.snap
@@ -0,0 +1,21 @@
+---
+source: crates/rome_service/tests/spec_tests.rs
+expression: vcs_wrong_client.json
+---
+vcs_wrong_client.json:4:17 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Found an unknown value `gitgit`.
+  
+    2 │ 	"vcs": {
+    3 │ 		"enabled": true,
+  > 4 │ 		"clientKind": "gitgit"
+      │ 		              ^^^^^^^^
+    5 │ 	}
+    6 │ }
+  
+  i Accepted values:
+  
+  - git
+  
+
+
diff --git a/editors/vscode/configuration_schema.json b/editors/vscode/configuration_schema.json
index 019b17518b1..db68943f65a 100644
--- a/editors/vscode/configuration_schema.json
+++ b/editors/vscode/configuration_schema.json
@@ -39,6 +39,13 @@
 		"organizeImports": {
 			"description": "The configuration of the import sorting",
 			"anyOf": [{ "$ref": "#/definitions/OrganizeImports" }, { "type": "null" }]
+		},
+		"vcs": {
+			"description": "The configuration of the filesystem",
+			"anyOf": [
+				{ "$ref": "#/definitions/VcsConfiguration" },
+				{ "type": "null" }
+			]
 		}
 	},
 	"additionalProperties": false,
@@ -1306,6 +1313,42 @@
 				}
 			}
 		},
-		"TrailingComma": { "type": "string", "enum": ["all", "es5", "none"] }
+		"TrailingComma": { "type": "string", "enum": ["all", "es5", "none"] },
+		"VcsClientKind": {
+			"oneOf": [
+				{
+					"description": "Integration with the git client as VCS",
+					"type": "string",
+					"enum": ["git"]
+				}
+			]
+		},
+		"VcsConfiguration": {
+			"description": "Set",
+			"type": "object",
+			"required": ["enabled"],
+			"properties": {
+				"clientKind": {
+					"description": "The kind of client.",
+					"anyOf": [
+						{ "$ref": "#/definitions/VcsClientKind" },
+						{ "type": "null" }
+					]
+				},
+				"enabled": {
+					"description": "Whether Rome should integrate itself with the VCS client",
+					"type": "boolean"
+				},
+				"root": {
+					"description": "The folder where Rome should check for VCS files. By default, Rome will use the same folder where `rome.json` was found.\n\nIf Rome can't fine the configuration, it will attempt to use the current working directory. If no current working directory can't be found, Rome won't use the VCS integration.",
+					"type": ["string", "null"]
+				},
+				"useIgnoreFile": {
+					"description": "Whether Rome should use the VCS ignore file. When [true], Rome will ignore the files specified in the ignore file.",
+					"type": ["boolean", "null"]
+				}
+			},
+			"additionalProperties": false
+		}
 	}
 }
diff --git a/npm/backend-jsonrpc/src/workspace.ts b/npm/backend-jsonrpc/src/workspace.ts
index da221d56d15..652021548e4 100644
--- a/npm/backend-jsonrpc/src/workspace.ts
+++ b/npm/backend-jsonrpc/src/workspace.ts
@@ -46,6 +46,10 @@ export interface Configuration {
 	 * The configuration of the import sorting
 	 */
 	organizeImports?: OrganizeImports;
+	/**
+	 * The configuration of the filesystem
+	 */
+	vcs?: VcsConfiguration;
 }
 /**
  * The configuration of the filesystem
@@ -117,6 +121,29 @@ export interface OrganizeImports {
 	 */
 	ignore?: string[];
 }
+/**
+ * Set
+ */
+export interface VcsConfiguration {
+	/**
+	 * The kind of client.
+	 */
+	clientKind?: VcsClientKind;
+	/**
+	 * Whether Rome should integrate itself with the VCS client
+	 */
+	enabled: boolean;
+	/**
+	* The folder where Rome should check for VCS files. By default, Rome will use the same folder where `rome.json` was found.
+
+If Rome can't fine the configuration, it will attempt to use the current working directory. If no current working directory can't be found, Rome won't use the VCS integration. 
+	 */
+	root?: string;
+	/**
+	 * Whether Rome should use the VCS ignore file. When [true], Rome will ignore the files specified in the ignore file.
+	 */
+	useIgnoreFile?: boolean;
+}
 export type PlainIndentStyle = "tab" | "space";
 /**
 	* Validated value for the `line_width` formatter options
@@ -161,6 +188,7 @@ export interface Rules {
 	style?: Style;
 	suspicious?: Suspicious;
 }
+export type VcsClientKind = "git";
 export type QuoteProperties = "asNeeded" | "preserve";
 export type QuoteStyle = "double" | "single";
 export type Semicolons = "always" | "asNeeded";
diff --git a/npm/rome/configuration_schema.json b/npm/rome/configuration_schema.json
index 019b17518b1..db68943f65a 100644
--- a/npm/rome/configuration_schema.json
+++ b/npm/rome/configuration_schema.json
@@ -39,6 +39,13 @@
 		"organizeImports": {
 			"description": "The configuration of the import sorting",
 			"anyOf": [{ "$ref": "#/definitions/OrganizeImports" }, { "type": "null" }]
+		},
+		"vcs": {
+			"description": "The configuration of the filesystem",
+			"anyOf": [
+				{ "$ref": "#/definitions/VcsConfiguration" },
+				{ "type": "null" }
+			]
 		}
 	},
 	"additionalProperties": false,
@@ -1306,6 +1313,42 @@
 				}
 			}
 		},
-		"TrailingComma": { "type": "string", "enum": ["all", "es5", "none"] }
+		"TrailingComma": { "type": "string", "enum": ["all", "es5", "none"] },
+		"VcsClientKind": {
+			"oneOf": [
+				{
+					"description": "Integration with the git client as VCS",
+					"type": "string",
+					"enum": ["git"]
+				}
+			]
+		},
+		"VcsConfiguration": {
+			"description": "Set",
+			"type": "object",
+			"required": ["enabled"],
+			"properties": {
+				"clientKind": {
+					"description": "The kind of client.",
+					"anyOf": [
+						{ "$ref": "#/definitions/VcsClientKind" },
+						{ "type": "null" }
+					]
+				},
+				"enabled": {
+					"description": "Whether Rome should integrate itself with the VCS client",
+					"type": "boolean"
+				},
+				"root": {
+					"description": "The folder where Rome should check for VCS files. By default, Rome will use the same folder where `rome.json` was found.\n\nIf Rome can't fine the configuration, it will attempt to use the current working directory. If no current working directory can't be found, Rome won't use the VCS integration.",
+					"type": ["string", "null"]
+				},
+				"useIgnoreFile": {
+					"description": "Whether Rome should use the VCS ignore file. When [true], Rome will ignore the files specified in the ignore file.",
+					"type": ["boolean", "null"]
+				}
+			},
+			"additionalProperties": false
+		}
 	}
 }
diff --git a/rome b/rome
deleted file mode 100755
index f24f5d46fc6..00000000000
--- a/rome
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Save directory we're currently in
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-PWD=$(pwd)
-
-cd "$DIR"
-
-# TODO retain original PWD for `rome` binary
-cargo run --quiet --bin rome -- "$@"
diff --git a/rome.json b/rome.json
index e3bf4435eb2..eff1db0cf52 100644
--- a/rome.json
+++ b/rome.json
@@ -1,11 +1,9 @@
 {
 	"$schema": "./npm/rome/configuration_schema.json",
-	"files": {
-		"ignore": [
-			"build",
-			"dist",
-			"target"
-		]
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
 	},
 	"formatter": {
 		"ignore": [