byterover-cli 0.3.5 → 0.4.1

package/dist/tui/components/scrollable-list.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ScrollableList Component
+ *
+ * Generic scrollable list that works reliably with Ink's layout.
+ * Uses item-based slicing with dynamic height calculation.
+ */
+import React from 'react';
+export interface ScrollableListProps<T> {
+    /** Auto-scroll to bottom when new items are added */
+    autoScrollToBottom?: boolean;
+    /** Available height in lines for the list */
+    availableHeight: number;
+    /** Estimate line count for an item (default: 1 line per item) */
+    estimateItemHeight?: (item: T, index: number) => number;
+    /** Whether keyboard input is active for this list */
+    isActive?: boolean;
+    /** Array of items to render */
+    items: T[];
+    /** Extract unique key for each item */
+    keyExtractor: (item: T, index: number) => string;
+    /** Called when scroll position changes */
+    onScroll?: (offset: number, total: number) => void;
+    /** Render function for each item */
+    renderItem: (item: T, index: number) => React.ReactNode;
+    /** Scroll step size (items per keypress) */
+    scrollStep?: number;
+    /** Show scroll position indicator */
+    showIndicator?: boolean;
+}
+export declare function ScrollableList<T>({ autoScrollToBottom, availableHeight, estimateItemHeight, isActive, items, keyExtractor, onScroll, renderItem, scrollStep, showIndicator, }: ScrollableListProps<T>): React.ReactElement;

package/dist/tui/components/scrollable-list.js

