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

package/dist/types/setup/scenes/types.d.ts

@@ -0,0 +1,110 @@
+import type { AuthStorage, Model } from "@oh-my-pi/pi-ai";
+import type { OAuthBrowserSessionRequest } from "@oh-my-pi/pi-ai/oauth/types";
+import type { SgrMouseEvent } from "../../mouse.js";
+import type { ComposerPreviewStatusSource } from "../../overlays/composer-shape-preview.js";
+import type { ComposerShape } from "../../overlays/composer-shape-registry.js";
+import type { ModelBrowserSource } from "../../overlays/model-browser.js";
+import type { SymbolPreset } from "../../theme/theme.js";
+import type { SearchProviderId } from "../../tools/web-search.js";
+import type { Component, TUI } from "../../tui.js";
+/** Terminal capabilities used by setup overlays and the startup splash. */
+export interface SetupUiHost {
+    readonly ui: Pick<TUI, "showOverlay" | "setFocus" | "requestRender" | "invalidate"> & {
+        readonly terminal: {
+            readonly rows: number;
+        };
+    };
+}
+/** Application-owned preferences and effects consumed by setup scenes. */
+export interface SetupHost extends SetupUiHost {
+    readonly statusLine: ComposerPreviewStatusSource | undefined;
+    readonly composerShape: ComposerShape;
+    readonly symbolPreset: SymbolPreset;
+    readonly colorBlindMode: boolean;
+    readonly webSearchOrder: readonly string[];
+    readonly disabledProviders: readonly string[];
+    readonly authStorage: AuthStorage;
+    readonly modelSource: ModelBrowserSource;
+    getModels(): {
+        available: Model[];
+        all: Model[];
+        current: Model | undefined;
+    };
+    refreshModels(): Promise<void>;
+    selectModel(model: Model, selector: string): Promise<void>;
+    refreshProvider(provider: string): Promise<void>;
+    saveComposerShape(shape: ComposerShape): Promise<void>;
+    saveSymbolPreset(preset: SymbolPreset): void;
+    saveColorBlindMode(enabled: boolean): void;
+    saveTheme(mode: "dark" | "light", name: string): void;
+    isSearchProviderAvailable(id: SearchProviderId): Promise<boolean>;
+    saveSearchProvider(id: SearchProviderId | "auto"): void;
+    captureBrowserSession(request: OAuthBrowserSessionRequest, signal?: AbortSignal): Promise<string>;
+    copyToClipboard(text: string): Promise<void>;
+    openInBrowser(url: string): void;
+    markComplete(version: number): Promise<void>;
+    playWelcomeIntro(): void;
+    showError(message: string): void;
+}
+/** Outcome reported when an onboarding scene finishes. */
+export type SetupSceneResult = "done" | "skipped";
+/** Per-scene focus, rendering, completion, and application callbacks. */
+export interface SetupSceneHost {
+    ctx: SetupHost;
+    requestRender(): void;
+    finish(result: SetupSceneResult): void;
+    setFocus(component: Component | null): void;
+    restoreFocus(): void;
+}
+/** Interactive content hosted inside the setup wizard frame. */
+export interface SetupSceneController extends Component {
+    title: string;
+    subtitle?: string;
+    onMount?(): void | Promise<void>;
+    onUnmount?(): void;
+    dispose?(): void;
+    /**
+     * Render the scene body. `maxLines` is the number of body rows the wizard
+     * will actually display (header and footer already subtracted); scenes
+     * shrink list windows and drop decorative chrome so the selected row stays
+     * inside the budget. Overflow beyond `maxLines` is clipped by the wizard.
+     */
+    render(width: number, maxLines?: number): readonly string[];
+    /**
+     * Route an SGR mouse report (tracking is on while the wizard holds the
+     * alternate screen). `line`/`col` are 0-based within this controller's
+     * last rendered output. When absent, the wizard falls back to synthesizing
+     * arrow keys from wheel notches.
+     */
+    routeMouse?(event: SgrMouseEvent, line: number, col: number): void;
+}
+/**
+ * A single panel inside a tabbed setup scene. The host scene owns the tab bar
+ * and forwards rendering/input to the active tab.
+ */
+export interface SetupTab {
+    readonly id: string;
+    readonly label: string;
+    /**
+     * While `true` the tab owns all keyboard input (e.g. an in-progress OAuth
+     * login). The parent scene MUST NOT switch tabs or finish while modal.
+     */
+    readonly modal: boolean;
+    /** See {@link SetupSceneController.render}: `maxLines` is the tab-local row budget. */
+    render(width: number, maxLines?: number): readonly string[];
+    handleInput(data: string): void;
+    invalidate(): void;
+    /** Called when the tab becomes active (including initial mount). */
+    onActivate?(): void;
+    /** Mouse routing at tab-local coordinates; see {@link SetupSceneController.routeMouse}. */
+    routeMouse?(event: SgrMouseEvent, line: number, col: number): void;
+    dispose(): void;
+}
+/** Versioned onboarding scene definition. */
+export interface SetupScene {
+    id: string;
+    title: string;
+    minVersion: number;
+    shouldRun?(ctx: SetupHost): boolean | Promise<boolean>;
+    mount(host: SetupSceneHost): SetupSceneController;
+}

