byterover-cli 0.3.5 → 0.4.0

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

@@ -0,0 +1,43 @@
+/**
+ * Onboarding Context
+ *
+ * Global context for managing onboarding state and step derivation.
+ * State is derived from brvConfig and sessionExecutions.
+ *
+ * Usage:
+ * ```tsx
+ * const {currentStep, shouldShowOnboarding, completeOnboarding} = useOnboarding()
+ * ```
+ */
+import React from 'react';
+export type OnboardingStep = 'complete' | 'curate' | 'init' | 'query';
+export interface OnboardingContextValue {
+    /** Set onboarding complete state. Pass skipped=true when user skips via Esc */
+    completeOnboarding: (skipped?: boolean) => void;
+    /** Whether user has acknowledged curate completion */
+    curateAcknowledged: boolean;
+    /** Current onboarding step */
+    currentStep: OnboardingStep;
+    /** Whether curate has been completed at least once */
+    hasCurated: boolean;
+    /** Whether query has been completed at least once */
+    hasQueried: boolean;
+    /** Whether the project is initialized (brvConfig exists) */
+    isInitialized: boolean;
+    /** Whether user has acknowledged query completion */
+    queryAcknowledged: boolean;
+    /** Set curate acknowledged state */
+    setCurateAcknowledged: (value: boolean) => void;
+    /** Set query acknowledged state */
+    setQueryAcknowledged: (value: boolean) => void;
+    /** Whether onboarding should be shown */
+    shouldShowOnboarding: boolean;
+    /** Total number of steps (excluding complete) */
+    totalSteps: number;
+}
+interface OnboardingProviderProps {
+    children: React.ReactNode;
+}
+export declare function OnboardingProvider({ children }: OnboardingProviderProps): React.ReactElement;
+export declare function useOnboarding(): OnboardingContextValue;
+export {};

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

