Optimize diff checks for clean worktrees (#2109)

j178 · web-flow · commit d3b112ba20f9 · 2026-05-20T16:02:23.000+08:00
Avoid full before-and-after git diff calls when hooks run from a cleaned worktree and leave it unchanged. Closes #1464 Related #1327
diff --git a/crates/prek/src/cli/run/diff.rs b/crates/prek/src/cli/run/diff.rs
@@ -0,0 +1,77 @@
+use std::path::Path;
+
+use anyhow::Result;
+
+use crate::git;
+
+pub(super) struct DiffTracker<'a> {
+    path: &'a Path,
+    baseline: DiffBaseline,
+}
+
+enum DiffBaseline {
+    Clean,
+    Unknown,
+    Snapshot(Vec<u8>),
+}
+
+impl<'a> DiffTracker<'a> {
+    pub(super) fn clean_baseline(path: &'a Path) -> Self {
+        Self {
+            path,
+            baseline: DiffBaseline::Clean,
+        }
+    }
+
+    pub(super) fn unknown_baseline(path: &'a Path) -> Self {
+        Self {
+            path,
+            baseline: DiffBaseline::Unknown,
+        }
+    }
+
+    pub(super) async fn prepare_for_group(&mut self, may_modify_files: bool) -> Result<()> {
+        if may_modify_files && let DiffBaseline::Unknown = self.baseline {
+            self.baseline = DiffBaseline::Snapshot(git::get_diff(self.path).await?);
+        }
+        Ok(())
+    }
+
+    pub(super) async fn changed_after_group(
+        &mut self,
+        may_modify_files: bool,
+        all_skipped: bool,
+    ) -> Result<bool> {
+        // Read-only groups and fully skipped groups cannot change files, so avoid
+        // asking git about the working tree.
+        if !may_modify_files || all_skipped {
+            return Ok(false);
+        }
+
+        match &mut self.baseline {
+            DiffBaseline::Clean => {
+                // `WorkTreeKeeper` already removed unstaged changes. A quiet
+                // worktree check is enough unless the hook actually wrote files.
+                if !git::has_worktree_diff(self.path).await? {
+                    return Ok(false);
+                }
+                // Capture the dirty state after this group so later groups can
+                // compare against the exact diff left by previous hooks.
+                self.baseline = DiffBaseline::Snapshot(git::get_diff(self.path).await?);
+                Ok(true)
+            }
+            DiffBaseline::Snapshot(prev_diff) => {
+                // Unknown initial state, `--all-files`, and later dirty groups
+                // need a full before/after diff comparison to avoid confusing
+                // pre-existing user changes with hook changes.
+                let curr_diff = git::get_diff(self.path).await?;
+                let modified = curr_diff != *prev_diff;
+                *prev_diff = curr_diff;
+                Ok(modified)
+            }
+            DiffBaseline::Unknown => {
+                unreachable!("diff baseline must be captured before hooks can modify files")
+            }
+        }
+    }
+}
diff --git a/crates/prek/src/cli/run/mod.rs b/crates/prek/src/cli/run/mod.rs
@@ -6,6 +6,7 @@ pub(crate) use install::{InstallCache, install_hooks};
 pub(crate) use run::run;
 pub(crate) use selector::{SelectorSource, Selectors};
 
+mod diff;
 mod filter;
 mod install;
 mod keeper;
diff --git a/crates/prek/src/cli/run/run.rs b/crates/prek/src/cli/run/run.rs
@@ -16,6 +16,7 @@ use tracing::{debug, trace};
 use unicode_width::UnicodeWidthStr;
 
 use crate::cli::reporter::{HookInitReporter, HookInstallReporter, HookRunReporter};
