Reduce internal tty API surface to the only production-used helper (#6942)

The `golang.org/x/term` review found that `internal/tty` exposed two
helpers with no production callers: `IsStdoutTerminal` and
`StderrTerminalWidth`. This change trims the package to the single
stderr TTY check actually used by the logger and aligns tests with that
smaller surface.

- **API cleanup**
  - Remove unused `internal/tty` helpers:
    - `IsStdoutTerminal()`
    - `StderrTerminalWidth()`
- Keep `IsStderrTerminal()` as the only exported helper in the package.

- **Test realignment**
  - Drop tests that existed only to cover the removed helpers.
- Replace direct `golang.org/x/term` assertions in `internal/tty` tests
with a package-level behavior test that swaps `os.Stderr` to a pipe and
verifies it is not treated as a terminal.

- **Result**
- `internal/tty` now reflects actual usage in the codebase instead of
carrying uncalled wrapper APIs.

```go
// remaining package surface
func IsStderrTerminal() bool {
	return term.IsTerminal(int(os.Stderr.Fd()))
}
```

Author: lpcox

internal/tty/tty.go

@@ -1,6 +1,4 @@
 // Package tty provides utilities for TTY (terminal) detection.
-// This package uses golang.org/x/term for TTY detection, which aligns with
-// modern Go best practices and the spinner library v1.23.1+ implementation.
 package tty
 
 import (
@@ -13,19 +11,3 @@ import (
 func IsStderrTerminal() bool {
 	return term.IsTerminal(int(os.Stderr.Fd()))
 }
-
-// IsStdoutTerminal returns true if stdout is connected to a terminal.
-func IsStdoutTerminal() bool {
-	return term.IsTerminal(int(os.Stdout.Fd()))
-}
-
-// StderrTerminalWidth returns the width of the terminal connected to stderr
-// and true if successful. Returns 0 and false if stderr is not a terminal or
-// the width cannot be determined.
-func StderrTerminalWidth() (int, bool) {
-	width, _, err := term.GetSize(int(os.Stderr.Fd()))
-	if err != nil || width <= 0 {
-		return 0, false
-	}
-	return width, true
-}

internal/tty/tty_test.go

@@ -6,17 +6,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/term"
 )
 
-// TestIsStderrTerminal verifies the function agrees with the underlying
-// term.IsTerminal check for os.Stderr.
-func TestIsStderrTerminal(t *testing.T) {
-	expected := term.IsTerminal(int(os.Stderr.Fd()))
-	result := IsStderrTerminal()
-	assert.Equal(t, expected, result, "IsStderrTerminal should match term.IsTerminal(stderr)")
-}
-
 // TestIsStderrTerminal_ConsistentResult verifies that repeated calls return the same value,
 // confirming deterministic behavior with no side effects.
 func TestIsStderrTerminal_ConsistentResult(t *testing.T) {
@@ -35,47 +26,17 @@ func TestIsStderrTerminal_NotATerminalInCI(t *testing.T) {
 	assert.False(t, IsStderrTerminal(), "stderr should not be a terminal in CI")
 }
 
-// TestIsStdoutTerminal verifies the function agrees with the underlying
-// term.IsTerminal check for os.Stdout.
-func TestIsStdoutTerminal(t *testing.T) {
-	expected := term.IsTerminal(int(os.Stdout.Fd()))
-	result := IsStdoutTerminal()
-	assert.Equal(t, expected, result, "IsStdoutTerminal should match term.IsTerminal(stdout)")
-}
-
-// TestTermIsTerminal_PipeIsNotTerminal verifies that the underlying
-// term.IsTerminal correctly identifies a pipe as not a terminal. This
-// documents the invariant that IsStdoutTerminal and IsStderrTerminal rely on.
-func TestTermIsTerminal_PipeIsNotTerminal(t *testing.T) {
+// TestIsStderrTerminal_WithPipe verifies that a pipe-backed stderr is not treated as a terminal.
+func TestIsStderrTerminal_WithPipe(t *testing.T) {
+	originalStderr := os.Stderr
 	r, w, err := os.Pipe()
 	require.NoError(t, err)
-	defer r.Close()
-	defer w.Close()
-	assert.False(t, term.IsTerminal(int(r.Fd())), "pipe file descriptor should not be a terminal")
-	assert.False(t, term.IsTerminal(int(w.Fd())), "pipe write-end should not be a terminal")
-}
-
-// TestStderrTerminalWidth verifies that StderrTerminalWidth returns consistent
-// results and only reports success when stderr is a terminal.
-func TestStderrTerminalWidth(t *testing.T) {
-	width, ok := StderrTerminalWidth()
-	isTerminal := term.IsTerminal(int(os.Stderr.Fd()))
-	if isTerminal {
-		assert.True(t, ok, "should succeed when stderr is a terminal")
-		assert.Greater(t, width, 0, "terminal width should be positive")
-	} else {
-		assert.False(t, ok, "should fail when stderr is not a terminal")
-		assert.Equal(t, 0, width, "width should be 0 when not a terminal")
-	}
-}
-
-// TestStderrTerminalWidth_NotATerminalInCI verifies that width detection
-// returns false in CI where stderr is not a terminal.
-func TestStderrTerminalWidth_NotATerminalInCI(t *testing.T) {
-	if os.Getenv("CI") == "" && os.Getenv("GITHUB_ACTIONS") == "" {
-		t.Skip("Skipping CI-specific assertion: not running in a CI environment")
-	}
-	width, ok := StderrTerminalWidth()
-	assert.False(t, ok, "should not detect terminal width in CI")
-	assert.Equal(t, 0, width, "width should be 0 in CI")
+	t.Cleanup(func() {
+		os.Stderr = originalStderr
+		require.NoError(t, r.Close())
+		require.NoError(t, w.Close())
+	})
+	os.Stderr = w
+
+	assert.False(t, IsStderrTerminal(), "pipe-backed stderr should not be a terminal")
 }