@@ -0,0 +1,121 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ScrollableList Component
+ *
+ * Generic scrollable list that works reliably with Ink's layout.
+ * Uses item-based slicing with dynamic height calculation.
+ */
+import { Box, Text, useInput } from 'ink';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+export function ScrollableList({ autoScrollToBottom = true, availableHeight, estimateItemHeight = () => 1, isActive = true, items, keyExtractor, onScroll, renderItem, scrollStep = 1, showIndicator = true, }) {
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const totalItems = items.length;
+    // Calculate which items are visible based on available height
+    const { visibleEndIndex, visibleItems, visibleStartIndex } = useMemo(() => {
+        if (totalItems === 0) {
+            return { visibleEndIndex: 0, visibleItems: [], visibleStartIndex: 0 };
+        }
+        // Calculate heights of all items
+        const itemHeights = [];
+        for (let i = 0; i < totalItems; i++) {
+            const h = estimateItemHeight(items[i], i);
+            itemHeights.push(h);
+        }
+        // Reserve space for indicators (1 line each)
+        const indicatorSpace = showIndicator ? 2 : 0;
+        const contentHeight = Math.max(1, availableHeight - indicatorSpace);
+        // Find visible range starting from scrollOffset
+        const startIdx = Math.min(scrollOffset, totalItems - 1);
+        let endIdx = startIdx;
+        let accumulatedHeight = 0;
+        // Accumulate items until we fill the available height
+        for (let i = startIdx; i < totalItems; i++) {
+            if (accumulatedHeight + itemHeights[i] > contentHeight && i > startIdx) {
+                break;
+            }
+            accumulatedHeight += itemHeights[i];
+            endIdx = i + 1;
+        }
+        return {
+            visibleEndIndex: endIdx,
+            visibleItems: items.slice(startIdx, endIdx),
+            visibleStartIndex: startIdx,
+        };
+    }, [items, totalItems, scrollOffset, availableHeight, estimateItemHeight, showIndicator]);
+    // Calculate max scroll offset
+    const maxOffset = useMemo(() => {
+        if (totalItems === 0)
+            return 0;
+        // Find the minimum start index that shows the last item
+        let maxStart = totalItems - 1;
+        const indicatorSpace = showIndicator ? 2 : 0;
+        const contentHeight = Math.max(1, availableHeight - indicatorSpace);
+        let accumulatedHeight = 0;
+        for (let i = totalItems - 1; i >= 0; i--) {
+            const h = estimateItemHeight(items[i], i);
+            if (accumulatedHeight + h > contentHeight && i < totalItems - 1) {
+                maxStart = i + 1;
+                break;
+            }
+            accumulatedHeight += h;
+            maxStart = i;
+        }
+        return maxStart;
+    }, [items, totalItems, availableHeight, estimateItemHeight, showIndicator]);
+    // Clamp scroll offset when items or height changes
+    useEffect(() => {
+        setScrollOffset((prev) => Math.min(prev, Math.max(0, maxOffset)));
+    }, [maxOffset]);
+    // Auto-scroll to bottom when new items are added
+    useEffect(() => {
+        if (autoScrollToBottom && totalItems > 0) {
+            setScrollOffset(maxOffset);
+        }
+    }, [autoScrollToBottom, totalItems, maxOffset]);
+    // Notify parent of scroll changes
+    useEffect(() => {
+        onScroll?.(scrollOffset, totalItems);
+    }, [scrollOffset, totalItems, onScroll]);
+    const scrollUp = useCallback(() => {
+        setScrollOffset((prev) => Math.max(0, prev - scrollStep));
+    }, [scrollStep]);
+    const scrollDown = useCallback(() => {
+        setScrollOffset((prev) => Math.min(maxOffset, prev + scrollStep));
+    }, [maxOffset, scrollStep]);
+    const scrollToTop = useCallback(() => {
+        setScrollOffset(0);
+    }, []);
+    const scrollToBottom = useCallback(() => {
+        setScrollOffset(maxOffset);
+    }, [maxOffset]);
+    useInput((input, key) => {
+        if (key.upArrow) {
+            scrollUp();
+        }
+        else if (key.downArrow) {
+            scrollDown();
+        }
+        else if (key.pageUp || (key.ctrl && input === 'u')) {
+            // Page up - scroll by ~half viewport worth of items
+            setScrollOffset((prev) => Math.max(0, prev - 3));
+        }
+        else if (key.pageDown || (key.ctrl && input === 'd')) {
+            // Page down - scroll by ~half viewport worth of items
+            setScrollOffset((prev) => Math.min(maxOffset, prev + 3));
+        }
+        else if (input === 'g' && !key.ctrl) {
+            scrollToTop();
+        }
+        else if (input === 'G') {
+            scrollToBottom();
+        }
+    }, { isActive });
+    const canScrollUp = scrollOffset > 0;
+    const canScrollDown = scrollOffset < maxOffset;
+    const itemsAbove = visibleStartIndex;
+    const itemsBelow = totalItems - visibleEndIndex;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [showIndicator && canScrollUp && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: ["\u2191 ", itemsAbove, " more above"] }) })), visibleItems.map((item, idx) => {
+                const actualIndex = visibleStartIndex + idx;
+                return _jsx(React.Fragment, { children: renderItem(item, actualIndex) }, keyExtractor(item, actualIndex));
+            }), showIndicator && canScrollDown && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: ["\u2193 ", itemsBelow, " more below"] }) }))] }));
+}

package/dist/tui/components/suggestions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Suggestions Component
+ *
+ * Displays command suggestions with auto-completion.
+ * Uses useSlashCompletion hook internally to manage state.
+ * Shows args/flags details for the selected command.
+ * Shows max 7 items with sliding window that follows selection.
+ */
+import React from 'react';
+interface SuggestionsProps {
+    input: string;
+    onInsert?: (value: string) => void;
+    onSelect?: (value: string) => void;
+}
+export declare const Suggestions: React.FC<SuggestionsProps>;
+export {};

package/dist/tui/components/suggestions.js