+use crate::cli::run::diff::DiffTracker;
 use crate::cli::run::keeper::WorkTreeKeeper;
 use crate::cli::run::{
     CollectOptions, FileTagCache, HookFileFilter, ProjectFiles, RunInput, Selectors,
@@ -220,6 +221,7 @@ pub(crate) async fn run(
         show_diff_on_failure,
         fail_fast,
         dry_run,
+        should_stash,
         verbose,
         printer,
     )
@@ -445,6 +447,7 @@ async fn run_hooks<'paths>(
     show_diff_on_failure: bool,
     fail_fast: Option<bool>,
     dry_run: bool,
+    worktree_cleaned: bool,
     verbose: bool,
     printer: Printer,
 ) -> Result<ExitStatus> {
@@ -481,28 +484,30 @@ async fn run_hooks<'paths>(
         hooks.sort_by(|a, b| a.priority.cmp(&b.priority).then(a.idx.cmp(&b.idx)));
 
         session.render_project_header(project, projects_len)?;
-        let mut prev_diff = None;
+        // The worktree is only known clean at the start of the whole run. Once
+        // an earlier project leaves a diff behind, later projects need a fresh
+        // per-project snapshot to avoid attributing that diff to their hooks.
+        let mut diff_tracker = if worktree_cleaned && !session.file_modified {
+            DiffTracker::clean_baseline(project.path())
+        } else {
+            DiffTracker::unknown_baseline(project.path())
+        };
 
         let project_fail_fast = fail_fast.or(project.config().fail_fast).unwrap_or(false);
 
         for group_hooks in PriorityGroups::new(hooks) {
             let group_may_modify_files =
                 !session.dry_run && group_hooks.iter().any(|hook| hooks::may_modify_files(hook));
-            if group_may_modify_files && prev_diff.is_none() {
-                prev_diff = Some(git::get_diff(project.path()).await?);
-            }
+            diff_tracker
+                .prepare_for_group(group_may_modify_files)
+                .await?;
 
             let group_results = session
                 .run_priority_group(group_hooks, &project_input, tag_cache)
                 .await?;
 
             let hook_fail_fast = session
-                .finish_priority_group(
-                    group_results,
-                    project,
-                    group_may_modify_files,
-                    &mut prev_diff,
-                )
+                .finish_priority_group(group_results, group_may_modify_files, &mut diff_tracker)
                 .await?;
 
             if !session.success && (project_fail_fast || hook_fail_fast) {
@@ -614,26 +619,17 @@ impl<'a> HookRunSession<'a> {
     async fn finish_priority_group(
         &mut self,
         mut group_results: Vec<RunResult>,
-        project: &Project,
         group_may_modify_files: bool,
-        prev_diff: &mut Option<Vec<u8>>,
+        diff_tracker: &mut DiffTracker<'_>,
     ) -> Result<bool> {
         // Print results in a stable order (same order as config within the project).
         group_results.sort_unstable_by_key(|a| a.hook.idx);
 
         // Check if any files were modified by this group of hooks.
         let all_skipped = group_results.iter().all(|r| r.status.is_skipped());
-        let group_modified_files = if group_may_modify_files && !all_skipped {
-            let prev_diff = prev_diff
-                .as_mut()
-                .expect("previous diff must be captured before file-modifying hooks run");
-            let curr_diff = git::get_diff(project.path()).await?;
-            let group_modified_files = curr_diff != *prev_diff;
-            *prev_diff = curr_diff;
-            group_modified_files
-        } else {
-            false
-        };
+        let group_modified_files = diff_tracker
+            .changed_after_group(group_may_modify_files, all_skipped)
+            .await?;
 
         self.file_modified |= group_modified_files;
 
diff --git a/crates/prek/src/git.rs b/crates/prek/src/git.rs
@@ -355,6 +355,32 @@ async fn parse_merge_msg_for_conflicts() -> Result<Vec<PathBuf>, Error> {
     Ok(conflicts)
 }
 
+#[instrument(level = "trace")]
+pub(crate) async fn has_worktree_diff(path: &Path) -> Result<bool, Error> {
+    let mut cmd = git_cmd("check worktree diff")?;
+    let status = cmd
+        .arg("diff-files")
+        .arg("--quiet")
+        .arg("--no-ext-diff")
+        .arg("--no-textconv")
+        .arg("--ignore-submodules")
+        .arg("--")
+        .arg(path)
+        .check(false)
+        .status()
+        .await?;
+
+    if status.success() {
+        return Ok(false);
+    }
+    if status.code() == Some(1) {
+        return Ok(true);
+    }
+
+    cmd.check_status(status)?;
+    Ok(true)
+}
+
 #[instrument(level = "trace")]
 pub(crate) async fn get_diff(path: &Path) -> Result<Vec<u8>, Error> {
     let output = git_cmd("git diff")?
diff --git a/crates/prek/tests/skipped_hooks.rs b/crates/prek/tests/skipped_hooks.rs
