fix(cli): narrow agent output to oxlint

Author: JoviDeCroock

apps/oxfmt/src/cli/command.rs

@@ -23,8 +23,6 @@ pub struct FormatCommand {
     #[bpaf(external(mode))]
     pub mode: Mode,
     #[bpaf(external)]
-    pub output_options: OutputOptions,
-    #[bpaf(external)]
     pub config_options: ConfigOptions,
     #[bpaf(external)]
     pub ignore_options: IgnoreOptions,
@@ -130,14 +128,6 @@ fn output_mode() -> impl bpaf::Parser<OutputMode> {
     bpaf::construct!([write, check, list_different]).group_help("Output Options:")
 }
 
-/// Output options
-#[derive(Debug, Clone, Bpaf)]
-pub struct OutputOptions {
-    /// Reduce CLI output for agents: print only changed paths and one-line diagnostics
-    #[bpaf(long("agent"), switch, hide)]
-    pub agent: bool,
-}
-
 /// Migration Source
 #[cfg(feature = "napi")]
 #[derive(Debug, Clone)]
@@ -183,16 +173,3 @@ pub struct RuntimeOptions {
     #[bpaf(argument("INT"), hide_usage)]
     pub threads: Option<usize>,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{Mode, OutputMode, format_command};
-
-    #[test]
-    fn agent_output_option() {
-        let command = format_command().run_inner(&["--agent", "--check", "."]).unwrap();
-
-        assert!(command.output_options.agent);
-        assert!(matches!(command.mode, Mode::Cli(OutputMode::Check)));
-    }
-}

apps/oxfmt/src/cli/reporter.rs

@@ -1,6 +1,6 @@
 use oxc_diagnostics::{
-    Error, GraphicalReportHandler, Severity,
-    reporter::{DiagnosticReporter, DiagnosticResult, Info},
+    Error, GraphicalReportHandler,
+    reporter::{DiagnosticReporter, DiagnosticResult},
 };
 
 // This reporter is used with stderr and displays diagnostics only in a graphical way.
@@ -36,85 +36,3 @@ impl DiagnosticReporter for DefaultReporter {
         Some(output)
     }
 }
-
-#[derive(Debug, Default)]
-pub struct AgentReporter;
-
-impl DiagnosticReporter for AgentReporter {
-    fn finish(&mut self, _result: &DiagnosticResult) -> Option<String> {
-        None
-    }
-
-    fn supports_minified_file_fallback(&self) -> bool {
-        false
-    }
-
-    fn render_error(&mut self, error: Error) -> Option<String> {
-        Some(format_agent(&error))
-    }
-}
-
-fn format_agent(diagnostic: &Error) -> String {
-    let Info { start, filename, .. } = Info::new(diagnostic);
-    let filename = if filename.is_empty() {
-        diagnostic
-            .source_code()
-            .and_then(miette::SourceCode::name)
-            .map_or_else(|| "<unknown>".to_string(), ToString::to_string)
-    } else {
-        filename
-    };
-    let severity = match diagnostic.severity() {
-        Some(Severity::Warning) => "warning",
-        Some(Severity::Advice) => "advice",
-        _ => "error",
-    };
-    let message = compact_message(&diagnostic.to_string());
-
-    if start.line == 0 {
-        format!("{filename}: {severity}: {message}\n")
-    } else {
-        format!("{filename}:{}:{}: {severity}: {message}\n", start.line, start.column)
-    }
-}
-
-fn compact_message(message: &str) -> String {
-    let mut compact = String::new();
-    for word in message.split_whitespace() {
-        if !compact.is_empty() {
-            compact.push(' ');
-        }
-        compact.push_str(word);
-    }
-    compact
-}
-
-#[cfg(test)]
-mod tests {
-    use oxc_diagnostics::{NamedSource, OxcDiagnostic, reporter::DiagnosticReporter};
-    use oxc_span::Span;
-
-    use super::AgentReporter;
-
-    #[test]
-    fn agent_reporter_with_label() {
-        let mut reporter = AgentReporter;
-        let error = OxcDiagnostic::error("Unexpected token")
-            .with_label(Span::new(0, 1))
-            .with_source_code(NamedSource::new("file.js", "!"));
-
-        assert_eq!(reporter.render_error(error).unwrap(), "file.js:1:1: error: Unexpected token\n");
-    }
-
-    #[test]
-    fn agent_reporter_without_label() {
-        let mut reporter = AgentReporter;
-        let error = OxcDiagnostic::error("Failed to save file\npermission denied")
-            .with_source_code(NamedSource::new("file.js", ""));
-
-        assert_eq!(
-            reporter.render_error(error).unwrap(),
-            "file.js: error: Failed to save file permission denied\n"
-        );
-    }
-}

apps/oxfmt/src/cli/service.rs