@@ -0,0 +1,181 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Onboarding Context
+ *
+ * Global context for managing onboarding state and step derivation.
+ * State is derived from brvConfig and sessionExecutions.
+ *
+ * Usage:
+ * ```tsx
+ * const {currentStep, shouldShowOnboarding, completeOnboarding} = useOnboarding()
+ * ```
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { useAuth } from './auth-context.js';
+import { useConsumer } from './index.js';
+import { useServices } from './services-context.js';
+const OnboardingContext = createContext(undefined);
+/**
+ * Provider for onboarding state
+ *
+ * State derivation:
+ * - Init: When !brvConfig
+ * - Curate: When brvConfig exists but no curate completion in session
+ * - Query: When curate completed but no query completion in session
+ * - Complete: When both curate and query completed
+ *
+ * Onboarding starts when project is not initialized on mount and
+ * continues until all steps are completed and dismissed.
+ */
+/** Cooldown period in milliseconds (7 days) */
+const ONBOARDING_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
+export function OnboardingProvider({ children }) {
+    const { brvConfig, isInitialConfigLoaded } = useAuth();
+    const { sessionExecutions } = useConsumer();
+    const { onboardingPreferenceStore, trackingService } = useServices();
+    const isInitialized = brvConfig !== undefined;
+    // Track if we've already checked initial config state
+    const hasCheckedRef = useRef(false);
+    // Track if project was not initialized after initial config check
+    // This determines whether we're in onboarding mode for this session
+    const wasNotInitializedRef = useRef(true);
+    // Track if onboarding is in cooldown (dismissed less than a week ago)
+    const [isInCooldown, setIsInCooldown] = useState(true); // Start true until we check
+    // Check cooldown on mount
+    useEffect(() => {
+        const checkCooldown = async () => {
+            const lastDismissedAt = await onboardingPreferenceStore.getLastDismissedAt();
+            if (lastDismissedAt) {
+                const elapsed = Date.now() - lastDismissedAt;
+                setIsInCooldown(elapsed < ONBOARDING_COOLDOWN_MS);
+            }
+            else {
+                // Never dismissed before - not in cooldown
+                setIsInCooldown(false);
+            }
+        };
+        checkCooldown();
+    }, [onboardingPreferenceStore]);
+    // Update ref once initial config load completes (only once)
+    // This distinguishes "async load found existing config" from "user just ran init"
+    useEffect(() => {
+        if (isInitialConfigLoaded && !hasCheckedRef.current) {
+            hasCheckedRef.current = true;
+            if (isInitialized) {
+                // Config existed before user interaction - don't show onboarding
+                wasNotInitializedRef.current = false;
+            }
+        }
+    }, [isInitialConfigLoaded, isInitialized]);
+    // Track acknowledgment for completed steps (user pressed Enter after seeing output)
+    const [curateAcknowledged, setCurateAcknowledgedState] = useState(false);
+    const [queryAcknowledged, setQueryAcknowledgedState] = useState(false);
+    // Track if user has dismissed the onboarding (pressed Enter on complete step)
+    const [onboardingDismissed, setOnboardingDismissed] = useState(false);
+    // Track if init was completed during this onboarding session (to avoid duplicate tracking)
+    const initTrackedRef = useRef(false);
+    // Track init completion when isInitialized changes during onboarding
+    useEffect(() => {
+        if (wasNotInitializedRef.current && isInitialized && !initTrackedRef.current) {
+            initTrackedRef.current = true;
+            trackingService.track('onboarding:init_completed');
+        }
+    }, [isInitialized, trackingService]);
+    // Wrapper for setCurateAcknowledged that also tracks
+    const setCurateAcknowledged = useCallback((value) => {
+        setCurateAcknowledgedState(value);
+        if (value) {
+            trackingService.track('onboarding:curate_completed');
+        }
+    }, [trackingService]);
+    // Wrapper for setQueryAcknowledged that also tracks
+    const setQueryAcknowledged = useCallback((value) => {
+        setQueryAcknowledgedState(value);
+        if (value) {
+            trackingService.track('onboarding:query_completed');
+        }
+    }, [trackingService]);
+    // Check for completed curate/query executions in session
+    const { hasCurated, hasQueried } = useMemo(() => {
+        let curateCompleted = false;
+        let queryCompleted = false;
+        for (const { execution } of sessionExecutions) {
+            if (execution.status === 'completed') {
+                if (execution.type === 'curate') {
+                    curateCompleted = true;
+                }
+                else if (execution.type === 'query') {
+                    queryCompleted = true;
+                }
+            }
+            // Early exit if both found
+            if (curateCompleted && queryCompleted)
+                break;
+        }
+        return { hasCurated: curateCompleted, hasQueried: queryCompleted };
+    }, [sessionExecutions]);
+    // Derive current step (considering acknowledgment)
+    // Stay on curate/query step until user acknowledges the completion
+    const currentStep = useMemo(() => {
+        if (!isInitialized)
+            return 'init';
+        if (!hasCurated)
+            return 'curate';
+        // hasCurated is true but not yet acknowledged -> stay on curate
+        if (!curateAcknowledged)
+            return 'curate';
+        if (!hasQueried)
+            return 'query';
+        // hasQueried is true but not yet acknowledged -> stay on query
+        if (!queryAcknowledged)
+            return 'query';
+        return 'complete';
+    }, [isInitialized, hasCurated, hasQueried, curateAcknowledged, queryAcknowledged]);
+    // Show onboarding if:
+    // 1. Project was not initialized after initial config check, AND
+    // 2. User has not dismissed the onboarding in this session, AND
+    // 3. Not in cooldown period (dismissed less than a week ago)
+    const shouldShowOnboarding = wasNotInitializedRef.current && !onboardingDismissed && !isInCooldown;
+    const completeOnboarding = useCallback((skipped = false) => {
+        setOnboardingDismissed(true);
+        // Save the dismissal timestamp to enforce cooldown period
+        onboardingPreferenceStore.setLastDismissedAt(Date.now());
+        if (skipped) {
+            trackingService.track('onboarding:skipped', { step: currentStep });
+        }
+        else {
+            trackingService.track('onboarding:completed');
+        }
+    }, [currentStep, onboardingPreferenceStore, trackingService]);
+    const contextValue = useMemo(() => ({
+        completeOnboarding,
+        curateAcknowledged,
+        currentStep,
+        hasCurated,
+        hasQueried,
+        isInitialized,
+        queryAcknowledged,
+        setCurateAcknowledged,
+        setQueryAcknowledged,
+        shouldShowOnboarding,
+        totalSteps: 3, // init, curate, query (complete is not counted)
+    }), [
+        completeOnboarding,
+        curateAcknowledged,
+        currentStep,
+        hasCurated,
+        hasQueried,
+        isInCooldown,
+        isInitialized,
+        queryAcknowledged,
+        shouldShowOnboarding,
+    ]);
+    return _jsx(OnboardingContext.Provider, { value: contextValue, children: children });
+}
+export function useOnboarding() {
+    const context = useContext(OnboardingContext);
+    if (!context) {
+        throw new Error('useOnboarding must be used within OnboardingProvider');
+    }
+    return context;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Services Context
+ *
+ * Provides dependency injection for stores and app config.
+ * This context is stable - values don't change during the app lifecycle.
+ */
+import React from 'react';
+import type { IOnboardingPreferenceStore } from '../../core/interfaces/i-onboarding-preference-store.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+export interface ServicesContextValue {
+    onboardingPreferenceStore: IOnboardingPreferenceStore;
+    projectConfigStore: IProjectConfigStore;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    version: string;
+}
+interface ServicesProviderProps {
+    children: React.ReactNode;
+    onboardingPreferenceStore: IOnboardingPreferenceStore;
+    projectConfigStore: IProjectConfigStore;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    version: string;
+}
+export declare function ServicesProvider({ children, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }: ServicesProviderProps): React.ReactElement;
+export declare function useServices(): ServicesContextValue;
+export {};

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

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Services Context
+ *
+ * Provides dependency injection for stores and app config.
+ * This context is stable - values don't change during the app lifecycle.
+ */
+import { createContext, useContext, useMemo } from 'react';
+const ServicesContext = createContext(undefined);
+export function ServicesProvider({ children, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }) {
+    const value = useMemo(() => ({ onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version }), [onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version]);
+    return _jsx(ServicesContext.Provider, { value: value, children: children });
+}
+export function useServices() {
+    const context = useContext(ServicesContext);
+    if (!context) {
+        throw new Error('useServices must be used within ServicesProvider');
+    }
+    return context;
+}

