@timurproko/a1 0.1.8-dev.ece8cef → 0.2.1-dev.590

package/dist/foundation/terminal-cleanup/fatal-exit.js

@@ -0,0 +1,87 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
+import { writeSync } from "node:fs";
+import { join } from "node:path";
+import { boundedCleanup, restoreProcessTerminal } from "./terminal-reset.js";
+export async function writeFatalDiagnostic(directory, origin, error, releaseId) {
+    try {
+        // Security: only known classifications and code locations are retained. Error messages,
+        // function names, arbitrary paths, and request objects are never persisted.
+        const cleanupFailed = error instanceof AggregateError && error.cause instanceof Error;
+        const primary = cleanupFailed ? error.cause : error;
+        const classification = primary instanceof TypeError ? "TypeError" : primary instanceof RangeError ? "RangeError" : "Error";
+        const stack = primary instanceof Error && typeof primary.stack === "string" ? primary.stack.slice(0, 32768) : "";
+        const locations = stack.split("\n").slice(1).flatMap(line => {
+            const match = /\/(?:dist|src)\/([a-zA-Z0-9_./-]+\.[cm]?[jt]s):(\d+):(\d+)\)?$/.exec(line.replaceAll("\\", "/"));
+            return match ? [{ file: match[1].slice(0, 160), line: Number(match[2]), column: Number(match[3]) }] : [];
+        }).slice(0, 16);
+        const record = {
+            timestamp: new Date().toISOString(),
+            origin: ["uncaughtException", "unhandledRejection", "entry"].includes(origin) ? origin : "entry",
+            classification, cleanupFailed, locations, node: process.version, platform: process.platform,
+            releaseId: releaseId && /^[a-zA-Z0-9._-]{1,128}$/.test(releaseId) ? releaseId : "unknown",
+        };
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const name = `fatal-${Date.now()}-${randomUUID()}.json`;
+        const path = join(directory, name);
+        const text = JSON.stringify(record, null, 2);
+        if (Buffer.byteLength(text) > 16 * 1024)
+            return null;
+        await writeFile(path, text, { flag: "wx", mode: 0o600 });
+        const names = (await readdir(directory)).filter(file => /^fatal-\d+-[a-f0-9-]+\.json$/.test(file)).sort().reverse();
+        await Promise.all(names.slice(10).map(file => unlink(join(directory, file)).catch(() => undefined)));
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+export function installFatalExit(options) {
+    let failing = false;
+    const restore = () => { try {
+        (options.restore ?? restoreProcessTerminal)();
+    }
+    catch { } };
+    const terminate = (origin, error) => {
+        if (failing)
+            return;
+        failing = true;
+        process.exitCode = 1;
+        // Security: stop accepting input immediately; fatal errors never resume normal work.
+        try {
+            process.stdin.pause();
+            process.stdin.removeAllListeners("data");
+        }
+        catch { }
+        restore();
+        let record = null;
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            restore();
+            try {
+                const location = record?.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 512);
+                writeSync(2, `A1 stopped after an unexpected error.${location ? ` Diagnostic: ${location}` : " Diagnostic storage unavailable."}\n`);
+            }
+            catch { }
+            process.exit(1);
+        };
+        const cleanupTimeoutMs = options.timeoutMs ?? 1000;
+        // Rationale: a short cleanup budget must not terminate the process while its bounded diagnostic write is still in flight.
+        const deadline = setTimeout(finish, Math.max(1000, cleanupTimeoutMs));
+        void Promise.all([
+            writeFatalDiagnostic(options.directory, origin, error, options.releaseId).then(path => { record = path; }),
+            boundedCleanup(() => options.dispose?.(), cleanupTimeoutMs).catch(() => undefined),
+        ]).then(() => { clearTimeout(deadline); finish(); }, finish);
+    };
+    const exception = (error) => terminate("uncaughtException", error);
+    const rejection = (error) => terminate("unhandledRejection", error);
+    process.on("uncaughtException", exception);
+    process.on("unhandledRejection", rejection);
+    return {
+        fail: error => terminate("entry", error),
+        remove() { process.off("uncaughtException", exception); process.off("unhandledRejection", rejection); },
+    };
+}

