git-lfs: access git attributes to ignore filtered files

Author: gusinacio

CHANGELOG.md

@@ -26,6 +26,9 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 * The `jj arrange` TUI now includes immediate parents and children. They are not
   selectable and are dimmed by default.
 
+* Added `git.ignore-filters` setting to specify what filtered files in
+  `.gitattributes` are ignored by `jj`. Defaults to `["lfs"]`.
+
 ### Fixed bugs
 
 ## [0.39.0] - 2026-03-04

cli/src/command_error.rs

@@ -34,6 +34,7 @@ use jj_lib::fileset::FilePatternParseError;
 use jj_lib::fileset::FilesetParseError;
 use jj_lib::fileset::FilesetParseErrorKind;
 use jj_lib::fix::FixError;
+use jj_lib::gitattributes::GitAttributesError;
 use jj_lib::gitignore::GitIgnoreError;
 use jj_lib::index::IndexError;
 use jj_lib::op_heads_store::OpHeadResolutionError;
@@ -725,6 +726,12 @@ impl From<GitIgnoreError> for CommandError {
     }
 }
 
+impl From<GitAttributesError> for CommandError {
+    fn from(err: GitAttributesError) -> Self {
+        user_error_with_message("Failed to process .gitattributes.", err)
+    }
+}
+
 impl From<ParseBulkEditMessageError> for CommandError {
     fn from(err: ParseBulkEditMessageError) -> Self {
         user_error(err)

cli/src/merge_tools/diff_working_copies.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::fs::File;
 use std::io;
 use std::io::Write as _;
@@ -156,6 +157,7 @@ pub(crate) async fn check_out_trees(
             eol_conversion_mode: EolConversionMode::None,
             exec_change_setting: ExecChangeSetting::Auto,
             fsmonitor_settings: FsmonitorSettings::None,
+            ignore_filters: HashSet::new(),
         };
         let mut state = TreeState::init(store.clone(), wc_path, state_dir, &tree_state_settings)?;
         state.set_sparse_patterns(changed_files.clone())?;

lib/src/git.rs

@@ -39,6 +39,7 @@ use crate::backend::CommitId;
 use crate::backend::TreeValue;
 use crate::commit::Commit;
 use crate::config::ConfigGetError;
+use crate::config::ConfigGetResultExt as _;
 use crate::file_util::IoResultExt as _;
 use crate::file_util::PathError;
 use crate::git_backend::GitBackend;

lib/src/gitattributes.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #![expect(missing_docs)]
-#![allow(unused)]
 
 use std::collections::HashMap;
 use std::collections::HashSet;

lib/src/local_working_copy.rs

@@ -90,6 +90,13 @@ use crate::fsmonitor::FsmonitorSettings;
 use crate::fsmonitor::WatchmanConfig;
 #[cfg(feature = "watchman")]
 use crate::fsmonitor::watchman;
+#[cfg(feature = "git")]
+use crate::git::GitSettings;
+use crate::gitattributes::DiskFileLoader;
+use crate::gitattributes::GitAttributes;
+use crate::gitattributes::GitAttributesFilter as _;
+use crate::gitattributes::SearchPriority;
+use crate::gitattributes::TreeFileLoader;
 use crate::gitignore::GitIgnoreFile;
 use crate::lock::FileLock;
 use crate::matchers::DifferenceMatcher;
@@ -952,6 +959,10 @@ pub struct TreeStateSettings {
     pub exec_change_setting: ExecChangeSetting,
     /// The fsmonitor (e.g. Watchman) to use, if any.
     pub fsmonitor_settings: FsmonitorSettings,
+
+    /// Names of .gitattributes filters whose matching files should be ignored
+    /// in the working copy.
+    pub ignore_filters: HashSet<String>,
 }
 
 impl TreeStateSettings {
@@ -962,6 +973,19 @@ impl TreeStateSettings {
             eol_conversion_mode: EolConversionMode::try_from_settings(user_settings)?,
             exec_change_setting: user_settings.get("working-copy.exec-bit-change")?,
             fsmonitor_settings: FsmonitorSettings::from_settings(user_settings)?,
+            ignore_filters: {
+                #[cfg(feature = "git")]
+                {
+                    GitSettings::from_settings(user_settings)?
+                        .ignore_filters
+                        .into_iter()
+                        .collect()
+                }
+                #[cfg(not(feature = "git"))]
+                {
+                    HashSet::new()
+                }
+            },
         })
     }
 }
