@vincemakes/kiso-tui 0.46.2 → 0.47.1

package/dist/at-picker.js

@@ -13,7 +13,10 @@
  * on the machine's locale).
  */
 import { escapeTerminal, palette } from "./lines.js";
-import { selectionBar, visibleWidth, widthCut } from "./components.js";
+import { atEmbed, bandKeyRow, bandVisible, bandWindow, goldHits, moreMark, selectionBar, visibleWidth, widthCut } from "./components.js";
+// Graphite P3: the band helpers and the matcher moved to tui-cells, where
+// the pick panels draw too; re-exported so every import site stays as it was
+export { atEmbed, bandKeyRow, bandVisible, bandWindow, moreMark };
 import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
 /**
  * KC3 §5 — the ONE cap. The file list is computed per open with no
@@ -39,53 +42,6 @@ export const AT_SKIP = new Set([".git", "node_modules", "dist", "build", "covera
 /** KC3 §4 — the panel's visible height. A ceiling, not a promise: the
  *  compositor clamps further when the terminal is short. */
 export const AT_VISIBLE = 5;
-/**
- * The subsequence embedding, TIGHTENED — the two-pass walk every good
- * fuzzy finder uses, and the reason `@ra` emboldens the "ra" of
- * "src/range.js" rather than the r of "src" and the a of "range".
- *
- * Pass 1 walks forward and stops at the EARLIEST index that completes
- * the query — this both answers "does it match at all" and fixes the
- * right-hand edge. Pass 2 walks backward from that edge, taking the
- * LATEST position for each query character in turn, which slides every
- * matched character as far right as it can go without crossing the
- * next one. The result is the most clustered embedding that ends where
- * the earliest match ends.
- *
- * Case-insensitive: both sides are lowercased by the caller once per
- * query rather than once per character.
- *
- * Returns the ascending match indices, or null when the query is not a
- * subsequence of the path at all.
- */
-export function atEmbed(lowerPath, lowerQuery) {
-    if (lowerQuery === "")
-        return [];
-    // pass 1 — forward, to the earliest completing index
-    let qi = 0;
-    let end = -1;
-    for (let pi = 0; pi < lowerPath.length; pi += 1) {
-        if (lowerPath[pi] === lowerQuery[qi]) {
-            qi += 1;
-            if (qi === lowerQuery.length) {
-                end = pi;
-                break;
-            }
-        }
-    }
-    if (end === -1)
-        return null; // not a subsequence — no embedding exists
-    // pass 2 — backward from that edge, sliding each character right
-    const hit = new Array(lowerQuery.length);
-    let pi = end;
-    for (let j = lowerQuery.length - 1; j >= 0; j -= 1) {
-        while (lowerPath[pi] !== lowerQuery[j])
-            pi -= 1;
-        hit[j] = pi;
-        pi -= 1;
-    }
-    return hit;
-}
 /** The longest run of CONSECUTIVE indices in an ascending list. An
  *  empty query has no run — every path ties on it, and the rank falls
  *  through to path length. */
@@ -140,117 +96,70 @@ export function atFilter(items, query) {
     });
     return { matches, capped };
 }
-/**
- * KC3 §4 — the picker's WINDOW: which slice of the ranked list is on
- * screen. The window TRAILS the selection exactly as the composer's
- * own viewport trails the cursor (KC1 §5) — derived per read, never
- * stored, so it can never disagree with the selection it is meant to
- * follow.
- */
-export function atWindow(total, selected, visible = AT_VISIBLE) {
-    const count = Math.min(total, visible);
-    const first = Math.max(0, Math.min(selected - count + 1, total - count));
-    return { first, count };
-}
 /** The path split into the two columns the panel draws: the file's own
  *  name, and the directory that qualifies it. A path with no slash is
  *  all name and no directory. */
