@aragon-agent/cli 0.6.11 → 0.6.13

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { ModelProfile, ModelProfilesConfig, ModelRole } from '../../config/model-profiles.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export interface ProfileFrameProps {
+    theme: Theme;
+    caps: TermCapabilities;
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp?: (offset: number) => void;
+}
+/** Move focus into view while accepting App's independent wheel/page scrolling. */
+export declare function useProfileScroll(props: ProfileFrameProps, focus: number): number;
+/** Cut by terminal columns, preserving surrogate pairs and wide names. */
+export declare function clipProfileText(value: string, columns: number): string;
+export declare function profileEndpointSummary(baseUrl: string | null): string;
+interface ModelProfilePickerProps extends ProfileFrameProps {
+    profiles: ModelProfilesConfig;
+    savedProfiles?: ModelProfilesConfig;
+    role: ModelRole;
+    manager?: boolean;
+    error?: string;
+    apiKeys: Record<string, string | undefined>;
+    customProfile?: ModelProfile;
+    onSelect: (id: string | null) => void;
+    onCreate: () => void;
+    onEdit: (profile: ModelProfile) => void;
+    onDuplicate: (id: string) => void;
+    onDelete: (id: string) => void;
+    onCancel: () => void;
+}
+/** Profile selection and explicit management actions share one input owner. */
+export declare function ModelProfilePicker(props: ModelProfilePickerProps): React.ReactElement;
+export {};

package/dist/ui/overlays/ModelProfilePicker.js

