tmux-ide 2.6.0 → 2.7.0

package/packages/daemon/src/tui/mirror/scrollbar-model.ts

@@ -0,0 +1,88 @@
+/**
+ * Pure scrollbar geometry (M19.5) — shared by the editor viewport, the diff
+ * pane, and any scrolled mirror pane.
+ *
+ * A 1-col track at the right edge of an always-present container; the thumb's
+ * position and size are pure functions of (viewportTop, contentLen, viewH).
+ * Both the RENDER (draws the track cells) and the ROUTER (classifies a press as
+ * thumb vs track, maps a thumb drag to an absolute scroll top, pages a track
+ * click) read the SAME math from here — the surface-bar discipline applied to a
+ * vertical strip. Deliberately opentui-free so it unit-tests under Node.
+ */
+
+export interface ScrollThumb {
+  /** Whether the content overflows the viewport (nothing to scroll → hidden). */
+  overflow: boolean;
+  /** First track row (0-based, within [0, viewH)) the thumb occupies. */
+  start: number;
+  /** Thumb height in rows (≥1, ≤viewH). */
+  size: number;
+}
+
+/** The thumb size for a content/viewport pair — a viewport-fraction of the
+ *  track, floored at one cell so a thumb always exists. Shared by every
+ *  function below so their maths never drift. */
+function thumbSize(contentLen: number, viewH: number): number {
+  return Math.max(1, Math.min(viewH, Math.round((viewH * viewH) / contentLen)));
+}
+
+/** The thumb geometry for a scroll position. `viewportTop` is the first visible
+ *  content line; `contentLen` the total lines; `viewH` the visible rows. When
+ *  the content fits, `overflow` is false and the caller draws no track. */
+export function scrollThumb(viewportTop: number, contentLen: number, viewH: number): ScrollThumb {
+  if (viewH <= 0 || contentLen <= viewH) {
+    return { overflow: false, start: 0, size: Math.max(1, viewH) };
+  }
+  const size = thumbSize(contentLen, viewH);
+  const maxTop = contentLen - viewH;
+  const maxStart = viewH - size;
+  const top = Math.max(0, Math.min(maxTop, viewportTop));
+  const start = maxStart <= 0 ? 0 : Math.round((top / maxTop) * maxStart);
+  return { overflow: true, start: Math.max(0, Math.min(maxStart, start)), size };
+}
+
+/** Where a track row falls relative to the thumb — the fourth drag-origin's
+ *  press classifier and the page-click direction source. */
+export type TrackZone = "above" | "thumb" | "below";
+
+export function trackZone(row: number, thumb: ScrollThumb): TrackZone {
+  if (row < thumb.start) return "above";
+  if (row >= thumb.start + thumb.size) return "below";
+  return "thumb";
+}
+
+/** Page the viewport toward a click at track `row` (above the thumb → up one
+ *  viewport, below → down one; on the thumb → unchanged), clamped to range. */
+export function pageTop(
+  row: number,
+  viewportTop: number,
+  contentLen: number,
+  viewH: number,
+): number {
+  const thumb = scrollThumb(viewportTop, contentLen, viewH);
+  if (!thumb.overflow) return viewportTop;
+  const maxTop = contentLen - viewH;
+  const zone = trackZone(row, thumb);
+  const next =
+    zone === "above" ? viewportTop - viewH : zone === "below" ? viewportTop + viewH : viewportTop;
+  return Math.max(0, Math.min(maxTop, next));
+}
+
+/** Map a dragged thumb to an absolute scroll top. `trackRow` is the current
+ *  pointer row within the track; `grabOffset` is the row within the thumb where
+ *  the drag began (so the thumb doesn't jump under the cursor). Returns the new
+ *  first-visible line, clamped. */
+export function dragTop(
+  trackRow: number,
+  grabOffset: number,
+  contentLen: number,
+  viewH: number,
+): number {
+  if (viewH <= 0 || contentLen <= viewH) return 0;
+  const size = thumbSize(contentLen, viewH);
+  const maxStart = viewH - size;
+  const maxTop = contentLen - viewH;
+  if (maxStart <= 0) return 0;
+  const start = Math.max(0, Math.min(maxStart, trackRow - grabOffset));
+  return Math.round((start / maxStart) * maxTop);
+}

package/packages/daemon/src/tui/mirror/search-model.ts