@@ -22,20 +22,14 @@ pub struct FormatService {
     cwd: Box<Path>,
     format_mode: OutputMode,
     formatter: SourceFormatter,
-    agent_output: bool,
 }
 
 impl FormatService {
-    pub fn new<T>(
-        cwd: T,
-        format_mode: OutputMode,
-        formatter: SourceFormatter,
-        agent_output: bool,
-    ) -> Self
+    pub fn new<T>(cwd: T, format_mode: OutputMode, formatter: SourceFormatter) -> Self
     where
         T: Into<Box<Path>>,
     {
-        Self { cwd: cwd.into(), format_mode, formatter, agent_output }
+        Self { cwd: cwd.into(), format_mode, formatter }
     }
 
     /// Process entries as they are received from the channel
@@ -46,8 +40,7 @@ impl FormatService {
         tx_success: &mpsc::Sender<SuccessResult>,
     ) {
         rx_entry.into_iter().par_bridge().for_each(|strategy| {
-            let start_time = (matches!(self.format_mode, OutputMode::Check) && !self.agent_output)
-                .then(Instant::now);
+            let start_time = matches!(self.format_mode, OutputMode::Check).then(Instant::now);
 
             let path: Arc<Path> = Arc::clone(strategy.path());
             let Ok(source_text) = utils::read_to_string(&path) else {
@@ -115,7 +108,7 @@ impl FormatService {
                         .cow_replace('\\', "/")
                         .to_string();
 
-                    if matches!(self.format_mode, OutputMode::Check) && !self.agent_output {
+                    if matches!(self.format_mode, OutputMode::Check) {
                         let elapsed = start_time.unwrap().elapsed().as_millis();
                         SuccessResult::Changed(format!("{display_path} ({elapsed}ms)"))
                     } else {

apps/oxfmt/src/cli/walk_runner.rs

@@ -1,10 +1,10 @@
 use std::{env, io::BufWriter, path::PathBuf, sync::mpsc, time::Instant};
 
-use oxc_diagnostics::{DiagnosticService, reporter::DiagnosticReporter};
+use oxc_diagnostics::DiagnosticService;
 
 use super::{
     command::{FormatCommand, Mode, OutputMode},
-    reporter::{AgentReporter, DefaultReporter},
+    reporter::DefaultReporter,
     resolve::resolve_ignore_paths,
     result::CliRunResult,
     service::{FormatService, SuccessResult},
@@ -69,20 +69,13 @@ impl WalkRunner {
         let start_time = Instant::now();
 
         let cwd = self.cwd;
-        let FormatCommand {
-            paths,
-            mode,
-            output_options,
-            config_options,
-            ignore_options,
-            runtime_options,
-        } = self.options;
+        let FormatCommand { paths, mode, config_options, ignore_options, runtime_options } =
+            self.options;
         // If `napi` feature is disabled, there is no other mode.
         #[cfg_attr(not(feature = "napi"), expect(irrefutable_let_patterns))]
         let Mode::Cli(format_mode) = mode else {
             unreachable!("`WalkRunner` should only be called with Mode::Cli");
         };
-        let agent_output = output_options.agent;
         let num_of_threads = rayon::current_num_threads();
 
         // Find and load root config file
@@ -147,14 +140,10 @@ impl WalkRunner {
         // Collect format results (changed paths or unchanged count)
         let (tx_success, rx_success) = mpsc::channel();
         // Diagnostic from formatting service
-        let reporter: Box<dyn DiagnosticReporter> = if agent_output {
-            Box::new(AgentReporter)
-        } else {
-            Box::new(DefaultReporter::default())
-        };
-        let (mut diagnostic_service, tx_error) = DiagnosticService::new(reporter);
+        let (mut diagnostic_service, tx_error) =
+            DiagnosticService::new(Box::new(DefaultReporter::default()));
 
-        if matches!(format_mode, OutputMode::Check) && !agent_output {
+        if matches!(format_mode, OutputMode::Check) {
             utils::print_and_flush(stdout, "Checking formatting...\n");
             utils::print_and_flush(stdout, "\n");
         }
@@ -172,8 +161,7 @@ impl WalkRunner {
         // Spawn formatting service on a dedicated thread so it doesn't occupy the rayon pool.
         // It just blocks on `rx_entry` waiting for entries; `par_bridge()` inside still uses rayon.
         std::thread::spawn(move || {
-            let format_service =
-                FormatService::new(cwd, format_mode, source_formatter, agent_output);
+            let format_service = FormatService::new(cwd, format_mode, source_formatter);
             format_service.run_streaming(rx_entry, &tx_error_for_format, &tx_success);
         });
 
@@ -218,11 +206,7 @@ impl WalkRunner {
         // Print sorted changed file paths to stdout
         if !changed_paths.is_empty() {
             changed_paths.sort_unstable();
-            if agent_output {
-                utils::print_and_flush(stdout, &format!("{}\n", changed_paths.join("\n")));
-            } else {
-                utils::print_and_flush(stdout, &changed_paths.join("\n"));
-            }
+            utils::print_and_flush(stdout, &changed_paths.join("\n"));
         }
 
         // Then, output diagnostics errors to stderr
@@ -234,10 +218,6 @@ impl WalkRunner {
         // Count the processed files
         let total_target_files_count = changed_paths.len() + unchanged_count + error_count;
         let print_stats = |stdout, stderr| {
-            if agent_output {
-                return;
-            }
-
             utils::print_and_flush(
                 stdout,
                 &format!(
@@ -259,32 +239,24 @@ impl WalkRunner {
         // Check if no files were found
         if total_target_files_count == 0 {
             if runtime_options.no_error_on_unmatched_pattern {
-                if !agent_output {
-                    utils::print_and_flush(stderr, "No files found matching the given patterns.\n");
-                    print_stats(stdout, stderr);
-                }
+                utils::print_and_flush(stderr, "No files found matching the given patterns.\n");
+                print_stats(stdout, stderr);
                 return CliRunResult::None;
             }
 
-            if agent_output {
-                utils::print_and_flush(stderr, "No files found.\n");
-            } else {
-                utils::print_and_flush(
-                    stderr,
-                    "Expected at least one target file. All matched files may have been excluded by ignore rules.\n",
-                );
-            }
+            utils::print_and_flush(
+                stderr,
+                "Expected at least one target file. All matched files may have been excluded by ignore rules.\n",
+            );
             return CliRunResult::NoFilesFound;
         }
 
         if 0 < error_count {
             // Each error is already printed in reporter
-            if !agent_output {
-                utils::print_and_flush(
-                    stderr,
-                    "Error occurred when checking code style in the above files.\n",
-                );
-            }
+            utils::print_and_flush(
+                stderr,
+                "Error occurred when checking code style in the above files.\n",
+            );
             return CliRunResult::FormatFailed;
         }
 
@@ -294,23 +266,19 @@ impl WalkRunner {
             (OutputMode::ListDifferent, _) => CliRunResult::FormatMismatch,
             // `--check` outputs friendly summary
             (OutputMode::Check, 0) => {
-                if !agent_output {
-                    utils::print_and_flush(stdout, "All matched files use the correct format.\n");
-                    print_stats(stdout, stderr);
-                }
+                utils::print_and_flush(stdout, "All matched files use the correct format.\n");
+                print_stats(stdout, stderr);
                 CliRunResult::FormatSucceeded
             }
             (OutputMode::Check, changed_count) => {
-                if !agent_output {
-                    utils::print_and_flush(stdout, "\n\n");
-                    utils::print_and_flush(
-                        stdout,
-                        &format!(
-                            "Format issues found in above {changed_count} files. Run without `--check` to fix.\n",
-                        ),
-                    );
-                    print_stats(stdout, stderr);
-                }
+                utils::print_and_flush(stdout, "\n\n");
+                utils::print_and_flush(
+                    stdout,
+                    &format!(
+                        "Format issues found in above {changed_count} files. Run without `--check` to fix.\n",
+                    ),
+                );
+                print_stats(stdout, stderr);
                 CliRunResult::FormatMismatch
             }
             // Default (write) outputs only stats

apps/oxlint/src/command/lint.rs

@@ -256,16 +256,6 @@ pub struct OutputOptions {
     /// `checkstyle`, `default`, `github`, `gitlab`, `json`, `junit`, `stylish`, `unix`
     #[bpaf(long, short, fallback_with(default_output_format), hide_usage)]
     pub format: OutputFormat,
-
-    /// Reduce CLI output for agents. Alias for `--format agent`.
-    #[bpaf(long("agent"), switch, hide)]
-    pub agent: bool,
-}
-
-impl OutputOptions {
-    pub fn effective_format(&self) -> OutputFormat {
-        if self.agent { OutputFormat::Agent } else { self.format }
-    }
 }
 
 #[expect(clippy::unnecessary_wraps)]
@@ -554,7 +544,6 @@ mod lint_options {
         assert!(!options.fix_options.fix);
         assert!(!options.list_rules);
         assert_eq!(options.output_options.format, OutputFormat::Default);
-        assert!(!options.output_options.agent);
     }
 
     #[test]
@@ -615,20 +604,10 @@ mod lint_options {
     fn format() {
         let options = get_lint_options("-f json");
         assert_eq!(options.output_options.format, OutputFormat::Json);
-        assert!(!options.output_options.agent);
         assert!(options.paths.is_empty());
 
         let options = get_lint_options("-f agent");
         assert_eq!(options.output_options.format, OutputFormat::Agent);
-        assert_eq!(options.output_options.effective_format(), OutputFormat::Agent);
-    }
-
-    #[test]
-    fn agent() {
-        let options = get_lint_options("--agent");
-        assert_eq!(options.output_options.format, OutputFormat::Default);
-        assert!(options.output_options.agent);
-        assert_eq!(options.output_options.effective_format(), OutputFormat::Agent);
     }
 
     #[test]

apps/oxlint/src/lint.rs

@@ -68,7 +68,7 @@ impl CliRunner {
 
     /// # Panics
     pub fn run(self, stdout: &mut dyn Write) -> CliRunResult {
-        let format_str = self.options.output_options.effective_format();
+        let format_str = self.options.output_options.format;
         let output_formatter = OutputFormatter::new(format_str);
 
         let LintCommand {