package/dist/tui/contexts/use-commands.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Commands Context
+ *
+ * Global context for managing slash commands across the entire app.
+ * Loads commands on mount and provides them to any component.
+ *
+ * Usage:
+ * ```tsx
+ * const {commands, handleSlashCommand} = useCommands()
+ *
+ * // Access commands
+ * commands.forEach(cmd => console.log(cmd.name))
+ *
+ * // Execute a command
+ * const result = await handleSlashCommand('/help')
+ * ```
+ */
+import React from 'react';
+import type { SlashCommand, SlashCommandActionReturn } from '../types.js';
+interface CommandsContextValue {
+    commands: readonly SlashCommand[];
+    handleSlashCommand: (input: string) => Promise<SlashCommandActionReturn>;
+}
+interface CommandsProviderProps {
+    children: React.ReactNode;
+}
+export declare function CommandsProvider({ children }: CommandsProviderProps): React.ReactElement;
+export declare function useCommands(): CommandsContextValue;
+export {};

package/dist/tui/contexts/use-commands.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Commands Context
+ *
+ * Global context for managing slash commands across the entire app.
+ * Loads commands on mount and provides them to any component.
+ *
+ * Usage:
+ * ```tsx
+ * const {commands, handleSlashCommand} = useCommands()
+ *
+ * // Access commands
+ * commands.forEach(cmd => console.log(cmd.name))
+ *
+ * // Execute a command
+ * const result = await handleSlashCommand('/help')
+ * ```
+ */
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { load } from '../../infra/repl/commands/index.js';
+import { useSlashCommandProcessor } from '../hooks/index.js';
+const CommandsContext = createContext(undefined);
+export function CommandsProvider({ children }) {
+    const [commands, setCommands] = useState([]);
+    useEffect(() => {
+        const abortController = new AbortController();
+        async function loadCommands() {
+            setCommands(load());
+        }
+        loadCommands();
+        return () => {
+            abortController.abort();
+        };
+    }, []);
+    const commandContext = useMemo(() => ({
+        slashCommands: commands,
+        // version:, -> need pass version here
+        // syncService:, -> need pass sync service here
+    }), [commands]);
+    const { handleSlashCommand } = useSlashCommandProcessor(commandContext, commands);
+    const contextValue = useMemo(() => ({
+        commands,
+        handleSlashCommand,
+    }), [commands, handleSlashCommand]);
+    return _jsx(CommandsContext.Provider, { value: contextValue, children: children });
+}
+export function useCommands() {
+    const context = useContext(CommandsContext);
+    if (!context) {
+        throw new Error('useCommands must be used within CommandsProvider');
+    }
+    return context;
+}

