@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/layout/wrap-rows.js

@@ -1,88 +0,0 @@
-import { graphemes, graphemeWidth } from '../editor-navigation.js';
-/**
- * `wrapToRows` — the prose wrapper for `OverlayFrame`'s controlled (mode A)
- * content (plan-mode §6.6).
- *
- * Mode A's contract is *one element per row, each already `wrap="truncate"`*,
- * and `sliceWindow` counts ELEMENTS, not lines. Help and Settings satisfy that
- * naturally because their content is a list of short rows. A plan is not: its
- * summary runs to 600 characters and a step detail to 400, so handing either
- * over as a single `<Text>` renders the whole paragraph as one truncated line —
- * the single worst failure available to a plan review card, and one that also
- * makes the frame's `1-14/22` position indicator a false statement.
- *
- * The repo had no wrapper before this (no `wrapText`, no `wordWrap`), so here is
- * one: pure, no Ink, unit-tested.
- */
-/**
- * Break `text` into lines of at most `width` columns.
- *
- * Prefers spaces; hard-breaks any single token longer than `width` (a URL or a
- * long path, which must not be dropped and cannot be wrapped politely).
- * Width is measured in terminal cells and hard breaks preserve graphemes. A
- * single grapheme wider than the limit stays intact on its own row.
- * Existing newlines are honoured as paragraph breaks. Returns `[]` for empty
- * input so callers can splice the result without an emptiness branch.
- */
-export function wrapToRows(text, width) {
-    if (typeof text !== 'string' || text.length === 0)
-        return [];
-    const limit = Math.max(1, Math.floor(width));
-    const rows = [];
-    for (const paragraph of text.split('\n')) {
-        if (paragraph.trim().length === 0) {
-            // A blank line in the source is a deliberate separator; keep it as a row
-            // rather than collapsing it, or the summary and the steps run together.
-            rows.push('');
-            continue;
-        }
-        rows.push(...wrapParagraph(paragraph, limit));
-    }
-    return rows;
-}
-function wrapParagraph(paragraph, limit) {
-    const rows = [];
-    let current = '';
-    let currentWidth = 0;
-    for (const word of paragraph.split(/\s+/).filter((w) => w.length > 0)) {
-        const parts = graphemes(word);
-        const wordWidth = parts.reduce((sum, part) => sum + graphemeWidth(part.text), 0);
-        if (wordWidth > limit) {
-            // Flush what we have, then chop the over-long token into full-width
-            // pieces. Its tail becomes the new `current` so the next word can still
-            // join it.
-            if (current.length > 0) {
-                rows.push(current);
-                current = '';
-                currentWidth = 0;
-            }
-            for (const part of parts) {
-                const cells = graphemeWidth(part.text);
-                if (current && currentWidth + cells > limit) {
-                    rows.push(current);
-                    current = '';
-                    currentWidth = 0;
-                }
-                current += part.text;
-                currentWidth += cells;
-            }
-            continue;
-        }
-        if (current.length === 0) {
-            current = word;
-            currentWidth = wordWidth;
-        }
-        else if (currentWidth + 1 + wordWidth <= limit) {
-            current = `${current} ${word}`;
-            currentWidth += 1 + wordWidth;
-        }
-        else {
-            rows.push(current);
-            current = word;
-            currentWidth = wordWidth;
-        }
-    }
-    if (current.length > 0)
-        rows.push(current);
-    return rows;
-}

package/dist/ui/live-clamp.d.ts

@@ -1,14 +0,0 @@
-/** Keep the newest thinking lines visible while an assistant entry streams. */
-export interface LiveClamp {
-    text: string;
-    /** Rows dropped off the FRONT. `0` means the text was returned untouched. */
-    hiddenRows: number;
-}
-/**
- * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
- *
- * Rows, not wrapped display lines: this runs per frame on a streaming entry, and
- * a wrap-aware count would need the column width and a second full scan of a
- * string this function exists to avoid scanning twice.
- */
-export declare function clampLiveText(text: string, maxRows: number): LiveClamp;

package/dist/ui/live-clamp.js