package/dist/types/setup/scenes/web-search.d.ts

@@ -0,0 +1,22 @@
+import { type SgrMouseEvent } from "../../mouse.js";
+import type { SetupSceneHost, SetupTab } from "./types.js";
+/**
+ * "Web search" panel: picks the provider the web_search tool should prefer and
+ * reports whether the highlighted provider is ready to use given current
+ * credentials (env keys or OAuth sign-ins from the Sign in tab) or an
+ * unauthenticated fallback.
+ */
+export declare class WebSearchTab implements SetupTab {
+    #private;
+    readonly id = "web-search";
+    readonly label = "Web search";
+    readonly modal = false;
+    constructor(host: SetupSceneHost);
+    onActivate(): void;
+    handleInput(data: string): void;
+    /** Wheel moves the highlight; hover lights the row under the pointer; click confirms it. */
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number, maxLines?: number): readonly string[];
+}

package/dist/types/setup/setup-version.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup version the wizard advances a fresh install to. Bump it whenever a new
+ * setup scene lands (or an existing scene raises its `minVersion`).
+ *
+ * Kept in its own dependency-free module so the cold-launch gate in `main.ts`
+ * can answer "is the stored setup version stale?" without statically importing
+ * the full wizard — every scene (sign-in/OAuth, web search, theme previews) plus
+ * the overlay component and their TUI deps. MUST equal `max(scene.minVersion)`
+ * across `ALL_SCENES`; the setup scene selection tests guard this invariant.
+ */
+export declare const CURRENT_SETUP_VERSION = 2;

package/dist/types/setup/startup-splash.d.ts

@@ -0,0 +1,9 @@
+import type { SetupUiHost } from "./scenes/types.js";
+/** Timing controls for the standalone startup animation. */
+export interface RunStartupSplashOptions {
+    readonly durationMs?: number;
+    readonly tickMs?: number;
+    readonly now?: () => number;
+}
+/** Show the startup animation and restore the previous overlay focus afterward. */
+export declare function runStartupSplash(ctx: SetupUiHost, options?: RunStartupSplashOptions): Promise<void>;

package/dist/types/setup/wizard-overlay.d.ts

