tmux-ide 2.6.1 → 2.8.0

package/packages/daemon/src/tui/mirror/attention.ts

@@ -0,0 +1,110 @@
+/**
+ * In-app attention surfacing (M25.1) — the PURE half of "an agent you can't
+ * see needs you". The app's 3s fleet poll diffs the previous per-pane agent
+ * states against the fresh payload; blocked/done transitions for agents NOT on
+ * the current screen (another workspace, another window, or a non-Terminal
+ * tab) become a status-strip note plus a brief sidebar flash. The diff, the
+ * visibility test, and the note text live here so they unit-test without
+ * OpenTUI; app.tsx supplies the signals and timers.
+ *
+ * First sight is graced exactly like the chrome updater's notification path
+ * (`from: null` never notes) — an app boot must not re-announce every agent
+ * that was already blocked.
+ */
+import type { AgentStatus } from "../detect/classify.ts";
+
+/** The per-agent slice of the fleet payload the diff needs. */
+export interface AttentionAgent {
+  paneId: string;
+  session: string;
+  kind: string;
+  state: AgentStatus;
+}
+
+/** One agent's state change between two fleet polls. */
+export interface AttentionTransition {
+  paneId: string;
+  session: string;
+  kind: string;
+  from: AgentStatus | null;
+  to: AgentStatus;
+}
+
+/** What the app is currently showing — the visibility side of the test. */
+export interface AttentionView {
+  /** The active surface tab (only `terminal` shows panes at all). */
+  tab: string;
+  /** Pane ids on screen right now (the mirrored window's panes). */
+  visiblePaneIds: readonly string[];
+}
+
+/** The two states worth interrupting the user over (mirrors the chrome
+ *  updater's NOTIFY_STATES). */
+const NOTE_STATES: ReadonlySet<AgentStatus> = new Set<AgentStatus>(["blocked", "done"]);
+
+/**
+ * PURE — diff the previous per-pane states against this poll's agents.
+ * Returns the transitions plus the fresh state map to thread into the next
+ * poll (the input map is NOT mutated). A pane that vanished emits nothing and
+ * drops out of the state.
+ */
+export function diffAttention(
+  prev: ReadonlyMap<string, AgentStatus>,
+  agents: readonly AttentionAgent[],
+): { transitions: AttentionTransition[]; next: Map<string, AgentStatus> } {
+  const next = new Map<string, AgentStatus>();
+  const transitions: AttentionTransition[] = [];
+  for (const a of agents) {
+    if (next.has(a.paneId)) continue; // deduped: a session can surface under two projects
+    const before = prev.has(a.paneId) ? prev.get(a.paneId)! : null;
+    next.set(a.paneId, a.state);
+    if (before === a.state) continue;
+    transitions.push({
+      paneId: a.paneId,
+      session: a.session,
+      kind: a.kind,
+      from: before,
+      to: a.state,
+    });
+  }
+  return { transitions, next };
+}
+
+/** PURE — is this pane on the app's screen right now? Only the Terminal tab
+ *  shows panes; there, exactly the mirrored window's panes are visible. */
+export function isPaneVisible(paneId: string, view: AttentionView): boolean {
+  return view.tab === "terminal" && view.visiblePaneIds.includes(paneId);
+}
+
+/**
+ * PURE — the transitions worth a note: blocked/done, not first-sight, and not
+ * currently visible (the user can see a visible pane flip themselves).
+ */
+export function noteworthyTransitions(
+  transitions: readonly AttentionTransition[],
+  view: AttentionView,
+): AttentionTransition[] {
+  return transitions.filter(
+    (t) => t.from !== null && NOTE_STATES.has(t.to) && !isPaneVisible(t.paneId, view),
+  );
+}
+
+/** PURE — the status-strip note for one transition, e.g.
+ *  `● claude blocked · zz-api — click agents`. Done reads `✓ … — click agents`. */
+export function attentionNote(t: AttentionTransition): string {
+  const glyph = t.to === "blocked" ? "●" : "✓";
+  return `${glyph} ${t.kind} ${t.to} · ${t.session} — click agents`;
+}
+
+/** PURE — the note line for a whole poll's noteworthy set: the first (most
+ *  recent diff order) transition's note, with a `(+N)` tail when several agents
+ *  flipped in the same poll. Null for an empty set. */
+export function attentionNoteLine(worthy: readonly AttentionTransition[]): string | null {
+  const first = worthy[0];
+  if (!first) return null;
+  const extra = worthy.length > 1 ? ` (+${worthy.length - 1})` : "";
+  return `${attentionNote(first)}${extra}`;
+}
+
+/** How long the sidebar attention flash lasts. */
+export const ATTENTION_FLASH_MS = 2500;

