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

package/dist/types/status-line/host.d.ts

@@ -0,0 +1,129 @@
+import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Tool, UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { CompactionBoundaries } from "./context-usage.js";
+import type { StatusLineSettings } from "./types.js";
+export interface StatusAccountIdentity {
+    accountId?: string;
+    email?: string;
+    projectId?: string;
+    orgId?: string;
+}
+/** Nested repository selected as the active workspace context. */
+export interface ActiveRepoContext {
+    cwd: string;
+    repoRoot: string;
+    relativeRepoRoot: string;
+    source: "single-direct-child-repo";
+}
+export interface StatusLineSession {
+    state: {
+        model?: Model;
+        thinkingLevel?: ThinkingLevel;
+        messages: readonly AgentMessage[];
+    };
+    model?: Model;
+    messages?: readonly AgentMessage[];
+    sessionFile?: string;
+    isStreaming: boolean;
+    isAutoThinking: boolean;
+    contextUsageRevision?: number;
+    systemPrompt?: readonly string[];
+    agent?: {
+        state?: {
+            tools?: readonly Pick<Tool, "name" | "description" | "parameters">[];
+        };
+        tokenizer?: unknown;
+    };
+    skills?: readonly unknown[];
+    compactionSpeculation?: "idle" | "running" | "armed";
+    sessionManager: {
+        getSessionName(): string | undefined;
+        getSessionId(): string;
+        getUsageStatistics(): {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+            totalTokens: number;
+            orchestrationInput: number;
+            orchestrationOutput: number;
+            orchestrationCacheRead: number;
+            premiumRequests: number;
+            cost: number;
+        };
+    };
+    modelRegistry: {
+        isUsingOAuth(model: Model): boolean;
+    };
+    getContextUsage(): {
+        tokens: number;
+        contextWindow: number;
+        percent: number | null;
+    } | undefined;
+    autoResolvedThinkingLevel(): string | undefined;
+    isFastModeActive(): boolean;
+    getPrewalkState?(): unknown;
+    getAsyncJobSnapshot(): {
+        running: readonly {
+            type: string;
+            agentId?: string;
+        }[];
+    } | null | undefined;
+    getGoalModeState(): {
+        goal?: {
+            status: string;
+            tokensUsed: number;
+            tokenBudget?: number;
+        };
+    } | undefined;
+    getAdvisorStatusOverview?(): {
+        configured: boolean;
+        advisors: readonly {
+            status: string;
+            yielded: boolean;
+        }[];
+    };
+    getAdvisorCost?(): number;
+    isAdvisorUsingSubscription?(): boolean;
+}
+export interface FooterSession {
+    state: Pick<StatusLineSession["state"], "model" | "thinkingLevel">;
+    isAutoThinking: boolean;
+    autoResolvedThinkingLevel(): string | undefined;
+    getContextUsage: StatusLineSession["getContextUsage"];
+    modelRegistry: Pick<StatusLineSession["modelRegistry"], "isUsingOAuth">;
+    sessionManager: {
+        getEntries(): readonly {
+            type: string;
+            message?: AgentMessage;
+        }[];
+    };
+}
+/**
+ * Runtime services stay in the host; renderers only consume these capabilities.
+ * `TSession` is the host's concrete session type (a structural superset of {@link StatusLineSession}).
+ */
+export interface StatusLineHost<TSession extends StatusLineSession = StatusLineSession> {
+    getSettings(): StatusLineSettings;
+    gitEnabled(): boolean;
+    codexResetFireworksEnabled(): boolean;
+    getSettingsRevision(): number;
+    getSessionSettingsIdentity(session: TSession): unknown;
+    getSessionSettingsRevision(session: TSession): number;
+    goalStatusInFooter(session: TSession): boolean;
+    activeAccount(session: TSession, provider: string): StatusAccountIdentity | undefined;
+    canFetchUsageReports(session: TSession): boolean;
+    fetchUsageReports(session: TSession, signal: AbortSignal): Promise<unknown>;
+    resolveActiveRepo(cwd: string): ActiveRepoContext | null;
+    lookupPullRequest(cwd: string): Promise<{
+        stdout: string;
+        exitCode: number;
+    }>;
+    calculateTokensPerSecond(messages: readonly AgentMessage[], isStreaming: boolean): number | null;
+    limitMatchesActiveAccount(report: UsageReport, limit: UsageLimit, identity: StatusAccountIdentity): boolean;
+    computeCompactionBoundaries(session: TSession, contextWindow: number, model?: Model): CompactionBoundaries | null;
+}
+export interface FooterHost {
+    gitEnabled(): boolean;
+}

