@xingular/harness 0.1.6 → 1.0.0

package/dist/sdk/terminal/tui/pageOverlay.js

@@ -0,0 +1,145 @@
+import { matchesKey } from '@earendil-works/pi-tui';
+import { CENTER_DIALOG_PAD, CHROME_PAD, centerDialogBodyRows, centerDialogContentWidth, centerDialogFrame, centerDialogVerticalPad, contentWidth, pageBodyRows, pageFrame, tabIndexAt, tabStrip } from "./chrome.js";
+import { centeredDialogHost, dialogFits, pageRows } from "./dialogGeometry.js";
+export class PageOverlay {
+    options;
+    focusedValue = false;
+    disposed = false;
+    pointerLayout;
+    hoveredTab;
+    constructor(options) {
+        this.options = options;
+        options.page.activate?.();
+    }
+    get page() { return this.options.page; }
+    get focused() { return this.focusedValue; }
+    set focused(value) {
+        this.focusedValue = value;
+        if (this.options.page.focused !== undefined)
+            this.options.page.focused = value;
+    }
+    invalidate() { }
+    handleMouse(event) {
+        if (this.disposed)
+            return undefined;
+        if (event.type === 'wheel') {
+            const key = event.wheelDelta !== undefined && event.wheelDelta < 0 ? '\x1b[5~' : '\x1b[6~';
+            this.handleInput(key);
+            return { handled: true, render: true };
+        }
+        if (event.type !== 'move' && event.type !== 'click')
+            return undefined;
+        if (event.type === 'click' && event.button !== 'left')
+            return undefined;
+        const layout = this.pointerLayout;
+        if (!layout)
+            return undefined;
+        const tabs = this.options.page.tabs();
+        const tabX = event.x - layout.contentX;
+        if (layout.tabRow !== undefined && event.y === layout.tabRow && tabs.length > 1) {
+            const tabIndex = tabIndexAt(tabs, layout.contentWidth, tabX);
+            const current = tabs.findIndex(tab => tab.id === this.options.page.activeTab());
+            if (event.type === 'move') {
+                const nextHover = tabIndex === undefined ? undefined : tabs[tabIndex]?.id;
+                if (nextHover === this.hoveredTab)
+                    return { handled: true, render: false };
+                this.hoveredTab = nextHover;
+                return { handled: true, render: true };
+            }
+            const target = tabIndex ?? (tabX < layout.contentWidth / 2
+                ? (current - 1 + tabs.length) % tabs.length
+                : (current + 1) % tabs.length);
+            const delta = (target - Math.max(0, current) + tabs.length) % tabs.length;
+            const reverse = (Math.max(0, current) - target + tabs.length) % tabs.length;
+            const direction = delta <= reverse ? '\t' : '\x1b[Z';
+            const steps = Math.min(delta, reverse);
+            for (let index = 0; index < steps; index += 1)
+                this.options.page.handleInput(direction);
+            this.hoveredTab = undefined;
+            return { handled: true, render: true };
+        }
+        let hoverChanged = false;
+        if (event.type === 'move' && this.hoveredTab) {
+            this.hoveredTab = undefined;
+            hoverChanged = true;
+        }
+        if (event.y < layout.bodyStart)
+            return hoverChanged ? { handled: true, render: true } : undefined;
+        const handled = this.options.page.handleMouse?.({ ...event, x: tabX, y: event.y - layout.bodyStart });
+        return handled ?? (hoverChanged ? { handled: true, render: true } : undefined);
+    }
+    handleInput(data) {
+        if (this.disposed)
+            return;
+        if (matchesKey(data, 'ctrl+c')) {
+            this.options.close();
+            return;
+        }
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const tabs = this.options.page.tabs();
+        const input = centered && tabs.length > 1
+            ? matchesKey(data, 'right') ? '\t' : matchesKey(data, 'left') ? '\x1b[Z' : data
+            : data;
+        if (this.options.page.handleInput(input)) {
+            this.options.changed();
+            return;
+        }
+        if (matchesKey(data, 'escape'))
+            this.options.close();
+    }
+    render(width) {
+        if (this.disposed)
+            return [];
+        const rows = pageRows(this.options.tui);
+        const page = this.options.page;
+        const tabs = page.tabs();
+        if (width < 1 || rows < 1 || !tabs.length)
+            return [];
+        const theme = this.options.theme();
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
+        if (centered) {
+            const tabRows = tabs.length > 1 ? 1 : 0;
+            const bodyStart = centerDialogVerticalPad(rows) + 2 + tabRows;
+            this.pointerLayout = {
+                tabRow: tabRows ? bodyStart - 1 : undefined,
+                bodyStart,
+                contentX: CENTER_DIALOG_PAD,
+                contentWidth: inner,
+                centered
+            };
+            const body = [
+                ...(tabRows ? [tabStrip(tabs, page.activeTab(), inner, theme, 'top', this.hoveredTab)] : []),
+                ...page.render(inner, Math.max(0, centerDialogBodyRows(rows) - tabRows))
+            ];
+            return centerDialogFrame({ title: tabs.find(tab => tab.id === page.activeTab())?.title ?? 'Page', body, width, rows, theme });
+        }
+        this.pointerLayout = {
+            tabRow: 0,
+            bodyStart: 2,
+            contentX: CHROME_PAD,
+            contentWidth: contentWidth(width),
+            centered
+        };
+        const footer = [
+            page.hint(),
+            tabs.length > 1 ? 'Tab/Shift+Tab sections' : '',
+            'Esc close'
+        ].filter(Boolean).join(' · ');
+        return pageFrame({
+            title: '',
+            headerLine: tabStrip(tabs, page.activeTab(), inner, theme, 'top', this.hoveredTab),
+            body: page.render(inner, pageBodyRows(rows)),
+            footer,
+            width,
+            rows,
+            theme
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.options.page.dispose?.();
+    }
+}

package/dist/sdk/terminal/tui/pages/accountsPage.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The Accounts page: one row per account with its health, the selected account's details beneath,
+ * and Pools as a second section. Enter on an account opens its actions; the actions themselves are
+ * the ones the `/accounts` menu of a native `pi` session uses.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type AccountsCall, type AccountsUi, type SessionAccount } from "../../accountsMenu.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface AccountsPageOptions {
+    theme: () => Theme;
+    call: AccountsCall;
+    /** The account this session runs on. */
+    session: () => SessionAccount | null;
+    ui: AccountsUi;
+    /** The session is switching accounts: the host ends it so the launcher can start it again. */
+    relaunch(): void;
+    changed(): void;
+}
+export declare class AccountsPage implements TerminalPage {
+    private readonly options;
+    private overview;
+    private error;
+    private section;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: AccountsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly [{
+        readonly id: "accounts";
+        readonly title: "Accounts";
+    }, {
+        readonly id: "pools";
+        readonly title: "Pools";
+    }];
+    activeTab(): string;
+    hint(): string;
+    private reload;
+    /** Searching looks through accounts and pools together; otherwise the page shows the current section. */
+    private fill;
+    private accountRows;
+    private poolRows;
+    private account;
+    /** Runs one thing at a time and always reads the accounts again afterwards. */
+    private guarded;
+    private activateRow;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

package/dist/sdk/terminal/tui/pages/accountsPage.js

@@ -0,0 +1,181 @@
+import { matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import { HEALTH, accountActions, accountDetails, addAccount, editPool, runAccountAction } from "../../accountsMenu.js";
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [{ id: 'accounts', title: 'Accounts' }, { id: 'pools', title: 'Pools' }];
+const ADD = 'action:add';
+const CHECK_ALL = 'action:check-all';
+const NEW_POOL = 'action:new-pool';
+const BACK = 'Back';
+const HEALTH_TONE = { ok: 'success', limited: 'warning', auth_expired: 'error', signed_out: 'error', error: 'error', unknown: 'dim' };
+export class AccountsPage {
+    options;
+    overview;
+    error;
+    section = 'accounts';
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['row', 'rows'], empty: 'Nothing here yet',
+            searchContext: () => 'accounts and pools',
+            onActivate: row => { void this.activateRow(row); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() { void this.reload(); }
+    dispose() { this.disposed = true; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    hint() { return this.list.query ? 'Enter open · Esc clear' : 'Enter actions · type to search'; }
+    async reload() {
+        try {
+            this.overview = await this.options.call('accounts.list');
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    /** Searching looks through accounts and pools together; otherwise the page shows the current section. */
+    fill() {
+        this.list.setRows(this.list.query ? [...this.accountRows(), ...this.poolRows()] : this.section === 'accounts' ? this.accountRows() : this.poolRows());
+    }
+    accountRows() {
+        const overview = this.overview;
+        if (!overview)
+            return [];
+        const session = this.options.session();
+        const accounts = overview.accounts.map(account => ({
+            id: `account:${account.id}`, group: 'Accounts',
+            label: `${account.isDefault ? '●' : '○'} ${safeText(account.label)}`,
+            detail: `${HEALTH[account.state.health] ?? HEALTH.unknown}${session?.accountId === account.id ? ' · this session' : ''}`,
+            tone: HEALTH_TONE[account.state.health] ?? 'dim',
+            searchText: `${account.label} ${account.state.identity ?? ''} ${HEALTH[account.state.health] ?? ''}`
+        }));
+        return [
+            ...accounts,
+            { id: ADD, label: '+ Add account', group: 'Actions', tone: 'accent' },
+            { id: CHECK_ALL, label: '⟳ Check all accounts', group: 'Actions', tone: 'accent' }
+        ];
+    }
+    poolRows() {
+        const overview = this.overview;
+        if (!overview)
+            return [];
+        const names = new Map(overview.accounts.map(account => [account.id, account.label]));
+        return [
+            ...overview.pools.map(pool => ({
+                id: `pool:${pool.id}`, group: 'Pools', label: safeText(pool.label),
+                detail: pool.accountIds.map(id => names.get(id) ?? 'removed account').join(' → '), tone: 'muted'
+            })),
+            { id: NEW_POOL, label: '+ New pool', group: 'Actions', tone: 'accent' }
+        ];
+    }
+    account(id) { return this.overview?.accounts.find(account => `account:${account.id}` === id); }
+    /** Runs one thing at a time and always reads the accounts again afterwards. */
+    async guarded(work) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            await work();
+        }
+        catch (error) {
+            this.options.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    activateRow(row) {
+        return this.guarded(async () => {
+            const { ui, call } = this.options;
+            const overview = this.overview;
+            if (!overview)
+                return;
+            if (row.id === ADD) {
+                await addAccount(ui, call);
+                return;
+            }
+            if (row.id === CHECK_ALL) {
+                try {
+                    await call('accounts.refresh');
+                }
+                catch (error) {
+                    ui.notify(error instanceof Error ? error.message : String(error), 'error');
+                }
+                return;
+            }
+            if (row.id === NEW_POOL) {
+                await editPool(ui, call, overview, null);
+                return;
+            }
+            const pool = overview.pools.find(candidate => `pool:${candidate.id}` === row.id);
+            if (pool) {
+                const action = await ui.select(pool.label, ['Edit', 'Delete', BACK]);
+                if (action === 'Edit')
+                    await editPool(ui, call, overview, pool);
+                else if (action === 'Delete' && await ui.confirm(`Delete ${pool.label}?`, 'The accounts stay. Only the pool is removed.')) {
+                    try {
+                        await call('accounts.removePool', { poolId: pool.id });
+                    }
+                    catch (error) {
+                        ui.notify(error instanceof Error ? error.message : String(error), 'error');
+                    }
+                }
+                return;
+            }
+            const account = this.account(row.id);
+            if (!account)
+                return;
+            const isSession = this.options.session()?.accountId === account.id;
+            const action = await ui.select(`${account.label} · ${HEALTH[account.state.health] ?? HEALTH.unknown}`, [...accountActions(account, isSession, false), BACK]);
+            if (!action || action === BACK)
+                return;
+            const outcome = await runAccountAction(ui, call, overview, account, action);
+            if (outcome === 'relaunch')
+                this.options.relaunch();
+        });
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                this.section = this.section === 'accounts' ? 'pools' : 'accounts';
+                this.fill();
+            }
+            return true;
+        }
+        const before = this.list.query;
+        const used = this.list.handleInput(data);
+        if (this.list.query !== before)
+            this.fill();
+        return used;
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.overview)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? `Could not read accounts: ${this.error}` : 'Reading accounts…')];
+        const selected = this.section === 'accounts' ? this.account(this.list.selected?.id ?? '') : undefined;
+        const details = selected ? accountDetails(selected).split('\n').slice(1) : [];
+        // The list gets the rows it needs first; the details take what is left.
+        const detailRows = Math.min(details.length, 9, Math.max(0, rows - 2 - this.list.height));
+        const lines = this.list.render(width, Math.max(2, rows - 1 - (detailRows ? detailRows + 1 : 0)));
+        if (detailRows)
+            lines.push('', ...details.slice(0, detailRows).map(line => theme.fg('muted', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/componentsPage.d.ts

@@ -0,0 +1,47 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type ComponentItem } from "../../../variant/components.js";
+import type { MenuUi } from "../../pluginMenu.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface ComponentLibrarySnapshot {
+    items: ComponentItem[];
+    addedIds: string[];
+    writable: boolean;
+    fingerprint: string | null;
+}
+export interface ComponentAddedResult {
+    fingerprint: string;
+    alreadyPresent: boolean;
+}
+export type ComponentPageCall = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>;
+export interface ComponentsPageOptions {
+    theme: () => Theme;
+    call: ComponentPageCall;
+    ui: MenuUi;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class ComponentsPage implements TerminalPage {
+    private readonly options;
+    private snapshot;
+    private section;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: ComponentsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    activate(): void;
+    dispose(): void;
+    hint(): string;
+    private load;
+    private fill;
+    private add;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

package/dist/sdk/terminal/tui/pages/componentsPage.js

@@ -0,0 +1,119 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'skills', title: 'Skills' },
+    { id: 'prompts', title: 'Prompts' },
+    { id: 'rules', title: 'Rules' }
+];
+export class ComponentsPage {
+    options;
+    snapshot;
+    section = 'skills';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['item', 'items'], empty: 'This library section is empty.',
+            onActivate: row => { void this.add(row.data); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    activate() { if (!this.snapshot)
+        void this.load(); }
+    dispose() { this.disposed = true; }
+    hint() { return this.list.query ? 'Enter add · Esc clear' : 'Enter add eligible item · type to search'; }
+    async load() {
+        try {
+            this.snapshot = await this.options.call('terminal.components.list');
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        const items = (this.snapshot?.items ?? []).filter(item => item.kind === this.section);
+        const added = new Set(this.snapshot?.addedIds ?? []);
+        this.list.setRows(items.map(item => {
+            const exists = added.has(item.id);
+            const detail = exists ? 'In Harness' : item.kind === 'prompts' ? 'Library only' : this.snapshot?.writable ? 'Add for next session' : 'Browse only';
+            return {
+                id: item.id, label: safeText(item.name), group: item.builtin ? 'Built-in' : 'Library',
+                detail, tone: exists ? 'success' : item.kind === 'prompts' ? 'dim' : 'muted',
+                searchText: item.name + ' ' + item.description + ' ' + item.id, data: item
+            };
+        }));
+    }
+    async add(item) {
+        if (!item || this.busy)
+            return;
+        if (item.kind === 'prompts') {
+            this.options.notify('Prompts stay in the library and cannot be added to a Variant.', 'info');
+            return;
+        }
+        if ((this.snapshot?.addedIds ?? []).includes(item.id)) {
+            this.options.notify('This item is already in the current Variant.', 'info');
+            return;
+        }
+        if (!this.snapshot?.writable) {
+            this.options.notify('This terminal has no writable Harness scope. The library is browse-only.', 'warning');
+            return;
+        }
+        const approved = await this.options.ui.confirm('Add ' + item.name + '?', 'This creates a new Variant version for the next session. The running terminal keeps its pinned version.');
+        if (!approved)
+            return;
+        this.busy = true;
+        try {
+            const result = await this.options.call('terminal.components.add', { id: item.id });
+            this.options.notify(result.alreadyPresent ? 'This item is already in the current Variant.' : 'Saved for the next session · version ' + result.fingerprint, 'info');
+            await this.load();
+        }
+        catch (error) {
+            this.options.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                const at = SECTIONS.findIndex(section => section.id === this.section);
+                const delta = matchesKey(data, 'shift+tab') ? -1 : 1;
+                this.section = SECTIONS[(at + delta + SECTIONS.length) % SECTIONS.length].id;
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.snapshot)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? 'Could not read the component library: ' + this.error : 'Reading the component library…')];
+        const selected = this.list.selected?.data;
+        const detail = selected && rows >= 8
+            ? wrapTextWithAnsi(safeText(selected.description || 'No description.'), width).slice(0, Math.min(3, rows - 4))
+            : [];
+        const lines = this.list.render(width, Math.max(2, rows - (detail.length ? detail.length + 1 : 0)));
+        if (detail.length)
+            lines.push('', ...detail.map(line => theme.fg('muted', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/doctorPage.d.ts

@@ -0,0 +1,37 @@
+import type { Theme, ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { TerminalPage } from "../page.js";
+import type { TabInfo } from "../chrome.js";
+interface DoctorPageOptions {
+    theme(): Theme;
+    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    selection(): {
+        model: string | null;
+        tools: string[];
+    };
+    confirm: ExtensionUIContext['confirm'];
+    select: ExtensionUIContext['select'];
+    changed(): void;
+}
+export declare class DoctorPage implements TerminalPage {
+    private readonly options;
+    focused: boolean;
+    private report?;
+    private error?;
+    private timer?;
+    private disposed;
+    private busy;
+    private offset;
+    constructor(options: DoctorPageOptions);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    activate(): void;
+    dispose(): void;
+    private start;
+    private poll;
+    private chooseLive;
+    private retry;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}
+export {};