@@ -0,0 +1,70 @@
+/**
+ * Pure, io-free math for scrollback search (M20.3) — the copy-mode `/` finder,
+ * app-native. app.tsx owns the search-session state machine + the io (reading a
+ * pane's `bufferLines`, driving scrollOffset); this module owns the arithmetic,
+ * unit-tested without a terminal exactly like selection.ts / diff-model.ts.
+ *
+ * A match is a (line, col) into the pane's full buffer (0 = oldest scrollback
+ * line). The render maps a match line to a visible row and inverse/accent-tints
+ * its [col, col+len) span; a jump converts a match line to a scrollOffset.
+ */
+
+/** One substring hit: `line` is the absolute buffer line, `col` the 0-based
+ *  character column of the match start on that line. */
+export interface SearchMatch {
+  line: number;
+  col: number;
+}
+
+/**
+ * Every case-insensitive substring occurrence of `query` across `lines`, in
+ * buffer order (top→bottom, left→right), one entry per occurrence (multiple per
+ * line allowed; non-overlapping — the scan advances past each hit). An empty
+ * query yields no matches.
+ */
+export function findMatches(lines: readonly string[], query: string): SearchMatch[] {
+  const out: SearchMatch[] = [];
+  if (query.length === 0) return out;
+  const needle = query.toLowerCase();
+  for (let line = 0; line < lines.length; line++) {
+    const hay = (lines[line] ?? "").toLowerCase();
+    let from = 0;
+    for (;;) {
+      const idx = hay.indexOf(needle, from);
+      if (idx === -1) break;
+      out.push({ line, col: idx });
+      from = idx + needle.length;
+    }
+  }
+  return out;
+}
+
+/**
+ * Matches in VISIT order — bottom-up (nearest the live viewport first), the
+ * order `/`-then-Enter lands on and n/N cycle through. So visit index 0 is the
+ * bottom-most match (shown as "1/N"), and `n` walks upward through the buffer.
+ * A fresh copy (does not mutate the input).
+ */
+export function visitOrder(matches: readonly SearchMatch[]): SearchMatch[] {
+  return [...matches].reverse();
+}
+
+/** Cycle a match index by `dir` (+1 next / -1 prev) with wraparound; -1 stays
+ *  -1 when there are no matches. */
+export function stepMatch(current: number, dir: number, total: number): number {
+  if (total <= 0) return -1;
+  return (((current + dir) % total) + total) % total;
+}
+
+/**
+ * The scrollOffset (lines above the live viewport) that brings buffer `line`
+ * into view, positioned roughly at the middle of a `viewH`-row viewport, clamped
+ * to [0, depth]. `depth` is the scrollback budget (lines above the live top);
+ * the pane snapshot renders visible row `r` from buffer line `depth - offset + r`,
+ * so putting `line` at row `target` needs `offset = depth + target - line`.
+ */
+export function offsetForMatch(line: number, depth: number, viewH: number): number {
+  const target = Math.floor(Math.max(0, viewH) / 2);
+  const raw = depth + target - line;
+  return Math.max(0, Math.min(depth, raw));
+}

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