package/packages/daemon/src/tui/mirror/blit.ts

@@ -0,0 +1,186 @@
+/**
+ * Pure cell → framebuffer writers for the framebuffer pane-blit path (M21.3).
+ *
+ * These map a mirror grid straight into an OpenTUI `OptimizedBuffer`'s typed
+ * arrays — no `StyledRun[]` intermediary, no per-run `RGBA` allocation, no Solid
+ * subtree. One packed cell is `char[i]` (a codepoint), four `fg`/`bg` channels
+ * (`r,g,b,a`, 0–255) at `i*4`, and one `attributes[i]` bitmask — the exact layout
+ * `OptimizedBuffer.buffers` exposes.
+ *
+ * Kept dependency-free (plain typed arrays) so the packing is unit-testable
+ * without the native render lib; {@link PaneMirror.blit} does the xterm walk and
+ * feeds these.
+ */
+
+/** The spacer (second) half of a wide glyph: char `0`. The native renderer knows
+ *  a cell is wide by MEASURING the lead cell's codepoint width and skips the
+ *  spacer, so the spacer's char just needs to be empty — this is exactly what
+ *  `OptimizedBuffer.setCell` writes for the trailing half (verified: a wide
+ *  glyph → `char[i]=codepoint, char[i+1]=0`). NB the `0xC0000000`
+ *  `CHAR_FLAG_CONTINUATION` seen in OptimizedBuffer is a DIFFERENT consumer (the
+ *  JS `getSpanLines`/`getRealCharBytes` text reader, off our render path);
+ *  writing it here blanks wide glyphs on screen (measured). */
+export const CHAR_CONTINUATION = 0;
+
+/** The space codepoint — the fill for blank / out-of-range cells. */
+export const SPACE_CODE = 0x20;
+
+/**
+ * INVERSE is rendered by SWAPPING fg/bg, not by the OpenTUI INVERSE attribute
+ * bit: a framebuffer cell carrying that bit composites (drawFrameBuffer preserves
+ * it) but does NOT flush as reverse-video — the direct `<text>` path does, the
+ * framebuffer path doesn't (measured). Swapping colors always renders (truecolor
+ * channels propagate cleanly), and covers app-driven reverse (vim status line),
+ * the cursor cell, and the drag selection uniformly. Swaps compose like the old
+ * XOR: two swaps on a cell (selection over the cursor) return it to normal.
+ */
+
+/** The four packed arrays behind an `OptimizedBuffer` (or a plain-array stand-in
+ *  for tests). `fg`/`bg` hold four `u16` channels (0–255) per cell at `i*4`. */
+export interface CellArrays {
+  char: Uint32Array;
+  fg: Uint16Array;
+  bg: Uint16Array;
+  attributes: Uint32Array;
+}
+
+/**
+ * A cell whose grapheme is more than one codepoint (ZWJ/flag emoji, combining
+ * marks) — a single `char[i]` u32 can't hold it. The fast blit writes its base
+ * codepoint; the caller (which owns the native `OptimizedBuffer`) re-writes these
+ * few cells with the full string via `setCell`, keeping full parity for the rare
+ * case without an allocation on the common path.
+ */
+export interface GraphemeOverride {
+  x: number;
+  y: number;
+  chars: string;
+  /** Packed `0xRRGGBB` or null (terminal default). */
+  fg: number | null;
+  bg: number | null;
+  attrs: number;
+}
+
+/**
+ * Write one styled cell at flat index `idx`. `fg`/`bg` are packed `0xRRGGBB` or
+ * `null` for the terminal default (→ the supplied `d*` channels); alpha is always
+ * opaque (panes never blend). No allocation — just eight typed-array stores.
+ */
+export function writeCell(
+  buf: CellArrays,
+  idx: number,
+  codepoint: number,
+  fg: number | null,
+  bg: number | null,
+  attrs: number,
+  dfR: number,
+  dfG: number,
+  dfB: number,
+  dbR: number,
+  dbG: number,
+  dbB: number,
+): void {
+  buf.char[idx] = codepoint;
+  const o = idx * 4;
+  if (fg === null) {
+    buf.fg[o] = dfR;
+    buf.fg[o + 1] = dfG;
+    buf.fg[o + 2] = dfB;
+  } else {
+    buf.fg[o] = (fg >> 16) & 0xff;
+    buf.fg[o + 1] = (fg >> 8) & 0xff;
+    buf.fg[o + 2] = fg & 0xff;
+  }
+  buf.fg[o + 3] = 255;
+  if (bg === null) {
+    buf.bg[o] = dbR;
+    buf.bg[o + 1] = dbG;
+    buf.bg[o + 2] = dbB;
+  } else {
+    buf.bg[o] = (bg >> 16) & 0xff;
+    buf.bg[o + 1] = (bg >> 8) & 0xff;
+    buf.bg[o + 2] = bg & 0xff;
+  }
+  buf.bg[o + 3] = 255;
+  buf.attributes[idx] = attrs;
+}
+
+/**
+ * Mark cell `idx` as the continuation (spacer) half of the wide glyph at `idx-1`,
+ * inheriting the glyph's colors so a colored wide glyph's background spans both
+ * cells. The renderer emits nothing for a continuation cell but still paints its
+ * background.
+ */
+export function writeContinuation(buf: CellArrays, idx: number): void {
+  buf.char[idx] = CHAR_CONTINUATION;
+  const o = idx * 4;
+  const p = (idx - 1) * 4;
+  buf.fg[o] = buf.fg[p]!;
+  buf.fg[o + 1] = buf.fg[p + 1]!;
+  buf.fg[o + 2] = buf.fg[p + 2]!;
+  buf.fg[o + 3] = buf.fg[p + 3]!;
+  buf.bg[o] = buf.bg[p]!;
+  buf.bg[o + 1] = buf.bg[p + 1]!;
+  buf.bg[o + 2] = buf.bg[p + 2]!;
+  buf.bg[o + 3] = buf.bg[p + 3]!;
+  buf.attributes[idx] = buf.attributes[idx - 1]!;
+}
+
+/**
+ * Swap fg/bg across cells `[from,to]` (inclusive, clamped to the row) of row `y`
+ * — the drag-selection reverse-video post-pass. A swap over the cursor cell (also
+ * swapped in the blit) returns it to normal, matching the run path's XOR.
+ */
+export function swapCells(
+  buf: CellArrays,
+  width: number,
+  y: number,
+  from: number,
+  to: number,
+): void {
+  const lo = Math.max(0, from);
+  const hi = Math.min(width - 1, to);
+  const base = y * width;
+  for (let x = lo; x <= hi; x++) {
+    const o = (base + x) * 4;
+    const r = buf.fg[o]!;
+    const g = buf.fg[o + 1]!;
+    const b = buf.fg[o + 2]!;
+    const a = buf.fg[o + 3]!;
+    buf.fg[o] = buf.bg[o]!;
+    buf.fg[o + 1] = buf.bg[o + 1]!;
+    buf.fg[o + 2] = buf.bg[o + 2]!;
+    buf.fg[o + 3] = buf.bg[o + 3]!;
+    buf.bg[o] = r;
+    buf.bg[o + 1] = g;
+    buf.bg[o + 2] = b;
+    buf.bg[o + 3] = a;
+  }
+}
+
+/**
+ * Paint the background of cells `[from,to]` (inclusive, clamped) of row `y` to
+ * packed `bg` — the scrollback-search highlight post-pass (the twin of
+ * {@link invertCells}; distinct treatment so a match and the selection coexist).
+ */
+export function paintBg(
+  buf: CellArrays,
+  width: number,
+  y: number,
+  from: number,
+  to: number,
+  bg: number,
+): void {
+  const lo = Math.max(0, from);
+  const hi = Math.min(width - 1, to);
+  const r = (bg >> 16) & 0xff;
+  const g = (bg >> 8) & 0xff;
+  const b = bg & 0xff;
+  for (let x = lo; x <= hi; x++) {
+    const o = (y * width + x) * 4;
+    buf.bg[o] = r;
+    buf.bg[o + 1] = g;
+    buf.bg[o + 2] = b;
+    buf.bg[o + 3] = 255;
+  }
+}