@@ -0,0 +1,162 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Suggestions Component
+ *
+ * Displays command suggestions with auto-completion.
+ * Uses useSlashCompletion hook internally to manage state.
+ * Shows args/flags details for the selected command.
+ * Shows max 7 items with sliding window that follows selection.
+ */
+import { Box, Text, useInput } from 'ink';
+import { useEffect, useMemo, useRef } from 'react';
+import { useMode } from '../contexts/use-mode.js';
+import { useTheme } from '../contexts/use-theme.js';
+import { useSlashCompletion } from '../hooks/index.js';
+const MAX_VISIBLE_ITEMS = 5;
+/**
+ * Format usage string from args, flags, and subcommands
+ */
+function formatUsage(label, args, flags, subCommands) {
+    let usage = label;
+    if (subCommands?.length) {
+        usage += ' <subcommand>';
+    }
+    if (args?.length) {
+        const argsStr = args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(' ');
+        usage += ` ${argsStr}`;
+    }
+    if (flags?.length) {
+        const flagsStr = flags.map((f) => `[--${f.name}]`).join(' ');
+        usage += ` ${flagsStr}`;
+    }
+    return usage;
+}
+export const Suggestions = ({ input, onInsert, onSelect }) => {
+    const { theme: { colors }, } = useTheme();
+    const { mode, setMode } = useMode();
+    const { activeIndex, clearSuggestions, hasMatchedCommand, isCommandAttempt, nextSuggestion, prevSuggestion, selectSuggestion, suggestions, } = useSlashCompletion(input);
+    // Track if user dismissed suggestions with Escape
+    const isDismissedRef = useRef(false);
+    const prevInputRef = useRef(input);
+    // Reset dismissed state when input changes
+    useEffect(() => {
+        if (input !== prevInputRef.current) {
+            isDismissedRef.current = false;
+            prevInputRef.current = input;
+        }
+    }, [input]);
+    // Manage mode based on suggestions visibility
+    // Don't show suggestions mode when user is typing arguments for a matched command
+    // Don't re-enable if user dismissed with Escape
+    // Only control mode when already in console/suggestions mode (don't override 'activity')
+    useEffect(() => {
+        if (isDismissedRef.current) {
+            return;
+        }
+        // Only manage mode transitions within console/suggestions context
+        if (mode !== 'console' && mode !== 'suggestions') {
+            return;
+        }
+        if (suggestions.length > 0 || (isCommandAttempt && !hasMatchedCommand)) {
+            setMode('suggestions');
+        }
+        else {
+            setMode('console');
+        }
+    }, [mode, suggestions.length, isCommandAttempt, hasMatchedCommand, setMode]);
+    // Calculate visible window based on selected index
+    const { visibleSuggestions, windowStart } = useMemo(() => {
+        if (suggestions.length <= MAX_VISIBLE_ITEMS) {
+            return { visibleSuggestions: suggestions, windowStart: 0 };
+        }
+        // Calculate window start to keep selected item visible
+        let start = 0;
+        if (activeIndex >= MAX_VISIBLE_ITEMS) {
+            start = activeIndex - MAX_VISIBLE_ITEMS + 1;
+        }
+        // Ensure we don't go past the end
+        const maxStart = suggestions.length - MAX_VISIBLE_ITEMS;
+        start = Math.min(start, maxStart);
+        return {
+            visibleSuggestions: suggestions.slice(start, start + MAX_VISIBLE_ITEMS),
+            windowStart: start,
+        };
+    }, [suggestions, activeIndex]);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            prevSuggestion();
+        }
+        if (key.downArrow) {
+            nextSuggestion();
+        }
+        if (key.return) {
+            const value = selectSuggestion();
+            if (value) {
+                // In file completion mode (value contains @)
+                const isFileCompletion = value.includes('@');
+                const isFolder = value.endsWith('/');
+                if (isFileCompletion && onInsert) {
+                    onInsert(value);
+                    // For folders, stay in suggestions mode to show contents
+                    if (isFolder) {
+                        clearSuggestions();
+                        // Don't exit suggestions mode - new suggestions will appear
+                        return;
+                    }
+                }
+                else if (onSelect) {
+                    onSelect(value);
+                }
+            }
+            clearSuggestions();
+            setMode('console');
+        }
+        if (key.tab) {
+            const value = selectSuggestion();
+            if (value && onInsert) {
+                onInsert(value);
+                // For folders, stay in suggestions mode
+                if (value.endsWith('/')) {
+                    clearSuggestions();
+                    return;
+                }
+            }
+            clearSuggestions();
+            setMode('console');
+        }
+        if (key.escape) {
+            isDismissedRef.current = true;
+            clearSuggestions();
+            setMode('console');
+        }
+    }, { isActive: mode === 'suggestions' });
+    // Don't render if dismissed
+    if (isDismissedRef.current) {
+        return null;
+    }
+    // Show "No commands found" when typing an unknown command
+    // Don't show when user is typing arguments for a known command
+    if (suggestions.length === 0) {
+        if (isCommandAttempt && !hasMatchedCommand && input.trim().length > 1) {
+            return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", paddingX: 1, children: _jsx(Text, { color: colors.dimText, children: "No commands found" }) }));
+        }
+        return null;
+    }
+    // Calculate max label width for alignment
+    const maxLabelLength = Math.max(...suggestions.map((s) => s.label.length));
+    const labelWidth = Math.max(maxLabelLength, 12);
+    // Get the selected suggestion
+    const selectedSuggestion = activeIndex >= 0 ? suggestions[activeIndex] : null;
+    const hasDetails = selectedSuggestion &&
+        (selectedSuggestion.args?.length || selectedSuggestion.flags?.length || selectedSuggestion.subCommands?.length);
+    // Calculate if there are more items above/below
+    const hasMoreAbove = windowStart > 0;
+    const hasMoreBelow = windowStart + MAX_VISIBLE_ITEMS < suggestions.length;
+    return (_jsxs(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", paddingX: 1, children: [hasMoreAbove && (_jsxs(Text, { color: colors.dimText, dimColor: true, children: ["\u2191 ", windowStart, " more above"] })), visibleSuggestions.map((suggestion, index) => {
+                const actualIndex = windowStart + index;
+                const isActive = actualIndex === activeIndex;
+                return (_jsxs(Box, { children: [_jsxs(Text, { backgroundColor: isActive ? colors.dimText : undefined, color: colors.text, children: [isActive ? '❯ ' : '  ', suggestion.label.padEnd(labelWidth)] }), _jsxs(Text, { color: colors.dimText, children: [" ", suggestion.description || ''] })] }, suggestion.value));
+            }), hasMoreBelow && (_jsxs(Text, { color: colors.dimText, dimColor: true, children: ["\u2193 ", suggestions.length - windowStart - MAX_VISIBLE_ITEMS, " more below"] })), hasDetails && (_jsxs(Box, { borderColor: colors.border, borderStyle: "single", borderTop: true, flexDirection: "column", marginTop: 0, children: [_jsxs(Text, { color: colors.text, children: ["Usage:", ' ', formatUsage(selectedSuggestion.label, selectedSuggestion.args, selectedSuggestion.flags, selectedSuggestion.subCommands)] }), selectedSuggestion.subCommands?.map((sub) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: sub.name.padEnd(labelWidth + 2) }), '  ', sub.description] }, sub.name))), selectedSuggestion.args?.map((arg) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: (arg.required ? `<${arg.name}>` : `[${arg.name}]`).padEnd(labelWidth + 2) }), '  ', arg.description] }, arg.name))), selectedSuggestion.flags?.map((flag) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: (flag.type === 'file'
+                                    ? `${flag.char || '@'}file`
+                                    : (flag.char ? `-${flag.char}, ` : '') + `--${flag.name}`).padEnd(labelWidth + 2) }), '  ', flag.description, flag.default !== undefined && _jsxs(Text, { children: [" (default: ", String(flag.default), ")"] })] }, flag.name)))] }))] }));
+};

