viberag 0.3.2 → 0.4.0

package/dist/store/warmup/slice.js

@@ -0,0 +1,72 @@
+/**
+ * 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 { createSlice } from '@reduxjs/toolkit';
+// ============================================================================
+// Initial State
+// ============================================================================
+const initialState = {
+    status: 'not_started',
+    provider: null,
+    startedAt: null,
+    readyAt: null,
+    elapsedMs: null,
+    error: null,
+};
+// ============================================================================
+// Slice
+// ============================================================================
+export const warmupSlice = createSlice({
+    name: 'warmup',
+    initialState,
+    reducers: {
+        /**
+         * Project is not initialized.
+         */
+        setNotInitialized: state => {
+            state.status = 'not_initialized';
+            state.provider = null;
+            state.startedAt = null;
+            state.readyAt = null;
+            state.elapsedMs = null;
+            state.error = null;
+        },
+        /**
+         * Start warmup process.
+         */
+        start: (state, action) => {
+            state.status = 'initializing';
+            state.provider = action.payload.provider;
+            state.startedAt = new Date().toISOString();
+            state.readyAt = null;
+            state.elapsedMs = null;
+            state.error = null;
+        },
+        /**
+         * Warmup completed successfully.
+         */
+        ready: (state, action) => {
+            state.status = 'ready';
+            state.readyAt = new Date().toISOString();
+            state.elapsedMs = action.payload.elapsedMs;
+            state.error = null;
+        },
+        /**
+         * Warmup failed with error.
+         */
+        failed: (state, action) => {
+            state.status = 'failed';
+            state.elapsedMs = action.payload.elapsedMs;
+            state.error = action.payload.error;
+        },
+        /**
+         * Reset state for retry.
+         */
+        reset: () => initialState,
+    },
+});
+export const WarmupActions = warmupSlice.actions;
+export const warmupReducer = warmupSlice.reducer;

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