@@ -1,46 +0,0 @@
-/** Keep the newest thinking lines visible while an assistant entry streams. */
-/**
- * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
- *
- * Rows, not wrapped display lines: this runs per frame on a streaming entry, and
- * a wrap-aware count would need the column width and a second full scan of a
- * string this function exists to avoid scanning twice.
- */
-export function clampLiveText(text, maxRows) {
-    if (!Number.isFinite(maxRows) || maxRows <= 0)
-        return { text: '', hiddenRows: rowCount(text) };
-    const keep = Math.floor(maxRows);
-    // Cheap reject: a string with fewer than `keep` newlines cannot have more than
-    // `keep` rows, and this is the path every ordinary entry takes.
-    let newlines = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10)
-            newlines += 1;
-    }
-    if (newlines + 1 <= keep)
-        return { text, hiddenRows: 0 };
-    // Walk back from the end to the `keep`-th newline rather than splitting the
-    // whole string: the point of the clamp is to stop touching the head at all.
-    let cut = text.length;
-    let seen = 0;
-    for (let i = text.length - 1; i >= 0; i -= 1) {
-        if (text.charCodeAt(i) === 10) {
-            seen += 1;
-            if (seen === keep) {
-                cut = i + 1;
-                break;
-            }
-        }
-    }
-    return { text: text.slice(cut), hiddenRows: newlines + 1 - keep };
-}
-function rowCount(text) {
-    if (text.length === 0)
-        return 0;
-    let n = 1;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10)
-            n += 1;
-    }
-    return n;
-}

package/dist/ui/markdown-blocks.d.ts

@@ -1,107 +0,0 @@
-/**
- * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * 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.
- */
-/** Heading levels are rendered with three distinct weights, not one (§4.7). */
-export interface HeadingBlock {
-    kind: 'heading';
-    level: 1 | 2 | 3 | 4 | 5 | 6;
-    text: string;
-}
-export interface RuleBlock {
-    kind: 'rule';
-}
-/** Column alignment carried by a table's `|---|:--:|` divider row. */
-export type Align = 'left' | 'right' | 'center';
-export interface TableBlock {
-    kind: 'table';
-    /** Already column-aligned; render as plain monospace rows. */
-    rows: string[][];
-    align: Align[];
-}
-export declare function parseHeading(line: string): HeadingBlock | null;
-export declare function isRule(line: string): boolean;
-/** Split one `| a | b |` row into trimmed cells. Returns null if not a row. */
-export declare function parseTableRow(line: string): string[] | null;
-/** Is this the `|---|:--:|` divider that makes the preceding row a header? */
-export declare function isTableDivider(line: string): boolean;
-export declare function tableAlignments(dividerLine: string): TableBlock['align'];
-/**
- * How the table is drawn. Both characters are injected by the renderer from
- * `pickGlyphs(caps)` because this file is inside the ASCII-only scan
- * (`glyphs.test.ts::inScope`): a Unicode box-drawing literal here would fail
- * that guard.
- */
-export interface TableFormatOptions {
-    /** Drawn between cells; `Markdown.tsx` passes `glyphs.railVertical`. */
-    separator?: string;
-    /** Repeated to a column's padded width; `Markdown.tsx` passes `glyphs.hrule`. */
-    rule?: string;
-}
-/**
- * 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 declare function formatTable(rows: string[][], align: TableBlock['align'], options?: TableFormatOptions): string[];
-/**
- * One parsed top-level block.
- *
- * `line` is deliberately UNPARSED: heading / rule / quote / bullet detection is
- * a handful of regexes over one short string and is done at render time, where
- * the theme and the glyph set live. Caching a themed element instead would make
- * `/theme` a no-op until the cache evicted (K-5).
- */
-export type MdBlock = {
-    kind: 'code';
-    code: string;
-    lang: string;
-} | {
-    kind: 'table';
-    rows: string[][];
-    align: Align[];
-} | {
-    kind: 'line';
-    text: string;
-};
-/** Split a document into fenced code, pipe tables, and everything else. */
-export declare function parseMarkdownBlocks(text: string): MdBlock[];
-export type InlineSpan = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'code';
-    text: string;
-} | {
-    kind: 'bold';
-    text: string;
-} | {
-    kind: 'italic';
-    text: string;
-} | {
-    kind: 'strike';
-    text: string;
-};
-/**
- * Two passes, and that ordering is the fix (§4.7).
- *
- * The old single regex alternated `code | bold | italic` at the same level, so
- * `**bold with `code` inside**` matched neither branch cleanly and rendered as
- * literal asterisks. Splitting code out FIRST — and never looking for emphasis
- * inside a code span — resolves both cases: emphasis around code now works, and
- * asterisks inside code stay literal, which is what a shell snippet needs.
- */
-export declare function parseInline(text: string): InlineSpan[];