package/dist/tui/components/tab-bar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tab Bar Component
+ */
+import React from 'react';
+import type { TabId } from '../types.js';
+interface TabBarProps {
+    activeTab: TabId;
+}
+export declare const TabBar: React.FC<TabBarProps>;
+export {};

package/dist/tui/components/tab-bar.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tab Bar Component
+ */
+import { Box, Text } from 'ink';
+import React from 'react';
+import { TABS } from '../constants.js';
+import { useTheme } from '../contexts/use-theme.js';
+export const TabBar = ({ activeTab }) => {
+    const { theme: { colors }, } = useTheme();
+    return (_jsxs(Box, { alignItems: "flex-end", paddingX: 1, width: "100%", children: [_jsx(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", height: "100%", width: 2 }), TABS.map((tab) => (_jsxs(React.Fragment, { children: [_jsx(Box, { borderBottomColor: activeTab === tab.id ? colors.primary : colors.border, borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", children: _jsx(Text, { children: tab.label }) }), _jsx(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", height: "100%", width: 6 })] }, tab.id))), _jsx(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", flexGrow: 1, height: "100%" })] }));
+};

package/dist/tui/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TUI Constants
+ */
+import type { Tab } from './types.js';
+export declare const TABS: Tab[];
+export declare const LAYOUT: {
+    readonly footerHeight: 2;
+    readonly headerHeight: 4;
+    readonly tabBarHeight: 2;
+};
+export declare const DEFAULT_TAB: "activity";

