@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/integrations/pi/components/models-dialog.js

@@ -0,0 +1,310 @@
+import { Input, Key, getKeybindings, matchesKey, truncateToWidth, } from "@earendil-works/pi-tui";
+import { piTheme } from "./theme.js";
+const MAX_VISIBLE_ROWS = 10;
+const MODELS_TITLE = "Models";
+function fullModelId(model) {
+    return `${model.provider}/${model.id}`;
+}
+function sameOrder(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function matchesQuery(model, query) {
+    const normalized = query.trim().toLowerCase();
+    if (normalized.length === 0)
+        return true;
+    return `${model.id} ${model.name} ${model.provider} ${fullModelId(model)}`.toLowerCase().includes(normalized);
+}
+function keyLabel(action) {
+    return getKeybindings().getKeys(action)
+        .map(key => key.split("+").map(part => process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part).join("+"))
+        .join("/");
+}
+/**
+ * Bare A1's one model-management dialog: a searchable catalog with `all`/`scoped` filters where
+ * Enter switches the active model, Space edits the session's cycling scope, and Ctrl+S persists
+ * that scope. The component owns only presentation state (query, filter, selection, desired and
+ * saved scope, refresh status); every switch, scope write, and save goes through its callbacks.
+ */
+export class ModelsDialogComponent {
+    #input = new Input();
+    #callbacks;
+    #models = [];
+    #activeModelId;
+    #scopeIds;
+    #savedScopeIds;
+    #filter;
+    #selectedIndex = 0;
+    #preferredId;
+    #refreshStatus;
+    #disposed = false;
+    #focused = false;
+    constructor(config, callbacks) {
+        this.#callbacks = callbacks;
+        this.#activeModelId = config.activeModelId;
+        this.#scopeIds = [...config.scopeIds];
+        this.#savedScopeIds = [...config.savedScopeIds];
+        this.#filter = config.initialFilter ?? "all";
+        this.#refreshStatus = config.refreshStatus === undefined ? undefined : { message: config.refreshStatus, kind: "muted" };
+        if (config.initialQuery)
+            this.#input.setValue(config.initialQuery);
+        this.#replaceModels(config.models);
+        const rows = this.#rows();
+        const activeIndex = rows.findIndex(row => row.fullId === this.#activeModelId);
+        this.#selectedIndex = activeIndex >= 0 ? activeIndex : 0;
+    }
+    get focused() {
+        return this.#focused;
+    }
+    set focused(value) {
+        this.#focused = value;
+        this.#input.focused = value;
+    }
+    /** True while the desired scope or order differs from the last successful save. */
+    get dirty() {
+        return !sameOrder(this.#scopeIds, this.#savedScopeIds);
+    }
+    get filter() {
+        return this.#filter;
+    }
+    get query() {
+        return this.#input.getValue();
+    }
+    get scopeIds() {
+        return [...this.#scopeIds];
+    }
+    get selectedModelId() {
+        return this.#rows()[this.#selectedIndex]?.fullId;
+    }
+    /** Replace the catalog after a refresh; query, filter, surviving selection, scope edits, and dirty state stay. */
+    updateModels(models) {
+        const selectedId = this.selectedModelId;
+        this.#replaceModels(models);
+        this.#restoreSelection(selectedId);
+    }
+    setRefreshStatus(message, kind) {
+        this.#refreshStatus = { message, kind };
+    }
+    dispose() {
+        this.#disposed = true;
+    }
+    invalidate() {
+        this.#input.invalidate();
+    }
+    handleInput(data) {
+        const kb = getKeybindings();
+        const rows = this.#rows();
+        this.#clampSelection(rows);
+        const selected = rows[this.#selectedIndex];
+        // Rationale: an emptied filter keeps the last highlighted model so switching filters lands back on it.
+        const preferredId = selected?.fullId ?? this.#preferredId;
+        this.#preferredId = preferredId;
+        if (kb.matches(data, "tui.select.up")) {
+            if (rows.length > 0)
+                this.#selectedIndex = this.#selectedIndex === 0 ? rows.length - 1 : this.#selectedIndex - 1;
+            return;
+        }
+        if (kb.matches(data, "tui.select.down")) {
+            if (rows.length > 0)
+                this.#selectedIndex = this.#selectedIndex === rows.length - 1 ? 0 : this.#selectedIndex + 1;
+            return;
+        }
+        if (kb.matches(data, "tui.input.tab")) {
+            this.#filter = this.#filter === "all" ? "scoped" : "all";
+            this.#restoreSelection(preferredId);
+            return;
+        }
+        if (data === " ") {
+            if (selected)
+                this.#setScope(this.#scopeIds.includes(selected.fullId)
+                    ? this.#scopeIds.filter(id => id !== selected.fullId)
+                    : [...this.#scopeIds, selected.fullId], selected.fullId);
+            return;
+        }
+        if (kb.matches(data, "tui.select.confirm")) {
+            if (selected)
+                this.#callbacks.onSelect(selected.fullId);
+            return;
+        }
+        if (kb.matches(data, "app.models.save")) {
+            this.#save();
+            return;
+        }
+        if (kb.matches(data, "app.models.enableAll")) {
+            const targets = this.#bulkTargets(rows);
+            this.#setScope([...this.#scopeIds, ...targets.filter(id => !this.#scopeIds.includes(id))], selected?.fullId);
+            return;
+        }
+        if (kb.matches(data, "app.models.clearAll")) {
+            const targets = new Set(this.#bulkTargets(rows));
+            this.#setScope(this.#scopeIds.filter(id => !targets.has(id)), selected?.fullId);
+            return;
+        }
+        if (kb.matches(data, "app.models.toggleProvider")) {
+            if (!selected)
+                return;
+            const providerIds = this.#models.filter(model => model.provider === selected.model.provider).map(fullModelId);
+            const allScoped = providerIds.every(id => this.#scopeIds.includes(id));
+            this.#setScope(allScoped
+                ? this.#scopeIds.filter(id => !providerIds.includes(id))
+                : [...this.#scopeIds, ...providerIds.filter(id => !this.#scopeIds.includes(id))], selected.fullId);
+            return;
+        }
+        const reorderUp = kb.matches(data, "app.models.reorderUp");
+        if (reorderUp || kb.matches(data, "app.models.reorderDown")) {
+            if (!selected)
+                return;
+            const index = this.#scopeIds.indexOf(selected.fullId);
+            const target = index + (reorderUp ? -1 : 1);
+            if (index < 0 || target < 0 || target >= this.#scopeIds.length)
+                return;
+            const next = [...this.#scopeIds];
+            next[index] = next[target];
+            next[target] = selected.fullId;
+            this.#setScope(next, selected.fullId);
+            return;
+        }
+        if (matchesKey(data, Key.ctrl("c"))) {
+            if (this.#input.getValue().length > 0) {
+                this.#input.setValue("");
+                this.#selectedIndex = 0;
+                return;
+            }
+            this.#callbacks.onCancel();
+            return;
+        }
+        if (kb.matches(data, "tui.select.cancel")) {
+            this.#callbacks.onCancel();
+            return;
+        }
+        const before = this.#input.getValue();
+        this.#input.handleInput(data);
+        if (this.#input.getValue() !== before)
+            this.#selectedIndex = 0;
+    }
+    render(width) {
+        const theme = piTheme();
+        const lines = [];
+        const push = (line = "") => { lines.push(truncateToWidth(line, width)); };
+        const border = theme.fg("border", "─".repeat(Math.max(1, width)));
+        const rows = this.#rows();
+        this.#clampSelection(rows);
+        push(border);
+        push();
+        push(theme.fg("accent", theme.bold(MODELS_TITLE)) + (this.dirty ? theme.fg("warning", " (unsaved)") : ""));
+        push(theme.fg("dim", "Filter: ")
+            + theme.fg(this.#filter === "all" ? "accent" : "dim", "all")
+            + theme.fg("dim", " | ")
+            + theme.fg(this.#filter === "scoped" ? "accent" : "dim", "scoped"));
+        push();
+        for (const line of this.#input.render(width))
+            push(line);
+        push();
+        if (rows.length === 0) {
+            push(theme.fg("muted", `  ${this.#emptyText()}`));
+        }
+        else {
+            const startIndex = Math.max(0, Math.min(this.#selectedIndex - Math.floor(MAX_VISIBLE_ROWS / 2), rows.length - MAX_VISIBLE_ROWS));
+            const endIndex = Math.min(startIndex + MAX_VISIBLE_ROWS, rows.length);
+            for (let index = startIndex; index < endIndex; index += 1) {
+                const row = rows[index];
+                const selected = index === this.#selectedIndex;
+                const scoped = this.#scopeIds.includes(row.fullId);
+                // Invariant: arrow, scope marker, model id, [provider], then the active checkmark, in that order.
+                const prefix = selected ? theme.fg("accent", "→ ") : "  ";
+                const marker = scoped ? theme.fg("success", "●") : theme.fg("dim", "○");
+                const label = selected ? theme.fg("accent", row.model.id) : row.model.id;
+                const provider = theme.fg("muted", `[${row.model.provider}]`);
+                const active = row.fullId === this.#activeModelId ? ` ${theme.fg("success", "✓")}` : "";
+                push(`${prefix}${marker} ${label} ${provider}${active}`);
+            }
+            if (startIndex > 0 || endIndex < rows.length)
+                push(theme.fg("muted", `  (${this.#selectedIndex + 1}/${rows.length})`));
+            const selectedRow = rows[this.#selectedIndex];
+            if (selectedRow) {
+                push();
+                push(theme.fg("muted", `  Model Name: ${selectedRow.model.name}`));
+            }
+        }
+        push();
+        if (this.#refreshStatus !== undefined)
+            push(theme.fg(this.#refreshStatus.kind, `  ${this.#refreshStatus.message}`));
+        push(theme.fg("dim", `  ${this.#hints().join(" · ")}`));
+        push(border);
+        return lines;
+    }
+    #hints() {
+        const tab = keyLabel("tui.input.tab");
+        const confirm = keyLabel("tui.select.confirm");
+        const save = keyLabel("app.models.save");
+        return [
+            "type to search",
+            "↑↓ navigate",
+            ...(tab.length === 0 ? [] : [`${tab} filter`]),
+            ...(confirm.length === 0 ? [] : [`${confirm} switch`]),
+            "space scope",
+            ...(save.length === 0 ? [] : [`${save} save`]),
+            "esc close",
+        ];
+    }
+    #emptyText() {
+        if (this.#input.getValue().trim().length > 0)
+            return "No matching models";
+        if (this.#filter === "scoped")
+            return "No scoped models";
+        return "No models available. Use /login to add providers.";
+    }
+    #replaceModels(models) {
+        this.#models = [...models].sort((left, right) => left.provider.localeCompare(right.provider) || left.id.localeCompare(right.id));
+    }
+    #rows() {
+        const query = this.#input.getValue();
+        const byId = new Map(this.#models.map(model => [fullModelId(model), model]));
+        const ordered = this.#filter === "scoped"
+            // Rationale: the scoped view lists the desired cycling order, then saved members removed in this session so they can be restored.
+            ? [...this.#scopeIds, ...this.#savedScopeIds.filter(id => !this.#scopeIds.includes(id))].flatMap(id => {
+                const model = byId.get(id);
+                return model === undefined ? [] : [model];
+            })
+            : this.#models;
+        return ordered.filter(model => matchesQuery(model, query)).map(model => ({ fullId: fullModelId(model), model }));
+    }
+    #bulkTargets(rows) {
+        // Compatibility: like the pinned scoped selector, a live search narrows bulk actions to the visible rows.
+        return this.#input.getValue().length > 0 || this.#filter === "scoped" ? rows.map(row => row.fullId) : this.#models.map(fullModelId);
+    }
+    #clampSelection(rows) {
+        this.#selectedIndex = Math.min(this.#selectedIndex, Math.max(0, rows.length - 1));
+    }
+    #restoreSelection(fullId) {
+        const rows = this.#rows();
+        const index = fullId === undefined ? -1 : rows.findIndex(row => row.fullId === fullId);
+        this.#selectedIndex = index >= 0 ? index : Math.min(this.#selectedIndex, Math.max(0, rows.length - 1));
+    }
+    #setScope(next, keepSelected) {
+        if (sameOrder(next, this.#scopeIds))
+            return;
+        this.#scopeIds = [...next];
+        this.#restoreSelection(keepSelected);
+        this.#callbacks.onScopeChange([...this.#scopeIds]);
+    }
+    #save() {
+        const snapshot = [...this.#scopeIds];
+        let outcome;
+        try {
+            outcome = this.#callbacks.onSave(snapshot);
+        }
+        catch {
+            return;
+        }
+        Promise.resolve(outcome).then(() => {
+            if (this.#disposed)
+                return;
+            // Invariant: only the exact snapshot that persisted becomes the baseline; later edits stay dirty.
+            this.#savedScopeIds = snapshot;
+            this.#callbacks.requestRender();
+        }, () => {
+            if (!this.#disposed)
+                this.#callbacks.requestRender();
+        });
+    }
+}

package/dist/integrations/pi/components/owned-editor-ux.d.ts

@@ -0,0 +1,74 @@
+import type { SelectionEditor as Editor } from "./editor-interaction.js";
+import type { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
+import type { PiShellClipboardContent, PiShellEditorTextRange, PiShellPasteReservation } from "./shell-shared-facade.js";
+/**
+ * Middleware boundary around Pi's editor. Interceptors may claim an input or
+ * delegate to the next interceptor/vanilla editor, and may decorate the rows
+ * vanilla Pi renders. This keeps owned UX additions out of the synchronized
+ * Pi editor port and gives future interactions one registration point.
+ */
+export interface OwnedEditorUxInterceptor {
+    handleInput(data: string, next: (data?: string) => void): void;
+    render(width: number, next: () => string[]): string[];
+    reset(): void;
+    handlePointer?(event: OwnedEditorPointerEvent): boolean;
+    hasSelection?(): boolean;
+    ownsPointer?(): boolean;
+    pasteClipboard?(): boolean;
+    cancelPendingPastes?(): void;
+}
+export interface OwnedEditorPointerEvent {
+    readonly kind: "press" | "motion" | "release";
+    readonly button: number;
+    readonly column: number;
+    /** One-based row relative to the top of the editor component. */
+    readonly row: number;
+}
+export declare class OwnedEditorUxInterception {
+    readonly interceptors: readonly OwnedEditorUxInterceptor[];
+    readonly fallback: {
+        handleInput(data: string): void;
+        render(width: number): string[];
+    };
+    constructor(interceptors: readonly OwnedEditorUxInterceptor[], fallback: {
+        handleInput(data: string): void;
+        render(width: number): string[];
+    });
+    handleInput(data: string): void;
+    render(width: number): string[];
+    reset(): void;
+    cancelPendingPastes(): void;
+    handlePointer(event: OwnedEditorPointerEvent): boolean;
+    hasSelection(): boolean;
+    ownsPointer(): boolean;
+    pasteClipboard(): boolean;
+}
+export interface PromptSelectionUxOptions {
+    readonly copyText: (text: string) => void;
+    readonly readClipboardContent: () => Promise<PiShellClipboardContent | null>;
+    readonly beginClipboardPaste?: () => PiShellPasteReservation;
+    readonly beginTextPaste?: (text: string) => PiShellPasteReservation;
+    readonly deferTextPaste?: (text: string) => boolean;
+    readonly onPasteRejected?: (error: unknown) => void;
+    readonly onPasteInput?: (bytes: number, phase: "framing" | "inserting" | "settled") => void;
+    readonly transformPastedContent: (content: PiShellClipboardContent) => string;
+    readonly atomicRanges: (line: string) => readonly PiShellEditorTextRange[];
+    readonly hiddenRanges?: (line: string) => readonly PiShellEditorTextRange[];
+    readonly expandCopiedText: (text: string) => string;
+    readonly paintSelection: (line: string, from: number, to: number, atomic: boolean) => string;
+    /** Row indices restart at zero for each complete decoration pass. */
+    readonly decorateRow: (row: string, width: number, rowIndex: number) => string;
+    readonly requestRender: () => void;
+    readonly getRows: () => number;
+    /** Presentation-only columns reserved before semantic editor text. */
+    readonly promptGeometry?: (width: number, padding: number) => {
+        readonly prefixWidth: number;
+        readonly innerWidth: number;
+        readonly paddingX: number;
+        readonly contentWidth: number;
+        readonly layoutWidth: number;
+    };
+}
+export declare function createPromptSelectionInterceptor(editor: Editor, keybindings: KeybindingsManager, options: PromptSelectionUxOptions): OwnedEditorUxInterceptor;
+/** Shares the existing atomic-aware body layout with prompt/menu composition. */
+export declare function editorVisualLineCount(editor: Editor, width: number): number | undefined;