pi-ui-extend 0.1.1

package/dist/app/native-modifiers.d.ts

@@ -0,0 +1,3 @@
+export declare function isNativeShiftPressed(): boolean;
+export declare function isNativeCommandPressed(): boolean;
+export declare function hasTerminalCommandModifier(modifierValue: number): boolean;

package/dist/app/native-modifiers.js

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TERMINAL_COMMAND_MODIFIER_FLAG } from "./constants.js";
+import { isRecord } from "./guards.js";
+const cjsRequire = createRequire(import.meta.url);
+let nativeModifiersHelper;
+export function isNativeShiftPressed() {
+    return isNativeModifierPressed("shift");
+}
+export function isNativeCommandPressed() {
+    return isNativeModifierPressed("command");
+}
+function isNativeModifierPressed(key) {
+    const helper = loadNativeModifiersHelper();
+    if (!helper)
+        return false;
+    try {
+        return helper.isModifierPressed(key) === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasTerminalCommandModifier(modifierValue) {
+    return ((modifierValue - 1) & TERMINAL_COMMAND_MODIFIER_FLAG) !== 0;
+}
+function loadNativeModifiersHelper() {
+    if (nativeModifiersHelper !== undefined)
+        return nativeModifiersHelper ?? undefined;
+    nativeModifiersHelper = null;
+    if (process.platform !== "darwin")
+        return undefined;
+    if (process.arch !== "x64" && process.arch !== "arm64")
+        return undefined;
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const nativePath = join("native", "darwin", "prebuilds", `darwin-${process.arch}`, "darwin-modifiers.node");
+    const candidates = [
+        join(process.cwd(), "node_modules", "@earendil-works", "pi-coding-agent", "node_modules", "@earendil-works", "pi-tui", nativePath),
+        join(process.cwd(), "node_modules", "@earendil-works", "pi-tui", nativePath),
+        join(moduleDir, "..", "node_modules", "@earendil-works", "pi-coding-agent", "node_modules", "@earendil-works", "pi-tui", nativePath),
+        join(dirname(process.execPath), nativePath),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const helper = cjsRequire(candidate);
+            if (isNativeModifiersHelper(helper)) {
+                nativeModifiersHelper = helper;
+                return helper;
+            }
+        }
+        catch {
+            // Try the next possible install layout.
+        }
+    }
+    return undefined;
+}
+function isNativeModifiersHelper(value) {
+    return isRecord(value) && typeof value.isModifierPressed === "function";
+}

package/dist/app/nerd-font-controller.d.ts

@@ -0,0 +1,11 @@
+export type NerdFontInstallHost = {
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    render(): void;
+};
+export declare class NerdFontController {
+    private readonly host;
+    private ensureStarted;
+    constructor(host: NerdFontInstallHost);
+    ensureInstalledOnStartup(): void;
+    private ensureInstalled;
+}

package/dist/app/nerd-font-controller.js

@@ -0,0 +1,90 @@
+import { spawn, spawnSync } from "node:child_process";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CASK_NAME = "font-jetbrains-mono-nerd-font";
+const FONT_FILE_PATTERN = /(?:JetBrainsMono|JetBrains).*Nerd.*\.(?:ttf|otf)$/iu;
+export class NerdFontController {
+    host;
+    ensureStarted = false;
+    constructor(host) {
+        this.host = host;
+    }
+    ensureInstalledOnStartup() {
+        if (this.ensureStarted)
+            return;
+        this.ensureStarted = true;
+        void this.ensureInstalled();
+    }
+    async ensureInstalled() {
+        if (await isJetBrainsNerdFontInstalled())
+            return;
+        if (process.platform !== "darwin") {
+            this.host.showToast("Nerd Font is missing; auto-install is only configured for macOS Homebrew", "warning");
+            return;
+        }
+        if (!commandExists("brew")) {
+            this.host.showToast("Nerd Font is missing; install Homebrew or JetBrainsMono Nerd Font manually", "warning");
+            return;
+        }
+        this.host.showToast("Installing JetBrainsMono Nerd Font…", "info");
+        try {
+            await runBrewInstall();
+            if (await isJetBrainsNerdFontInstalled()) {
+                this.host.showToast("JetBrainsMono Nerd Font installed", "success");
+            }
+            else {
+                this.host.showToast("Nerd Font install finished, but the font was not detected", "warning");
+            }
+        }
+        catch (error) {
+            this.host.showToast(`Nerd Font install failed: ${errorMessage(error)}`, "error");
+        }
+        finally {
+            this.host.render();
+        }
+    }
+}
+async function isJetBrainsNerdFontInstalled() {
+    if (commandExists("brew") && spawnSync("brew", ["list", "--cask", CASK_NAME], { stdio: "ignore" }).status === 0)
+        return true;
+    const fontDirs = [join(homedir(), "Library", "Fonts"), "/Library/Fonts", "/System/Library/Fonts"];
+    for (const dir of fontDirs) {
+        try {
+            const files = await readdir(dir);
+            if (files.some((file) => FONT_FILE_PATTERN.test(file)))
+                return true;
+        }
+        catch {
+            // Ignore unreadable/missing font directories.
+        }
+    }
+    return false;
+}
+async function runBrewInstall() {
+    await new Promise((resolve, reject) => {
+        const child = spawn("brew", ["install", "--cask", CASK_NAME], {
+            env: { ...process.env, HOMEBREW_NO_AUTO_UPDATE: "1" },
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-800);
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(stderr.trim() || `brew exited with code ${code ?? "unknown"}`));
+        });
+    });
+}
+function commandExists(command) {
+    if (process.platform === "win32")
+        return spawnSync("where", [command], { stdio: "ignore" }).status === 0;
+    return spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" }).status === 0;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/app/popup-action-controller.d.ts

@@ -0,0 +1,44 @@
+import type { AgentSession, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { AppCommandController } from "./command-controller.js";
+import type { AppMenuItemsController } from "./menu-items-controller.js";
+import type { AppPopupMenuController } from "./popup-menu-controller.js";
+import type { AppQueuedMessageController } from "./queued-message-controller.js";
+import type { Entry, SlashCommand } from "./types.js";
+import type { AppWorkspaceActionsController } from "./workspace-actions-controller.js";
+export type AppPopupActionControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    getBuiltinSlashCommands(): readonly SlashCommand[];
+    isRunning(): boolean;
+    setInput(value: string): void;
+    addEntry(entry: Entry): void;
+    setStatus(status: string): void;
+    setSessionStatus(session: AgentSession | undefined): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    render(): void;
+    resetSessionView(): void;
+    bindCurrentSession(): Promise<void>;
+    loadSessionHistory(): void;
+    scrollToConversationEntry(entryId: string): boolean;
+};
+export declare class AppPopupActionController {
+    private readonly host;
+    private readonly popupMenus;
+    private readonly commandController;
+    private readonly menuItems;
+    private readonly queuedMessages;
+    private readonly workspaceActions;
+    constructor(host: AppPopupActionControllerHost, popupMenus: AppPopupMenuController, commandController: AppCommandController, menuItems: AppMenuItemsController, queuedMessages: AppQueuedMessageController, workspaceActions: AppWorkspaceActionsController);
+    submitActivePopupMenu(): Promise<boolean>;
+    submitSlashCommand(text: string): Promise<void>;
+    private submitSelectedSlashCommand;
+    private submitSelectedModel;
+    private submitSelectedThinking;
+    private submitSelectedUserMessageAction;
+    private submitSelectedUserMessageJump;
+    private submitSelectedQueueMessageAction;
+    private submitSelectedResume;
+    private formatSlashCommandLine;
+    private executeResourceSlashCommand;
+    private getRuntime;
+    private getIdleRuntime;
+}

package/dist/app/popup-action-controller.js

@@ -0,0 +1,278 @@
+import { createId } from "./id.js";
+import { stringifyUnknown } from "./message-content.js";
+export class AppPopupActionController {
+    host;
+    popupMenus;
+    commandController;
+    menuItems;
+    queuedMessages;
+    workspaceActions;
+    constructor(host, popupMenus, commandController, menuItems, queuedMessages, workspaceActions) {
+        this.host = host;
+        this.popupMenus = popupMenus;
+        this.commandController = commandController;
+        this.menuItems = menuItems;
+        this.queuedMessages = queuedMessages;
+        this.workspaceActions = workspaceActions;
+    }
+    async submitActivePopupMenu() {
+        const active = this.popupMenus.syncActivePopupMenu();
+        if (!active)
+            return false;
+        if (active === "queue-message")
+            return await this.submitSelectedQueueMessageAction();
+        if (active === "user-message")
+            return await this.submitSelectedUserMessageAction();
+        if (active === "user-message-jump")
+            return this.submitSelectedUserMessageJump();
+        if (active === "resume")
+            return await this.submitSelectedResume();
+        if (active === "model")
+            return await this.submitSelectedModel();
+        if (active === "thinking")
+            return await this.submitSelectedThinking();
+        if (active === "sdk-menu")
+            return this.popupMenus.submitSelectedSdkMenu();
+        if (active === "slash")
+            return await this.submitSelectedSlashCommand();
+        return false;
+    }
+    async submitSlashCommand(text) {
+        const parsed = this.menuItems.parseSlashInput(text);
+        if (!parsed)
+            return;
+        if (parsed.commandName.length === 0) {
+            this.host.setStatus("type a slash command");
+            this.host.render();
+            return;
+        }
+        const builtinCommandName = parsed.commandName.toLowerCase();
+        const command = this.host.getBuiltinSlashCommands().find((candidate) => candidate.name === builtinCommandName)
+            ?? this.menuItems.getResourceSlashCommands().find((candidate) => candidate.name === parsed.commandName);
+        if (!command) {
+            const suggestions = this.menuItems.getSlashCommandMatches(parsed.commandName, 3).map((match) => `/${match.value.name}`);
+            this.host.showToast(suggestions.length > 0 ? `Unknown command /${parsed.commandName}; try ${suggestions.join(", ")}` : "Unknown command", "warning");
+            this.host.render();
+            return;
+        }
+        if (parsed.hasArguments && !command.allowArguments) {
+            this.host.showToast(`/${command.name} does not take arguments`, "warning");
+            this.host.render();
+            return;
+        }
+        this.host.setInput("");
+        if (!command.suppressCommandEcho) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `command: ${this.formatSlashCommandLine(command.name, parsed.arguments)}` });
+        }
+        this.host.render();
+        try {
+            if (command.kind === "resource") {
+                await this.executeResourceSlashCommand(command, parsed.arguments);
+            }
+            else {
+                if (!command.run)
+                    throw new Error(`/${command.name} is not executable`);
+                await command.run(parsed.arguments);
+            }
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast(`/${command.name} failed`, "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+        }
+        if (this.host.isRunning())
+            this.host.render();
+    }
+    async submitSelectedSlashCommand() {
+        const selected = this.popupMenus.selectedSlashCommand();
+        if (!selected)
+            return false;
+        this.popupMenus.closeSlashCommandSelection();
+        if (selected.name === "resume") {
+            this.host.setInput("");
+            await this.commandController.runResumeCommand();
+            return true;
+        }
+        await this.submitSlashCommand(`/${selected.name}`);
+        return true;
+    }
+    async submitSelectedModel() {
+        const selected = this.popupMenus.selectedModel();
+        if (!selected)
+            return false;
+        this.popupMenus.closeModelSelection();
+        if (!selected.direct) {
+            this.host.setInput("");
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `command: /model ${selected.value.ref}` });
+        }
+        this.host.render();
+        try {
+            await this.commandController.runModelCommand(selected.value.model);
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast("/model failed", "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+        }
+        if (this.host.isRunning())
+            this.host.render();
+        return true;
+    }
+    async submitSelectedThinking() {
+        const selected = this.popupMenus.selectedThinking();
+        if (!selected)
+            return false;
+        this.popupMenus.closeThinkingSelection();
+        if (!selected.direct) {
+            this.host.setInput("");
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `command: /thinking ${selected.value.level}` });
+        }
+        this.host.render();
+        try {
+            await this.commandController.runThinkingCommand(selected.value.level);
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast("/thinking failed", "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+        }
+        if (this.host.isRunning())
+            this.host.render();
+        return true;
+    }
+    async submitSelectedUserMessageAction() {
+        const selected = this.popupMenus.selectedUserMessageAction();
+        if (!selected)
+            return false;
+        this.popupMenus.closeUserMessageMenu();
+        this.host.render();
+        try {
+            if (selected.value === "copy") {
+                this.workspaceActions.copyUserMessage(selected.entryId);
+                return true;
+            }
+            if (selected.value === "fork") {
+                await this.workspaceActions.forkFromUserMessage(selected.entryId);
+                return true;
+            }
+            await this.workspaceActions.undoChangesFromUserMessage(selected.entryId);
+            return true;
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast(`${selected.label} failed`, "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            return true;
+        }
+    }
+    submitSelectedUserMessageJump() {
+        const selected = this.popupMenus.selectedUserMessageJump();
+        if (!selected)
+            return false;
+        const entryId = selected.entryId;
+        this.popupMenus.closeUserMessageJumpMenu();
+        if (!this.host.scrollToConversationEntry(entryId)) {
+            this.host.showToast("User message not found", "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            return true;
+        }
+        this.host.showToast("Jumped to user message", "success");
+        this.host.setSessionStatus(this.host.runtime()?.session);
+        return true;
+    }
+    async submitSelectedQueueMessageAction() {
+        const selected = this.popupMenus.selectedQueueMessageAction();
+        if (!selected)
+            return false;
+        this.popupMenus.closeQueueMessageMenu();
+        this.host.render();
+        try {
+            if (selected.value === "cancel") {
+                await this.queuedMessages.cancelQueuedMessage(selected.entryId);
+                return true;
+            }
+            if (selected.value === "edit") {
+                await this.queuedMessages.editQueuedMessage(selected.entryId);
+                return true;
+            }
+            await this.queuedMessages.sendQueuedMessageImmediately(selected.entryId);
+            return true;
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast(`${selected.label} failed`, "error");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            return true;
+        }
+    }
+    async submitSelectedResume() {
+        const selected = this.popupMenus.selectedResume();
+        if (!selected)
+            return false;
+        this.popupMenus.setDirectMenu(undefined);
+        this.popupMenus.setDirectPreserveStatus(false);
+        this.popupMenus.setDirectQuery("");
+        this.popupMenus.closeResumeMenu();
+        if (selected.kind === "new") {
+            await this.submitSlashCommand("/new");
+            return true;
+        }
+        const runtime = this.getIdleRuntime("resume");
+        if (!runtime)
+            return true;
+        const { session } = selected;
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Resuming session ${session.id.slice(0, 8)}…` });
+        this.host.setStatus("switching session");
+        this.host.render();
+        try {
+            const result = await runtime.switchSession(session.path);
+            if (result.cancelled) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });
+                this.host.setSessionStatus(runtime.session);
+                this.host.render();
+                return true;
+            }
+            this.host.resetSessionView();
+            await this.host.bindCurrentSession();
+            this.host.loadSessionHistory();
+            const name = runtime.session.sessionName ?? session.id.slice(0, 8);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Resumed session "${name}"` });
+            this.host.setSessionStatus(runtime.session);
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: `Resume failed: ${error instanceof Error ? error.message : String(error)}` });
+            this.host.showToast("Failed to resume session", "error");
+            this.host.setSessionStatus(runtime.session);
+        }
+        if (this.host.isRunning())
+            this.host.render();
+        return true;
+    }
+    formatSlashCommandLine(name, argumentsText) {
+        return `/${name}${argumentsText ? ` ${argumentsText}` : ""}`;
+    }
+    async executeResourceSlashCommand(command, argumentsText) {
+        const promptText = this.formatSlashCommandLine(command.name, argumentsText);
+        this.host.setStatus(`running /${command.name}`);
+        await this.queuedMessages.submitUserMessage(this.queuedMessages.createSubmittedUserMessage(promptText, promptText, []));
+    }
+    getRuntime(commandName) {
+        const runtime = this.host.runtime();
+        if (!runtime) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: "Runtime is not initialized" });
+            this.host.showToast(`/${commandName} unavailable`, "error");
+            return undefined;
+        }
+        return runtime;
+    }
+    getIdleRuntime(commandName) {
+        const runtime = this.getRuntime(commandName);
+        if (!runtime)
+            return undefined;
+        if (runtime.session.isStreaming) {
+            this.host.showToast(`/${commandName} is unavailable while the agent is running`, "warning");
+            return undefined;
+        }
+        return runtime;
+    }
+}

