@oh-my-pi/pi-tui 18.2.4 → 18.2.5

package/dist/types/overlays/extensions/inspector-model.d.ts

@@ -0,0 +1,109 @@
+import { type Extension, type ExtensionState } from "./types.js";
+export interface LiveToolRecord {
+    name: string;
+    label?: string;
+    description?: string;
+    parameters?: unknown;
+    hidden?: boolean;
+    loadMode?: "essential" | "discoverable";
+    /** Origin class from session `ToolInfo.sourceInfo.source`. */
+    source?: "builtin" | "mcp" | "sdk" | "extension";
+    /** Originating module path when the session actually has one. */
+    sourcePath?: string;
+}
+export interface ToolRuntimeSource {
+    getLiveTool(name: string): LiveToolRecord | undefined;
+    listLiveTools?(): LiveToolRecord[];
+}
+export interface ToolParamView {
+    name: string;
+    type: string;
+    required: boolean;
+    flag: string;
+    description?: string;
+}
+export interface CommandPreview {
+    description?: string;
+    body: string;
+    argumentHint?: string;
+    usesArguments: boolean;
+}
+export declare function isPlaceholderToolDescription(name: string, description: string | undefined): boolean;
+/** First JSDoc on a custom-tool file, minus symlink footnotes. */
+export declare function parseToolFileHeader(source: string): string | undefined;
+export interface ExtensionInspectorSource {
+    readToolHeader?(filePath: string): string | undefined;
+    /** Optional application parser for raw frontmatter; otherwise fields must already be normalized. */
+    parseRule?(raw: Record<string, unknown>): {
+        condition?: string[];
+        astCondition?: string[];
+        scope?: string[];
+        agents?: string[];
+    };
+}
+/** Display fields already parsed from command frontmatter. */
+export declare function slashCommandFrontmatterDisplay(frontmatter: Record<string, unknown>): {
+    description?: string;
+    argumentHint?: string;
+};
+export declare function commandPreview(content: string | undefined): CommandPreview;
+export declare function toolParamsFromSchema(schema: unknown): ToolParamView[];
+export declare function liveToolsForExtension(ext: Extension, source: ToolRuntimeSource | undefined): LiveToolRecord[];
+export declare function liveToolDetail(live: LiveToolRecord | undefined): string | undefined;
+/** Project-local items only. Uses the directory that contains `.omp`, when present. */
+export declare function projectListHint(ext: Extension): string | undefined;
+export declare function joinListHints(...parts: Array<string | undefined>): string | undefined;
+export declare function formatExtensionListHint(ext: Extension, lives?: LiveToolRecord[]): string | undefined;
+export declare function toolInspectorData(ext: Extension, lives: LiveToolRecord[], source?: ExtensionInspectorSource): {
+    label?: string;
+    description?: string;
+    params: ToolParamView[];
+    runtimeDetail?: string;
+    factory: LiveToolRecord[];
+};
+export declare function ruleInspectorData(ext: Extension, source?: ExtensionInspectorSource): {
+    description?: string;
+    alwaysApply: boolean;
+    globs?: string[];
+    condition?: string[];
+    astCondition?: string[];
+    scope?: string[];
+    agents?: string[];
+    interruptMode?: string;
+    content: string;
+    runtimeDetail?: string;
+};
+export declare function skillInspectorData(ext: Extension): {
+    description?: string;
+    content: string;
+    globs?: string[];
+    alwaysApply: boolean;
+    hidden: boolean;
+    runtimeDetail?: string;
+};
+export declare function commandInspectorData(ext: Extension): {
+    description?: string;
+    body: string;
+    argumentHint?: string;
+    usesArguments: boolean;
+    runtimeDetail?: string;
+};
+export declare function hookInspectorData(ext: Extension): {
+    hookType?: string;
+    tool?: string;
+    runtimeDetail?: string;
+};
+export declare function promptInspectorData(ext: Extension): {
+    content: string;
+    runtimeDetail?: string;
+};
+export declare function instructionInspectorData(ext: Extension): {
+    content: string;
+    applyTo?: string;
+    runtimeDetail?: string;
+};
+export declare function contextInspectorData(ext: Extension): {
+    content: string;
+    runtimeDetail?: string;
+};
+export declare function enablementLabel(state: ExtensionState, reason?: string, shadowedBy?: string): string;

