viberag 0.3.2 → 0.4.0

package/dist/store/slot-progress/slice.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Redux slice for slot progress during indexing.
+ *
+ * Separates trigger actions (intercepted by listeners) from mutation actions
+ * (called directly by api-utils).
+ */
+import { type PayloadAction } from '@reduxjs/toolkit';
+/**
+ * State of a single embedding slot.
+ * Matches daemon SlotInfo type.
+ */
+export type SlotState = {
+    state: 'idle' | 'processing' | 'rate-limited';
+    batchInfo: string | null;
+    retryInfo: string | null;
+};
+/**
+ * Information about a batch that failed after exhausting all retries.
+ * Matches daemon FailureInfo type.
+ */
+export type FailedChunk = {
+    /** Batch info (e.g., "chunks 15-20") */
+    batchInfo: string;
+    /** Error message */
+    error: string;
+    /** ISO timestamp when failure occurred */
+    timestamp: string;
+};
+export interface SlotProgressState {
+    slots: SlotState[];
+    /** Batches that failed after exhausting all retries */
+    failures: FailedChunk[];
+}
+export declare const slotProgressSlice: import("@reduxjs/toolkit").Slice<SlotProgressState, {
+    setSlotProcessing: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        index: number;
+        batchInfo: string;
+    }>) => void;
+    setSlotRateLimited: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        index: number;
+        batchInfo: string;
+        retryInfo: string;
+    }>) => void;
+    setSlotIdle: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<number>) => void;
+    resetSlots: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }) => void;
+    /**
+     * Record a batch failure after all retries exhausted.
+     */
+    addFailure: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<FailedChunk>) => void;
+    /**
+     * Clear all recorded failures (typically at start of new indexing run).
+     */
+    clearFailures: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }) => void;
+    /**
+     * Sync full state from daemon status (for polling-based updates).
+     * Replaces slots and failures arrays from daemon status response.
+     */
+    sync: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        slots: SlotState[];
+        failures: FailedChunk[];
+    }>) => void;
+}, "slotProgress", "slotProgress", import("@reduxjs/toolkit").SliceSelectors<SlotProgressState>>;
+export declare const SlotProgressActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setSlotProcessing: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        index: number;
+        batchInfo: string;
+    }>) => void;
+    setSlotRateLimited: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        index: number;
+        batchInfo: string;
+        retryInfo: string;
+    }>) => void;
+    setSlotIdle: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<number>) => void;
+    resetSlots: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }) => void;
+    /**
+     * Record a batch failure after all retries exhausted.
+     */
+    addFailure: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<FailedChunk>) => void;
+    /**
+     * Clear all recorded failures (typically at start of new indexing run).
+     */
+    clearFailures: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }) => void;
+    /**
+     * Sync full state from daemon status (for polling-based updates).
+     * Replaces slots and failures arrays from daemon status response.
+     */
+    sync: (state: {
+        slots: {
+            state: "idle" | "processing" | "rate-limited";
+            batchInfo: string | null;
+            retryInfo: string | null;
+        }[];
+        failures: {
+            batchInfo: string;
+            error: string;
+            timestamp: string;
+        }[];
+    }, action: PayloadAction<{
+        slots: SlotState[];
+        failures: FailedChunk[];
+    }>) => void;
+}, "slotProgress">;
+export declare const slotProgressReducer: import("redux").Reducer<SlotProgressState>;

package/dist/store/slot-progress/slice.js

