@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/clipboard-task.js

@@ -1,66 +0,0 @@
-import { startClipboardTask, } from './clipboard.js';
-class SharedClipboardCoordinator {
-    options;
-    busy = false;
-    cleanupPending = false;
-    disposed = false;
-    abort = new AbortController();
-    constructor(options) {
-        this.options = options;
-        options.clipboard?.signal?.addEventListener('abort', this.dispose, { once: true });
-        if (options.clipboard?.signal?.aborted)
-            this.dispose();
-    }
-    isBusy() { return this.busy; }
-    isCleanupPending() { return this.cleanupPending; }
-    state() {
-        return { busy: this.busy, cleanupPending: this.cleanupPending };
-    }
-    notifyState() {
-        if (!this.disposed)
-            this.options.onStateChange?.(this.state());
-    }
-    requestCopy = (request) => {
-        if (this.disposed)
-            return Promise.resolve({ status: 'failed', reason: 'cancelled' });
-        if (this.busy) {
-            this.options.onRequest?.();
-            this.options.onBusy?.(this.state());
-            return Promise.resolve({ status: 'busy' });
-        }
-        // Claim synchronously, before callbacks or Promise work can re-enter this port.
-        this.busy = true;
-        this.options.onRequest?.();
-        this.notifyState();
-        const snapshot = { ...request };
-        const task = startClipboardTask(snapshot.text, {
-            ...this.options.clipboard, signal: this.abort.signal,
-        });
-        const result = task.result.then((value) => {
-            if (!this.disposed) {
-                this.cleanupPending = this.busy && value.status === 'failed';
-                this.notifyState();
-                this.options.onResult?.(value, snapshot);
-            }
-            return value;
-        });
-        // Failure feedback is not a release signal: the old native writer may still live.
-        void task.released.then(() => {
-            this.busy = false;
-            this.cleanupPending = false;
-            this.notifyState();
-        });
-        return result;
-    };
-    dispose = () => {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.options.clipboard?.signal?.removeEventListener('abort', this.dispose);
-        this.abort.abort();
-    };
-}
-/** Create the App-owned copy port; use its live busy state before taking a selection. */
-export function createClipboardCoordinator(options = {}) {
-    return new SharedClipboardCoordinator(options);
-}

package/dist/ui/clipboard.d.ts

