@digilogiclabs/create-saas-app 2.10.0 → 2.12.0

package/src/templates/web/ui-auth-payments-ai-rag/template/hooks/useRAGSystem.ts

@@ -1,478 +0,0 @@
-'use client'
-
-import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
-import { RAGSystem } from '@digilogiclabs/saas-factory-ai';
-import type { 
-  RAGQuery, 
-  RAGResponse, 
-  RAGDocument, 
-  RAGSearchResult,
-  RAGDocumentSchema 
-} from '@digilogiclabs/saas-factory-ai-types';
-import { getRAGConfigForDomain, webRAGOptions } from '../lib/rag/config';
-import { toast } from 'sonner';
-
-interface UseRAGSystemOptions {
-  domain?: string;
-  enableStreaming?: boolean;
-  enableCache?: boolean;
-  autoInitialize?: boolean;
-}
-
-interface RAGState {
-  isInitialized: boolean;
-  isLoading: boolean;
-  isStreaming: boolean;
-  lastSyncAt: Date | null;
-  totalQueries: number;
-  totalDocuments: number;
-  error: string | null;
-  health: 'healthy' | 'degraded' | 'down';
-}
-
-interface StreamingState {
-  isStreaming: boolean;
-  currentResponse: string;
-  sources: RAGSearchResult[];
-  confidence: number;
-}
-
-export function useRAGSystem<TSchema extends RAGDocumentSchema>(
-  options: UseRAGSystemOptions = {}
-) {
-  const {
-    domain = 'generic',
-    enableStreaming = true,
-    enableCache = true,
-    autoInitialize = true
-  } = options;
-
-  const [ragSystem, setRAGSystem] = useState<RAGSystem<TSchema> | null>(null);
-  const [state, setState] = useState<RAGState>({
-    isInitialized: false,
-    isLoading: false,
-    isStreaming: false,
-    lastSyncAt: null,
-    totalQueries: 0,
-    totalDocuments: 0,
-    error: null,
-    health: 'down'
-  });
-
-  const [streamingState, setStreamingState] = useState<StreamingState>({
-    isStreaming: false,
-    currentResponse: '',
-    sources: [],
-    confidence: 0
-  });
-
-  const [queryHistory, setQueryHistory] = useState<RAGQuery[]>([]);
-  const [responseCache, setResponseCache] = useState<Map<string, RAGResponse>>(new Map());
-  
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const statsRef = useRef({ queries: 0, documents: 0, lastSync: null as Date | null });
-
-  // Memoized configuration
-  const ragConfig = useMemo(() => getRAGConfigForDomain(domain), [domain]);
-
-  // Initialize RAG system
-  useEffect(() => {
-    if (!autoInitialize) return;
-
-    const initRAG = async () => {
-      try {
-        setState(prev => ({ ...prev, isLoading: true, error: null }));
-
-        const system = new RAGSystem<TSchema>(ragConfig);
-        await system.initialize();
-        
-        setRAGSystem(system);
-
-        // Load initial stats
-        const stats = await system.getStats();
-        statsRef.current = {
-          queries: stats.totalQueries || 0,
-          documents: stats.totalDocuments || 0,
-          lastSync: stats.lastSync ? new Date(stats.lastSync) : null
-        };
-
-        setState(prev => ({ 
-          ...prev, 
-          isInitialized: true, 
-          isLoading: false,
-          totalQueries: statsRef.current.queries,
-          totalDocuments: statsRef.current.documents,
-          lastSyncAt: statsRef.current.lastSync,
-          health: 'healthy'
-        }));
-
-        toast.success('AI Knowledge System initialized');
-
-      } catch (error) {
-        console.error('RAG initialization error:', error);
-        const errorMessage = error instanceof Error ? error.message : 'Initialization failed';
-        
-        setState(prev => ({ 
-          ...prev, 
-          error: errorMessage,
-          isLoading: false,
-          health: 'down'
-        }));
-
-        toast.error(`Failed to initialize AI system: ${errorMessage}`);
-      }
-    };
-
-    initRAG();
-  }, [ragConfig, autoInitialize]);
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-    };
-  }, []);
-
-  // Query function with streaming support
-  const query = useCallback(async (
-    queryText: string, 
-    options?: {
-      category?: string;
-      maxResults?: number;
-      includeMetadata?: boolean;
-      stream?: boolean;
-    }
-  ): Promise<RAGResponse> => {
-    if (!ragSystem) {
-      throw new Error('RAG system not initialized');
-    }
-
-    // Cancel any ongoing request
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-    
-    abortControllerRef.current = new AbortController();
-
-    const ragQuery: RAGQuery = {
-      query: queryText,
-      category: options?.category,
-      maxResults: options?.maxResults || 6,
-      includeMetadata: options?.includeMetadata ?? true,
-      timestamp: new Date()
-    };
-
-    const cacheKey = getCacheKey(ragQuery);
-    const shouldStream = enableStreaming && (options?.stream !== false);
-
-    // Check cache first
-    if (enableCache && responseCache.has(cacheKey)) {
-      const cached = responseCache.get(cacheKey)!;
-      toast.success('Retrieved from cache');
-      return { ...cached, fromCache: true };
-    }
-
-    try {
-      setState(prev => ({ ...prev, isLoading: true, error: null }));
-
-      if (shouldStream) {
-        // Initialize streaming state
-        setStreamingState({
-          isStreaming: true,
-          currentResponse: '',
-          sources: [],
-          confidence: 0
-        });
-
-        // Handle streaming response
-        const response = await ragSystem.queryStream(
-          ragQuery,
-          {
-            onChunk: (chunk) => {
-              setStreamingState(prev => ({
-                ...prev,
-                currentResponse: prev.currentResponse + chunk.text,
-                confidence: chunk.confidence || prev.confidence
-              }));
-            },
-            onSources: (sources) => {
-              setStreamingState(prev => ({
-                ...prev,
-                sources
-              }));
-            },
-            signal: abortControllerRef.current?.signal
-          }
-        );
-
-        // Finalize streaming
-        setStreamingState(prev => ({ ...prev, isStreaming: false }));
-
-        return response;
-
-      } else {
-        // Regular non-streaming query
-        const response = await ragSystem.query(ragQuery, {
-          signal: abortControllerRef.current?.signal
-        });
-
-        // Cache successful responses
-        if (enableCache && response.confidence > 0.6) {
-          const newCache = new Map(responseCache);
-          newCache.set(cacheKey, response);
-          
-          // Limit cache size
-          if (newCache.size > 100) {
-            const firstKey = newCache.keys().next().value;
-            newCache.delete(firstKey);
-          }
-          
-          setResponseCache(newCache);
-        }
-
-        return response;
-      }
-
-    } catch (error: any) {
-      if (error.name === 'AbortError') {
-        throw new Error('Query cancelled');
-      }
-      
-      setState(prev => ({ ...prev, error: error.message, health: 'degraded' }));
-      toast.error(`Query failed: ${error.message}`);
-      throw error;
-
-    } finally {
-      setState(prev => ({ 
-        ...prev, 
-        isLoading: false,
-        totalQueries: prev.totalQueries + 1
-      }));
-
-      // Update query history
-      setQueryHistory(prev => [ragQuery, ...prev.slice(0, 19)]);
-      
-      // Reset streaming state if not streaming
-      if (!shouldStream) {
-        setStreamingState({
-          isStreaming: false,
-          currentResponse: '',
-          sources: [],
-          confidence: 0
-        });
-      }
-    }
-  }, [ragSystem, enableStreaming, enableCache, responseCache]);
-
-  // Search knowledge base
-  const searchKnowledge = useCallback(async (
-    searchText: string,
-    filters?: { 
-      category?: string; 
-      limit?: number; 
-      sort?: 'relevance' | 'date' | 'popularity';
-      includeMetadata?: boolean;
-    }
-  ): Promise<RAGSearchResult[]> => {
-    if (!ragSystem) return [];
-
-    try {
-      return await ragSystem.searchDocuments(searchText, {
-        ...filters,
-        limit: filters?.limit || 20
-      });
-    } catch (error) {
-      console.error('Knowledge search error:', error);
-      toast.error('Search failed');
-      return [];
-    }
-  }, [ragSystem]);
-
-  // Add document to knowledge base
-  const addKnowledge = useCallback(async (
-    document: Omit<RAGDocument<TSchema>, 'id' | 'createdAt' | 'updatedAt'>
-  ): Promise<string | null> => {
-    if (!ragSystem) return null;
-
-    try {
-      const id = await ragSystem.addDocument(document as RAGDocument<TSchema>);
-      
-      setState(prev => ({ 
-        ...prev, 
-        totalDocuments: prev.totalDocuments + 1 
-      }));
-      
-      toast.success('Knowledge added successfully');
-      return id;
-
-    } catch (error) {
-      console.error('Add knowledge error:', error);
-      toast.error('Failed to add knowledge');
-      return null;
-    }
-  }, [ragSystem]);
-
-  // Update document
-  const updateKnowledge = useCallback(async (
-    id: string,
-    updates: Partial<RAGDocument<TSchema>>
-  ): Promise<boolean> => {
-    if (!ragSystem) return false;
-
-    try {
-      await ragSystem.updateDocument(id, updates);
-      toast.success('Knowledge updated successfully');
-      return true;
-
-    } catch (error) {
-      console.error('Update knowledge error:', error);
-      toast.error('Failed to update knowledge');
-      return false;
-    }
-  }, [ragSystem]);
-
-  // Delete document
-  const deleteKnowledge = useCallback(async (id: string): Promise<boolean> => {
-    if (!ragSystem) return false;
-
-    try {
-      await ragSystem.deleteDocument(id);
-      
-      setState(prev => ({ 
-        ...prev, 
-        totalDocuments: Math.max(0, prev.totalDocuments - 1) 
-      }));
-      
-      toast.success('Knowledge deleted successfully');
-      return true;
-
-    } catch (error) {
-      console.error('Delete knowledge error:', error);
-      toast.error('Failed to delete knowledge');
-      return false;
-    }
-  }, [ragSystem]);
-
-  // Bulk operations
-  const bulkAddKnowledge = useCallback(async (
-    documents: Omit<RAGDocument<TSchema>, 'id' | 'createdAt' | 'updatedAt'>[]
-  ): Promise<string[]> => {
-    if (!ragSystem) return [];
-
-    try {
-      setState(prev => ({ ...prev, isLoading: true }));
-      
-      const ids = await ragSystem.bulkAddDocuments(documents as RAGDocument<TSchema>[]);
-      
-      setState(prev => ({ 
-        ...prev, 
-        totalDocuments: prev.totalDocuments + ids.length,
-        isLoading: false
-      }));
-      
-      toast.success(`Added ${ids.length} knowledge documents`);
-      return ids;
-
-    } catch (error) {
-      setState(prev => ({ ...prev, isLoading: false }));
-      console.error('Bulk add error:', error);
-      toast.error('Bulk add operation failed');
-      return [];
-    }
-  }, [ragSystem]);
-
-  // Sync knowledge base
-  const syncKnowledgeBase = useCallback(async (): Promise<void> => {
-    if (!ragSystem) return;
-
-    try {
-      setState(prev => ({ ...prev, isLoading: true }));
-      
-      await ragSystem.sync(state.lastSyncAt);
-      
-      const stats = await ragSystem.getStats();
-      
-      setState(prev => ({ 
-        ...prev, 
-        lastSyncAt: new Date(),
-        totalDocuments: stats.totalDocuments || prev.totalDocuments,
-        isLoading: false,
-        health: 'healthy'
-      }));
-
-      toast.success('Knowledge base synchronized');
-
-    } catch (error) {
-      setState(prev => ({ ...prev, isLoading: false, health: 'degraded' }));
-      console.error('Sync error:', error);
-      toast.error('Synchronization failed');
-    }
-  }, [ragSystem, state.lastSyncAt]);
-
-  // Cancel current operation
-  const cancelOperation = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      setStreamingState({
-        isStreaming: false,
-        currentResponse: '',
-        sources: [],
-        confidence: 0
-      });
-      setState(prev => ({ ...prev, isLoading: false }));
-      toast.info('Operation cancelled');
-    }
-  }, []);
-
-  // Clear cache
-  const clearCache = useCallback(() => {
-    setResponseCache(new Map());
-    setQueryHistory([]);
-    toast.success('Cache cleared');
-  }, []);
-
-  // Get analytics data
-  const getAnalytics = useCallback(async (timeRange: string = '7d') => {
-    if (!ragSystem) return null;
-
-    try {
-      return await ragSystem.getAnalytics(timeRange);
-    } catch (error) {
-      console.error('Analytics error:', error);
-      return null;
-    }
-  }, [ragSystem]);
-
-  // Helper functions
-  const getCacheKey = (query: RAGQuery): string => {
-    return `${query.query}:${query.category || 'all'}:${query.maxResults}`;
-  };
-
-  return {
-    // State
-    ...state,
-    ragSystem,
-    queryHistory,
-    streamingState,
-    cacheSize: responseCache.size,
-
-    // Actions
-    query,
-    searchKnowledge,
-    addKnowledge,
-    updateKnowledge,
-    deleteKnowledge,
-    bulkAddKnowledge,
-    syncKnowledgeBase,
-    cancelOperation,
-    clearCache,
-    getAnalytics,
-
-    // Utilities
-    isReady: state.isInitialized && !state.isLoading && state.health !== 'down',
-    canQuery: state.isInitialized && state.health !== 'down',
-    hasError: !!state.error,
-  };
-}