+/** The cells a file's NAME takes in its row — the measure the band's name
+ *  column is laid over (escaped as the row draws it, so the column a
+ *  wide or control-character name asks for is the one it gets). */
+export function atNameWidth(path) {
+    return visibleWidth(splitPath(escapeTerminal(path)).name);
+}
 function splitPath(path) {
     const cut = path.lastIndexOf("/");
     return cut === -1 ? { dir: "", name: path } : { dir: path.slice(0, cut + 1), name: path.slice(cut + 1) };
 }
 /**
- * KC3 §4 — ONE row of the panel.
- *
- * Two columns: the file's NAME on the left with its matched characters
- * bold, and the DIRECTORY dim on the right, pushed to the far edge.
- * The name is what the user is aiming at; the directory is what tells
- * two same-named files apart, which is why it is present but quiet.
+ * KC3 §4, Graphite P2 (owner, 2026-10-03) — ONE row of the panel: the
+ * file's NAME, padded to the name column, then its FOLDER as a dim column,
+ * so the folders line up. The letters the query matched are gold in both.
  *
- * The selected row carries `→` on the inverse band (SGR 7, closed with
- * 27 — never SGR 0, so it composes inside the row's own spans).
+ * DECLARED REVERSAL of TUI2-R1.5 ⑧ (VD-9) in two parts: the folder no
+ * longer trails each name after an em dash — it is a column one gap after
+ * the longest name in the list (never the far edge, which was VD-9's
+ * complaint), so twenty rows read as a table; and a match inside the
+ * folder is drawn, gold, because the person typed it.
  *
- * The `hit` indices are over the FULL path, so they are shifted by the
- * directory's length to land on the name. A hit that falls INSIDE the
- * directory is simply not drawn bold — the directory column is
- * uniformly dim by design (a bold fragment in a right-aligned dim
- * column reads as damage, not as information).
- *
- * The row never exceeds W: the name cuts first (it is the flexible
- * column), and the directory is dropped entirely before the name is
- * cut to nothing.
+ * The name is the flexible column when the row is short: the folder gives
+ * way first, then the name is cut with an ellipsis.
  */
