viberag 0.3.2 → 0.4.0

package/dist/cli/components/StatusBar.js

@@ -0,0 +1,156 @@
+/**
+ * StatusBar Component
+ *
+ * Displays current status and indexing progress.
+ * Uses DaemonStatusContext for daemon state instead of Redux.
+ */
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { useDaemonStatus } from '../contexts/DaemonStatusContext.js';
+/** Braille dots spinner frames */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Simple spinner component using interval-based animation.
+ */
+function Spinner({ color }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(f => (f + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    return React.createElement(Text, { color: color },
+        SPINNER_FRAMES[frame],
+        " ");
+}
+/**
+ * Progress bar component for visual progress indication.
+ */
+function ProgressBar({ percent, width = 20, }) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return (React.createElement(Text, null,
+        React.createElement(Text, { color: "cyan" }, '█'.repeat(filled)),
+        React.createElement(Text, { dimColor: true }, '░'.repeat(empty))));
+}
+/**
+ * Format status message for display.
+ * Note: Indexing state is derived from daemon status.
+ * This function only handles non-indexing app states.
+ */
+function formatNonIndexingStatus(status) {
+    switch (status.state) {
+        case 'ready':
+            return { text: 'Ready', color: 'green', showSpinner: false };
+        case 'searching':
+            return { text: 'Searching', color: 'cyan', showSpinner: true };
+        case 'warning':
+            return { text: status.message, color: 'yellow', showSpinner: false };
+    }
+}
+/**
+ * Format stats for display.
+ */
+function formatStats(stats) {
+    if (stats === undefined) {
+        return 'Loading...';
+    }
+    if (stats === null) {
+        return 'Not indexed';
+    }
+    return `${stats.totalFiles} files · ${stats.totalChunks} chunks`;
+}
+/**
+ * Derive display values from daemon indexing state.
+ */
+function deriveIndexingDisplay(indexing) {
+    const isActive = indexing.status === 'initializing' || indexing.status === 'indexing';
+    const showProgressBar = isActive && indexing.total > 0;
+    const chunkInfo = indexing.chunksProcessed > 0
+        ? `${indexing.chunksProcessed} chunks`
+        : undefined;
+    const color = indexing.throttleMessage !== null ? 'yellow' : 'cyan';
+    return {
+        isActive,
+        showProgressBar,
+        percent: indexing.percent,
+        stage: indexing.stage,
+        chunkInfo,
+        throttleInfo: indexing.throttleMessage,
+        color,
+    };
+}
+export default function StatusBar({ status, stats }) {
+    const statsText = formatStats(stats);
+    // Get daemon status from context
+    const daemonStatus = useDaemonStatus();
+    // Derive indexing display from daemon status
+    const indexingDisplay = daemonStatus
+        ? deriveIndexingDisplay(daemonStatus.indexing)
+        : {
+            isActive: false,
+            showProgressBar: false,
+            percent: 0,
+            stage: '',
+            chunkInfo: undefined,
+            throttleInfo: null,
+            color: 'cyan',
+        };
+    const isIndexingActive = indexingDisplay.isActive;
+    // Get failures from daemon status
+    const failures = daemonStatus?.failures ?? [];
+    // Determine display values based on state source
+    const nonIndexingStatus = formatNonIndexingStatus(status);
+    // Use daemon status for indexing display, props for everything else
+    const displayValues = isIndexingActive
+        ? {
+            text: indexingDisplay.stage,
+            color: indexingDisplay.color,
+            showSpinner: true,
+            showProgressBar: indexingDisplay.showProgressBar,
+            percent: indexingDisplay.percent,
+            stage: indexingDisplay.stage,
+            chunkInfo: indexingDisplay.chunkInfo,
+            throttleInfo: indexingDisplay.throttleInfo,
+        }
+        : {
+            text: nonIndexingStatus.text,
+            color: nonIndexingStatus.color,
+            showSpinner: nonIndexingStatus.showSpinner,
+            showProgressBar: false,
+            percent: 0,
+            stage: '',
+            chunkInfo: undefined,
+            throttleInfo: null,
+        };
+    const { text, color, showSpinner, showProgressBar, percent, stage, chunkInfo, throttleInfo, } = displayValues;
+    // Show failure summary if any batches failed
+    const hasFailures = failures.length > 0;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { paddingX: 1, justifyContent: "space-between" },
+            React.createElement(Box, null,
+                showSpinner && React.createElement(Spinner, { color: color }),
+                showProgressBar ? (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: color },
+                        stage,
+                        " "),
+                    React.createElement(Text, null, "["),
+                    React.createElement(ProgressBar, { percent: percent }),
+                    React.createElement(Text, null, "] "),
+                    React.createElement(Text, { color: color },
+                        percent,
+                        "%"),
+                    chunkInfo && React.createElement(Text, { dimColor: true },
+                        " \u00B7 ",
+                        chunkInfo),
+                    throttleInfo && React.createElement(Text, { color: "yellow" },
+                        " \u00B7 ",
+                        throttleInfo))) : (React.createElement(Text, { color: color }, text))),
+            React.createElement(Text, { dimColor: true }, statsText)),
+        hasFailures && (React.createElement(Box, { paddingLeft: 2 },
+            React.createElement(Text, { color: "red" },
+                "\u26A0 ",
+                failures.length,
+                " batch(es) failed - see .viberag/debug.log")))));
+}

