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

package/dist/integrations/pi/components/shell-selectors-dialogs.js

@@ -0,0 +1,255 @@
+import { ArminComponent, BorderedLoader, DynamicBorder, ExtensionSelectorComponent, getSelectListTheme, LoginDialogComponent, ModelSelectorComponent, OAuthSelectorComponent, SettingsSelectorComponent, ShowImagesSelectorComponent, ThemeSelectorComponent, ThinkingSelectorComponent, UserMessageSelectorComponent, } from "../startup-public.js";
+import { DaxnutsComponent, } from "./upstream/components/daxnuts.js";
+import { EarendilAnnouncementComponent, } from "./upstream/components/earendil-announcement.js";
+import { SessionSelectorComponent, } from "./upstream/components/session-selector.js";
+import { TreeSelectorComponent, } from "./upstream/components/tree-selector.js";
+import { Box, Container, SelectList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { ScopedModelsSelectorComponent, } from "./upstream/components/scoped-models-selector.js";
+import { ModelsDialogComponent, } from "./models-dialog.js";
+import { TrustSelectorComponent, } from "./upstream/components/trust-selector.js";
+import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
+import { componentFromPort, componentPort, createTuiFacade, ensureTheme, isRecord, } from "./shell-shared-facade.js";
+export { createPiShellSkillsSelector } from "./skills-dialog.js";
+export function createPiShellSelector(options) {
+    ensureTheme();
+    const items = options.options.map(toSelectItem);
+    const list = new SelectList(items, options.maxVisible ?? Math.min(PINNED_PI_LAYOUT.selectorMaxVisible, Math.max(1, items.length)), getSelectListTheme());
+    if (options.onSelect !== undefined)
+        list.onSelect = item => options.onSelect?.(item.value);
+    if (options.onCancel !== undefined)
+        list.onCancel = options.onCancel;
+    if (!options.title)
+        return componentPort(list);
+    const container = new Container();
+    container.addChild(new Text(piTheme().fg("accent", piTheme().bold(options.title)), PINNED_PI_LAYOUT.contentPaddingX, 0));
+    container.addChild(list);
+    return componentPort(container, data => list.handleInput(data));
+}
+export function createPiShellSettingsSelector(options) {
+    ensureTheme();
+    // Protocol: one-argument callbacks pass the value; the per-model callbacks carry (provider, modelId[, level]) as a tuple.
+    const change = (name) => (...values) => options.onChange(name, values.length > 1 ? values : values[0]);
+    const callbacks = {
+        onAutoCompactChange: change("onAutoCompactChange"),
+        onShowImagesChange: change("onShowImagesChange"),
+        onImageWidthCellsChange: change("onImageWidthCellsChange"),
+        onAutoResizeImagesChange: change("onAutoResizeImagesChange"),
+        onBlockImagesChange: change("onBlockImagesChange"),
+        onEnableSkillCommandsChange: change("onEnableSkillCommandsChange"),
+        onSteeringModeChange: change("onSteeringModeChange"),
+        onFollowUpModeChange: change("onFollowUpModeChange"),
+        onTransportChange: change("onTransportChange"),
+        onHttpIdleTimeoutMsChange: change("onHttpIdleTimeoutMsChange"),
+        onModelThinkingLevelChange: change("onModelThinkingLevelChange"),
+        onModelThinkingLevelRemove: change("onModelThinkingLevelRemove"),
+        onThemeChange: change("onThemeChange"),
+        onThemePreview: change("onThemePreview"),
+        onHideThinkingBlockChange: change("onHideThinkingBlockChange"),
+        onMermaidRenderingModeChange: change("onMermaidRenderingModeChange"),
+        onShowCacheMissNoticesChange: change("onShowCacheMissNoticesChange"),
+        onCollapseChangelogChange: change("onCollapseChangelogChange"),
+        onEnableInstallTelemetryChange: change("onEnableInstallTelemetryChange"),
+        onDoubleEscapeActionChange: change("onDoubleEscapeActionChange"),
+        onTreeFilterModeChange: change("onTreeFilterModeChange"),
+        onShowHardwareCursorChange: change("onShowHardwareCursorChange"),
+        onEditorPaddingXChange: change("onEditorPaddingXChange"),
+        onOutputPadChange: change("onOutputPadChange"),
+        onAutocompleteMaxVisibleChange: change("onAutocompleteMaxVisibleChange"),
+        onQuietStartupChange: change("onQuietStartupChange"),
+        onDefaultProjectTrustChange: change("onDefaultProjectTrustChange"),
+        onClearOnShrinkChange: change("onClearOnShrinkChange"),
+        onShowTerminalProgressChange: change("onShowTerminalProgressChange"),
+        onTuiModeChange: change("onTuiModeChange"),
+        onFullscreenExitOutputChange: change("onFullscreenExitOutputChange"),
+        onFullscreenScrollbarChange: change("onFullscreenScrollbarChange"),
+        onFullscreenCopyOnSelectChange: change("onFullscreenCopyOnSelectChange"),
+        onWarningsChange: change("onWarningsChange"),
+        onCancel: options.onCancel,
+    };
+    const selector = new SettingsSelectorComponent(options.config, callbacks);
+    const settingsList = selector.getSettingsList();
+    return componentPort(selector, data => settingsList.handleInput(data));
+}
+export function createPiShellModelSelector(options) {
+    ensureTheme();
+    const selector = new ModelSelectorComponent(createTuiFacade(options.runtime), options.currentModel, options.modelRuntime, options.scopedModels, options.onSelect, options.onCancel, options.initialSearchInput, options.onSelectAsDefault, options.defaultModel);
+    return componentPort(selector);
+}
+function toPiScopedModel(model) {
+    const candidate = { provider: model.provider, id: model.id, name: model.name };
+    if (!isPiScopedModel(candidate))
+        throw new TypeError("Pi scoped-model façade rejected malformed model metadata");
+    return candidate;
+}
+function isPiScopedModel(value) {
+    return isRecord(value) && typeof value.provider === "string" && typeof value.id === "string" && typeof value.name === "string";
+}
+export function createPiShellScopedModelsSelector(options) {
+    ensureTheme();
+    const selector = new ScopedModelsSelectorComponent({
+        allModels: options.models.map(toPiScopedModel),
+        enabledModelIds: options.enabledModelIds === null ? null : [...options.enabledModelIds],
+        ...(options.refreshStatus === undefined ? {} : { refreshStatus: options.refreshStatus }),
+    }, {
+        onChange: ids => options.onChange(ids),
+        onPersist: ids => options.onPersist(ids),
+        onCancel: options.onCancel,
+    });
+    return {
+        ...componentPort(selector),
+        updateModels(models, enabledModelIds) {
+            selector.updateModels(models.map(toPiScopedModel), enabledModelIds === undefined
+                ? undefined
+                : enabledModelIds === null ? null : [...enabledModelIds]);
+        },
+        setRefreshStatus: (message, kind) => selector.setRefreshStatus(message, kind),
+    };
+}
+/** The bare-A1 unified Models dialog behind the owned component boundary; the pinned selectors above stay for `a1 pi`. */
+export function createPiShellModelsDialog(options) {
+    ensureTheme();
+    const dialog = new ModelsDialogComponent(options, options);
+    return {
+        ...componentPort(dialog),
+        updateModels: models => dialog.updateModels(models),
+        setRefreshStatus: (message, kind) => dialog.setRefreshStatus(message, kind),
+        dirty: () => dialog.dirty,
+    };
+}
+export function createPiShellTrustSelector(options) {
+    ensureTheme();
+    return componentPort(new TrustSelectorComponent(options));
+}
+export function createPiShellSessionSelector(options) {
+    ensureTheme();
+    const selector = new SessionSelectorComponent(options.currentSessionsLoader, options.allSessionsLoader, options.onSelect, options.onCancel, options.onExit, options.requestRender, { renameSession: options.renameSession, showRenameHint: true }, options.currentSessionFilePath);
+    return componentPort(selector);
+}
+export function createPiShellTreeSelector(options) {
+    ensureTheme();
+    const selector = new TreeSelectorComponent([...options.tree], options.currentLeafId, options.terminalHeight, options.onSelect, options.onCancel, options.onLabelChange, options.initialSelectedId, options.initialFilterMode);
+    if (options.onCopy)
+        selector.onCopy = options.onCopy;
+    return componentPort(selector);
+}
+export function createPiShellUserMessageSelector(messages, onSelect, onCancel, initialSelectedId) {
+    ensureTheme();
+    const selector = new UserMessageSelectorComponent(messages.map(message => ({ id: message.id, text: message.label })), onSelect, onCancel, initialSelectedId);
+    const list = selector.getMessageList();
+    return componentPort(selector, data => list.handleInput(data));
+}
+export function createPiShellLoginDialog(runtime, providerId, onComplete, providerName, title) {
+    ensureTheme();
+    const dialog = new LoginDialogComponent(createTuiFacade(runtime), providerId, onComplete, providerName, title);
+    return {
+        ...componentPort(dialog),
+        showAuth: (url, instructions) => dialog.showAuth(url, instructions),
+        showDeviceCode: info => dialog.showDeviceCode(info),
+        showManualInput: message => dialog.showManualInput(message),
+        showPrompt: (message, placeholder) => dialog.showPrompt(message, placeholder),
+        showDetails: lines => dialog.showDetails([...lines]),
+        showInfo: (message, links = [], showCloseHint = false) => dialog.showInfo(message, [...links], showCloseHint),
+        showWaiting: message => dialog.showWaiting(message),
+        showProgress: message => dialog.showProgress(message),
+    };
+}
+export function createPiShellArmin(runtime) {
+    ensureTheme();
+    return componentPort(new ArminComponent(createTuiFacade(runtime)));
+}
+export function createPiShellDaxnuts(runtime) {
+    ensureTheme();
+    return componentPort(new DaxnutsComponent(createTuiFacade(runtime)));
+}
+export function createPiShellEarendilAnnouncement() {
+    ensureTheme();
+    return componentPort(new EarendilAnnouncementComponent());
+}
+export function createPiShellOperationLoader(runtime, message) {
+    ensureTheme();
+    const loader = new BorderedLoader(createTuiFacade(runtime), piTheme(), message, { cancellable: true });
+    return { ...componentPort(loader), signal: loader.signal };
+}
+export function createPiShellReloadBox() {
+    ensureTheme();
+    const container = new Container();
+    const borderColor = (text) => piTheme().fg("border", text);
+    container.addChild(new DynamicBorder(borderColor));
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(piTheme().fg("muted", "Reloading keybindings, extensions, skills, prompts, themes, and context files..."), 1, 0));
+    container.addChild(new Spacer(1));
+    container.addChild(new DynamicBorder(borderColor));
+    return componentPort(container);
+}
+export function createPiShellAuthProviderSelector(mode, providers, onSelect, onCancel, initialSearchInput) {
+    ensureTheme();
+    const selector = new OAuthSelectorComponent(mode, providers.map(provider => ({
+        id: provider.providerId,
+        name: provider.label,
+        authType: provider.authType,
+        ...(provider.status === undefined ? {} : { status: provider.status }),
+    })), (providerId, authType) => {
+        const selected = providers.find(provider => provider.providerId === providerId && provider.authType === authType);
+        if (selected)
+            onSelect(selected.id);
+    }, onCancel, initialSearchInput);
+    return componentPort(selector);
+}
+export function createPiShellExtensionSelector(title, options, onSelect, onCancel) {
+    ensureTheme();
+    return componentPort(new ExtensionSelectorComponent(title, [...options], onSelect, onCancel));
+}
+export function createPiShellThinkingSelector(currentLevel, availableLevels, onSelect, onCancel, onSelectAsDefault, defaultLevel) {
+    ensureTheme();
+    const selector = new ThinkingSelectorComponent(currentLevel, [...availableLevels], onSelect, onCancel, onSelectAsDefault, defaultLevel);
+    const list = selector.getSelectList();
+    return componentPort(selector, data => list.handleInput(data));
+}
+export function createPiShellThemeSelector(currentTheme, onSelect, onCancel, onPreview) {
+    ensureTheme();
+    const selector = new ThemeSelectorComponent(currentTheme, onSelect, onCancel, onPreview);
+    const list = selector.getSelectList();
+    return componentPort(selector, data => list.handleInput(data));
+}
+export function createPiShellShowImagesSelector(currentValue, onSelect, onCancel) {
+    ensureTheme();
+    const selector = new ShowImagesSelectorComponent(currentValue, onSelect, onCancel);
+    const list = selector.getSelectList();
+    return componentPort(selector, data => list.handleInput(data));
+}
+export function createPiShellDialog(dialog, handlers = {}) {
+    ensureTheme();
+    const selector = createPiShellSelector({
+        title: dialog.title,
+        options: dialogOptions(dialog),
+        maxVisible: 8,
+        ...(handlers.onSelect === undefined ? {} : { onSelect: handlers.onSelect }),
+        ...(handlers.onCancel === undefined ? {} : { onCancel: handlers.onCancel }),
+    });
+    const box = new Box(1, 1);
+    box.addChild(componentFromPort(selector));
+    return componentPort(box, data => selector.handleInput?.(data));
+}
+function toSelectItem(option) {
+    return {
+        value: option.id,
+        label: option.label,
+        ...(option.description === undefined ? {} : { description: option.description }),
+    };
+}
+function dialogOptions(dialog) {
+    if (isRecord(dialog.payload) && Array.isArray(dialog.payload.options)) {
+        const values = dialog.payload.options.filter(isRecord).flatMap(option => {
+            if (typeof option.id !== "string" || typeof option.label !== "string")
+                return [];
+            return [{
+                    id: option.id,
+                    label: option.label,
+                    ...(typeof option.description === "string" ? { description: option.description } : {}),
+                }];
+        });
+        if (values.length > 0)
+            return values;
+    }
+    return [{ id: "accept", label: "Accept" }, { id: "cancel", label: "Cancel" }];
+}

