@aragon-agent/cli 0.4.3

package/dist/ui/Header.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Header (spec §4.2) — the always-present brand bar.
+ *
+ * In full-screen this is EXACTLY ONE ROW at every size, which is what makes the
+ * viewport height monotonic in `rows` and the first submit jump-free. The 6-row
+ * wordmark it used to host now lives in `SessionOpener`, inside the viewport.
+ *
+ * `banner` survives for the inline path only (`App.tsx` picks it with a local
+ * ternary and never calls `pickHeaderVariant`), so inline keeps its v0.3.0
+ * geometry. `art` is no longer reachable from here.
+ *
+ * Every line is `wrap="truncate"`: a long cwd silently costing a second row
+ * would push the bottom chrome off-frame and break R2.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import { type HeaderVariant } from './Logo.js';
+interface HeaderProps {
+    version: string;
+    cwd: string;
+    provider: string;
+    model: string;
+    hasKey: boolean;
+    variant: HeaderVariant;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function Header({ version, cwd, provider, model, hasKey, variant, theme, caps, }: HeaderProps): React.ReactElement;
+export {};

package/dist/ui/Header.js

@@ -0,0 +1,25 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { homedir } from 'node:os';
+import { basename } from 'node:path';
+import { Box, Text } from 'ink';
+import { Logo } from './Logo.js';
+/** Collapse the home directory to `~` for a shorter path display. */
+function tildeCwd(cwd) {
+    const home = homedir();
+    if (home && cwd.startsWith(home))
+        return `~${cwd.slice(home.length)}`;
+    return cwd;
+}
+function KeyDot({ hasKey, theme }) {
+    return (_jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: [hasKey ? theme.symbols.keyOn : theme.symbols.keyOff, " ", hasKey ? 'key set' : 'no key'] }));
+}
+export function Header({ version, cwd, provider, model, hasKey, variant, theme, caps, }) {
+    if (variant === 'mini') {
+        return (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: _jsx(Text, { wrap: "truncate", children: _jsx(Logo, { variant: "mini", theme: theme, caps: caps }) }) }));
+    }
+    if (variant === 'bar') {
+        return (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: "bar", theme: theme, caps: caps }), _jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] }) }));
+    }
+    // `banner` (inline only): wordmark row + meta row.
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Logo, { variant: variant, theme: theme, caps: caps }), _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.muted, children: ["v", version] }), _jsxs(Text, { color: theme.accent, children: ['   ', provider, ":", model] }), _jsx(Text, { children: '   ' }), _jsx(KeyDot, { hasKey: hasKey, theme: theme }), _jsxs(Text, { color: theme.muted, children: ['   ', tildeCwd(cwd)] })] })] }));
+}