package/dist/ui/markdown-blocks.js

@@ -1,240 +0,0 @@
-/**
- * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * 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,})$/;
-const TABLE_ROW_RE = /^\s*\|(.+)\|\s*$/;
-const TABLE_DIVIDER_CELL_RE = /^:?-{1,}:?$/;
-export function parseHeading(line) {
-    const m = HEADING_RE.exec(line);
-    if (!m)
-        return null;
-    return { kind: 'heading', level: m[1].length, text: m[2] ?? '' };
-}
-export function isRule(line) {
-    return RULE_RE.test(line.trim());
-}
-/** Split one `| a | b |` row into trimmed cells. Returns null if not a row. */
-export function parseTableRow(line) {
-    const m = TABLE_ROW_RE.exec(line);
-    if (!m)
-        return null;
-    return m[1].split('|').map((c) => c.trim());
-}
-/** Is this the `|---|:--:|` divider that makes the preceding row a header? */
-export function isTableDivider(line) {
-    const cells = parseTableRow(line);
-    if (!cells || cells.length === 0)
-        return false;
-    return cells.every((c) => TABLE_DIVIDER_CELL_RE.test(c));
-}
-export function tableAlignments(dividerLine) {
-    const cells = parseTableRow(dividerLine) ?? [];
-    return cells.map((c) => {
-        const left = c.startsWith(':');
-        const right = c.endsWith(':');
-        if (left && right)
-            return 'center';
-        if (right)
-            return 'right';
-        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 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, 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) => displayColumns(r[c] ?? '')), 0);
-    }
-    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 };
-        }
-        body.push(lines[i] ?? '');
-        i += 1;
-    }
-    return { code: body.join('\n'), next: i };
-}
-/** Split a document into fenced code, pipe tables, and everything else. */
-export function parseMarkdownBlocks(text) {
-    // 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 = parseFenceOpen(line.trim());
-        if (fence) {
-            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.
-        const headerCells = parseTableRow(line);
-        if (headerCells && i + 1 < lines.length && isTableDivider(lines[i + 1] ?? '')) {
-            const align = tableAlignments(lines[i + 1] ?? '');
-            const rows = [headerCells];
-            i += 2;
-            while (i < lines.length) {
-                const cells = parseTableRow(lines[i] ?? '');
-                if (!cells)
-                    break;
-                rows.push(cells);
-                i += 1;
-            }
-            blocks.push({ kind: 'table', rows, align });
-            continue;
-        }
-        blocks.push({ kind: 'line', text: line });
-        i += 1;
-    }
-    return blocks;
-}
-const CODE_RE = /`[^`]+`/g;
-const EMPHASIS_RE = /(\*\*[^*]+\*\*|~~[^~]+~~|\*[^*]+\*)/g;
-/**
- * Two passes, and that ordering is the fix (§4.7).
- *
- * The old single regex alternated `code | bold | italic` at the same level, so
- * `**bold with `code` inside**` matched neither branch cleanly and rendered as
- * literal asterisks. Splitting code out FIRST — and never looking for emphasis
- * inside a code span — resolves both cases: emphasis around code now works, and
- * asterisks inside code stay literal, which is what a shell snippet needs.
- */
-export function parseInline(text) {
-    const spans = [];
-    let last = 0;
-    let m;
-    CODE_RE.lastIndex = 0;
-    while ((m = CODE_RE.exec(text)) !== null) {
-        if (m.index > last)
-            pushEmphasis(spans, text.slice(last, m.index));
-        spans.push({ kind: 'code', text: m[0].slice(1, -1) });
-        last = m.index + m[0].length;
-    }
-    if (last < text.length)
-        pushEmphasis(spans, text.slice(last));
-    return spans;
-}
-function pushEmphasis(out, text) {
-    let last = 0;
-    let m;
-    EMPHASIS_RE.lastIndex = 0;
-    while ((m = EMPHASIS_RE.exec(text)) !== null) {
-        if (m.index > last)
-            out.push({ kind: 'text', text: text.slice(last, m.index) });
-        const token = m[0];
-        if (token.startsWith('**'))
-            out.push({ kind: 'bold', text: token.slice(2, -2) });
-        else if (token.startsWith('~~'))
-            out.push({ kind: 'strike', text: token.slice(2, -2) });
-        else
-            out.push({ kind: 'italic', text: token.slice(1, -1) });
-        last = m.index + token.length;
-    }
-    if (last < text.length)
-        out.push({ kind: 'text', text: text.slice(last) });
-}

package/dist/ui/overlays/AgentsBoardOverlay.d.ts

@@ -1,57 +0,0 @@
-/**
- * AgentsBoardOverlay — the read-only detail board behind `Ctrl+B` / `/agents`
- * (tui-subagent-panel §4.4 / §6.3).
- *
- * READ-ONLY IS THE SAFETY BOUNDARY (§2.2). Nothing here nudges, kills or re-dispatches
- * a child, and no new `TeamEvent` member was introduced to feed it: a board that can
- * only read can never kill a healthy child, which is the whole reason this is a
- * second surface rather than a control panel.
- *
- * ONE SCREEN, CONTROLLED MODE. `OverlayFrame`'s controlled form already owns paging,
- * the position indicator and the narrow-terminal degradation, and `helpRows` /
- * `projectQueueRows` are the precedent. A second pane would mean a second horizontal
- * budget inside Ink for a benefit the board's 2-up field rows already deliver.
- *
- * IT DOES NOT GO BLANK WHEN THE DISPATCH ENDS (D-9). `state.team` becomes `null` the
- * frame the dispatch settles, and a reader would lose the child they were reading
- * about at the exact moment they wanted the post-mortem. The last live snapshot is
- * therefore FROZEN (a copy, held in a ref) and keeps rendering with a
- * `dispatch ended` row; a board opened AFTER the dispatch has ended builds from the
- * transcript's settled `team` entry instead (`resolveBoardSource`), which is where the
- * `result` section earns its place - the error is the one fact that is never stripped.
- *
- * NO `ink-spinner` HERE (D-13): `spinner-census.test.ts` pins the exact list of files
- * that mount an animated spinner, and this is a reading surface, not an animation.
- * The panel is where motion belongs.
- *
- * AND NO MOTION PROP (v2 implementation note, appended to the spec's
- * "implementation findings"). Because nothing here animates, a motion flag would be a
- * prop with no consumer - and worse, the same census counts how many times `App.tsx`
- * hands the RAW motion flag to a child and asserts the count is EXACTLY ONE, so passing
- * it from the board's branch would break a shipped guard rail for no gain.
- *
- * ASCII ONLY: every symbol comes through `glyphs`.
- */
-import React from 'react';
-import type { Entry } from '../../agent/reducer.js';
-import type { Theme } from '../theme.js';
-import type { TermCapabilities } from '../capabilities.js';
-import type { TeamSnapshot } from '../../team/types.js';
-export interface AgentsBoardOverlayProps {
-    /** The live snapshot; `null` once the dispatch has settled. */
-    team: TeamSnapshot | null;
-    /** The transcript, for the settled fallback (D-9 path 4). */
-    entries: readonly Entry[];
-    /** Overlay content width (`App`'s `viewCols`). */
-    cols: number;
-    maxRows: number;
-    scrollOffset: number;
-    onScrollClamp: (offset: number) => void;
-    isActive: boolean;
-    native: boolean;
-    theme: Theme;
-    caps: TermCapabilities;
-    /** Injectable clock, so the board's tests do not depend on wall time. */
-    now?: number;
-}
-export declare function AgentsBoardOverlay({ team, entries, cols, maxRows, scrollOffset, onScrollClamp, isActive, native, theme, caps, now, }: AgentsBoardOverlayProps): React.ReactElement;