tmux-ide 2.7.0 → 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/dialog-stack.ts

@@ -279,6 +279,17 @@ export interface DialogKeyEvent {
   shift: boolean;
 }
 
+/** The typed character a key event contributes to a filter/prompt, or null.
+ *  OpenTUI names the space key `"space"` (not a 1-char name), so the bare
+ *  length-1 check silently DROPPED every space — a custom command with flags
+ *  could never be typed (measured live, M24.1). */
+function typedChar(evt: DialogKeyEvent): string | null {
+  if (evt.ctrl || evt.meta) return null;
+  if (evt.name === "space") return " ";
+  if (evt.name.length === 1) return evt.shift ? evt.name.toUpperCase() : evt.name;
+  return null;
+}
+
 /**
  * Feed one key to the stack's top dialog. Centralized ESCAPE lives here: it
  * pops exactly one level. The caller must treat EVERY key as consumed while
@@ -313,8 +324,9 @@ export function dialogKey(stack: DialogStack, evt: DialogKeyEvent): void {
       state.armed = null;
       return stack.touch();
     }
-    if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
-      state.query += evt.shift ? evt.name.toUpperCase() : evt.name;
+    const ch = typedChar(evt);
+    if (ch !== null) {
+      state.query += ch;
       state.sel = 0;
       state.top = 0;
       state.armed = null;
@@ -338,8 +350,9 @@ export function dialogKey(stack: DialogStack, evt: DialogKeyEvent): void {
       state.error = null;
       return stack.touch();
     }
-    if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
-      state.input += evt.shift ? evt.name.toUpperCase() : evt.name;
+    const ch = typedChar(evt);
+    if (ch !== null) {
+      state.input += ch;
       state.error = null;
       return stack.touch();
     }

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

@@ -1,14 +1,22 @@
 /**
- * Pure, io-free helpers for the built-in git diff panel (M18.3).
+ * Pure, io-free helpers for the built-in git diff panel (M18.3; grouped +
+ * stage-aware M24.5).
  *
  * Like {@link ./editor-buffer.ts}, this imports NOTHING from @opentui/core: the
  * app runs the git subprocesses (async execFile) and reads untracked files, but
  * the PARSING and coordinate math live here so they unit-test as tables under
  * the Node/vitest runner while app.tsx keeps the OpenTUI wiring.
  *
- * Three concerns: (1) parse `git status --porcelain` into a flat, display-ready
- * file list; (2) classify each `git diff` line so the renderer can color it; and
- * (3) turn an untracked file's contents into an all-additions pseudo-diff (git
+ * Concerns: (1) parse `git status --porcelain` into display-ready entries —
+ * flat ({@link parseStatusPorcelain}, legacy) or split into Staged / Unstaged /
+ * Untracked components ({@link parseStatusGroups}: an `MM` file yields BOTH a
+ * staged and an unstaged row, each diffing its own side of the index); (2) lay
+ * the grouped entries out as list ROWS (section headers + files) whose math is
+ * shared by the render and the mouse router ({@link buildDiffRows}); (3) merge
+ * `git diff --numstat` ± counts into the entries; (4) classify each `git diff`
+ * line so the renderer can color it; (5) hunk coordinate math — `]`/`[` jump
+ * targets and the `^e` open-editor-at-line target parsed from `@@ -a,b +c,d`;
+ * (6) turn an untracked file's contents into an all-additions pseudo-diff (git
  * diff prints nothing for untracked paths).
  */
 
@@ -110,3 +118,270 @@ export function clampSel(sel: number, count: number): number {
   if (count <= 0) return 0;
   return Math.max(0, Math.min(sel, count - 1));
 }