package/dist/types/overlays/extensions/inspector-panel.d.ts

@@ -0,0 +1,17 @@
+import type { Component } from "../../tui.js";
+import { type ExtensionInspectorSource, type ToolRuntimeSource } from "./inspector-model.js";
+import { type MCPRuntimeSource } from "./mcp-runtime.js";
+import { type Extension } from "./types.js";
+export type { ToolRuntimeSource };
+export declare class InspectorPanel implements Component {
+    #private;
+    constructor(source?: ExtensionInspectorSource);
+    setExtension(extension: Extension | null): void;
+    setMcpSource(source: MCPRuntimeSource | undefined): void;
+    setToolSource(source: ToolRuntimeSource | undefined): void;
+    setHeight(height: number): void;
+    isExpanded(): boolean;
+    toggleExpanded(): boolean;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/extensions/live-tool-session.d.ts

@@ -0,0 +1,28 @@
+export interface LiveToolInfo {
+    name: string;
+    sourceInfo: {
+        source: string;
+        path?: string;
+    };
+}
+import type { LiveToolRecord, ToolRuntimeSource } from "./inspector-model.js";
+/** Session methods the `/extensions` live-tool join actually uses. */
+export interface LiveToolSessionLookup {
+    getToolByName(name: string): {
+        name: string;
+        label?: string;
+        description?: string;
+        parameters?: unknown;
+        hidden?: boolean;
+        loadMode?: "essential" | "discoverable";
+    } | undefined;
+    getAllToolInfos(): LiveToolInfo[];
+}
+/** Convert an already-fetched ToolInfo plus the registered tool. */
+export declare function liveToolRecordFromInfo(session: LiveToolSessionLookup, info: LiveToolInfo): LiveToolRecord | undefined;
+/** One-name lookup. Obtains a fresh ToolInfo snapshot for that name. */
+export declare function liveToolRecordFromSession(session: LiveToolSessionLookup, name: string): LiveToolRecord | undefined;
+/** List every live tool. Calls `getAllToolInfos()` once. */
+export declare function listLiveToolRecords(session: LiveToolSessionLookup): LiveToolRecord[];
+/** One list snapshot for a dashboard/list/inspector render. Not a persistent cache. */
+export declare function snapshotToolRuntimeSource(source: ToolRuntimeSource | undefined): ToolRuntimeSource | undefined;

package/dist/types/overlays/extensions/mcp-runtime.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Live MCP runtime view-model for `/extensions`.
+ *
+ * Discovery yields config (`MCPServer`). `MCPManager` holds the live connection.
+ * This module joins them by server name without stuffing runtime objects into
+ * `Extension.raw`.
+ */
+/** Config and connection fields actually consumed by the dashboard. */
+export interface MCPServerConfigDisplay {
+    type?: string;
+    transport?: string;
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, unknown>;
+}
+export interface MCPServerDisplay extends MCPServerConfigDisplay {
+    name: string;
+    enabled?: boolean;
+    _source: unknown;
+}
+export interface MCPImplementationDisplay {
+    name: string;
+    version?: string;
+    title?: string;
+    description?: string;
+    websiteUrl?: string;
+}
+export interface MCPResourceDisplay {
+    name: string;
+    title?: string;
+    description?: string;
+    uri?: string;
+    uriTemplate?: string;
+}
+export interface MCPConnectionDisplay {
+    name: string;
+    config: MCPServerConfigDisplay;
+    serverInfo?: MCPImplementationDisplay;
+    instructions?: string;
+    tools?: Array<{
+        name: string;
+        title?: string;
+        description?: string;
+        annotations?: {
+            title?: string;
+        };
+        inputSchema?: unknown;
+    }>;
+    resources?: MCPResourceDisplay[];
+    resourceTemplates?: MCPResourceDisplay[];
+    prompts?: MCPResourceDisplay[];
+}
+export type MCPConnectionHealth = "connected" | "connecting" | "disconnected" | "inactive";
+export interface MCPRuntimeCatalogItem {
+    name: string;
+    title?: string;
+    description?: string;
+    /** MCP `inputSchema` / bridged `parameters`. Rendered on expand. */
+    parameters?: unknown;
+}
+export interface MCPRuntimeSnapshot {
+    health: MCPConnectionHealth;
+    transport: "stdio" | "sse" | "http";
+    title?: string;
+    description?: string;
+    websiteUrl?: string;
+    implementationName?: string;
+    implementationVersion?: string;
+    instructions?: string;
+    tools: MCPRuntimeCatalogItem[];
+    resources: MCPRuntimeCatalogItem[];
+    prompts: MCPRuntimeCatalogItem[];
+    command?: string;
+    args?: string[];
+    url?: string;
+    envCount: number;
+}
+/** Narrow manager surface so tests can stub without constructing MCPManager. */
+export interface MCPRuntimeSource {
+    getConnectionStatus(name: string): "connected" | "connecting" | "disconnected";
+    getConnection(name: string): MCPConnectionDisplay | undefined;
+    getTools(): Array<{
+        mcpServerName?: string;
+        mcpToolName?: string;
+        description?: string;
+        label?: string;
+        parameters?: unknown;
+    }>;
+    getServerResources?(name: string): {
+        resources: MCPResourceDisplay[];
+        templates: MCPResourceDisplay[];
+    } | undefined;
+    getServerPrompts?(name: string): MCPResourceDisplay[] | undefined;
+}
+export declare function isDiscoveredMcpServer(raw: unknown): raw is MCPServerDisplay;
+export declare function inferMcpTransport(server: MCPServerDisplay | MCPServerConfigDisplay): "stdio" | "sse" | "http";
+export declare function snapshotMcpRuntime(server: MCPServerDisplay, manager: MCPRuntimeSource | undefined, opts?: {
+    enabled?: boolean;
+    shadowed?: boolean;
+}): MCPRuntimeSnapshot;
+export declare function formatMcpListHint(snapshot: MCPRuntimeSnapshot): string;
+export declare function formatMcpHealthLabel(health: MCPConnectionHealth): string;
+export declare function visibleMcpTools(tools: MCPRuntimeCatalogItem[], limit?: number): {
+    shown: MCPRuntimeCatalogItem[];
+    hidden: number;
+};

package/dist/types/overlays/extensions/state-manager.d.ts

@@ -0,0 +1,42 @@
+import { type DashboardState, type DisabledReason, type Extension, type ExtensionState, type FlatTreeItem, type ProviderTab, type ExtensionProvider, type TreeNode } from "./types.js";
+export declare function resolveExtensionState(source: {
+    provider: string;
+    level: string;
+}, isDisabled: boolean, isShadowed: boolean | undefined, providers: readonly ExtensionProvider[]): {
+    state: ExtensionState;
+    disabledReason?: DisabledReason;
+};
+/**
+ * Build sidebar tree from extensions.
+ * Groups by provider → kind.
+ */
+export declare function buildSidebarTree(extensions: Extension[], providers: readonly ExtensionProvider[]): TreeNode[];
+/**
+ * Flatten tree for keyboard navigation.
+ */
+export declare function flattenTree(tree: TreeNode[]): FlatTreeItem[];
+/**
+ * Apply fuzzy filter to extensions.
+ */
+export declare function applyFilter(extensions: Extension[], query: string): Extension[];
+/**
+ * Build provider tabs from extensions.
+ */
+export declare function buildProviderTabs(extensions: Extension[], providers: readonly ExtensionProvider[]): ProviderTab[];
+/**
+ * Filter extensions by provider tab.
+ */
+export declare function filterByProvider(extensions: Extension[], providerId: string): Extension[];
+/**
+ * Apply setting-backed item disable overrides to an existing dashboard state.
+ * This gives the UI immediate feedback while the full capability refresh runs.
+ */
+export declare function applyDisabledExtensionsToState(state: DashboardState, disabledIds: string[], providers?: readonly ExtensionProvider[]): DashboardState;
+/**
+ * Create initial dashboard state.
+ */
+export declare function createInitialState(extensions: Extension[], providers: readonly ExtensionProvider[]): DashboardState;
+/**
+ * Refresh state after toggle.
+ */
+export declare function refreshState(state: DashboardState, extensions: Extension[], providers: readonly ExtensionProvider[]): DashboardState;

package/dist/types/overlays/extensions/types.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Types for the Extension Control Center dashboard.
+ */
+/** Discovery snapshot used by provider controls, independent of the loader. */
+export interface ExtensionProvider {
+    id: string;
+    displayName: string;
+    enabled: boolean;
+    userSourceEnabled: boolean;
+    foreignUserSource: boolean;
+}
+/**
+ * Extension kinds matching capability types.
+ */
+export type ExtensionKind = "extension-module" | "skill" | "rule" | "tool" | "mcp" | "prompt" | "instruction" | "context-file" | "hook" | "slash-command";
+/**
+ * Extension state (active, disabled, or shadowed).
+ */
+export type ExtensionState = "active" | "disabled" | "shadowed";
+/**
+ * Reason why an extension is disabled.
+ */
+export type DisabledReason = "provider-disabled" | "user-opt-in" | "item-disabled" | "shadowed";
+/**
+ * Unified extension representation for the dashboard.
+ * Normalizes all capability types into a common shape.
+ */
+export interface Extension {
+    /** Unique ID: `${kind}:${name}` */
+    id: string;
+    /** Extension kind */
+    kind: ExtensionKind;
+    /** Extension name */
+    name: string;
+    /** Display name (may differ from name) */
+    displayName: string;
+    /** Description if available */
+    description?: string;
+    /** Trigger pattern (slash command, glob, regex) */
+    trigger?: string;
+    /** Absolute path to source file */
+    path: string;
+    /** Source metadata */
+    source: {
+        provider: string;
+        providerName: string;
+        level: "user" | "project" | "native";
+    };
+    /** Current state */
+    state: ExtensionState;
+    /** Reason for disabled state */
+    disabledReason?: DisabledReason;
+    /** If shadowed, what shadows it */
+    shadowedBy?: string;
+    /**
+     * Raw item data for inspector. For `kind: "mcp"` this remains the discovered
+     * `MCPServer` config — live connection state is joined at render time via
+     * {@link snapshotMcpRuntime}, not stuffed into this bag.
+     */
+    raw: unknown;
+}
+/**
+ * True when this row is a lower-precedence copy of another same-name item.
+ * Disablement takes display precedence (`state === "disabled"`), but the
+ * discovery `_shadowed` flag (and `shadowedBy`) still mark the row as a
+ * loser — it must not be toggleable and must not join the winner's live state.
+ */
+export declare function isShadowedExtension(ext: Extension): boolean;
+/**
+ * Tree node types for sidebar hierarchy.
+ */
+export type TreeNodeType = "provider" | "kind" | "item";
+/**
+ * Sidebar tree node.
+ */
+export interface TreeNode {
+    /** Unique ID */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Node type (provider can be toggled, kind groups items) */
+    type: TreeNodeType;
+    /** Whether this node/provider is enabled */
+    enabled: boolean;
+    /** Whether collapsed */
+    collapsed: boolean;
+    /** Child nodes */
+    children: TreeNode[];
+    /** Extension count (for display) */
+    count?: number;
+}
+/**
+ * Flattened tree item for navigation.
+ */
+export interface FlatTreeItem {
+    node: TreeNode;
+    depth: number;
+    index: number;
+}
+/**
+ * Focus region in the tabbed dashboard.
+ */
+export type FocusRegion = "tabs" | "list";
+/**
+ * Provider tab representation.
+ */
+export interface ProviderTab {
+    /** Provider ID (or "all" for the ALL tab) */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Whether provider is enabled (always true for "all") */
+    enabled: boolean;
+    /** Extension count for this provider */
+    count: number;
+}
+/**
+ * Tabbed dashboard state.
+ */
+export interface DashboardState {
+    /** Provider tabs */
+    tabs: ProviderTab[];
+    /** Active tab index */
+    activeTabIndex: number;
+    /** All extensions (unfiltered) */
+    extensions: Extension[];
+    /** Extensions filtered by active tab */
+    tabFiltered: Extension[];
+    /** Extensions filtered by search (applied after tab filter) */
+    searchFiltered: Extension[];
+    /** Current search query */
+    searchQuery: string;
+    /** Selected index in main list */
+    listIndex: number;
+    /** Scroll offset for main list */
+    scrollOffset: number;
+    /** Currently selected extension for inspector */
+    selected: Extension | null;
+}
+/**
+ * Callbacks from dashboard to parent.
+ */
+export interface DashboardCallbacks {
+    /** Called when provider is toggled */
+    onProviderToggle: (providerId: string, enabled: boolean) => void;
+    /** Called when extension item is toggled */
+    onExtensionToggle: (extensionId: string, enabled: boolean) => void;
+    /** Called when dashboard is closed */
+    onClose: () => void;
+}
+/**
+ * Create extension ID from kind and name.
+ */
+export declare function makeExtensionId(kind: ExtensionKind, name: string): string;
+/**
+ * Parse extension ID into kind and name.
+ */
+export declare function parseExtensionId(id: string): {
+    kind: ExtensionKind;
+    name: string;
+} | null;
+/**
+ * Map SourceMeta to extension source shape.
+ */
+export declare function sourceFromMeta(meta: Extension["source"]): Extension["source"];

package/dist/types/overlays/history-search.d.ts

@@ -0,0 +1,16 @@
+/** Prompt history fields displayed in search results. */
+export interface HistorySearchEntry {
+    prompt: string;
+    created_at: number;
+}
+/** Searchable prompt history supplied by the host. */
+export interface HistorySource {
+    search(query: string, limit: number): HistorySearchEntry[];
+    getRecent(limit: number): HistorySearchEntry[];
+}
+import { OverlayPanel } from "../chrome/overlay-box.js";
+export declare class HistorySearchComponent extends OverlayPanel {
+    #private;
+    constructor(historyStorage: HistorySource, onSelect: (prompt: string) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

package/dist/types/overlays/hook-editor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Multi-line editor component for hooks and ask custom input.
+ * Supports Ctrl+G for external editor.
+ *
+ * Two modes:
+ * - Default (hook): Enter inserts newline, the `app.message.followUp` chord
+ *   (Ctrl+Q / Ctrl+Enter) submits, bordered popup
+ * - Prompt-style (ask): Enter submits, Shift+Enter inserts newline, legacy ask chrome
+ */
+import { type Focusable, type TUI } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+export interface HookEditorOptions {
+    /** Edit text with the host's configured external editor. */
+    externalEditor?: (text: string) => Promise<string | null>;
+    /** When true, use prompt-style keybindings with the legacy ask prompt chrome. */
+    promptStyle?: boolean;
+    /**
+     * Max rows the inner Editor may occupy. When omitted, the editor is
+     * bounded to the current terminal height minus the component's chrome
+     * (≈10 rows) so long content scrolls instead of pushing the submit
+     * hint out of view.
+     */
+    maxHeight?: number;
+}
+/** Interactive multiline dialog used by hooks and the ask tool's Other response. */
+export declare class HookEditorComponent extends OverlayPanel implements Focusable {
+    #private;
+    /** Focus state mirrored to the nested editor during rendering. */
+    focused: boolean;
+    constructor(tui: TUI, title: string, prefill: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, options?: HookEditorOptions);
+    /** Keep the nested editor's software/hardware cursor mode aligned with the dialog focus target. */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
+    /** Render the dialog after forwarding its focus state to the nested editor. */
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+    /** Reserve ordered clipboard delivery. Completion accepts nonempty text once, or releases on undefined. */
+    beginPaste(): (text: string | undefined) => boolean;
+    dispose(): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner editor, mirroring bracketed-paste semantics. Without this hook,
+     *  enhanced-paste routing falls back to the main prompt editor hidden behind the
+     *  dialog (#2127 routing contract). */
+    pasteText(text: string): void;
+}

package/dist/types/overlays/hook-input.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Simple text input component for hooks.
+ */
+import { type TUI } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+export interface HookInputOptions {
+    tui?: TUI;
+    timeout?: number;
+    onTimeout?: () => void;
+}
+export declare class HookInputComponent extends OverlayPanel {
+    #private;
+    constructor(title: string, _placeholder: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, opts?: HookInputOptions);
+    handleInput(keyData: string): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner field, mirroring bracketed-paste semantics. Pasting counts as
+     *  interaction, so the timeout countdown resets like any keystroke. */
+    pasteText(text: string): void;
+    dispose(): void;
+}

package/dist/types/overlays/hook-selector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Generic selector component for hooks.
+ * Displays a list of string options with keyboard navigation.
+ */
+import { type TUI } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** One segment of a {@link HookSelectorSlider} — a label and an optional
+ *  detail line (e.g. the resolved model name) shown beneath the track while
+ *  the segment is active. Segment colors come from the track's theme palette,
+ *  assigned by position. */
+export interface HookSelectorSliderSegment {
+    label: string;
+    /** Secondary line rendered under the track when this segment is selected. */
+    detail?: string;
+}
+/**
+ * A horizontal left/right selector rendered above the option list. Unlike the
+ * up/down option cursor, the slider is moved with the left/right arrows from
+ * any list position, letting the caller capture an orthogonal choice (e.g. the
+ * model tier to continue execution with) alongside the selected option.
+ */
+export interface HookSelectorSlider {
+    /** Dim caption rendered before the slider track (e.g. "continue with"). */
+    caption?: string;
+    segments: HookSelectorSliderSegment[];
+    /** Initially highlighted segment index. */
+    index: number;
+    /** Invoked with the new index whenever the slider moves. */
+    onChange?: (index: number) => void;
+}
+export interface HookSelectorOptions {
+    tui?: TUI;
+    timeout?: number;
+    onTimeout?: () => void;
+    onTimeoutStart?: () => void;
+    onTimeoutReset?: () => void;
+    initialIndex?: number;
+    outline?: boolean;
+    maxVisible?: number;
+    onLeft?: () => void;
+    onRight?: () => void;
+    onExternalEditor?: () => void;
+    helpText?: string;
+    slider?: HookSelectorSlider;
+    /** Indices into the original options that cannot be selected: they render
+     *  dimmed, are skipped during navigation, and reject enter/timeout. */
+    disabledIndices?: readonly number[];
+    /** Render a leading radio/checkbox marker before each markable option,
+     *  matching the ask transcript. "radio" fills the marker on the cursor row
+     *  (single-choice); "checkbox" reflects {@link checkedIndices} per row
+     *  (multi-select). Options at or beyond {@link markableCount} keep the plain
+     *  cursor prefix — used for trailing control rows like "Other"/"Done". */
+    selectionMarker?: "radio" | "checkbox";
+    /** For `selectionMarker: "checkbox"`: original-indices currently checked. */
+    checkedIndices?: readonly number[];
+    /** Number of leading options (original order) that receive a selection
+     *  marker. Defaults to every option when {@link selectionMarker} is set. */
+    markableCount?: number;
+}
+export interface HookSelectorOption {
+    label: string;
+    description?: string;
+}
+export type HookSelectorOptionInput = string | HookSelectorOption;
+export declare class HookSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(title: string, options: HookSelectorOptionInput[], onSelect: (option: string) => void, onCancel: () => void, opts?: HookSelectorOptions);
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+    dispose(): void;
+}