@@ -1,31 +0,0 @@
-export type CopyFailureReason = 'empty' | 'unavailable' | 'write' | 'timeout' | 'too-large' | 'cancelled';
-export type CopyResult = {
-    status: 'confirmed';
-    via: 'native';
-} | {
-    status: 'sent';
-    via: 'osc52';
-    fallbackReason?: CopyFailureReason;
-} | {
-    status: 'failed';
-    reason: CopyFailureReason;
-};
-export interface ClipboardOptions {
-    /** Frame differ's foreign-write door, never the intercepted stdout stream. */
-    write?: (chunk: string) => void;
-    remote?: boolean;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-export interface ClipboardTask {
-    result: Promise<CopyResult>;
-    /** Resolves only after no writer can change the clipboard again. */
-    released: Promise<void>;
-}
-export declare const MAX_OSC52_BYTES = 56000;
-/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
-export declare function osc52(text: string): string;
-/** Start a copy without rejecting; result and writer release are separate signals. */
-export declare function startClipboardTask(text: string, options?: ClipboardOptions): ClipboardTask;
-/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
-export declare function copyText(text: string, options?: ClipboardOptions): Promise<CopyResult>;

package/dist/ui/clipboard.js

@@ -1,157 +0,0 @@
-/** The only clipboard writer. Interaction callers share clipboard-task's coordinator. */
-import { spawn } from 'node:child_process';
-import process from 'node:process';
-export const MAX_OSC52_BYTES = 56_000;
-const CLEANUP_GRACE_MS = 500;
-// clip.exe preserves a supplied BOM and guesses BOM-less UTF-16 incorrectly for
-// short CJK text. Decode stdin explicitly; never interpolate clipboard content.
-const WINDOWS_CLIPBOARD_COMMAND = "$ErrorActionPreference='Stop'; "
-    + '$reader=[IO.StreamReader]::new([Console]::OpenStandardInput(),'
-    + '[Text.UTF8Encoding]::new($false),$false); Set-Clipboard -Value $reader.ReadToEnd()';
-/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
-export function osc52(text) {
-    return `\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`;
-}
-function sendOsc52(text, options, fallbackReason) {
-    if (options.signal?.aborted)
-        return { status: 'failed', reason: 'cancelled' };
-    if (Buffer.byteLength(text, 'utf8') > MAX_OSC52_BYTES) {
-        return { status: 'failed', reason: 'too-large' };
-    }
-    if (!options.write)
-        return { status: 'failed', reason: fallbackReason ?? 'unavailable' };
-    try {
-        options.write(osc52(text));
-        return { status: 'sent', via: 'osc52', ...(fallbackReason ? { fallbackReason } : {}) };
-    }
-    catch {
-        return { status: 'failed', reason: 'write' };
-    }
-}
-function settledTask(result) {
-    return { result: Promise.resolve(result), released: Promise.resolve() };
-}
-function spawnNative() {
-    const windows = process.platform === 'win32';
-    const file = windows ? 'powershell.exe' : process.platform === 'darwin' ? 'pbcopy' : 'xclip';
-    const args = windows
-        ? ['-NoProfile', '-NonInteractive', '-STA', '-Command', WINDOWS_CLIPBOARD_COMMAND]
-        : file === 'xclip' ? ['-selection', 'clipboard'] : [];
-    return spawn(file, args, {
-        stdio: ['pipe', 'ignore', 'ignore'], shell: false, windowsHide: true,
-    });
-}
-/** Owns a writer through close, even when its user-facing result timed out earlier. */
-class NativeClipboardTask {
-    child;
-    text;
-    options;
-    result;
-    released;
-    resolveResult;
-    resolveReleased;
-    settled = false;
-    closed = false;
-    stopping = false;
-    failure;
-    timer;
-    cleanupTimer;
-    constructor(child, text, options) {
-        this.child = child;
-        this.text = text;
-        this.options = options;
-        this.result = new Promise((resolve) => { this.resolveResult = resolve; });
-        this.released = new Promise((resolve) => { this.resolveReleased = resolve; });
-        child.on('error', this.onError);
-        child.once('close', this.onClose);
-        child.stdin?.on('error', this.onStdinError);
-        options.signal?.addEventListener('abort', this.onAbort, { once: true });
-        this.timer = setTimeout(() => this.stop('timeout'), options.timeoutMs ?? 1500);
-        if (options.signal?.aborted) {
-            this.onAbort();
-            return;
-        }
-        if (!child.stdin) {
-            this.stop('write');
-            return;
-        }
-        try {
-            child.stdin.end(Buffer.from(text, 'utf8'));
-        }
-        catch {
-            this.stop('write');
-        }
-    }
-    settle(result) {
-        if (this.settled)
-            return;
-        this.settled = true;
-        clearTimeout(this.timer);
-        clearTimeout(this.cleanupTimer);
-        this.resolveResult(result);
-    }
-    stop(reason) {
-        if (this.closed || this.stopping)
-            return;
-        this.stopping = true;
-        this.failure = reason;
-        clearTimeout(this.timer);
-        // No fallback before close: even a successful kill request is not proof of exit.
-        if (!this.settled) {
-            this.cleanupTimer = setTimeout(() => {
-                this.settle({ status: 'failed', reason });
-            }, CLEANUP_GRACE_MS);
-        }
-        try {
-            this.child.stdin?.destroy();
-        }
-        catch { /* Keep error listeners until close. */ }
-        try {
-            this.child.kill();
-        }
-        catch { /* A failed kill must not release the writer lock. */ }
-    }
-    onAbort = () => {
-        this.settle({ status: 'failed', reason: 'cancelled' });
-        this.stop('cancelled');
-    };
-    onError = () => { this.stop('unavailable'); };
-    onStdinError = () => { this.stop('write'); };
-    onClose = (code) => {
-        this.closed = true;
-        clearTimeout(this.timer);
-        clearTimeout(this.cleanupTimer);
-        this.options.signal?.removeEventListener('abort', this.onAbort);
-        if (!this.settled) {
-            const result = code === 0 && !this.failure
-                ? { status: 'confirmed', via: 'native' }
-                : sendOsc52(this.text, this.options, this.failure ?? 'write');
-            this.settle(result);
-        }
-        this.child.removeListener('error', this.onError);
-        this.child.stdin?.removeListener('error', this.onStdinError);
-        this.resolveReleased();
-    };
-}
-/** Start a copy without rejecting; result and writer release are separate signals. */
-export function startClipboardTask(text, options = {}) {
-    if (options.signal?.aborted)
-        return settledTask({ status: 'failed', reason: 'cancelled' });
-    if (text.length === 0)
-        return settledTask({ status: 'failed', reason: 'empty' });
-    const remote = options.remote ?? Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY);
-    if (remote)
-        return settledTask(sendOsc52(text, options));
-    let child;
-    try {
-        child = spawnNative();
-    }
-    catch {
-        return settledTask(sendOsc52(text, options, 'unavailable'));
-    }
-    return new NativeClipboardTask(child, text, options);
-}
-/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
-export function copyText(text, options = {}) {
-    return startClipboardTask(text, options).result;
-}

