jeopi-cli 16.2.14 → 16.2.15

package/dist/types/modes/components/collab-prompt-message.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "jeopi-tui";
+import type { CollabPromptDetails } from "../../collab/protocol";
+import type { CustomMessage } from "../../session/messages";
+/**
+ * Renders a collab guest prompt on every participant's transcript: a
+ * user-message-styled bubble prefixed with the author's name.
+ */
+export declare class CollabPromptMessageComponent extends Container {
+    constructor(message: CustomMessage<CollabPromptDetails>);
+}

package/dist/types/modes/components/compaction-summary-message.d.ts

@@ -0,0 +1,46 @@
+import { type Component } from "jeopi-tui";
+import type { BranchSummaryMessage, CompactionSummaryMessage, CustomMessage } from "../../session/messages";
+/**
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 compacted · ctrl+o ────────
+ *
+ * The conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
+ */
+export declare class CompactionSummaryMessageComponent implements Component {
+    #private;
+    private readonly message;
+    constructor(message: CompactionSummaryMessage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}
+/**
+ * Handoff is a compaction strategy too, but it is persisted as a custom message
+ * so the LLM sees the handoff-specific developer context. Render it with the
+ * same divider affordance as `/compact` instead of the generic `[handoff]` box.
+ */
+export declare class HandoffSummaryMessageComponent implements Component {
+    #private;
+    private readonly message;
+    constructor(message: CustomMessage<unknown>);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}
+export declare function createHandoffSummaryMessageComponent(message: CustomMessage<unknown>, expanded: boolean): HandoffSummaryMessageComponent | undefined;
+/**
+ * A branch summary collapses a side branch back into the main line. Render it
+ * with the same slim divider as `/compact` and handoff rather than a `[branch]`
+ * box, so every history-collapse point reads as one consistent banner.
+ */
+export declare class BranchSummaryMessageComponent implements Component {
+    #private;
+    private readonly message;
+    constructor(message: BranchSummaryMessage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/copy-selector.d.ts

@@ -0,0 +1,22 @@
+import { type Component } from "jeopi-tui";
+import type { CopyTarget } from "../utils/copy-targets";
+export interface CopySelectorCallbacks {
+    /** A copy target was chosen — copy its `content`. */
+    onPick: (target: CopyTarget) => void;
+    /** The picker was dismissed. */
+    onCancel: () => void;
+}
+/**
+ * Fullscreen `/copy` picker rendered as a `/tree`-style tree inside one
+ * outlined box: a title, the tree of copy targets (recent assistant messages
+ * with their code blocks nested beneath), a live preview of the highlighted
+ * node, and a keybinding footer. Every node copies its `content` on Enter.
+ */
+export declare class CopySelectorComponent implements Component {
+    #private;
+    private readonly callbacks;
+    constructor(roots: CopyTarget[], callbacks: CopySelectorCallbacks);
+    invalidate(): void;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/countdown-timer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reusable countdown timer for dialog components.
+ */
+import type { TUI } from "jeopi-tui";
+export declare class CountdownTimer {
+    #private;
+    private tui;
+    private onTick;
+    private onExpire;
+    constructor(timeoutMs: number, tui: TUI | undefined, onTick: (seconds: number) => void, onExpire: () => void);
+    /** Reset the countdown to its initial value */
+    reset(): void;
+    dispose(): void;
+}

package/dist/types/modes/components/custom-editor.d.ts

@@ -0,0 +1,163 @@
+import type { ImageContent } from "jeopi-ai";
+import { Editor, type KeyId } from "jeopi-tui";
+import type { AppKeybinding } from "../../config/keybindings";
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.retry" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
+ *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
+export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
+/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
+ *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
+ *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
+ *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
+ *  steady. */
+export declare const SPACE_REPEAT_JITTER_MS = 18;
+export declare const SPACE_REPEAT_JITTER_RATIO = 0.35;
+/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
+ *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
+ *  reach it. */
+export declare const SPACE_HOLD_MECHANICAL_RUN = 2;
+/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
+ *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
+export declare const SPACE_HOLD_RELEASE_MS = 250;
+/**
+ * Extract image-or-other file paths from plain (un-bracketed) clipboard text.
+ * Mirrors {@link extractBracketedPastePaths} for terminals/handlers that
+ * already stripped the `\x1b[200~`…`\x1b[201~` markers (e.g. clipboard text
+ * read directly via `pbpaste`/PowerShell).
+ */
+export declare function extractPastePathsFromText(text: string): string[] | undefined;
+export declare function extractBracketedPastePaths(data: string): string[] | undefined;
+export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
+/**
+ * Same shape as {@link extractBracketedImagePastePaths} but operates on a
+ * payload that has already been stripped of the `\x1b[200~` / `\x1b[201~`
+ * markers — used by the assembled-paste router in {@link CustomEditor.handleInput}
+ * so split bracketed pastes get the same image-path detection as single-chunk ones.
+ */
+export declare function extractImagePastePathsFromText(text: string): string[] | undefined;
+export declare function extractBracketedImagePastePath(data: string): string | undefined;
+/**
+ * Return a single image file path when `text` is exactly one explicit path
+ * pointing at a supported image extension (`.png`, `.jpg`/`.jpeg`, `.gif`,
+ * `.webp`). Used by the keybind-driven clipboard image paste path so a
+ * clipboard whose only payload is an image file (e.g. Finder `Cmd+C` on
+ * macOS) attaches the image instead of pasting the path as literal text.
+ *
+ * Two-stage detection:
+ *
+ * 1. Splitter pass (shared with the bracketed-paste handler) — handles
+ *    quoted paths, shell-escaped spaces, and unambiguous single tokens.
+ *    Returns the single image path when it parses cleanly; explicitly
+ *    returns `undefined` when the splitter found multiple segments (so
+ *    ambiguous multi-path clipboard text like `/tmp/a.png /tmp/b.png`
+ *    still falls through to the text fallback instead of being mis-loaded
+ *    as one giant path).
+ * 2. Whole-text-as-path pass — only reached when the splitter failed
+ *    (every segment must look like an explicit path; an unescaped space in
+ *    a real path breaks that). Restricted to inputs anchored by
+ *    {@link ABSOLUTE_PATH_PREFIX_REGEX} so prose containing a path-shaped
+ *    fragment ("see /tmp/x.png") never hijacks the smart fallback. This
+ *    is what recovers macOS screenshot filenames like
+ *    `/Users/me/Desktop/Screenshot 2026-06-25 at 1.23.45 PM.png`.
+ */
+export declare function extractImagePathFromText(text: string): string | undefined;
+/**
+ * Custom editor that handles configurable app-level shortcuts for coding-agent.
+ */
+export declare class CustomEditor extends Editor {
+    #private;
+    imageLinks?: readonly (string | undefined)[];
+    /** Draft images pasted into the composer, consumed on submit. Co-located with
+     *  {@link imageLinks} so every piece of draft-image state lives on the editor. */
+    pendingImages: ImageContent[];
+    /** Per-image source links (file:// targets) parallel to {@link pendingImages};
+     *  `undefined` entries are images without a backing reference yet. */
+    pendingImageLinks: (string | undefined)[];
+    /** Clear the composer draft: optionally commit `historyText` to history, then
+     *  reset the editor text and all pending draft-image state. The shared tail of
+     *  every "message submitted" path; pass no argument for a plain discard. */
+    clearDraft(historyText?: string): void;
+    /** Treat image/paste markers as indivisible: a stray backspace deletes the whole token
+     *  instead of corrupting `[Paste #1, +30 lines]` into plain text. */
+    atomicTokenPattern: RegExp;
+    /** Magic-keyword shimmer cadence — drives one editor repaint every 70 ms while
+     *  a keyword is on screen and the prompt is focused. ~14 frames/s is smooth
+     *  without flooding the renderer. */
+    static readonly SHIMMER_FRAME_MS = 70;
+    /** Time for the gradient to sweep one full cycle across each keyword. */
+    static readonly SHIMMER_PERIOD_MS = 1800;
+    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflowz" keywords as the user types
+     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
+     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists.
+     *  When the editor is focused, the buffer contains a magic keyword, and `magicKeywords.enabled`
+     *  is on, the gradient shifts every frame to produce a Claude-Code-style shimmer; each render
+     *  schedules the next frame, so losing focus, deleting the keyword, or flipping the setting
+     *  stops the animation on its own. The static glow itself runs even when shimmering is gated
+     *  off, matching existing behavior for the editor and sent bubbles. */
+    decorateText: (text: string) => string;
+    /** Optional test/host override for the magic-keyword shimmer gate. When
+     *  defined, takes precedence over the global `magicKeywords.enabled` setting,
+     *  letting tests assert the gating behaviour without mutating the
+     *  process-wide Settings singleton (which races with parallel test files —
+     *  see issue #2582). Production wires this through the host's Settings
+     *  reader and updates it on the relevant setting change. */
+    magicKeywordsEnabledOverride: boolean | undefined;
+    /** Bind the host's render request callback. Idempotent — the host wires this
+     *  once after construction (and again after `setEditorComponent` swaps the
+     *  editor). Passing `undefined` clears any pending frame. */
+    setShimmerRepaintHandler(handler: (() => void) | undefined): void;
+    onEscape?: () => void;
+    onClear?: () => void;
+    onExit?: () => void;
+    onDisplayReset?: () => void;
+    onCycleThinkingLevel?: () => void;
+    onCycleModelForward?: () => void;
+    onCycleModelBackward?: () => void;
+    onSelectModel?: () => void;
+    onExpandTools?: () => void;
+    onToggleThinking?: () => void;
+    onExternalEditor?: () => void;
+    onHistorySearch?: () => void;
+    onSuspend?: () => void;
+    onSelectModelTemporary?: () => void;
+    /** Called when the configured copy-prompt shortcut is pressed. */
+    onCopyPrompt?: () => void;
+    /** Called when the configured image-paste shortcut is pressed. */
+    onPasteImage?: () => Promise<boolean>;
+    /** Called when a bracketed paste contains one or more image-file paths. */
+    onPasteImagePath?: (path: string) => void | Promise<void>;
+    /** Called when the configured raw text-paste shortcut is pressed. */
+    onPasteTextRaw?: () => void;
+    /** Called when the configured dequeue shortcut is pressed. */
+    onDequeue?: () => void;
+    /** Called when the configured retry shortcut is pressed. */
+    onRetry?: () => void;
+    /** Called when Caps Lock is pressed. */
+    onCapsLock?: () => void;
+    /** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
+    onLeftAtStart?: () => void;
+    /** Fired when a sustained space-bar hold is recognized — the push-to-talk STT start. The
+     *  optimistically-typed spaces have already been deleted by the time this runs. */
+    onSpaceHoldStart?: () => void;
+    /** Fired when the held space bar is released (detected as an idle gap with no further repeated
+     *  spaces) — the push-to-talk STT stop. */
+    onSpaceHoldEnd?: () => void;
+    /** Gate for the space-hold gesture. Returns false to keep the space bar inserting spaces
+     *  normally; wired to `stt.enabled` so disabling STT restores plain space behavior. */
+    sttHoldEnabled?: () => boolean;
+    setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
+    /**
+     * Register a custom key handler. Extensions use this for shortcuts.
+     */
+    setCustomKeyHandler(key: KeyId, handler: () => void): void;
+    /**
+     * Remove a custom key handler.
+     */
+    removeCustomKeyHandler(key: KeyId): void;
+    /**
+     * Clear all custom key handlers.
+     */
+    clearCustomKeyHandlers(): void;
+    handleInput(data: string): void;
+}
+export {};

package/dist/types/modes/components/custom-editor.test.d.ts

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

package/dist/types/modes/components/custom-message.d.ts

@@ -0,0 +1,15 @@
+import { Container } from "jeopi-tui";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import type { CustomMessage } from "../../session/messages";
+/**
+ * Component that renders a custom message entry from extensions.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class CustomMessageComponent extends Container {
+    #private;
+    private readonly message;
+    private readonly customRenderer?;
+    constructor(message: CustomMessage<unknown>, customRenderer?: MessageRenderer | undefined);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/diff.d.ts

@@ -0,0 +1,11 @@
+export interface RenderDiffOptions {
+    /** File path used to resolve indentation (.editorconfig + defaults) */
+    filePath?: string;
+}
+/**
+ * Render a diff string with colored lines and intra-line change highlighting.
+ * - Context lines: dim/gray
+ * - Removed lines: red, with inverse on changed tokens
+ * - Added lines: green, with inverse on changed tokens
+ */
+export declare function renderDiff(diffText: string, options?: RenderDiffOptions): string;

package/dist/types/modes/components/dynamic-border.d.ts

@@ -0,0 +1,14 @@
+import type { Component } from "jeopi-tui";
+/**
+ * Dynamic border component that adjusts to viewport width.
+ *
+ * Note: When used from hooks loaded via jiti, the global `theme` may be undefined
+ * because jiti creates a separate module cache. Always pass an explicit color
+ * function when using DynamicBorder in components exported for hook use.
+ */
+export declare class DynamicBorder implements Component {
+    #private;
+    constructor(color?: (str: string) => string);
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/error-banner.d.ts

@@ -0,0 +1,11 @@
+import { Container } from "jeopi-tui";
+/**
+ * A persistent error banner pinned above the editor. Unlike the transcript
+ * "Error: …" line (which scrolls away as the conversation grows), this stays in
+ * the fixed region directly above the input so a turn that ended on a provider
+ * error — e.g. Anthropic's "Output blocked by content filtering policy" — cannot
+ * be missed. It is cleared when the next turn starts.
+ */
+export declare class ErrorBannerComponent extends Container {
+    constructor(message: string);
+}

package/dist/types/modes/components/eval-execution.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Component for displaying user-initiated eval execution with streaming output.
+ * Shares the same kernel session as the agent's eval tool.
+ */
+import { Container, type TUI } from "jeopi-tui";
+import type { TruncationMeta } from "../../tools/output-meta";
+export type EvalExecutionLanguage = "python" | "js";
+export declare class EvalExecutionComponent extends Container {
+    #private;
+    private readonly code;
+    private readonly excludeFromContext;
+    private readonly language;
+    constructor(code: string, ui: TUI, excludeFromContext?: boolean, language?: EvalExecutionLanguage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+    }): void;
+    getOutput(): string;
+    getCode(): string;
+}

package/dist/types/modes/components/execution-shared.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared rendering primitives for bash/eval execution components.
+ *
+ * Each helper isolates a piece of structure both components share verbatim
+ * (frame layout, collapsed preview, post-run status line). Differences in
+ * how each component prepares its header, output lines, or sixel masking
+ * stay in their respective files.
+ */
+import { type Component, Container, Loader, Text, type TUI } from "jeopi-tui";
+import { type TruncationMeta } from "../../tools/output-meta";
+export type ExecutionStatus = "running" | "complete" | "cancelled" | "error";
+/** Theme color keys valid for an execution frame. */
+export type ExecutionColorKey = "dim" | "bashMode" | "pythonMode";
+/**
+ * Build the spacer + top border + content container + bottom border scaffold
+ * that bash and eval execution components share. The caller appends the
+ * header (command vs `>>>` prompt) and the returned loader to
+ * `contentContainer` so per-mode order is preserved.
+ */
+export declare function buildExecutionFrame(parent: Container, ui: TUI, colorKey: ExecutionColorKey): {
+    contentContainer: Container;
+    loader: Loader;
+};
+/**
+ * Wrap a styled preview block in a render-time visual-line truncator.
+ * Recomputed per render width so wrapping stays in sync with terminal size.
+ */
+export declare function createCollapsedPreview(previewText: string, previewLines: number): Component;
+/**
+ * Build the post-run status block (hidden-line hint, exit/cancel marker,
+ * truncation notice). Returns undefined when there is nothing to display so
+ * callers can skip appending a stray Text child.
+ */
+export declare function buildStatusFooter(opts: {
+    status: ExecutionStatus;
+    exitCode: number | undefined;
+    truncation: TruncationMeta | undefined;
+    hiddenLineCount: number;
+    /** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */
+    suppressHiddenCount?: boolean;
+}): Text | undefined;
+/**
+ * Derive the post-run status from an exit code + cancellation flag using the
+ * same precedence both execution components apply.
+ */
+export declare function resolveExecutionStatus(exitCode: number | undefined, cancelled: boolean): ExecutionStatus;

package/dist/types/modes/components/extensions/extension-dashboard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ExtensionDashboard - Fullscreen alternate-screen control center for extensions.
+ *
+ * Chrome mirrors the `/settings` overlay: a titled rounded box, a shared
+ * {@link TabBar} for provider selection, and a two-column body (inventory list |
+ * inspector). Both panes are mouse-aware — wheel scrolls, hover highlights, and
+ * clicks select/activate — routed from a single SGR-mouse handler.
+ *
+ * Navigation:
+ * - Tab/Shift+Tab or ←/→: switch provider tab
+ * - Up/Down/j/k or wheel: move list selection
+ * - Space/Enter or click: toggle selected item (or provider master switch)
+ * - Wheel over the inspector: scroll the detail pane
+ * - Esc: clear search (if active) then close
+ */
+import { type Component, type Tab } from "jeopi-tui";
+import { Settings } from "../../../config/settings";
+import type { ProviderTab } from "./types";
+/**
+ * Map dashboard provider tabs to {@link TabBar} tabs. Empty *enabled* providers
+ * are muted — skipped by keyboard nav and unclickable; disabled providers stay
+ * selectable (with a leading disabled glyph) so their master switch can be
+ * re-enabled from the list. The "all" tab is never muted or marked.
+ */
+export declare function buildTabBarTabs(tabs: ProviderTab[]): Tab[];
+export declare class ExtensionDashboard implements Component {
+    #private;
+    private readonly cwd;
+    private readonly settings;
+    private readonly terminalHeight;
+    onClose?: () => void;
+    onRequestRender?: () => void;
+    private constructor();
+    static create(cwd: string, settings?: Settings | null, terminalHeight?: number): Promise<ExtensionDashboard>;
+    /**
+     * Fullscreen frame: titled top border, the tab row(s), a divider, the
+     * two-column body sized to fill the viewport, a divider, the footer hint, and
+     * the bottom border. Records row geometry for mouse hit-testing.
+     */
+    render(width: number): readonly string[];
+    invalidate(): void;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/extensions/extension-list.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ExtensionList - Inventory list with Master Switch and fuzzy search.
+ *
+ * When viewing a specific provider (not "ALL"), Row #0 is the Master Switch
+ * that toggles the entire provider. All items below are dimmed when the
+ * master switch is off.
+ */
+import { type Component } from "jeopi-tui";
+import type { Extension, ExtensionKind } from "./types";
+export interface ExtensionListCallbacks {
+    /** Called when selection changes */
+    onSelectionChange?: (extension: Extension | null) => void;
+    /** Called when extension is toggled */
+    onToggle?: (extensionId: string, enabled: boolean) => void;
+    /** Called when master switch is toggled */
+    onMasterToggle?: (providerId: string) => void;
+    /** Provider ID for master switch (null = no master switch) */
+    masterSwitchProvider?: string | null;
+}
+export declare class ExtensionList implements Component {
+    #private;
+    private extensions;
+    private readonly callbacks;
+    constructor(extensions: Extension[], callbacks?: ExtensionListCallbacks, maxVisible?: number);
+    setMaxVisible(maxVisible: number): void;
+    setExtensions(extensions: Extension[]): void;
+    setFocused(focused: boolean): void;
+    setMasterSwitchProvider(providerId: string | null): void;
+    getSearchQuery(): string;
+    resetSelection(): void;
+    getSelectedExtension(): Extension | null;
+    /** Get the currently selected kind header (for preview purposes) */
+    getSelectedKind(): ExtensionKind | null;
+    setSearchQuery(query: string): void;
+    clearSearch(): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+    /** Highlight the row under the pointer (null clears). */
+    setHoverIndex(index: number | null): void;
+    /**
+     * Map a 0-based line within this component's render to the absolute list-item
+     * index, or null when the line is the search banner, a padding row, or outside
+     * the visible window. The first two lines are the search banner and a blank
+     * separator; item rows follow, windowed at the current scroll offset.
+     */
+    hitTest(line: number): number | null;
+    /** Wheel notch: move the selection (and the inspector) one row. */
+    handleWheel(delta: -1 | 1): void;
+    /** Click: select the row under the pointer, or activate it when already selected. */
+    handleClick(line: number): void;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/extensions/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extension Control Center exports.
+ */
+export * from "./extension-dashboard";
+export * from "./extension-list";
+export * from "./inspector-panel";
+export * from "./state-manager";
+export * from "./types";

package/dist/types/modes/components/extensions/inspector-panel.d.ts

@@ -0,0 +1,8 @@
+import { type Component } from "jeopi-tui";
+import type { Extension } from "./types";
+export declare class InspectorPanel implements Component {
+    #private;
+    setExtension(extension: Extension | null): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/extensions/state-manager.d.ts

@@ -0,0 +1,50 @@
+import type { DashboardState, Extension, FlatTreeItem, ProviderTab, TreeNode } from "./types";
+/**
+ * Settings manager interface for granular toggle persistence.
+ */
+export interface ExtensionSettingsManager {
+    getDisabledExtensions(): string[];
+    setDisabledExtensions(ids: string[]): void;
+}
+/**
+ * Load all extensions from all capabilities.
+ */
+export declare function loadAllExtensions(cwd?: string, disabledIds?: string[]): Promise<Extension[]>;
+/**
+ * Build sidebar tree from extensions.
+ * Groups by provider → kind.
+ */
+export declare function buildSidebarTree(extensions: Extension[]): 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[]): 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[]): DashboardState;
+/**
+ * Create initial dashboard state.
+ */
+export declare function createInitialState(cwd?: string, disabledIds?: string[]): Promise<DashboardState>;
+/**
+ * Toggle provider enabled state.
+ */
+export declare function toggleProvider(providerId: string): boolean;
+/**
+ * Refresh state after toggle.
+ */
+export declare function refreshState(state: DashboardState, cwd?: string, disabledIds?: string[]): Promise<DashboardState>;