@aragon-agent/cli 0.6.27 → 0.6.29

package/dist/ui/markdown-blocks.js

@@ -1,11 +1,13 @@
 /**
  * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * unit-tested without rendering anything.
+ * unit-tested without rendering anything. `string-width` is the only import and
+ * it is a pure function of its argument, so the module stays side-effect free.
  *
  * Scope is deliberately small — this is not CommonMark. It covers what a coding
  * agent's answers actually contain: fenced code, headings, lists, quotes, rules,
  * tables, and inline emphasis / code / strikethrough.
  */
+import stringWidth from 'string-width';
 const HEADING_RE = /^(#{1,6})\s+(.*)$/;
 /** `---`, `***` or `___`, three or more, nothing else on the line. */
 const RULE_RE = /^(?:-{3,}|\*{3,}|_{3,})$/;
@@ -46,53 +48,128 @@ export function tableAlignments(dividerLine) {
         return 'left';
     });
 }
+/** Default column separator: pure ASCII, so this module holds no glyph literal. */
+const DEFAULT_TABLE_SEPARATOR = '|';
+/** Default header rule: pure ASCII for the same reason. */
+const DEFAULT_TABLE_RULE = '-';
+/** One space either side of the separator, so a boundary is unmistakable. */
+const TABLE_CELL_GAP = ' ';
 /**
- * Pad a parsed table into fixed-width columns. Returns one string per row —
- * no borders, because a bordered table inside an already-indented gutter wraps
- * on any realistic terminal.
+ * Pad a parsed table into fixed-width columns and draw the header rule.
+ *
+ * Returns `[header, divider, ...bodyRows]`, one string per rendered row, so
+ * index 0 is always the header and index 1 always the divider. The divider is
+ * rendered rather than swallowed because the parser consumes the source
+ * `|---|` row to read alignment: without it, a `--no-color` terminal showed a
+ * table as unseparated prose (bold is dropped at colour level 0, and the old
+ * two-space join gave no column boundary either).
+ *
+ * Padding is by DISPLAY columns, not `String.length`: a CJK cell is one code
+ * unit but two terminal columns, so `.length` misaligned every such table.
  */