@@ -0,0 +1,115 @@
+/**
+ * Memoized selectors for watcher state.
+ */
+import type { WatcherState, WatcherStatus } from './slice.js';
+type RootState = {
+    watcher: WatcherState;
+};
+export declare const selectWatcherState: (state: RootState) => WatcherState;
+export declare const selectWatcherStatus: (state: RootState) => WatcherStatus;
+export declare const selectFilesWatched: (state: RootState) => number;
+export declare const selectPendingPaths: (state: RootState) => string[];
+export declare const selectLastIndexUpdate: (state: RootState) => string | null;
+export declare const selectIsIndexUpToDate: (state: RootState) => boolean;
+export declare const selectWatcherError: (state: RootState) => string | null;
+/**
+ * Check if watcher is active (any status except stopped).
+ */
+export declare const selectIsWatching: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WatcherStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WatcherStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => WatcherStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if watcher is busy (debouncing or batching).
+ * Note: Indexing status is tracked by the indexing slice, not here.
+ * Use selectIsIndexing() from indexing/selectors.ts to check if indexing is in progress.
+ */
+export declare const selectIsWatcherBusy: ((state: RootState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WatcherStatus) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WatcherStatus) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => WatcherStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get pending change count.
+ */
+export declare const selectPendingChangeCount: ((state: RootState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: RootState) => string[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get display-friendly status text.
+ * Note: Indexing status text should come from the indexing slice,
+ * not from here. Use selectIndexingDisplay() from indexing/selectors.ts.
+ */
+export declare const selectWatcherStatusText: ((state: RootState) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WatcherState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: WatcherState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: RootState) => WatcherState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export {};

package/dist/store/watcher/selectors.js

@@ -0,0 +1,52 @@
+/**
+ * Memoized selectors for watcher state.
+ */
+import { createSelector } from '@reduxjs/toolkit';
+// ============================================================================
+// Basic Selectors
+// ============================================================================
+export const selectWatcherState = (state) => state.watcher;
+export const selectWatcherStatus = (state) => state.watcher.status;
+export const selectFilesWatched = (state) => state.watcher.filesWatched;
+export const selectPendingPaths = (state) => state.watcher.pendingPaths;
+export const selectLastIndexUpdate = (state) => state.watcher.lastIndexUpdate;
+export const selectIsIndexUpToDate = (state) => state.watcher.indexUpToDate;
+export const selectWatcherError = (state) => state.watcher.lastError;
+// ============================================================================
+// Memoized Selectors
+// ============================================================================
+/**
+ * Check if watcher is active (any status except stopped).
+ */
+export const selectIsWatching = createSelector([selectWatcherStatus], (status) => status !== 'stopped');
+/**
+ * Check if watcher is busy (debouncing or batching).
+ * Note: Indexing status is tracked by the indexing slice, not here.
+ * Use selectIsIndexing() from indexing/selectors.ts to check if indexing is in progress.
+ */
+export const selectIsWatcherBusy = createSelector([selectWatcherStatus], (status) => status === 'debouncing' || status === 'batching');
+/**
+ * Get pending change count.
+ */
+export const selectPendingChangeCount = createSelector([selectPendingPaths], (paths) => paths.length);
+/**
+ * Get display-friendly status text.
+ * Note: Indexing status text should come from the indexing slice,
+ * not from here. Use selectIndexingDisplay() from indexing/selectors.ts.
+ */
+export const selectWatcherStatusText = createSelector([selectWatcherState], (state) => {
+    switch (state.status) {
+        case 'stopped':
+            return 'Stopped';
+        case 'starting':
+            return 'Starting...';
+        case 'watching':
+            return state.indexUpToDate
+                ? `Watching ${state.filesWatched} files`
+                : `Watching ${state.filesWatched} files (pending changes)`;
+        case 'debouncing':
+            return `Debouncing (${state.pendingPaths.length} changes)`;
+        case 'batching':
+            return `Batching (${state.pendingPaths.length} changes)`;
+    }
+});

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

@@ -0,0 +1,269 @@
+/**
+ * Redux slice for file watcher state.
+ *
+ * Tracks the observable state of the file watcher for auto-indexing.
+ * The FileWatcher class dispatches actions to this slice to report status.
+ */
+import { type PayloadAction } from '@reduxjs/toolkit';
+/**
+ * WatcherStatus tracks ONLY watcher-specific concerns:
+ * - stopped: Watcher not running
+ * - starting: Watcher initializing
+ * - watching: Actively watching, ready to detect changes
+ * - debouncing: Change detected, waiting for more changes
+ * - batching: Debounce done, collecting final batch before triggering index
+ *
+ * Note: 'indexing' is NOT included here. Whether indexing is in progress
+ * is tracked by the `indexing` slice (single source of truth).
+ * Use selectIsIndexing() from indexing/selectors.ts to check indexing status.
+ */
+export type WatcherStatus = 'stopped' | 'starting' | 'watching' | 'debouncing' | 'batching';
+export interface WatcherState {
+    /** Current watcher status */
+    status: WatcherStatus;
+    /** Number of files being watched */
+    filesWatched: number;
+    /** Paths of pending changes (limited to first 10) */
+    pendingPaths: string[];
+    /** ISO timestamp of last index update */
+    lastIndexUpdate: string | null;
+    /** Whether the index is up to date */
+    indexUpToDate: boolean;
+    /** Last error message if any */
+    lastError: string | null;
+}
+export declare const watcherSlice: import("@reduxjs/toolkit").Slice<WatcherState, {
+    /**
+     * Watcher is starting up.
+     */
+    starting: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Watcher is ready and watching.
+     */
+    ready: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        filesWatched: number;
+    }>) => void;
+    /**
+     * File change detected, entering debounce period.
+     */
+    debouncing: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        pendingPaths: string[];
+    }>) => void;
+    /**
+     * Debounce complete, entering batch window.
+     */
+    batching: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Index update completed successfully.
+     * Transitions from batching back to watching.
+     */
+    indexed: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        chunksAdded: number;
+        chunksDeleted: number;
+    }>) => void;
+    /**
+     * Index update failed.
+     */
+    indexFailed: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        error: string;
+    }>) => void;
+    /**
+     * File was added (increment count).
+     */
+    fileAdded: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * File was deleted (decrement count).
+     */
+    fileDeleted: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Error occurred in watcher.
+     */
+    error: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        error: string;
+    }>) => void;
+    /**
+     * Watcher stopped.
+     */
+    stopped: () => WatcherState;
+}, "watcher", "watcher", import("@reduxjs/toolkit").SliceSelectors<WatcherState>>;
+export declare const WatcherActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    /**
+     * Watcher is starting up.
+     */
+    starting: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Watcher is ready and watching.
+     */
+    ready: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        filesWatched: number;
+    }>) => void;
+    /**
+     * File change detected, entering debounce period.
+     */
+    debouncing: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        pendingPaths: string[];
+    }>) => void;
+    /**
+     * Debounce complete, entering batch window.
+     */
+    batching: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Index update completed successfully.
+     * Transitions from batching back to watching.
+     */
+    indexed: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        chunksAdded: number;
+        chunksDeleted: number;
+    }>) => void;
+    /**
+     * Index update failed.
+     */
+    indexFailed: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        error: string;
+    }>) => void;
+    /**
+     * File was added (increment count).
+     */
+    fileAdded: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * File was deleted (decrement count).
+     */
+    fileDeleted: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }) => void;
+    /**
+     * Error occurred in watcher.
+     */
+    error: (state: {
+        status: WatcherStatus;
+        filesWatched: number;
+        pendingPaths: string[];
+        lastIndexUpdate: string | null;
+        indexUpToDate: boolean;
+        lastError: string | null;
+    }, action: PayloadAction<{
+        error: string;
+    }>) => void;
+    /**
+     * Watcher stopped.
+     */
+    stopped: () => WatcherState;
+}, "watcher">;
+export declare const watcherReducer: import("redux").Reducer<WatcherState>;