package/dist/ui/color-runtime.d.ts

@@ -1,5 +0,0 @@
-import type { TermCapabilities } from './capabilities.js';
-/** Highlight cache entries must not cross color preferences between sessions. */
-export declare function syntaxColorLevel(): number;
-/** Apply session colors without changing environment inherited by agent tools. */
-export declare function useTuiColors(level: TermCapabilities['colorLevel']): () => void;

package/dist/ui/color-runtime.js

@@ -1,29 +0,0 @@
-import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-import chalk from 'chalk';
-const require = createRequire(import.meta.url);
-/** Resolve the actual dependency instance even when npm nests its Chalk. */
-async function dependencyChalk(packageName) {
-    const dependency = createRequire(require.resolve(packageName));
-    return (await import(pathToFileURL(dependency.resolve('chalk')).href)).default;
-}
-const [inkChalk, highlightChalk] = await Promise.all([
-    dependencyChalk('ink'), dependencyChalk('cli-highlight'),
-]);
-/** Highlight cache entries must not cross color preferences between sessions. */
-export function syntaxColorLevel() { return highlightChalk.level; }
-/** Apply session colors without changing environment inherited by agent tools. */
-export function useTuiColors(level) {
-    const renderers = new Set([chalk, inkChalk, highlightChalk]);
-    const previous = new Map([...renderers].map(renderer => [renderer, renderer.level]));
-    for (const renderer of renderers)
-        renderer.level = level;
-    let restored = false;
-    return () => {
-        if (restored)
-            return;
-        restored = true;
-        for (const [renderer, original] of previous)
-            renderer.level = original;
-    };
-}

package/dist/ui/composer-input.d.ts

