commandmate 0.30.2 → 0.31.1

package/dist/server/src/lib/detection/sgr-background.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Background colours read off a `capture-pane -e` row (Issue #2323).
+ *
+ * ## Why this is its own module
+ *
+ * Two different questions in this repository are answered by the same walk over
+ * a captured row's SGR sequences:
+ *
+ *  - `opencode-modal-overlay.ts` (Issue #2112) asks **where the edges are** — an
+ *    opencode overlay is a rectangle whose rows switch the background on and off
+ *    at the same two columns, and the rule is about those columns;
+ *  - `ChatDialogCard.tsx` (Issue #2323) asks **which row is painted** — Command
+ *    Code's `/model` picker marks the arrow-selected row with a background and
+ *    prints no caret at all, so the card's scroll-follow has nothing else to
+ *    anchor on.
+ *
+ * #2112 wrote the walk first and kept it private. #2323 needs the identical
+ * answer to "what background is painted at column N of this row", and a second
+ * copy of an SGR state machine is exactly how the two readings would come to
+ * disagree about the same bytes while both claiming to read backgrounds — the
+ * argument `terminal-columns.ts` already makes for column counting.
+ *
+ * A leaf module by design: it imports the column rule and nothing else, so a
+ * detector, a payload builder and a client component can all share it.
+ *
+ * ## What a `null` background means
+ *
+ * The terminal default — i.e. "this row said nothing about its background",
+ * which is also what an already-stripped frame produces for every column. Every
+ * caller therefore fails OPEN on a frame captured without `-e`: it reads no
+ * rectangle and no painted row rather than inventing one. `lib/tmux/tmux.ts`
+ * always passes `-e`, and Auto-Yes's `captureAndCleanOutput` is the one path in
+ * this repository that strips first.
+ *
+ * @module lib/detection/sgr-background
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRowBackgrounds = scanRowBackgrounds;
+exports.backgroundAt = backgroundAt;
+exports.backgroundValues = backgroundValues;
+exports.dominantBackground = dominantBackground;
+const terminal_columns_1 = require("./terminal-columns");
+/**
+ * Every ANSI sequence, in the repository's own spelling.
+ *
+ * Restated from `ANSI_PATTERN` (`ansi.ts`) rather than imported because this
+ * module needs to walk the sequences IN ORDER while counting columns, and that
+ * one is a shared `g`-flagged instance whose `lastIndex` a caller must not
+ * disturb. `tests/unit/detection/sgr-background-2323.test.ts` asserts the text
+ * this scan produces is byte-identical to `stripAnsi`'s, so the restatement
+ * cannot drift silently.
+ */
+const ANSI_SEQUENCE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\[[0-9;]*m/g;
+/** An SGR sequence, with its parameters. Only these can change the background. */
+const SGR_PARAMETERS = /^(?:\x1b\[|\[)([0-9;]*)m$/;
+/**
+ * The SGR codes that introduce an EXTENDED colour and therefore swallow the
+ * parameters after them: foreground (`38`), background (`48`) and the
+ * underline colour (`58`, which tmux re-emits from terminals that set it).
+ *
+ * They are listed together because the swallowing is the point — see
+ * {@link applySgr}.
+ */
+const EXTENDED_COLOUR_CODES = new Set([38, 48, 58]);
+/**
+ * Fold one SGR sequence's parameters into the current background.
+ *
+ * Handles the three forms tmux emits: the 16-colour codes (`40`–`47`,
+ * `100`–`107`), the 256-colour and 24-bit extended forms (`48;5;n`,
+ * `48;2;r;g;b`), and the two resets (`0`, `49`). Attribute codes leave the
+ * background alone, which is what keeps a syntax-highlighted transcript row
+ * from producing dozens of spurious edges.
+ *
+ * ## Foreground parameters are consumed, not scanned (Issue #2323)
+ *
+ * A 24-bit FOREGROUND is `38;2;r;g;b`, and its channels are ordinary numbers
+ * that land in the 16-colour background ranges as often as not. Walking them as
+ * if they were codes in their own right is what #2112's private version did,
+ * and Command Code's `/model` picker is where it shows: every model row is
+ * printed `\x1b[38;2;46;189;142m`, whose green channel `46` was then read as
+ * "background 6" — so every row that is NOT selected reported itself painted.
+ * Measured on `tests/fixtures/chat-dialog-card-2254/command-code-model-1-40-1
+ * .txt`: 70 of the 1001 rows carried a background before this and 8 after, the
+ * 62 that went being the picker's unselected rows and one `38;2;76;85;106`
+ * separator. `58` (underline colour) takes the same parameter shapes and is
+ * consumed the same way.
+ *
+ * Only `48` assigns; `38` and `58` consume their parameters and move on.
+ */
+function applySgr(current, parameters) {
+    const parts = (parameters === '' ? '0' : parameters).split(';');
+    let bg = current;
+    for (let i = 0; i < parts.length; i++) {
+        const code = Number(parts[i] === '' ? '0' : parts[i]);
+        if (!Number.isFinite(code))
+            continue;
+        if (EXTENDED_COLOUR_CODES.has(code)) {
+            // `2` is r;g;b and `5` is a palette index; anything else is a bare `38` /
+            // `48` / `58` with no extended form, which sets nothing and swallows
+            // nothing.
+            const span = parts[i + 1] === '2' ? 4 : parts[i + 1] === '5' ? 2 : 0;
+            if (span > 0 && code === 48)
+                bg = parts.slice(i, i + 1 + span).join(';');
+            i += span;
+            continue;
+        }
+        if (code === 0 || code === 49) {
+            bg = null;
+        }
+        else if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107)) {
+            bg = parts[i];
+        }
+    }
+    return bg;
+}
+/** Measure one captured row: its text, its background runs and their edges. */
+function scanRowBackgrounds(line) {
+    ANSI_SEQUENCE.lastIndex = 0;
+    const segments = [];
+    let text = '';
+    let bg = null;
+    let columns = 0;
+    let segmentStart = 0;
+    let cursor = 0;
+    let match;
+    while ((match = ANSI_SEQUENCE.exec(line)) !== null) {
+        const chunk = line.slice(cursor, match.index);
+        text += chunk;
+        columns += (0, terminal_columns_1.visibleWidth)(chunk);
+        cursor = match.index + match[0].length;
+        const sgr = SGR_PARAMETERS.exec(match[0]);
+        if (sgr === null)
+            continue;
+        const next = applySgr(bg, sgr[1]);
+        if (next === bg)
+            continue;
+        if (columns > segmentStart)
+            segments.push({ bg, start: segmentStart, end: columns });
+        bg = next;
+        segmentStart = columns;
+    }
+    const tail = line.slice(cursor);
+    text += tail;
+    columns += (0, terminal_columns_1.visibleWidth)(tail);
+    if (columns > segmentStart)
+        segments.push({ bg, start: segmentStart, end: columns });
+    const edges = new Set(segments.map(segment => segment.start));
+    if (segments.length > 0)
+        edges.add(segments[segments.length - 1].end);
+    return { text, segments, edges, width: columns };
+}
+/** The background painted at one column, or `null` for the terminal default. */
+function backgroundAt(row, column) {
+    for (const segment of row.segments) {
+        if (segment.start <= column && column < segment.end)
+            return segment.bg;
+    }
+    return null;
+}
+/**
+ * Every background value the row paints, ignoring how much of it each covers.
+ *
+ * The companion to {@link dominantBackground}: one says what a row is mostly
+ * painted in, the other says what it is painted in AT ALL. A caller separating
+ * a highlighted row from the panel it sits in needs both — the panel's colour
+ * is on the neighbouring rows somewhere, usually not as their dominant one
+ * (Command Code's boot banner is the exception that makes the rule readable:
+ * there the panel colour IS the dominant one on all seven of its rows).
+ */
+function backgroundValues(row) {
+    const values = new Set();
+    for (const segment of row.segments) {
+        if (segment.bg !== null)
+            values.add(segment.bg);
+    }
+    return values;
+}
+/**
+ * The background a row is mostly painted in, and how much of it that covers.
+ *
+ * "Mostly" rather than "entirely" because a painted row is not painted in one
+ * run: Command Code's selected `/model` row switches the FOREGROUND twice
+ * across the label and the description, which splits the background into three
+ * segments of the same value, and its trailing `✔` glyph is printed after the
+ * background is reset. Summing per value and taking the largest reads that as
+ * one painted row; taking the first or the widest single segment would read it
+ * as a third of one.
+ *
+ * Ties go to whichever value is encountered first, which is arbitrary and
+ * deliberately so — a row split evenly between two backgrounds is not a row
+ * painted in one, and every caller of this has a floor that such a row fails.
+ */
+function dominantBackground(row) {
+    const totals = new Map();
+    for (const segment of row.segments) {
+        if (segment.bg === null)
+            continue;
+        totals.set(segment.bg, (totals.get(segment.bg) ?? 0) + (segment.end - segment.start));
+    }
+    let bg = null;
+    let columns = 0;
+    for (const [value, painted] of totals) {
+        if (painted > columns) {
+            bg = value;
+            columns = painted;
+        }
+    }
+    return { bg, columns };
+}

package/dist/server/src/lib/detection/status-detector.js

@@ -54,6 +54,12 @@ exports.SELECTION_LIST_REASONS = new Set([
     // 1.18.21), so it is a `menu`, not something `respond <id> N` can answer.
     status_reason_1.STATUS_REASON.OPENCODE_PERMISSION_PROMPT,
     status_reason_1.STATUS_REASON.CLAUDE_SELECTION_LIST,
+    // Issue #2297: Command Code's picker. Its footer is a lower-case hint bar of
+    // its own (`enter to select · esc to cancel`), so it needs its own rule — and
+    // it needs to be HERE, because the alternative reading of that frame is the
+    // unclassified floor, whose controls are the answer characters and whose
+    // answer characters go into the picker's search box.
+    status_reason_1.STATUS_REASON.COMMAND_CODE_SELECTION_LIST,
     status_reason_1.STATUS_REASON.COPILOT_SELECTION_LIST,
     status_reason_1.STATUS_REASON.CODEX_SELECTION_LIST,
     // Issue #1017: Codex pager/edit-previous mode also drives NavigationButtons.

package/dist/server/src/lib/detection/status-reason.js

@@ -46,6 +46,24 @@ exports.STATUS_REASON = {
     /** Issue #1893: opencode's permission dialog — an arrow-key button strip. */
     OPENCODE_PERMISSION_PROMPT: 'opencode_permission_prompt',
     CLAUDE_SELECTION_LIST: 'claude_selection_list',
+    /**
+     * Issue #2297: Command Code's own picker (`/model`, and every overlay that
+     * shares its footer).
+     *
+     * Distinct from {@link STATUS_REASON.CLAUDE_SELECTION_LIST} even though
+     * Command Code renders claude's inline TUI, because the two footers are not
+     * the same sentence and neither pattern matches the other's screen: claude
+     * prints `Enter to set as default` / `Enter to confirm · Esc`, Command Code
+     * prints a lower-case `enter to select · esc to cancel` hint bar. Reporting
+     * the claude token for a Command Code frame would tell an operator reading
+     * `capture --json` that a rule they can go and read had fired, when it had not.
+     *
+     * Before this reason existed the picker reached the `default` floor, which is
+     * `isUnclassifiedActive` — and the chat surface answers THAT with the `1`-`9`
+     * / `y` / `n` answer keys, every one of which types into the picker's
+     * `Type to search models...` box.
+     */
+    COMMAND_CODE_SELECTION_LIST: 'command_code_selection_list',
     COPILOT_SELECTION_LIST: 'copilot_selection_list',
     CODEX_SELECTION_LIST: 'codex_selection_list',
     /** Issue #1017: Codex pager / edit-previous (transcript) mode. */

package/dist/server/src/lib/detection/tools/antigravity/detect.js

@@ -6,11 +6,13 @@
  * and 2.8) out of `detectSessionStatus`.
  *
  * No `readIdleEvidence`: agy's idle branch reads the same always-visible `> `
- * input box that #1885 showed is not evidence on its own, and this repository
- * holds no live agy capture to measure a better rule from. Per §4 D1 決定 1's
- * tool-by-tool rollout (DR2-002) a tool without a measured rule keeps the
- * pre-#1927 reading, and its rule must be read off ITS OWN frames rather than
- * inferred from another tool's — which is exactly the mistake #1979 corrected.
+ * input box that #1885 showed is not evidence on its own, and no IDLE agy frame
+ * has been captured to measure a better rule from. (Issue #2270 added live
+ * 1.1.25 captures, but only of the permission dialog and the `/model` picker —
+ * both `waiting`.) Per §4 D1 決定 1's tool-by-tool rollout (DR2-002) a tool
+ * without a measured rule keeps the pre-#1927 reading, and its rule must be read
+ * off ITS OWN frames rather than inferred from another tool's — which is exactly
+ * the mistake #1979 corrected.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.antigravityStatusDetector = exports.VERIFIED_AGAINST = void 0;
@@ -31,16 +33,37 @@ exports.antigravityStatusDetector = (0, run_detection_1.createToolStatusDetector
         // screen as "generating" and NavigationButtons would never be shown. Detecting the
         // selection list here — ahead of thinking — is the fix. Mirrors the Copilot /
         // Codex early-detection pattern.
-        if (cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN.test(frame.lastLines)) {
-            return {
-                status: 'waiting',
-                confidence: 'high',
-                reason: status_reason_1.STATUS_REASON.ANTIGRAVITY_SELECTION_LIST,
-                hasActivePrompt: false,
-                evidence: 'positive',
-            };
-        }
-        return null;
+        if (!cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN.test(frame.lastLines))
+            return null;
+        // Issue #2270: except when the frame is the NUMBERED permission dialog.
+        //
+        // #997 widened the pattern above to the bare `↑/↓ Navigate` footer so the
+        // "Do you want to proceed?" menu would reach this branch — but this branch
+        // answers `hasActivePrompt: false` and a reason in `SELECTION_LIST_REASONS`,
+        // and those two are what the chat surface turns into "a selection list is
+        // open, drive it from the terminal" plus a pair of arrow buttons. Enter on
+        // those approves the highlighted option 1; nothing on that surface could
+        // reach 2-4. Meanwhile the poller stored the SAME frame as a `prompt` row
+        // with four `multiple_choice` options and the push notification sent
+        // `kind: 'prompt'` — one screen, two answers.
+        //
+        // Returning null hands the frame to priority 1, where `detectPrompt` with
+        // `buildDetectPromptOptions('antigravity')` already reads it as that same
+        // 4-option `multiple_choice` (Issue #999). That is what puts
+        // `hasActivePrompt: true` and `promptData` on the wire, so PromptPanel and
+        // the legacy Auto-Yes path both work and all three producers agree.
+        //
+        // #995's own case is untouched: the Switch Model picker carries no numbered
+        // rows, so it still resolves here and still keeps NavigationButtons.
+        if ((0, cli_patterns_1.isAntigravityNumberedDialog)(frame.lastLines))
+            return null;
+        return {
+            status: 'waiting',
+            confidence: 'high',
+            reason: status_reason_1.STATUS_REASON.ANTIGRAVITY_SELECTION_LIST,
+            hasActivePrompt: false,
+            evidence: 'positive',
+        };
     },
     afterThinking(frame) {
         // 2.8. Antigravity (agy) footer-based detection (Issue #988)