byterover-cli 0.4.0 → 1.0.0

package/dist/tui/hooks/use-auth-polling.js

@@ -0,0 +1,104 @@
+/**
+ * Auth Polling Hook
+ *
+ * Periodically checks auth state and refreshes token when needed.
+ */
+import { useEffect, useRef } from 'react';
+import { getAuthConfig } from '../../config/auth.config.js';
+import { getCurrentConfig } from '../../config/environment.js';
+import { AuthToken as AuthTokenClass } from '../../core/domain/entities/auth-token.js';
+import { OAuthService } from '../../infra/auth/oauth-service.js';
+import { OidcDiscoveryService } from '../../infra/auth/oidc-discovery-service.js';
+import { HttpUserService } from '../../infra/user/http-user-service.js';
+/** Auth state polling interval in milliseconds (15 seconds) */
+const AUTH_POLL_INTERVAL_MS = 15 * 1000;
+/**
+ * Hook that polls auth state and refreshes token when needed.
+ *
+ * - Polls every 30 seconds when authorized
+ * - Validates token by calling user API
+ * - Refreshes token if validation fails
+ * - Clears auth state if refresh fails
+ */
+export function useAuthPolling({ authToken, onTokenChange, tokenStore }) {
+    // Track if validation/refresh is in progress to prevent concurrent operations
+    const isProcessingRef = useRef(false);
+    useEffect(() => {
+        // Only poll when authorized
+        if (!authToken) {
+            return;
+        }
+        const checkAndRefreshAuth = async () => {
+            // Skip if already processing
+            if (isProcessingRef.current) {
+                return;
+            }
+            isProcessingRef.current = true;
+            try {
+                // Validate token by calling user API
+                const isValid = await validateToken(authToken);
+                if (!isValid) {
+                    // Token invalid - attempt refresh
+                    await refreshToken(authToken, tokenStore, onTokenChange);
+                }
+            }
+            finally {
+                isProcessingRef.current = false;
+            }
+        };
+        // Run immediately on mount/token change
+        checkAndRefreshAuth();
+        // Set up polling interval
+        const pollInterval = setInterval(checkAndRefreshAuth, AUTH_POLL_INTERVAL_MS);
+        return () => {
+            clearInterval(pollInterval);
+        };
+    }, [authToken, onTokenChange, tokenStore]);
+}
+/**
+ * Validate token by calling user API
+ * @returns true if token is valid, false otherwise
+ */
+async function validateToken(authToken) {
+    try {
+        const config = getCurrentConfig();
+        const userService = new HttpUserService({ apiBaseUrl: config.apiBaseUrl });
+        // Try to get current user - if this fails, token is invalid
+        await userService.getCurrentUser(authToken.accessToken, authToken.sessionKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Refresh the token using refresh token
+ */
+async function refreshToken(authToken, tokenStore, onTokenChange) {
+    try {
+        const discoveryService = new OidcDiscoveryService();
+        const authConfig = await getAuthConfig(discoveryService);
+        const authService = new OAuthService(authConfig);
+        // Refresh the token
+        const newTokenData = await authService.refreshToken(authToken.refreshToken);
+        // Create new AuthToken with refreshed data but preserve user info
+        const refreshedToken = new AuthTokenClass({
+            accessToken: newTokenData.accessToken,
+            expiresAt: newTokenData.expiresAt,
+            refreshToken: newTokenData.refreshToken,
+            sessionKey: newTokenData.sessionKey,
+            tokenType: newTokenData.tokenType,
+            userEmail: authToken.userEmail,
+            userId: authToken.userId,
+        });
+        // Persist the new token
+        await tokenStore.save(refreshedToken);
+        // Update state
+        onTokenChange(refreshedToken);
+    }
+    catch {
+        // Refresh failed - token is invalid, force logout
+        await tokenStore.clear();
+        onTokenChange();
+    }
+}

package/dist/tui/hooks/use-slash-command-processor.js

@@ -106,7 +106,6 @@ export function useSlashCommandProcessor(context, commands) {
                 name: commandNameForContext,
                 raw: input,
             },
-            slashCommands: commands,
         };
         setIsProcessing(true);
         try {

package/dist/tui/hooks/use-slash-completion.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useCommands } from '../contexts/use-commands.js';
+import { useCommands } from '../contexts/commands-context.js';
 /**
  * Generate file suggestions based on @ prefix
  * Returns files from the current working directory matching the search pattern

package/dist/tui/hooks/use-tab-navigation.d.ts

@@ -1,10 +1,11 @@
 /**
  * Tab Navigation Hook
  */
-import type { TabId } from '../types.js';
+import type { Tab, TabId } from '../types.js';
 interface UseTabNavigationResult {
     activeTab: TabId;
     setActiveTab: (tab: TabId) => void;
+    tabs: Tab[];
 }
 export declare function useTabNavigation(): UseTabNavigationResult;
 export {};

package/dist/tui/hooks/use-tab-navigation.js

@@ -2,26 +2,35 @@
  * Tab Navigation Hook
  */
 import { useApp, useInput } from 'ink';
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { stopQueuePollingService } from '../../infra/cipher/consumer/queue-polling-service.js';
 import { DEFAULT_TAB, TABS } from '../constants.js';
-import { useMode } from '../contexts/use-mode.js';
+import { useMode } from '../contexts/mode-context.js';
 import { useOnboarding } from './use-onboarding.js';
 export function useTabNavigation() {
     const { exit } = useApp();
     const { shouldShowOnboarding } = useOnboarding();
     const { mode, setMode } = useMode();
     const [activeTab, setActiveTab] = useState(DEFAULT_TAB);
+    // Filter tabs based on onboarding state - hide console during onboarding
+    const tabs = useMemo(() => (shouldShowOnboarding ? TABS.filter((t) => t.id !== 'console') : TABS), [shouldShowOnboarding]);
     // Sync mode with active tab on mount and when activeTab changes
     useEffect(() => {
         setMode(activeTab === 'activity' ? 'activity' : 'console');
     }, [activeTab, setMode]);
+    // Reset to activity tab if current tab is not available
+    useEffect(() => {
+        const isCurrentTabAvailable = tabs.some((t) => t.id === activeTab);
+        if (!isCurrentTabAvailable) {
+            setActiveTab(DEFAULT_TAB);
+        }
+    }, [tabs, activeTab]);
     useInput((input, key) => {
-        // Tab: cycle through tabs (blocked during onboarding)
+        // Tab: cycle through available tabs (blocked during onboarding)
         if (key.tab && !shouldShowOnboarding) {
-            const currentIndex = TABS.findIndex((t) => t.id === activeTab);
-            const nextIndex = currentIndex >= TABS.length - 1 ? 0 : currentIndex + 1;
-            const nextTab = TABS[nextIndex].id;
+            const currentIndex = tabs.findIndex((t) => t.id === activeTab);
+            const nextIndex = currentIndex >= tabs.length - 1 ? 0 : currentIndex + 1;
+            const nextTab = tabs[nextIndex].id;
             setActiveTab(nextTab);
             // Mode will be synced by useEffect
         }
@@ -31,5 +40,5 @@ export function useTabNavigation() {
             exit();
         }
     }, { isActive: mode === 'activity' || mode === 'console' });
-    return { activeTab, setActiveTab };
+    return { activeTab, setActiveTab, tabs };
 }

package/dist/tui/hooks/use-terminal-breakpoint.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useTerminalBreakpoint Hook
+ *
+ * Watches terminal row count and returns current breakpoint.
+ */
+export type TerminalBreakpoint = 'compact' | 'normal';
+export interface TerminalBreakpointReturn {
+    breakpoint: TerminalBreakpoint;
+    columns: number;
+    rows: number;
+}
+/**
+ * Hook for determining terminal breakpoint based on row count
+ *
+ * Breakpoints:
+ * - compact: 0 - 23 rows (small terminal, limited space)
+ * - normal: >= 24 rows (standard terminal, comfortable space)
+ *
+ * @returns Current breakpoint and terminal dimensions
+ */
+export declare function useTerminalBreakpoint(): TerminalBreakpointReturn;

package/dist/tui/hooks/use-terminal-breakpoint.js

@@ -0,0 +1,38 @@
+/**
+ * useTerminalBreakpoint Hook
+ *
+ * Watches terminal row count and returns current breakpoint.
+ */
+import { useStdout } from 'ink';
+import { useEffect, useState } from 'react';
+/**
+ * Hook for determining terminal breakpoint based on row count
+ *
+ * Breakpoints:
+ * - compact: 0 - 23 rows (small terminal, limited space)
+ * - normal: >= 24 rows (standard terminal, comfortable space)
+ *
+ * @returns Current breakpoint and terminal dimensions
+ */
+export function useTerminalBreakpoint() {
+    const { stdout } = useStdout();
+    const [dimensions, setDimensions] = useState({
+        columns: stdout?.columns ?? 80,
+        rows: stdout?.rows ?? 24,
+    });
+    useEffect(() => {
+        const handleResize = () => {
+            setDimensions({
+                columns: process.stdout.columns,
+                rows: process.stdout.rows,
+            });
+        };
+        process.stdout.on('resize', handleResize);
+        return () => {
+            process.stdout.off('resize', handleResize);
+        };
+    }, []);
+    const { columns, rows } = dimensions;
+    const breakpoint = rows >= 22 ? 'normal' : 'compact';
+    return { breakpoint, columns, rows };
+}

package/dist/tui/hooks/use-ui-heights.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Configuration object defining all UI element heights per breakpoint
+ *
+ * Single source of truth for UI layout across different terminal sizes.
+ * Each breakpoint defines a complete set of height values for all UI elements.
+ *
+ * Breakpoints:
+ * - compact (0-23 rows): Minimal heights for small terminals
+ * - normal (≥24 rows): Standard heights for comfortable viewing
+ *
+ * Note: Object keys are ordered top-to-bottom according to actual UI layout.
+ * perfectionist/sort-objects is disabled to preserve this logical ordering.
+ */
+declare const BREAKPOINT_HEIGHTS: {
+    readonly compact: {
+        readonly header: 2;
+        readonly tab: 3;
+        readonly messageItem: {
+            readonly header: 1;
+            readonly input: 3;
+            readonly maxProgressItems: 2;
+            readonly contentBottomMargin: 0;
+            readonly maxChanges: {
+                readonly created: 2;
+                readonly updated: 2;
+            };
+            readonly bottomMargin: 1;
+        };
+        readonly commandInput: 3;
+        readonly footer: 1;
+        readonly appBottomPadding: 0;
+    };
+    readonly normal: {
+        readonly header: 2;
+        readonly tab: 3;
+        readonly messageItem: {
+            readonly header: 1;
+            readonly input: 3;
+            readonly maxProgressItems: 3;
+            readonly contentBottomMargin: 1;
+            readonly maxChanges: {
+                readonly created: 3;
+                readonly updated: 3;
+            };
+            readonly bottomMargin: 1;
+        };
+        readonly commandInput: 3;
+        readonly footer: 1;
+        readonly appBottomPadding: 0;
+    };
+};
+/**
+ * Message item heights interface
+ *
+ * Defines height constraints for individual message item components
+ * in the activity logs view. These values control how much vertical
+ * space each part of a message can consume.
+ *
+ */
+export interface MessageItemHeights {
+    bottomMargin: number;
+    contentBottomMargin: number;
+    header: number;
+    input: number;
+    maxChanges: {
+        created: number;
+        updated: number;
+    };
+    maxContentLines: number;
+    maxProgressItems: number;
+}
+/**
+ * Breakpoint configuration type derived from BREAKPOINT_HEIGHTS
+ *
+ * Single source of truth - directly represents the configuration structure.
+ * This type automatically infers the shape from BREAKPOINT_HEIGHTS object,
+ * ensuring type safety when accessing height values.
+ *
+ * Structure:
+ * - header: Height of header section
+ * - tab: Height of tab bar
+ * - footer: Height of footer section
+ * - messageItem: Nested heights for message item components
+ * - appBottomPadding: Bottom padding for the entire app
+ */
+export type BreakpointConfig = typeof BREAKPOINT_HEIGHTS[keyof typeof BREAKPOINT_HEIGHTS];
+/**
+ * Complete UI heights return type
+ *
+ * Extends BreakpointConfig with the current breakpoint name.
+ * Use this to access all height values directly without nested structure.
+ *
+ * @example
+ * const {breakpoint, header, tab, footer, messageItem, appBottomPadding} = useUIHeights()
+ * const totalFixed = header + tab + footer
+ */
+export type UIHeights = BreakpointConfig & {
+    breakpoint: 'compact' | 'normal';
+};
+/**
+ * Hook for providing breakpoint-specific UI heights
+ *
+ * Detects the current terminal breakpoint and returns the corresponding
+ * height configuration from BREAKPOINT_HEIGHTS. All height values are
+ * returned at the top level for easy destructuring.
+ *
+ * @returns {UIHeights} Object containing:
+ *   - breakpoint: Current breakpoint ('compact' | 'normal')
+ *   - header: Header section height
+ *   - tab: Tab bar height
+ *   - footer: Footer section height
+ *   - messageItem: Message item component heights
+ *   - appBottomPadding: App bottom padding
+ *
+ * @example
+ * const {breakpoint, header, tab, footer, messageItem} = useUIHeights()
+ * const availableHeight = terminalRows - header - tab - footer
+ */
+export declare function useUIHeights(): UIHeights;
+export {};

package/dist/tui/hooks/use-ui-heights.js

@@ -0,0 +1,88 @@
+/* eslint-disable perfectionist/sort-objects */
+/**
+ * useUIHeights Hook
+ *
+ * Provides breakpoint-specific height configuration for all UI elements.
+ * Returns the complete configuration object from BREAKPOINT_HEIGHTS
+ * based on current terminal size, including header, tab, footer, messageItem,
+ * commandItem, and appBottomPadding values.
+ */
+import { useTerminalBreakpoint } from './use-terminal-breakpoint.js';
+/**
+ * Configuration object defining all UI element heights per breakpoint
+ *
+ * Single source of truth for UI layout across different terminal sizes.
+ * Each breakpoint defines a complete set of height values for all UI elements.
+ *
+ * Breakpoints:
+ * - compact (0-23 rows): Minimal heights for small terminals
+ * - normal (≥24 rows): Standard heights for comfortable viewing
+ *
+ * Note: Object keys are ordered top-to-bottom according to actual UI layout.
+ * perfectionist/sort-objects is disabled to preserve this logical ordering.
+ */
+const BREAKPOINT_HEIGHTS = {
+    compact: {
+        header: 2,
+        tab: 3,
+        messageItem: {
+            header: 1,
+            input: 3,
+            maxProgressItems: 2,
+            contentBottomMargin: 0,
+            maxChanges: {
+                created: 2,
+                updated: 2,
+            },
+            bottomMargin: 1,
+        },
+        commandInput: 3,
+        footer: 1,
+        appBottomPadding: 0,
+    },
+    normal: {
+        header: 2,
+        tab: 3,
+        messageItem: {
+            header: 1,
+            input: 3,
+            maxProgressItems: 3,
+            contentBottomMargin: 1,
+            maxChanges: {
+                created: 3,
+                updated: 3,
+            },
+            bottomMargin: 1,
+        },
+        commandInput: 3,
+        footer: 1,
+        appBottomPadding: 0,
+    },
+};
+/**
+ * Hook for providing breakpoint-specific UI heights
+ *
+ * Detects the current terminal breakpoint and returns the corresponding
+ * height configuration from BREAKPOINT_HEIGHTS. All height values are
+ * returned at the top level for easy destructuring.
+ *
+ * @returns {UIHeights} Object containing:
+ *   - breakpoint: Current breakpoint ('compact' | 'normal')
+ *   - header: Header section height
+ *   - tab: Tab bar height
+ *   - footer: Footer section height
+ *   - messageItem: Message item component heights
+ *   - appBottomPadding: App bottom padding
+ *
+ * @example
+ * const {breakpoint, header, tab, footer, messageItem} = useUIHeights()
+ * const availableHeight = terminalRows - header - tab - footer
+ */
+export function useUIHeights() {
+    const { breakpoint } = useTerminalBreakpoint();
+    const config = BREAKPOINT_HEIGHTS[breakpoint];
+    return {
+        breakpoint,
+        ...config,
+    };
+}

package/dist/tui/providers/app-providers.js

@@ -1,9 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { AuthProvider, ConsumerProvider, ServicesProvider } from '../contexts/index.js';
-import { OnboardingProvider } from '../contexts/onboarding-context.js';
-import { CommandsProvider } from '../contexts/use-commands.js';
-import { ModeProvider } from '../contexts/use-mode.js';
-import { ThemeProvider } from '../contexts/use-theme.js';
+import { AuthProvider, CommandsProvider, ModeProvider, OnboardingProvider, ServicesProvider, TasksProvider, ThemeProvider, TransportProvider, } from '../contexts/index.js';
 export function AppProviders({ children, initialAuthToken, initialBrvConfig, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }) {
-    return (_jsx(ServicesProvider, { onboardingPreferenceStore: onboardingPreferenceStore, projectConfigStore: projectConfigStore, tokenStore: tokenStore, trackingService: trackingService, version: version, children: _jsx(AuthProvider, { initialAuthToken: initialAuthToken, initialBrvConfig: initialBrvConfig, children: _jsx(ThemeProvider, { children: _jsx(CommandsProvider, { children: _jsx(ModeProvider, { children: _jsx(ConsumerProvider, { children: _jsx(OnboardingProvider, { children: children }) }) }) }) }) }) }));
+    return (_jsx(ServicesProvider, { onboardingPreferenceStore: onboardingPreferenceStore, projectConfigStore: projectConfigStore, tokenStore: tokenStore, trackingService: trackingService, version: version, children: _jsx(AuthProvider, { initialAuthToken: initialAuthToken, initialBrvConfig: initialBrvConfig, children: _jsx(ThemeProvider, { children: _jsx(CommandsProvider, { children: _jsx(ModeProvider, { children: _jsx(TransportProvider, { children: _jsx(TasksProvider, { children: _jsx(OnboardingProvider, { children: children }) }) }) }) }) }) }) }));
 }

package/dist/tui/types/commands.d.ts

@@ -3,7 +3,6 @@
  */
 import type React from 'react';
 import type { PromptRequest, StreamingMessage } from './index.js';
-import type { Message } from './messages.js';
 /**
  * Command kind indicates the source/type of command
  * Based on Gemini CLI pattern for extensibility
@@ -59,31 +58,6 @@ export interface CommandContext {
         /** Full raw input string */
         raw: string;
     };
-    /**
-     * All loaded slash commands (for help command, etc.)
-     */
-    slashCommands?: readonly SlashCommand[];
-    /**
-     * UI operations available to commands
-     */
-    ui?: {
-        /**
-         * Add a message to the message history
-         */
-        addMessage: (msg: Message) => void;
-        /**
-         * Clear all messages from the history
-         */
-        clearMessages: () => void;
-        /**
-         * Remove the currently displayed custom dialog
-         */
-        removeDialog: () => void;
-        /**
-         * Set processing state
-         */
-        setIsProcessing: (processing: boolean) => void;
-    };
     /**
      * CLI version
      */

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

@@ -8,4 +8,4 @@ export type { ClearActionReturn, CommandArg, CommandContext, CommandFlag, Comman
 export type { ConfirmationRequest, CurateContextInputRequest, CurateDialogRequest, QueryDialogRequest, } from './dialogs.js';
 export type { ActivityLog, CommandMessage, Message, StreamingMessage } from './messages.js';
 export type { ConfirmPromptRequest, FileSelectorItemResult, FileSelectorMode, FileSelectorPromptRequest, InputPromptRequest, PromptChoice, PromptRequest, SearchPromptRequest, SelectPromptRequest, } from './prompts.js';
-export type { AuthState, ConsumerStatus, QueueStats, Tab, TabId } from './ui.js';
+export type { AuthState, ConsumerStatus, Tab, TabId, TaskStats } from './ui.js';

package/dist/tui/types/ui.d.ts

@@ -7,8 +7,13 @@ export interface Tab {
     id: TabId;
     label: string;
 }
-export interface QueueStats {
-    pending: number;
-    processing: number;
-}
+/**
+ * Statistics for task states.
+ */
+export type TaskStats = {
+    /** Number of tasks in 'created' status */
+    created: number;
+    /** Number of tasks in 'started' status */
+    started: number;
+};
 export type ConsumerStatus = 'error' | 'running' | 'starting' | 'stopped';

package/dist/tui/utils/line.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Line utility functions for calculating visual line counts
+ */
+/**
+ * Calculate visual line count for a single line, accounting for wrapping
+ *
+ * @param line - The text line to measure
+ * @param maxCharsPerLine - Maximum characters per line (terminal width)
+ * @returns Number of visual lines this text will occupy
+ */
+export declare function getVisualLineCount(line: string, maxCharsPerLine: number): number;

package/dist/tui/utils/line.js

@@ -0,0 +1,16 @@
+/**
+ * Line utility functions for calculating visual line counts
+ */
+/**
+ * Calculate visual line count for a single line, accounting for wrapping
+ *
+ * @param line - The text line to measure
+ * @param maxCharsPerLine - Maximum characters per line (terminal width)
+ * @returns Number of visual lines this text will occupy
+ */
+export function getVisualLineCount(line, maxCharsPerLine) {
+    if (maxCharsPerLine <= 0 || line.length === 0) {
+        return 1;
+    }
+    return Math.ceil(line.length / maxCharsPerLine) || 1;
+}

package/dist/tui/utils/log.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Log utility functions for height calculations
+ */
+import type { MessageItemHeights } from '../hooks/index.js';
+import type { ActivityLog } from '../types.js';
+/**
+ * Calculate the actual rendered height of a log item.
+ * This reflects the real space the item takes up when rendered.
+ *
+ * @param log - The activity log to analyze
+ * @param baseHeights - Base height configuration from breakpoint (maxContentLines is optional)
+ * @returns Total height in lines that this log item will occupy
+ */
+export declare function calculateActualLogHeight(log: ActivityLog, baseHeights: MessageItemHeights): number;
+/**
+ * Calculate dynamic space usage for each part of a log
+ * Returns array showing how many lines each field uses
+ *
+ * @param log - The activity log to analyze
+ * @param scrollableHeight - Total available height for content area
+ * @param baseHeights - Base height configuration from breakpoint
+ * @returns Array of { field, lines } showing space breakdown, including calculated content lines
+ */
+export declare function calculateLogContentLimit(log: ActivityLog, scrollableHeight: number, baseHeights: Omit<MessageItemHeights, 'maxContentLines'>): Array<{
+    field: string;
+    lines: number;
+}>;