package/dist/types/status-line/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./component.js";
+export * from "./metrics.js";
+export * from "./presets.js";
+export * from "./segments.js";
+export * from "./separators.js";
+export * from "./types.js";

package/dist/types/status-line/loop.d.ts

@@ -0,0 +1,18 @@
+/** A `/loop --while` / `/loop --until` continue-condition. */
+export interface LoopConditionConfig {
+    /** Shell command line, run through the user's configured shell. */
+    command: string;
+    /** `--until`: continue while the command *fails*. `--while`: while it succeeds. */
+    until: boolean;
+}
+export type LoopLimitRuntime = {
+    kind: "iterations";
+    initial: number;
+    remaining: number;
+} | {
+    kind: "duration";
+    durationMs: number;
+    deadlineMs: number;
+};
+/** Compact status-line form: `until: bun test`. */
+export declare function summarizeLoopCondition(condition: LoopConditionConfig, maxWidth: number): string;

package/dist/types/status-line/metrics.d.ts

@@ -0,0 +1,21 @@
+import type { Theme } from "../theme/index.js";
+/** Inputs whose differences are intentionally preserved between current status segments and the legacy footer. */
+export interface BillingSummaryOptions {
+    readonly cost: number;
+    readonly usingSubscription: boolean;
+    readonly premiumRequests: number;
+    readonly fractionDigits: number;
+    readonly startupPlaceholder?: boolean;
+    readonly pricingPeriod?: "peak" | "off-peak";
+    readonly advisor?: {
+        readonly cost: number;
+        readonly usingSubscription: boolean;
+    };
+}
+/** Round premium-request counters without losing legitimate fractional requests. */
+export declare function normalizePremiumRequests(value: number): number;
+/**
+ * Shared billing metric presentation. Callers select precision explicitly so
+ * the legacy footer keeps three decimals while current status segments keep two.
+ */
+export declare function formatBillingSummary(options: BillingSummaryOptions, uiTheme: Theme): string | undefined;

package/dist/types/status-line/presets.d.ts

@@ -0,0 +1,3 @@
+import type { PresetDef, StatusLinePreset } from "./types.js";
+export declare const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef>;
+export declare function getPreset(name: StatusLinePreset): PresetDef;

package/dist/types/status-line/schema.d.ts

@@ -0,0 +1,15 @@
+/** Status line segment identifiers accepted by custom status-line settings. */
+export declare const STATUS_LINE_SEGMENT_IDS: readonly ["pi", "status", "model", "mode", "path", "git", "pr", "subagents", "token_in", "token_out", "token_total", "token_rate", "cost", "context_pct", "context_total", "time_spent", "time", "session", "hostname", "cache_read", "cache_write", "cache_hit", "session_name", "usage", "collab", "stream", "vim"];
+/** One identifier from the supported status-line segment catalog. */
+export type StatusLineSegmentId = (typeof STATUS_LINE_SEGMENT_IDS)[number];
+/** Baseline segments used when Custom is selected without segment overrides. */
+export declare const CUSTOM_STATUS_LINE_DEFAULTS: {
+    readonly left: StatusLineSegmentId[];
+    readonly right: StatusLineSegmentId[];
+};
+export declare const CONTEXT_LINE_MODE_VALUES: readonly ["off", "percentage", "annotated", "embedded"];
+export type ContextLineMode = (typeof CONTEXT_LINE_MODE_VALUES)[number];
+export declare const STATUS_LINE_PRESET_VALUES: readonly ["default", "minimal", "compact", "full", "nerd", "ascii", "custom"];
+export type StatusLinePreset = (typeof STATUS_LINE_PRESET_VALUES)[number];
+export declare const STATUS_LINE_SEPARATOR_VALUES: readonly ["powerline", "powerline-thin", "slash", "pipe", "block", "none", "ascii"];
+export type StatusLineSeparatorStyle = (typeof STATUS_LINE_SEPARATOR_VALUES)[number];

