Treat \r as logical-line boundary and swallow stray padding spaces

Follow-up to #32. While that fix preserved \r-based progress updates
end-to-end, two cosmetic glitches remained when running real apt /
pip installs through run_command:

1. apt's progress UI sometimes emits a stray padding space after a
   \n, e.g. 'Fetched 52.4 MB in 30s (1,729 kB/s)\n Selecting...'.
   The previous logic treated the trailing space as the start of a
   fresh logical line, wrote the group prefix, then the space, then
   the real content -- producing output like:

       PITFT Fetched 52.4 MB in 30s (1,729 kB/s)
       PITFT  Selecting previously unselected package ...
              ^ stray space, prefix pushed one column right

2. A bare \r-only line (e.g. apt's 'erase-progress-line' sequence)
   was being treated as 'still on the same logical line', so the
   next chunk's content would not get a prefix at all -- producing:

       PITFT 52.4 MB ...
       Selecting previously unselected package ...
       ^ no PITFT prefix; line just looks orphaned

Reproduced both with a deterministic harness. Same root cause: the
splitter only recognized \n as a logical-line boundary, and the
emitter treated any non-empty body at line-start as 'real content'
(so apt's padding-space pushed the prefix right).

This change:

* Splits chunks on either \n or runs of \r (\r+), so cursor-at-col-0
  is the actual boundary, not just newline.
* Strips leading horizontal whitespace (spaces and tabs) immediately
  after a boundary, so padding from the source process doesn't push
  the prefix right.
* Suppresses the prefix entirely when a logical line is pure padding,
  but keeps the terminator (the \r or \n) so the terminal still sees
  cursor motion.
* Stays in line-start state when an unterminated tail was pure
  padding, so the next chunk's real content still gets a prefix.

Pip-style \r-only progress bars now correctly keep the prefix on
every redraw ('PITFT 10%\rPITFT 25%\rPITFT 50%\r...') rather than
having the prefix appear only on the very first frame.

Verified end-to-end via a deterministic harness that simulates
terminal CR/LF cursor semantics against captured output. Six
scenarios pass: plain multi-line, \r progress, line-split-across-
reads, apt stray-space, apt \r-pad-\r, pip \r-only progress, and
the no-group raw passthrough.

ruff check + ruff format clean.

Author: makermelissa-piclaw

adafruit_shell.py

@@ -190,13 +190,35 @@ def preexec():
                 return False
             return True
 
+    # Match either ``\n`` (advance to next line) or one-or-more ``\r``
+    # (return cursor to column 0). Both put the terminal at column 0, so
+    # both are treated as logical-line boundaries for prefix re-emission.
+    # We coalesce runs of ``\r`` so progress like ``\r\r%5d\r`` doesn't
+    # cause us to write the prefix multiple times back-to-back.
+    _LINE_BOUNDARY_RE = re.compile(r"\n|\r+")
+
     def _emit_stream_chunk(self, chunk, *, kind, at_line_start):
         """
         Write a chunk read from a subprocess stream to stdout, preserving the
         process's own line terminators (including ``\r``-only progress updates)
         and prepending the colored group prefix at the start of each logical
         new line.
 
+        "Logical line" here means "the cursor is at column 0", which is true
+        after either ``\n`` (newline) or ``\r`` (carriage return). Both kinds
+        of boundary trigger prefix re-emission so that in-place progress
+        updates like ``Downloading 12%\rDownloading 24%\r...`` keep showing
+        the prefix as they redraw, and so that any content following a bare
+        ``\r`` (e.g. apt's "erase progress line, then start the next status
+        line") is not mistakenly appended to the previous line's tail.
+
+        Leading horizontal whitespace right after a logical-line boundary is
+        treated as padding (apt and pip emit space-padded "clear" sequences
+        like ``\r                \r`` to wipe a progress line) and is
+        suppressed before the prefix is written, so output reads as e.g.
+        ``PITFT Selecting previously unselected package ...`` rather than
+        ``PITFT  Selecting ...`` with stray indentation.
+
         ``kind`` selects the color used for the group prefix
         (``"info"`` -> green, ``"error"`` -> red). The ``end="\n\r"`` that the
         old code hardcoded is *not* added here; whatever terminators the
@@ -220,23 +242,69 @@ def _emit_stream_chunk(self, chunk, *, kind, at_line_start):
 
         prefix = colorize(self._group) + " " if self._group is not None else ""
 
-        # Split on '\n' but keep the separator attached to each segment so
-        # we can detect logical line boundaries. A bare '\r' inside a segment
-        # is *not* a new logical line -- it's an in-place update of the
-        # current line -- so we deliberately don't re-emit the prefix for it.
-        parts = chunk.split("\n")
-        for index, part in enumerate(parts):
-            is_last = index == len(parts) - 1
-            segment = part if is_last else part + "\n"
-            if not segment:
-                continue
-            if at_line_start and prefix:
-                stream.write(prefix)
-            stream.write(segment)
-            at_line_start = segment.endswith("\n")
+        # Walk the chunk segment-by-segment, where each segment is the run of
+        # bytes between two consecutive line boundaries (``\n`` or ``\r+``).
+        # The boundary itself is written after its preceding segment, and the
+        # next segment is treated as the start of a fresh logical line.
+        pos = 0
+        for match in self._LINE_BOUNDARY_RE.finditer(chunk):
+            body = chunk[pos : match.start()]
+            boundary = match.group(0)
+            self._write_logical_line(stream, prefix, body, at_line_start, terminator=boundary)
+            at_line_start = True
+            pos = match.end()
+        # Anything after the last boundary is an unterminated tail; emit it
+        # with no terminator. If we were at a line start and the tail was
+        # pure leading whitespace that we suppressed, stay at line-start so
+        # the prefix gets emitted with the real content on the next chunk.
+        tail = chunk[pos:]
+        if tail:
+            wrote = self._write_logical_line(stream, prefix, tail, at_line_start, terminator="")
+            if wrote:
+                at_line_start = False
+            # else: nothing was actually written (pure padding swallowed);
+            # leave ``at_line_start`` as-is so the next chunk still gets
+            # the prefix on its first real content.
         stream.flush()
         return at_line_start
 
+    @staticmethod
+    def _write_logical_line(stream, prefix, body, at_line_start, *, terminator):
+        """Write one segment (optionally prefixed, optionally terminated).
+
+        If ``at_line_start`` is true and a prefix is configured, the prefix
+        is written first, then ``body`` with any leading horizontal
+        whitespace stripped (so apt/pip padding doesn't push the real content
+        to the right). If ``body`` is empty after stripping, the prefix is
+        still suppressed so we don't leave a dangling ``PITFT `` on a
+        whitespace-only "clear" line.
+
+        Returns True if any body bytes were written (i.e. real content
+        landed on this logical line). The terminator is written regardless,
+        but does not count as body content -- callers use the return value
+        to decide whether to flip ``at_line_start``.
+        """
+        wrote_body = False
+        if at_line_start:
+            # Strip leading horizontal whitespace (spaces/tabs) that the
+            # source process used as padding. Don't strip ``\r`` / ``\n`` --
+            # the regex already consumed those.
+            stripped = body.lstrip(" \t")
+            if stripped:
+                if prefix:
+                    stream.write(prefix)
+                stream.write(stripped)
+                wrote_body = True
+            # else: pure-whitespace segment, swallow it; the terminator
+            # below (likely ``\r``) still gets written so the terminal
+            # still sees the cursor return.
+        elif body:
+            stream.write(body)
+            wrote_body = True
+        if terminator:
+            stream.write(terminator)
+        return wrote_body
+
     def write_templated_file(self, output_path, template, **kwargs):
         """
         Use a template file and render it with the given context and write it to the specified path.