package/dist/cli/contexts/DaemonStatusContext.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Daemon Status Context
+ *
+ * Provides daemon status to CLI components via React Context.
+ * Replaces Redux sync for daemon state - components read directly
+ * from the polled status instead of going through Redux.
+ */
+import React, { type ReactNode } from 'react';
+import type { DaemonStatusResponse } from '../../client/types.js';
+interface DaemonStatusProviderProps {
+    children: ReactNode;
+    projectRoot: string;
+    enabled?: boolean;
+    intervalMs?: number;
+}
+/**
+ * Provides daemon status to child components.
+ *
+ * Polls daemon.status() and makes the result available via context.
+ * Components use useDaemonStatus() to access the current status.
+ */
+export declare function DaemonStatusProvider({ children, projectRoot, enabled, intervalMs, }: DaemonStatusProviderProps): React.ReactElement;
+/**
+ * Access the current daemon status.
+ *
+ * Returns null if status hasn't been fetched yet or daemon is not running.
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const status = useDaemonStatus();
+ *   if (!status) return <Text>Loading...</Text>;
+ *   return <Text>Indexing: {status.indexing.status}</Text>;
+ * }
+ * ```
+ */
+export declare function useDaemonStatus(): DaemonStatusResponse | null;
+export {};

package/dist/cli/contexts/DaemonStatusContext.js

@@ -0,0 +1,106 @@
+/**
+ * Daemon Status Context
+ *
+ * Provides daemon status to CLI components via React Context.
+ * Replaces Redux sync for daemon state - components read directly
+ * from the polled status instead of going through Redux.
+ */
+import React, { createContext, useContext, useState, useEffect, useRef, } from 'react';
+import { DaemonClient } from '../../client/index.js';
+import { createCliLogger, handleCliErrorIfUnexpected, isExpectedError, } from '../utils/error-handler.js';
+// ============================================================================
+// Context
+// ============================================================================
+const DaemonStatusContext = createContext(null);
+/**
+ * Provides daemon status to child components.
+ *
+ * Polls daemon.status() and makes the result available via context.
+ * Components use useDaemonStatus() to access the current status.
+ */
+export function DaemonStatusProvider({ children, projectRoot, enabled = true, intervalMs = 500, }) {
+    const [status, setStatus] = useState(null);
+    const clientRef = useRef(null);
+    const pollingRef = useRef(false);
+    const loggerRef = useRef(null);
+    useEffect(() => {
+        let mounted = true;
+        let interval = null;
+        if (!enabled) {
+            return () => {
+                mounted = false;
+            };
+        }
+        loggerRef.current = createCliLogger(projectRoot);
+        const client = new DaemonClient({
+            projectRoot,
+            autoStart: false,
+        });
+        clientRef.current = client;
+        const poll = async () => {
+            if (!mounted)
+                return;
+            if (pollingRef.current)
+                return;
+            pollingRef.current = true;
+            try {
+                if (!(await client.isRunning())) {
+                    return;
+                }
+                await client.connect();
+                try {
+                    const daemonStatus = await client.status();
+                    if (mounted) {
+                        setStatus(daemonStatus);
+                    }
+                }
+                finally {
+                    await client.disconnect();
+                }
+            }
+            catch (error) {
+                handleCliErrorIfUnexpected('DaemonStatusProvider', error, loggerRef.current);
+            }
+            finally {
+                pollingRef.current = false;
+            }
+        };
+        poll();
+        interval = setInterval(poll, intervalMs);
+        return () => {
+            mounted = false;
+            pollingRef.current = false;
+            if (interval) {
+                clearInterval(interval);
+            }
+            clientRef.current?.disconnect().catch(err => {
+                if (!isExpectedError(err)) {
+                    handleCliErrorIfUnexpected('DaemonStatusProvider.cleanup', err, loggerRef.current);
+                }
+            });
+            clientRef.current = null;
+            loggerRef.current = null;
+        };
+    }, [projectRoot, enabled, intervalMs]);
+    return (React.createElement(DaemonStatusContext.Provider, { value: status }, children));
+}
+// ============================================================================
+// Hook
+// ============================================================================
+/**
+ * Access the current daemon status.
+ *
+ * Returns null if status hasn't been fetched yet or daemon is not running.
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const status = useDaemonStatus();
+ *   if (!status) return <Text>Loading...</Text>;
+ *   return <Text>Indexing: {status.indexing.status}</Text>;
+ * }
+ * ```
+ */
+export function useDaemonStatus() {
+    return useContext(DaemonStatusContext);
+}