@@ -0,0 +1,16 @@
+import { type Component, type OverlayFocusOwner } from "../tui.js";
+import type { SetupHost } from "./scenes/types.js";
+import type { SetupScene } from "./scenes/types.js";
+/** Fullscreen onboarding presentation with scene focus and mouse routing. */
+export declare class SetupWizardComponent implements Component, OverlayFocusOwner {
+    #private;
+    readonly ctx: SetupHost;
+    readonly scenes: readonly SetupScene[];
+    constructor(ctx: SetupHost, scenes: readonly SetupScene[]);
+    run(): Promise<void>;
+    dispose(): void;
+    invalidate(): void;
+    ownsOverlayFocusTarget(component: Component): boolean;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/setup/wizard.d.ts

@@ -0,0 +1,25 @@
+import { CURRENT_SETUP_VERSION } from "./setup-version.js";
+import type { SetupHost } from "./scenes/types.js";
+import type { SetupScene } from "./scenes/types.js";
+export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types.js";
+export { runStartupSplash } from "./startup-splash.js";
+export { CURRENT_SETUP_VERSION };
+/** Ordered onboarding scenes with independent version gates. */
+export declare const ALL_SCENES: readonly [SetupScene, SetupScene, SetupScene, SetupScene, SetupScene];
+/** Environment and invocation gates for onboarding scene selection. */
+export interface SetupSceneSelectionOptions {
+    resuming?: boolean;
+    isTTY?: boolean;
+    skipEnv?: string;
+    setupWizardEnabled?: boolean;
+    force?: boolean;
+}
+/** Select scenes newer than the stored version, honoring hard environment gates. */
+export declare function selectSetupScenes(storedVersion: number, scenes: readonly SetupScene[], ctx?: SetupHost, options?: SetupSceneSelectionOptions): Promise<SetupScene[]>;
+/** Control completion persistence and the post-setup welcome animation. */
+export interface RunSetupWizardOptions {
+    markComplete?: boolean;
+    playWelcomeIntro?: boolean;
+}
+/** Own the fullscreen setup overlay until its scenes and outro finish. */
+export declare function runSetupWizard(ctx: SetupHost, scenes?: readonly SetupScene[], options?: RunSetupWizardOptions): Promise<void>;

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

@@ -0,0 +1,182 @@
+import { type Component, type ComposerStyle } from "../index.js";
+import type { StatusLineHost, StatusLineSession } from "./host.js";
+import { type CodexResetFireworksEvent } from "../overlays/codex-reset-fireworks.js";
+import { type SegmentContext } from "./segments.js";
+import type { CollabStatus, EffectiveStatusLineSettings, StatusLineSettings } from "./types.js";
+type StatusLineLayout = "box" | "band" | "plain-full" | "plain-left" | "plain-right";
+export declare class StatusLineComponent<TSession extends StatusLineSession = StatusLineSession> implements Component {
+    #private;
+    private session;
+    private readonly host;
+    constructor(session: TSession, host: StatusLineHost<TSession>);
+    /**
+     * Re-point the status line at another session (focus proxy). Invalidate: model/context/usage all derive
+     * from it. `focusedAgentId` is the focused subagent id while the view is proxied, undefined for main.
+     */
+    setSession(session: TSession, focusedAgentId?: string): void;
+    updateSettings(settings: StatusLineSettings): void;
+    getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
+    setAutoCompactEnabled(enabled: boolean): void;
+    setRunningSubagents(agentIds: readonly string[]): void;
+    /**
+     * Compatibility shim for callers predating the simplified subagent badge.
+     * The status line now intentionally shows only the active count.
+     */
+    setSubagentHubHint(_hint: string | undefined): void;
+    /** Active subagent count as currently displayed (collab state mirroring). */
+    get subagentCount(): number;
+    /**
+     * Reset the currently-attached session's active-time accumulators so
+     * the `time_spent` segment starts from zero. Called from `/clear`,
+     * fresh-session, and joined-collab paths; both the completed
+     * accumulator and any in-flight window are dropped, so a reset
+     * mid-turn ignores the running window (the matching `markActivityEnd`
+     * will see an idle meter and no-op).
+     */
+    resetActiveTime(): void;
+    /**
+     * Mark the currently-attached session as having started a unit of
+     * active processing. Idempotent: a second start while a window is
+     * already open is a no-op, so reentrant `agent_start` events (e.g.
+     * nested auto-compaction loops, focus-controller mid-turn attach onto
+     * an already-running window) do not double-count.
+     */
+    markActivityStart(): void;
+    /**
+     * Close the currently-attached session's open active-processing
+     * window, folding its elapsed time into the accumulator. Idempotent
+     * when the meter is already idle so callers can fire it on every
+     * `agent_end` without guarding.
+     */
+    markActivityEnd(): void;
+    /**
+     * Snapshot of total active-processing time for the currently-attached
+     * session, including any in-flight window. Exposed for the segment
+     * context builder; tests assert against this too.
+     */
+    getActiveMs(): number;
+    /**
+     * Elapsed ms of the currently-open active-processing window, or null when
+     * idle. Feeds the `pi` segment's working spinner + turn timer.
+     */
+    getTurnElapsedMs(): number | null;
+    setPlanModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setLoopModeStatus(status: NonNullable<SegmentContext["loopMode"]> | undefined): void;
+    setGoalModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setVibeModeStatus(status: {
+        enabled: boolean;
+    } | undefined): void;
+    /** Mirror of the editor's modal state; `undefined` clears it (Vim mode off). */
+    setVimStatus(status: NonNullable<SegmentContext["vim"]> | undefined): void;
+    /**
+     * Inject the aggregator that returns the aggregate tok/s of this session's
+     * live vibe worker sessions (null when no workers are streaming). Wired by
+     * interactive-mode, which owns the VibeSessionRegistry coupling, so the
+     * render layer stays off the heavy vibe/task dependency graph. Pass
+     * `undefined` to clear.
+     */
+    setVibeWorkerTokenRateProvider(provider: (() => number | null) | undefined): void;
+    setCollabStatus(status: CollabStatus | null): void;
+    setStreamStatus(status: {
+        viewers: number;
+    } | null): void;
+    /** Set the callback that presents detected Codex reset celebrations, or clear it with `undefined`. */
+    setCodexResetFireworksHandler(handler: ((event: CodexResetFireworksEvent) => void) | undefined): void;
+    setHookStatus(key: string, text: string | undefined): void;
+    watchBranch(onBranchChange: () => void): void;
+    dispose(): void;
+    invalidate(): void;
+    /**
+     * Explicit Git/repository cache invalidation. Aborts any in-flight
+     * reftable HEAD/PR resolve, bumps the stale-result generation, and drops
+     * the branch/PR/jj caches so the next render refetches from disk. Called
+     * by the git watcher on a HEAD move and by {@link applyCwdChange} on a
+     * repo/cwd switch. Generic repaints use {@link invalidate} instead and
+     * must never reach this path.
+     */
+    invalidateGitCaches(): void;
+    /**
+     * Re-point the status line's VCS watcher and caches at a new cwd/repository.
+     * Atomically retires the old watcher/listeners, invalidates VCS caches and
+     * in-flight controllers, then runs watcher setup for the new cwd and requests
+     * a repaint. Called by {@link InteractiveMode.applyCwdChange} after the
+     * SessionManager's cwd has moved — the watcher ownership always follows the
+     * effective cwd/repo, so a stale watcher for the previous repo can never
+     * invalidate the new one. Generic repaints use {@link invalidate} and must
+     * never retire the watcher or abort a live resolve.
+     */
+    applyCwdChange(): void;
+    /**
+     * Startup redraws only arm a short-delayed task; timeout releases the render
+     * cadence while a late successful fetch can still refresh the cached segment.
+     */
+    refreshUsageInBackground(): void;
+    /**
+     * Used-tokens / context-window totals for the status-line context% segment,
+     * memoized so the per-event redraw stays O(1) when nothing changed.
+     *
+     * The numerator comes from `session.getContextUsage()`, which anchors on the
+     * last assistant's real prompt-token count — so the bar matches the provider
+     * and the `/context` panel — and reports `null` while that count is unknown
+     * (right after compaction, before the next response). Exposed (non-private)
+     * for unit tests and the collab host's state broadcast.
+     */
+    getCachedContextBreakdown(): {
+        usedTokens: number;
+        contextWindow: number;
+    };
+    /** Render startup ellipses inside each segment's normal icon, color, and static chrome. */
+    renderStartupPlaceholder(width: number, layout: StatusLineLayout): string;
+    getTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+        revision: number;
+    };
+    /** Flush-left soft-capped powerline band (the band composer's top row). */
+    getBandTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+        revision: number;
+    };
+    /**
+     * Standalone bar placement derived from the composer style. `bottomBar`
+     * `"full"` renders both groups on the bottom bar (pi/borderless/field/rail);
+     * `"left"` renders just the left group there — the right group attaches to
+     * the editor's top rule via {@link getStandaloneTopBorder} (claude/rule);
+     * `"none"` returns the bar to the box composer's embedded top border.
+     * `bottomBarGap` inserts a blank spacer row above the bar for styles whose
+     * editor has no bottom chrome.
+     */
+    setComposerStyle(style: Pick<ComposerStyle, "statusAttachment" | "bottomBar" | "bottomBarGap">): void;
+    /** While true, the standalone bar yields its row to the editor's autocomplete menu. */
+    setAutocompleteActiveProbe(probe: (() => boolean) | undefined): void;
+    /** Plain right-group content for the claude composer's top rule. */
+    getStandaloneTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+        revision: number;
+    };
+    /**
+     * The plain standalone bottom bar through the real segment/gauge pipeline —
+     * `groups` picks which segment groups it carries. Used by the live render
+     * loop and by composer previews (which inject a candidate layout instead of
+     * the active one).
+     */
+    renderBottomBar(width: number, groups: "left" | "full", previewTitle?: string): string;
+    /**
+     * Status bar lines for a composer layout, rendered through the real
+     * pipeline — the single source for the /settings appearance preview.
+     * `style` overrides the layout (candidate composer shape); omitted, the
+     * active layout is used. Ignores the autocomplete probe: previews always
+     * render.
+     */
+    getPreviewLines(width: number, style?: Pick<ComposerStyle, "statusAttachment" | "bottomBar">): string[];
+    render(width: number): readonly string[];
+}
+export {};

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

