@aliou/pi-processes 0.10.3 → 0.10.4

package/extensions/processes/notifications/log-matchers.ts

@@ -1,4 +1,5 @@
 import { compileLineMatcher } from "../../../src/utils/match-line";
+import { plainTextForDisplay } from "../../shared/display-text";
 import type { NotifyConfig } from "./registry";
 import type { Attention } from "./types";
 
@@ -130,8 +131,12 @@ function splitAppendedIntoLines(
   for (const entry of appended) {
     const split = entry.text.split("\n");
     for (const line of split) {
-      if (line.length === 0) continue;
-      lines.push({ type: entry.type, text: line });
+      // Match the same per-line visible text the log views render. This keeps
+      // CR-overwritten progress and invisible escape bytes from firing
+      // watches, without making watches depend on viewport width.
+      const displayLine = plainTextForDisplay(line);
+      if (displayLine.length === 0) continue;
+      lines.push({ type: entry.type, text: displayLine });
     }
   }
 

package/extensions/processes-logs/components/log-file-viewer.ts

@@ -1,8 +1,15 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { sanitizeForDisplay } from "../../shared/display-text";
+import {
+  plainTextForDisplay,
+  sanitizeForDisplay,
+} from "../../shared/display-text";
 import { trimToBudget } from "../../shared/line-buffer";
-import { type LogLineEmphasis, renderLogLine } from "../../shared/log-line";
+import {
+  displayTextOf,
+  type LogLineEmphasis,
+  renderLogLine,
+} from "../../shared/log-line";
 import { truncateToWidth } from "../../shared/truncate";
 import type { ProcessLogLine } from "../logs-client";
 
@@ -122,8 +129,9 @@ export class LogFileViewer {
    * priority (search current match > search match > notify match > stream).
    */
   addNotifyMatch(match: { line: string }): void {
-    // Stored sanitized so it can be compared against sanitized buffer lines.
-    const line = sanitizeForDisplay(match.line);
+    // Stored as plain visible text so invisible escape bytes cannot be what
+    // makes a notification marker match.
+    const line = plainTextForDisplay(match.line);
     if (line) this.notifyLines.add(line);
   }
 
@@ -192,7 +200,8 @@ export class LogFileViewer {
           ? "search-current"
           : matchSet.has(visibleIndex)
             ? "search"
-            : this.notifyLines.has(line.text)
+            : this.notifyLines.has(line.text) ||
+                this.notifyLines.has(displayTextOf(line))
               ? "notify"
               : "none";
       return renderLogLine(line, { theme: this.theme, width, emphasis });

package/extensions/shared/display-text.ts

@@ -13,10 +13,17 @@ const ESC = String.fromCodePoint(0x001b);
 const BEL = String.fromCodePoint(0x0007);
 const ST = String.fromCodePoint(0x009c);
 const RESET = `${ESC}[0m`;
+const C1_DCS = String.fromCodePoint(0x0090);
+const C1_SOS = String.fromCodePoint(0x0098);
+const C1_OSC = String.fromCodePoint(0x009d);
+const C1_PM = String.fromCodePoint(0x009e);
+const C1_APC = String.fromCodePoint(0x009f);
+const C1_STRING_INTRODUCERS = [C1_DCS, C1_SOS, C1_OSC, C1_PM, C1_APC];
 
-// Control characters a single display row must never contain. Tabs are handled
-// separately; newlines are dropped because they would shift the whole frame.
-// C1 controls are included: a raw \u009b is an alias for CSI on some terminals.
+// Control characters a single display row must never contain. Tabs and
+// carriage returns are handled separately; newlines are dropped because they
+// would shift the whole frame. C1 controls are included: a raw \u009b is an
+// alias for CSI on some terminals.
 // biome-ignore lint/suspicious/noControlCharactersInRegex: this regex intentionally targets terminal control characters.
 const DISPLAY_CONTROL_CHARS = /[\u0000-\u0008\u000a-\u001f\u007f-\u009f]/gu;
 
@@ -41,7 +48,9 @@ const TAB_WIDTH = 8;
  * into the rest of the frame.
  */
 export function sanitizeForDisplay(text: string): string {
-  if (!text.includes(ESC)) return cleanPlainText(text, 0).text;
+  if (!text.includes(ESC) && !hasC1StringIntroducer(text)) {
+    return cleanPlainText(text, 0).text;
+  }
 
   let out = "";
   let cursor = 0;
@@ -49,21 +58,34 @@ export function sanitizeForDisplay(text: string): string {
   let keptSgr = false;
 
   while (cursor < text.length) {
-    const escapeAt = text.indexOf(ESC, cursor);
-    if (escapeAt === -1) {
-      out += cleanPlainText(text.slice(cursor), column).text;
+    const sequenceAt = findNextSequenceStart(text, cursor);
+    if (sequenceAt === -1) {
+      const chunk = cleanPlainText(text.slice(cursor), column);
+      if (chunk.resetsRow) {
+        out = "";
+        keptSgr = false;
+      }
+      out += chunk.text;
       break;
     }
-    const chunk = cleanPlainText(text.slice(cursor, escapeAt), column);
+    const chunk = cleanPlainText(text.slice(cursor, sequenceAt), column);
+    if (chunk.resetsRow) {
+      out = "";
+      keptSgr = false;
+    }
     out += chunk.text;
     column = chunk.column;
 
-    const sequence = readEscapeSequence(text, escapeAt);
-    if (sequence.isSgr) {
-      out += text.slice(escapeAt, sequence.end);
-      keptSgr = true;
+    if (text[sequenceAt] === ESC) {
+      const sequence = readEscapeSequence(text, sequenceAt);
+      if (sequence.isSgr) {
+        out += text.slice(sequenceAt, sequence.end);
+        keptSgr = true;
+      }
+      cursor = sequence.end;
+    } else {
+      cursor = readC1StringSequence(text, sequenceAt).end;
     }
-    cursor = sequence.end;
   }
 
   if (!keptSgr || out.endsWith(RESET)) return out;
@@ -79,6 +101,22 @@ export function truncateForDisplay(text: string, width: number): string {
   return closeSgr(truncateToWidth(sanitizeForDisplay(text), width, "…"));
 }
 
+/**
+ * Return the unstyled text a user can actually read after terminal controls
+ * have been interpreted/dropped. Use this for comparisons such as search,
+ * notify markers, and log watches so invisible escape bytes cannot match.
+ */
+export function plainTextForDisplay(text: string): string {
+  return stripSgr(sanitizeForDisplay(text));
+}
+
+const SGR = new RegExp(`${ESC}\\[[0-9;:]*m`, "gu");
+
+/** Drop the SGR sequences `sanitizeForDisplay` kept for rendering colors. */
+export function stripSgr(text: string): string {
+  return text.replace(SGR, "");
+}
+
 /**
  * Re-close colors after truncation. `sanitizeForDisplay` ends a colored string
  * with a reset, but truncating can cut that reset off and let the color bleed
@@ -97,21 +135,42 @@ export function closeSgr(text: string): string {
 function cleanPlainText(
   text: string,
   column: number,
-): { text: string; column: number } {
-  const clean = text.replace(DISPLAY_CONTROL_CHARS, "");
+): { text: string; column: number; resetsRow: boolean } {
+  const carriageReturn = text.lastIndexOf("\r");
+  const resetsRow = carriageReturn !== -1;
+  const visibleText = resetsRow ? text.slice(carriageReturn + 1) : text;
+  const startColumn = resetsRow ? 0 : column;
+  const clean = visibleText.replace(DISPLAY_CONTROL_CHARS, "");
   if (!clean.includes("\t")) {
-    return { text: clean, column: column + visibleWidth(clean) };
+    return {
+      text: clean,
+      column: startColumn + visibleWidth(clean),
+      resetsRow,
+    };
   }
 
   const parts = clean.split("\t");
   let out = parts[0] ?? "";
-  let col = column + visibleWidth(out);
+  let col = startColumn + visibleWidth(out);
   for (const part of parts.slice(1)) {
     const spaces = TAB_WIDTH - (col % TAB_WIDTH);
     out += " ".repeat(spaces) + part;
     col += spaces + visibleWidth(part);
   }
-  return { text: out, column: col };
+  return { text: out, column: col, resetsRow };
+}
+
+function findNextSequenceStart(text: string, cursor: number): number {
+  let next = text.indexOf(ESC, cursor);
+  for (const introducer of C1_STRING_INTRODUCERS) {
+    const index = text.indexOf(introducer, cursor);
+    if (index !== -1 && (next === -1 || index < next)) next = index;
+  }
+  return next;
+}
+
+function hasC1StringIntroducer(text: string): boolean {
+  return C1_STRING_INTRODUCERS.some((introducer) => text.includes(introducer));
 }
 
 /**
@@ -151,6 +210,12 @@ function readEscapeSequence(
   return { end: start + 2, isSgr: false };
 }
 
+function readC1StringSequence(text: string, start: number): { end: number } {
+  const introducer = text[start];
+  const allowBel = introducer === C1_OSC || introducer === C1_APC;
+  return { end: findStringTerminator(text, start + 1, allowBel) };
+}
+
 /** Index just past the terminator of a string sequence, else end of input. */
 function findStringTerminator(
   text: string,

package/extensions/shared/log-line.ts

@@ -10,7 +10,12 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
-import { closeSgr, sanitizeForDisplay } from "./display-text";
+import {
+  closeSgr,
+  plainTextForDisplay,
+  sanitizeForDisplay,
+  stripSgr,
+} from "./display-text";
 import { truncateToWidth } from "./truncate";
 
 export interface DisplayLogLine {
@@ -60,7 +65,7 @@ export function renderLogLine(
 
 /** Text of a log line as the views display it, for match comparisons. */
 export function displayTextOf(line: DisplayLogLine): string {
-  return sanitizeForDisplay(line.text);
+  return plainTextForDisplay(line.text);
 }
 
 function toneLogText(
@@ -75,10 +80,3 @@ function toneLogText(
   if (type === "stderr") return theme.fg("warning", text);
   return text;
 }
-
-const SGR = new RegExp(`${String.fromCodePoint(0x001b)}\\[[0-9;:]*m`, "gu");
-
-/** Drop the SGR sequences `sanitizeForDisplay` kept. */
-function stripSgr(text: string): string {
-  return text.replace(SGR, "");
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "license": "MIT",
   "type": "module",
   "private": false,