@@ -0,0 +1,70 @@
+/**
+ * Redux slice for slot progress during indexing.
+ *
+ * Separates trigger actions (intercepted by listeners) from mutation actions
+ * (called directly by api-utils).
+ */
+import { createSlice } from '@reduxjs/toolkit';
+import { CONCURRENCY } from '../../daemon/lib/constants.js';
+// ============================================================================
+// Initial State
+// ============================================================================
+const createInitialSlots = () => Array(CONCURRENCY)
+    .fill(null)
+    .map(() => ({ state: 'idle', batchInfo: null, retryInfo: null }));
+const initialState = {
+    slots: createInitialSlots(),
+    failures: [],
+};
+// ============================================================================
+// Slice
+// ============================================================================
+export const slotProgressSlice = createSlice({
+    name: 'slotProgress',
+    initialState,
+    reducers: {
+        setSlotProcessing: (state, action) => {
+            const { index, batchInfo } = action.payload;
+            if (index >= 0 && index < state.slots.length) {
+                state.slots[index] = { state: 'processing', batchInfo, retryInfo: null };
+            }
+        },
+        setSlotRateLimited: (state, action) => {
+            const { index, batchInfo, retryInfo } = action.payload;
+            if (index >= 0 && index < state.slots.length) {
+                state.slots[index] = { state: 'rate-limited', batchInfo, retryInfo };
+            }
+        },
+        setSlotIdle: (state, action) => {
+            const index = action.payload;
+            if (index >= 0 && index < state.slots.length) {
+                state.slots[index] = { state: 'idle', batchInfo: null, retryInfo: null };
+            }
+        },
+        resetSlots: state => {
+            state.slots = createInitialSlots();
+        },
+        /**
+         * Record a batch failure after all retries exhausted.
+         */
+        addFailure: (state, action) => {
+            state.failures.push(action.payload);
+        },
+        /**
+         * Clear all recorded failures (typically at start of new indexing run).
+         */
+        clearFailures: state => {
+            state.failures = [];
+        },
+        /**
+         * Sync full state from daemon status (for polling-based updates).
+         * Replaces slots and failures arrays from daemon status response.
+         */
+        sync: (state, action) => {
+            state.slots = action.payload.slots;
+            state.failures = action.payload.failures;
+        },
+    },
+});
+export const SlotProgressActions = slotProgressSlice.actions;
+export const slotProgressReducer = slotProgressSlice.reducer;

package/dist/store/store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Redux store configuration.
+ *
+ * CLI-only store for wizard and app state.
+ * Daemon state is managed separately via daemon/state.ts.
+ */
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    wizard: import("./wizard/slice.js").WizardState;
+    app: import("./app/slice.js").AppState;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        wizard: import("./wizard/slice.js").WizardState;
+        app: import("./app/slice.js").AppState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/dist/store/store.js

@@ -0,0 +1,18 @@
+/**
+ * Redux store configuration.
+ *
+ * CLI-only store for wizard and app state.
+ * Daemon state is managed separately via daemon/state.ts.
+ */
+import { configureStore } from '@reduxjs/toolkit';
+import { wizardReducer } from './wizard/slice.js';
+import { appReducer } from './app/slice.js';
+// ============================================================================
+// Store Configuration
+// ============================================================================
+export const store = configureStore({
+    reducer: {
+        wizard: wizardReducer,
+        app: appReducer,
+    },
+});

package/dist/store/warmup/selectors.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Memoized selectors for warmup state.
+ */
+import type { WarmupState, WarmupStatus } from './slice.js';
+type RootState = {
+    warmup: WarmupState;
+};
+export declare const selectWarmupState: (state: RootState) => WarmupState;
+export declare const selectWarmupStatus: (state: RootState) => WarmupStatus;
+export declare const selectWarmupProvider: (state: RootState) => string | null;
+export declare const selectWarmupError: (state: RootState) => string | null;
+export declare const selectWarmupElapsedMs: (state: RootState) => number | null;
+/**
+ * Check if warmup is ready (engine available for searches).
+ */
+export declare const selectIsWarmupReady: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarmupStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WarmupStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => WarmupStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if warmup is in progress.
+ */
+export declare const selectIsWarmingUp: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarmupStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WarmupStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => WarmupStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if warmup failed.
+ */
+export declare const selectIsWarmupFailed: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarmupStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WarmupStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => WarmupStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get display-friendly status text.
+ */
+export declare const selectWarmupStatusText: ((state: RootState) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarmupState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: WarmupState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: RootState) => WarmupState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export {};

package/dist/store/warmup/selectors.js