@@ -0,0 +1,156 @@
+import type { AgentMessage, Tokenizer } from "@oh-my-pi/pi-agent-core";
+import type { CompactionSettings } from "@oh-my-pi/pi-agent-core/compaction";
+import type { Tool as AiTool, Model } from "@oh-my-pi/pi-ai";
+import type { Theme } from "../theme/index.js";
+interface ContextSkill {
+    readonly name: string;
+    readonly description?: string;
+    readonly hide?: boolean;
+}
+type ContextTool = Pick<AiTool, "name" | "description" | "parameters">;
+/** Savings computed by the host's inline-image planner, not by the renderer. */
+export interface ContextSavingsEstimate {
+    visionCapable: boolean;
+    systemPrompt?: {
+        applied: boolean;
+        reason?: "empty" | "margin" | "budget";
+        textTokens: number;
+        frames: number;
+        imageTokens: number;
+        savedTokens: number;
+        scope: "agents-md" | "all";
+    };
+    toolResults?: {
+        total: number;
+        swapped: number;
+        textTokens: number;
+        frames: number;
+        imageTokens: number;
+        savedTokens: number;
+    };
+    savedTokens: number;
+}
+/** Real sessions satisfy this view without wrapping or copying their state. */
+export interface ContextUsageSession extends NonMessageTokenSource {
+    readonly model: Model | undefined;
+    readonly agent: {
+        readonly tokenizer: Tokenizer;
+        readonly state?: {
+            readonly tools?: readonly ContextTool[];
+        };
+    };
+    readonly messages?: AgentMessage[];
+    getContextBreakdown?(): {
+        messagesTokens: number;
+        skillsTokens: number;
+        systemToolsTokens: number;
+        systemContextTokens: number;
+        systemPromptTokens: number;
+        usedTokens: number;
+    } | undefined;
+}
+export interface ContextUsageOptions {
+    compaction: CompactionSettings;
+    sourceRevision?: number;
+    skillful?: boolean;
+    snapcompact?: ContextSavingsEstimate;
+}
+type CategoryId = "systemPrompt" | "systemContext" | "systemTools" | "skills" | "messages";
+interface CategoryInfo {
+    id: CategoryId;
+    label: string;
+    tokens: number;
+    color: "accent" | "warning" | "success" | "userMessageText" | "customMessageLabel";
+    glyph: string;
+}
+export interface ContextBreakdown {
+    model: Model | undefined;
+    contextWindow: number;
+    categories: CategoryInfo[];
+    usedTokens: number;
+    autoCompactBufferTokens: number;
+    freeTokens: number;
+    /** Estimated snapcompact wire savings; set when requested and a snapcompact.* setting is enabled. */
+    snapcompact?: ContextSavingsEstimate;
+}
+/** Percent positions (0–100 of the context window) for the auto-compaction boundaries. */
+export interface CompactionBoundaries {
+    /** Where auto-compaction fires. */
+    thresholdPercent: number;
+    /**
+     * Where the background speculative summarizer starts (threshold − lead), or
+     * `null` when no speculation will run (async compaction disabled, or the
+     * first available method is local — snapcompact/shake — and thus instant).
+     */
+    speculationPercent: number | null;
+}
+/**
+ * Boundary positions for the status line's annotated context gauge. `null`
+ * when compaction is disabled/off or the window is unknown — the gauge then
+ * renders without markers. The host supplies a lead only when its configured
+ * method and async policy allow speculative compaction.
+ */
+export declare function computeCompactionBoundaries(compactionSettings: CompactionSettings, contextWindow: number, speculationLeadTokens?: number): CompactionBoundaries | null;
+/** Stable inputs used to cache non-message token estimates. */
+export interface NonMessageTokenSource {
+    readonly systemPrompt?: readonly string[];
+    readonly agent?: {
+        readonly state?: {
+            readonly tools?: readonly ContextTool[];
+        };
+    };
+    readonly skills?: readonly ContextSkill[];
+}
+/** Shared empty system-prompt part list, avoiding an allocation per render. */
+export declare const EMPTY_STRING_PARTS: string[];
+export declare function estimateSkillsTokens(skills: readonly ContextSkill[], tokenizer: Tokenizer): number;
+type ToolSchemaSource = readonly ContextTool[];
+/**
+ * Current dynamic metadata revision for one tool roster.
+ *
+ * Consumers caching a larger context breakdown must key on both the tools
+ * array identity and this revision. Array replacement covers roster changes;
+ * {@link invalidateToolSchemaMetadata} covers live description/schema changes
+ * while the roster object remains stable.
+ */
+export declare function getToolSchemaMetadataRevision(tools: ToolSchemaSource): number;
+/**
+ * Invalidate token estimates after a live tool description or parameter schema
+ * can change without replacing the tools array (settings, model, policy, or
+ * discovered-agent metadata changes).
+ */
+export declare function invalidateToolSchemaMetadata(tools: ToolSchemaSource): void;
+/**
+ * Estimate provider-visible tool-schema tokens.
+ *
+ * Results are cached by roster-array identity, tokenizer identity, the
+ * caller-supplied settings/source revision, and the roster's explicit dynamic
+ * metadata revision. Callers whose descriptions or schemas are live getters
+ * must either advance `sourceRevision` or call
+ * {@link invalidateToolSchemaMetadata} when those inputs change.
+ */
+export declare function estimateToolSchemaTokens(tools: ToolSchemaSource, tokenizer: Tokenizer, sourceRevision?: number): number;
+export declare function computeNonMessageTokens(session: NonMessageTokenSource, tokenizer: Tokenizer, sourceRevision?: number): number;
+/**
+ * Shared helper for the four non-message token totals used by
+ * `computeContextBreakdown` (/context panel). Keep this category split stable:
+ * the status-line fast path intentionally uses the equivalent collapsed total
+ * in `computeNonMessageTokens`.
+ */
+export declare function computeNonMessageBreakdown(session: NonMessageTokenSource, tokenizer: Tokenizer, sourceRevision?: number, skillful?: boolean): {
+    skillsTokens: number;
+    toolsTokens: number;
+    systemContextTokens: number;
+    systemPromptTokens: number;
+};
+/**
+ * Compute a breakdown of estimated context usage by category for the active
+ * session and model.
+ */
+export declare function computeContextBreakdown(session: ContextUsageSession, options: ContextUsageOptions): ContextBreakdown;
+/**
+ * Render a colorful context-usage panel as ANSI text. Output is a series of
+ * lines pairing the grid (left) with the legend (right).
+ */
+export declare function renderContextUsage(breakdown: ContextBreakdown, theme: Theme): string;
+export {};

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