package/dist/tui/constants.js

@@ -0,0 +1,13 @@
+/**
+ * TUI Constants
+ */
+export const TABS = [
+    { id: 'activity', label: 'Activity' },
+    { id: 'console', label: 'Console' },
+];
+export const LAYOUT = {
+    footerHeight: 2,
+    headerHeight: 4,
+    tabBarHeight: 2,
+};
+export const DEFAULT_TAB = 'activity';

package/dist/tui/contexts/auth-context.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Auth Context
+ *
+ * Manages authentication state and login flow.
+ * Executes LoginUseCase directly for authentication.
+ */
+import React from 'react';
+import type { AuthToken } from '../../core/domain/entities/auth-token.js';
+import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import type { AuthState } from '../types.js';
+export interface AuthContextValue {
+    authToken: AuthToken | undefined;
+    brvConfig: BrvConfig | undefined;
+    isInitialConfigLoaded: boolean;
+    isLoggingIn: boolean;
+    loginOutput: string[];
+    authState: AuthState;
+    isAuthorized: boolean;
+    login: () => void;
+    reloadAuth: () => Promise<void>;
+    reloadBrvConfig: () => Promise<void>;
+}
+interface AuthProviderProps {
+    children: React.ReactNode;
+    initialAuthToken?: AuthToken;
+    initialBrvConfig?: BrvConfig;
+}
+export declare function AuthProvider({ children, initialAuthToken, initialBrvConfig }: AuthProviderProps): React.ReactElement;
+export declare function useAuth(): AuthContextValue;
+export {};

