@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

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

@@ -0,0 +1,242 @@
+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 { 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 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),
+    };
+}
+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,217 @@
+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[];
+}
+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[];
+    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/submitted-prompt-adapter.d.ts

@@ -0,0 +1,17 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+export interface PiShellSubmittedPromptComposer {
+    readonly layout: (width: number, source?: Date | number | null) => {
+        readonly contentWidth: number;
+    };
+    readonly compose: (contentRows: readonly string[], width: number, source?: Date | number | null, style?: {
+        readonly prefix?: (text: string) => string;
+        readonly timestamp?: (text: string) => string;
+    }) => readonly string[];
+}
+/** Branch summaries share the block kind but do not participate in prompt navigation. */
+export declare function isPiPromptStyleCompaction(block: OwnedUiTranscriptBlock): boolean;
+/** Keep prompt timestamps metadata-grey even inside hover and quiet whole-row wrappers. */
+export declare function paintPiSubmittedPromptTimestamp(text: string): string;
+/** Pi owns Markdown and theme adaptation; the injected composer owns neutral row geometry. */
+export declare function createPiSubmittedPromptComponent(block: OwnedUiTranscriptBlock, composer: PiShellSubmittedPromptComposer, heading?: string): Component;

package/dist/integrations/pi/components/submitted-prompt-adapter.js

@@ -0,0 +1,49 @@
+import { getMarkdownTheme } from "../startup-public.js";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import { piTheme } from "./theme.js";
+/** Branch summaries share the block kind but do not participate in prompt navigation. */
+export function isPiPromptStyleCompaction(block) {
+    return block.kind === "compaction" && block.status === "finalized"
+        && typeof block.payload === "object" && block.payload !== null
+        && block.payload.role === "compactionSummary";
+}
+/** Keep prompt timestamps metadata-grey even inside hover and quiet whole-row wrappers. */
+export function paintPiSubmittedPromptTimestamp(text) {
+    // Protocol: combine the intensity/foreground reset so quietSticky does not immediately
+    // reapply faint; the semantic foreground that follows remains theme-controlled.
+    return `\u001b[22;39m${piTheme().fg("dim", text)}`;
+}
+/** Pi owns Markdown and theme adaptation; the injected composer owns neutral row geometry. */
+export function createPiSubmittedPromptComponent(block, composer, heading) {
+    const timestamp = numericTimestamp(block);
+    // Invariant: presentation-only chrome stays outside the summary's Markdown parser and stored text.
+    const header = heading === undefined ? undefined : new Text(heading, 0, 0);
+    const markdown = new Markdown(block.text, 0, 0, getMarkdownTheme(), { color: content => piTheme().fg("userMessageText", content) }, { preserveOrderedListMarkers: true, preserveBackslashEscapes: true });
+    const content = {
+        render(width) {
+            const layout = composer.layout(width, timestamp);
+            const bodyRows = markdown.render(layout.contentWidth);
+            const rows = header === undefined ? bodyRows : [
+                ...header.render(layout.contentWidth).map(row => piTheme().fg("userMessageText", row)),
+                ...(bodyRows.length === 0 ? [] : ["", ...bodyRows]),
+            ];
+            return [...composer.compose(rows, width, timestamp, {
+                    prefix: text => piTheme().fg("muted", text),
+                    timestamp: paintPiSubmittedPromptTimestamp,
+                })];
+        },
+        invalidate() {
+            header?.invalidate();
+            markdown.invalidate();
+        },
+    };
+    const box = new Box(0, 0, line => piTheme().bg("userMessageBg", line));
+    box.addChild(content);
+    return box;
+}
+function numericTimestamp(block) {
+    if (typeof block.payload !== "object" || block.payload === null)
+        return null;
+    const value = block.payload.timestamp;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/integrations/pi/components/tool-image-presentation.d.ts

@@ -0,0 +1,21 @@
+import { convertToPng } from "../startup-public.js";
+import { type Component } from "@earendil-works/pi-tui";
+/**
+ * Own only current attachment presentation; tool renderers still receive original result content.
+ * Unlike pinned 0.84.2's index cache, entries follow immutable source bytes and stale completions
+ * cannot republish. At most one conversion runs per mount; queued work is only the current set.
+ */
+export declare class ToolImagePresentation {
+    #private;
+    private readonly changed;
+    private readonly convert;
+    constructor(changed: () => void, convert?: typeof convertToPng);
+    update(content: readonly {
+        type: string;
+        data?: string;
+        mimeType?: string;
+    }[], show: boolean): void;
+    /** Public Image remains responsible for Kitty/iTerm protocol and dimension-aware fallback. */
+    components(width: number): Component[];
+    dispose(): void;
+}