package/dist/integrations/pi/components/shell-shared-facade.d.ts

@@ -0,0 +1,225 @@
+import { visibleWidth, type AutocompleteProvider, type Component, type KeybindingsConfig, type TUI } from "@earendil-works/pi-tui";
+import type { OwnedUiImageAttachment, OwnedUiSessionViewModel, OwnedUiThinkingLevel, OwnedUiTranscriptBlock, SuggestionDecision } from "../../../contracts/owned-ui/index.js";
+import type { HistoryEditorConstructor } from "./history-editor-loader.js";
+import type { PiShellPromptInputPresentation } from "./prompt-input-port.js";
+import type { EditorRecallPort } from "./editor-interaction.js";
+import type { PresentationComponentPort } from "../../../contracts/presentation/index.js";
+/** Terminal-cell width authority used by Pi-rendered component rows. */
+export declare const piShellVisibleWidth: typeof visibleWidth;
+export declare const piShellTruncateToWidth: (text: string, width: number) => string;
+/** A clickable URL in pinned Pi's grammar: an OSC 8 link where the terminal supports one, the plain URL otherwise. */
+export declare const piShellHyperlink: (url: string, text?: string) => string;
+export interface PiShellComponentPort extends PresentationComponentPort {
+}
+export type PiShellClipboardContent = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "image";
+    readonly data: string;
+    readonly mimeType: string;
+};
+export interface PiShellEditorTextRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface PiShellEditorPointerEvent {
+    readonly kind: "press" | "motion" | "release";
+    readonly button: number;
+    readonly column: number;
+    /** One-based row relative to the top border of the editor body, excluding its menu. */
+    readonly row: number;
+}
+export interface PiShellEditorBodyGeometry {
+    /** Zero-based body offset in the most recently rendered component rows. */
+    readonly rowOffset: number;
+    /** Border-inclusive body height, excluding autocomplete. */
+    readonly rowCount: number;
+}
+export interface PiShellEditorPort extends PiShellComponentPort {
+    /** Present only for the owned above-prompt autocomplete presentation. */
+    bodyGeometry?(): PiShellEditorBodyGeometry;
+    readonly recall?: EditorRecallPort;
+    readonly historyReplacement?: typeof import("../../../contracts/owned-ui/index.js").PROMPT_HISTORY_EDITOR_REPLACEMENT;
+    /** Restores this editor's profile after another Pi component changed the global manager. */
+    activateKeybindings(): void;
+    keybindingConfig(): KeybindingsConfig;
+    reloadKeybindings(): void;
+    /** Uses Pi's terminal decoder rather than assuming one terminal escape spelling. */
+    matchesTerminalKey(data: string, key: "home" | "end" | "ctrl+home" | "ctrl+end" | "alt+home" | "ctrl+v"): boolean;
+    getText(): string;
+    setText(text: string): void;
+    insertText(text: string): void;
+    addToHistory(text: string): void;
+    setSubmitEnabled(enabled: boolean): void;
+    setSubmitHandler(handler: (text: string) => void): void;
+    setInterruptHandler(handler: () => void): void;
+    setAutocompleteCommands(commands: readonly PiShellAutocompleteCommand[]): void;
+    setPaddingX(padding: number): void;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    addAutocompleteProvider(factory: unknown): void;
+    setThinkingLevel(level: OwnedUiThinkingLevel): void;
+    setPromptSuggestion(text: string | null): void;
+    canPresentPromptSuggestion(): boolean;
+    promptSuggestionBlockReason?(): SuggestionDecision;
+    hasSelection(): boolean;
+    ownsPointer(): boolean;
+    handlePointer(event: PiShellEditorPointerEvent): boolean;
+    pasteClipboard(): boolean;
+    cancelPendingPastes?(): void;
+}
+export interface PiShellAutocompleteCommand {
+    readonly name: string;
+    readonly description?: string;
+    readonly argumentHint?: string;
+    readonly argumentOptions?: readonly PiShellSelectorOption[];
+    /** Built-in entries decorate the active profile's catalog; everything else is a discovered resource. */
+    readonly source?: "builtin" | "prompt" | "skill" | "extension";
+}
+export interface PiShellViewComponentPort extends PiShellComponentPort {
+    update(view: OwnedUiSessionViewModel): void;
+}
+export type PiShellStatusPlacement = "live" | "dock" | "hidden";
+export interface PiShellStatusPort extends PiShellViewComponentPort {
+    setWorkingOverride(message: string | undefined): void;
+    setOutputPad(padding: 0 | 1): void;
+    /** Bare A1 shows engine-measured progress beside the working word; the pinned route keeps the bare word. */
+    setProgressPresentation(presentation: "pinned" | "custom-viewport"): void;
+    /** Semantic row placement; callers must not inspect rendered text. */
+    placement(): PiShellStatusPlacement;
+    renderDock(width: number): readonly string[];
+    renderLive(width: number): readonly string[];
+}
+export interface PiShellQueuedInputPort extends PiShellComponentPort {
+    update(submissions: readonly string[]): void;
+}
+export interface PiShellHeaderPort extends PiShellComponentPort {
+    readonly expanded: boolean;
+    setExpanded(expanded: boolean): void;
+}
+export type PiShellResourceSection = "Context" | "Skills" | "Prompts" | "Extensions" | "Themes";
+export interface PiShellResourceEntry {
+    readonly section: PiShellResourceSection;
+    readonly label: string;
+    readonly sourcePath: string | null;
+    readonly diagnostic?: string | null;
+}
+export interface PiShellLoadedResourcesPort extends PiShellComponentPort {
+    setExpanded(expanded: boolean): void;
+}
+export interface PiShellImageAssetResolver {
+    resolve(assetId: string): OwnedUiImageAttachment | null;
+}
+export interface PiShellExtensionRendererResolver {
+    getMessageRenderer(customType: string): unknown;
+    getToolDefinition(toolName: string): unknown;
+    getShortcuts?(bindings: KeybindingsConfig): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
+}
+export interface PiShellTranscriptComponentPort extends PiShellComponentPort {
+    readonly id: string;
+    readonly revision: number;
+    readonly presentationRevision?: number;
+    update(block: OwnedUiTranscriptBlock): void;
+    setExpanded(expanded: boolean): void;
+    setOutputPad(padding: 0 | 1): void;
+    setHideThinkingBlock(hidden: boolean): void;
+    setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
+    setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+}
+export interface PiShellStartupNotice {
+    readonly kind: "info" | "warning" | "error";
+    readonly message: string;
+}
+export interface PiShellHeaderOptions {
+    readonly getKeybindings?: () => KeybindingsConfig;
+    readonly quiet?: boolean;
+    readonly expanded?: boolean;
+    readonly notices?: readonly PiShellStartupNotice[];
+    readonly resources?: readonly PiShellResourceEntry[];
+}
+/** An owned paste reserves its edit immediately and acknowledges completion only after insertion. */
+export interface PiShellPasteReservation {
+    readonly marker: string;
+    readonly result: Promise<string>;
+    complete?(): void;
+    isCurrent?(): boolean;
+}
+export interface PiShellEditorOptions {
+    readonly persistentHistory?: boolean;
+    readonly historyEditor?: HistoryEditorConstructor;
+    /** Bare A1 adds ergonomic aliases while comparison profiles retain Pi defaults. */
+    readonly keybindingProfile?: "pi" | "a1";
+    readonly getColumns: () => number;
+    readonly getRows: () => number;
+    readonly requestRender: () => void;
+    readonly onSubmit: (text: string) => void;
+    readonly onChange?: (text: string) => void;
+    readonly onInterrupt?: () => void;
+    readonly onClear?: () => void;
+    readonly onExit?: () => void;
+    readonly onSuspend?: () => void;
+    readonly onExternalEditor?: () => void;
+    readonly onPasteImage?: () => void;
+    readonly onExtensionShortcut?: (data: string) => boolean;
+    readonly onModelSelect?: () => void;
+    readonly onModelCycle?: ((direction: "forward" | "backward") => void) | undefined;
+    readonly onThinkingCycle?: (() => void) | undefined;
+    readonly onThinkingToggle?: (() => void) | undefined;
+    readonly onToolsExpand?: (() => void) | undefined;
+    readonly onMessageCopy?: (() => void) | undefined;
+    readonly onFollowUp?: (() => void) | undefined;
+    readonly onDequeue?: (() => void) | undefined;
+    readonly onPromptSuggestionAccepted?: (text: string) => void;
+    readonly onCopyText?: (text: string) => void;
+    readonly readClipboardContent?: (signal?: AbortSignal) => 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 editorHiddenRanges?: (line: string) => readonly PiShellEditorTextRange[];
+    readonly transformPastedContent?: (content: PiShellClipboardContent) => string;
+    readonly editorAtomicRanges?: (line: string) => readonly PiShellEditorTextRange[];
+    readonly expandCopiedEditorText?: (text: string) => string;
+    readonly paintEditorSelection?: (line: string, from: number, to: number, atomic: boolean) => string;
+    /** Row indices restart at zero for each complete owned editor decoration pass. */
+    readonly decorateEditorRow?: (row: string, width: number, rowIndex: number) => string;
+    readonly cwd?: string;
+    readonly agentDir?: string;
+    readonly autocompleteCommands?: readonly PiShellAutocompleteCommand[];
+    /**
+     * Bare A1's skills presentation, read at every command-list installation. `collapse` replaces the
+     * `skill:<name>` entries with one `skills` command and its tunnel; absent or `expand` keeps the
+     * pinned per-skill entries. Comparison profiles ignore it.
+     */
+    readonly skillsPresentation?: () => "collapse" | "expand";
+    readonly promptPresentation?: {
+        readonly input: PiShellPromptInputPresentation;
+        readonly styleSuggestion: (text: string) => string;
+        readonly styleSuggestionCaret: (text: string) => string;
+    };
+}
+export interface PiShellSelectorOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+}
+export interface PiShellSelectorOptions {
+    readonly title?: string;
+    readonly options: readonly PiShellSelectorOption[];
+    readonly maxVisible?: number;
+    readonly onSelect?: (id: string) => void;
+    readonly onCancel?: () => void;
+}
+export declare function createTuiFacade(options: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender"> & {
+    readonly onSubmit?: (text: string) => void;
+}): TUI;
+export declare function componentPort(component: Component, handleInput?: (data: string) => void): PiShellComponentPort;
+export declare function componentFromPort(port: PiShellComponentPort): Component;
+export declare function formatSessionTokens(count: number): string;
+export declare function isAutocompleteProvider(value: unknown): value is AutocompleteProvider;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function ensureTheme(): void;