@@ -986,6 +1010,10 @@ pub struct TreeState {
     exec_policy: ExecChangePolicy,
     fsmonitor_settings: FsmonitorSettings,
     target_eol_strategy: TargetEolStrategy,
+
+    // attributes
+    git_attributes: Arc<GitAttributes>,
+    ignore_filters: HashSet<String>,
 }
 
 #[derive(Debug, Error)]
@@ -1046,14 +1074,21 @@ impl TreeState {
             eol_conversion_mode,
             exec_change_setting,
             fsmonitor_settings,
+            ignore_filters,
         }: &TreeStateSettings,
     ) -> Self {
         let exec_policy = ExecChangePolicy::new(*exec_change_setting, &state_path);
+        let tree = store.empty_merged_tree();
+
+        let store_file_loader = TreeFileLoader::new(tree.clone());
+        let disk_file_loader = DiskFileLoader::new(working_copy_path.clone());
+
+        let git_attributes = Arc::new(GitAttributes::new(store_file_loader, disk_file_loader));
         Self {
             store: store.clone(),
             working_copy_path,
             state_path,
-            tree: store.empty_merged_tree(),
+            tree,
             file_states: FileStatesMap::new(),
             sparse_patterns: vec![RepoPathBuf::root()],
             own_mtime: MillisSinceEpoch(0),
@@ -1063,6 +1098,9 @@ impl TreeState {
             exec_policy,
             fsmonitor_settings: fsmonitor_settings.clone(),
             target_eol_strategy: TargetEolStrategy::new(*eol_conversion_mode),
+            // TODO We should update git_attributes every time TreeState::tree_id is updated
+            git_attributes,
+            ignore_filters: ignore_filters.clone(),
         }
     }
 
@@ -1311,6 +1349,8 @@ impl TreeState {
                 error: OnceLock::new(),
                 progress: *progress,
                 max_new_file_size: *max_new_file_size,
+                git_attributes: self.git_attributes.clone(),
+                ignore_filters: self.ignore_filters.clone(),
             };
             let directory_to_visit = DirectoryToVisit {
                 dir: RepoPathBuf::root(),
@@ -1482,6 +1522,9 @@ struct FileSnapshotter<'a> {
     error: OnceLock<SnapshotError>,
     progress: Option<&'a SnapshotProgress<'a>>,
     max_new_file_size: u64,
+
+    git_attributes: Arc<GitAttributes>,
+    ignore_filters: HashSet<String>,
 }
 
 impl FileSnapshotter<'_> {
@@ -1623,7 +1666,16 @@ impl FileSnapshotter<'_> {
             if let Some(progress) = self.progress {
                 progress(&path);
             }
-            if maybe_current_file_state.is_none()
+            if self
+                .git_attributes
+                .filter_matches(&path, &self.ignore_filters, SearchPriority::Disk)
+                .block_on()
+            {
+                // Skip gitattributes files that we want to ignore - this
+                // would result in them showing up as deleted, but we also
+                // omit them in `emit_deleted_files` to avoid that.
+                Ok(None)
+            } else if maybe_current_file_state.is_none()
                 && (git_ignore.matches(path.as_internal_file_string())
                     && !self.force_tracking_matcher.matches(&path))
             {
@@ -1767,6 +1819,13 @@ impl FileSnapshotter<'_> {
             .flat_map(|(_, chunk)| chunk)
             // Whether or not the entry exists, submodule should be ignored
             .filter(|(_, state)| state.file_type != FileType::GitSubmodule)
+            // Whether or not the entry exists, ignored gitattributes files should be omitted
+            .filter(|(path, _)| {
+                !self
+                    .git_attributes
+                    .filter_matches(path, &self.ignore_filters, SearchPriority::Disk)
+                    .block_on()
+            })
             .filter(|(path, _)| self.matcher.matches(path))
             .try_for_each(|(path, _)| self.deleted_files_tx.send(path.to_owned()))
             .ok();

lib/src/working_copy.rs

@@ -29,6 +29,7 @@ use tracing::instrument;
 use crate::backend::BackendError;
 use crate::commit::Commit;
 use crate::dag_walk;
+use crate::gitattributes::GitAttributesError;
 use crate::gitignore::GitIgnoreError;
 use crate::gitignore::GitIgnoreFile;
 use crate::matchers::Matcher;
@@ -191,6 +192,9 @@ pub enum SnapshotError {
     /// Checking path with ignore patterns failed.
     #[error(transparent)]
     GitIgnoreError(#[from] GitIgnoreError),
+    /// Checking path with gitattributes patterns failed.
+    #[error(transparent)]
+    GitAttributesError(#[from] GitAttributesError),
     /// Failed to load the working copy state.
     #[error(transparent)]
     WorkingCopyStateError(#[from] WorkingCopyStateError),