package/dist/tui/contexts/use-mode.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Mode Context
+ *
+ * Global context for managing application mode state and keyboard shortcuts.
+ * Any component can access the current mode, switch modes, or get mode-specific shortcuts.
+ *
+ * Usage:
+ * ```tsx
+ * const {mode, setMode, shortcuts} = useMode()
+ *
+ * // Access current mode
+ * console.log(mode) // "activity" or "console"
+ *
+ * // Switch mode
+ * setMode('suggestions')
+ *
+ * // Access mode-specific shortcuts
+ * shortcuts.forEach(s => console.log(`${s.key}: ${s.description}`))
+ * ```
+ */
+import React from 'react';
+type Mode = 'activity' | 'console' | 'suggestions';
+/**
+ * Keyboard shortcut definition
+ */
+export interface Shortcut {
+    description: string;
+    key: string;
+}
+interface ModeContextValue {
+    appendShortcuts: (shortcuts: Shortcut[]) => void;
+    mode: Mode;
+    removeShortcuts: (keys: string[]) => void;
+    setMode: (mode: Mode) => void;
+    shortcuts: readonly Shortcut[];
+}
+interface ModeProviderProps {
+    children: React.ReactNode;
+    initialMode?: Mode;
+}
+export declare function ModeProvider({ children, initialMode }: ModeProviderProps): React.ReactElement;
+export declare function useMode(): ModeContextValue;
+export {};