@@ -1,38 +0,0 @@
-import { type EditorState, type InputSegment } from './editor-reducer.js';
-export interface ComposerSubmitResult {
-    accepted: boolean;
-    reason?: string;
-}
-/**
- * A fill carries the prompt body; `submit` folds "insert and send" into the SAME
- * transaction, so `Ctrl+Enter` in the picker is literally the Enter key one step
- * later rather than a second submission path (quick-prompt-library P0-1 / I-9).
- */
-export type ComposerInputIntent = InputSegment | {
-    kind: 'newline';
-} | {
-    kind: 'submit';
-} | {
-    kind: 'fill';
-    text: string;
-    mode: 'insert' | 'replace';
-    submit: boolean;
-};
-export interface ComposerInputOptions {
-    editor: EditorState;
-    intents: readonly ComposerInputIntent[];
-    resolveSubmit: (editor: EditorState) => string | null;
-    checkPasteLimit: (segments: InputSegment[], editor: EditorState) => string | null;
-}
-export interface ComposerInputPlan {
-    nextEditor: EditorState;
-    rejectedEditor: EditorState;
-    submission?: string;
-    notice?: string;
-    refusal?: string;
-}
-/**
- * Plan both accepted and rejected drafts before any submission side effect.
- * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
- */
-export declare function planComposerInput(options: ComposerInputOptions): ComposerInputPlan;

package/dist/ui/composer-input.js

@@ -1,79 +0,0 @@
-import { editorReducer } from './editor-reducer.js';
-import { planPromptFill } from '../prompts/fill.js';
-const MORE_INPUT_NOTICE = 'More input is kept in the draft; press Enter to send.';
-/**
- * Apply one fill to one draft. TWO CALLS PER INTENT, on purpose: the same plan runs
- * against the accepted and the rejected draft (P0-1), so a submission the host
- * refuses leaves the FILLED text in the composer rather than the text from before
- * the fill. Doing it once and sharing the result would silently drop the prompt the
- * user just chose, which is the data loss this design exists to prevent.
- *
- * THE REDUCER OWNS THE RESULT. `planPromptFill` says what to insert; `insert` and
- * `replace` decide the caret, the paste-token snapping and the draft-flag reset,
- * exactly as they do for typing.
- */
-function applyFill(editor, intent) {
-    const plan = planPromptFill({
-        draft: editor.buffer,
-        cursor: editor.cursor,
-        content: intent.text,
-        mode: intent.mode,
-    });
-    return plan.mode === 'replace'
-        ? editorReducer(editor, { type: 'replace', buffer: plan.text, cursor: plan.cursor })
-        : editorReducer(editor, { type: 'insert', text: plan.text });
-}
-/**
- * Plan both accepted and rejected drafts before any submission side effect.
- * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
- */
-export function planComposerInput(options) {
-    let nextEditor = options.editor;
-    let rejectedEditor = options.editor;
-    let acceptedBase = options.editor;
-    let acceptedPastes = [];
-    const rejectedPastes = [];
-    let submission;
-    let notice;
-    for (const intent of options.intents) {
-        if (intent.kind === 'fill') {
-            nextEditor = applyFill(nextEditor, intent);
-            rejectedEditor = applyFill(rejectedEditor, intent);
-            // A plain fill stops here: the draft is filled, nothing is sent (AC-16).
-            if (!intent.submit)
-                continue;
-        }
-        else if (intent.kind !== 'submit') {
-            const segment = intent.kind === 'newline'
-                ? { kind: 'text', text: '\n' } : intent;
-            const segments = [segment];
-            if (segment.kind === 'paste') {
-                // Inline pastes have no map entry; count every paste in this callback as before.
-                acceptedPastes.push(segment);
-                rejectedPastes.push(segment);
-                const refusal = options.checkPasteLimit(acceptedPastes, acceptedBase)
-                    ?? options.checkPasteLimit(rejectedPastes, options.editor);
-                if (refusal) {
-                    return { nextEditor: options.editor, rejectedEditor: options.editor, refusal };
-                }
-            }
-            nextEditor = editorReducer(nextEditor, { type: 'input', segments });
-            rejectedEditor = editorReducer(rejectedEditor, { type: 'input', segments });
-            continue;
-        }
-        // THE ONE SUBMIT PATH. A `fill` with `submit` and a bare `submit` reach this
-        // block and nothing else, so queueing, paste expansion and the
-        // accepted/rejected contract are inherited rather than re-implemented.
-        const text = options.resolveSubmit(nextEditor);
-        if (submission !== undefined) {
-            notice = MORE_INPUT_NOTICE;
-        }
-        else if (text !== null && text.trim().length > 0) {
-            submission = text;
-            nextEditor = editorReducer(nextEditor, { type: 'clear' });
-            acceptedBase = nextEditor;
-            acceptedPastes = [];
-        }
-    }
-    return { nextEditor, rejectedEditor, submission, notice };
-}

