Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
fix(output): strip stderr color on a pipe where std's eprint! kept it (#3771)
Worktrunk Botec0f3a344f3f
diff --git a/src/commands/config/update.rs b/src/commands/config/update.rsindex a2a0b9a5a..2da0d7d8c 100644--- a/src/commands/config/update.rs+++ b/src/commands/config/update.rs@@ -15,8 +15,8 @@ use worktrunk::config::{};use worktrunk::git::Repository;use worktrunk::styling::{- eprintln, format_bash_with_gutter, hint_message, info_message, print, println, success_message,- suggest_command_in_dir,+ eprint, eprintln, format_bash_with_gutter, hint_message, info_message, print, println,+ success_message, suggest_command_in_dir,};use crate::output::prompt::{PromptResponse, prompt_yes_no_preview};diff --git a/src/commands/for_each.rs b/src/commands/for_each.rsindex 003433a92..96fc9f9d6 100644--- a/src/commands/for_each.rs+++ b/src/commands/for_each.rs@@ -24,7 +24,7 @@//!//! For now, we keep `for-each` under `step` as a pragmatic choice.-use std::io::{Write as _, stderr};+use std::io::Write as _;use std::process::Stdio;use color_print::cformat;@@ -32,7 +32,8 @@ use worktrunk::config::{UserConfig, VarScope};use worktrunk::git::{ErrorExt, Repository, WorktreeInfo, WorktrunkError};use worktrunk::shell_exec::{Cmd, ShellEscapeMode};use worktrunk::styling::{- eprintln, error_message, format_with_gutter, progress_message, success_message, warning_message,+ eprint, eprintln, error_message, format_with_gutter, progress_message, stderr, success_message,+ warning_message,};use crate::commands::command_executor::{CommandContext, build_hook_context};@@ -220,6 +221,12 @@ fn run_argv(argv: Vec<String>,stdin_json: &str,) -> anyhow::Result<()> {+ // Reset ANSI codes on stderr so our color doesn't bleed into the child's+ // output, the same three lines `execute_shell_command` runs before its own+ // spawn. Both `eprint!` and `stderr` are anstream's: the flushes have to+ // name the stream the reset was written to, and on a redirected stderr+ // anstream drops the reset rather than writing a literal `ESC[0m` into the+ // file.stderr().flush()?;eprint!("{}", anstyle::Reset);stderr().flush().ok();diff --git a/src/commands/list/mod.rs b/src/commands/list/mod.rsindex 06e0047ab..d8592c2cf 100644--- a/src/commands/list/mod.rs+++ b/src/commands/list/mod.rs@@ -134,7 +134,7 @@ use anstyle::Style;use model::{BranchScope, ItemKind, ListData, ListItem};use progressive::RenderTarget;use worktrunk::git::Repository;-use worktrunk::styling::INFO_SYMBOL;+use worktrunk::styling::{INFO_SYMBOL, eprintln};use crate::output::print_json;@@ -213,7 +213,7 @@ pub(crate) fn resolve_json_schema(repo: &Repository) -> u8 {use std::sync::Once;use color_print::cformat;- use worktrunk::styling::{eprintln, hint_message, warning_message};+ use worktrunk::styling::{hint_message, warning_message};static WARNED: Once = Once::new();match repo.config().list.json_schema {diff --git a/src/config/deprecation.rs b/src/config/deprecation.rsindex 551b52473..d42c2ca9a 100644--- a/src/config/deprecation.rs+++ b/src/config/deprecation.rs@@ -45,7 +45,7 @@ use shell_escape::unix::escape;use crate::config::WorktrunkConfig;use crate::shell_exec::Cmd;use crate::styling::{- eprintln, format_with_gutter, hint_message, info_message, suggest_command_in_dir,+ eprint, eprintln, format_with_gutter, hint_message, info_message, suggest_command_in_dir,warning_message,};diff --git a/src/output/global.rs b/src/output/global.rsindex b807f52c3..57160b28b 100644--- a/src/output/global.rs+++ b/src/output/global.rs@@ -64,7 +64,7 @@ use worktrunk::shell_exec::scrub_git_discovery_env_vars;use worktrunk::shell_exec::{DIRECTIVE_CD_FILE_ENV_VAR, DIRECTIVE_EXEC_FILE_ENV_VAR, RETIRED_DIRECTIVE_FILE_ENV_VAR,};-use worktrunk::styling::{hint_message, stderr, warning_message};+use worktrunk::styling::{eprintln, hint_message, stderr, warning_message};/// Issue tracking whether to relax the EXEC scrub further for project aliases/// and hooks. (User aliases already pass EXEC through.) Emitted in the warningdiff --git a/src/output/prompt.rs b/src/output/prompt.rsindex 9950873c3..d5c25d407 100644--- a/src/output/prompt.rs+++ b/src/output/prompt.rs@@ -3,7 +3,7 @@use std::io::{self, Write};use color_print::cformat;-use worktrunk::styling::PROMPT_SYMBOL;+use worktrunk::styling::{PROMPT_SYMBOL, eprint, eprintln};/// Response from a `[y/N/?]` prompt.#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -42,7 +42,7 @@ pub fn prompt_yes_no_preview(show_preview: impl Fn(),) -> io::Result<PromptResponse> {// Blank line before first prompt for visual separation- worktrunk::styling::eprintln!();+ eprintln!();loop {eprint!(diff --git a/tests/integration_tests/output_system_guard.rs b/tests/integration_tests/output_system_guard.rsindex 2a7ff58e2..1b9d66210 100644--- a/tests/integration_tests/output_system_guard.rs+++ b/tests/integration_tests/output_system_guard.rs@@ -10,7 +10,9 @@//! This test enforces: **No accidental stdout writes anywhere under `src/`**//!//! Allowed:-//! - `eprintln!` / `eprint!` (stderr is safe)+//! - `eprintln!` / `eprint!` — stderr is not the answer stream, so writing to+//! it is safe; *which* macro of that name is in scope is a separate rule,+//! enforced by [`check_stderr_macros_come_from_styling`]//! - `println!` / `print!` in files listed in `STDOUT_ALLOWED_PATHS`//!//! When adding stdout output:@@ -22,7 +24,14 @@//!//! anstream's macros don't panic when the consumer closes the pipe, which//! [`test_stdout_surfaces_survive_a_closed_consumer`] checks from the outside.+//!+//! The stderr counterpart is two tests: [`check_stderr_macros_come_from_styling`]+//! requires every bare `eprint!`/`eprintln!` under `src/` to resolve to+//! anstream's, statically and for every site; and+//! [`test_stderr_narration_strips_ansi_when_piped`] proves from the outside+//! what that buys — narration redirected to a file carries no escapes.+use std::collections::HashSet;use std::fs;use std::path::Path;use std::process::Stdio;@@ -202,6 +211,172 @@ fn check_file(path: &Path, tokens: &[&str], violations: &mut Vec<String>, scan_r}}+/// Paths (relative to `src/`) allowed to reach std's `eprint!`/`eprintln!`.+///+/// Every other file that writes to stderr must have the macro of that name in+/// scope from `worktrunk::styling`, or qualify the call — see+/// [`check_stderr_macros_come_from_styling`].+///+/// An entry exempts the **whole file**, not the call its comment names, so an+/// entry added for one narrow site also covers whatever that file grows later.+/// Keep the list to files where std's macro is right throughout.+const STD_STDERR_ALLOWED_PATHS: &[&str] = &[+ // Relays a stub's captured stderr verbatim; the bytes are the fixture's+ // data, so stripping their escapes would change what the test replays.+ "testing/mock_stub.rs",+ // A `#[cfg(test)]` skip diagnostic, not narration a user ever redirects.+ "remove_dir.rs",+];++/// Narration on stderr goes out through anstream, at every site.+///+/// `worktrunk::styling`'s `eprint!`/`eprintln!` are anstream's and strip ANSI+/// when stderr isn't a terminal; std's prelude macros of the same name keep it.+/// The two are one import apart and indistinguishable at the call site, so a+/// file that imported `eprintln` but not `eprint` printed a warning and the+/// hint beneath it through different printers — one line of `wt list 2>log`+/// carrying escapes and the next not.+///+/// No runtime test can cover this: it is a property of every stderr write in+/// the binary, and the suite's own `CLICOLOR_FORCE=1` forces color on both+/// printers, so a snapshot agrees no matter which macro is in scope. Hence a+/// static scan. A call may satisfy it either way — importing the macro from+/// `styling`, or qualifying the call as `styling::eprintln!(…)`.+#[test]+fn check_stderr_macros_come_from_styling() {+ let src_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");+ let mut violations = Vec::new();+ scan_stderr_macros(&src_dir, &src_dir, &mut violations);+ violations.sort();++ assert!(+ violations.is_empty(),+ "stderr writes that resolve to std's macro instead of anstream's:\n\n{}\n\n\+ std's `eprint!`/`eprintln!` keep ANSI escapes when stderr is redirected, so a\n\+ file mixing them with anstream's emits color on some lines of a log and not others.\n\+ Import the macro from `worktrunk::styling`, qualify the call as\n\+ `worktrunk::styling::eprintln!(…)`, or add the file to STD_STDERR_ALLOWED_PATHS\n\+ with a comment explaining why std's macro is the right one there.",+ violations.join("\n")+ );+}++fn scan_stderr_macros(dir: &Path, src_dir: &Path, violations: &mut Vec<String>) {+ let entries = match fs::read_dir(dir) {+ Ok(e) => e,+ Err(_) => return,+ };++ for entry in entries.flatten() {+ let path = entry.path();+ if path.is_dir() {+ scan_stderr_macros(&path, src_dir, violations);+ } else if path.extension().and_then(|s| s.to_str()) == Some("rs") {+ check_stderr_macros_in_file(&path, src_dir, violations);+ }+ }+}++fn check_stderr_macros_in_file(path: &Path, src_dir: &Path, violations: &mut Vec<String>) {+ let relative_path = path+ .strip_prefix(src_dir)+ .map(|p| p.to_slash_lossy())+ .unwrap_or_default();+ if STD_STDERR_ALLOWED_PATHS.contains(&relative_path.as_ref()) {+ return;+ }++ let contents = match fs::read_to_string(path) {+ Ok(c) => c,+ Err(_) => return,+ };+ let imported = styling_imports(&contents);++ for (line_num, line) in contents.lines().enumerate() {+ // A doc comment quoting `eprintln!` is prose, not a write.+ let code = match line.find("//") {+ Some(pos) => &line[..pos],+ None => line,+ };++ for macro_name in ["eprint", "eprintln"] {+ if imported.contains(macro_name) {+ continue;+ }+ let token = format!("{macro_name}!");+ for (pos, _) in code.match_indices(&token) {+ // `eprintln!` never matches the `eprint!` token — the `!` is+ // part of it — so only a leading identifier char can be a+ // false positive here.+ let preceded_by_ident = pos > 0+ && (code.as_bytes()[pos - 1].is_ascii_alphanumeric()+ || code.as_bytes()[pos - 1] == b'_');+ // A qualified `styling::eprintln!(…)` picks anstream's+ // regardless of what the file imported.+ if preceded_by_ident || code[..pos].ends_with("styling::") {+ continue;+ }+ violations.push(format!(+ "src/{relative_path}:{}: {}",+ line_num + 1,+ line.trim()+ ));+ }+ }+ }+}++/// Names a file imports from `worktrunk::styling` / `crate::styling`.+///+/// Only `use` statements count. A qualified call site (`styling::eprintln!(…)`)+/// carries the same `styling::` prefix but binds nothing, so counting it would+/// let a file's *bare* calls silently fall through to std's macro.+///+/// **Only *top-level* `use` statements count** — ones at column 0. The caller+/// tests coverage per file while Rust resolves imports per scope, so a+/// function-local `use worktrunk::styling::eprintln;` would otherwise mark+/// every other function in the file as covered when none of them is. Every+/// `eprint`/`eprintln` import in `src/` is top-level, so the narrower rule+/// costs nothing; a future function-local one fails this scan and gets+/// hoisted. (Function-local styling imports of *other* names do exist —+/// `commands/remove.rs`, `commands/configure_shell.rs` — so a caller that+/// checked a third macro could not assume the same.)+fn styling_imports(contents: &str) -> HashSet<String> {+ let mut imports = HashSet::new();+ let mut statement = String::new();++ for line in contents.lines() {+ if statement.is_empty() && !(line.starts_with("use ") || line.starts_with("pub use ")) {+ continue;+ }+ let trimmed = line.trim();+ statement.push_str(trimmed);+ if !trimmed.ends_with(';') {+ continue;+ }++ // `use worktrunk::styling::{a, b as c};` or `use crate::styling::a;`+ if let Some(pos) = statement.find("styling::") {+ let tail = &statement[pos + "styling::".len()..];+ let names = match tail.strip_prefix('{') {+ Some(braced) => braced.split_once('}').map(|(inner, _)| inner).unwrap_or(""),+ // The single-import form ends at the statement's `;`.+ None => tail.trim_end_matches(';'),+ };+ for name in names.split(',') {+ // `foo as bar` binds `bar`, which is not the macro this checks.+ let name = name.trim().split(" as ").next().unwrap_or("").trim();+ if !name.is_empty() {+ imports.insert(name.to_string());+ }+ }+ }+ statement.clear();+ }++ imports+}+/// Every stdout surface exits cleanly when its consumer stops reading.////// std's `print!`/`println!` panic on a `BrokenPipe`, so a command whose@@ -258,6 +433,44 @@ fn test_stdout_surfaces_survive_a_closed_consumer(repo: TestRepo) {}}+/// Narration on stderr strips its color when stderr isn't a terminal.+///+/// The stdout rule above has a stderr counterpart, and it is the same mistake:+/// `worktrunk::styling`'s `eprint!` is anstream's and strips ANSI off a+/// non-tty, std's prelude macro of the same name keeps it. A file that+/// imported `eprintln` from `styling` but not `eprint` got one of each, so a+/// deprecation warning and the hint printed directly beneath it disagreed+/// about whether `wt list 2>log` should carry escapes.+///+/// The suite's own `CLICOLOR_FORCE=1` is what hides this — it forces color on+/// both printers, so every snapshot agrees no matter which macro is in scope.+/// This test clears it and sets `NO_COLOR`, which only anstream honors.+///+/// The trigger is a deprecated `[ci]` block, whose warning is emitted by the+/// pre-deserialization deprecation pass on every command that loads config.+#[rstest]+fn test_stderr_narration_strips_ansi_when_piped(repo: TestRepo) {+ repo.write_project_config("[ci]\nplatform = \"github\"\n");++ let output = repo+ .wt_command()+ .arg("list")+ .env_remove("CLICOLOR_FORCE")+ .env("NO_COLOR", "1")+ .output()+ .expect("failed to run wt list");++ let stderr = String::from_utf8_lossy(&output.stderr);+ assert!(+ stderr.contains("deprecated"),+ "expected the [ci] deprecation warning on stderr; got: {stderr:?}"+ );+ assert!(+ !stderr.contains('\x1b'),+ "wt narration redirected to a file must not contain ANSI escapes; got: {stderr:?}"+ );+}+/// Whether stdout carries ANSI escapes is the consumer's call, except where a/// command declares otherwise.///