package/dist/types/status-line/segments.d.ts

@@ -0,0 +1,5 @@
+import type { RenderedSegment, SegmentContext, StatusLineSegment, StatusLineSegmentId } from "./types.js";
+export type { SegmentContext } from "./types.js";
+export declare const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment>;
+export declare function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment;
+export declare const ALL_SEGMENT_IDS: StatusLineSegmentId[];

package/dist/types/status-line/separators.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from "../theme/index.js";
+import type { SeparatorDef, StatusLineSeparatorStyle } from "./types.js";
+export declare function getSeparator(style: StatusLineSeparatorStyle, theme: Theme): SeparatorDef;

package/dist/types/status-line/types.d.ts

@@ -0,0 +1,236 @@
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { SessionState } from "@oh-my-pi/pi-wire";
+import type { ContextLineMode, StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "./schema.js";
+import type { ActiveRepoContext, StatusLineSession } from "./host.js";
+import type { LoopConditionConfig, LoopLimitRuntime } from "./loop.js";
+export type { ContextLineMode, StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle };
+/** Context-window occupancy shown by the status line and exposed to extensions. */
+export interface ContextUsage {
+    /** Estimated context tokens. */
+    tokens: number;
+    contextWindow: number;
+    /** Context usage as percentage of context window. */
+    percent: number;
+}
+/** Debounced footer snapshot a collab host broadcasts to guests. */
+export type CollabSessionState = SessionState & {
+    /**
+     * Host model (full catalog object). Guests apply it to their replica
+     * agent state so model display and context-window math are native.
+     */
+    model?: Model;
+    /** Host status-line context numbers (guest system prompt/tools differ, so local estimates drift). */
+    contextUsage?: ContextUsage;
+};
+/** Collab session indicator + (guest-only) host-state override for segments. */
+export interface CollabStatus {
+    role: "host" | "guest";
+    participantCount: number;
+    /** Guest only: host footer snapshot that overrides locally computed values. */
+    stateOverride?: CollabSessionState | null;
+}
+export interface StatusLineSegmentOptions {
+    model?: {
+        showThinkingLevel?: boolean;
+    };
+    path?: {
+        abbreviate?: boolean;
+        maxLength?: number;
+        stripWorkPrefix?: boolean;
+    };
+    git?: {
+        showBranch?: boolean;
+        showStaged?: boolean;
+        showUnstaged?: boolean;
+        showUntracked?: boolean;
+    };
+    time?: {
+        format?: "12h" | "24h";
+        showSeconds?: boolean;
+    };
+}
+export interface StatusLineSettings {
+    preset?: StatusLinePreset;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+    showHookStatus?: boolean;
+    sessionAccent?: boolean;
+    /** Drop the theme's `statusLineBg` fill and powerline caps so the bar
+     *  inherits the terminal's default background. */
+    transparent?: boolean;
+    /** Replace the model-segment icon with the thinking-level glyph and drop the
+     *  " · <level>" suffix, so the thinking level reads as a single compact icon. */
+    compactThinkingLevel?: boolean;
+    /** How the gap line between the left and right groups reacts to context
+     *  usage. `embedded` moves configured context segments into the annotated
+     *  gauge as percentage and window labels. Box composer only. */
+    contextLine?: ContextLineMode;
+}
+export type EffectiveStatusLineSettings = Required<Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">> & StatusLineSettings;
+export type RGB = readonly [number, number, number];
+export interface SegmentContext {
+    session: StatusLineSession;
+    /** Deterministic wall clock for previews/tests; production omits it. */
+    now?: Date;
+    /** Deterministic host label for previews/tests; production omits it. */
+    hostname?: string;
+    /** Focused subagent id while the view is proxied at its session, undefined otherwise. */
+    focusedAgentId?: string | undefined;
+    /** Effective `statusLine.sessionAccent`; `false` disables hash-derived accent colors, while `true` or omission enables them. */
+    sessionAccent?: boolean;
+    /** Stand-in session title for previews; `session_name` renders it when the session is unnamed. */
+    previewTitle?: string;
+    /** Replace dynamic values with ellipses while preserving each segment's icon, color, and static text. */
+    startupPlaceholder?: boolean;
+    activeRepo: ActiveRepoContext | null;
+    width: number;
+    options: StatusLineSegmentOptions;
+    /** Render the model segment's thinking level as a compact leading glyph. */
+    compactThinkingLevel: boolean;
+    /** Key-sorted extension/hook status values. Segment renderers sanitize before display. */
+    hookStatuses?: readonly string[];
+    planMode: {
+        enabled: boolean;
+        paused: boolean;
+    } | null;
+    prewalk: {
+        enabled: boolean;
+    } | null;
+    loopMode: {
+        state: "waiting" | "running" | "paused";
+        limit?: LoopLimitRuntime;
+        condition?: LoopConditionConfig;
+    } | null;
+    goalStatusInFooter?: boolean;
+    goalMode: {
+        enabled: boolean;
+        paused: boolean;
+    } | null;
+    vibeMode: {
+        enabled: boolean;
+    } | null;
+    /** Modal editing state, or null when `tui.vimMode` is off. */
+    vim: {
+        mode: "insert" | "normal" | "visual" | "visual-line";
+        /** Half-typed operator/count (`"2d"`), empty when nothing is pending. */
+        pending: string;
+        /** Lines spanned by the active Visual selection; 0 outside Visual modes. */
+        selectedLines: number;
+        /** `tui.vimModeDisplay`: how the mode renders in the status line. */
+        display: "text" | "icon" | "none";
+    } | null;
+    collab: CollabStatus | null;
+    stream: {
+        viewers: number;
+    } | null;
+    usageStats: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        totalTokens: number;
+        orchestrationInput: number;
+        orchestrationOutput: number;
+        orchestrationCacheRead: number;
+        premiumRequests: number;
+        cost: number;
+        tokensPerSecond: number | null;
+    };
+    /** Context usage percent, or null when unknown (e.g. right after compaction). */
+    contextPercent: number | null;
+    contextTokens: number;
+    contextWindow: number;
+    autoCompactEnabled: boolean;
+    /** Background speculative-compaction state (async compaction). */
+    compactionSpeculation: "idle" | "running" | "armed";
+    /** Blink phase for the running-speculation pulse; toggled by the component's timer. */
+    speculationBlinkOn: boolean;
+    subagentCount: number;
+    /**
+     * Active processing time accumulated this session, in ms — the union of
+     * every `agent_start`→`agent_end` window plus the currently-streaming
+     * window if the agent is running. Idle wall-clock never contributes, so
+     * this is what {@link StatusLineSegmentId.time_spent} renders instead of
+     * `Date.now() - sessionStart`.
+     */
+    activeMs: number;
+    /**
+     * Elapsed ms of the currently-running turn (the open `agent_start` window),
+     * or null when the agent is idle. Drives the `pi` segment's working
+     * spinner + turn timer.
+     */
+    turnElapsedMs: number | null;
+    /**
+     * Sampled foreground ANSI for the `pi` brand segment — tweened between dim
+     * gray (idle) and the accent (working) across turn edges (rust omp's
+     * status-band brand fade). Absent in direct-segment fixtures and previews,
+     * which fall back to the static dim color.
+     */
+    brandFgAnsi?: string;
+    git: {
+        branch: string | null;
+        status: {
+            staged: number;
+            unstaged: number;
+            untracked: number;
+        } | null;
+        pr: {
+            number: number;
+            url: string;
+        } | null;
+    };
+    /**
+     * Set when the path cwd is a *linked* git worktree, naming the shared
+     * primary checkout (the project). Lets the path segment collapse the
+     * base-prefixed `<base>/<project>/<worktree>` path to the project name —
+     * the worktree/branch is already shown by the git segment.
+     */
+    worktree: {
+        projectName: string;
+        worktreeName: string;
+    } | null;
+    usage: {
+        tier?: string;
+        fiveHour?: {
+            percent: number;
+            resetMinutes?: number;
+        };
+        daily?: {
+            percent: number;
+            resetMinutes?: number;
+        };
+        sevenDay?: {
+            percent: number;
+            resetHours?: number;
+        };
+        monthly?: {
+            percent: number;
+            resetHours?: number;
+        };
+    } | null;
+}
+export interface RenderedSegment {
+    content: string;
+    visible: boolean;
+}
+export interface StatusLineSegment {
+    id: StatusLineSegmentId;
+    render(ctx: SegmentContext): RenderedSegment;
+}
+export interface SeparatorDef {
+    left: string;
+    right: string;
+    endCaps?: {
+        left: string;
+        right: string;
+        useBgAsFg: boolean;
+    };
+}
+export interface PresetDef {
+    leftSegments: StatusLineSegmentId[];
+    rightSegments: StatusLineSegmentId[];
+    separator: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+}