package/dist/ui/composer-limits.d.ts

@@ -1,30 +0,0 @@
-/**
- * Composer and transcript row ceilings (tui-paste-handling section 5.5 / 5.6).
- *
- * Structural, not policy (D-10): the only user-facing key this feature adds is
- * the boolean `paste`. Everything here is a bound that keeps the frame's row
- * arithmetic true, and every one of them is switchable by returning a larger
- * number rather than by a config flag.
- */
-/** At or below BOTH of these a paste is inserted verbatim rather than collapsed. */
-export declare const PASTE_INLINE_MAX_LINES = 6;
-export declare const PASTE_INLINE_MAX_CHARS = 400;
-/**
- * Rows one submitted user message may RENDER in the transcript, before the
- * `... +N more lines` tail (G7).
- *
- * `ui/layout/virtual-window.ts` imports this rather than duplicating the number,
- * unlike `DIFF_COLLAPSED_LINES` / `TOOL_LIVE_TAIL_ROWS` beside it: I-13 makes the
- * render cap and the height estimate THE SAME NUMBER, and there is no
- * import-cycle reason here for them to be two.
- */
-export declare const USER_ENTRY_MAX_ROWS = 40;
-/**
- * Ceiling on the composer's DRAFT rows at a given terminal height.
- *
- * Non-decreasing in `terminalRows`, with one quarter of the terminal available
- * to the draft and an absolute six-row ceiling shared by rendering and budgets.
- */
-export declare function draftMaxRows(terminalRows: number): number;
-/** Compatibility export for the shared hint visibility threshold. */
-export declare const DRAFT_MAX_ROWS_HINT_TIER = 20;

package/dist/ui/composer-limits.js

@@ -1,45 +0,0 @@
-/**
- * Composer and transcript row ceilings (tui-paste-handling section 5.5 / 5.6).
- *
- * Structural, not policy (D-10): the only user-facing key this feature adds is
- * the boolean `paste`. Everything here is a bound that keeps the frame's row
- * arithmetic true, and every one of them is switchable by returning a larger
- * number rather than by a config flag.
- */
-/** At or below BOTH of these a paste is inserted verbatim rather than collapsed. */
-export const PASTE_INLINE_MAX_LINES = 6;
-export const PASTE_INLINE_MAX_CHARS = 400;
-/**
- * Rows one submitted user message may RENDER in the transcript, before the
- * `... +N more lines` tail (G7).
- *
- * `ui/layout/virtual-window.ts` imports this rather than duplicating the number,
- * unlike `DIFF_COLLAPSED_LINES` / `TOOL_LIVE_TAIL_ROWS` beside it: I-13 makes the
- * render cap and the height estimate THE SAME NUMBER, and there is no
- * import-cycle reason here for them to be two.
- */
-export const USER_ENTRY_MAX_ROWS = 40;
-/**
- * The terminal height at which the composer's hint row starts to fit.
- *
- * DELIBERATELY A SECOND COPY of `ui/layout/budget.ts::HINT_MIN_ROWS` rather than
- * an import: `budget.ts` calls `draftMaxRows` to clamp its composer term, so an
- * import in this direction would close an ESM cycle whose only protection is
- * that neither side reads the other at module scope -- true today, and a
- * confusing TDZ crash the first time someone hoists a use. `budget.test.ts`
- * asserts the two numbers are equal, so they cannot drift in silence.
- */
-const DRAFT_TIER_MIN_ROWS = 20;
-/**
- * Ceiling on the composer's DRAFT rows at a given terminal height.
- *
- * Non-decreasing in `terminalRows`, with one quarter of the terminal available
- * to the draft and an absolute six-row ceiling shared by rendering and budgets.
- */
-export function draftMaxRows(terminalRows) {
-    if (!Number.isFinite(terminalRows))
-        return 3;
-    return Math.max(1, Math.min(6, Math.floor(terminalRows / 4)));
-}
-/** Compatibility export for the shared hint visibility threshold. */
-export const DRAFT_MAX_ROWS_HINT_TIER = DRAFT_TIER_MIN_ROWS;