-export function formatTable(rows, align) {
+export function formatTable(rows, align, options = {}) {
+    const separator = options.separator ?? DEFAULT_TABLE_SEPARATOR;
+    const rule = options.rule ?? DEFAULT_TABLE_RULE;
     const colCount = Math.max(...rows.map((r) => r.length), 0);
     const widths = [];
     for (let c = 0; c < colCount; c += 1) {
-        widths[c] = Math.max(...rows.map((r) => (r[c] ?? '').length), 0);
+        widths[c] = Math.max(...rows.map((r) => displayColumns(r[c] ?? '')), 0);
     }
-    return rows.map((row) => row
-        .map((cell, c) => {
-        const w = widths[c] ?? 0;
-        const a = align[c] ?? 'left';
-        if (a === 'right')
-            return cell.padStart(w);
-        if (a === 'center') {
-            const total = w - cell.length;
-            const left = Math.floor(total / 2);
-            return ' '.repeat(left) + cell + ' '.repeat(total - left);
+    const gap = `${TABLE_CELL_GAP}${separator}${TABLE_CELL_GAP}`;
+    const body = rows.map((row) => padRow(row, widths, align).join(gap).trimEnd());
+    if (body.length === 0)
+        return [];
+    const divider = widths.map((w) => rule.repeat(w)).join(gap).trimEnd();
+    return [body[0], divider, ...body.slice(1)];
+}
+function padRow(row, widths, align) {
+    return row.map((cell, c) => padCell(cell, widths[c] ?? 0, align[c] ?? 'left'));
+}
+function padCell(cell, width, align) {
+    const pad = width - displayColumns(cell);
+    if (pad <= 0)
+        return cell;
+    const filler = ' '.repeat(pad);
+    if (align === 'right')
+        return filler + cell;
+    if (align === 'center') {
+        const left = Math.floor(pad / 2);
+        return `${' '.repeat(left)}${cell}${' '.repeat(pad - left)}`;
+    }
+    return cell + filler;
+}
+/**
+ * Printable ASCII with no TAB: one code unit is one cell, so the width table is
+ * not consulted at all.
+ *
+ * The same load-bearing fast path `virtual-window.displayColumns` carries, and for
+ * the same reason: `stringWidth` strips ANSI and walks the East-Asian width table
+ * per code point, while this runs once per CELL of every table row on every frame.
+ * Table cells are overwhelmingly ASCII, so the branch is taken almost always -
+ * and when it is not, the table is CJK and the table is exactly what must be used.
+ */
+const PLAIN_ASCII = /^[\x20-\x7e]*$/;
+/** Terminal columns occupied by `text` (wide glyphs count two). */
+function displayColumns(text) {
+    return PLAIN_ASCII.test(text) ? text.length : stringWidth(text);
+}
+/**
+ * An opening fence is three or more backticks plus an optional info string.
+ *
+ * The old `(\w*)` info group was too narrow for real answers: ```c++ and
+ * ```objective-c did not open a block at all, so the body degraded to prose and
+ * the closing fence was then swallowed as a new empty code block. A backtick is
+ * the one character CommonMark forbids in an info string; everything else is
+ * accepted here and the language is simply the FIRST token.
+ */
+const FENCE_OPEN_RE = /^(`{3,})[ \t]*([^`]*)$/;
+/** A closing fence carries backticks only — no info string. */
+const FENCE_CLOSE_RE = /^(`{3,})[ \t]*$/;
+function parseFenceOpen(line) {
+    const m = FENCE_OPEN_RE.exec(line);
+    if (!m)
+        return null;
+    const info = (m[2] ?? '').trim();
+    return { count: m[1].length, lang: info.split(/\s+/)[0] ?? '' };
+}
+/** Backtick count of a line that could close a fence; 0 when it could not. */
+function closingFenceLength(line) {
+    const m = FENCE_CLOSE_RE.exec(line);
+    return m ? m[1].length : 0;
+}
+/**
+ * Collect a fence body starting after the opening fence.
+ *
+ * A closer must carry AT LEAST as many backticks as its opener, so a
+ * four-backtick block may contain ``` lines — that is how a nested markdown
+ * example survives. A shorter run is content, not the end of the block.
+ */
+function readFenceBody(lines, openIndex, openCount) {
+    const body = [];
+    let i = openIndex + 1;
+    while (i < lines.length) {
+        if (closingFenceLength((lines[i] ?? '').trim()) >= openCount) {
+            return { code: body.join('\n'), next: i + 1 };
         }
-        return cell.padEnd(w);
-    })
-        .join('  ')
-        .trimEnd());
+        body.push(lines[i] ?? '');
+        i += 1;
+    }
+    return { code: body.join('\n'), next: i };
 }
-/** A fence line: ```` ```lang ```` or a bare ```` ``` ````. */
-const FENCE_RE = /^```(\w*)\s*$/;
 /** Split a document into fenced code, pipe tables, and everything else. */
 export function parseMarkdownBlocks(text) {
-    const lines = text.split('\n');
+    // CRLF-safe: a bare `split('\n')` left a '\r' on every code line, which then
+    // reached the highlighter and the display-width maths.
+    const lines = text.split(/\r?\n/);
     const blocks = [];
     let i = 0;
     while (i < lines.length) {
         const line = lines[i] ?? '';
-        const fence = FENCE_RE.exec(line.trim());
+        const fence = parseFenceOpen(line.trim());
         if (fence) {
-            const lang = fence[1] || '';
-            const codeLines = [];
-            i += 1;
-            while (i < lines.length && !FENCE_RE.test((lines[i] ?? '').trim())) {
-                codeLines.push(lines[i] ?? '');
-                i += 1;
-            }
-            i += 1; // skip the closing fence
-            blocks.push({ kind: 'code', code: codeLines.join('\n'), lang });
+            const { code, next } = readFenceBody(lines, i, fence.count);
+            blocks.push({ kind: 'code', code, lang: fence.lang });
+            i = next;
             continue;
         }
         // A pipe row followed by a divider row starts a table; consume the run.

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/dist/ui/use-wheel-routing.d.ts

@@ -22,13 +22,6 @@
 import type { Overlay } from '../agent/reducer.js';
 import type { MouseSource } from '../input/stdin-filter.js';
 import type { ScrollIntent } from './layout/scroll.js';
-/**
- * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
- * overlay. Declared here rather than in `App.tsx` because both the keyboard
- * branch and the wheel branch need it and `App` imports this module; the other
- * direction would be a cycle.
- */
-export declare const OVERLAY_PAGE = 8;
 export interface WheelRoutingOptions {
     isPointerCaptured?: () => boolean;
     isActive?: () => boolean;
@@ -39,6 +32,16 @@ export interface WheelRoutingOptions {
     onScroll: (kind: ScrollIntent, repeat: number) => void;
     /** Signed row delta; the caller clamps at 0 the way the keyboard branch does. */
     onOverlayScroll: (delta: number) => void;
+    /**
+     * Rows one Shift+wheel notch turns inside a controlled overlay (defect 11).
+     *
+     * A GETTER, read at event time for the same reason `getOverlay` is: the window
+     * height changes with the terminal, with `statusExpanded` and with the rail, and
+     * a value captured when the subscription was built is the value that goes stale.
+     * `App` answers with `overlayPageSize(...)`, the same function its keyboard
+     * branch uses, so the wheel and `PgDn` can never disagree.
+     */
+    getOverlayPage?: () => number;
 }
 export interface WheelRouting {
     /**

package/dist/ui/use-wheel-routing.js

@@ -21,12 +21,15 @@
  */
 import { useCallback, useEffect, useRef } from 'react';
 /**
- * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
- * overlay. Declared here rather than in `App.tsx` because both the keyboard
- * branch and the wheel branch need it and `App` imports this module; the other
- * direction would be a cycle.
+ * Page rows used ONLY when the host supplies no `getOverlayPage`.
+ *
+ * `App` always supplies one (defect 11): the step is the overlay's visible window
+ * minus two rows of context, so `PgDn` in `/help` turns a page instead of 42% of
+ * one. This fallback exists so a host that owns no overlay window - this module's
+ * own routing tests are the only such host - still gets a page rather than
+ * silently degrading a Shift+wheel to a three-row notch.
  */
-export const OVERLAY_PAGE = 8;
+const FALLBACK_OVERLAY_PAGE = 8;
 /** Transcript rows per notch. The terminal's own convention. */
 const CONTENT_LINES_PER_NOTCH = 3;
 /** Overlay rows per notch. Overlay content is short; a page needs Shift. */
@@ -113,7 +116,9 @@ export function useWheelRouting(options) {
             // D-3: the row is not consulted here either. Behind an overlay the
             // composer is inactive and the overlay is the only scrollable thing on
             // screen, so a notch anywhere scrolls it.
-            const step = event.shift ? OVERLAY_PAGE : OVERLAY_LINES_PER_NOTCH;
+            const step = event.shift
+                ? current.getOverlayPage?.() ?? FALLBACK_OVERLAY_PAGE
+                : OVERLAY_LINES_PER_NOTCH;
             current.onOverlayScroll(event.dir === 'up' ? -step : step);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.27",
+  "version": "0.6.29",
   "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.39",
+    "@aragon-agent/core": "^0.2.41",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",