package/dist/cli/hooks/useStatusPolling.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Status Polling Hook
+ *
+ * Polls daemon status endpoint and syncs state to Redux.
+ * This is the primary mechanism for state synchronization between
+ * the daemon process and the CLI React application.
+ */
+interface UseStatusPollingOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Enable/disable polling (default: true) */
+    enabled?: boolean;
+    /** Polling interval in ms (default: 500) */
+    intervalMs?: number;
+}
+/**
+ * Polls daemon status and syncs to Redux store.
+ *
+ * Features:
+ * - Deduplicates overlapping polls (skips if previous poll still in-flight)
+ * - Logs unexpected errors (silent on expected "daemon not running")
+ * - Properly cleans up interval and connections on unmount or disable
+ *
+ * Usage:
+ * ```tsx
+ * useStatusPolling({
+ *   projectRoot: '/path/to/project',
+ *   enabled: isInitialized,
+ *   intervalMs: 500,
+ * });
+ * ```
+ */
+export declare function useStatusPolling({ projectRoot, enabled, intervalMs, }: UseStatusPollingOptions): void;
+export {};

package/dist/cli/hooks/useStatusPolling.js

@@ -0,0 +1,121 @@
+/**
+ * Status Polling Hook
+ *
+ * Polls daemon status endpoint and syncs state to Redux.
+ * This is the primary mechanism for state synchronization between
+ * the daemon process and the CLI React application.
+ */
+import { useEffect, useRef } from 'react';
+import { useAppDispatch } from '../../store/hooks.js';
+import { IndexingActions, SlotProgressActions } from '../../store/index.js';
+import { DaemonClient } from '../../client/index.js';
+import { createCliLogger, handleCliErrorIfUnexpected, isExpectedError, } from '../utils/error-handler.js';
+/**
+ * Polls daemon status and syncs to Redux store.
+ *
+ * Features:
+ * - Deduplicates overlapping polls (skips if previous poll still in-flight)
+ * - Logs unexpected errors (silent on expected "daemon not running")
+ * - Properly cleans up interval and connections on unmount or disable
+ *
+ * Usage:
+ * ```tsx
+ * useStatusPolling({
+ *   projectRoot: '/path/to/project',
+ *   enabled: isInitialized,
+ *   intervalMs: 500,
+ * });
+ * ```
+ */
+export function useStatusPolling({ projectRoot, enabled = true, intervalMs = 500, }) {
+    const dispatch = useAppDispatch();
+    const clientRef = useRef(null);
+    const pollingRef = useRef(false);
+    const loggerRef = useRef(null);
+    useEffect(() => {
+        // Always set up cleanup, even when disabled
+        let mounted = true;
+        let interval = null;
+        // Early exit if disabled, but still return cleanup function
+        if (!enabled) {
+            return () => {
+                mounted = false;
+            };
+        }
+        // Create logger for CLI error tracking
+        loggerRef.current = createCliLogger(projectRoot);
+        // Create client for polling (don't auto-start for status checks)
+        const client = new DaemonClient({
+            projectRoot,
+            autoStart: false,
+        });
+        clientRef.current = client;
+        const poll = async () => {
+            // Skip if unmounted
+            if (!mounted)
+                return;
+            // Deduplicate: skip if previous poll still in-flight
+            if (pollingRef.current) {
+                return;
+            }
+            pollingRef.current = true;
+            try {
+                // Check if daemon is running first
+                if (!(await client.isRunning())) {
+                    return; // Daemon not running, skip poll
+                }
+                await client.connect();
+                try {
+                    const status = await client.status();
+                    if (!mounted)
+                        return;
+                    // Sync indexing state to Redux
+                    dispatch(IndexingActions.sync({
+                        status: status.indexing.status,
+                        current: status.indexing.current,
+                        total: status.indexing.total,
+                        stage: status.indexing.stage,
+                        chunksProcessed: status.indexing.chunksProcessed,
+                        throttleMessage: status.indexing.throttleMessage,
+                        error: status.indexing.error,
+                        lastCompleted: status.indexing.lastCompleted,
+                    }));
+                    // Sync slot progress to Redux
+                    dispatch(SlotProgressActions.sync({
+                        slots: status.slots,
+                        failures: status.failures,
+                    }));
+                }
+                finally {
+                    await client.disconnect();
+                }
+            }
+            catch (error) {
+                // Log unexpected errors to console and CLI log file
+                handleCliErrorIfUnexpected('StatusPolling', error, loggerRef.current);
+            }
+            finally {
+                pollingRef.current = false;
+            }
+        };
+        // Initial poll
+        poll();
+        // Set up interval
+        interval = setInterval(poll, intervalMs);
+        return () => {
+            mounted = false;
+            pollingRef.current = false;
+            if (interval) {
+                clearInterval(interval);
+            }
+            clientRef.current?.disconnect().catch(err => {
+                // Log unexpected disconnect errors
+                if (!isExpectedError(err)) {
+                    handleCliErrorIfUnexpected('StatusPolling.cleanup', err, loggerRef.current);
+                }
+            });
+            clientRef.current = null;
+            loggerRef.current = null;
+        };
+    }, [projectRoot, enabled, intervalMs, dispatch]);
+}