package/dist/ui/composer-rows.d.ts

@@ -1,73 +0,0 @@
-/**
- * Composer layout (tui-paste-handling section 5.5) -- pure. No Ink, no React.
- *
- * THE ONE PLACE THAT MAPS A BUFFER INDEX TO A SCREEN CELL (I-9). The composer
- * used to hand its buffer to Ink one `<Text>` per logical line and let Yoga wrap
- * it, which is fine until the draft is taller than the frame: `AppShell` gives
- * the bottom chrome `flexShrink={0}`, so a tall composer does not grow the frame
- * -- Yoga takes the rows out of the transcript and `overflow: hidden` clips them
- * away, while `layout/budget.ts` keeps telling five consumers the composer is
- * three rows tall. Four hundred presses of `Shift+Enter` do it without pasting
- * anything.
- *
- * So the wrap happens HERE, the row count is a number this module returns, and
- * `budget.ts` is told that number (I-8).
- *
- * HARD WRAP BY DISPLAY COLUMN, NEVER `layout/wrap-rows.ts::wrapToRows` (D-15).
- * That function is a PROSE wrapper: it splits on `/\s+/` and rejoins with single
- * spaces, so it destroys indentation and makes the character-index-to-screen-cell
- * mapping the caret depends on impossible to state, let alone compute.
- */
-export interface ComposerSegment {
-    readonly text: string;
-    readonly kind: 'text' | 'token';
-}
-export interface ComposerRow {
-    readonly segments: ComposerSegment[];
-}
-export interface ComposerLayout {
-    /** At most `maxRows`, and always containing the caret when `active`. */
-    readonly rows: ComposerRow[];
-    /** Index into `rows`, or -1 when the composer is not focused. */
-    readonly cursorRow: number;
-    /** Display column within that row. */
-    readonly cursorCol: number;
-    /** Rows the buffer occupies BEFORE the window was applied. */
-    readonly totalRows: number;
-    readonly hiddenAbove: number;
-    readonly hiddenBelow: number;
-}
-export interface ComposerLayoutInput {
-    readonly buffer: string;
-    readonly cursor: number;
-    readonly cols: number;
-    readonly maxRows: number;
-    readonly active: boolean;
-}
-/** Width of a displayed run, measured by complete graphemes. */
-export declare function displayWidth(text: string): number;
-/**
- * Wrap `buffer` into rows, locate the caret, and select a window of at most
- * `maxRows` rows that contains it.
- *
- * The window is pinned to the BOTTOM -- where the user is typing -- and pulled up
- * only far enough to keep the caret visible. That is deterministic, which matters
- * because this function holds no state between calls: a scroll offset would have
- * to live in the reducer and would then need its own invalidation rules.
- */
-export declare function layoutComposer(input: ComposerLayoutInput): ComposerLayout;
-export interface RowSplit {
-    readonly before: ComposerSegment[];
-    /** The one cell the caret sits on, or `null` when it sits past the last one. */
-    readonly at: ComposerSegment | null;
-    readonly after: ComposerSegment[];
-}
-/**
- * Split one row at a display column so the renderer can draw an inverse caret on
- * exactly one cell.
- *
- * Lives here rather than in the component because it walks the SAME width table
- * `layoutComposer` walked (I-9): a second, subtly different measurement is how
- * the caret ends up drawn on a cell that does not hold the character it is on.
- */
-export declare function splitRowAtColumn(row: ComposerRow, column: number): RowSplit;