@gaia-ai/addon-gaia-ui 0.17.2 → 0.19.0

package/dist/src/Entity/ticket/Screen/ticket-addons.js

@@ -0,0 +1,492 @@
+// The ticket's addon messages (GAIA-661): one entry per addon of the
+// ticket's conductor in an addon bar (←/→), the selected addon's permitted
+// messages as one list, Enter to send through the conductor inbox, and a
+// modal form for a message with input. Definitions and states come from the
+// server, so this tab needs no addon installed locally. Contract 1
+// (views/actions/rows) is retired; only contract-2 messages render here.
+import { actionItem, } from '../../../Component/footer-actions/index.js';
+import { Markdown, markdownLines } from '../../../Component/markdown/index.js';
+import { flattenSections } from '../../../Component/section-list/index.js';
+import { copyThrough } from '../../../lib/clipboard.js';
+import { ListCursor } from '../../../lib/cursor.js';
+import { columnNode, messageTree } from '../../../lib/vnode.js';
+import { AsyncModalScreen } from '../../../Screen/async-modal-screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { runRowAction } from '../../../Screen/row-action.js';
+import { FIELDS_REGION, renderDeclaredFieldsTree, } from '../../../Widget/render.js';
+import { listRowIds, listTableRows, listTableTree, } from '../../collection.js';
+import { ticketEditAction, ticketHeaderTree, ticketTitleOf, } from '../Component/ticket-detail/index.js';
+import { addonEntries, isOpen, readTicketAddons, sendAddonAction, } from '../Data/addons.js';
+import { ticketInputContext } from '../Data/input.js';
+import { readTicket } from '../Data/store.js';
+import { addonForm, formFields, payloadFrom, } from '../Form/addon-action.js';
+import { keyToIntent } from '../Form/keys.js';
+/** Re-read cadence while a message of the shown addon is pending/running. */
+const OPEN_POLL_MS = 3_000;
+function ticketUuidOf(context, ticket) {
+    return ticket?.data?.id ?? context.params?.ticketId ?? '';
+}
+/** The table of one addon: label and an Enter-to-run hint per message. */
+function tableFor() {
+    const columns = [
+        {
+            fields: [],
+            key: 'c0',
+            label: 'LABEL',
+            width: 28,
+            get: (l) => l.cells[0] ?? '',
+        },
+        {
+            fields: [],
+            key: 'actions',
+            label: 'ACTIONS',
+            width: 0,
+            get: (l) => l.cells[1] ?? '',
+        },
+    ];
+    return {
+        noun: 'addon',
+        columns,
+        emptyMessage: 'No data yet.',
+    };
+}
+function linesFor(entries) {
+    return entries.map((entry) => ({
+        id: entry.id,
+        cells: [
+            `▶ ${entry.message.label}`,
+            entry.message.input ? 'Enter: form' : 'Enter: send',
+        ],
+    }));
+}
+/** The addon bar: every addon, the selected one in brackets. */
+function addonBar(model, selected) {
+    return model.addons
+        .map((a, i) => (i === selected ? `[${a.label}]` : a.label))
+        .join('  ');
+}
+/** The newest message of the addon, as one status line. */
+function latestLine(addon) {
+    const latest = addon.latest;
+    if (!latest)
+        return undefined;
+    return `${latest.label}: ${latest.status}`;
+}
+/** The latest answer's Markdown body. */
+function latestMarkdown(addon) {
+    return addon.latest?.result?.markdown;
+}
+/** The first safe http(s) link a Markdown answer carries, if any (`l` key). */
+function firstHttpLink(markdown) {
+    // Prefer the URL inside markdown link syntax `[text](url)` first: a bare
+    // `\S+` scan greedily swallows the closing `)` and any wrapping brackets
+    // of a real `[443](https://host:443)` answer (GAIA-661).
+    return (markdown.match(/\]\((https?:[^)\s]+)\)/)?.[1] ??
+        markdown.match(/\bhttps?:\/\/\S+/)?.[0]?.replace(/[)\]."'`]+$/, ''));
+}
+export class TicketAddonsScreen extends AsyncScreen {
+    // No `tab` here (GAIA-661): this screen is the full send/poll surface, kept
+    // navigable from the Overview sidebar's inline card, never a tab a person
+    // sees — the tab bar never shows the word "addon".
+    static route = {
+        id: 'ticket.addons',
+        path: '/tickets/:ticketId/addons',
+        parent: 'project.tickets',
+        fallback: { routeId: 'my.work' },
+        context: ticketInputContext,
+    };
+    id = TicketAddonsScreen.route.id;
+    frameId = 'ticket';
+    cursor = new ListCursor();
+    selected = 0;
+    sending = new Set();
+    timer;
+    async load(context) {
+        const ticket = readTicket(context, this.readyValue?.ticket);
+        const client = context.services?.client;
+        // No control plane (a bare pipe): nothing to show rather than an error.
+        if (!client)
+            return { ticket, model: { conductor: null, addons: [] } };
+        return {
+            ticket,
+            model: await readTicketAddons(client, ticketUuidOf(context, ticket)),
+        };
+    }
+    didLoad(data, context) {
+        this.selected = Math.min(this.selected, Math.max(0, data.model.addons.length - 1));
+        this.clampCursor();
+        this.schedulePoll(context);
+    }
+    reload(context) {
+        void this.retry(context);
+    }
+    leave() {
+        this.stopPoll();
+        super.leave();
+    }
+    reset() {
+        this.stopPoll();
+        super.reset();
+        this.cursor.reset();
+        this.selected = 0;
+        this.sending = new Set();
+        this.toast = '';
+    }
+    /** Re-read every 3 s while the shown addon has an open message. */
+    schedulePoll(context) {
+        const addon = this.addon();
+        if (!addon || !isOpen(addon)) {
+            this.stopPoll();
+            return;
+        }
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            if (context.isActive())
+                this.reload(context);
+        }, OPEN_POLL_MS);
+        this.timer.unref?.();
+    }
+    stopPoll() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    addon() {
+        return this.readyValue?.model.addons[this.selected];
+    }
+    entries() {
+        const addon = this.addon();
+        return addon ? addonEntries(addon) : [];
+    }
+    clampCursor() {
+        this.cursor.index = Math.max(0, Math.min(this.cursor.index, this.entries().length - 1));
+    }
+    renderLoading() {
+        return ['Loading addons…'];
+    }
+    lines() {
+        const addon = this.addon();
+        if (!addon)
+            return undefined;
+        const entries = this.entries();
+        const table = tableFor();
+        const lines = linesFor(entries).map((line) => this.sending.has(line.id)
+            ? { ...line, cells: [...line.cells.slice(0, -1), 'sending …'] }
+            : line);
+        return { table, lines };
+    }
+    renderReady(data, context) {
+        const view = this.lines();
+        if (!view)
+            return messageTree('addons', ['No addons for this ticket.']);
+        const addon = this.addon();
+        const markdown = addon ? latestMarkdown(addon) : undefined;
+        const children = [
+            messageTree('addons-bar', [addonBar(data.model, this.selected)]),
+            listTableTree(view.table, view.lines, undefined, {
+                selectedIndex: this.cursor.index,
+            }),
+        ];
+        if (markdown) {
+            children.push(Markdown({
+                id: 'addons-answer',
+                width: Math.max(16, (context.terminalColumns ?? 80) - 12),
+                source: markdown,
+            }));
+        }
+        return columnNode('addons', ...children);
+    }
+    renderNonInteractive(context) {
+        const notice = this.noticeRows(context);
+        if (notice)
+            return notice;
+        const data = this.readyValue;
+        const view = this.lines();
+        // A ticket report prints every tab; one without addons adds nothing.
+        if (!data || !view)
+            return [];
+        const addon = this.addon();
+        const markdown = addon ? latestMarkdown(addon) : undefined;
+        return flattenSections([
+            {
+                heading: addonBar(data.model, this.selected),
+                lines: [
+                    ...listTableRows(view.table, view.lines, undefined),
+                    ...(markdown ? markdownLines(markdown).map((l) => l.text) : []),
+                ],
+            },
+        ]).lines;
+    }
+    chrome(context) {
+        const ticket = this.readyValue?.ticket;
+        const { identifier, title } = ticketTitleOf(ticket ?? {});
+        const view = this.lines();
+        const count = view?.lines.length ?? 0;
+        return {
+            title: ticket?.data
+                ? `${identifier} · ${title}`
+                : (context.params?.ticketId ?? 'ticket'),
+            ...(ticket?.data
+                ? { header: ticketHeaderTree(ticket, identifier, title, []) }
+                : {}),
+            selectable: count,
+            selectedIndex: this.cursor.index,
+            cursorMode: count > 1 ? 'select' : 'scroll',
+            ...(view ? { rowIds: listRowIds(view.table, view.lines) } : {}),
+        };
+    }
+    actions() {
+        const many = (this.readyValue?.model.addons.length ?? 0) > 1;
+        return [
+            actionItem('detail-tab', 'Tab', 'section'),
+            actionItem('detail-edit', 'e', 'edit'),
+            ...(many ? [actionItem('addons-switch', '←→', 'addon')] : []),
+            actionItem('detail-arrows', '↑↓', 'select'),
+            actionItem('addons-enter', 'Enter', 'run'),
+            actionItem('addons-link', 'l', 'copy link'),
+        ];
+    }
+    notice() {
+        const addon = this.addon();
+        const offline = this.readyValue?.model.conductor?.status === 'offline';
+        return ([
+            offline
+                ? 'Conductor offline — messages are queued until it returns'
+                : '',
+            addon && addon.contract !== 2
+                ? `Addon contract ${addon.contract} is not supported`
+                : '',
+            addon
+                ? (latestLine(addon) ?? 'You have not sent a message to this addon.')
+                : '',
+        ]
+            .filter(Boolean)
+            .join(' · ') || undefined);
+    }
+    select(index, context) {
+        const next = Math.max(0, Math.min(index, this.entries().length - 1));
+        if (next === this.cursor.index)
+            return false;
+        this.cursor.index = next;
+        context.requestDraw();
+        return true;
+    }
+    activate(index, context) {
+        return this.run(index, context);
+    }
+    /** Runs an entry's message: sends it, or opens its form. */
+    run(index, context) {
+        const entry = this.entries()[index];
+        const addon = this.addon();
+        const data = this.readyValue;
+        if (!entry || !addon || !data)
+            return false;
+        const ticketUuid = ticketUuidOf(context, data.ticket);
+        const { message } = entry;
+        if (message.input) {
+            const state = {
+                ticketUuid,
+                addon: addon.name,
+                key: message.key,
+                label: message.label,
+                input: message.input,
+            };
+            context.navigate?.('ticket.addons.action', { ticketId: context.params?.ticketId ?? ticketUuid }, state);
+            return true;
+        }
+        const client = context.services?.client;
+        if (!client)
+            return false;
+        runRowAction({
+            rowId: entry.id,
+            busy: this.sending,
+            context,
+            perform: async () => {
+                await sendAddonAction(client, ticketUuid, `${addon.name}.${message.key}`, {});
+                return { message: `${message.label} sent` };
+            },
+            refresh: (ctx) => this.retry(ctx),
+            setStatus: (status) => {
+                this.toast = status;
+            },
+            captureLifecycle: () => this.captureLifecycle(context),
+            lifecycleIsCurrent: (guard, ctx) => this.lifecycleIsCurrent(guard, ctx),
+            statusIsCurrent: (guard, ctx) => this.actionStillCurrent(guard, ctx),
+            failPrefix: `${addon.name}.${message.key} failed`,
+        });
+        return true;
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
+        const data = this.readyValue;
+        if (this.state !== 'ready' || !data)
+            return false;
+        const count = data.model.addons.length;
+        if ((input === 'left' || input === 'right') && count > 1) {
+            this.selected =
+                (this.selected + (input === 'right' ? 1 : -1) + count) % count;
+            this.cursor.reset();
+            this.schedulePoll(context);
+            context.requestDraw();
+            return true;
+        }
+        if (input === 'enter' || input === ' ')
+            return this.run(this.cursor.index, context);
+        if (input === 'l') {
+            const addon = this.addon();
+            const markdown = addon ? latestMarkdown(addon) : undefined;
+            const href = markdown ? firstHttpLink(markdown) : undefined;
+            this.toast = copyThrough(context.copyToClipboard, href, href ?? '', 'no link in the latest answer');
+            context.requestDraw();
+            return true;
+        }
+        const entries = this.entries().length;
+        if (entries > 1) {
+            const before = this.cursor.index;
+            if (this.cursor.handle(input, entries) && this.cursor.index !== before) {
+                context.requestDraw();
+                return true;
+            }
+        }
+        return false;
+    }
+    commandForInput(input) {
+        return this.state === 'ready' && input === 'e'
+            ? 'edit-assignment'
+            : undefined;
+    }
+    actionForInput(input, context) {
+        return this.commandForInput(input)
+            ? ticketEditAction(context, this.readyValue?.ticket)
+            : undefined;
+    }
+    receiveResult(result, context) {
+        const returned = result;
+        if (returned?.type === 'addon-action-sent') {
+            this.toast = returned.message ?? '';
+            this.reload(context);
+        }
+    }
+}
+/** The form of an action with input, built from its input subset. */
+export class AddonActionFormScreen extends AsyncModalScreen {
+    static route = {
+        id: 'ticket.addons.action',
+        path: '/tickets/:ticketId/addons/action',
+        parent: 'ticket.addons',
+        presentation: 'modal',
+    };
+    id = AddonActionFormScreen.route.id;
+    target;
+    form;
+    values;
+    errors = {};
+    sending = false;
+    async load(context) {
+        const target = context.navigationState;
+        if (!target?.input)
+            throw new Error('No addon action to fill in');
+        this.target = target;
+        this.form = addonForm(target.input);
+        const options = {};
+        for (const field of formFields(target.input))
+            if (field.options)
+                options[field.id] = field.options;
+        return options;
+    }
+    didLoad(options) {
+        if (!this.form || !this.target)
+            return;
+        const prefill = {};
+        for (const [id, field] of Object.entries(this.target.input.properties)) {
+            if (field.type === 'boolean')
+                prefill[id] = field.default === true ? 'yes' : 'no';
+            else if (field.default !== undefined)
+                prefill[id] = String(field.default);
+        }
+        this.values = this.form.initial(options, prefill);
+    }
+    renderLoading() {
+        return ['Loading…'];
+    }
+    renderReady(options) {
+        if (!this.form || !this.values)
+            return columnNode(FIELDS_REGION);
+        return renderDeclaredFieldsTree(this.form.fields, this.values, options, {
+            width: 58,
+            errorFor: (field) => this.errors[field.id],
+        });
+    }
+    modalChrome() {
+        return { title: this.target?.label ?? 'Addon action' };
+    }
+    actions() {
+        return [
+            actionItem('addon-form-field', '↑↓', 'field'),
+            actionItem('addon-form-send', 'Ctrl+S', 'send'),
+            actionItem('addon-form-esc', 'Esc', 'cancel'),
+        ];
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
+        const options = this.readyValue;
+        if (!options || !this.form || !this.values)
+            return false;
+        const intent = keyToIntent(input, this.form.activeField(this.values));
+        if (!intent)
+            return true;
+        if (intent.kind === 'cancel') {
+            context.back?.();
+            return true;
+        }
+        if (intent.kind === 'submit') {
+            void this.submit(context);
+            return true;
+        }
+        this.values = this.form.apply(this.values, options, intent);
+        context.requestDraw();
+        return true;
+    }
+    async submit(context) {
+        const target = this.target;
+        const client = context.services?.client;
+        if (!target || !client || !this.values || this.sending)
+            return;
+        const outcome = payloadFrom(target.input, this.values);
+        if ('errors' in outcome) {
+            this.errors = outcome.errors;
+            context.requestDraw();
+            return;
+        }
+        this.errors = {};
+        this.sending = true;
+        try {
+            await sendAddonAction(client, target.ticketUuid, `${target.addon}.${target.key}`, outcome.payload);
+            context.back?.({
+                type: 'addon-action-sent',
+                message: `${target.label} sent`,
+            });
+        }
+        catch (error) {
+            this.toast = error instanceof Error ? error.message : String(error);
+            context.requestDraw();
+        }
+        finally {
+            this.sending = false;
+        }
+    }
+    notice() {
+        return this.toast || undefined;
+    }
+    reset() {
+        this.target = undefined;
+        this.form = undefined;
+        this.values = undefined;
+        this.errors = {};
+        this.sending = false;
+        super.reset();
+    }
+}

