Add --progress-bar option with interactive/simple/no modes

Summary:
When pyrefly is run by another tool such as pysa, the interactive progress bar produces garbled log output. This adds a `--progress-bar` option with three modes: `interactive` (default, the existing fancy progress bar), `simple` (log-style "Processed X of Y modules" lines suitable for non-interactive use), and `no` (disabled).

The existing `--no-progress-bar` (in check) and `--show-progress-bar` (in buck-check) are kept for backward compatibility but hidden from help output.

Reviewed By: stroxler

Differential Revision: D102639648

fbshipit-source-id: 8a6959837a31584b1560494c47d86f756f2314f5

Author: arthaud

pyrefly/lib/commands/buck_check.rs

@@ -37,7 +37,7 @@ use crate::error::legacy::LegacyErrors;
 use crate::report;
 use crate::state::require::Require;
 use crate::state::state::State;
-use crate::state::subscriber::ProgressBarSubscriber;
+use crate::state::subscriber::ProgressBarStyle;
 
 /// Arguments for Buck-powered type checking.
 #[deny(clippy::missing_docs_in_private_items)]
@@ -63,9 +63,16 @@ pub struct BuckCheckArgs {
     #[arg(long, value_enum, default_value_t = report::pysa::PysaFormat::Capnp)]
     report_pysa_format: report::pysa::PysaFormat,
 
-    /// Show a progress bar during type checking.
-    #[arg(long)]
+    /// Show a progress bar during type checking. Deprecated: use `--progress-bar=interactive` instead.
+    #[arg(long, hide = true)]
     show_progress_bar: bool,
+
+    /// Set the progress bar style.
+    /// `interactive` shows a visual progress bar.
+    /// `simple` prints periodic log-style progress messages (suitable for piping or non-interactive use).
+    /// `no` (default) disables progress reporting entirely.
+    #[arg(long, value_enum)]
+    progress_bar: Option<ProgressBarStyle>,
 }
 
 #[derive(Debug, Deserialize, PartialEq, Eq)]
