@sandropadin/tend 0.1.0

package/AGENTS.md

@@ -0,0 +1,160 @@
+# AGENTS.md — working on tend
+
+Context for AI agents (and humans) modifying this repo. Read this before touching
+detection, tmux glue, or the dashboard. User-facing usage lives in
+[README.md](README.md); this file is the *why* and the *gotchas*.
+
+## What this is
+
+`tend` reports the status of AI coding agents (Claude Code, Codex, …) running
+inside **tmux** panes — blocked / working / idle — grouped by session, with a
+live selectable dashboard that can jump you (or another window) to an agent. It
+deliberately does **not** multiplex, split, or manage windows — tmux already
+does that.
+
+## Running & dev loop
+
+- **Local dev needs no build.** Node ≥ 22.18 runs the TypeScript directly:
+  `node src/index.ts`. Don't add a bundler or a dev-time transpile step.
+- **Distribution DOES need a build — don't remove it.** Node refuses to
+  type-strip files under `node_modules`
+  (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), so an installed/published
+  package can't run the raw `.ts`. `npm run build` (`tsconfig.build.json`) emits
+  `dist/` with `./x.ts` import specifiers rewritten to `./x.js`; `bin` points at
+  `dist/index.js`; the `prepare` hook builds it automatically on install / git
+  install / publish. `dist/` is gitignored (built on demand, never committed).
+- Typecheck with `npx tsc --noEmit` (it's `noEmit`; tsc is only a checker here).
+- **Zero runtime dependencies.** The only deps are dev-only `@types/node` +
+  `typescript`. Keep it that way — everything is Node stdlib + shelling out to
+  `tmux`/`git`. Don't reach for a TUI/ANSI/arg-parsing library.
+- The tool must be run where a tmux server is reachable. Inside tmux it scans the
+  current session by default; outside (or with no `--current`) it scans all.
+
+## Architecture (one job per file)
+
+| File | Role |
+|------|------|
+| `src/types.ts` | Data model: `AgentState`, `Rule`, `Manifest`, `PaneInfo`, `AgentStatus`. |
+| `src/regions.ts` | Region extractors — pure string slicers over captured pane text. |
+| `src/manifests.ts` | **The detection rules you tune.** Per-agent identity + state patterns. |
+| `src/detect.ts` | Engine: `identifyAgent` + `resolveState` (signal arbitration). |
+| `src/tmux.ts` | All tmux shelling: list panes, capture, switch/select clients, list clients. |
+| `src/git.ts` | Git branch/dirty/ahead-behind via the `git` binary, cached per repo root. |
+| `src/scan.ts` | One detection pass over all panes; shared by every mode. |
+| `src/nav.ts` | Jump logic (switch-client / attach / target another client). |
+| `src/render.ts` | Grouped/JSON output, state glyph + spinner, ANSI helpers. |
+| `src/pick.ts` | Interactive dashboard (raw-mode TUI): keys, animation, target cycling. |
+| `src/index.ts` | CLI arg parsing + mode dispatch. |
+
+Data flow: `scan()` → `listPanes()` (tmux) → per pane `capturePane()` +
+`resolveState()` → `AgentStatus[]` → `render*` / `pick`.
+
+## The detection model
+
+Two independent halves, both driven by **data, not code**:
+
+1. **Identity** (`identifyAgent`): match `pane_current_command` against a
+   manifest's `match` names → its `commandPattern` regex → screen `signature`
+   substrings. Highest-confidence source wins.
+2. **State** (`resolveState` + manifest `rules`): capture the pane's rendered
+   screen, run the agent's rules by `priority` (highest match wins) over a
+   `region` of the screen; then arbitrate against PTY activity.
+
+Arbitration order in `resolveState` (do not casually reorder):
+`skipStateUpdate` (hold prev) → **blocked** (active match only) → **working**
+(content changed since last scan) → working (on-screen interrupt hint) → **idle**
+(debounced: must persist two scans) → else keep previous.
+
+## Invariants & gotchas (each was a real bug — don't reintroduce)
+
+- **tmux sanitizes control chars in `-F` output to `_`** — including a chosen
+  field separator *and even newlines*. So you cannot pack multiple fields into
+  one `-F` line. `listPanes` queries **one field per call**, each paired with
+  `#{pane_id}` and split on the first `|` (pane ids are `%<digits>`, never
+  contain `|`), then merges by id. Keep this pattern for any new pane/client
+  field. (`src/tmux.ts`)
+- **Claude Code renames its process comm to its version string** (e.g.
+  `2.1.200`), so `pane_current_command` is *not* `claude`. Identity relies on the
+  semver `commandPattern` (`^\d+\.\d+\.\d+`). Screen `signature`s must be
+  *persistent* chrome (mode footer, `esc to interrupt`, permission prompt) — the
+  welcome banner scrolls off mid-session and must not be relied on. (`manifests.ts`)
+- **Blocked must key on the LIVE selection cursor** (`^\s*❯\s+\d+\.`), not the
+  question text. The prompt text ("Do you want to proceed?") lingers in the
+  scroll buffer after you answer; the `❯ 1.` cursor disappears the instant you
+  answer. **Blocked is also never inherited** — `resolveState`'s `keep()` demotes
+  a held `blocked` to `idle`, so a stale block can't persist. (`detect.ts`,
+  `manifests.ts`)
+- **Dashboard redraw must erase each line's tail (`\x1b[K`)**, not just clear
+  below the last line. Otherwise a line that gets *shorter* (e.g. a `· 1 blocked`
+  suffix that goes away) leaves ghost text. Don't switch back to a full-screen
+  `\x1b[2J` clear — it flickers against the ~90ms spinner tick. (`pick.ts`)
+- **The spinner animates on its own ~90ms timer, separate from the 800ms scan**,
+  and only ticks while something is `working` (an all-idle board stays quiet). Do
+  not scan tmux on the animation tick — `render()` only rebuilds strings.
+- **Cross-window jump uses `switch-client -c <client_tty>`.** tmux is
+  client-server: each attached terminal is a client identified by its tty.
+  `selfClientTty()` is only meaningful **inside** tmux — guard it with
+  `insideTmux()`, or a plain-terminal dashboard will mislabel the one real client
+  as "self" and find no targets. (`nav.ts`, `pick.ts`, `index.ts`)
+- **Jump behavior is context-dependent:** targeting another client, or self
+  inside tmux, keeps the dashboard alive; self *outside* tmux means `tmux attach`
+  (takes over the terminal), so there it exits. (`nav.ts::jumpToPane`)
+- **`scan()` preserves tmux pane order** (resolve concurrently, then filter in
+  order) so the grouped view is stable across refreshes — don't `push` in
+  async-completion order.
+
+## Changing detection rules (the common task)
+
+Agent TUIs drift, so `manifests.ts` is expected to need tuning. Workflow:
+
+1. `node src/index.ts --debug <pane>` against a live agent pane. It prints what
+   each region extractor pulls out and marks which rules ✓ match.
+2. Adjust the rule's `region` / `contains` / `anyContains` / `regex` / `not`.
+   Rules are `{ id, state, priority, region, … }`; highest matching priority
+   wins. Regions: `full`, `after_last_horizontal_rule`, `prompt_box_body`,
+   `{ bottom_non_empty_lines: N }` (see `regions.ts`).
+3. Prefer matching the **live** interactive element over lingering text (see the
+   blocked invariant above), and set `skipStateUpdate: true` for scrollback /
+   picker screens that shouldn't author state.
+
+## Testing (no framework — use throwaway tmux servers)
+
+There's no test runner; verify against **isolated tmux servers** on a dedicated
+socket so you never touch the user's real session:
+
+```sh
+SOCK=/tmp/tend-test.sock
+tmux -S "$SOCK" new-session -d -s demo -n runner
+# simulate an agent by printing its TUI into a pane:
+tmux -S "$SOCK" new-window -t demo -n agent
+tmux -S "$SOCK" send-keys -t demo:agent "clear; printf '%s\n' 'Do you want to proceed?' '❯ 1. Yes' '  2. No'" Enter
+# run tend FROM INSIDE that server (so its plain `tmux` calls hit $SOCK):
+tmux -S "$SOCK" send-keys -t demo:runner "node /abs/path/src/index.ts --once --json > /tmp/out.json 2>&1" Enter
+tmux -S "$SOCK" kill-server   # always clean up
+```
+
+Key testing facts:
+- tend always talks to the **default** socket via plain `tmux`; to test against
+  `-S <socket>` you must run it *inside* a pane of that server (its `$TMUX` then
+  points there).
+- The interactive dashboard reads a real PTY, so drive it with
+  `tmux send-keys -t <pane> Down` / `Enter` / `o` / `q` and read it back with
+  `tmux capture-pane -p`.
+- **Cross-window / `switch-client` tests need ≥2 real clients.** Attach them via a
+  *second* tmux server whose panes run `tmux -S <first-socket> attach -t <sess>`
+  (a plain `&`-backgrounded `attach` won't get a sized PTY on macOS).
+- `capture-pane -p` strips color; assert on glyphs/text, use `--debug` or logic
+  for color/state.
+
+## Conventions
+
+- TypeScript with `erasableSyntaxOnly` + `verbatimModuleSyntax` — no enums,
+  no namespaces, no param-properties; `import type` for types; **import with the
+  `.ts` extension** (`./tmux.ts`). Target/module per `tsconfig.json` (NodeNext).
+- Comments explain the *why* (especially the invariants above), not the *what*.
+- Keep the CLI's snapshot path (`--once`/`--json`/piped) side-effect-free and
+  exiting; only the dashboard holds the terminal.
+
+## License
+
+`tend` is MIT — see `LICENSE`. All the code here is original; keep it that way.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sandro Padin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# tend
+
+Status of the AI coding agents running inside your **tmux** session — at a glance.
+
+`tend` scans your tmux panes, figures out which ones are AI agents (Claude
+Code, Codex, …), and reports whether each is **blocked** (waiting on you),
+**working**, or **idle** — plus the git branch state of each pane's directory.
+
+It's small and focused: it does **not** multiplex, split panes, manage windows,
+or persist sessions — tmux already does all of that. It answers one question:
+*what are my agents doing right now?*
+
+A state glyph carries each agent's state — shape *and* color, so it reads even
+without color: **`●` red = blocked**, **`⠧` yellow (animated spinner) = working**,
+**`○` green = idle**, `◌` grey = unknown.
+
+```
+▸ api  (1)
+  ● %1    claude    feature/x ↑2 ✱
+▸ web  (2)
+  ⠧ %5    claude    main
+  ○ %0    codex     main ✱
+3 agent(s) across 2 session(s) — 1 blocked, 1 working, 1 idle
+```
+
+## Install
+
+`tend` needs **tmux** and **Node ≥ 20**. Install it from npm:
+
+```sh
+npm install -g @spadin/tend    # global — puts `tend` on your PATH
+# or run it without installing:
+npx @spadin/tend
+```
+
+**From source** (to hack on it) — Node ≥ 22.18 runs the TypeScript directly, no
+build step:
+
+```sh
+git clone https://github.com/spadin/tend.git && cd tend
+npm install          # dev-only deps (types); the tool itself is stdlib-only
+node src/index.ts    # run it, or `npm link` to put `tend` on your PATH
+```
+
+## Usage
+
+By default it scans **every tmux session** and groups agents by session:
+
+```sh
+tend                 # live, selectable dashboard (default in a terminal)
+tend --once          # print a grouped snapshot and exit
+tend jump %3         # jump straight to a pane id
+tend jump %3 --to T  # open pane %3 in another window (client tty T)
+tend clients         # list attached tmux clients (terminal windows)
+tend --json          # machine-readable snapshot (for status bars, scripts)
+tend --current       # limit to the current session only
+tend --readonly      # dashboard without selection (display-only pane)
+tend --debug %3      # dump what each region extractor sees, for rule tuning
+```
+
+Bare `tend` opens the dashboard when run in a terminal, but **falls back to a
+one-off snapshot when its output is piped or redirected** — so `tend | grep`
+and `tend > file` still behave like a snapshot. `--json` and `--once` always
+snapshot.
+
+Options: `--interval <ms>` (dashboard refresh, default 800), `--once-delay <ms>`
+(snapshot activity-sampling window, default 350).
+
+### The dashboard
+
+`tend` (or `tend watch`) is a live, grouped list of every agent across every
+session — and it's **selectable**, so it doubles as a navigator: monitor and
+jump in one surface.
+
+```
+tend  ↑/↓ move · enter jump · o target · r refresh · q quit
+opens in: this window
+
+▸ alpha  (1)
+❯ ⠹ %1    claude    main ✱
+▸ beta  (2)  · 1 blocked
+  ● %2    claude    main ✱
+  ○ %3    claude    main ✱
+```
+
+The glyph shape + color carries the state (`●` red blocked, `⠹` yellow working —
+an animated spinner, `○` green idle), so you never need the word.
+
+- **↑/↓** (or `j`/`k`) move the cursor over agents, **Enter** jumps to that pane,
+  **r** refreshes, **q**/**Esc**/**Ctrl-C** quits. It re-scans on an interval so
+  states stay current.
+- **Jumping keeps the dashboard alive.** Inside tmux, Enter `switch-client`s your
+  attached client to the agent's pane but leaves the monitor running in its own
+  pane — a persistent surface you can switch back to, not a one-shot chooser.
+  (Outside tmux, jumping means `tmux attach`, which takes over the terminal, so
+  there it exits when you detach.)
+- `--readonly` (or piping the output) gives the old non-interactive repaint, for
+  a display-only status pane.
+- `tend jump %3` jumps non-interactively — handy to bind to a tmux key.
+
+### Opening agents in another window
+
+Run the dashboard in one terminal window and keep a second window for actually
+working — then open blocked agents *over there* while the dashboard stays put.
+This works because tmux is client-server: each terminal window that attaches is a
+separate **client**, and tend can move a specific one.
+
+> **The second window must be an attached tmux client on the same server.** In
+> that other terminal, run `tmux attach` (or `tmux new -s scratch`). A plain
+> shell that isn't running tmux — or one attached to a different socket
+> (`tmux -L`/`-S …`) — is not a client and won't appear as a target. Check with
+> `tend clients`: if it lists only one line, `o` has nowhere to go.
+
+- In the dashboard, press **`o`** to cycle where Enter opens the agent: **this
+  window → each other attached client → back**. The header shows the current
+  target (`opens in: ttys023 · scratch`). Pick a blocked agent, hit Enter, and it
+  opens in that other window while the dashboard never moves.
+- `tend clients` lists the attached windows (their ttys and current sessions),
+  marking the current one.
+- Preset the target instead of cycling: `--other` (the one other attached client)
+  or `--to <tty>` (a specific one). Works for both the dashboard and
+  `tend jump %3 --to /dev/ttys023`.
+
+So the setup you'd use: `tend` in window A (your monitor), a plain shell or
+scratch tmux session in window B. Watch A, press `o` once to aim at B, and every
+Enter sends the selected agent to B.
+
+### tmux status-bar integration
+
+```tmux
+set -g status-right "#(cd #{pane_current_path} && tend --json | jq -r '...')"
+```
+
+Or bind a key to a quick popup:
+
+```tmux
+bind-key g display-popup -E "tend; read"
+```
+
+## How it works
+
+Two signals, arbitrated:
+
+1. **Which agent is in a pane** — tmux's `#{pane_current_command}` gives the
+   foreground process name. Note Claude Code renames its process to its **version
+   string**
+   (e.g. `2.1.200`), so we match a semver `commandPattern`, not the literal
+   name. This is the most reliable signal because it's present no matter what's
+   scrolled into view. If the command is generic (`node`), we fall back to a
+   **screen signature** — persistent footer chrome (`shift+tab to cycle`,
+   `esc to interrupt`), not the welcome banner, which scrolls away.
+
+2. **What state it's in** — we `capture-pane` the rendered screen and run
+   declarative **manifest rules** (see [`src/manifests.ts`](src/manifests.ts))
+   against slices of it. Highest-priority matching rule wins.
+
+Arbitration (in [`src/detect.ts`](src/detect.ts)):
+
+- **blocked** comes from the screen and is *strong* — it wins immediately. It's
+  deliberately strict (only a positive match of a known approval UI) so you
+  don't get false "needs you" alarms; everything unmatched falls back to idle.
+- **working** comes from **activity** — the pane's content changed since the
+  last look (we diff `capture-pane` snapshots). A visible "esc to interrupt"
+  hint is a secondary signal.
+- **idle** is debounced: it must persist across two reads, so a single quiet
+  frame mid-task doesn't flap the status.
+- Scrollback / model-picker / transcript screens are recognized and **hold** the
+  previous state instead of authoring a bogus one.
+
+Git facts come from shelling out to the real `git` binary (no libgit2), memoized
+per repo root within each scan so N panes in one repo cost one set of calls.
+
+## Tuning the rules
+
+The detection is **data, not code**. Each
+rule is `{ id, state, priority, region, contains?, anyContains?, regex?, not? }`.
+When an agent's TUI changes, or you add a new agent, edit
+[`src/manifests.ts`](src/manifests.ts) — no engine changes needed.
+
+Workflow: run `tend --debug <pane>` against a live agent pane. It prints the
+text each region extractor (`full`, `after_last_horizontal_rule`,
+`prompt_box_body`, `bottom_non_empty_lines`) pulls out, and marks which rules
+match. Adjust patterns until the ✓ marks line up with reality.
+
+The shipped Claude/Codex rules are a **starting point** — TUIs vary by version,
+so expect to tune them against your own agents.
+
+## Layout
+
+| File | Role |
+|------|------|
+| `src/types.ts` | Data model (states, rules, manifests) |
+| `src/regions.ts` | Region extractors — pure string slicers |
+| `src/manifests.ts` | **The rules you tune** — per-agent detection patterns |
+| `src/tmux.ts` | tmux glue (`list-panes`, `capture-pane`, switch/select) |
+| `src/git.ts` | Git status via the `git` binary, cached per repo |
+| `src/detect.ts` | The engine: identify agent + arbitrate state |
+| `src/scan.ts` | One detection pass over all panes (shared by all modes) |
+| `src/nav.ts` | Jump to a pane (switch-client inside tmux / attach outside) |
+| `src/render.ts` | Grouped / JSON output |
+| `src/pick.ts` | Interactive selectable dashboard (raw-mode TUI) |
+| `src/index.ts` | CLI (once / watch / jump / debug) |
+
+## License
+
+MIT — see [LICENSE](LICENSE). All original code; use it however you like.

package/dist/detect.js

@@ -0,0 +1,123 @@
+// The detection engine: identify the agent in a pane, then resolve its state by
+// arbitrating three signals:
+//   1. blocked/idle come from the screen (manifest rules),
+//   2. working comes from PTY activity (content changed since last tick),
+//   3. skipStateUpdate screens (scrollback/menus) hold the previous state.
+// Blocked is strong and wins; otherwise activity beats a stale idle read; idle
+// is debounced so a quiet frame mid-task doesn't flap the status.
+import { extractRegion } from "./regions.js";
+import { manifestFor, MANIFESTS } from "./manifests.js";
+export function identifyAgent(pane, captureText) {
+    const cmd = pane.command.toLowerCase();
+    // 1. Exact / substring command-name match (e.g. comm is literally "claude").
+    for (const m of MANIFESTS) {
+        if (m.match.some((name) => cmd === name || cmd.includes(name)))
+            return m.agent;
+    }
+    // 2. Command-pattern match — catches Claude Code, whose comm is its version
+    //    string (e.g. "2.1.200"). Most reliable: independent of screen scroll.
+    for (const m of MANIFESTS) {
+        if (m.commandPattern && new RegExp(m.commandPattern).test(pane.command)) {
+            return m.agent;
+        }
+    }
+    // 3. Screen signature — for agents launched under a generic comm (node/python)
+    //    whose version-rename doesn't apply. Matches persistent on-screen chrome.
+    const hay = captureText.toLowerCase();
+    for (const m of MANIFESTS) {
+        if (m.signature.some((sig) => hay.includes(sig.toLowerCase())))
+            return m.agent;
+    }
+    return null;
+}
+function ruleMatches(rule, regionText) {
+    const hay = regionText.toLowerCase();
+    if (rule.contains && !rule.contains.every((s) => hay.includes(s.toLowerCase()))) {
+        return false;
+    }
+    if (rule.anyContains && !rule.anyContains.some((s) => hay.includes(s.toLowerCase()))) {
+        return false;
+    }
+    if (rule.not && rule.not.some((s) => hay.includes(s.toLowerCase()))) {
+        return false;
+    }
+    if (rule.regex) {
+        const re = new RegExp(rule.regex, "im");
+        if (!re.test(regionText))
+            return false;
+    }
+    return true;
+}
+// Evaluate the manifest against captured lines; highest-priority match wins.
+function evaluateRules(manifest, lines) {
+    const sorted = [...manifest.rules].sort((a, b) => b.priority - a.priority);
+    for (const rule of sorted) {
+        const regionText = extractRegion(lines, rule.region);
+        if (ruleMatches(rule, regionText)) {
+            return { state: rule.state, ruleId: rule.id, hold: rule.skipStateUpdate === true };
+        }
+    }
+    return { state: "unknown", ruleId: null, hold: false };
+}
+function hashLines(lines) {
+    // Cheap content fingerprint — we only need "did it change", not crypto.
+    let h = 0;
+    const s = lines.join("\n");
+    for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+    }
+    return `${s.length}:${h}`;
+}
+export function resolveState(pane, lines, prev) {
+    const captureText = lines.join("\n");
+    const agent = identifyAgent(pane, captureText);
+    if (agent === null)
+        return null;
+    const manifest = manifestFor(agent);
+    const verdict = manifest
+        ? evaluateRules(manifest, lines)
+        : { state: "unknown", ruleId: null, hold: false };
+    const hash = hashLines(lines);
+    const changed = prev !== undefined && prev.lastCaptureHash !== hash;
+    const previousState = prev?.lastState ?? "unknown";
+    let state;
+    let pendingIdle = false;
+    // "blocked" must be earned by an active match every scan — never inherited.
+    // Holding it (on scrollback or an ambiguous frame) is exactly what keeps a
+    // stale "1 blocked" on the board after you've answered the prompt.
+    const keep = (prevState) => prevState === "unknown" || prevState === "blocked" ? "idle" : prevState;
+    if (verdict.hold) {
+        // Scrollback / menu screen: don't author state, keep what we had.
+        state = keep(previousState);
+    }
+    else if (verdict.state === "blocked") {
+        state = "blocked"; // strong signal, wins immediately
+    }
+    else if (changed) {
+        state = "working"; // PTY activity is the authority for "working"
+    }
+    else if (verdict.state === "working") {
+        state = "working"; // explicit interrupt-hint on screen
+    }
+    else if (verdict.state === "idle") {
+        // Debounce: require idle to persist for two reads before committing, so a
+        // single quiet frame between output bursts doesn't flip us to idle.
+        if (previousState === "working" && prev?.pendingIdle !== true) {
+            state = "working";
+            pendingIdle = true;
+        }
+        else {
+            state = "idle";
+        }
+    }
+    else {
+        // Known agent, nothing matched: fall back without inheriting a stale block.
+        state = keep(previousState);
+    }
+    return {
+        agent,
+        state,
+        matchedRule: verdict.ruleId,
+        memory: { lastCaptureHash: hash, lastState: state, pendingIdle },
+    };
+}

