Technician tool v0.2

Imported from the Google Drive folder 004-technician_tool/v0.2.

kota_tech/core/logline.py

@@ -76,65 +76,71 @@ class LineFramer:
 
     A partial line is released after `idle_flush_s` without new bytes so
     prompts / unterminated output are not held back forever.
+
+    Lines are also split where a new log line starts in the middle
+    ("I (2302) chip[DL]: I (2302) chip[DL]: Posting..."): the two S3 cores
+    interleave output, and the USB-Serial-JTAG FIFO keeps the tail of an old
+    line while no host reads, releasing it glued in front of the next live
+    output. After a (re)open, the fragment in front of the first such split
+    is stale and dropped. Timing cannot identify it, because the FIFO only
+    flushes when the board next prints, possibly seconds later.
     """
 
-    # Stale FIFO bytes arrive immediately after open; anything later is live.
-    STALE_WINDOW_S = 0.25
-
     def __init__(self, idle_flush_s: float = 0.3, max_line: int = 4096,
-                 drop_first_partial: bool = False, now: float | None = None):
+                 drop_first_partial: bool = False):
         self._buf = bytearray()
         self._last_rx = 0.0
         self.idle_flush_s = idle_flush_s
         self.max_line = max_line
-        # The S3 USB-Serial-JTAG FIFO keeps the tail of an old line while no
-        # host is reading and flushes it on open; drop bytes up to the first
-        # newline after a (re)connect so it is not glued to a fresh line.
-        # Only bytes arriving within STALE_WINDOW_S of open are considered
-        # stale, otherwise an idle board's next boot banner would be lost.
-        self._dropping = drop_first_partial
-        self._drop_deadline = (time.monotonic() if now is None else now) + self.STALE_WINDOW_S
+        self._first_line_pending = drop_first_partial
 
     def cancel_drop(self) -> None:
-        self._dropping = False
+        self._first_line_pending = False
 
     def feed(self, data: bytes, now: float | None = None) -> list[str]:
         now = time.monotonic() if now is None else now
-        if self._dropping and now > self._drop_deadline:
-            self._dropping = False
         if data:
             self._buf.extend(data)
             self._last_rx = now
-        if self._dropping:
-            i = self._buf.find(b"\n")
-            if i < 0:
-                return []
-            del self._buf[: i + 1]
-            self._dropping = False
         out: list[str] = []
         while (i := self._buf.find(b"\n")) >= 0:
-            out.append(self._decode(self._buf[:i]))
+            out += self._emit(self._buf[:i])
             del self._buf[: i + 1]
         if len(self._buf) >= self.max_line:
-            out.append(self._decode(self._buf))
+            out += self._emit(self._buf)
             self._buf.clear()
         return out
 
     def poll_idle(self, now: float | None = None) -> list[str]:
         now = time.monotonic() if now is None else now
         if self._buf and now - self._last_rx >= self.idle_flush_s:
-            line = self._decode(self._buf)
-            self._buf.clear()
-            return [line]
+            return self.flush()
         return []
 
     def flush(self) -> list[str]:
         if not self._buf:
             return []
-        line = self._decode(self._buf)
+        out = self._emit(self._buf)
         self._buf.clear()
-        return [line]
+        return out
 
-    @staticmethod
-    def _decode(b: bytes | bytearray) -> str:
-        return bytes(b).decode("utf-8", errors="replace")
+    def _emit(self, raw: bytes | bytearray) -> list[str]:
+        parts = split_glued(bytes(raw).decode("utf-8", errors="replace"))
+        if self._first_line_pending:
+            self._first_line_pending = False
+            if len(parts) > 1:
+                parts = parts[1:]  # stale FIFO fragment from before the open
+        return parts
+
+
+# Start of a log line (optionally ANSI-coloured) or ROM banner.
+_LINE_START = re.compile(r"(?:\x1b\[[0-9;]*m)?(?:[EWIDV] \(\d+\) \S|ESP-ROM:)")
+
+
+def split_glued(text: str) -> list[str]:
+    # Left-to-right scan so an ANSI colour prefix stays with its line.
+    cuts = [m.start() for m in _LINE_START.finditer(text) if m.start() > 0]
+    if not cuts:
+        return [text]
+    bounds = [0, *cuts, len(text)]
+    return [text[a:b] for a, b in zip(bounds, bounds[1:]) if a < b]