-export function atRow(match, selected, W) {
+export function atRow(match, selected, W, nameCol = 0, mark = null) {
     const p = palette();
     const { dir, name } = splitPath(escapeTerminal(match.path));
-    // the name's own matched positions, mapped out of the full path
-    const marks = new Set(match.hit.filter((i) => i >= dir.length).map((i) => i - dir.length));
-    // TUI2-R1.5 ⑧ (VD-9): the directory rides NEXT TO the name it
-    // qualifies. It used to be right-aligned to the band's far edge, which
-    // on a 100-column terminal put `src/` some eighty columns from the
-    // `parser.ts` it belongs to: the eye had to cross the whole row to
-    // learn which parser.ts this was, and the column read as a second list.
-    // Adjacent and dim, it is what it always meant to be — a qualifier.
-    // the name is the flexible column and the qualifier gives way first: a
-    // narrow window keeps the thing being aimed at.
-    const room = Math.max(1, W - 2);
-    const suffix = dir === "" ? "" : widthCut(`  — ${dir}`, Math.max(0, room - 4));
-    const nameRoom = Math.max(1, room - visibleWidth(suffix));
-    const shownName = widthCut(name, nameRoom);
-    let painted = "";
-    for (let i = 0; i < shownName.length; i += 1) {
-        painted += marks.has(i) ? `${p.bold}${shownName[i]}${p.reset}` : shownName[i];
-    }
-    const text = `${painted}${suffix === "" ? "" : `${p.dim}${suffix}${p.reset}`}`;
-    const width = visibleWidth(shownName) + visibleWidth(suffix);
-    if (!selected)
-        return `  ${text}`;
-    // TUI2-R1.5 ⑧ (VD-9): the selection is a FULL-ROW bar — the W16 chip
-    // mechanism, which the user chip and the turn fold already use. A
-    // two-cell `→ ` marker on the inverse band is one character of
-    // highlight in an eighty-column row, and the walkthrough could barely
-    // find it. The bar spans the row's whole width so the selection is
-    // visible from anywhere on the line. Mono discipline: reverse video,
-    // no new colours.
-    //
-    // R2: the composition is selectionBar's — one copy, and with it the
-    // §2.1 rule that dim never sits on the wash (the directory column was
-    // rendering grey-on-grey inside the bar, i.e. the half of the row the
-    // selection was meant to help you read).
-    return selectionBar(`${painted}${suffix === "" ? "" : `${p.dim}${suffix}${p.reset}`}`, width, W);
-}
-/**
- * KC3 §4 — the counter row: `(n/total)`, where n is the 1-based
- * position of the SELECTION in the whole ranked list, not in the
- * visible window. The user needs to know where they are in the list,
- * which the five visible rows cannot tell them.
- *
- * When the source list was truncated the row SAYS SO. A file picker
- * that quietly lists 2,000 of 40,000 files and shows a confident
- * "(3/1998)" is lying by omission; this one admits the horizon.
- */
-export function atCounterRow(selected, total, capped, W) {
-    const p = palette();
-    const text = capped ? `  (${selected + 1}/${total}) · first ${AT_CAP} files only` : `  (${selected + 1}/${total})`;
-    return `${p.dim}${widthCut(text, W)}${p.reset}`;
+    const nameHits = new Set(match.hit.filter((i) => i >= dir.length).map((i) => i - dir.length));
+    const dirHits = new Set(match.hit.filter((i) => i < dir.length));
+    const room = Math.max(1, W - 3); // the two-cell lead and one cell of margin
+    const col = Math.min(Math.max(nameCol, visibleWidth(name)), room);
+    const shownName = visibleWidth(name) <= col ? name : col <= 1 ? widthCut(name, col) : `${widthCut(name, col - 1)}…`;
+    const dirRoom = room - col - 2;
+    const shownDir = dir === "" || dirRoom < 4 ? "" : visibleWidth(dir) <= dirRoom ? dir : `${widthCut(dir, dirRoom - 1)}…`;
+    const pad = shownDir === "" ? "" : " ".repeat(col - visibleWidth(shownName) + 2);
+    const text = `${goldHits(shownName, nameHits, selected ? p.bold : "")}${pad}${shownDir === "" ? "" : goldHits(shownDir, dirHits, p.dim)}`;
+    const width = visibleWidth(shownName) + pad.length + visibleWidth(shownDir);
+    if (selected)
+        return selectionBar(` ${text}`, width + 1, W);
+    return mark === null ? `  ${text}` : `${p.dim}${mark}${p.reset} ${text}`;
 }
 /**
- * KC3 §4 — the whole band: at most AT_VISIBLE windowed rows, then the
+ * KC3 §4, Graphite P2 — the whole band: the named hairline with the count
+ * (`files · 8`, `2 of 8 match`, and `first 2000 only` when the walk was
+ * cut), the windowed rows with their more-marks, and the key row with the
  * counter. Returned as plain strings for the menu-rows channel, which
- * already accounts them in chromeRows — the picker needs no geometry
- * of its own, which is the entire reason it rides that channel.
+ * already accounts them in chromeRows — the picker needs no geometry of
+ * its own, which is the entire reason it rides that channel.
  */
-export function atPanelRows(state, W) {
-    const { first, count } = atWindow(state.matches.length, state.selected);
-    // TUI2-R1.5 ⑦(b) (VD-8): the band NAMES itself. It renders frameless
-    // directly above the composer, so with scrollback behind it there was
-    // nothing to say where the surface began — the rows read as more
-    // history. One dim row is enough to make it UI. Mono discipline: dim
-    // text, no rule, no colour.
-    const rows = [bandHeader("files", W)];
+export function atPanelRows(state, W, height = 24) {
+    const total = state.total ?? state.matches.length;
+    const query = state.query ?? "";
+    const facts = `${query === "" ? `${total}` : `${state.matches.length} of ${total} match`}${state.capped ? ` · first ${AT_CAP} only` : ""}`;
+    // TUI2-R1.5 ⑦(b) (VD-8): the band NAMES itself — with scrollback behind
+    // it, nothing else says where the surface begins
+    const rows = [bandHeader(`files · ${facts}`, W)];
+    const { first, count } = bandWindow(state.matches.length, state.selected, bandVisible(height));
+    const nameCol = state.nameCol ?? 0;
     for (let i = first; i < first + count; i += 1)
-        rows.push(atRow(state.matches[i], i === state.selected, W));
-    rows.push(atCounterRow(state.selected, state.matches.length, state.capped, W));
+        rows.push(atRow(state.matches[i], i === state.selected, W, nameCol, moreMark(i, first, count, state.matches.length)));
+    rows.push(bandKeyRow(["↑↓ move", "tab inserts", "esc"], state.selected, state.matches.length, W));
     return rows;
 }
 /**

package/dist/compositor.d.ts

@@ -55,11 +55,15 @@ export interface AtPanelState {
     readonly selected: number;
     readonly capped: boolean;
 }
+import { type NoticeMark, type RecallSection } from "./components.js";
 import { type BannerMeta, type ResumeMeta } from "./lines.js";
+import { type BarInput } from "./status.js";
 /** The cursor marker — an APC private sequence the focus component
  *  embeds at the edit position; the compositor strips it and moves
  *  relatively (it never reaches the terminal). */
 export declare const CURSOR_MARKER = "\u001B_[kiso-cur]\u001B\\";
+/** R8 — the command band's window: five rows plus a counter, the same
+ *  budget the composer's own ceiling can afford above it. */
 /** KC1 §5 — the input row's bound state. The legacy pair stays
  *  REQUIRED and keeps its exact meaning (the cursor line's visible
  *  slice and its display column), so a one-row provider — the old
@@ -160,6 +164,38 @@ export declare class Body {
      */
     fold(label: string, replay: () => void, summary?: string | null): void;
     notice(text: string): void;
+    /** The tasks round (owner, 2026-10-06) — a notice whose terminal form
+     *  is one meta row per thing it names (a task's end, a project's trust):
+     *  each row a label (`TASK` once, `""` under it), the sentence cut to one
+     *  row, its outcome word marked. A pipe keeps `text`, byte for byte. */
+    metaNotice(text: string, rows: readonly {
+        readonly label: string;
+        readonly sentence: string;
+        readonly mark?: NoticeMark;
+    }[]): void;
+    /** The last sweep (owner, 2026-10-06) — what `/think` or `/last` brings
+     *  back: on the terminal ONE cell, a meta row (`label`, `sentence`) and
+     *  the sections under it; a pipe keeps `text`, byte for byte. */
+    recall(text: string, label: string, sentence: string, sections: readonly RecallSection[]): void;
+    /** Graphite R3e (owner, 2026-09-29) — a mode switch: on the terminal
+     *  `MODE` on a row of its own and `from → to` under it, the new tier
+     *  bold (full access — the old bypass — in the failure colour, plan in
+     *  blue) — no explanation:
+     *  the picker that switched it says what each tier does. A pipe keeps
+     *  the confirmation it always printed, byte for byte (`text`). */
+    modeNotice(text: string, from: string, to: string): void;
+    /** The main-sync round (owner, 2026-09-30) — the don't-ask switch, the
+     *  MODE row's sibling: `DON'T ASK` gold (the person's choice) and
+     *  `off → on` with the new state bold. It is a switch on top of the tier,
+     *  not a tier, so it has a row of its own. A pipe keeps #203's words
+     *  (`don't ask → on`), byte for byte. */
+    dontAskNotice(text: string, on: boolean): void;
+    /**
+     * Graphite §7.11 — the turn's SEAL. On the terminal a cell of its own,
+     * drawn at the current width (widest tier that fits); a pipe gets
+     * `pipe` — today's recap line — byte for byte.
+     */
+    seal(tiers: readonly string[], pipe: string): void;
     /** The startup banner (W1): a LIVE cell — the tier re-derives per
      *  frame (bannerLines with the CURRENT W and H), so a resize re-tiers
      *  the art instead of re-folding frozen rows (a window below 40 cols
@@ -169,6 +205,9 @@ export declare class Body {
      *  the pipe contract). */
     banner(version: string, extensionsText: string, resume?: ResumeMeta[], meta?: BannerMeta | undefined): void;
     raw(lines: string[], wrap?: "words"): void;
+    /** G3 (R2d) — the person's `!!cmd`: run, shown here, never sent. Off a
+     *  dock the command and its output are written as they always were. */
+    bang(command: string, output: string, isError: boolean): void;
     /** The last COMPLETE thinking block, for /think. */
     lastThinking(): string | null;
     /** The last completed tool call, for /last. */
@@ -266,10 +305,18 @@ export declare class Body {
      * which time the first frame is already painted with the no-ground
      * palette. Rather than delay the opening to wait for an answer that
      * may never come, the frame is painted at once and repainted when the
-     * answer lands. Invalidating the held screen is exactly what a resize
-     * does, for exactly the same reason — every row's bytes are wrong —
-     * so it rides the settle the resize already owns and costs one
-     * repaint, once per session.
+     * answer lands.
+     *
+     * It is NOT a resize, and must not ride one: the settle returns early
+     * when the geometry did not change — which it never does here — so the
+     * old path cleared the held screen and painted nothing, leaving the
+     * no-ground palette up until the first keystroke. Nor is it a reprint:
+     * `3J` would erase the shell's scrollback at every launch, since the
+     * answer arrives at every launch. So: the committed cells' cached rows
+     * are dropped (their bytes carry the old palette; their geometry does
+     * not change, the palette sets no width), the held screen is voided,
+     * and one frame repaints what is on screen. Rows already in the
+     * terminal's scrollback keep the palette they were written in.
      */
     onGroundChange(): void;
     /**
@@ -325,6 +372,15 @@ export declare class Body {
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */
     setStatus(text: string, hint?: string | null): void;
+    /** Graphite §8.9 — hand the status bar its facts. */
+    setBar(bar: BarInput | null): void;
+    /** Graphite §8.7 — the live row (already composed for the width the
+     *  caller measured; cut here if the terminal narrowed since), or null
+     *  when nothing is live. */
+    setLive(row: string | null): void;
+    /** A confirmation that is true for a moment — `copied 212 chars` — on the
+     *  live row, until the next keypress. It never displaces a live row. */
+    flash(text: string): void;
     setTail(tail: string): void;
     /** Bind the editor's panel state — the PanelSelect slot occupant
      *  (W21: the panel replaces the live region + the input lead while
@@ -335,10 +391,13 @@ export declare class Body {
     /** Bind the editor's slash-command menu state — the MenuSelect slot
      *  occupant (the menu replaces the editor's view while open). */
     /** TUI2-R1 (D): bind the editor's keys-sheet flag. */
-    bindSheet(state: () => boolean): void;
+    bindSheet(state: () => boolean | ((W: number) => string[])): void;
     bindMenu(state: () => {
         items: readonly MenuItem[];
         selected: number;
+        total?: number;
+        query?: string;
+        nameCol?: number;
     } | null): void;
     /** KC3 §4: bind the editor's @ file picker. It shares the menu's
      *  band — see #menuRows for why that is a decision and not a
@@ -348,8 +407,9 @@ export declare class Body {
      *  occupant (see #menuRows for why they share one). */
     bindPick(state: () => SessionPickState | null): void;
     /** Bind the pending-turn queue — the CLI's live slots (chat.ts):
-     *  the chips render in the menu-rows family, the live caps shrink
-     *  by their rows, and the +N queued hint rides the status row. */
+     *  the queued rows render in the menu-rows family and the live caps
+     *  shrink by their rows (Graphite §8.7). The status bar does not
+     *  count them; without a bar the status row's hint still does. */
     bindQueue(state: () => readonly string[]): void;
     /** The input line's edit column — the old dock's API. v6: the CURSOR
      *  derives from the frame's marker; this is the same value computed
@@ -405,6 +465,12 @@ export declare class Dock {
         size: number;
     } | null;
     setStatus(text: string, hint?: string | null): void;
+    /** Graphite §8.9 — the status bar's facts. */
+    setBar(bar: BarInput | null): void;
+    /** Graphite §8.7 — the live row, or null. */
+    setLive(row: string | null): void;
+    /** A short confirmation on the live row, gone at the next keypress. */
+    flash(text: string): void;
     setTail(tail: string): void;
     /** W21: bind the editor's panel state — the PanelSelect slot
      *  occupant (the panel replaces the live region + the input lead
@@ -412,7 +478,7 @@ export declare class Dock {
     bindApproval(state: () => PanelState | null): void;
     /** TUI2-R1 (D): bind the editor's keys-sheet flag — the slot read for
      *  the ? overlay (the menu/picker binding pattern). */
-    bindSheet(state: () => boolean): void;
+    bindSheet(state: () => boolean | ((W: number) => string[])): void;
     /** R5 — the transcript viewer's three doors, forwarded to the live
      *  compositor. Unlike the other bindings there is no buffer: the
      *  viewer cannot be open before a compositor exists, so a call with
@@ -424,6 +490,9 @@ export declare class Dock {
     bindMenu(state: () => {
         items: readonly MenuItem[];
         selected: number;
+        total?: number;
+        query?: string;
+        nameCol?: number;
     } | null): void;
     /** KC3 §4: bind the editor's @ picker — the SAME band as the slash
      *  menu (see Body#menuRows). Unbound, the picker cannot render, and
@@ -433,8 +502,8 @@ export declare class Dock {
      *  occupant. Unbound (every path but bare `kiso resume`), the picker
      *  cannot render and every frame is byte-identical to before. */
     bindPick(state: () => SessionPickState | null): void;
-    /** W22: bind the pending-turn queue — the chips + the +N queued
-     *  hint (the CLI binds it from chat(); the editor's pop keys ride
+    /** W22: bind the pending-turn queue — the queued rows (the CLI
+     *  binds it from chat(); the editor's pop keys ride
      *  the LineInput's own bindQueue). */
     bindQueue(state: () => readonly string[]): void;
     editCol(): number;