package/dist/git.js

@@ -0,0 +1,57 @@
+// Git status by shelling out to the real `git` binary (no libgit2 dependency).
+// Cheap enough for a handful of panes; results are memoized per repo root within
+// a single tick so N panes in one repo cost one set of calls.
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+async function git(cwd, args) {
+    try {
+        const { stdout } = await exec("git", ["-C", cwd, ...args], {
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function repoRoot(cwd) {
+    return git(cwd, ["rev-parse", "--show-toplevel"]);
+}
+async function computeStatus(cwd) {
+    const branch = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (branch === null)
+        return null; // not a git repo
+    const porcelain = await git(cwd, ["status", "--porcelain"]);
+    const dirty = porcelain !== null && porcelain.length > 0;
+    let ahead = 0;
+    let behind = 0;
+    const counts = await git(cwd, [
+        "rev-list",
+        "--left-right",
+        "--count",
+        "HEAD...@{upstream}",
+    ]);
+    if (counts) {
+        const [a, b] = counts.split(/\s+/);
+        ahead = Number(a) || 0;
+        behind = Number(b) || 0;
+    }
+    return { branch: branch === "HEAD" ? null : branch, dirty, ahead, behind };
+}
+// Per-tick cache keyed by repo root, so panes sharing a repo share the answer.
+export function createGitCache() {
+    const byRoot = new Map();
+    return async function statusFor(cwd) {
+        const root = await repoRoot(cwd);
+        if (root === null)
+            return null;
+        let pending = byRoot.get(root);
+        if (!pending) {
+            // Compute from the repo root so all panes agree regardless of subdir.
+            pending = computeStatus(root);
+            byRoot.set(root, pending);
+        }
+        return pending;
+    };
+}