@aragon-agent/cli 0.6.26 → 0.6.28

package/dist/ui/entries/QueuedEntry.js

@@ -13,10 +13,13 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
+import { expandTabs } from '../display-tab.js';
 function QueuedEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const lines = text.split('\n');
-    const first = lines[0] ?? '';
+    // Same reason as `UserEntry`: a queued draft is a draft, so its TABs must
+    // occupy the columns the composer showed them at.
+    const first = expandTabs(lines[0] ?? '');
     const extra = lines.length - 1;
     const suffix = extra > 0 ? ` ${glyphs.ellipsis}+${extra} line${extra === 1 ? '' : 's'}` : '';
     return (_jsx(Text, { wrap: "truncate", color: theme.muted, children: `Queue: ${first}${suffix}` }));

package/dist/ui/entries/UserEntry.js

@@ -14,9 +14,16 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+import { expandTabs } from '../display-tab.js';
 function UserEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
-    const all = text.split('\n');
+    // TAB IS EXPANDED HERE, AT THE RENDER BOUNDARY, AND NOWHERE ABOVE IT.
+    // The payload keeps its `\t` (the model must receive the original
+    // indentation), so `<Text>` used to hand the raw byte to the terminal and
+    // the terminal painted an EIGHT-column stop while the composer painted a
+    // FOUR-column one. Splitting first and expanding per line keeps this row
+    // identical to the row the user saw in the draft.
+    const all = text.split('\n').map((line) => expandTabs(line));
     // A submitted 5 000-line paste otherwise asks Yoga to lay out 5 000 nodes
     // inside a measured entry -- the hazard `render-cache.ts:37` already records
     // in the same words ("a multi-megabyte 'code block' is almost always a pasted

package/dist/ui/layout/virtual-window.js

@@ -32,9 +32,11 @@
  * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
  * through the mounted set and the measured heights back to the offset.
  */
+import stringWidth from 'string-width';
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
+import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 export const VIRTUAL_LIMITS = {
     /**
@@ -159,21 +161,52 @@ export function entryRevision(entry) {
 export function heightKey(entry, cols, expanded, density, flags = '') {
     return `${entry.id}|${entryRevision(entry)}|${cols}|${expanded ? 1 : 0}|${density}|${flags}`;
 }
-/** Rows a string occupies at `usable` columns, wrapping included. At least 1. */
+/**
+ * Rows a string occupies at `usable` columns, wrapping included. At least 1.
+ *
+ * COUNTED IN DISPLAY COLUMNS, NOT UTF-16 CODE UNITS, and the difference is a
+ * correctness bug rather than a nicety: a CJK glyph is one code unit and two
+ * cells, and a TAB is one code unit and up to `TAB_WIDTH` cells. Counting code
+ * units therefore UNDER-estimates, which this file's own note names as the
+ * unsafe direction ("an over-estimate makes the scroll position slightly
+ * conservative and self-corrects ... an under-estimate can put the newest
+ * output off the bottom of a viewport the user believes is pinned"). It also
+ * had to change together with the renderers: a stored `\t` is now expanded at
+ * paint time, so measuring the unexpanded string would keep the estimate short
+ * while the painted row got taller.
+ */
 function wrappedRows(text, usable) {
     const width = Math.max(1, usable);
     let rows = 0;
-    let lineLen = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10) {
-            rows += Math.max(1, Math.ceil(lineLen / width));
-            lineLen = 0;
-        }
-        else {
-            lineLen += 1;
-        }
+    let start = 0;
+    for (;;) {
+        const end = text.indexOf('\n', start);
+        const line = end === -1 ? text.slice(start) : text.slice(start, end);
+        rows += Math.max(1, Math.ceil(displayColumns(line) / width));
+        if (end === -1)
+            return rows;
+        start = end + 1;
     }
-    return rows + Math.max(1, Math.ceil(lineLen / width));
+}
+/**
+ * Printable ASCII with no TAB: one code unit is one cell, so the width table is
+ * not consulted at all.
+ *
+ * THE FAST PATH IS LOAD-BEARING, not a micro-optimisation. `stringWidth`
+ * strips ANSI and walks the East-Asian width table for every code point, and
+ * this function runs over EVERY unmeasured entry of a 10 000-entry document
+ * (`render-budget.test.tsx` mounts exactly that); measuring them all with the
+ * table turned that test into a timeout. Transcript text is overwhelmingly
+ * ASCII, so the branch is taken almost always.
+ */
+const PLAIN_ASCII = /^[\x20-\x7e]*$/;
+/** Display columns of one logical line: TABs expanded, CJK counted twice. */
+function displayColumns(line) {
+    if (line.indexOf('\t') === -1 && PLAIN_ASCII.test(line))
+        return line.length;
+    // `expandTabs` mirrors what `entries/*` paints; `stringWidth` is the width
+    // table the composer already wraps with, so the two agree on CJK and emoji.
+    return stringWidth(expandTabs(line));
 }
 /** Collapsed preview rows in `ToolCard`; duplicated as a NUMBER, not imported. */
 const TOOL_COLLAPSED_LINES = 8;