package/dist/tui/contexts/use-mode.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Mode Context
+ *
+ * Global context for managing application mode state and keyboard shortcuts.
+ * Any component can access the current mode, switch modes, or get mode-specific shortcuts.
+ *
+ * Usage:
+ * ```tsx
+ * const {mode, setMode, shortcuts} = useMode()
+ *
+ * // Access current mode
+ * console.log(mode) // "activity" or "console"
+ *
+ * // Switch mode
+ * setMode('suggestions')
+ *
+ * // Access mode-specific shortcuts
+ * shortcuts.forEach(s => console.log(`${s.key}: ${s.description}`))
+ * ```
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+/**
+ * Keyboard shortcuts by mode
+ */
+const SHORTCUTS_BY_MODE = {
+    activity: [
+        { description: 'scroll logs', key: '↑↓' },
+        { description: 'switch view', key: 'tab' },
+        { description: 'quit', key: 'ctrl+c' },
+    ],
+    console: [
+        { description: 'scroll', key: '↑↓' },
+        { description: 'switch view', key: 'tab' },
+        { description: 'quit', key: 'ctrl+c' },
+    ],
+    suggestions: [
+        { description: 'navigate', key: '↑↓' },
+        { description: 'select', key: 'enter' },
+        { description: 'insert', key: 'tab' },
+        { description: 'close', key: 'esc' },
+    ],
+};
+const ModeContext = createContext(undefined);
+export function ModeProvider({ children, initialMode = 'activity' }) {
+    const [mode, setModeState] = useState(initialMode);
+    const [extraShortcuts, setExtraShortcuts] = useState([]);
+    const setMode = useCallback((newMode) => {
+        setModeState(newMode);
+    }, []);
+    const appendShortcuts = useCallback((shortcuts) => {
+        setExtraShortcuts((prev) => [...prev, ...shortcuts]);
+    }, []);
+    const removeShortcuts = useCallback((keys) => {
+        setExtraShortcuts((prev) => prev.filter((s) => !keys.includes(s.key)));
+    }, []);
+    const shortcuts = useMemo(() => {
+        const base = [...SHORTCUTS_BY_MODE[mode]];
+        return [...base, ...extraShortcuts];
+    }, [mode, extraShortcuts]);
+    const contextValue = useMemo(() => ({
+        appendShortcuts,
+        mode,
+        removeShortcuts,
+        setMode,
+        shortcuts,
+    }), [appendShortcuts, mode, removeShortcuts, setMode, shortcuts]);
+    return _jsx(ModeContext.Provider, { value: contextValue, children: children });
+}
+export function useMode() {
+    const context = useContext(ModeContext);
+    if (!context) {
+        throw new Error('useMode must be used within ModeProvider');
+    }
+    return context;
+}

package/dist/tui/contexts/use-theme.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Theme Context
+ *
+ * Global context for managing theme state across the entire app.
+ * Any component can access the current theme or switch themes dynamically.
+ *
+ * Usage:
+ * ```tsx
+ * const {theme, setTheme} = useTheme()
+ *
+ * // Access theme properties
+ * <Text color={theme.colors.primary}>Hello</Text>
+ *
+ * // Switch theme (future feature)
+ * setTheme('default')
+ * ```
+ */
+import React from 'react';
+export interface ThemeColors {
+    bg1: string;
+    bg2: string;
+    border: string;
+    curateCommand: string;
+    dimText: string;
+    errorText: string;
+    info: string;
+    logoBold: string;
+    logoDecor: string;
+    logoVersion: string;
+    primary: string;
+    queryCommand: string;
+    secondary: string;
+    text: string;
+    warning: string;
+}
+export interface Theme {
+    colors: ThemeColors;
+}
+export declare const themes: {
+    readonly default: Theme;
+};
+export type ThemeName = keyof typeof themes;
+interface ThemeContextValue {
+    setTheme: (name: ThemeName) => void;
+    theme: Theme;
+}
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    initialTheme?: ThemeName;
+}
+export declare function ThemeProvider({ children, initialTheme }: ThemeProviderProps): React.ReactElement;
+export declare function useTheme(): ThemeContextValue;
+export {};