@@ -0,0 +1,30 @@
+import { type Component } from "../index.js";
+import type { FooterHost, FooterSession } from "./host.js";
+/**
+ * Footer component that shows pwd, token stats, and context usage
+ */
+export declare class FooterComponent implements Component {
+    #private;
+    private readonly session;
+    private readonly host;
+    constructor(session: FooterSession, host: FooterHost);
+    setAutoCompactEnabled(enabled: boolean): void;
+    /**
+     * Set extension status text to display in the footer.
+     * ANSI/VT escape sequences and most control characters are stripped; tabs and newlines become spaces.
+     * The combined status line is trimmed and truncated to terminal width.
+     * @param key - Unique key to identify this status
+     * @param text - Status text, or undefined to clear
+     */
+    setExtensionStatus(key: string, text: string | undefined): void;
+    /**
+     * Watch the repository head for label changes and repaint the footer.
+     */
+    watchBranch(onBranchChange: () => void): void;
+    /**
+     * Clean up the file watcher
+     */
+    dispose(): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Extract "owner/repo" from a GitHub remote URL.
+ * Handles HTTPS, SSH (scp-style), and git:// protocols.
+ *
+ * @returns "owner/repo" or null if the URL isn't a recognized GitHub remote.
+ */
+export declare function parseGitHubRepo(remoteUrl: string): string | null;
+/**
+ * Extract the branch name from a remote HEAD ref like "origin/main".
+ * Returns the portion after the first "/" or the whole string if no "/" is present.
+ */
+export declare function parseDefaultBranch(ref: string): string;
+export interface PrCacheContext {
+    branch: string;
+    repoId: string | null;
+}
+export declare function createPrCacheContext(branch: string, repoId: string | null): PrCacheContext;
+export declare function isSamePrCacheContext(a: PrCacheContext | undefined, b: PrCacheContext | undefined): boolean;
+export declare function canReuseCachedPr(cachedPr: {
+    number: number;
+    url: string;
+} | null | undefined, cachedContext: PrCacheContext | undefined, currentContext: PrCacheContext | null): boolean;