package/dist/tui/contexts/auth-context.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Auth Context
+ *
+ * Manages authentication state and login flow.
+ * Executes LoginUseCase directly for authentication.
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { getAuthConfig } from '../../config/auth.config.js';
+import { getCurrentConfig } from '../../config/environment.js';
+import { OAuthService } from '../../infra/auth/oauth-service.js';
+import { OidcDiscoveryService } from '../../infra/auth/oidc-discovery-service.js';
+import { SystemBrowserLauncher } from '../../infra/browser/system-browser-launcher.js';
+import { CallbackHandler } from '../../infra/http/callback-handler.js';
+import { FileGlobalConfigStore } from "../../infra/storage/file-global-config-store.js";
+import { MixpanelTrackingService } from '../../infra/tracking/mixpanel-tracking-service.js';
+import { LoginUseCase } from '../../infra/usecase/login-use-case.js';
+import { HttpUserService } from '../../infra/user/http-user-service.js';
+import { useServices } from './services-context.js';
+const AuthContext = createContext(undefined);
+/**
+ * Simple terminal that appends output to state
+ * Only supports log/error/warn - interactive prompts throw errors
+ */
+function createStateTerminal(appendOutput) {
+    return {
+        actionStart() { },
+        actionStop() { },
+        async confirm() {
+            return true;
+        },
+        error(message) {
+            appendOutput(`Error: ${message}`);
+        },
+        async fileSelector() {
+            throw new Error('fileSelector not supported in login terminal');
+        },
+        async input() {
+            throw new Error('input not supported in login terminal');
+        },
+        log(message) {
+            appendOutput(message ?? '');
+        },
+        async search() {
+            throw new Error('search not supported in login terminal');
+        },
+        async select() {
+            throw new Error('select not supported in login terminal');
+        },
+        warn(message) {
+            appendOutput(`Warning: ${message}`);
+        },
+    };
+}
+export function AuthProvider({ children, initialAuthToken, initialBrvConfig }) {
+    const { projectConfigStore, tokenStore } = useServices();
+    // State
+    const [authToken, setAuthToken] = useState(initialAuthToken);
+    const [brvConfig, setBrvConfig] = useState(initialBrvConfig);
+    const [isLoggingIn, setIsLoggingIn] = useState(false);
+    const [loginOutput, setLoginOutput] = useState([]);
+    const [isInitialConfigLoaded, setIsInitialConfigLoaded] = useState(false);
+    // Computed
+    const authState = authToken?.isValid() ? 'authorized' : 'unauthorized';
+    const isAuthorized = authState === 'authorized';
+    // Reload auth state (after login or logout)
+    const reloadAuth = useCallback(async () => {
+        // Clear display output
+        setLoginOutput([]);
+        try {
+            // Reload brv config state before checking auth token
+            await reloadBrvConfig();
+        }
+        catch { }
+        const newToken = await tokenStore.load();
+        if (newToken?.isValid()) {
+            setAuthToken(newToken);
+        }
+        else {
+            // Token is undefined or invalid (logged out or expired)
+            setAuthToken(undefined);
+        }
+    }, [tokenStore, projectConfigStore]);
+    // Reload brv config state
+    const reloadBrvConfig = useCallback(async () => {
+        const configExists = await projectConfigStore.exists();
+        if (configExists) {
+            const config = await projectConfigStore.read();
+            setBrvConfig(config);
+        }
+    }, [projectConfigStore]);
+    // Login action - executes LoginUseCase
+    const login = useCallback(() => {
+        setIsLoggingIn(true);
+        setLoginOutput([]);
+        const appendOutput = (line) => {
+            setLoginOutput((prev) => [...prev, line]);
+        };
+        const runLogin = async () => {
+            try {
+                const config = getCurrentConfig();
+                const globalConfigStore = new FileGlobalConfigStore();
+                const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
+                const discoveryService = new OidcDiscoveryService();
+                const authConfig = await getAuthConfig(discoveryService);
+                const useCase = new LoginUseCase({
+                    authService: new OAuthService(authConfig),
+                    browserLauncher: new SystemBrowserLauncher(),
+                    callbackHandler: new CallbackHandler(),
+                    terminal: createStateTerminal(appendOutput),
+                    tokenStore,
+                    trackingService,
+                    userService: new HttpUserService({ apiBaseUrl: config.apiBaseUrl }),
+                });
+                await useCase.run();
+            }
+            catch (error) {
+                appendOutput(`Error: ${error instanceof Error ? error.message : 'Login failed'}`);
+            }
+            finally {
+                setIsLoggingIn(false);
+            }
+        };
+        runLogin();
+    }, [tokenStore]);
+    // Reload brv config state on mount and mark initial load complete
+    useEffect(() => {
+        reloadBrvConfig().then(() => {
+            setIsInitialConfigLoaded(true);
+        });
+    }, [reloadBrvConfig]);
+    // Memoize context value
+    const value = useMemo(() => ({
+        authState,
+        authToken,
+        brvConfig,
+        isAuthorized,
+        isInitialConfigLoaded,
+        isLoggingIn,
+        login,
+        loginOutput,
+        reloadAuth,
+        reloadBrvConfig
+    }), [authToken, brvConfig, isInitialConfigLoaded, isLoggingIn, loginOutput, authState, isAuthorized, login, reloadAuth]);
+    return _jsx(AuthContext.Provider, { value: value, children: children });
+}
+export function useAuth() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within AuthProvider');
+    }
+    return context;
+}