package/dist/cli/store/app/selectors.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Memoized selectors for app state.
+ */
+import type { AppState } from './slice.js';
+import type { OutputItem, IndexDisplayStats, AppStatus } from '../../../common/types.js';
+type RootState = {
+    app: AppState;
+};
+export declare const selectAppState: (state: RootState) => AppState;
+export declare const selectIsInitialized: (state: RootState) => boolean | undefined;
+export declare const selectIndexStats: (state: RootState) => IndexDisplayStats | null | undefined;
+export declare const selectAppStatus: (state: RootState) => AppStatus;
+export declare const selectOutputItems: (state: RootState) => OutputItem[];
+/**
+ * Check if app startup is complete (both init status and stats loaded).
+ */
+export declare const selectStartupLoaded: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean | undefined, resultFuncArgs_1: IndexDisplayStats | null | undefined) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean | undefined, resultFuncArgs_1: IndexDisplayStats | null | undefined) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean | undefined, (state: RootState) => IndexDisplayStats | null | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if the app is in a busy state (searching).
+ * Note: For indexing state, use selectIsIndexing from indexing selectors.
+ */
+export declare const selectIsBusy: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AppStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: AppStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => AppStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get output item count.
+ */
+export declare const selectOutputCount: ((state: RootState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: OutputItem[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: OutputItem[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: RootState) => OutputItem[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export {};

package/dist/cli/store/app/selectors.js

@@ -0,0 +1,28 @@
+/**
+ * Memoized selectors for app state.
+ */
+import { createSelector } from '@reduxjs/toolkit';
+// ============================================================================
+// Basic Selectors
+// ============================================================================
+export const selectAppState = (state) => state.app;
+export const selectIsInitialized = (state) => state.app.isInitialized;
+export const selectIndexStats = (state) => state.app.indexStats;
+export const selectAppStatus = (state) => state.app.appStatus;
+export const selectOutputItems = (state) => state.app.outputItems;
+// ============================================================================
+// Memoized Selectors
+// ============================================================================
+/**
+ * Check if app startup is complete (both init status and stats loaded).
+ */
+export const selectStartupLoaded = createSelector([selectIsInitialized, selectIndexStats], (isInitialized, indexStats) => isInitialized !== undefined && indexStats !== undefined);
+/**
+ * Check if the app is in a busy state (searching).
+ * Note: For indexing state, use selectIsIndexing from indexing selectors.
+ */
+export const selectIsBusy = createSelector([selectAppStatus], (status) => status.state === 'searching');
+/**
+ * Get output item count.
+ */
+export const selectOutputCount = createSelector([selectOutputItems], (items) => items.length);