@@ -90,7 +97,7 @@ fn compute_errors(
     thread_count: ThreadCount,
     report_pysa: Option<&Path>,
     report_pysa_format: report::pysa::PysaFormat,
-    show_progress_bar: bool,
+    progress_bar_style: ProgressBarStyle,
 ) -> anyhow::Result<Vec<Error>> {
     let modules_to_check = sourcedb.modules_to_check().into_iter().collect::<Vec<_>>();
 
@@ -134,19 +141,15 @@ fn compute_errors(
         transaction.as_mut().set_pysa_reporter(Some(reporter));
     }
 
-    if show_progress_bar {
-        transaction
-            .as_mut()
-            .set_subscriber(Some(Box::new(ProgressBarSubscriber::new())));
-    }
+    transaction
+        .as_mut()
+        .set_subscriber(progress_bar_style.make_subscriber());
 
     transaction
         .as_mut()
         .run(&modules_to_check, Require::Errors, None);
 
-    if show_progress_bar {
-        transaction.as_mut().set_subscriber(None);
-    }
+    transaction.as_mut().set_subscriber(None);
 
     let errors = transaction.as_ref().get_errors(&modules_to_check);
 
@@ -199,6 +202,17 @@ fn write_output(errors: &[Error], path: Option<&Path>) -> anyhow::Result<()> {
 }
 
 impl BuckCheckArgs {
+    fn progress_bar_style(&self) -> ProgressBarStyle {
+        if let Some(style) = &self.progress_bar {
+            return style.clone();
+        }
+        if self.show_progress_bar {
+            ProgressBarStyle::Interactive
+        } else {
+            ProgressBarStyle::No
+        }
+    }
+
     pub fn run(self, thread_count: ThreadCount) -> anyhow::Result<CommandExitStatus> {
         let input_file = read_input_file(self.input_path.as_path())?;
         let python_version = PythonVersion::from_str(&input_file.py_version)?;
@@ -216,7 +230,7 @@ impl BuckCheckArgs {
             thread_count,
             self.report_pysa.as_deref(),
             self.report_pysa_format,
-            self.show_progress_bar,
+            self.progress_bar_style(),
         )?;
         let min_severity = self.min_severity.unwrap_or(Severity::Error);
         let displayed_errors: Vec<Error> = type_errors

pyrefly/lib/commands/check.rs

@@ -75,7 +75,7 @@ use crate::state::require::Require;
 use crate::state::require::RequireLevels;
 use crate::state::state::State;
 use crate::state::state::Transaction;
-use crate::state::subscriber::ProgressBarSubscriber;
+use crate::state::subscriber::ProgressBarStyle;
 
 /// Result data from a non-watch check run, used for telemetry logging.
 pub struct CheckResult {
@@ -319,10 +319,17 @@ struct OutputArgs {
     )]
     summary: Summary,
 
-    /// Suppress the progress bar during type checking.
-    #[arg(long)]
+    /// Suppress the progress bar during type checking. Deprecated: use `--progress-bar=no` instead.
+    #[arg(long, hide = true)]
     no_progress_bar: bool,
 
+    /// Set the progress bar style.
+    /// `interactive` (default) shows a visual progress bar.
+    /// `simple` prints periodic log-style progress messages (suitable for piping or non-interactive use).
+    /// `no` disables progress reporting entirely.
+    #[arg(long, value_enum)]
+    progress_bar: Option<ProgressBarStyle>,
+
     /// When specified, strip this prefix from any paths in the output.
     /// Pass "" to show absolute paths. When omitted, we will use the current working directory.
     #[arg(long)]
@@ -358,6 +365,18 @@ impl OutputArgs {
     fn output_format(&self) -> OutputFormat {
         self.output_format.unwrap_or_default()
     }
+
+    /// Resolve the effective progress bar style, taking deprecated flags into account.
+    fn progress_bar_style(&self) -> ProgressBarStyle {
+        if let Some(style) = &self.progress_bar {
+            return style.clone();
+        }
+        if self.no_progress_bar || self.summary == Summary::None {
+            ProgressBarStyle::No
+        } else {
+            ProgressBarStyle::Interactive
+        }
+    }
 }
 
 #[derive(Clone, Debug, ValueEnum, Default, PartialEq, Eq)]
@@ -873,7 +892,7 @@ impl CheckArgs {
             let events = get_watcher_events(&mut watcher).await?;
             transaction = state.new_committable_transaction(
                 require_levels.default,
-                Some(Box::new(ProgressBarSubscriber::new())),
+                self.output.progress_bar_style().make_subscriber(),
             );
             let new_transaction_mut = transaction.as_mut();
             new_transaction_mut.invalidate_events(&events);
@@ -947,15 +966,9 @@ impl CheckArgs {
         }
 
         let type_check_start = Instant::now();
-        let show_progress_bar =
-            self.output.summary != Summary::None && !self.output.no_progress_bar;
-        if show_progress_bar {
-            transaction.set_subscriber(Some(Box::new(ProgressBarSubscriber::new())));
-        }
+        transaction.set_subscriber(self.output.progress_bar_style().make_subscriber());
         transaction.run(handles, require, None);
-        if show_progress_bar {
-            transaction.set_subscriber(None);
-        }
+        transaction.set_subscriber(None);
 
         let loads = if self.behavior.check_all {
             transaction.get_all_errors()
@@ -1159,7 +1172,7 @@ impl CheckArgs {
         }
         if let Some(output_path) = &self.output.report_timings {
             eprintln!("Computing timing information");
-            transaction.set_subscriber(Some(Box::new(ProgressBarSubscriber::new())));
+            transaction.set_subscriber(self.output.progress_bar_style().make_subscriber());
             transaction.report_timings(output_path)?;
             transaction.set_subscriber(None);
         }

pyrefly/lib/state/subscriber.rs

@@ -8,6 +8,7 @@
 use std::mem;
 use std::sync::Arc;
 
+use clap::ValueEnum;
 use dupe::Dupe;
 use indicatif::ProgressBar;
 use indicatif::ProgressStyle;
@@ -20,6 +21,29 @@ use starlark_map::small_map::SmallMap;
 use crate::state::load::Load;
 use crate::state::state::Transaction;
 
+/// Controls which progress bar style to use during type checking.
+#[derive(Clone, Debug, ValueEnum, Default, PartialEq, Eq)]
+pub enum ProgressBarStyle {
+    /// Show an interactive progress bar (default).
+    #[default]
+    Interactive,
+    /// Show simple log-style progress messages, suitable for non-interactive use.
+    Simple,
+    /// Disable progress reporting entirely.
+    No,
+}
+
+impl ProgressBarStyle {
+    /// Create a subscriber matching this style, or `None` if progress reporting is disabled.
+    pub fn make_subscriber(&self) -> Option<Box<dyn Subscriber>> {
+        match self {
+            ProgressBarStyle::Interactive => Some(Box::new(ProgressBarSubscriber::new())),
+            ProgressBarStyle::Simple => Some(Box::new(SimpleProgressBarSubscriber::new())),
+            ProgressBarStyle::No => None,
+        }
+    }
+}
+
 /// Trait to capture which handles are executed by `State`.
 /// Calls to `start_work` and `finish_work` will be paired.
 /// It may be the case that a single `Handle` is computed multiple times within a single call to `run`.
@@ -176,6 +200,45 @@ impl ProgressBarSubscriber {
     }
 }
 
+/// A simple progress bar subscriber that prints log-style progress messages.
+/// Suitable for non-interactive environments (e.g., when output is piped to a file
+/// or when pyrefly is invoked by another tool like pysa).
+pub struct SimpleProgressBarSubscriber {
+    state: Mutex<ProgressBarState>,
+}
+
+impl SimpleProgressBarSubscriber {
+    pub fn new() -> Self {
+        Self {
+            state: Mutex::new(ProgressBarState {
+                last_progress: 0,
+                started: 0,
+                finished: 0,
+            }),
+        }
+    }
+}
+
+impl Subscriber for SimpleProgressBarSubscriber {
+    fn start_work(&self, _: &Handle) {
+        self.state.lock().started += 1;
+    }
+
+    fn finish_work(&self, _: &Transaction<'_>, _: &Handle, _: &Arc<Load>, _: bool) {
+        let (finished, started) = {
+            let mut state = self.state.lock();
+            state.finished += 1;
+            (state.finished, state.started)
+        };
+        // Log at regular intervals to avoid flooding the output.
+        // Print on the first completion, then at every 1% of progress, and at the end.
+        let interval = (started / 100).max(1);
+        if finished == 1 || finished == started || finished % interval == 0 {
+            eprintln!("Processed {} of {} modules", finished, started);
+        }
+    }
+}
+
 pub struct PublishDiagnosticsSubscriber<F>
 where
     F: Fn(&Transaction<'_>, &Handle, bool) + Send + Sync,