package/packages/daemon/src/tui/mirror/control-client.ts

@@ -12,14 +12,29 @@
  * intact; `parseControlLine`/`decodeControlBytes` do the pure protocol work.
  */
 import { spawn, type ChildProcess } from "node:child_process";
+import { appendFileSync } from "node:fs";
 import { parseControlLine, textToHexKeys } from "./control.ts";
 
 interface PendingReply {
+  discard?: false;
   resolve: (lines: string[]) => void;
   reject: (err: Error) => void;
   lines: string[];
 }
 
+/** A fire-and-forget command's FIFO placeholder: its reply block is consumed
+ *  and dropped (errors counted). `lines` collects the error body only when
+ *  TMUX_IDE_MIRROR_DEBUG asks for it. */
+interface DiscardedReply {
+  discard: true;
+  lines?: string[];
+}
+
+type Pending = PendingReply | DiscardedReply;
+
+/** The shared no-debug placeholder — fire-and-forget input allocates NOTHING. */
+const DISCARDED: DiscardedReply = { discard: true };
+
 export interface ControlClientOptions {
   /** Session (or other tmux target) to attach the control client to. */
   attachTarget: string;
@@ -33,9 +48,10 @@ export interface ControlClientOptions {
 
 export class ControlModeClient {
   private proc: ChildProcess | null = null;
-  private readonly pending: PendingReply[] = [];
+  private readonly pending: Pending[] = [];
   private inReply = false;
   private buffer = "";
+  private discardedErrors = 0;
   private readonly opts: ControlClientOptions;
 
   constructor(opts: ControlClientOptions) {
@@ -72,14 +88,38 @@ export class ControlModeClient {
     });
   }
 
-  /** Type literal text into a pane (UTF-8, sent as hex bytes — quote-proof). */
-  sendText(pane: string, text: string): Promise<string[]> {
-    return this.command(`send-keys -t ${pane} -H ${textToHexKeys(text).join(" ")}`);
+  /**
+   * The INPUT FAST PATH (M21.5): write a command fire-and-forget. The bytes
+   * hit tmux's stdin exactly as immediately as `command()`'s do, but no
+   * Promise/resolver is allocated and nothing ever waits on the reply. Every
+   * control-mode command still produces exactly one `%begin/%end` block, so a
+   * placeholder is pushed onto the SAME pending FIFO — reply matching for
+   * reply-carrying commands (list-panes, capture-pane, …) stays aligned by
+   * construction. Errors are swallowed but counted ({@link inputErrorCount});
+   * with TMUX_IDE_MIRROR_DEBUG set the error body is appended to
+   * /tmp/zz-input-errors.log.
+   */
+  send(cmd: string): void {
+    const proc = this.proc;
+    if (!proc?.stdin?.writable) return;
+    this.pending.push(process.env.TMUX_IDE_MIRROR_DEBUG ? { discard: true, lines: [] } : DISCARDED);
+    proc.stdin.write(`${cmd}\n`);
+  }
+
+  /** Type literal text into a pane (UTF-8, sent as hex bytes — quote-proof).
+   *  Fire-and-forget: input never queues behind a slow structural reply. */
+  sendText(pane: string, text: string): void {
+    this.send(`send-keys -t ${pane} -H ${textToHexKeys(text).join(" ")}`);
   }
 
-  /** Send a named tmux key (Enter, Escape, Up, C-c, …) to a pane. */
-  sendKey(pane: string, key: string): Promise<string[]> {
-    return this.command(`send-keys -t ${pane} ${key}`);
+  /** Send a named tmux key (Enter, Escape, Up, C-c, …) to a pane. Fire-and-forget. */
+  sendKey(pane: string, key: string): void {
+    this.send(`send-keys -t ${pane} ${key}`);
+  }
+
+  /** How many fire-and-forget commands came back `%error` (debug/tests). */
+  get inputErrorCount(): number {
+    return this.discardedErrors;
   }
 
   dispose(): void {
@@ -97,6 +137,7 @@ export class ControlModeClient {
   }
 
   private feed(chunk: string): void {
+    const t0 = process.env.TMUX_IDE_ZZ_PERF ? performance.now() : 0;
     this.buffer += chunk;
     let nl: number;
     while ((nl = this.buffer.indexOf("\n")) !== -1) {
@@ -106,6 +147,16 @@ export class ControlModeClient {
       this.buffer = this.buffer.slice(nl + 1);
       this.handleLine(line);
     }
+    if (t0) {
+      try {
+        appendFileSync(
+          "/tmp/zz-feed.log",
+          `${chunk.length} ${(performance.now() - t0).toFixed(2)}\n`,
+        );
+      } catch {
+        /* perf tap */
+      }
+    }
   }
 
   private handleLine(line: string): void {
@@ -114,14 +165,34 @@ export class ControlModeClient {
       case "begin":
         this.inReply = true;
         break;
-      case "reply-line":
-        this.pending[0]?.lines.push(event.line);
+      case "reply-line": {
+        const head = this.pending[0];
+        // Discarded (fire-and-forget) replies skip body collection entirely —
+        // unless the debug placeholder brought its own lines buffer.
+        if (head) head.lines?.push(event.line);
         break;
+      }
       case "end":
       case "error": {
         this.inReply = false;
         const reply = this.pending.shift();
         if (!reply) break; // unsolicited block (e.g. greeting after a race)
+        if (reply.discard) {
+          if (event.kind === "error") {
+            this.discardedErrors++;
+            if (process.env.TMUX_IDE_MIRROR_DEBUG) {
+              try {
+                appendFileSync(
+                  "/tmp/zz-input-errors.log",
+                  `#${this.discardedErrors} ${reply.lines?.join(" | ") ?? ""}\n`,
+                );
+              } catch {
+                // debug tap only
+              }
+            }
+          }
+          break;
+        }
         if (event.kind === "error") {
           reply.reject(new Error(reply.lines.join("\n") || "tmux command failed"));
         } else {