package/dist/types/stdin-buffer.d.ts

@@ -17,6 +17,10 @@
  * MIT License - Copyright (c) 2025 opentui
  */
 import { EventEmitter } from "events";
+/** Terminal bracketed-paste open marker wrapping pasted input. */
+export declare const BRACKETED_PASTE_START = "\u001B[200~";
+/** Terminal bracketed-paste close marker wrapping pasted input. */
+export declare const BRACKETED_PASTE_END = "\u001B[201~";
 export type StdinBufferOptions = {
     /**
      * Maximum time to wait for sequence completion (default: 75ms).

package/dist/types/theme/color.d.ts

@@ -0,0 +1,24 @@
+import type { ColorMode, ColorValue } from "./schema.js";
+/** SGR reset for the foreground color only, leaving other attributes intact. */
+export declare const FG_RESET = "\u001B[39m";
+/** SGR reset for the background color only, leaving other attributes intact. */
+export declare const BG_RESET = "\u001B[49m";
+/** Resolve theme color depth from the shared terminal capability model. */
+export declare function detectColorMode(env?: NodeJS.ProcessEnv): ColorMode;
+export declare function colorToAnsi(color: string, mode: ColorMode): string;
+export declare function fgAnsi(color: string | number, mode: ColorMode): string;
+export declare function bgAnsi(color: string | number, mode: ColorMode): string;
+export declare function resolveVarRefs(value: ColorValue, vars: Record<string, ColorValue>, visited?: Set<string>): string | number;
+export declare function resolveThemeColors<T extends Record<string, ColorValue>>(colors: T, vars?: Record<string, ColorValue>): Record<keyof T, string | number>;
+/**
+ * Resolve a theme color value (hex string or 256-color index) to a CSS hex string.
+ * Empty string represents the default terminal color.
+ */
+export declare function resolveToHex(value: string | number, isLight: boolean): string;
+/**
+ * Convert a 256-color index to hex string.
+ * Indices 0-15: basic colors (approximate)
+ * Indices 16-231: 6x6x6 color cube
+ * Indices 232-255: grayscale ramp
+ */
+export declare function ansi256ToHex(index: number): string;