package/dist/store/watcher/slice.js

@@ -0,0 +1,100 @@
+/**
+ * Redux slice for file watcher state.
+ *
+ * Tracks the observable state of the file watcher for auto-indexing.
+ * The FileWatcher class dispatches actions to this slice to report status.
+ */
+import { createSlice } from '@reduxjs/toolkit';
+// ============================================================================
+// Initial State
+// ============================================================================
+const initialState = {
+    status: 'stopped',
+    filesWatched: 0,
+    pendingPaths: [],
+    lastIndexUpdate: null,
+    indexUpToDate: true,
+    lastError: null,
+};
+// ============================================================================
+// Slice
+// ============================================================================
+export const watcherSlice = createSlice({
+    name: 'watcher',
+    initialState,
+    reducers: {
+        /**
+         * Watcher is starting up.
+         */
+        starting: state => {
+            state.status = 'starting';
+            state.lastError = null;
+        },
+        /**
+         * Watcher is ready and watching.
+         */
+        ready: (state, action) => {
+            state.status = 'watching';
+            state.filesWatched = action.payload.filesWatched;
+            state.lastError = null;
+        },
+        /**
+         * File change detected, entering debounce period.
+         */
+        debouncing: (state, action) => {
+            state.status = 'debouncing';
+            state.pendingPaths = action.payload.pendingPaths.slice(0, 10);
+            state.indexUpToDate = false;
+        },
+        /**
+         * Debounce complete, entering batch window.
+         */
+        batching: state => {
+            state.status = 'batching';
+        },
+        /**
+         * Index update completed successfully.
+         * Transitions from batching back to watching.
+         */
+        indexed: (state, action) => {
+            state.status = 'watching';
+            state.lastIndexUpdate = new Date().toISOString();
+            state.indexUpToDate = true;
+            state.pendingPaths = [];
+            state.lastError = null;
+            // Log to action payload for debugging, not stored in state
+            void action.payload;
+        },
+        /**
+         * Index update failed.
+         */
+        indexFailed: (state, action) => {
+            state.status = 'watching';
+            state.lastError = action.payload.error;
+        },
+        /**
+         * File was added (increment count).
+         */
+        fileAdded: state => {
+            state.filesWatched++;
+        },
+        /**
+         * File was deleted (decrement count).
+         */
+        fileDeleted: state => {
+            state.filesWatched = Math.max(0, state.filesWatched - 1);
+        },
+        /**
+         * Error occurred in watcher.
+         */
+        error: (state, action) => {
+            state.lastError = action.payload.error;
+        },
+        /**
+         * Watcher stopped.
+         */
+        stopped: () => initialState,
+    },
+});
+export const WatcherActions = watcherSlice.actions;
+export const watcherReducer = watcherSlice.reducer;