package/dist/integrations/pi/components/shell-shared-facade.js

@@ -0,0 +1,92 @@
+import { hyperlink, setKeybindings, visibleWidth, truncateToWidth, } from "@earendil-works/pi-tui";
+import { KeybindingsManager, } from "./upstream/adjacent/core/keybindings.js";
+import { ensurePiTheme, } from "./theme.js";
+/** Terminal-cell width authority used by Pi-rendered component rows. */
+export const piShellVisibleWidth = visibleWidth;
+export const piShellTruncateToWidth = (text, width) => truncateToWidth(text, width, "");
+/** A clickable URL in pinned Pi's grammar: an OSC 8 link where the terminal supports one, the plain URL otherwise. */
+export const piShellHyperlink = (url, text = url) => hyperlink(url, text);
+// Provenance: pinned from packages/coding-agent/src/core/slash-commands.ts at 914cf14.
+export function createTuiFacade(options) {
+    const children = [];
+    const terminal = {
+        start() { }, stop() { }, async drainInput() { }, write() { },
+        get columns() { return Math.max(1, options.getColumns()); },
+        get rows() { return Math.max(1, options.getRows()); },
+        get kittyProtocolActive() { return false; },
+        moveBy() { }, hideCursor() { }, showCursor() { }, clearLine() { }, clearFromCursor() { }, clearScreen() { }, setTitle() { }, setProgress() { },
+    };
+    return {
+        mode: "regular",
+        children,
+        terminal,
+        fullRedraws: 0,
+        addChild: component => children.push(component),
+        removeChild: component => {
+            const index = children.indexOf(component);
+            if (index >= 0)
+                children.splice(index, 1);
+        },
+        clear: () => children.splice(0),
+        render: width => children.flatMap(component => component.render(width)),
+        invalidate: () => children.forEach(component => component.invalidate()),
+        getShowHardwareCursor: () => false,
+        setShowHardwareCursor() { },
+        getClearOnShrink: () => true,
+        setClearOnShrink() { },
+        setFocus() { },
+        showOverlay: () => ({ hide() { }, setHidden() { }, isHidden: () => false, focus() { }, unfocus() { }, isFocused: () => false, getBounds: () => undefined }),
+        hideOverlay() { },
+        hasOverlay: () => false,
+        start() { },
+        stop() { },
+        renderNow() { },
+        requestRender: options.requestRender,
+        addInputListener: () => () => { },
+        removeInputListener() { },
+        onTerminalColorSchemeChange: () => () => { },
+        setTerminalColorSchemeNotifications() { },
+        queryTerminalBackgroundColor: async () => undefined,
+        queryTerminalColorScheme: async () => undefined,
+    };
+}
+export function componentPort(component, handleInput) {
+    const input = handleInput ?? component.handleInput;
+    const focusable = component;
+    const disposable = component;
+    return {
+        render: width => component.render(width),
+        ...(input === undefined ? {} : { handleInput: (data) => input.call(component, data) }),
+        invalidate: () => component.invalidate(),
+        ...("focused" in focusable ? { setFocused: (focused) => { focusable.focused = focused; } } : {}),
+        ...(typeof disposable.dispose === "function" ? { dispose: () => disposable.dispose?.() } : {}),
+    };
+}
+export function componentFromPort(port) {
+    return {
+        render: width => [...port.render(width)],
+        ...(port.handleInput === undefined ? {} : { handleInput: (data) => port.handleInput?.(data) }),
+        invalidate: () => port.invalidate(),
+    };
+}
+export function formatSessionTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10_000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1_000_000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10_000_000)
+        return `${(count / 1_000_000).toFixed(1)}M`;
+    return `${Math.round(count / 1_000_000)}M`;
+}
+export function isAutocompleteProvider(value) {
+    return isRecord(value) && typeof value.getSuggestions === "function" && typeof value.applyCompletion === "function";
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function ensureTheme() {
+    ensurePiTheme();
+    setKeybindings(KeybindingsManager.create());
+}

package/dist/integrations/pi/components/skills-command.d.ts

@@ -0,0 +1,47 @@
+import type { AutocompleteItem, AutocompleteProvider } from "@earendil-works/pi-tui";
+import type { PiShellAutocompleteCommand } from "./shell-shared-facade.js";
+/** The collapsed bare-A1 replacement for the per-skill command listing. */
+export declare const SKILLS_COMMAND_NAME = "skills";
+export declare const SKILLS_COMMAND_DESCRIPTION = "Browse, search, and apply a skill";
+/** Pi's own command prefix; the engine expands `/skill:<name>` regardless of how the menu presents it. */
+export declare const SKILL_COMMAND_PREFIX = "skill:";
+export interface PiShellSkillSummary {
+    readonly name: string;
+    readonly description: string;
+}
+export interface PiShellCollapsedSkillCommands {
+    readonly commands: readonly PiShellAutocompleteCommand[];
+    /** The skills withheld from the top-level menu, in the engine's discovery order. */
+    readonly skills: readonly PiShellSkillSummary[];
+}
+/** One line of description, as the v2 extension shows it beside a row. */
+export declare function oneLineSkillDescription(description: string): string;
+/** The skills the engine registered as `skill:<name>` commands, in its order. */
+export declare function skillsFromCommands(commands: readonly PiShellAutocompleteCommand[]): readonly PiShellSkillSummary[];
+/**
+ * Replace every `skill:<name>` entry with one `skills` command whose argument completions are the
+ * skill names. A list without skill entries (registration disabled, or no skills) is returned
+ * unchanged with no `skills` command, so the collapsed presentation never invents a command.
+ */
+export declare function collapseSkillCommands(commands: readonly PiShellAutocompleteCommand[]): PiShellCollapsedSkillCommands;
+/** Case-insensitive substring match on the name or description; a leading `skill:`/`skills:` in the query is ignored for the name. */
+export declare function skillMatchesQuery(skill: PiShellSkillSummary, query: string): boolean;
+/** Resolve a `/skills` argument token to a skill, accepting the name with or without `skill:`. */
+export declare function findSkillByArgument(skills: readonly PiShellSkillSummary[], token: string): PiShellSkillSummary | undefined;
+/** The `/skill:<name>` prompt the engine expands, with any arguments after one space. */
+export declare function skillPrompt(name: string, args?: string): string;
+/**
+ * Rewrite a submitted tunnel form `/skills:<name> rest` to `/skill:<name> rest`; anything else is
+ * returned unchanged so ordinary prompts, `/skills <name>`, and `/skill:` input keep their text.
+ */
+export declare function rewriteSkillsTunnelSubmission(text: string): string;
+/** The tunnel query when single-line content before the cursor is exactly `/skills:<query>`. */
+export declare function skillsTunnelQuery(lines: readonly string[], cursorLine: number, cursorCol: number): string | null;
+export declare function skillsTunnelItems(skills: readonly PiShellSkillSummary[], query: string): AutocompleteItem[];
+/**
+ * Wrap the pinned combined provider with the `skills` tunnel: `/skills:<query>` lists matching
+ * skills as `skills:<name>` rows and shows nothing when none match; every other request, the
+ * completion application, and the file-completion decision are delegated unchanged so extension
+ * wrappers registered over this provider see one ordinary provider.
+ */
+export declare function createSkillsTunnelProvider(base: AutocompleteProvider, skills: readonly PiShellSkillSummary[]): AutocompleteProvider;