package/dist/tui/contexts/use-theme.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Theme Context
+ *
+ * Global context for managing theme state across the entire app.
+ * Any component can access the current theme or switch themes dynamically.
+ *
+ * Usage:
+ * ```tsx
+ * const {theme, setTheme} = useTheme()
+ *
+ * // Access theme properties
+ * <Text color={theme.colors.primary}>Hello</Text>
+ *
+ * // Switch theme (future feature)
+ * setTheme('default')
+ * ```
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+const defaultTheme = {
+    colors: {
+        bg1: '#020202',
+        bg2: '#222221',
+        border: '#3D3D3D',
+        curateCommand: '#E5C76B',
+        dimText: '#747474',
+        errorText: '#E5484D',
+        info: '#00B8D9',
+        logoBold: '#00CC66',
+        logoDecor: '#00E6A8',
+        logoVersion: '#7FFFD4',
+        primary: '#03BF86',
+        queryCommand: '#C477FF',
+        secondary: '#4CCEBF60',
+        text: '#F3F3F3',
+        warning: '#F5A623'
+    },
+};
+export const themes = {
+    default: defaultTheme,
+};
+const ThemeContext = createContext(undefined);
+export function ThemeProvider({ children, initialTheme = 'default' }) {
+    const [theme, setThemeState] = useState(themes[initialTheme]);
+    const setTheme = useCallback((name) => {
+        setThemeState(themes[name]);
+    }, []);
+    const contextValue = useMemo(() => ({
+        setTheme,
+        theme,
+    }), [theme, setTheme]);
+    return _jsx(ThemeContext.Provider, { value: contextValue, children: children });
+}
+export function useTheme() {
+    const context = useContext(ThemeContext);
+    if (!context) {
+        throw new Error('useTheme must be used within ThemeProvider');
+    }
+    return context;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * TUI Hooks
+ */
+export { CommandsProvider, useCommands } from '../contexts/use-commands.js';
+export { ModeProvider, useMode } from '../contexts/use-mode.js';
+export { ThemeProvider, useTheme } from '../contexts/use-theme.js';
+export { composeChangesFromToolCalls, parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
+export type { UseActivityLogsReturn } from './use-activity-logs.js';
+export { useConsumer } from './use-consumer.js';
+export { useOnboarding } from './use-onboarding.js';
+export type { OnboardingStep, UseOnboardingReturn } from './use-onboarding.js';
+export { useQueuePolling, useQueuePollingCleanup } from './use-queue-polling.js';
+export { useSlashCommandProcessor } from './use-slash-command-processor.js';
+export { useSlashCompletion } from './use-slash-completion.js';
+export { useTabNavigation } from './use-tab-navigation.js';
+export { useVisibleWindow } from './use-visible-window.js';
+export type { UseVisibleWindowReturn } from './use-visible-window.js';

package/dist/tui/hooks/index.js

@@ -0,0 +1,14 @@
+/**
+ * TUI Hooks
+ */
+export { CommandsProvider, useCommands } from '../contexts/use-commands.js';
+export { ModeProvider, useMode } from '../contexts/use-mode.js';
+export { ThemeProvider, useTheme } from '../contexts/use-theme.js';
+export { composeChangesFromToolCalls, parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
+export { useConsumer } from './use-consumer.js';
+export { useOnboarding } from './use-onboarding.js';
+export { useQueuePolling, useQueuePollingCleanup } from './use-queue-polling.js';
+export { useSlashCommandProcessor } from './use-slash-command-processor.js';
+export { useSlashCompletion } from './use-slash-completion.js';
+export { useTabNavigation } from './use-tab-navigation.js';
+export { useVisibleWindow } from './use-visible-window.js';

package/dist/tui/hooks/use-activity-logs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Activity Logs Hook
+ *
+ * Transforms sessionExecutions into ActivityLog format for display.
+ */
+import type { ToolCall } from '../../core/domain/cipher/queue/types.js';
+import type { ActivityLog } from '../types.js';
+/**
+ * Parse execution input to extract content
+ */
+export declare function parseExecutionContent(input: string): string;
+/**
+ * Extract file changes from curate tool calls
+ */
+export declare function composeChangesFromToolCalls(toolCalls: ToolCall[]): {
+    created: string[];
+    updated: string[];
+};
+export interface UseActivityLogsReturn {
+    /** Activity logs derived from session executions */
+    logs: ActivityLog[];
+}
+/**
+ * Hook that transforms sessionExecutions into ActivityLog format
+ */
+export declare function useActivityLogs(): UseActivityLogsReturn;