chore: import upstream snapshot with attribution

internal/progress/term.go

@@ -0,0 +1,75 @@
+package progress
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/charmbracelet/x/ansi"
+	"github.com/muesli/termenv"
+	"golang.org/x/term"
+)
+
+// ANSI control sequences used by the live renderer. Private-mode toggles that
+// a terminal doesn't implement (the ?2026 synchronized-update pair) are
+// ignored by spec, so they are safe to emit unconditionally.
+const (
+	ansiHideCursor = "\x1b[?25l"
+	ansiShowCursor = "\x1b[?25h"
+	ansiClearEOL   = "\x1b[K"
+	ansiClearBelow = "\x1b[J"
+	ansiSyncStart  = "\x1b[?2026h"
+	ansiSyncEnd    = "\x1b[?2026l"
+	ansiReset      = "\x1b[0m"
+)
+
+// ansiUp moves the cursor n lines up (column unchanged). n <= 0 is a no-op.
+func ansiUp(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("\x1b[%dA", n)
+}
+
+// colorProfileFor resolves the color depth for the animated renderer bound to
+// w. termenv's per-platform detection covers COLORTERM / TERM on unix and the
+// console-API probes on Windows; a writer that isn't a real terminal (frame
+// capture under GORTEX_FORCE_ANIMATION) degrades to plain-byte styles unless
+// the caller overrides the profile explicitly.
+func colorProfileFor(w io.Writer) termenv.Profile {
+	return termenv.NewOutput(w).ColorProfile()
+}
+
+// termSize returns the terminal dimensions behind w, falling back to a
+// conservative 80×24 when w has no descriptor or the ioctl fails (captures,
+// tests). Queried per frame so a live resize re-clamps the next repaint
+// without any platform-specific resize signal.
+func termSize(w io.Writer) (width, height int) {
+	width, height = 80, 24
+	f, ok := w.(interface{ Fd() uintptr })
+	if !ok {
+		return width, height
+	}
+	cw, ch, err := term.GetSize(int(f.Fd()))
+	if err != nil || cw <= 0 || ch <= 0 {
+		return width, height
+	}
+	return cw, ch
+}
+
+// visibleWidth measures the printable cell width of a styled line,
+// ANSI-aware.
+func visibleWidth(s string) int { return ansi.StringWidth(s) }
+
+// clampLine hard-truncates a styled line to width cells, ANSI-aware, so a
+// frame line can never soft-wrap. Soft wrap is fatal to a repaint renderer:
+// one wrapped line desyncs the cursor-up arithmetic and every later frame
+// smears. The ellipsis tail marks the cut.
+func clampLine(s string, width int, ellipsis string) string {
+	if width <= 0 {
+		return ""
+	}
+	if ansi.StringWidth(s) <= width {
+		return s
+	}
+	return ansi.Truncate(s, width, ellipsis)
+}