tmux-ide 2.6.1 → 2.8.0

package/packages/daemon/src/tui/mirror/size-truth.ts

@@ -0,0 +1,130 @@
+/**
+ * Size truth (M22.8) — is tmux's window the size we pinned, or did a co-attached
+ * terminal shrink it out from under us?
+ *
+ * The mirror pins its virtual control client to the render area
+ * (`refresh-client -C`), so when we are the only (or the latest-active) client
+ * the window matches our canvas. But tmux's default `window-size latest` lets a
+ * second, smaller terminal attached to the same session dictate the window size
+ * — and our canvas then renders letterboxed. These PURE helpers detect that
+ * mismatch from the pane layout, center the grid inside the canvas, and format
+ * the quiet honest hint. No tmux, no render loop — unit-tested in isolation; the
+ * app reads the pane geometry and the pinned canvas size and wires the rest.
+ *
+ * KNOWN GAP, measured (M25.5, tmux 3.7b): when TWO app processes mirror the
+ * same session (one per terminal — the non-hosted double-open), the later
+ * control client's boot pin wins `window-size latest`, and the other app can
+ * NEVER re-win it by interaction — the keys/mouse it forwards travel as
+ * control-client `send-keys` commands, which do not update tmux's
+ * latest-client
+ * bookkeeping (measured: local keystroke and wheel left the window at the
+ * other app's pin). The hint + the palette's "Resize to fit" verb are the
+ * designed escape; the structural fix is the hosted cockpit (`--detachable`),
+ * where one app process serves every terminal and REAL clients attach to the
+ * host session, whose native latest handling re-adopts on attach/focus/detach.
+ */
+
+export interface Size {
+  cols: number;
+  rows: number;
+}
+
+/** The minimal pane rectangle the bounding box needs (LivePane is assignable). */
+export interface Rect {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * PURE — the effective window size implied by the pane layout: the bounding box
+ * of all pane rects. tmux tiles panes to fill the whole window (edge panes sit
+ * flush to the edges, borders live between them), so the maximum right edge
+ * (`left + width`) is the window width and the maximum bottom edge
+ * (`top + height`) is the window height. Null when there are no panes yet.
+ */
+export function effectiveWindowSize(panes: readonly Rect[]): Size | null {
+  if (panes.length === 0) return null;
+  let cols = 0;
+  let rows = 0;
+  for (const p of panes) {
+    cols = Math.max(cols, p.left + p.width);
+    rows = Math.max(rows, p.top + p.height);
+  }
+  return { cols, rows };
+}
+
+/**
+ * PURE — the actual window size when it DIFFERS from what we pinned (another
+ * terminal is dictating it), else null. Any difference on either axis counts;
+ * equal sizes mean we own the window and there is nothing to surface.
+ */
+export function detectSizeMismatch(pinned: Size, effective: Size): Size | null {
+  if (effective.cols === pinned.cols && effective.rows === pinned.rows) return null;
+  return { cols: effective.cols, rows: effective.rows };
+}
+
+/**
+ * PURE — the letterbox offset that centers a `content`-sized grid inside a
+ * `canvas`-sized area. Never negative (a window LARGER than the canvas pins to
+ * the origin and clips rather than shifting off-screen), floored so cells stay
+ * aligned to the grid.
+ */
+export function letterboxOffset(canvas: Size, content: Size): { x: number; y: number } {
+  return {
+    x: Math.max(0, Math.floor((canvas.cols - content.cols) / 2)),
+    y: Math.max(0, Math.floor((canvas.rows - content.rows) / 2)),
+  };
+}
+
+/** An in-flight re-pin (M23.5): we changed our pinned size and tmux has not
+ *  confirmed the new layout yet. `prev` is the pin BEFORE this re-pin. */
+export interface RepinState {
+  prev: Size;
+  at: number;
+}
+
+/** How long any mismatch is suppressed after a re-pin (server round-trip +
+ *  layout-change latency is sub-ms; the margin covers a loaded machine). */
+export const REPIN_GRACE_MS = 400;
+/** How long a mismatch that still equals the PRE-repin pin is suppressed — the
+ *  unambiguous "tmux hasn't applied our new pin yet" signature can wait longer
+ *  before we call it another terminal's doing. */
+export const REPIN_STALE_GRACE_MS = 1500;
+
+/**
+ * PURE — {@link detectSizeMismatch}, gated for the re-pin transition (M23.5,
+ * D4b): between our `refresh-client -C` and tmux's `%layout-change` the
+ * effective size is legitimately stale, and surfacing it flashed a false
+ * "window sized by another terminal" hint plus a letterbox jump-to-center on
+ * EVERY grow (measured). Suppress the mismatch while a re-pin is in flight:
+ * any mismatch within {@link REPIN_GRACE_MS}, and — for longer, up to
+ * {@link REPIN_STALE_GRACE_MS} — one whose effective size still equals the
+ * pre-repin pin exactly (that shape can only be the old pin, not a co-attached
+ * terminal's choice). Past the grace the honest hint returns.
+ */
+export function detectSizeMismatchWithRepin(
+  pinned: Size,
+  effective: Size,
+  repin: RepinState | null,
+  now: number,
+): Size | null {
+  const mm = detectSizeMismatch(pinned, effective);
+  if (!mm || !repin) return mm;
+  const age = now - repin.at;
+  if (age < REPIN_GRACE_MS) return null;
+  const isPrevPin = effective.cols === repin.prev.cols && effective.rows === repin.prev.rows;
+  if (isPrevPin && age < REPIN_STALE_GRACE_MS) return null;
+  return mm;
+}
+
+/**
+ * PURE — the quiet, plain-language hint for a size mismatch: the honest answer
+ * ("here is the size another terminal chose"), dimensions in the terminal-native
+ * `cols×rows` form. Dismiss-free — the app shows it only while the mismatch
+ * exists, so it disappears the moment the sizes agree.
+ */
+export function formatSizeHint(effective: Size): string {
+  return `window sized by another terminal — ${effective.cols}×${effective.rows}`;
+}

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

@@ -0,0 +1,46 @@
+/** Pure horizontal-span geometry shared by the two clickable tab rows — the
+ *  surface tab bar (F1..F4, startX=0, gap=0) and the per-window strip inside the
+ *  Terminal surface (startX=SIDEBAR_W+1, gap=1). Both render a row of labels
+ *  laid out left-to-right and both resolve clicks in the central `route` by
+ *  x-span math; keeping that math in one tested place is the whole point (the
+ *  window strip's old inline math drifted from its render and hit the late-mount
+ *  landmine). Index `i` of the returned array maps to `labels[i]`. */
+export interface Span {
+  /** First column (inclusive) this label occupies. */
+  start: number;
+  /** Cell width — the label's string length (labels are single display-width). */
+  width: number;
+}
+
+/** Lay `labels` out from `startX`, each `label.length` cells wide, separated by
+ *  `gap` blank cells. Pure. */
+export function spans(labels: string[], startX: number, gap: number): Span[] {
+  const out: Span[] = [];
+  let x = startX;
+  for (const label of labels) {
+    out.push({ start: x, width: label.length });
+    x += label.length + gap;
+  }
+  return out;
+}
+
+/** Lay `labels` out left-to-right anchored to the RIGHT: the last label ends
+ *  flush at `rightEdge` (its final cell is `rightEdge - 1`), separated by `gap`.
+ *  For right-aligned header affordance buttons whose PRECEDING content is
+ *  variable-width — the layout is pinned to the (fixed) right edge, not a left
+ *  origin, so the render (a flexGrow spacer then the buttons) and the router
+ *  agree cell-for-cell. Pure. */
+export function spansFromRight(labels: string[], rightEdge: number, gap: number): Span[] {
+  const total = labels.reduce((n, l) => n + l.length, 0) + gap * Math.max(0, labels.length - 1);
+  return spans(labels, rightEdge - total, gap);
+}
+
+/** Index of the span containing column `x`, or -1. Gap cells between spans and
+ *  columns past the last span resolve to -1 (no hit). */
+export function spanHit(list: Span[], x: number): number {
+  for (let i = 0; i < list.length; i++) {
+    const s = list[i]!;
+    if (x >= s.start && x < s.start + s.width) return i;
+  }
+  return -1;
+}

package/packages/daemon/src/tui/mirror/status-grammar.ts

@@ -0,0 +1,32 @@
+/**
+ * The unified app's status glyph + color grammar — PURE declarative data, hoisted
+ * out of app.tsx (M22.2) so every mirror surface shares ONE source of truth: the
+ * sidebar fleet tree, the home rollup chips, the AGENTS section, and (post-merge)
+ * the pane-chrome agent chips. Keyed by {@link AgentStatus}.
+ *
+ * This is the MIRROR app's grammar — deliberately distinct from the cockpit's
+ * (whose idle glyph is a filled ●) and from chrome's color tokens. Do not swap
+ * in either of those: keep every mirror surface in one visual family.
+ */
+import { RGBA } from "@opentui/core";
+import type { AgentStatus } from "../detect/classify.ts";
+
+/** Per-state foreground color: blocked red, working amber, done blue, idle
+ *  green, unknown grey. */
+export const STATUS_COLOR: Record<AgentStatus, RGBA> = {
+  blocked: RGBA.fromInts(240, 100, 100, 255),
+  working: RGBA.fromInts(235, 200, 100, 255),
+  done: RGBA.fromInts(120, 170, 250, 255),
+  idle: RGBA.fromInts(120, 200, 140, 255),
+  unknown: RGBA.fromInts(110, 110, 130, 255),
+};
+
+/** Per-state glyph: working/blocked/done share the filled dot (color carries the
+ *  distinction), idle is hollow, unknown a middot. */
+export const STATUS_GLYPH: Record<AgentStatus, string> = {
+  blocked: "●",
+  working: "●",
+  done: "●",
+  idle: "○",
+  unknown: "·",
+};

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

@@ -0,0 +1,45 @@
+/**
+ * The unified app's color tokens — PURE data, hoisted out of app.tsx (M26) so
+ * the surfaces extracted from it (starting with {@link ./sidebar.tsx}) carry
+ * their palette with them instead of reaching back into a 21k-line module.
+ *
+ * Companion to {@link ./status-grammar.ts}: that file owns the per-AGENT-STATE
+ * glyph + hue (a status signal), this one owns the CHROME (surface, accent,
+ * hover, selection). Keep the two families distinct — focus is an accent signal,
+ * agent state is a status signal, and they must never collide on a hue.
+ *
+ * Node-free on purpose: the web host (docs/tui-web) imports this module
+ * verbatim, aliasing @opentui/core to a browser shim for RGBA.
+ */
+import { RGBA } from "@opentui/core";
+
+export const DEFAULT_FG = RGBA.fromInts(212, 212, 216, 255);
+export const DEFAULT_BG = RGBA.fromInts(16, 16, 22, 255);
+
+/** The sidebar's surface — one lift above DEFAULT_BG so the nav column reads as
+ *  chrome, not as content. */
+export const SIDEBAR_BG = RGBA.fromInts(22, 22, 30, 255);
+export const ACCENT = RGBA.fromInts(130, 170, 255, 255);
+export const MUTED = RGBA.fromInts(110, 110, 130, 255);
+export const BADGE_BG = RGBA.fromInts(60, 66, 92, 255);
+
+/** Focused-pane gutter hairline (M22.7): the ACCENT family, drawn as │/─ glyphs
+ *  so the gutter stays visually thin (a filled bar read as extra padding — user
+ *  feedback). Doesn't compete with the blocked chip's red — focus is an accent
+ *  signal, agent state is a status signal, never the same hue. */
+export const FOCUS_BORDER_FG = RGBA.fromInts(110, 145, 230, 255);
+
+/** The selected row/tab. Always wins over HOVER_BG. */
+export const TAB_ACTIVE_BG = RGBA.fromInts(40, 46, 66, 255);
+
+/** A single subtle pointer-hover tint, one lift above both DEFAULT_BG (16,16,22)
+ *  and SIDEBAR_BG (22,22,30) and below TAB_ACTIVE_BG — the active/selected state
+ *  always wins over hover. Used on every hoverable row/segment. */
+export const HOVER_BG = RGBA.fromInts(30, 34, 48, 255);
+
+/** A chip/button under the pointer. */
+export const BUTTON_HOVER_BG = RGBA.fromInts(52, 60, 86, 255);
+
+/** The attention flash (M25.1): a just-flipped hidden agent's row pulses this
+ *  for a beat — the status-strip note's "look here" twin. */
+export const CHIP_ATTN_BG = RGBA.fromInts(92, 44, 48, 255);

package/packages/daemon/src/tui/team/entry.ts

@@ -1,11 +1,38 @@
 /**
- * Front-door decision for bare `tmux-ide` / `tmux-ide start`: open the team
- * cockpit (the multi-project TUI) instead of launching a single project.
+ * Front-door decision for bare `tmux-ide` / `tmux-ide start`: what does running
+ * the command with no subcommand land on?
  *
- * The cockpit is the default entry when there's no single-project `ide.yml` to
- * launch here, or when `--team` forces it. When an `ide.yml` is present, bare
- * invocation still launches that project (backward compatible).
+ * Three outcomes:
+ *  - `"project"` — a single-project `ide.yml` is present here (and `--team`
+ *    wasn't passed): launch that project, exactly as always (backward compatible).
+ *  - `"app"` — the M22.6 front-door flip: when there's no project to launch and
+ *    the user opted in (`app.frontDoor`), bare `tmux-ide` opens the unified app
+ *    (`tmux-ide app`) — the VS-Code-style "starts anywhere" entry.
+ *  - `"cockpit"` — the classic team cockpit: the default no-project entry while
+ *    the flip is off, and always the target of an explicit `--team`.
+ *
+ * `--team` ALWAYS means the classic cockpit (an explicit request for it), so it
+ * overrides both a present `ide.yml` and the front-door flip.
+ */
+export type EntryTarget = "project" | "cockpit" | "app";
+
+export interface ResolveEntryOptions {
+  /** Whether an `ide.yml` is present in the target directory. */
+  hasIdeYml: boolean;
+  /** Whether `--team` forced the cockpit. */
+  teamFlag: boolean;
+  /** The `app.frontDoor` config flag — flip the default no-project entry to the app. */
+  frontDoor: boolean;
+}
+
+/**
+ * PURE — resolve the bare-invocation target. `--team` wins (always the classic
+ * cockpit); otherwise a present `ide.yml` launches the project; otherwise the
+ * front-door flag decides between the unified app (opted in) and the classic
+ * cockpit (default).
  */
-export function shouldOpenCockpit(hasIdeYml: boolean, teamFlag: boolean): boolean {
-  return teamFlag || !hasIdeYml;
+export function resolveEntry(opts: ResolveEntryOptions): EntryTarget {
+  if (opts.teamFlag) return "cockpit";
+  if (opts.hasIdeYml) return "project";
+  return opts.frontDoor ? "app" : "cockpit";
 }

package/packages/daemon/src/tui/team/fuzzy.ts

@@ -24,6 +24,15 @@ const START_BONUS = 10; // matched char is the first char of the target
 const SEPARATOR_BONUS = 8; // matched char follows a separator (word start)
 const CONTIGUOUS_BONUS = 5; // matched char is adjacent to the previous match
 const BASE = 1; // every matched char is worth at least this
+// Whole-alignment extra when the query is a contiguous PREFIX of the target
+// (M24.4): typing a label's start must rank that label above mid-word runs
+// AND above scattered matches that rack up several word-start bonuses —
+// measured: "save" scored 29 on "Save file" but 30 on "swap pane view east"
+// (three word-start hits). Sized to dominate realistic competitors (a
+// non-prefix alignment outscores a prefix only past ~8 all-word-start chars);
+// word-boundary preference WITHIN non-prefix matches is untouched ("web"
+// still anchors on the "web" of `wavyr-website`, not the leading "w").
+const PREFIX_EXTRA = 24;
 
 /**
  * Case-insensitive subsequence match of `query` against `target`.
@@ -106,6 +115,17 @@ export function fuzzyMatch(
   }
   if (start === -1) return null;
 
+  // The exact/prefix tier (M24.4): when the query IS the target's start, that
+  // alignment (positions 0..m-1) + PREFIX_EXTRA competes with the DP's best —
+  // and effectively always wins, so prefix matches rank first however many
+  // word-start bonuses a scattered alignment collected.
+  if (t.startsWith(q)) {
+    const prefixScore = m * BASE + START_BONUS + (m - 1) * CONTIGUOUS_BONUS + PREFIX_EXTRA;
+    if (prefixScore >= bestScore) {
+      return { score: prefixScore, positions: Array.from({ length: m }, (_, i) => i) };
+    }
+  }
+
   const positions: number[] = [];
   let j = start;
   for (let i = 0; i < m && j !== -1; i++) {

package/packages/daemon/src/tui/team/report.ts

@@ -10,7 +10,7 @@
  */
 import type { AgentStatus } from "../detect/classify.ts";
 import type { TeamProject } from "./projects.ts";
-import type { TeamSession } from "./sessions.ts";
+import type { PaneAgentEntry, TeamSession } from "./sessions.ts";
 
 /** The stable JSON shape emitted by `tmux-ide team --json`. */
 export interface FleetJson {
@@ -32,6 +32,13 @@ export interface FleetJson {
         panes: number;
         status: AgentStatus;
       }>;
+      /**
+       * Per-pane agent detail — one entry per pane the detection layer resolves
+       * to a real agent, flat across the session's windows (each entry carries
+       * its `windowIndex`). ADDITIVE: always present (possibly empty); existing
+       * consumers that ignore it are unaffected.
+       */
+      agents: PaneAgentEntry[];
     }>;
   }>;
 }
@@ -57,6 +64,9 @@ export function toFleetJson(projects: TeamProject[]): FleetJson {
           panes: w.panes,
           status: w.status,
         })),
+        // A pre-agents TeamSession (older constructor/test) yields `[]` — the
+        // contract always exposes the array.
+        agents: s.agents ?? [],
       })),
     })),
   };