package/dist/ui/Logo.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Brand wordmark (spec §5.1 / R1). The first row of the frame always starts
+ * with a brand glyph, at every terminal size and every capability tier.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+/** 6 rows × 52 columns, every row equal width (pinned by logo.test.ts). */
+export declare const LOGO_ART: readonly string[];
+export declare const LOGO_ART_WIDTH = 52;
+export type HeaderVariant = 'art' | 'banner' | 'bar' | 'mini';
+/** How the one-off opening wordmark renders inside the viewport (§4.2). */
+export type OpenerVariant = 'art' | 'banner' | 'none';
+/**
+ * Pick the header tier (spec §4.2).
+ *
+ * `cols` is the only input, and that is the point. The old signature also took
+ * `empty` and `rows` and could return `art`, so the brand region was 8 rows tall
+ * on an empty session and 1 row afterwards: sending the first message made the
+ * viewport jump by 7 rows, and widening a 27-row terminal to 28 rows made the
+ * visible content SHRINK. A constant-height brand bar removes both, which is
+ * what lets `budget.ts::viewportRows` be monotonic (A-3/A-4/A-9).
+ *
+ * The wordmark did not disappear — it moved into the viewport as
+ * `SessionOpener`, where it scrolls away like any other content.
+ *
+ * NOTE: `Header` still renders `banner`; the inline path picks it directly at
+ * `App.tsx` and does not call this function.
+ */
+export declare function pickHeaderVariant(cols: number): HeaderVariant;
+/**
+ * Pick the opening wordmark tier.
+ *
+ * Judged against VIEWPORT rows rather than terminal rows because the wordmark
+ * now spends the viewport's budget, not the frame's: the test has to be against
+ * the account being charged.
+ *
+ * No hand-drawn ASCII fallback for `art`: figlet-style art is hard to keep
+ * column-aligned, and a terminal without Unicode should not be paying six rows
+ * for a wordmark in the first place. `banner` still carries the brand there, and
+ * the always-present header bar carries it even at `none` (R1).
+ */
+export declare function pickOpenerVariant(viewportRows: number, cols: number, caps: TermCapabilities): OpenerVariant;
+export interface LogoProps {
+    /** `art` / `banner` come from `SessionOpener`; `bar` / `mini` from `Header`. */
+    variant: HeaderVariant | OpenerVariant;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function Logo({ variant, theme, caps }: LogoProps): React.ReactElement | null;

package/dist/ui/Logo.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { gradientLine } from './gradient.js';
+/** 6 rows × 52 columns, every row equal width (pinned by logo.test.ts). */
+export const LOGO_ART = [
+    ' █████╗ ██████╗  █████╗  ██████╗  ██████╗ ███╗   ██╗',
+    '██╔══██╗██╔══██╗██╔══██╗██╔════╝ ██╔═══██╗████╗  ██║',
+    '███████║██████╔╝███████║██║  ███╗██║   ██║██╔██╗ ██║',
+    '██╔══██║██╔══██╗██╔══██║██║   ██║██║   ██║██║╚██╗██║',
+    '██║  ██║██║  ██║██║  ██║╚██████╔╝╚██████╔╝██║ ╚████║',
+    '╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝',
+];
+export const LOGO_ART_WIDTH = 52;
+/** Minimum viewport rows / cols each tier needs before it earns its budget. */
+const ART_MIN_VIEWPORT_ROWS = 14;
+/**
+ * 4 columns of headroom on purpose: the art renders with `wrap="truncate"`, so
+ * at zero headroom anything upstream claiming a single column silently shears
+ * the right edge off the `N`. Between `LOGO_ART_WIDTH` and this threshold the
+ * opener degrades to `banner`, which is the intended fallback (rename C2).
+ */
+const ART_MIN_COLS = LOGO_ART_WIDTH + 4;
+const BANNER_MIN_COLS = 48;
+const BAR_MIN_COLS = 40;
+/**
+ * Pick the header tier (spec §4.2).
+ *
+ * `cols` is the only input, and that is the point. The old signature also took
+ * `empty` and `rows` and could return `art`, so the brand region was 8 rows tall
+ * on an empty session and 1 row afterwards: sending the first message made the
+ * viewport jump by 7 rows, and widening a 27-row terminal to 28 rows made the
+ * visible content SHRINK. A constant-height brand bar removes both, which is
+ * what lets `budget.ts::viewportRows` be monotonic (A-3/A-4/A-9).
+ *
+ * The wordmark did not disappear — it moved into the viewport as
+ * `SessionOpener`, where it scrolls away like any other content.
+ *
+ * NOTE: `Header` still renders `banner`; the inline path picks it directly at
+ * `App.tsx` and does not call this function.
+ */
+export function pickHeaderVariant(cols) {
+    return cols >= BAR_MIN_COLS ? 'bar' : 'mini';
+}
+/**
+ * Pick the opening wordmark tier.
+ *
+ * Judged against VIEWPORT rows rather than terminal rows because the wordmark
+ * now spends the viewport's budget, not the frame's: the test has to be against
+ * the account being charged.
+ *
+ * No hand-drawn ASCII fallback for `art`: figlet-style art is hard to keep
+ * column-aligned, and a terminal without Unicode should not be paying six rows
+ * for a wordmark in the first place. `banner` still carries the brand there, and
+ * the always-present header bar carries it even at `none` (R1).
+ */
+export function pickOpenerVariant(viewportRows, cols, caps) {
+    if (viewportRows >= ART_MIN_VIEWPORT_ROWS &&
+        cols >= ART_MIN_COLS &&
+        caps.unicode &&
+        caps.colorLevel >= 2) {
+        return 'art';
+    }
+    if (cols >= BANNER_MIN_COLS)
+        return 'banner';
+    return 'none';
+}
+/** Rotate the gradient stops by one per row so the block reads as a diagonal sheen. */
+function shiftStops(stops, row) {
+    if (stops.length === 0)
+        return stops;
+    const at = row % stops.length;
+    return [...stops.slice(at), ...stops.slice(0, at)];
+}
+export function Logo({ variant, theme, caps }) {
+    const wordmark = `${theme.symbols.wordmark} AragonAgent`;
+    if (variant === 'none')
+        return null;
+    if (variant === 'art') {
+        return (_jsx(_Fragment, { children: LOGO_ART.map((line, i) => (_jsx(Text, { wrap: "truncate", color: theme.gradient.length > 0 ? undefined : theme.logoShadow, children: gradientLine(line, shiftStops(theme.gradient, i), caps.colorLevel) }, i))) }));
+    }
+    if (variant === 'banner') {
+        return (_jsx(Text, { wrap: "truncate", bold: true, color: theme.gradient.length > 0 ? undefined : theme.primary, children: gradientLine(wordmark, theme.gradient, caps.colorLevel) }));
+    }
+    return (_jsx(Text, { bold: true, color: theme.primary, children: wordmark }));
+}

package/dist/ui/Markdown.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lightweight markdown renderer for Ink (spec §4 / §4.7).
+ *
+ * Supports: fenced code blocks (syntax-highlighted via cli-highlight, on a left
+ * rail with a language tag), six DISTINCT heading weights, horizontal rules,
+ * unordered/ordered lists, blockquotes, pipe tables, and inline **bold** /
+ * *italic* / `code` / ~~strike~~. Anything else renders as plain text. Still
+ * intentionally small — not a CommonMark implementation.
+ *
+ * The grammar lives in `markdown-blocks.ts`; this file only renders.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+interface MarkdownProps {
+    text: string;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function Markdown({ text, theme, caps }: MarkdownProps): React.ReactElement;
+/** Turn parsed inline spans into Ink `<Text>` nodes. */
+export declare function renderInline(text: string, theme: Theme): React.ReactNode;
+export {};

package/dist/ui/Markdown.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { highlight } from 'cli-highlight';
+import { pickGlyphs } from './glyphs.js';
+import { railBorderProps } from './layout/Gutter.js';
+import { formatTable, isRule, isTableDivider, parseHeading, parseInline, parseTableRow, tableAlignments, } from './markdown-blocks.js';
+const FENCE = /^```(\w*)\s*$/;
+/** Width of the `---` rule. Fixed so it cannot force a wrap on narrow frames. */
+const RULE_WIDTH = 24;
+export function Markdown({ text, theme, caps }) {
+    const glyphs = pickGlyphs(caps);
+    const lines = text.split('\n');
+    const blocks = [];
+    let i = 0;
+    let key = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        const fence = FENCE.exec(line.trim());
+        if (fence) {
+            const lang = fence[1] || '';
+            const codeLines = [];
+            i += 1;
+            while (i < lines.length && !FENCE.test((lines[i] ?? '').trim())) {
+                codeLines.push(lines[i] ?? '');
+                i += 1;
+            }
+            i += 1; // skip closing fence
+            blocks.push(_jsx(CodeBlock, { code: codeLines.join('\n'), lang: lang, theme: theme, glyphs: glyphs }, `b${key++}`));
+            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;
+            }
+            const formatted = formatTable(rows, align);
+            blocks.push(_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: r === 0 ? theme.accent : undefined, children: row }, r))) }, `b${key++}`));
+            continue;
+        }
+        blocks.push(_jsx(InlineLine, { line: line, theme: theme, glyphs: glyphs }, `b${key++}`));
+        i += 1;
+    }
+    return _jsx(Box, { flexDirection: "column", children: blocks });
+}
+/**
+ * Fenced code. The round border is gone (§4.3): nested inside a tool card it
+ * produced a box inside a box and squeezed an 80-column terminal down to 74
+ * usable columns. A left rail plus the language tag conveys the same "this is
+ * code" boundary for 1 column and 0 rows.
+ */
+function CodeBlock({ code, lang, theme, glyphs, }) {
+    let rendered = code;
+    try {
+        rendered = highlight(code, { language: lang || undefined, ignoreIllegals: true });
+    }
+    catch {
+        rendered = code;
+    }
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [lang.length > 0 && (_jsx(Text, { color: theme.chip.fg, backgroundColor: theme.chip.bg, children: ` ${lang} ` })), _jsx(Text, { children: rendered })] }));
+}
+/** Six heading levels used to render identically; now they carry three weights. */
+function headingStyle(level, theme) {
+    if (level <= 2)
+        return { color: theme.primary };
+    if (level === 3)
+        return { color: theme.accent };
+    return { color: theme.assistant };
+}
+function InlineLine({ line, theme, glyphs, }) {
+    const heading = parseHeading(line);
+    if (heading) {
+        const style = headingStyle(heading.level, theme);
+        if (heading.level === 1) {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: style.color, children: heading.text }), _jsx(Text, { color: theme.border, children: glyphs.hrule.repeat(RULE_WIDTH) })] }));
+        }
+        return (_jsx(Text, { bold: true, color: style.color, children: heading.text }));
+    }
+    if (isRule(line)) {
+        return _jsx(Text, { color: theme.border, children: glyphs.hrule.repeat(RULE_WIDTH) });
+    }
+    const quote = /^>\s?(.*)$/.exec(line);
+    if (quote) {
+        return (_jsxs(Text, { color: theme.muted, italic: true, children: [glyphs.railVertical, " ", renderInline(quote[1] ?? '', theme)] }));
+    }
+    const bullet = /^(\s*)([-*+])\s+(.*)$/.exec(line);
+    if (bullet) {
+        return (_jsxs(Text, { children: [bullet[1], _jsxs(Text, { color: theme.accent, children: [glyphs.bullet, " "] }), renderInline(bullet[3] ?? '', theme)] }));
+    }
+    const ordered = /^(\s*)(\d+)\.\s+(.*)$/.exec(line);
+    if (ordered) {
+        return (_jsxs(Text, { children: [ordered[1], _jsxs(Text, { color: theme.accent, children: [ordered[2], ". "] }), renderInline(ordered[3] ?? '', theme)] }));
+    }
+    return _jsx(Text, { children: renderInline(line, theme) });
+}
+/** Turn parsed inline spans into Ink `<Text>` nodes. */
+export function renderInline(text, theme) {
+    const spans = parseInline(text);
+    if (spans.length === 0)
+        return text;
+    return spans.map((span, i) => {
+        switch (span.kind) {
+            case 'code':
+                return (_jsx(Text, { color: theme.code, children: span.text }, `i${i}`));
+            case 'bold':
+                return (_jsx(Text, { bold: true, children: span.text }, `i${i}`));
+            case 'italic':
+                return (_jsx(Text, { italic: true, children: span.text }, `i${i}`));
+            case 'strike':
+                return (_jsx(Text, { strikethrough: true, children: span.text }, `i${i}`));
+            default:
+                return span.text;
+        }
+    });
+}

package/dist/ui/PromptInput.d.ts

@@ -0,0 +1,81 @@
+/**
+ * PromptInput (spec §3.6 / §3.10) — a controlled multiline input on Ink's
+ * `useInput` with: full line editing (Home/End, word jump/delete, kill-line via
+ * `input/keymap`), multi-line vertical cursor navigation, prompt-history recall
+ * at the edges, a slash-command palette, and `@file` path completion.
+ *
+ * The buffer/cursor transforms (`applyEdit`, `moveVertical`) and the suggestion
+ * computations (`slashSuggestions`, `fileTokenAt`) are pure module functions,
+ * exported for `input.test.ts`, so the component itself stays thin.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import { type EditIntent } from '../input/keymap.js';
+import { type Suggestion } from './AutocompletePopup.js';
+export interface CommandOption {
+    name: string;
+    description: string;
+}
+interface PromptInputProps {
+    isActive: boolean;
+    running: boolean;
+    history: string[];
+    commands: CommandOption[];
+    cwd: string;
+    theme: Theme;
+    caps: TermCapabilities;
+    /**
+     * Row budget for the completion popup (§5.2 / R-14).
+     *
+     * The popup renders INSIDE this component, inside the shell's `flexShrink={0}`
+     * bottom chrome, and can add up to 9 rows. On a short terminal that pushes the
+     * status bar past the frame height, where the root box's `overflow: hidden`
+     * clips it away — the one piece of chrome R2 promises is always visible.
+     * `App` derives this from `budget.ts` so the popup shrinks instead.
+     */
+    popupMaxRows?: number;
+    onSubmit: (text: string) => void;
+    onHelp?: () => void;
+    /**
+     * Set by `Composer` in full-screen mode: draw the rounded frame around the
+     * input row only, so the autocomplete popup lands OUTSIDE it (spec §4.7)
+     * without lifting the editor's buffer/cursor state out of this component.
+     * Unset ⇒ the v0.2.0 borderless inline rendering.
+     */
+    bordered?: {
+        color?: string;
+    };
+    /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
+    onDraftChange?: (hasDraft: boolean) => void;
+}
+/** Apply an edit intent as a pure buffer/cursor transform. */
+export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
+    buffer: string;
+    cursor: number;
+};
+/**
+ * Move the cursor up/down one line preserving the column. Returns `null` at the
+ * top/bottom edge (or for a single-line buffer) so the caller can fall back to
+ * prompt-history recall.
+ */
+export declare function moveVertical(buffer: string, cursor: number, dir: 'up' | 'down'): {
+    cursor: number;
+} | null;
+/**
+ * Slash-command suggestions when the buffer is a bare `/word` (no space yet).
+ *
+ * The character class covers `-` and `:` as well as `\w` (D16). Skill names are
+ * kebab-case and the namespaced fallback is `/skill:<name>`; with the original
+ * `^\/(\w*)$` a user typing `/my-sk` got NO popup at all — not an error message,
+ * just silence, which reads as "that command does not exist".
+ */
+export declare function slashSuggestions(buffer: string, commands: CommandOption[]): Suggestion[] | null;
+/** The `@file` token under the cursor (`@` + non-space run), if any. */
+export declare function fileTokenAt(buffer: string, cursor: number): {
+    start: number;
+    end: number;
+    query: string;
+} | null;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
+export {};