@vincemakes/kiso-tui-cells 0.31.1 → 0.32.1

package/dist/components.d.ts

@@ -99,6 +99,7 @@ export type BodyCell = {
     text: string;
     done: boolean;
     turn: number;
+    folded?: boolean;
 } | {
     kind: "tool";
     name: string;

package/dist/components.js

@@ -30,7 +30,7 @@ import { displayWidth, visibleWidth, widthCut } from "./width.js";
 // KEY_BINDINGS). strings.js imports only render/width here, so this edge
 // adds no cycle.
 import { displayVerb } from "./strings.js";
-import { bannerLines, breathFrame, cutLine, escapeTerminal, foldThinking, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
+import { bannerLines, breathFrame, cutLine, escapeTerminal, foldThinking, foldThinkingRow, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
 // TUI2-MD: the markdown renderer's surface reaches the tui through this
 // module (the tui's components shim re-exports it) — one import edge,
 // and it points one way: md.ts measures with the width authority, never
@@ -370,6 +370,17 @@ class ThinkingBlock {
         const text = escapeTerminal(this.cell.text).trim();
         if (text === "")
             return [];
+        // §2.3 — ctrl+t folded this block. The row is the pipe's own fold,
+        // fitted: `foldThinkingRow` is the single source of the shape and
+        // with unlimited room it IS `foldThinking`, so thinking has two
+        // renderings in the product and not three. It is width-aware here
+        // because a row must measure ≤ W and the pipe's line does not —
+        // cutting it from the right would take the `/think` suffix, which
+        // is the one part of a folded block that says how to read the rest.
+        // It keeps the block's own indent, so a folded block sits in the
+        // column an unfolded one does (DC-47).
+        if (this.cell.folded)
+            return [`${THINK_COL}${foldThinkingRow(this.cell.text, Math.max(1, W - THINK_COL.length))}`];
         // DC-47 — THINKING GOES ONE LEVEL DEEPER THAN PROSE, and the
         // reason is a law rather than a taste.
         //

package/dist/render.d.ts

@@ -161,6 +161,21 @@ export declare function escapeTerminal(text: string): string;
  * strategy is presentation-independent.
  */
 export declare function foldThinking(block: string): string;
+/** §2.3 — the same fold, as a ROW that fits `room` columns.
+ *
+ *  A row must measure ≤ W (invariant ①), and the pipe's line does not:
+ *  `…` + 100 characters + " (N chars · /think)" is about 122 columns, so
+ *  on an 80-column terminal the frame's cut takes the SUFFIX — which is
+ *  the affordance, the one part of a folded block that says how to read
+ *  the rest of it. Cutting from the right removes exactly the thing the
+ *  fold exists to leave behind.
+ *
+ *  So the suffix is reserved FIRST and the head takes what is left. The
+ *  vocabulary is unchanged — the leading `…`, the character count, the
+ *  `/think` route — and with unlimited room the result is byte-for-byte
+ *  the line the pipe has always written, which is what keeps the two
+ *  renderings one shape rather than two. */
+export declare function foldThinkingRow(block: string, room: number): string;
 /** v2b — the [result] echo truncates at 160 chars + a /last hint. */
 export declare function foldResult(content: string): string;
 /**
@@ -179,6 +194,22 @@ export declare function renderToolSummary(name: string, input: Record<string, un
  *  the summary detail uses, WITHOUT the counts (the header names what
  *  was expanded, not its size). */
 export declare function toolTarget(name: string, input: Record<string, unknown>): string;
+/**
+ * HF-1 (0.32.1) — a head row is ONE row, whatever the model wrote.
+ *
+ * The owner's 0.32.0 dogfood: the model issued a heredoc shell command
+ * (`python3 - <<'EOF' …`), the running card's head carried its newlines
+ * into the compositor, invariant ①b threw in the field and the process
+ * died. `escapeTerminal` keeps `\n` on purpose (text blocks need it); a
+ * HEAD ROW does not — it is one physical row by construction. So every
+ * builder that puts a tool's target on a row projects the breaks to a
+ * visible mark first: a line break becomes `⏎` (CRLF is one), a tab
+ * becomes one cell of space (its width is a property of the column, and
+ * a cut row has no column to give it). The full command is still on the
+ * approval panel and in the durable log; the row says what ran, in one
+ * row.
+ */
+export declare function oneRow(text: string): string;
 /** k-units for the status line: 12345 → 12.3k, 800 → 800, null → ?. */
 export declare function kUnit(value: number | null): string;
 /**

package/dist/render.js

@@ -113,10 +113,34 @@ export function escapeTerminal(text) {
  * strategy is presentation-independent.
  */
 export function foldThinking(block) {
+    // the PIPE's line: no room limit, so the row path below reproduces
+    // today's bytes exactly and this stays the one source of the shape.
+    return `${foldThinkingRow(block, Number.POSITIVE_INFINITY)}\n`;
+}
+/** §2.3 — the same fold, as a ROW that fits `room` columns.
+ *
+ *  A row must measure ≤ W (invariant ①), and the pipe's line does not:
+ *  `…` + 100 characters + " (N chars · /think)" is about 122 columns, so
+ *  on an 80-column terminal the frame's cut takes the SUFFIX — which is
+ *  the affordance, the one part of a folded block that says how to read
+ *  the rest of it. Cutting from the right removes exactly the thing the
+ *  fold exists to leave behind.
+ *
+ *  So the suffix is reserved FIRST and the head takes what is left. The
+ *  vocabulary is unchanged — the leading `…`, the character count, the
+ *  `/think` route — and with unlimited room the result is byte-for-byte
+ *  the line the pipe has always written, which is what keeps the two
+ *  renderings one shape rather than two. */
+export function foldThinkingRow(block, room) {
     const p = palette();
     const trimmed = escapeTerminal(block.trim());
     const truncated = trimmed.length > 100;
-    return `${p.dim}…${trimmed.slice(0, 100)}${truncated ? ` (${block.length} chars · /think)` : ""}${p.reset}\n`;
+    const suffix = truncated ? ` (${block.length} chars · /think)` : "";
+    const head = Number.isFinite(room)
+        ? // the leading … costs one column, the suffix costs its own width
+            widthCut(trimmed.slice(0, 100), Math.max(1, room - 1 - displayWidth(suffix)))
+        : trimmed.slice(0, 100);
+    return `${p.dim}…${head}${suffix}${p.reset}`;
 }
 /** v2b — the [result] echo truncates at 160 chars + a /last hint. */
 export function foldResult(content) {
@@ -143,7 +167,7 @@ export function renderToolSummary(name, input, result, reason = null) {
     }
     const mark = result.isError ? `${p.red}✗${p.reset}` : `${p.bold}✓${p.reset}`;
     const shortName = name.replace("_file", "");
-    const detail = toolSummaryDetail(name, input, result);
+    const detail = oneRow(toolSummaryDetail(name, input, result)); // HF-1: one row, whatever the command
     return `${mark} ${escapeTerminal(`${shortName} ${detail}`)}`;
 }
 function toolSummaryDetail(name, input, result) {
@@ -189,6 +213,27 @@ function toolSummaryDetail(name, input, result) {
  *  the summary detail uses, WITHOUT the counts (the header names what
  *  was expanded, not its size). */
 export function toolTarget(name, input) {
+    return oneRow(toolTargetRaw(name, input));
+}
+/**
+ * HF-1 (0.32.1) — a head row is ONE row, whatever the model wrote.
+ *
+ * The owner's 0.32.0 dogfood: the model issued a heredoc shell command
+ * (`python3 - <<'EOF' …`), the running card's head carried its newlines
+ * into the compositor, invariant ①b threw in the field and the process
+ * died. `escapeTerminal` keeps `\n` on purpose (text blocks need it); a
+ * HEAD ROW does not — it is one physical row by construction. So every
+ * builder that puts a tool's target on a row projects the breaks to a
+ * visible mark first: a line break becomes `⏎` (CRLF is one), a tab
+ * becomes one cell of space (its width is a property of the column, and
+ * a cut row has no column to give it). The full command is still on the
+ * approval panel and in the durable log; the row says what ran, in one
+ * row.
+ */
+export function oneRow(text) {
+    return text.replace(/\r\n|\n|\r/g, "\u23ce").replace(/\t/g, " ");
+}
+function toolTargetRaw(name, input) {
     switch (name) {
         case "read_file":
         case "write_file":

package/dist/strings.js

@@ -440,6 +440,21 @@ export function helpRows() {
         ["/compact", "summarize the older conversation to free context"],
         ["/clear", "start a fresh conversation (the old session stays resumable)"],
         ["/resume", "switch to another session; /resume <id> goes directly"],
+        // §2.5: the conversation is untouched — this rereads what kiso was
+        // built with, not what it has said.
+        ["/reload", "reread extensions, skills and config into this session"],
+        // §2.2: the two shell gestures and their one escape. They sit
+        // beside the slash commands because that is what a reader is
+        // looking for when they look here, even though `!` is not one.
+        // §2.3: the switch belongs beside ctrl+o's job, and a gesture the
+        // sheet does not name is a gesture nobody uses (DC-30, DC-36).
+        ["ctrl+t", "fold the thinking blocks, and fold them back"],
+        // §2.4: the composer, in your own editor. It names the variables
+        // because that is what a reader has to set for it to work.
+        ["ctrl+g", "edit the composer in $VISUAL or $EDITOR — the text comes back unsent"],
+        ["!<cmd>", "run a shell command and send it with its output as your turn"],
+        ["!!<cmd>", "run one and show it here only — the model never sees it"],
+        ["\\!", "send a line that really starts with ! (the only escape)"],
         ["exit", "leave the session"],
         // TUI2-R1 (D): the SENTENCE is deliberately unchanged. Deriving it
         // from KEY_BINDINGS would be an improvement and it would also move

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.31.1",
+	"version": "0.32.1",
 	"description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",