package/dist/app/popup-menu-controller.d.ts

@@ -0,0 +1,183 @@
+import { type Theme } from "../theme.js";
+import { PopupMenu, type PopupMenuItem } from "../ui.js";
+import type { ScreenStyler } from "./screen-styler.js";
+import type { ActivePopupMenu, Entry, ModelMenuValue, ParsedSlashInput, PixMenuController, PixMenuItem, PixMenuOptions, PixMenuSelectOptions, PopupMenuPlacement, QueueMessageMenuValue, RenderedLine, ResumeMenuValue, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "./types.js";
+import type { AgentSession, SessionInfo } from "@earendil-works/pi-coding-agent";
+type SlashCommandMenuValue = SlashCommand;
+type ModelPopupMenuValue = ModelMenuValue;
+type ThinkingPopupMenuValue = ThinkingMenuValue;
+type ResumePopupMenuValue = ResumeMenuValue;
+type UserMessagePopupMenuValue = UserMessageMenuValue;
+type UserMessageJumpPopupMenuValue = UserMessageJumpMenuValue;
+type QueueMessagePopupMenuValue = QueueMessageMenuValue;
+export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
+export type AppPopupMenuControllerHost = {
+    readonly theme: Theme;
+    readonly screenStyler: ScreenStyler;
+    readonly entries: readonly Entry[];
+    readonly session: AgentSession | undefined;
+    readonly resumeLoading: boolean;
+    readonly resumeSessionCount: number;
+    isRunning(): boolean;
+    getInput(): string;
+    setInput(value: string): void;
+    parseSlashInput(text: string): ParsedSlashInput | undefined;
+    getSlashCommandMenuItems(query: string): PopupMenuItem<SlashCommand>[];
+    getModelMenuItems(query: string): PopupMenuItem<ModelMenuValue>[];
+    getThinkingMenuItems(query: string): PopupMenuItem<ThinkingMenuValue>[];
+    getResumeMenuItems(query: string, limit?: number): PopupMenuItem<ResumeMenuValue>[];
+    getUserMessageMenuItems(): PopupMenuItem<UserMessageMenuValue>[];
+    getUserMessageJumpMenuItems(query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
+    getQueueMessageMenuItems(): PopupMenuItem<QueueMessageMenuValue>[];
+    hasUserEntry(entryId: string): boolean;
+    hasQueuedEntry(entryId: string): boolean;
+    setStatus(status: string): void;
+    restoreSessionStatus(): void;
+    render(): void;
+};
+export declare class AppPopupMenuController {
+    private readonly host;
+    readonly menuController: PixMenuController;
+    private readonly slashCommandMenu;
+    private readonly modelMenu;
+    private readonly thinkingMenu;
+    private readonly resumeMenu;
+    private readonly userMessageMenu;
+    private readonly userMessageJumpMenu;
+    private readonly queueMessageMenu;
+    private readonly sdkMenu;
+    private sdkMenuRequest;
+    private slashCommandMenuQuery;
+    private dismissedSlashCommandMenuInput;
+    private modelMenuQuery;
+    private dismissedModelMenuInput;
+    private thinkingMenuQuery;
+    private dismissedThinkingMenuInput;
+    private directPopupMenu;
+    private directPopupMenuPreserveStatus;
+    private directPopupMenuPlacement;
+    private directPopupMenuQuery;
+    private resumeMenuQuery;
+    private resumeMenuSessionLimit;
+    private resumeMenuAllSessionsLoaded;
+    private activeUserMessageEntryId;
+    private activeQueuedMessageEntryId;
+    constructor(host: AppPopupMenuControllerHost);
+    get directMenu(): DirectPopupMenu | undefined;
+    get directQuery(): string;
+    setDirectMenu(menu: DirectPopupMenu | undefined): void;
+    setDirectPreserveStatus(preserveStatus: boolean): void;
+    setDirectQuery(query: string): void;
+    resetInputMenuDismissals(): void;
+    showSdkMenu<T>(items: readonly PixMenuItem<T>[], options: PixMenuOptions): Promise<T | undefined>;
+    selectSdkMenu(title: string, options: readonly string[], menuOptions?: PixMenuSelectOptions): Promise<string | undefined>;
+    closeSdkMenu(value: unknown | undefined, options?: {
+        render?: boolean;
+        restoreStatus?: boolean;
+    }): void;
+    getActivePopupMenu(active: ActivePopupMenu): PopupMenu<unknown>;
+    moveActivePopupMenuSelection(delta: number): boolean;
+    scrollActivePopupMenu(delta: number): boolean;
+    handleDirectPopupInput(char: string): boolean;
+    openDirectPopupMenu(menu: DirectPopupMenu, options?: {
+        preserveStatus?: boolean;
+        placement?: PopupMenuPlacement;
+    }): void;
+    popupMenuPlacement(): PopupMenuPlacement;
+    openUserMessageMenu(entryId: string): boolean;
+    openQueueMessageMenu(entryId: string): boolean;
+    openResumeMenuWithQuery(query: string): void;
+    closeResumeMenu(): void;
+    closeUserMessageMenu(): void;
+    closeUserMessageJumpMenu(): void;
+    closeQueueMessageMenu(): void;
+    resetConversationMenuState(): void;
+    closeModelSelection(): void;
+    closeThinkingSelection(): void;
+    closeSlashCommandSelection(): void;
+    cancelActivePopupMenu(): void;
+    autocompleteSlashCommand(): void;
+    autocompleteModel(): boolean;
+    autocompleteThinking(): boolean;
+    selectedSlashCommand(): SlashCommand | undefined;
+    selectedModel(): {
+        value: ModelMenuValue;
+        direct: boolean;
+    } | undefined;
+    selectedThinking(): {
+        value: ThinkingMenuValue;
+        direct: boolean;
+    } | undefined;
+    selectedResume(): ResumeMenuValue | undefined;
+    selectedUserMessageAction(): {
+        value: UserMessageMenuValue;
+        label: string;
+        entryId: string;
+    } | undefined;
+    selectedUserMessageJump(): UserMessageJumpMenuValue | undefined;
+    selectedQueueMessageAction(): {
+        value: QueueMessageMenuValue;
+        label: string;
+        entryId: string;
+    } | undefined;
+    submitSelectedSdkMenu(): boolean;
+    syncActivePopupMenu(): ActivePopupMenu | undefined;
+    renderActivePopupMenu(width: number): RenderedLine[];
+    popupMenuWidth(columns: number): number;
+    popupMenuMargin(columns: number): number;
+    effectivePopupMenuWidth(columns: number): number;
+    styleOverlayLine(row: number, line: RenderedLine, width: number): string;
+    overlayPlainText(line: RenderedLine, width: number): string;
+    isDynamicConversationBlock(entry: Entry): boolean;
+    hasDynamicConversationBlock(): boolean;
+    renderInlineUserMessageMenu(entry: Extract<Entry, {
+        kind: "user";
+    }>, options: {
+        userContentWidth: number;
+        userContentLeft: number;
+        userLine: (text: string, entryId?: string, syntaxHighlight?: RenderedLine["syntaxHighlight"]) => RenderedLine;
+    }): RenderedLine[];
+    private hasPopupActionItems;
+    private withoutCloseMenuItems;
+    private resetPopupMenuSelection;
+    private resetResumeMenuLazyState;
+    private maybeGrowResumeMenuWindow;
+    private updateResumeMenuLoadedState;
+    private resumeMenuLoadedSessionCount;
+    private userMessageActionForeground;
+    private selectableItemVariant;
+    private queueMessageItemVariant;
+    private sdkItemVariant;
+    private resumeMenuItemSegments;
+    private popupMenuHeader;
+    private syncModelMenu;
+    private syncThinkingMenu;
+    private syncResumeMenu;
+    private syncUserMessageMenu;
+    private syncUserMessageJumpMenu;
+    private syncQueueMessageMenu;
+    private syncSdkMenu;
+    private syncSlashCommandMenu;
+    private closeMenusExcept;
+    private getSdkMenuItems;
+    private renderSlashCommandMenu;
+    private renderModelMenu;
+    private renderThinkingMenu;
+    private renderResumeMenu;
+    private renderUserMessageJumpMenu;
+    private renderQueueMessageMenu;
+    private renderSdkMenu;
+    private popupLineForeground;
+    private popupLineBackground;
+}
+export declare function formatPopupMenuHeader(title: string, width: number): string;
+export type SessionInfoMenuItemsLoader = {
+    readonly total: number;
+    items(limit?: number): PopupMenuItem<SessionInfo>[];
+};
+export declare function createSessionInfoMenuItemsLoader(sessions: readonly SessionInfo[], currentSessionFile: string | undefined, query: string): SessionInfoMenuItemsLoader;
+export declare function formatSessionInfoMenuItems(sessions: readonly SessionInfo[], currentSessionFile: string | undefined, query: string, options?: {
+    limit?: number;
+}): PopupMenuItem<SessionInfo>[];
+export declare function buildUserMessageJumpItems(entries: readonly Entry[], query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
+export type { ModelPopupMenuValue, QueueMessagePopupMenuValue, ResumePopupMenuValue, SlashCommandMenuValue, ThinkingPopupMenuValue, UserMessageJumpPopupMenuValue, UserMessagePopupMenuValue, };