Print progress at once off a terminal, keep stderr to one writer (closes #13)

On a pipe, a file or /dev/null each scan phase now prints its zero-state
line the moment it starts instead of after its first finished item, so
a slow first read under cron no longer leaves the log silent. Terminal
detection uses golang.org/x/term, now a direct dependency listed in the
README; the old character-device test took /dev/null for a terminal.
The walk spinner no longer redraws from the library's own goroutine; it
advances only as items complete, so a redraw cannot garble a warning.
Building the bar moved into newBar so the terminal display can be
tested without a terminal.

Lint suppressed: gosec on two test file opens, paralleltest on three
tests that replace os.Stderr.

Model: opus-5-5

progress.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/schollz/progressbar/v3"
+	"golang.org/x/term"
 )
 
 // plainInterval is the minimum time between progress lines when stderr
@@ -24,24 +25,21 @@ const percentScale = 100
 
 // stderrIsTTY reports whether stderr is attached to a terminal.
 func stderrIsTTY() bool {
-	fi, err := os.Stderr.Stat()
-	if err != nil {
-		return false
-	}
-
-	return fi.Mode()&os.ModeCharDevice != 0
+	return term.IsTerminal(int(os.Stderr.Fd()))
 }
 
 // progress renders one scan pass's progress on stderr. On a TTY it
 // delegates to the progressbar library (spinner style when the total is
 // unknown, full bar with count/percent/rate/elapsed/ETA otherwise). When
 // stderr is not a TTY it emits no ANSI redraws: it prints a plain
-// one-line update no more often than every plainInterval.
+// one-line update as the pass starts, then no more often than every
+// plainInterval.
 //
-// All methods must be called from the main goroutine only. A nil
-// *progress is a valid no-display receiver: every method is a no-op,
-// so batched database flushes during the streaming pass can reuse the
-// update-pass helpers without rendering anything.
+// All methods must be called from the main goroutine only; nothing
+// else writes to stderr while a pass runs. A nil *progress is a valid
+// no-display receiver: every method is a no-op, so batched database
+// flushes during the streaming pass can reuse the update-pass helpers
+// without rendering anything.
 type progress struct {
 	label string
 	total int64 // -1 when unknown (walk pass)
@@ -53,10 +51,22 @@ type progress struct {
 
 func newProgress(label string, total int64) *progress {
 	p := &progress{label: label, total: total, start: time.Now()}
-	if !stderrIsTTY() {
+	if stderrIsTTY() {
+		p.bar = newBar(label, total)
+
 		return p
 	}
 
+	// Print the zero state at once: the first item may take minutes,
+	// and a pass must never look hung.
+	p.last = p.start
+	fmt.Fprintln(os.Stderr, p.plainLine())
+
+	return p
+}
+
+// newBar builds the TTY display for newProgress.
+func newBar(label string, total int64) *progressbar.ProgressBar {
 	opts := []progressbar.Option{
 		progressbar.OptionSetWriter(os.Stderr),
 		progressbar.OptionSetDescription(label),
@@ -78,12 +88,14 @@ func newProgress(label string, total int64) *progress {
 		opts = append(opts,
 			progressbar.OptionSetPredictTime(false),
 			progressbar.OptionSpinnerType(walkSpinnerType),
+			// Advance the spinner only on Add. The library's default
+			// redraws it from its own goroutine every 100ms, which
+			// garbles a warning printed at the same moment.
+			progressbar.OptionSetSpinnerChangeInterval(0),
 		)
 	}
 
-	p.bar = progressbar.NewOptions64(total, opts...)
-
-	return p
+	return progressbar.NewOptions64(total, opts...)
 }
 
 // increment records one completed item and refreshes the display.