package/dist/src/Entity/ticket/Screen/ticket-content-screen.d.ts

@@ -18,12 +18,16 @@ export declare abstract class TicketContentScreen extends AsyncScreen<TicketDeta
     private initializedKey;
     protected labels: AssignmentLabels | undefined;
     private status;
+    private readonly freezeBusy;
     private releaseStore;
     private expanded;
     protected viewMode: UiViewMode;
     /** Visit-local: the sidebar pane and Planning document tab last chosen. */
     private sidebarTab;
     private documentKey;
+    /** Overview only (GAIA-661); a stale load after navigating away is dropped. */
+    private addonsPreview;
+    private addonsPreviewGeneration;
     private modelMemo;
     compact(): boolean;
     get document(): TicketDetailDocument | undefined;
@@ -37,6 +41,8 @@ export declare abstract class TicketContentScreen extends AsyncScreen<TicketDeta
     contentProps(context: ScreenContext): TicketContentProps;
     reload(context: ScreenContext): void;
     enter(context: ScreenContext): void;
+    /** The inline card's data (GAIA-661); Overview only, loaded once per visit. */
+    private loadAddonsPreview;
     leave(): void;
     protected load(context: ScreenContext): Promise<TicketDetailDocument>;
     protected didLoad(document: TicketDetailDocument, context: ScreenContext): void;
@@ -45,8 +51,23 @@ export declare abstract class TicketContentScreen extends AsyncScreen<TicketDeta
     };
     restoreState(token: unknown): void;
     setLabels(labels: AssignmentLabels | undefined): void;
+    /**
+     * The model's selectable keys, plus the inline addons card's row (GAIA-661
+     * D1) when the Overview preview has a message worth reaching: a Tab/arrow
+     * visit stops there and Enter opens the full send/poll screen, the same
+     * keyboard reach the Details/Stats/Related sidebar card already has via its
+     * own (Technical details) row.
+     */
+    private selectableKeys;
+    private openAddons;
     select(index: number, context: ScreenContext): boolean;
     activate(index: number, context: ScreenContext): boolean;
+    private isFrozen;
+    /**
+     * PATCH `frozen` through the write client, then re-read on the session
+     * client so the ladder and document agree with the server.
+     */
+    private toggleFrozen;
     handleInput(input: string, context: ScreenContext): boolean;
     commandForInput(input: string): string | undefined;
     actionForInput(input: string, context: ScreenContext): ScreenAction | undefined;