@@ -0,0 +1,167 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Text, useInput } from 'ink';
+import stringWidth from 'string-width';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { profileUsers } from './model-profile-state.js';
+/** Move focus into view while accepting App's independent wheel/page scrolling. */
+export function useProfileScroll(props, focus) {
+    const [offset, setOffset] = useState(0);
+    useEffect(() => { props.onScrollClamp?.(0); }, []);
+    useEffect(() => { setOffset(props.scrollOffset); }, [props.scrollOffset]);
+    useEffect(() => {
+        const height = Math.max(1, props.maxRows - (props.cols >= 48 ? 5 : 3));
+        const next = focus < offset ? focus : focus >= offset + height ? focus - height + 1 : offset;
+        if (next !== offset) {
+            setOffset(next);
+            props.onScrollClamp?.(next);
+        }
+    }, [focus, props.maxRows, props.cols]);
+    return offset;
+}
+/** Cut by terminal columns, preserving surrogate pairs and wide names. */
+export function clipProfileText(value, columns) {
+    let result = '';
+    for (const point of value) {
+        if (stringWidth(result + point) > Math.max(0, columns))
+            break;
+        result += point;
+    }
+    return result;
+}
+function uniqueId(profile, entries) {
+    let length = Math.min(8, profile.id.length);
+    while (length < profile.id.length && entries.some((other) => other.id !== profile.id
+        && other.id.slice(0, length) === profile.id.slice(0, length)))
+        length++;
+    return profile.id.slice(0, length);
+}
+export function profileEndpointSummary(baseUrl) {
+    if (!baseUrl)
+        return 'Default URL';
+    try {
+        const url = new URL(baseUrl);
+        return url.username || url.password || url.search || url.hash ? 'Invalid URL' : url.host;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+function host(profile) {
+    return profileEndpointSummary(profile.baseUrl);
+}
+function usePickerState(props) {
+    const [index, setIndex] = useState(0);
+    const [selectedId, setSelectedId] = useState(props.profiles.entries[0]?.id);
+    const [query, setQuery] = useState('');
+    const [searching, setSearching] = useState(false);
+    const searchable = props.profiles.entries.length > 8;
+    const entries = props.profiles.entries.filter((entry) => `${entry.name} ${entry.provider} ${entry.model}`.toLocaleLowerCase()
+        .includes(query.toLocaleLowerCase()));
+    const actions = props.manager ? ['New', 'Edit', 'Duplicate', 'Delete'] : ['Create profile'];
+    const prefix = props.manager ? 0 : 1;
+    const count = entries.length + prefix + actions.length;
+    const cursor = Math.min(index, count - 1);
+    const focused = entries[cursor - prefix];
+    const selected = props.profiles.entries.find((entry) => entry.id === selectedId);
+    const offset = useProfileScroll(props, cursor + (searchable ? 1 : 0));
+    useEffect(() => { if (focused)
+        setSelectedId(focused.id); }, [focused?.id]);
+    return { setIndex, query, setQuery, searching, setSearching, searchable, entries,
+        actions, prefix, count, cursor, focused, selected, offset };
+}
+function usePickerInput(props, state) {
+    const { cursor, focused, selected, actions, prefix, entries, count, searching, searchable, setIndex, setQuery, setSearching } = state;
+    function activate() {
+        if (!props.manager && cursor === 0) {
+            props.onSelect(null);
+            return;
+        }
+        if (focused) {
+            if (props.manager)
+                setIndex(prefix + entries.length + 1);
+            else
+                props.onSelect(focused.id);
+            return;
+        }
+        const action = actions[cursor - prefix - entries.length];
+        if (action === 'New' || action === 'Create profile')
+            props.onCreate();
+        if (action === 'Edit' && selected)
+            props.onEdit(selected);
+        if (action === 'Duplicate' && selected)
+            props.onDuplicate(selected.id);
+        if (action === 'Delete' && selected)
+            props.onDelete(selected.id);
+    }
+    useInput((input, key) => {
+        if (key.escape) {
+            if (searching)
+                setSearching(false);
+            else
+                props.onCancel();
+            return;
+        }
+        if (searching) {
+            if (key.return || key.downArrow || key.tab) {
+                setSearching(false);
+                return;
+            }
+            if (key.backspace || key.delete)
+                setQuery((value) => [...value].slice(0, -1).join(''));
+            else if (input && !key.ctrl && !key.meta) {
+                setQuery((value) => value + stripPasteFrames(stripEnterFrames(input)));
+            }
+            setIndex(0);
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift))
+            setIndex((cursor - 1 + count) % count);
+        else if (key.downArrow || key.tab)
+            setIndex((cursor + 1) % count);
+        else if (key.return)
+            activate();
+        else if (input === '/' && searchable)
+            setSearching(true);
+    });
+}
+function profilePickerLabel(props, entry) {
+    const saved = profileUsers(props.savedProfiles, entry.id);
+    const checked = props.profiles[`${props.role}Id`] === entry.id ? '[Selected] ' : '';
+    const duplicate = props.profiles.entries.some((other) => other.id !== entry.id
+        && other.name === entry.name);
+    const identity = duplicate ? `#${uniqueId(entry, props.profiles.entries)} ` : '';
+    const detail = duplicate ? ` ${host(entry)}` : '';
+    return `${identity}${checked}${entry.name}  ${entry.provider}:${entry.model}${detail}`
+        + (saved ? ` [${saved}]` : '');
+}
+function buildPickerRows(props, state) {
+    const { entries, actions, cursor, searching, searchable, query, focused, selected } = state;
+    const glyphs = pickGlyphs(props.caps);
+    const lines = [];
+    if (!props.manager)
+        lines.push('Current custom');
+    lines.push(...entries.map((entry) => profilePickerLabel(props, entry)));
+    lines.push(...actions);
+    const rows = lines.map((line, row) => _jsxs(Text, { wrap: "truncate", color: row === cursor ? props.theme.accent : props.theme.muted, children: [`${row === cursor && !searching ? glyphs.caret : ' '} `, clipProfileText(line, props.cols - 8)] }, row));
+    if (searchable)
+        rows.unshift(_jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [searching ? `${glyphs.caret} ` : '  ', "Search: ", query || '(/ to search)'] }, "search"));
+    const detail = !props.manager && cursor === 0 ? props.customProfile : focused ?? selected;
+    if (detail) {
+        rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: [detail.provider, ":", detail.model || '(not set)', " ", host(detail), detail === props.customProfile ? '' : ` #${detail.id}`] }, "detail"));
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: detail.apiKey ? 'Profile key: Configured'
+                : props.apiKeys[detail.provider] ? 'Shared / environment: Configured' : 'Missing API key' }, "key"));
+    }
+    return rows;
+}
+/** Profile selection and explicit management actions share one input owner. */
+export function ModelProfilePicker(props) {
+    const state = usePickerState(props);
+    usePickerInput(props, state);
+    return _jsx(OverlayFrame, { ...props, title: props.error ?? (props.manager ? 'Manage profiles'
+            : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
+            : 'Enter select/action | Esc back' });
+}

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { PendingSteering } from '../../agent/queued-messages.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export interface QueueTextRow {
+    queueId: string;
+    offset: number;
+    text: string;
+}
+/** Preserve visible whitespace and display terminal controls as harmless escapes. */
+export declare function projectQueueRows(pending: readonly PendingSteering[], columns: number): QueueTextRow[];
+/** Anchor by stable message ID and source offset, including long soft-wrapped lines. */
+export declare function restoreQueueAnchor(before: readonly QueueTextRow[], after: readonly QueueTextRow[], scroll: number): number;
+export declare function QueueOverlay(props: {
+    pending: readonly PendingSteering[];
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp: (offset: number) => void;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;

package/dist/ui/overlays/QueueOverlay.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { Text } from 'ink';
+import stringWidth from 'string-width';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { graphemes } from '../editor-navigation.js';
+/** Preserve visible whitespace and display terminal controls as harmless escapes. */
+export function projectQueueRows(pending, columns) {
+    const width = Math.max(1, columns);
+    const rows = [];
+    for (const [index, item] of pending.entries()) {
+        rows.push({ queueId: item.queueId, offset: -1, text: `Queue ${index + 1}` });
+        let text = '';
+        let cells = 0;
+        let offset = 0;
+        const flush = () => {
+            rows.push({ queueId: item.queueId, offset, text });
+            text = '';
+            cells = 0;
+        };
+        for (const part of graphemes(item.text)) {
+            if (part.text === '\n' || part.text === '\r\n') {
+                flush();
+                offset = part.end;
+                continue;
+            }
+            const safe = part.text === '\t' ? ' '.repeat(4 - cells % 4)
+                : part.text.replace(/[\x00-\x1f\x7f-\x9f]/g, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`);
+            const units = safe === part.text ? [safe] : Array.from(safe);
+            for (const unit of units) {
+                const size = stringWidth(unit);
+                if (cells + size > width && text) {
+                    flush();
+                    offset = part.index;
+                }
+                text += unit;
+                cells += size;
+            }
+        }
+        flush();
+    }
+    return rows;
+}
+/** Anchor by stable message ID and source offset, including long soft-wrapped lines. */
+export function restoreQueueAnchor(before, after, scroll) {
+    const anchor = before[Math.min(scroll, before.length - 1)];
+    if (!anchor || !after.length)
+        return 0;
+    let target = -1;
+    for (let i = 0; i < after.length; i++) {
+        if (after[i].queueId === anchor.queueId && after[i].offset <= anchor.offset)
+            target = i;
+    }
+    if (target >= 0)
+        return target;
+    const next = before.slice(scroll).find((row) => after.some((item) => item.queueId === row.queueId));
+    if (next)
+        return after.findIndex((row) => row.queueId === next.queueId);
+    const previous = [...before.slice(0, scroll)].reverse()
+        .find((row) => after.some((item) => item.queueId === row.queueId));
+    return previous ? after.findIndex((row) => row.queueId === previous.queueId) : 0;
+}
+export function QueueOverlay(props) {
+    const { pending, cols, scrollOffset, onScrollClamp, theme } = props;
+    const projected = useMemo(() => projectQueueRows(pending, cols - (cols >= 48 ? 4 : 2)), [pending, cols]);
+    const previous = useRef({ rows: projected, scroll: scrollOffset });
+    const anchored = previous.current.rows === projected ? scrollOffset
+        : restoreQueueAnchor(previous.current.rows, projected, previous.current.scroll);
+    const bodyRows = Math.max(1, Math.floor(props.maxRows) - (cols >= 48 ? 5 : 3));
+    const offset = Math.max(0, Math.min(anchored, projected.length - bodyRows));
+    useEffect(() => {
+        previous.current = { rows: projected, scroll: offset };
+        if (offset !== scrollOffset)
+            onScrollClamp(offset);
+    }, [projected, offset, scrollOffset, onScrollClamp]);
+    const rows = useMemo(() => projected.length ? projected.map((row, index) => _jsx(Text, { wrap: "truncate", color: theme.primary, children: row.text || ' ' }, `${row.queueId}:${index}`))
+        : [_jsx(Text, { children: '\u961f\u5217\u5df2\u5904\u7406\u5b8c\u6bd5' }, "empty")], [projected, theme]);
+    return _jsx(OverlayFrame, { ...props, title: `Queue: \u5f85\u5904\u7406 ${pending.length}`, hint: "PgUp/PgDn | Up/Down | Esc", rows: rows, scrollOffset: offset });
+}

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

@@ -13,6 +13,7 @@ import { type CompactionConfig, type FastConfig } from '../../config/schema.js';
 import { type LogLevelName } from '../../logging/levels.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
+import type { ModelSettingsDraft, ModelSettingsPatch, ModelSettingsSaveResult } from '../../config/model-profile-store.js';
 export interface SettingsValues {
     provider: string;
     model: string;
@@ -97,7 +98,11 @@ interface SettingsScreenProps {
     onScrollClamp?: (offset: number) => void;
     theme: Theme;
     caps: TermCapabilities;
-    onSave: (values: SettingsValues) => void;
+    onSave?: (values: SettingsValues) => void;
+    draft?: ModelSettingsDraft;
+    onProfileSave?: (draft: ModelSettingsDraft) => ModelSettingsSaveResult;
+    onClose?: () => void;
+    onReload?: () => ModelSettingsDraft;
     /**
      * `API retries` READ-ONLY row (llm-api-retry-backoff §6.9), e.g. `10` or `off`.
      *
@@ -178,5 +183,7 @@ export declare function compactionSettingsFrom(compaction: CompactionConfig): Pi
  * "I set 64000 but answers still stop early" has no answer anywhere in the UI.
  */
 export declare function effectiveCapLine(values: Pick<SettingsValues, 'provider' | 'model' | 'maxTokens'>): string;
-export declare function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, retrySummary, }: SettingsScreenProps): React.ReactElement;
+export declare function SettingsScreen(props: SettingsScreenProps): React.ReactElement;
+/** Only fields changed by the user belong in a settings transaction. */
+export declare function readDirtySettings(initial: SettingsValues, values: SettingsValues): ModelSettingsPatch;
 export {};