@@ -0,0 +1,44 @@
+/**
+ * Memoized selectors for warmup state.
+ */
+import { createSelector } from '@reduxjs/toolkit';
+// ============================================================================
+// Basic Selectors
+// ============================================================================
+export const selectWarmupState = (state) => state.warmup;
+export const selectWarmupStatus = (state) => state.warmup.status;
+export const selectWarmupProvider = (state) => state.warmup.provider;
+export const selectWarmupError = (state) => state.warmup.error;
+export const selectWarmupElapsedMs = (state) => state.warmup.elapsedMs;
+// ============================================================================
+// Memoized Selectors
+// ============================================================================
+/**
+ * Check if warmup is ready (engine available for searches).
+ */
+export const selectIsWarmupReady = createSelector([selectWarmupStatus], (status) => status === 'ready');
+/**
+ * Check if warmup is in progress.
+ */
+export const selectIsWarmingUp = createSelector([selectWarmupStatus], (status) => status === 'initializing');
+/**
+ * Check if warmup failed.
+ */
+export const selectIsWarmupFailed = createSelector([selectWarmupStatus], (status) => status === 'failed');
+/**
+ * Get display-friendly status text.
+ */
+export const selectWarmupStatusText = createSelector([selectWarmupState], (state) => {
+    switch (state.status) {
+        case 'not_started':
+            return 'Not started';
+        case 'not_initialized':
+            return 'Project not initialized';
+        case 'initializing':
+            return `Warming up ${state.provider ?? 'provider'}...`;
+        case 'ready':
+            return `Ready (${state.provider}, ${state.elapsedMs}ms)`;
+        case 'failed':
+            return `Failed: ${state.error ?? 'Unknown error'}`;
+    }
+});

package/dist/store/warmup/slice.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Redux slice for warmup state.
+ *
+ * Manages the state of the embedding provider warmup process.
+ * The WarmupManager dispatches actions to this slice to track status.
+ */
+import { type PayloadAction } from '@reduxjs/toolkit';
+export type WarmupStatus = 'not_started' | 'not_initialized' | 'initializing' | 'ready' | 'failed';
+export interface WarmupState {
+    /** Current warmup status */
+    status: WarmupStatus;
+    /** Embedding provider name (e.g., 'gemini', 'openai', 'local') */
+    provider: string | null;
+    /** ISO timestamp when warmup started */
+    startedAt: string | null;
+    /** ISO timestamp when warmup completed */
+    readyAt: string | null;
+    /** Time taken to warm up in milliseconds */
+    elapsedMs: number | null;
+    /** Error message if warmup failed */
+    error: string | null;
+}
+export declare const warmupSlice: import("@reduxjs/toolkit").Slice<WarmupState, {
+    /**
+     * Project is not initialized.
+     */
+    setNotInitialized: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }) => void;
+    /**
+     * Start warmup process.
+     */
+    start: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        provider: string;
+    }>) => void;
+    /**
+     * Warmup completed successfully.
+     */
+    ready: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        elapsedMs: number;
+    }>) => void;
+    /**
+     * Warmup failed with error.
+     */
+    failed: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        error: string;
+        elapsedMs: number;
+    }>) => void;
+    /**
+     * Reset state for retry.
+     */
+    reset: () => WarmupState;
+}, "warmup", "warmup", import("@reduxjs/toolkit").SliceSelectors<WarmupState>>;
+export declare const WarmupActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    /**
+     * Project is not initialized.
+     */
+    setNotInitialized: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }) => void;
+    /**
+     * Start warmup process.
+     */
+    start: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        provider: string;
+    }>) => void;
+    /**
+     * Warmup completed successfully.
+     */
+    ready: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        elapsedMs: number;
+    }>) => void;
+    /**
+     * Warmup failed with error.
+     */
+    failed: (state: {
+        status: WarmupStatus;
+        provider: string | null;
+        startedAt: string | null;
+        readyAt: string | null;
+        elapsedMs: number | null;
+        error: string | null;
+    }, action: PayloadAction<{
+        error: string;
+        elapsedMs: number;
+    }>) => void;
+    /**
+     * Reset state for retry.
+     */
+    reset: () => WarmupState;
+}, "warmup">;
+export declare const warmupReducer: import("redux").Reducer<WarmupState>;