@@ -0,0 +1,262 @@
+/**
+ * Pure, io-free geometry + text math for mouse selection & clipboard (M19.4).
+ *
+ * Two surfaces select the same way — the session MIRROR (pane snapshot rows)
+ * and the built-in EDITOR (buffer lines) — so the coordinate math lives here,
+ * unit-tested without a terminal, exactly like spans.ts / diff-model.ts. app.tsx
+ * owns the mouse-gesture state machine and the io (OSC52 to stdout, tmux
+ * passthrough, send-keys); this module owns the arithmetic.
+ *
+ * The selection is LINEAR (terminal-style, reading order), not rectangular: a
+ * cell is selected if it falls between the anchor and head in row-major order.
+ */
+
+/** A cell in surface-local coordinates: mirror = snapshot row + pane column;
+ *  editor = buffer line + buffer column. */
+export interface Cell {
+  row: number;
+  col: number;
+}
+
+/** An active selection on one surface. `anchor` is where the drag began, `head`
+ *  the current/last pointer cell; either may precede the other. */
+export type Selection =
+  | { surface: "mirror"; paneId: string; anchor: Cell; head: Cell }
+  | { surface: "editor"; anchor: Cell; head: Cell };
+
+/** OpenTUI TextAttributes bit for inverse video (matches pane-mirror.ts). */
+export const ATTR_INVERSE = 32;
+
+/** Order two cells into reading order (row-major); both endpoints inclusive. */
+export function orderCells(a: Cell, b: Cell): { start: Cell; end: Cell } {
+  if (a.row < b.row || (a.row === b.row && a.col <= b.col)) return { start: a, end: b };
+  return { start: b, end: a };
+}
+
+/**
+ * The inclusive [from,to] column interval selected on `row` for a linear
+ * selection between ordered endpoints, or null when the row is outside the
+ * selection or has no cells. `rowLen` is the row's character count.
+ */
+export function rowSelectionRange(
+  row: number,
+  rowLen: number,
+  start: Cell,
+  end: Cell,
+): { from: number; to: number } | null {
+  if (row < start.row || row > end.row) return null;
+  if (rowLen <= 0) return null;
+  const rawFrom = row === start.row ? start.col : 0;
+  const rawTo = row === end.row ? end.col : rowLen - 1;
+  const from = Math.max(0, Math.min(rawFrom, rowLen - 1));
+  const to = Math.max(0, Math.min(rawTo, rowLen - 1));
+  if (to < from) return null;
+  return { from, to };
+}
+
+/**
+ * Extract the selected text from per-row plain strings between ordered
+ * endpoints. Rows join with "\n". When `trimTrailing` (mirror snapshot rows are
+ * space-padded to the pane width), trailing whitespace on each visual row is
+ * stripped — the terminal-copy convention; the editor passes false to keep
+ * buffer text exact.
+ */
+export function extractSelection(
+  rowTexts: string[],
+  start: Cell,
+  end: Cell,
+  trimTrailing = true,
+): string {
+  const out: string[] = [];
+  for (let r = start.row; r <= end.row; r++) {
+    const text = rowTexts[r] ?? "";
+    const range = rowSelectionRange(r, text.length, start, end);
+    let seg = range ? text.slice(range.from, range.to + 1) : "";
+    if (trimTrailing) seg = seg.replace(/\s+$/u, "");
+    out.push(seg);
+  }
+  return out.join("\n");
+}
+
+/**
+ * The inclusive [from,to] char interval of the word at `col` in `text`,
+ * splitting on /\W/ (word chars are [A-Za-z0-9_]). A click on a non-word char
+ * selects just that char; an empty line selects {0,0}.
+ */
+export function wordRangeAt(text: string, col: number): { from: number; to: number } {
+  const n = text.length;
+  if (n === 0) return { from: 0, to: 0 };
+  const c = Math.max(0, Math.min(col, n - 1));
+  const isWord = (ch: string): boolean => /\w/u.test(ch);
+  if (!isWord(text[c]!)) return { from: c, to: c };
+  let from = c;
+  let to = c;
+  while (from > 0 && isWord(text[from - 1]!)) from--;
+  while (to < n - 1 && isWord(text[to + 1]!)) to++;
+  return { from, to };
+}
+
+/** The inclusive [from,to] interval covering the line up to its last non-blank
+ *  char (a blank line → {0,0}). */
+export function lineRangeAt(text: string): { from: number; to: number } {
+  const trimmed = text.replace(/\s+$/u, "");
+  if (trimmed.length === 0) return { from: 0, to: 0 };
+  return { from: 0, to: trimmed.length - 1 };
+}
+
+/**
+ * The resulting click count (1/2/3, cycling to 1 after 3) for double/triple
+ * detection: a click at the same cell within `windowMs` of the previous one
+ * increments; anything else resets to 1.
+ */
+export function clickCount(
+  prev: { row: number; col: number; ts: number; count: number } | null,
+  cell: Cell,
+  ts: number,
+  windowMs: number,
+): number {
+  if (prev && prev.row === cell.row && prev.col === cell.col && ts - prev.ts <= windowMs) {
+    return prev.count >= 3 ? 1 : prev.count + 1;
+  }
+  return 1;
+}
+
+/**
+ * Toggle the inverse attribute across chars [from,to] (inclusive, in row-char
+ * columns) of a row's styled runs, splitting runs at the boundaries so the
+ * selected span renders highlighted while every other run keeps its colors.
+ * XOR (not OR) so an already-inverse cell — e.g. the painted cursor — flips
+ * back, matching pane-mirror's cursor treatment.
+ */
+export function tintRunsInverse<T extends { text: string; attributes: number }>(
+  runs: T[],
+  from: number,
+  to: number,
+): T[] {
+  if (to < from) return runs;
+  const out: T[] = [];
+  let col = 0;
+  for (const run of runs) {
+    const len = run.text.length;
+    const runStart = col;
+    const runEnd = col + len - 1;
+    col += len;
+    if (len === 0 || runEnd < from || runStart > to) {
+      out.push(run);
+      continue;
+    }
+    const a = Math.max(from, runStart) - runStart;
+    const b = Math.min(to, runEnd) - runStart;
+    if (a > 0) out.push({ ...run, text: run.text.slice(0, a) });
+    out.push({ ...run, text: run.text.slice(a, b + 1), attributes: run.attributes ^ ATTR_INVERSE });
+    if (b + 1 < len) out.push({ ...run, text: run.text.slice(b + 1) });
+  }
+  return out;
+}
+
+/**
+ * Set the background color across chars [from,to] (inclusive, in row-char
+ * columns) of a row's styled runs, splitting runs at the boundaries so the
+ * spanned cells render with `bg` while every other run keeps its colors. The
+ * twin of {@link tintRunsInverse} — search-match highlighting paints an accent
+ * background (a distinct treatment from the inverse-video selection) so the two
+ * can coexist on one row. `bg` is packed 0xRRGGBB (the run bg convention).
+ */
+export function tintRunsBg<T extends { text: string; bg: number | null }>(
+  runs: T[],
+  from: number,
+  to: number,
+  bg: number,
+): T[] {
+  if (to < from) return runs;
+  const out: T[] = [];
+  let col = 0;
+  for (const run of runs) {
+    const len = run.text.length;
+    const runStart = col;
+    const runEnd = col + len - 1;
+    col += len;
+    if (len === 0 || runEnd < from || runStart > to) {
+      out.push(run);
+      continue;
+    }
+    const a = Math.max(from, runStart) - runStart;
+    const b = Math.min(to, runEnd) - runStart;
+    if (a > 0) out.push({ ...run, text: run.text.slice(0, a) });
+    out.push({ ...run, text: run.text.slice(a, b + 1), bg });
+    if (b + 1 < len) out.push({ ...run, text: run.text.slice(b + 1) });
+  }
+  return out;
+}
+
+// ── Select mode on app-mouse panes (M22.9) ──────────────────────────────────
+// Panes whose app turned mouse reporting on (`appMouse`) normally get every
+// press FORWARDED, so a drag can never start a local selection there. Two
+// entries reopen selection: an explicit per-pane SELECT MODE (right-click →
+// "Select text…", paused forwarding until esc / a completed copy / focus
+// leaving the pane) and a SHIFT-modified press when the terminal passes shift
+// through (SGR encodes it as +4 on the button code; many terminals keep
+// shift+drag for native selection instead — then only select mode applies).
+
+/** PURE — whether a left press on a pane begins a LOCAL drag selection
+ *  (vs. being forwarded to the pane's app as an SGR press). */
+export function pressStartsSelection(
+  appMouse: boolean,
+  selectModeOn: boolean,
+  shift: boolean,
+): boolean {
+  return !appMouse || selectModeOn || shift;
+}
+
+/** PURE — whether the wheel scrolls the LOCAL mirror scrollback (vs. being
+ *  forwarded as SGR wheel events). Select mode reclaims the wheel so older
+ *  output can be scrolled into view and selected. */
+export function wheelScrollsLocal(appMouse: boolean, selectModeOn: boolean): boolean {
+  return !appMouse || selectModeOn;
+}
+
+/** PURE — the select-mode badge text for a pane width (rendered in the pane's
+ *  top-right badge family, next to the scroll badge), degrading label → glyph
+ *  → hidden on narrow panes exactly like the agent chip's budget. */
+export function selectBadgeLabel(paneWidth: number): string | null {
+  if (paneWidth >= 16) return " ⧉ select ";
+  if (paneWidth >= 5) return " ⧉ ";
+  return null;
+}
+
+/** The raw OSC52 clipboard-set escape for a base64 payload (BEL-terminated). */
+export function osc52Sequence(base64: string): string {
+  return `\x1b]52;c;${base64}\x07`;
+}
+
+/**
+ * Wrap a sequence in the tmux passthrough envelope (DCS `tmux;` … ST) with inner
+ * ESC bytes doubled, so it rides through an outer tmux (with allow-passthrough
+ * on) verbatim to the real terminal. Kept tested + available; the app prefers
+ * raw OSC52 so `set-clipboard on` captures it into tmux's paste buffer.
+ */
+export function tmuxPassthrough(seq: string): string {
+  const doubled = seq.split("\x1b").join("\x1b\x1b");
+  return `\x1bPtmux;${doubled}\x1b\\`;
+}
+
+/** Split `text` into chunks each at most `maxBytes` UTF-8 bytes, never breaking
+ *  a code point — for send-keys -H, whose per-command length tmux caps. */
+export function chunkByBytes(text: string, maxBytes: number): string[] {
+  const enc = new TextEncoder();
+  const chunks: string[] = [];
+  let cur = "";
+  let curBytes = 0;
+  for (const ch of text) {
+    const b = enc.encode(ch).length;
+    if (curBytes + b > maxBytes && cur.length > 0) {
+      chunks.push(cur);
+      cur = "";
+      curBytes = 0;
+    }
+    cur += ch;
+    curBytes += b;
+  }
+  if (cur.length > 0) chunks.push(cur);
+  return chunks;
+}