+
+// ── Grouped list (M24.5) ─────────────────────────────────────────────────────
+
+/** Which section of the grouped list an entry belongs to. */
+export type DiffGroup = "staged" | "unstaged" | "untracked";
+
+/** One stage-aware changed-file entry: a porcelain XY line is SPLIT into its
+ *  index and worktree components, so an `MM` file yields two entries — the
+ *  staged one diffs `--cached`, the unstaged one diffs the worktree. */
+export interface DiffEntry {
+  group: DiffGroup;
+  /** Display letter for THIS component: the X (index) letter for staged rows,
+   *  the Y (worktree) letter for unstaged rows, `?` for untracked. */
+  status: string;
+  /** Repo-relative path (the NEW path for renames). */
+  path: string;
+  /** ± line counts from `git diff --numstat` (untracked: the file's line
+   *  count). `null` until loaded, and for binary/unreadable files. */
+  additions: number | null;
+  deletions: number | null;
+}
+
+/**
+ * PURE — parse porcelain v1 output into grouped, stage-aware entries. Each
+ * `XY PATH` line contributes: a STAGED entry when X is a real index state, an
+ * UNSTAGED entry when Y is a real worktree state, or one UNTRACKED entry for
+ * `??`. Ignored (`!!`) and malformed lines are skipped. Counts start `null`
+ * ({@link applyCounts} fills them).
+ */
+export function parseStatusGroups(out: string): DiffEntry[] {
+  const entries: DiffEntry[] = [];
+  for (const line of out.split("\n")) {
+    if (line.length < 4) continue;
+    const index = line[0]!;
+    const work = line[1]!;
+    let rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    if (arrow !== -1) rest = rest.slice(arrow + 4);
+    if (index === "!" && work === "!") continue;
+    if (index === "?" && work === "?") {
+      entries.push({
+        group: "untracked",
+        status: "?",
+        path: rest,
+        additions: null,
+        deletions: null,
+      });
+      continue;
+    }
+    if (index !== " " && index !== "?")
+      entries.push({
+        group: "staged",
+        status: index,
+        path: rest,
+        additions: null,
+        deletions: null,
+      });
+    if (work !== " " && work !== "?")
+      entries.push({
+        group: "unstaged",
+        status: work,
+        path: rest,
+        additions: null,
+        deletions: null,
+      });
+  }
+  return entries;
+}
+
+/** PURE — narrow entries to paths containing `query` (case-insensitive
+ *  substring). An empty/blank query returns the input unchanged. */
+export function filterEntries(entries: DiffEntry[], query: string): DiffEntry[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return entries;
+  return entries.filter((e) => e.path.toLowerCase().includes(q));
+}
+
+/** One row of the grouped file list: a non-selectable section header or a file
+ *  entry carrying its index into the flat selectable-file order. */
+export type DiffRow =
+  | { kind: "header"; group: DiffGroup; label: string }
+  | { kind: "file"; entry: DiffEntry; fileIndex: number };
+
+const GROUP_ORDER: { group: DiffGroup; label: string }[] = [
+  { group: "staged", label: "Staged" },
+  { group: "unstaged", label: "Unstaged" },
+  { group: "untracked", label: "Untracked" },
+];
+
+/**
+ * PURE — lay grouped entries out as list rows: per-group `Label (n)` headers
+ * (only for non-empty groups, in Staged → Unstaged → Untracked order) followed
+ * by that group's files. `files` is the flat selectable order — `fileIndex` on
+ * each file row indexes it, so the selection model stays a plain integer while
+ * the render/hit math walk ROWS. Shared render↔router, one source of truth.
+ */
+export function buildDiffRows(entries: DiffEntry[]): { rows: DiffRow[]; files: DiffEntry[] } {
+  const rows: DiffRow[] = [];
+  const files: DiffEntry[] = [];
+  for (const { group, label } of GROUP_ORDER) {
+    const members = entries.filter((e) => e.group === group);
+    if (members.length === 0) continue;
+    rows.push({ kind: "header", group, label: `${label} (${members.length})` });
+    for (const entry of members) {
+      rows.push({ kind: "file", entry, fileIndex: files.length });
+      files.push(entry);
+    }
+  }
+  return { rows, files };
+}
+
+/** PURE — the row index of selectable file `fileIndex` (for keeping the
+ *  selection in view when the list scrolls over ROWS). -1 when absent. */
+export function rowIndexOfFile(rows: DiffRow[], fileIndex: number): number {
+  return rows.findIndex((r) => r.kind === "file" && r.fileIndex === fileIndex);
+}
+
+// ── numstat (M24.5) ──────────────────────────────────────────────────────────
+
+/** ± line counts for one file. */
+export interface Numstat {
+  additions: number;
+  deletions: number;
+}
+
+/** Resolve a numstat path cell to the NEW path: renames print either
+ *  `pre{old => new}post` (common-prefix brace form) or a bare `old => new`. */
+function numstatPath(raw: string): string {
+  const brace = raw.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
+  if (brace) return `${brace[1]}${brace[3]}${brace[4]}`;
+  const arrow = raw.indexOf(" => ");
+  if (arrow !== -1) return raw.slice(arrow + 4);
+  return raw;
+}
+
+/**
+ * PURE — parse `git diff --numstat` output (`added<TAB>deleted<TAB>path`) into
+ * a path → counts map. Binary files print `-	-	path` and are SKIPPED (their
+ * entries keep `null` counts); rename cells resolve to the new path.
+ */
+export function parseNumstat(out: string): Map<string, Numstat> {
+  const counts = new Map<string, Numstat>();
+  for (const line of out.split("\n")) {
+    if (!line) continue;
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const additions = parseInt(parts[0]!, 10);
+    const deletions = parseInt(parts[1]!, 10);
+    if (Number.isNaN(additions) || Number.isNaN(deletions)) continue; // binary: "-"
+    counts.set(numstatPath(parts.slice(2).join("\t")), { additions, deletions });
+  }
+  return counts;
+}
+
+/** PURE — the line count an untracked file shows as its `+` count: content
+ *  lines, with the single trailing newline's empty not counted (mirrors
+ *  {@link untrackedDiffText}); empty content counts 0. */
+export function untrackedLineCount(content: string): number {
+  if (content === "") return 0;
+  const lines = content.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines.length;
+}
+
+/**
+ * PURE — merge per-group counts into entries (staged entries read the
+ * `--cached` numstat, unstaged the worktree numstat, untracked the line-count
+ * map). Entries without a match keep `null` counts (binary/unreadable).
+ */
+export function applyCounts(
+  entries: DiffEntry[],
+  staged: Map<string, Numstat>,
+  unstaged: Map<string, Numstat>,
+  untrackedLines: Map<string, number>,
+): DiffEntry[] {
+  return entries.map((e) => {
+    if (e.group === "untracked") {
+      const lines = untrackedLines.get(e.path);
+      return lines === undefined ? e : { ...e, additions: lines, deletions: 0 };
+    }
+    const n = (e.group === "staged" ? staged : unstaged).get(e.path);
+    return n === undefined ? e : { ...e, additions: n.additions, deletions: n.deletions };
+  });
+}
+
+/** PURE — sum the loaded ± counts across entries (nulls contribute 0), for the
+ *  header totals. */
+export function totalCounts(entries: DiffEntry[]): { additions: number; deletions: number } {
+  let additions = 0;
+  let deletions = 0;
+  for (const e of entries) {
+    additions += e.additions ?? 0;
+    deletions += e.deletions ?? 0;
+  }
+  return { additions, deletions };
+}
+
+// ── Hunk math (M24.5) ────────────────────────────────────────────────────────
+
+/** A parsed `@@ -a,b +c,d @@` header (counts default 1 when omitted). */
+export interface HunkHeader {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+}
+
+/** PURE — parse a hunk header line; null for anything else. */
+export function parseHunkHeader(text: string): HunkHeader | null {
+  const m = text.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+  if (!m) return null;
+  return {
+    oldStart: parseInt(m[1]!, 10),
+    oldCount: m[2] !== undefined ? parseInt(m[2], 10) : 1,
+    newStart: parseInt(m[3]!, 10),
+    newCount: m[4] !== undefined ? parseInt(m[4], 10) : 1,
+  };
+}
+
+/** PURE — the indices of all hunk-header lines in a classified diff. */
+export function hunkLineIndices(lines: DiffLine[]): number[] {
+  const out: number[] = [];
+  for (let i = 0; i < lines.length; i++) if (lines[i]!.kind === "hunk") out.push(i);
+  return out;
+}
+
+/** PURE — the `]`/`[` jump target: the first hunk-line index strictly after
+ *  (`dir` 1) or before (`dir` -1) the current view top. null = no further hunk
+ *  in that direction (the view stays put). */
+export function nextHunkTop(lines: DiffLine[], top: number, dir: 1 | -1): number | null {
+  const hunks = hunkLineIndices(lines);
+  if (dir === 1) {
+    for (const i of hunks) if (i > top) return i;
+    return null;
+  }
+  for (let j = hunks.length - 1; j >= 0; j--) if (hunks[j]! < top) return hunks[j]!;
+  return null;
+}
+
+/**
+ * PURE — the `^e` open-editor target: the 0-based NEW-file line of the first
+ * changed (add/del) line of the SELECTED hunk — the hunk whose header is at or
+ * nearest above the current view top (the first hunk when the view is above
+ * them all). Walks from `+c` counting context/add lines; a del line targets
+ * the new-file position where the removal happened. Falls back to `c` itself
+ * for a hunk with no explicit ± lines, and null when the diff has no hunks
+ * (binary/meta-only/pseudo-diff — the caller opens at 0).
+ */
+export function hunkEditTarget(lines: DiffLine[], top: number): number | null {
+  const hunks = hunkLineIndices(lines);
+  if (hunks.length === 0) return null;
+  let h = hunks[0]!;
+  for (const i of hunks) {
+    if (i <= top) h = i;
+    else break;
+  }
+  const hdr = parseHunkHeader(lines[h]!.text);
+  if (!hdr) return null;
+  let newLine = hdr.newStart; // 1-based
+  for (let i = h + 1; i < lines.length; i++) {
+    const kind = lines[i]!.kind;
+    if (kind === "hunk" || kind === "meta") break;
+    if (kind === "add" || kind === "del") return Math.max(0, newLine - 1);
+    newLine++; // context
+  }
+  return Math.max(0, hdr.newStart - 1);
+}