package/dist/foundation/terminal-cleanup/index.d.ts

@@ -0,0 +1,3 @@
+export { EMERGENCY_TERMINAL_RESET, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
+export { installFatalExit, writeFatalDiagnostic } from "./fatal-exit.js";
+export type { FatalExitOptions } from "./fatal-exit.js";

package/dist/foundation/terminal-cleanup/index.js

@@ -0,0 +1,2 @@
+export { EMERGENCY_TERMINAL_RESET, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
+export { installFatalExit, writeFatalDiagnostic } from "./fatal-exit.js";

package/dist/foundation/terminal-cleanup/terminal-reset.d.ts

@@ -0,0 +1,4 @@
+export declare const EMERGENCY_TERMINAL_RESET: string;
+export declare function restoreProcessTerminal(): void;
+export declare function restoreAfterOwnedExit(ownsTerminal: boolean, code: number | null, signal: string | null, restore?: () => void): number;
+export declare function boundedCleanup(cleanup: () => Promise<unknown> | void, timeoutMs?: number): Promise<void>;

package/dist/foundation/terminal-cleanup/terminal-reset.js

@@ -0,0 +1,40 @@
+import { writeSync } from "node:fs";
+// Protocol: reset modes on both screens; setting keyboard flags to zero is idempotent,
+// unlike repeatedly popping a keyboard-protocol stack owned by a parent application.
+export const EMERGENCY_TERMINAL_RESET = "\x1b[?2026l\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1004l\x1b[?1006l"
+    + "\x1b[?2004l\x1b[=0u\x1b[>4;0m\x1b]8;;\x1b\\\x1b[0m\x1b[r\x1b[?7h\x1b[?25h"
+    + "\x1b[?1049l\x1b[r\x1b[?7h\x1b[?25h\x1b]9;4;0\x07";
+export function restoreProcessTerminal() {
+    try {
+        if (process.stdout.isTTY)
+            writeSync(process.stdout.fd, EMERGENCY_TERMINAL_RESET);
+    }
+    catch { }
+    try {
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+    }
+    catch { }
+}
+export function restoreAfterOwnedExit(ownsTerminal, code, signal, restore = restoreProcessTerminal) {
+    const outcome = code ?? (signal ? 1 : 0);
+    if (ownsTerminal && outcome !== 0) {
+        try {
+            restore();
+        }
+        catch { }
+    }
+    return outcome;
+}
+export async function boundedCleanup(cleanup, timeoutMs = 1000) {
+    let timer;
+    try {
+        await Promise.race([
+            Promise.resolve().then(cleanup),
+            new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("Cleanup deadline exceeded")), timeoutMs); }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/integrations/pi/components/components.d.ts

@@ -0,0 +1,4 @@
+import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+export declare function adaptPiUserMessage(block: OwnedUiTranscriptBlock, width: number): readonly string[];
+export declare function adaptPiAssistantMessage(block: OwnedUiTranscriptBlock, width: number): readonly string[];
+export declare function adaptPiToolExecution(block: OwnedUiTranscriptBlock, width: number, cwd: string): readonly string[];

package/dist/integrations/pi/components/components.js

@@ -0,0 +1,64 @@
+import { AssistantMessageComponent, ToolExecutionComponent, UserMessageComponent, } from "../startup-public.js";
+import { createTuiFacade, validatedAssistantMessage } from "./shell-components.js";
+import { ensurePiTheme } from "./theme.js";
+export function adaptPiUserMessage(block, width) {
+    requireBlock(block, "user");
+    ensurePiTheme();
+    return new UserMessageComponent(block.text).render(width);
+}
+export function adaptPiAssistantMessage(block, width) {
+    requireBlock(block, "assistant");
+    ensurePiTheme();
+    return new AssistantMessageComponent(validatedAssistantMessage(block), false).render(width);
+}
+export function adaptPiToolExecution(block, width, cwd) {
+    if (block.kind !== "tool-call" && block.kind !== "tool-result") {
+        throw new TypeError("Pi tool execution adaptation requires a tool block");
+    }
+    ensurePiTheme();
+    const payload = blockPayload(block);
+    const toolCallId = stringPayload(payload, "toolCallId") ?? block.id;
+    const toolName = stringPayload(payload, "toolName") ?? block.title ?? "tool";
+    const args = isRecord(payload.arguments) && "json" in payload.arguments ? payload.arguments.json : {};
+    const component = new ToolExecutionComponent(toolName, toolCallId, args, undefined, undefined, createTuiFacade({ getColumns: () => width, getRows: () => 24, requestRender() { } }), cwd);
+    if (block.status === "live")
+        component.markExecutionStarted();
+    component.setArgsComplete();
+    if (block.kind === "tool-result") {
+        component.updateResult({
+            content: [{ type: "text", text: block.text }],
+            isError: payload.isError === true,
+        });
+    }
+    return component.render(width);
+}
+function requireBlock(block, kind) {
+    if (block.kind !== kind)
+        throw new TypeError(`Pi component adaptation requires ${kind}, received ${block.kind}`);
+}
+function blockPayload(block) {
+    return isRecord(block.payload) ? block.payload : {};
+}
+function blockProvider(block) {
+    return stringPayload(blockPayload(block), "provider") ?? "openai";
+}
+function blockModel(block) {
+    return stringPayload(blockPayload(block), "model") ?? "gpt-5";
+}
+function stringPayload(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/integrations/pi/components/conformance.d.ts

@@ -0,0 +1,18 @@
+export interface PiComponentConformanceResult {
+    readonly component: "user-message" | "assistant-message" | "tool-execution";
+    readonly renderRows: number;
+    readonly width: number;
+}
+export interface PiComponentConformanceReport {
+    readonly packageName: "@earendil-works/pi-coding-agent";
+    readonly packageVersion: string;
+    readonly ownedUiContractVersion: number;
+    readonly componentResults: readonly PiComponentConformanceResult[];
+    readonly componentFamilies: readonly string[];
+}
+/** Identifies the Pi presentation-conformance stage that failed against the pinned component surface. */
+export declare class PiComponentConformanceError extends Error {
+    readonly stage: "theme" | "components";
+    constructor(stage: "theme" | "components", cause: unknown);
+}
+export declare function runPiComponentConformance(): Promise<PiComponentConformanceReport>;

package/dist/integrations/pi/components/conformance.js

@@ -0,0 +1,70 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AssistantMessageComponent, ExtensionSelectorComponent, initTheme, LoginDialogComponent, ModelSelectorComponent, SettingsSelectorComponent, ThemeSelectorComponent, ThinkingSelectorComponent, ToolExecutionComponent, UserMessageComponent, UserMessageSelectorComponent, VERSION, } from "@earendil-works/pi-coding-agent";
+import { OWNED_UI_CONTRACT_VERSION } from "../../../contracts/owned-ui/index.js";
+import { createTuiFacade, validatedAssistantMessage } from "./shell-components.js";
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+/** Identifies the Pi presentation-conformance stage that failed against the pinned component surface. */
+export class PiComponentConformanceError extends Error {
+    stage;
+    constructor(stage, cause) {
+        super(`Pi component conformance failed during ${stage}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.stage = stage;
+        this.name = "PiComponentConformanceError";
+    }
+}
+export async function runPiComponentConformance() {
+    const root = await mkdtemp(join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-components-`));
+    try {
+        try {
+            initTheme("dark", false);
+        }
+        catch (error) {
+            throw new PiComponentConformanceError("theme", error);
+        }
+        try {
+            const width = 80;
+            const publicConstructors = [UserMessageComponent, AssistantMessageComponent, ToolExecutionComponent, ExtensionSelectorComponent,
+                LoginDialogComponent, ModelSelectorComponent, SettingsSelectorComponent, ThemeSelectorComponent, ThinkingSelectorComponent,
+                UserMessageSelectorComponent];
+            if (publicConstructors.some(constructor => typeof constructor !== "function"))
+                throw new Error("a reused public component constructor is missing");
+            const user = new UserMessageComponent(`hello from ${PRODUCT_IDENTITY.displayName}`);
+            const assistantBlock = {
+                id: "assistant-1",
+                kind: "assistant",
+                status: "finalized",
+                text: "hello from Pi",
+                title: null,
+                revision: 1,
+                payload: { provider: "openai", model: "gpt-5" },
+            };
+            const assistant = new AssistantMessageComponent(validatedAssistantMessage(assistantBlock), false);
+            const tool = new ToolExecutionComponent("read", "tool-1", { path: "README.md" }, undefined, undefined, createTuiFacade({ getColumns: () => width, getRows: () => 24, requestRender() { } }), root);
+            const componentResults = [
+                { component: "user-message", renderRows: user.render(width).length, width },
+                { component: "assistant-message", renderRows: assistant.render(width).length, width },
+                { component: "tool-execution", renderRows: tool.render(width).length, width },
+            ];
+            if (componentResults.some(result => result.renderRows <= 0)) {
+                throw new Error("a public component produced no render rows");
+            }
+            return {
+                packageName: "@earendil-works/pi-coding-agent",
+                packageVersion: VERSION,
+                ownedUiContractVersion: OWNED_UI_CONTRACT_VERSION,
+                componentResults,
+                componentFamilies: ["messages", "tool-execution", "selectors", "dialogs", "editor-autocomplete", "footer-status", "extension-surfaces"],
+            };
+        }
+        catch (error) {
+            if (error instanceof PiComponentConformanceError)
+                throw error;
+            throw new PiComponentConformanceError("components", error);
+        }
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+}

package/dist/integrations/pi/components/editor-interaction.d.ts

@@ -0,0 +1,38 @@
+import type { Editor } from "@earendil-works/pi-tui";
+export interface EditorInteractionState {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+}
+export interface EditorInteractionPort {
+    snapshot(): EditorInteractionState;
+    setCursor(line: number, col: number): void;
+    replaceLines(lines: readonly string[]): void;
+    updateUndoStates(update: (state: EditorInteractionState) => void): void;
+    scrollOffset(): number;
+    visualLines(width: number): Array<{
+        logicalLine: number;
+        startCol: number;
+        length: number;
+    }>;
+    setSegmentTransform(transform: (text: string, mode: "word" | "grapheme", segments: Iterable<Intl.SegmentData>) => Iterable<Intl.SegmentData>): void;
+}
+export interface EditorRecallPort {
+    replace(entries: readonly string[]): void;
+    position(): {
+        readonly index: number;
+        readonly total: number;
+    };
+    observe(listener: () => void): () => void;
+    reset(): void;
+}
+export interface EditorSurface extends Pick<Editor, Exclude<keyof Editor, "setText" | "render" | "handleInput">> {
+    setText(text: string): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    readonly interaction?: EditorInteractionPort;
+    readonly recall?: EditorRecallPort;
+}
+export type SelectionEditor = Pick<Editor, "getText" | "getCursor" | "setText" | "insertTextAtCursor" | "invalidate" | "onChange" | "getPaddingX" | "isShowingAutocomplete"> & {
+    readonly interaction?: EditorInteractionPort;
+};

package/dist/integrations/pi/components/editor-interaction.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/pi/components/history-editor-loader.d.ts

@@ -0,0 +1,5 @@
+import { type ShellEditorInstance, type OwnedEditorOptions } from "./upstream/components/owned-editor.js";
+import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
+import type { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
+export type HistoryEditorConstructor = new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions) => ShellEditorInstance;
+export declare function loadHistoryEditor(): Promise<HistoryEditorConstructor>;

package/dist/integrations/pi/components/history-editor-loader.js

@@ -0,0 +1,5 @@
+import { createOwnedEditorClass } from "./upstream/components/owned-editor.js";
+export async function loadHistoryEditor() {
+    const { HistoryEditorCore } = await import("./upstream/history/editor-core.js");
+    return createOwnedEditorClass(HistoryEditorCore);
+}

package/dist/integrations/pi/components/index.d.ts

@@ -0,0 +1,26 @@
+export { adaptPiAssistantMessage, adaptPiToolExecution, adaptPiUserMessage } from "./components.js";
+export { loadHistoryEditor, type HistoryEditorConstructor } from "./history-editor-loader.js";
+export { PiComponentConformanceError, runPiComponentConformance } from "./conformance.js";
+export type { PiComponentConformanceReport, PiComponentConformanceResult } from "./conformance.js";
+export { OWNED_BUILTIN_SLASH_COMMANDS, PINNED_PI_BUILTIN_SLASH_COMMANDS, componentFromPort, componentPort, createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellCollapsedChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellModelsDialog, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellShowImagesSelector, createPiShellSkillsSelector, createPiShellStatus, createPiShellThemeSelector, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, createTuiFacade, ensureTheme, formatSessionTokens, isAutocompleteProvider, isPiPromptStyleCompaction, isRecord, paintPiSubmittedPromptTimestamp, piShellHyperlink, piShellTruncateToWidth, piShellVisibleWidth, renderPiShellChangelogLines, renderPiShellCommandMessage, renderPiShellHotkeysLines, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, validatedAssistantMessage, } from "./shell-components.js";
+export { renderPiShellHotkeySections } from "./shell-hotkey-sections.js";
+export type { PiShellHotkeySection } from "./shell-hotkey-sections.js";
+export type { PiExtensionUiBridge, PiExtensionUiBridgeHost, PiShellAuthProviderOption, PiShellAutocompleteCommand, PiShellClipboardContent, PiShellCommandMessagePresentation, PiShellComponentPort, PiShellEditorBodyGeometry, PiShellEditorOptions, PiShellEditorPointerEvent, PiShellEditorPort, PiShellEditorTextRange, PiShellExtensionRendererResolver, PiShellHeaderOptions, PiShellHeaderPort, PiShellHotkeysPresentation, PiShellImageAssetResolver, PiShellLoadedResourcesPort, PiShellLoginDialogPort, PiShellModelSelectorOptions, PiShellModelsDialogOptions, PiShellModelsDialogPort, PiShellOperationLoaderPort, PiShellPasteReservation, PiShellQueuedInputPort, PiShellResourceEntry, PiShellResourceSection, PiShellScopedModelDescriptor, PiShellScopedModelsSelectorOptions, PiShellScopedModelsSelectorPort, PiShellSelectorOption, PiShellSelectorOptions, PiShellSessionInfoPresentation, PiShellSettingsSelectorOptions, PiShellStartupNotice, PiShellStatusPlacement, PiShellStatusPort, PiShellSubmittedPromptComposer, PiShellTranscriptComponentPort, PiShellViewComponentPort, } from "./shell-components.js";
+export { PINNED_PI_LAYOUT, applyConfiguredPiTheme, applyPiTheme, applyPiThemeInstance, currentPiThemeName, detectPiTerminalBackgroundFromEnv, detectPiTerminalBackgroundTheme, detectPiTerminalThemeForAuto, ensurePiTheme, getAvailablePiThemes, loadPiTheme, onPiThemeChange, parsePiAutoThemeSetting, piTheme, resolvePiThemeSetting, stopPiThemeWatcher, } from "./theme.js";
+export type { PiColorMode, PiTerminalTheme, PiTerminalThemeDetection, PiTerminalThemeDetector, PiThemeBackground, PiThemeResult } from "./theme.js";
+export { OwnedPiThemeController } from "./upstream/theme/theme-controller.js";
+export type { PiThemeRuntimePort, PiThemeSettingsPort } from "./upstream/theme/theme-controller.js";
+export { PI_MODAL_CONTENT_PADDING_X, PiModalFrame, PiModalHeader, addPiModalHeader, adoptPiModalFrame, adoptPiModalHeader, } from "./modal-frame.js";
+export { ModelsDialogComponent } from "./models-dialog.js";
+export type { ModelsDialogCallbacks, ModelsDialogConfig, ModelsDialogFilter, ModelsDialogModel } from "./models-dialog.js";
+export { CountdownTimer } from "./upstream/components/countdown-timer.js";
+export { ExtensionEditorComponent } from "./upstream/components/extension-editor.js";
+export { SessionSelectorComponent } from "./upstream/components/session-selector.js";
+export { filterAndSortSessions, hasSessionName, matchSession, parseSearchQuery } from "./upstream/components/session-selector-search.js";
+export type { MatchResult, NameFilter, ParsedSearchQuery, SortMode } from "./upstream/components/session-selector-search.js";
+export { BranchSummaryStatusIndicator, CompactionStatusIndicator, IdleStatus, RetryStatusIndicator, StatusIndicator, WorkingStatusIndicator, } from "./upstream/components/status-indicator.js";
+export type { CompactionStatusReason, StatusIndicatorKind } from "./upstream/components/status-indicator.js";
+export { TreeSelectorComponent } from "./upstream/components/tree-selector.js";
+export type { FilterMode } from "./upstream/components/tree-selector.js";
+export { KEYBINDINGS, KeybindingsManager, migrateKeybindingsConfig } from "./upstream/adjacent/core/keybindings.js";
+export type { AppKeybinding, AppKeybindings, KeyId, Keybinding, KeybindingsConfig } from "./upstream/adjacent/core/keybindings.js";

package/dist/integrations/pi/components/index.js

@@ -0,0 +1,16 @@
+export { adaptPiAssistantMessage, adaptPiToolExecution, adaptPiUserMessage } from "./components.js";
+export { loadHistoryEditor } from "./history-editor-loader.js";
+export { PiComponentConformanceError, runPiComponentConformance } from "./conformance.js";
+export { OWNED_BUILTIN_SLASH_COMMANDS, PINNED_PI_BUILTIN_SLASH_COMMANDS, componentFromPort, componentPort, createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellCollapsedChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellModelsDialog, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellShowImagesSelector, createPiShellSkillsSelector, createPiShellStatus, createPiShellThemeSelector, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, createTuiFacade, ensureTheme, formatSessionTokens, isAutocompleteProvider, isPiPromptStyleCompaction, isRecord, paintPiSubmittedPromptTimestamp, piShellHyperlink, piShellTruncateToWidth, piShellVisibleWidth, renderPiShellChangelogLines, renderPiShellCommandMessage, renderPiShellHotkeysLines, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, validatedAssistantMessage, } from "./shell-components.js";
+export { renderPiShellHotkeySections } from "./shell-hotkey-sections.js";
+export { PINNED_PI_LAYOUT, applyConfiguredPiTheme, applyPiTheme, applyPiThemeInstance, currentPiThemeName, detectPiTerminalBackgroundFromEnv, detectPiTerminalBackgroundTheme, detectPiTerminalThemeForAuto, ensurePiTheme, getAvailablePiThemes, loadPiTheme, onPiThemeChange, parsePiAutoThemeSetting, piTheme, resolvePiThemeSetting, stopPiThemeWatcher, } from "./theme.js";
+export { OwnedPiThemeController } from "./upstream/theme/theme-controller.js";
+export { PI_MODAL_CONTENT_PADDING_X, PiModalFrame, PiModalHeader, addPiModalHeader, adoptPiModalFrame, adoptPiModalHeader, } from "./modal-frame.js";
+export { ModelsDialogComponent } from "./models-dialog.js";
+export { CountdownTimer } from "./upstream/components/countdown-timer.js";
+export { ExtensionEditorComponent } from "./upstream/components/extension-editor.js";
+export { SessionSelectorComponent } from "./upstream/components/session-selector.js";
+export { filterAndSortSessions, hasSessionName, matchSession, parseSearchQuery } from "./upstream/components/session-selector-search.js";
+export { BranchSummaryStatusIndicator, CompactionStatusIndicator, IdleStatus, RetryStatusIndicator, StatusIndicator, WorkingStatusIndicator, } from "./upstream/components/status-indicator.js";
+export { TreeSelectorComponent } from "./upstream/components/tree-selector.js";
+export { KEYBINDINGS, KeybindingsManager, migrateKeybindingsConfig } from "./upstream/adjacent/core/keybindings.js";

package/dist/integrations/pi/components/modal-frame.d.ts

@@ -0,0 +1,41 @@
+import { Container, type Component } from "@earendil-works/pi-tui";
+export declare const PI_MODAL_CONTENT_PADDING_X = 1;
+/** The semantic top rule/title pair used while a modal assembles its frame. */
+export declare class PiModalHeader implements Component {
+    readonly rule: Component;
+    readonly title: Component;
+    constructor(rule: Component, title: Component);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/**
+ * Complete framed-modal chrome. Rules remain frame-wide; every semantic content component renders
+ * in the same one-cell-smaller rectangle and receives the same left inset.
+ */
+export declare class PiModalFrame implements Component {
+    #private;
+    constructor(topRule: Component, content: readonly Component[], bottomRule: Component, fullWidthContent?: readonly Component[], preInsetContent?: readonly Component[]);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/** Add compact titled-modal chrome while a component assembles its semantic body. */
+export declare function addPiModalHeader(container: Container, rule: Component, title: Component): PiModalHeader;
+export interface PiModalFrameAdoption {
+    readonly topIndex: number;
+    readonly bottomIndex: number;
+    readonly header?: PiModalHeader;
+    readonly fullWidthContent?: readonly Component[];
+    /** Public pinned children that already own the same one-cell outer inset. */
+    readonly preInsetContent?: readonly Component[];
+}
+/**
+ * Replace explicitly identified structural modal children with the shared padded frame. Callers
+ * identify semantic rules/components; rendered text is never inspected or rewritten.
+ */
+export declare function adoptPiModalFrame(container: Container, adoption: PiModalFrameAdoption): PiModalFrame;
+/**
+ * Adopt a public component's semantic rule/title children at the bare-A1 boundary. Only an optional
+ * structural Spacer between those explicitly identified children is accepted; rendered text is
+ * never inspected or rewritten. The pinned comparison profile does not call this adapter.
+ */
+export declare function adoptPiModalHeader(container: Container, ruleIndex: number, titleIndex: number): PiModalHeader;

package/dist/integrations/pi/components/modal-frame.js

@@ -0,0 +1,110 @@
+import { Container, Spacer } from "@earendil-works/pi-tui";
+export const PI_MODAL_CONTENT_PADDING_X = 1;
+/** The semantic top rule/title pair used while a modal assembles its frame. */
+export class PiModalHeader {
+    rule;
+    title;
+    constructor(rule, title) {
+        this.rule = rule;
+        this.title = title;
+    }
+    invalidate() {
+        this.rule.invalidate();
+        this.title.invalidate();
+    }
+    render(width) {
+        return [...this.rule.render(width), ...this.title.render(width)];
+    }
+}
+/**
+ * Complete framed-modal chrome. Rules remain frame-wide; every semantic content component renders
+ * in the same one-cell-smaller rectangle and receives the same left inset.
+ */
+export class PiModalFrame {
+    #topRule;
+    #content;
+    #bottomRule;
+    #fullWidthContent;
+    #preInsetContent;
+    constructor(topRule, content, bottomRule, fullWidthContent = [], preInsetContent = []) {
+        this.#topRule = topRule;
+        this.#content = content;
+        this.#bottomRule = bottomRule;
+        this.#fullWidthContent = new Set(fullWidthContent);
+        this.#preInsetContent = new Set(preInsetContent);
+    }
+    invalidate() {
+        this.#topRule.invalidate();
+        for (const component of this.#content)
+            component.invalidate();
+        this.#bottomRule.invalidate();
+    }
+    render(width) {
+        const padding = Math.min(PI_MODAL_CONTENT_PADDING_X, Math.max(0, width));
+        const contentWidth = Math.max(0, width - padding);
+        const rows = [...this.#topRule.render(width)];
+        for (const component of this.#content) {
+            if (this.#fullWidthContent.has(component) || this.#preInsetContent.has(component)) {
+                rows.push(...component.render(width));
+            }
+            else if (component instanceof Spacer) {
+                rows.push(...component.render(contentWidth));
+            }
+            else {
+                rows.push(...component.render(contentWidth).map(row => `${" ".repeat(padding)}${row}`));
+            }
+        }
+        rows.push(...this.#bottomRule.render(width));
+        return rows;
+    }
+}
+/** Add compact titled-modal chrome while a component assembles its semantic body. */
+export function addPiModalHeader(container, rule, title) {
+    const header = new PiModalHeader(rule, title);
+    container.addChild(header);
+    return header;
+}
+/**
+ * Replace explicitly identified structural modal children with the shared padded frame. Callers
+ * identify semantic rules/components; rendered text is never inspected or rewritten.
+ */
+export function adoptPiModalFrame(container, adoption) {
+    const { topIndex, bottomIndex, header, fullWidthContent = [], preInsetContent = [] } = adoption;
+    if (topIndex < 0 || bottomIndex <= topIndex || bottomIndex >= container.children.length) {
+        throw new TypeError("invalid modal frame child positions");
+    }
+    const top = container.children[topIndex];
+    const bottom = container.children[bottomIndex];
+    const contentStart = topIndex + 1;
+    let topRule = top;
+    const content = [];
+    if (header !== undefined) {
+        if (top !== header)
+            throw new TypeError("modal header is not at the declared top position");
+        topRule = header.rule;
+        content.push(header.title);
+    }
+    content.push(...container.children.slice(contentStart, bottomIndex));
+    const frame = new PiModalFrame(topRule, content, bottom, fullWidthContent, preInsetContent);
+    container.children.splice(topIndex, bottomIndex - topIndex + 1, frame);
+    return frame;
+}
+/**
+ * Adopt a public component's semantic rule/title children at the bare-A1 boundary. Only an optional
+ * structural Spacer between those explicitly identified children is accepted; rendered text is
+ * never inspected or rewritten. The pinned comparison profile does not call this adapter.
+ */
+export function adoptPiModalHeader(container, ruleIndex, titleIndex) {
+    if (ruleIndex < 0 || titleIndex <= ruleIndex || titleIndex >= container.children.length) {
+        throw new TypeError("invalid modal rule/title child positions");
+    }
+    const between = container.children.slice(ruleIndex + 1, titleIndex);
+    if (between.length > 1 || between.some(child => !(child instanceof Spacer))) {
+        throw new TypeError("modal rule and title are not separated by an optional single Spacer");
+    }
+    const rule = container.children[ruleIndex];
+    const title = container.children[titleIndex];
+    const header = new PiModalHeader(rule, title);
+    container.children.splice(ruleIndex, titleIndex - ruleIndex + 1, header);
+    return header;
+}

package/dist/integrations/pi/components/models-dialog.d.ts

@@ -0,0 +1,55 @@
+import { type Component, type Focusable } from "@earendil-works/pi-tui";
+export type ModelsDialogFilter = "all" | "scoped";
+export interface ModelsDialogModel {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+}
+export interface ModelsDialogConfig {
+    /** The authenticated catalog; rows never widen beyond it. */
+    readonly models: readonly ModelsDialogModel[];
+    /** `provider/id` of the active model, or null before one is set. */
+    readonly activeModelId: string | null;
+    /** The explicit cycling scope the session currently uses, in order. */
+    readonly scopeIds: readonly string[];
+    /** The last persisted scope, in order; the dirty comparison baseline. */
+    readonly savedScopeIds: readonly string[];
+    readonly initialQuery?: string;
+    readonly initialFilter?: ModelsDialogFilter;
+    readonly refreshStatus?: string;
+}
+export interface ModelsDialogCallbacks {
+    /** Enter on a row: the shell switches through its workflow and closes the dialog on success. */
+    onSelect(modelId: string): void;
+    /** Every scope or order edit, session-only. */
+    onScopeChange(scopeIds: readonly string[]): void;
+    /** Ctrl+S: a resolved promise clears the dirty state for exactly the saved snapshot; a rejection keeps it. */
+    onSave(scopeIds: readonly string[]): Promise<void> | void;
+    onCancel(): void;
+    requestRender(): void;
+}
+/**
+ * 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 declare class ModelsDialogComponent implements Component, Focusable {
+    #private;
+    constructor(config: ModelsDialogConfig, callbacks: ModelsDialogCallbacks);
+    get focused(): boolean;
+    set focused(value: boolean);
+    /** True while the desired scope or order differs from the last successful save. */
+    get dirty(): boolean;
+    get filter(): ModelsDialogFilter;
+    get query(): string;
+    get scopeIds(): readonly string[];
+    get selectedModelId(): string | undefined;
+    /** Replace the catalog after a refresh; query, filter, surviving selection, scope edits, and dirty state stay. */
+    updateModels(models: readonly ModelsDialogModel[]): void;
+    setRefreshStatus(message: string, kind: "muted" | "success" | "warning"): void;
+    dispose(): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}