package/dist/ui/paste-frames.d.ts

@@ -82,6 +82,10 @@ export declare function hasPasteFrame(input: string): boolean;
  * nothing on screen to explain it.
  *
  * This is strictly better than v0.6.3 for both consumers: a pasted key carrying a
- * stray CR or an ANSI sequence is now cleaned rather than stored raw.
+ * stray CR or an ANSI sequence is now cleaned rather than stored raw. The
+ * unframed branch strips escape SEQUENCES before the control sweep, because
+ * deleting only the introducer left `[0m` in the stored value -- and in a
+ * settings field that residue is invisible behind `maskDot` while the value
+ * handed to `registerSecret()` is silently wrong.
  */
 export declare function stripPasteFrames(input: string): string;

package/dist/ui/paste-frames.js

@@ -7,6 +7,7 @@
  */
 import { PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
 import { sanitisePaste } from '../input/paste-parse.js';
+import { stripControlSequences } from '../input/control-sequences.js';
 /**
  * Remove every C0 byte, DEL and C1 byte from text that arrived OUTSIDE a frame
  * (I-14). NO CR -> LF conversion, and that omission is the point.
@@ -101,11 +102,15 @@ export function hasPasteFrame(input) {
  * nothing on screen to explain it.
  *
  * This is strictly better than v0.6.3 for both consumers: a pasted key carrying a
- * stray CR or an ANSI sequence is now cleaned rather than stored raw.
+ * stray CR or an ANSI sequence is now cleaned rather than stored raw. The
+ * unframed branch strips escape SEQUENCES before the control sweep, because
+ * deleting only the introducer left `[0m` in the stored value -- and in a
+ * settings field that residue is invisible behind `maskDot` while the value
+ * handed to `registerSecret()` is silently wrong.
  */
 export function stripPasteFrames(input) {
     if (!hasPasteFrame(input))
-        return sanitiseTyped(input);
+        return sanitiseTyped(stripControlSequences(input));
     return splitPasteFrames(input)
         .map((segment) => (segment.kind === 'paste' ? sanitiseTyped(segment.text) : segment.text))
         .join('');

package/dist/ui/transcript-text.js

@@ -1,12 +1,21 @@
 import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
+import { expandTabs } from './display-tab.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
 const MAX_ARG_CHARS = 60;
-/** Prefix the first line with `marker`, indent the rest to line up under it. */
+/**
+ * Prefix the first line with `marker`, indent the rest to line up under it.
+ *
+ * `expandTabs` RUNS BEFORE THE PREFIX IS ADDED, so a stored line lands on the
+ * same columns the TUI drew it at. Without it this replay -- the only record
+ * left once the alternate screen is torn down -- disagreed with the screen
+ * about every TAB, because the terminal painted an eight-column stop under text
+ * the composer had laid out at four.
+ */
 function block(marker, text) {
-    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const lines = expandTabs(text.replace(/\r\n/g, '\n')).split('\n');
     const head = `${marker} ${lines[0] ?? ''}`.trimEnd();
     const rest = lines.slice(1).map((l) => `${CONTINUATION_INDENT}${l}`.trimEnd());
     return [head, ...rest];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.26",
+  "version": "0.6.28",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.38",
+    "@aragon-agent/core": "^0.2.40",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",