package/dist/tui/contexts/consumer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Consumer Context
+ *
+ * Global context for managing consumer service and queue polling state.
+ * Consolidates useConsumer and useQueuePolling hooks into a single context.
+ *
+ * Usage:
+ * ```tsx
+ * const { consumerId, sessionExecutions, stats } = useConsumer()
+ * ```
+ */
+import React from 'react';
+import type { ExecutionWithToolCalls, QueueStats } from '../../infra/cipher/consumer/queue-polling-service.js';
+import type { ConsumerStatus } from '../types.js';
+interface ConsumerContextValue {
+    consumerError: Error | null;
+    consumerId: null | string;
+    consumerStatus: ConsumerStatus;
+    isConnected: boolean;
+    pollingError: Error | null;
+    reconnectCount: number;
+    restart: () => Promise<void>;
+    sessionExecutions: ExecutionWithToolCalls[];
+    stats: null | QueueStats;
+}
+interface ConsumerProviderProps {
+    children: React.ReactNode;
+}
+export declare function ConsumerProvider({ children }: ConsumerProviderProps): React.ReactElement;
+export declare function useConsumer(): ConsumerContextValue;
+export {};

package/dist/tui/contexts/consumer.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Consumer Context
+ *
+ * Global context for managing consumer service and queue polling state.
+ * Consolidates useConsumer and useQueuePolling hooks into a single context.
+ *
+ * Usage:
+ * ```tsx
+ * const { consumerId, sessionExecutions, stats } = useConsumer()
+ * ```
+ */
+import { createContext, useContext, useMemo } from 'react';
+import { useConsumer as useConsumerHook } from '../hooks/use-consumer.js';
+import { useQueuePolling } from '../hooks/use-queue-polling.js';
+const ConsumerContext = createContext(undefined);
+export function ConsumerProvider({ children }) {
+    // Start consumer service
+    const { consumerError, consumerId, consumerStatus, restart } = useConsumerHook();
+    // Poll queue for executions and stats
+    const { error: pollingError, isConnected, reconnectCount, sessionExecutions, stats, } = useQueuePolling({
+        consumerId: consumerId ?? undefined,
+        pollInterval: 1000,
+    });
+    const contextValue = useMemo(() => ({
+        // Consumer state
+        consumerError,
+        consumerId,
+        consumerStatus,
+        // Queue polling state
+        isConnected,
+        pollingError,
+        reconnectCount,
+        restart,
+        sessionExecutions,
+        stats,
+    }), [
+        consumerError,
+        consumerId,
+        consumerStatus,
+        restart,
+        isConnected,
+        pollingError,
+        reconnectCount,
+        sessionExecutions,
+        stats,
+    ]);
+    return _jsx(ConsumerContext.Provider, { value: contextValue, children: children });
+}
+export function useConsumer() {
+    const context = useContext(ConsumerContext);
+    if (!context) {
+        throw new Error('useConsumer must be used within ConsumerProvider');
+    }
+    return context;
+}

package/dist/tui/contexts/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TUI Contexts
+ */
+export * from './auth-context.js';
+export * from './consumer.js';
+export * from './services-context.js';

package/dist/tui/contexts/index.js

@@ -0,0 +1,6 @@
+/**
+ * TUI Contexts
+ */
+export * from './auth-context.js';
+export * from './consumer.js';
+export * from './services-context.js';