add chunking persistence

Author: iBz-04

src/renderer/stores/ragPipelineStore.ts

@@ -0,0 +1,190 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { ChunkingConfig, ChunkingStrategy } from "../services/chunking";
+
+export interface WebSource {
+  id: string;
+  url: string;
+  enabled: boolean;
+}
+
+export interface KBDocumentSource {
+  id: string;
+  enabled: boolean;
+}
+
+interface RAGPipelineState {
+  // Active section and document selection
+  activeSection: "sources" | "chunking" | "embedding" | "storage";
+  selectedDocumentId: string | undefined;
+  
+  // Knowledge sources
+  webSources: WebSource[];
+  kbDocumentSources: KBDocumentSource[];
+  
+  // Chunking configuration
+  chunkingConfig: ChunkingConfig;
+  
+  // UI feedback state
+  isChunking: boolean;
+  chunkingProgress: number; // 0-100
+  chunkingError: string | null;
+  chunkingCompleted: boolean;
+  
+  // Actions
+  setActiveSection: (section: "sources" | "chunking" | "embedding" | "storage") => void;
+  setSelectedDocumentId: (id: string | undefined) => void;
+  
+  // Web sources actions
+  addWebSource: (url: string) => void;
+  removeWebSource: (id: string) => void;
+  toggleWebSource: (id: string) => void;
+  updateWebSources: (sources: WebSource[]) => void;
+  
+  // KB document sources actions
+  updateKBDocumentSources: (sources: KBDocumentSource[]) => void;
+  toggleKBDocumentSource: (id: string) => void;
+  
+  // Chunking configuration actions
+  updateChunkingConfig: (config: Partial<ChunkingConfig>) => void;
+  setChunkingStrategy: (strategy: ChunkingStrategy) => void;
+  setChunkSize: (size: number) => void;
+  setChunkOverlap: (overlap: number) => void;
+  setSeparators: (separators: string[]) => void;
+  
+  // UI feedback actions
+  setChunkingState: (isChunking: boolean, progress?: number, error?: string | null) => void;
+  setChunkingProgress: (progress: number) => void;
+  setChunkingError: (error: string | null) => void;
+  setChunkingCompleted: (completed: boolean) => void;
+}
+
+export const useRAGPipelineStore = create<RAGPipelineState>()(
+  persist(
+    (set, get) => ({
+      // Initial state
+      activeSection: "sources",
+      selectedDocumentId: undefined,
+      webSources: [],
+      kbDocumentSources: [],
+      chunkingConfig: {
+        strategy: "fixed-size",
+        chunkSize: 1000,
+        overlap: 100,
+        separators: ["\n\n", "\n", ". ", " ", ""],
+      },
+      isChunking: false,
+      chunkingProgress: 0,
+      chunkingError: null,
+      chunkingCompleted: false,
+      
+      // Section and document actions
+      setActiveSection: (section) => set({ activeSection: section }),
+      setSelectedDocumentId: (id) => set({ selectedDocumentId: id }),
+      
+      // Web sources actions
+      addWebSource: (url) => {
+        const source: WebSource = {
+          id: Date.now().toString(),
+          url: url.trim(),
+          enabled: true,
+        };
+        set((state) => ({
+          webSources: [...state.webSources, source],
+        }));
+      },
+      
+      removeWebSource: (id) => {
+        set((state) => ({
+          webSources: state.webSources.filter(s => s.id !== id),
+        }));
+      },
+      
+      toggleWebSource: (id) => {
+        set((state) => ({
+          webSources: state.webSources.map(s => 
+            s.id === id ? { ...s, enabled: !s.enabled } : s
+          ),
+        }));
+      },
+      
+      updateWebSources: (sources) => set({ webSources: sources }),
+      
+      // KB document sources actions  
+      updateKBDocumentSources: (sources) => set({ kbDocumentSources: sources }),
+      
+      toggleKBDocumentSource: (id) => {
+        set((state) => {
+          const currentSource = state.kbDocumentSources.find(s => s.id === id);
+          const willBeEnabled = !currentSource?.enabled;
+          
+          return {
+            kbDocumentSources: state.kbDocumentSources.map(s => 
+              s.id === id ? { ...s, enabled: willBeEnabled } : { ...s, enabled: false }
+            ),
+            selectedDocumentId: willBeEnabled ? id : undefined,
+          };
+        });
+      },
+      
+      // Chunking configuration actions
+      updateChunkingConfig: (config) => {
+        set((state) => ({
+          chunkingConfig: { ...state.chunkingConfig, ...config },
+        }));
+      },
+      
+      setChunkingStrategy: (strategy) => {
+        set((state) => ({
+          chunkingConfig: { ...state.chunkingConfig, strategy },
+        }));
+      },
+      
+      setChunkSize: (chunkSize) => {
+        set((state) => ({
+          chunkingConfig: { ...state.chunkingConfig, chunkSize },
+        }));
+      },
+      
+      setChunkOverlap: (overlap) => {
+        set((state) => ({
+          chunkingConfig: { ...state.chunkingConfig, overlap },
+        }));
+      },
+      
+      setSeparators: (separators) => {
+        set((state) => ({
+          chunkingConfig: { ...state.chunkingConfig, separators },
+        }));
+      },
+      
+      // UI feedback actions
+      setChunkingState: (isChunking, progress = 0, error = null) => {
+        set({ isChunking, chunkingProgress: progress, chunkingError: error, chunkingCompleted: false });
+      },
+      
+      setChunkingProgress: (progress) => {
+        set({ chunkingProgress: Math.min(100, Math.max(0, progress)) });
+      },
+      
+      setChunkingError: (error) => {
+        set({ chunkingError: error, isChunking: false });
+      },
+
+      setChunkingCompleted: (completed) => {
+        set({ chunkingCompleted: completed });
+      },
+    }),
+    {
+      name: "rag-pipeline-storage",
+      partialize: (state) => ({
+        // Persist configuration and sources, but not UI state
+        webSources: state.webSources,
+        kbDocumentSources: state.kbDocumentSources,
+        chunkingConfig: state.chunkingConfig,
+        activeSection: state.activeSection,
+        selectedDocumentId: state.selectedDocumentId,
+      }),
+    }
+  )
+);