@digilogiclabs/create-saas-app 1.17.1 → 1.18.0

package/dist/templates/mobile/ui-auth-payments-ai-rag/template/hooks/useRAGSystem.ts

@@ -0,0 +1,346 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { AppState } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import NetInfo from '@react-native-community/netinfo';
+import { RAGSystem } from '@digilogiclabs/saas-factory-ai';
+import type { 
+  RAGQuery, 
+  RAGResponse, 
+  RAGDocument, 
+  RAGSearchResult,
+  RAGDocumentSchema 
+} from '@digilogiclabs/saas-factory-ai-types';
+import { getRAGConfigForDomain, mobileRAGOptions } from '../lib/rag/config';
+
+interface UseRAGSystemOptions {
+  domain?: string;
+  enableOffline?: boolean;
+  autoSync?: boolean;
+  cacheResults?: boolean;
+}
+
+interface RAGState {
+  isInitialized: boolean;
+  isOnline: boolean;
+  isLoading: boolean;
+  lastSyncAt: Date | null;
+  cachedQueries: number;
+  error: string | null;
+}
+
+export function useRAGSystem<TSchema extends RAGDocumentSchema>(
+  options: UseRAGSystemOptions = {}
+) {
+  const {
+    domain = 'generic',
+    enableOffline = true,
+    autoSync = true,
+    cacheResults = true
+  } = options;
+
+  const [ragSystem, setRAGSystem] = useState<RAGSystem<TSchema> | null>(null);
+  const [state, setState] = useState<RAGState>({
+    isInitialized: false,
+    isOnline: true,
+    isLoading: false,
+    lastSyncAt: null,
+    cachedQueries: 0,
+    error: null
+  });
+
+  const [recentQueries, setRecentQueries] = useState<RAGQuery[]>([]);
+  const [cachedResponses, setCachedResponses] = useState<Map<string, RAGResponse>>(new Map());
+  const offlineQueueRef = useRef<RAGQuery[]>([]);
+
+  // Initialize RAG system
+  useEffect(() => {
+    const initRAG = async () => {
+      try {
+        setState(prev => ({ ...prev, isLoading: true, error: null }));
+
+        const config = getRAGConfigForDomain(domain);
+        const system = new RAGSystem<TSchema>(config);
+        
+        await system.initialize();
+        setRAGSystem(system);
+
+        // Load cached data
+        if (enableOffline) {
+          await loadCachedData();
+        }
+
+        setState(prev => ({ 
+          ...prev, 
+          isInitialized: true, 
+          isLoading: false,
+          lastSyncAt: new Date()
+        }));
+
+      } catch (error) {
+        console.error('RAG initialization error:', error);
+        setState(prev => ({ 
+          ...prev, 
+          error: error instanceof Error ? error.message : 'Initialization failed',
+          isLoading: false
+        }));
+      }
+    };
+
+    initRAG();
+  }, [domain, enableOffline]);
+
+  // Network state monitoring
+  useEffect(() => {
+    const unsubscribe = NetInfo.addEventListener(state => {
+      setState(prev => ({ ...prev, isOnline: state.isConnected ?? false }));
+      
+      // Process offline queue when back online
+      if (state.isConnected && offlineQueueRef.current.length > 0) {
+        processOfflineQueue();
+      }
+    });
+
+    return unsubscribe;
+  }, []);
+
+  // App state handling for sync
+  useEffect(() => {
+    if (!autoSync) return;
+
+    const handleAppStateChange = (nextAppState: string) => {
+      if (nextAppState === 'active' && ragSystem && state.isOnline) {
+        syncKnowledgeBase();
+      }
+    };
+
+    const subscription = AppState.addEventListener('change', handleAppStateChange);
+    return () => subscription?.remove();
+  }, [ragSystem, state.isOnline, autoSync]);
+
+  // Query function with caching and offline support
+  const query = useCallback(async (queryText: string, options?: {
+    category?: string;
+    maxResults?: number;
+    includeMetadata?: boolean;
+  }): Promise<RAGResponse> => {
+    if (!ragSystem) {
+      throw new Error('RAG system not initialized');
+    }
+
+    const ragQuery: RAGQuery = {
+      query: queryText,
+      category: options?.category,
+      maxResults: options?.maxResults || 5,
+      includeMetadata: options?.includeMetadata ?? true,
+      timestamp: new Date()
+    };
+
+    // Check cache first
+    const cacheKey = getCacheKey(ragQuery);
+    if (cacheResults && cachedResponses.has(cacheKey)) {
+      const cached = cachedResponses.get(cacheKey)!;
+      return { ...cached, fromCache: true };
+    }
+
+    // Handle offline mode
+    if (!state.isOnline && enableOffline) {
+      return handleOfflineQuery(ragQuery);
+    }
+
+    try {
+      setState(prev => ({ ...prev, isLoading: true }));
+      
+      const response = await ragSystem.query(ragQuery);
+      
+      // Cache successful responses
+      if (cacheResults && response.confidence > 0.5) {
+        const newCache = new Map(cachedResponses);
+        newCache.set(cacheKey, response);
+        setCachedResponses(newCache);
+        
+        // Persist to local storage
+        await cacheResponseLocally(cacheKey, response);
+      }
+
+      // Update recent queries
+      setRecentQueries(prev => [ragQuery, ...prev.slice(0, 9)]);
+      
+      setState(prev => ({ ...prev, isLoading: false }));
+      return response;
+
+    } catch (error) {
+      setState(prev => ({ ...prev, isLoading: false }));
+      
+      if (enableOffline) {
+        return handleOfflineQuery(ragQuery);
+      }
+      
+      throw error;
+    }
+  }, [ragSystem, state.isOnline, cacheResults, enableOffline, cachedResponses]);
+
+  // Search knowledge base
+  const searchKnowledge = useCallback(async (
+    searchText: string,
+    filters?: { category?: string; limit?: number }
+  ): Promise<RAGSearchResult[]> => {
+    if (!ragSystem) return [];
+
+    try {
+      return await ragSystem.searchDocuments(searchText, filters);
+    } catch (error) {
+      console.error('Knowledge search error:', error);
+      return [];
+    }
+  }, [ragSystem]);
+
+  // Add document to knowledge base
+  const addKnowledge = useCallback(async (
+    document: Omit<RAGDocument<TSchema>, 'id' | 'createdAt' | 'updatedAt'>
+  ): Promise<string | null> => {
+    if (!ragSystem || !state.isOnline) return null;
+
+    try {
+      return await ragSystem.addDocument(document as RAGDocument<TSchema>);
+    } catch (error) {
+      console.error('Add knowledge error:', error);
+      return null;
+    }
+  }, [ragSystem, state.isOnline]);
+
+  // Update document
+  const updateKnowledge = useCallback(async (
+    id: string,
+    updates: Partial<RAGDocument<TSchema>>
+  ): Promise<boolean> => {
+    if (!ragSystem || !state.isOnline) return false;
+
+    try {
+      await ragSystem.updateDocument(id, updates);
+      return true;
+    } catch (error) {
+      console.error('Update knowledge error:', error);
+      return false;
+    }
+  }, [ragSystem, state.isOnline]);
+
+  // Sync knowledge base
+  const syncKnowledgeBase = useCallback(async (): Promise<void> => {
+    if (!ragSystem || !state.isOnline) return;
+
+    try {
+      setState(prev => ({ ...prev, isLoading: true }));
+      
+      // Implement incremental sync based on lastSyncAt
+      await ragSystem.sync(state.lastSyncAt);
+      
+      setState(prev => ({ 
+        ...prev, 
+        lastSyncAt: new Date(), 
+        isLoading: false 
+      }));
+    } catch (error) {
+      console.error('Sync error:', error);
+      setState(prev => ({ ...prev, isLoading: false }));
+    }
+  }, [ragSystem, state.isOnline, state.lastSyncAt]);
+
+  // Clear cache
+  const clearCache = useCallback(async () => {
+    setCachedResponses(new Map());
+    setRecentQueries([]);
+    await AsyncStorage.multiRemove(['rag_cache', 'rag_recent_queries']);
+    setState(prev => ({ ...prev, cachedQueries: 0 }));
+  }, []);
+
+  // Helper functions
+  const getCacheKey = (query: RAGQuery): string => {
+    return `${query.query}:${query.category || 'all'}:${query.maxResults}`;
+  };
+
+  const handleOfflineQuery = async (query: RAGQuery): Promise<RAGResponse> => {
+    // Add to offline queue
+    offlineQueueRef.current.push(query);
+    
+    // Return fallback response
+    return {
+      query: query.query,
+      response: "I'm currently offline. Your query has been saved and I'll respond when connection is restored.",
+      sources: [],
+      confidence: 0,
+      metadata: { offline: true },
+      timestamp: new Date()
+    };
+  };
+
+  const processOfflineQueue = async () => {
+    if (!ragSystem || offlineQueueRef.current.length === 0) return;
+
+    const queue = [...offlineQueueRef.current];
+    offlineQueueRef.current = [];
+
+    for (const query of queue) {
+      try {
+        await ragSystem.query(query);
+      } catch (error) {
+        console.error('Offline queue processing error:', error);
+        // Re-add failed queries to queue
+        offlineQueueRef.current.push(query);
+      }
+    }
+  };
+
+  const loadCachedData = async () => {
+    try {
+      const [cacheData, recentData] = await AsyncStorage.multiGet([
+        'rag_cache',
+        'rag_recent_queries'
+      ]);
+
+      if (cacheData[1]) {
+        const cache = JSON.parse(cacheData[1]);
+        setCachedResponses(new Map(cache));
+        setState(prev => ({ ...prev, cachedQueries: cache.length }));
+      }
+
+      if (recentData[1]) {
+        const recent = JSON.parse(recentData[1]);
+        setRecentQueries(recent);
+      }
+    } catch (error) {
+      console.error('Cache loading error:', error);
+    }
+  };
+
+  const cacheResponseLocally = async (key: string, response: RAGResponse) => {
+    try {
+      const current = await AsyncStorage.getItem('rag_cache');
+      const cache = current ? JSON.parse(current) : {};
+      cache[key] = response;
+      
+      await AsyncStorage.setItem('rag_cache', JSON.stringify(cache));
+    } catch (error) {
+      console.error('Cache storage error:', error);
+    }
+  };
+
+  return {
+    // State
+    ...state,
+    ragSystem,
+    recentQueries,
+    offlineQueueSize: offlineQueueRef.current.length,
+
+    // Actions
+    query,
+    searchKnowledge,
+    addKnowledge,
+    updateKnowledge,
+    syncKnowledgeBase,
+    clearCache,
+
+    // Utilities
+    isReady: state.isInitialized && !state.isLoading,
+    canQuery: state.isInitialized && (state.isOnline || enableOffline),
+  };
+}

package/dist/templates/mobile/ui-auth-payments-ai-rag/template/lib/rag/config.ts

@@ -0,0 +1,180 @@
+import { 
+  createGenericRAGConfig,
+  createPlantCareRAGConfig,
+  createEcommerceRAGConfig,
+  createEducationRAGConfig
+} from '@digilogiclabs/saas-factory-ai';
+import type { 
+  RAGConfig, 
+  GenericRAGDocumentSchema,
+  PlantKnowledgeSchema,
+  EcommerceKnowledgeSchema,
+  EducationKnowledgeSchema
+} from '@digilogiclabs/saas-factory-ai-types';
+import Constants from 'expo-constants';
+
+// Environment configuration
+const supabaseConfig = {
+  url: Constants.expoConfig?.extra?.supabaseUrl || process.env.EXPO_PUBLIC_SUPABASE_URL,
+  anonKey: Constants.expoConfig?.extra?.supabaseAnonKey || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY,
+  serviceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY, // Server-only for embeddings
+};
+
+const openAIKey = Constants.expoConfig?.extra?.openaiApiKey || process.env.EXPO_PUBLIC_OPENAI_API_KEY;
+
+// RAG Configuration Templates
+export const createRAGConfigs = () => {
+  const baseNamespace = '{{packageName}}';
+  
+  return {
+    // Generic AI Assistant
+    generic: createGenericRAGConfig<GenericRAGDocumentSchema>(
+      baseNamespace,
+      supabaseConfig,
+      openAIKey,
+      {
+        retrieval: {
+          topK: 5,
+          confidenceThreshold: 0.75,
+          hybridSearchWeight: { vector: 0.7, text: 0.3 }
+        },
+        generation: {
+          systemPrompt: `You are an intelligent AI assistant for the ${baseNamespace} app. 
+          Use the provided knowledge base to give accurate, helpful responses. 
+          If information isn't in the knowledge base, say so clearly and provide general guidance.
+          Keep responses concise and actionable for mobile users.`,
+          temperature: 0.3,
+          maxTokens: 500,
+        },
+        mobile: {
+          caching: true,
+          offlineMode: true,
+          syncStrategy: 'incremental'
+        }
+      }
+    ),
+    
+    // Plant Care Assistant
+    plantCare: createPlantCareRAGConfig(
+      `${baseNamespace}-plants`,
+      supabaseConfig,
+      openAIKey,
+      {
+        retrieval: {
+          topK: 4,
+          confidenceThreshold: 0.8,
+          hybridSearchWeight: { vector: 0.8, text: 0.2 }
+        },
+        generation: {
+          systemPrompt: `You are a botanical expert assistant helping users care for their plants.
+          Use the plant knowledge base to provide specific care instructions, diagnose issues, and suggest solutions.
+          Always consider the user's location, season, and plant type when giving advice.
+          Focus on practical, actionable guidance.`,
+          temperature: 0.2,
+          maxTokens: 400,
+        }
+      }
+    ),
+    
+    // E-commerce Assistant
+    ecommerce: createEcommerceRAGConfig(
+      `${baseNamespace}-store`,
+      supabaseConfig,
+      openAIKey,
+      {
+        retrieval: {
+          topK: 6,
+          confidenceThreshold: 0.7,
+          hybridSearchWeight: { vector: 0.6, text: 0.4 }
+        },
+        generation: {
+          systemPrompt: `You are a helpful shopping assistant for the ${baseNamespace} store.
+          Help users find products, answer questions about specifications, pricing, and availability.
+          Provide personalized recommendations based on their needs and preferences.
+          Always mention stock status and current promotions if available.`,
+          temperature: 0.4,
+          maxTokens: 350,
+        }
+      }
+    ),
+    
+    // Education Assistant
+    education: createEducationRAGConfig(
+      `${baseNamespace}-learning`,
+      supabaseConfig,
+      openAIKey,
+      {
+        retrieval: {
+          topK: 5,
+          confidenceThreshold: 0.8,
+          hybridSearchWeight: { vector: 0.75, text: 0.25 }
+        },
+        generation: {
+          systemPrompt: `You are an educational tutor assistant for the ${baseNamespace} learning platform.
+          Help students understand concepts, answer questions, and provide study guidance.
+          Adapt your explanations to the appropriate grade level and learning style.
+          Encourage critical thinking and provide examples when helpful.`,
+          temperature: 0.3,
+          maxTokens: 600,
+        }
+      }
+    )
+  };
+};
+
+// Default configuration selector
+export const getRAGConfigForDomain = (domain: string): RAGConfig<any> => {
+  const configs = createRAGConfigs();
+  
+  switch (domain.toLowerCase()) {
+    case 'plants':
+    case 'plant-care':
+    case 'gardening':
+      return configs.plantCare;
+    
+    case 'store':
+    case 'shop':
+    case 'ecommerce':
+    case 'products':
+      return configs.ecommerce;
+    
+    case 'education':
+    case 'learning':
+    case 'courses':
+    case 'study':
+      return configs.education;
+    
+    default:
+      return configs.generic;
+  }
+};
+
+// Mobile-specific optimizations
+export const mobileRAGOptions = {
+  // Cache frequently accessed documents locally
+  enableLocalCache: true,
+  maxCacheSize: 100, // Max cached documents
+  
+  // Offline mode settings
+  offlineMode: {
+    enabled: true,
+    fallbackResponses: true,
+    queueQueries: true,
+  },
+  
+  // Performance settings
+  performance: {
+    debounceMs: 300, // Debounce search queries
+    maxConcurrentRequests: 2,
+    timeout: 10000, // 10 second timeout
+  },
+  
+  // Mobile UX settings
+  ui: {
+    showTypingIndicator: true,
+    showConfidenceScores: false, // Hide on mobile for simplicity
+    showSources: true,
+    maxDisplaySources: 3,
+    compactMode: true,
+  }
+};

package/dist/templates/mobile/ui-auth-payments-ai-rag/template/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "{{packageName}}",
+  "version": "1.0.0",
+  "description": "{{description}} - Mobile AI App with RAG Knowledge Base, UI, Auth, Payments, and AI Generation",
+  "main": "node_modules/expo/AppEntry.js",
+  "scripts": {
+    "start": "expo start",
+    "dev": "expo start --dev-client",
+    "android": "expo start --android",
+    "ios": "expo start --ios", 
+    "web": "expo start --web",
+    "build": "eas build",
+    "build:android": "eas build --platform android",
+    "build:ios": "eas build --platform ios",
+    "preview": "eas build --profile preview",
+    "submit": "eas submit",
+    "test": "jest",
+    "lint": "expo lint",
+    "type-check": "tsc --noEmit",
+    "setup:rag": "node scripts/setup-rag.js",
+    "seed:knowledge": "node scripts/seed-knowledge.js",
+    "db:types": "supabase gen types --local > types/supabase.ts"
+  },
+  "dependencies": {
+    "expo": "~50.0.0",
+    "react": "18.2.0",
+    "react-native": "0.73.4",
+    
+    "@expo/vector-icons": "^14.0.0",
+    "@expo/config-plugins": "~7.8.0",
+    
+    "@react-navigation/native": "^6.1.9",
+    "@react-navigation/stack": "^6.3.20",
+    "@react-navigation/bottom-tabs": "^6.5.11",
+    "@react-navigation/drawer": "^6.6.6",
+    "react-native-screens": "~3.29.0",
+    "react-native-safe-area-context": "4.8.2",
+    "react-native-gesture-handler": "~2.14.0",
+    "react-native-reanimated": "~3.6.2",
+    
+    "@digilogiclabs/saas-factory-ui": "^0.22.0",
+    "@digilogiclabs/saas-factory-auth": "^1.0.1", 
+    "@digilogiclabs/saas-factory-payments": "^1.1.0",
+    "@digilogiclabs/saas-factory-ai": "^4.0.0",
+    "@digilogiclabs/saas-factory-ai-types": "^4.0.0",
+    
+    "@supabase/supabase-js": "^2.39.0",
+    "@react-native-async-storage/async-storage": "1.21.0",
+    
+    "@stripe/stripe-react-native": "0.37.2",
+    
+    "expo-router": "~3.4.0",
+    "expo-font": "~11.10.0",
+    "expo-linking": "~6.2.2",
+    "expo-constants": "~15.4.0",
+    "expo-status-bar": "~1.11.1",
+    "expo-splash-screen": "~0.26.4",
+    "expo-system-ui": "~2.9.3",
+    "expo-web-browser": "~12.8.2",
+    "expo-haptics": "~12.8.1",
+    "expo-device": "~5.9.3",
+    "expo-location": "~16.5.3",
+    "expo-image-picker": "~14.7.1",
+    "expo-camera": "~14.1.3",
+    "expo-barcode-scanner": "~12.9.3",
+    "expo-notifications": "~0.27.6",
+    "expo-secure-store": "~12.8.1",
+    "expo-file-system": "~16.0.6",
+    "expo-updates": "~0.24.11",
+    "expo-linear-gradient": "~12.7.2",
+    "expo-blur": "~12.9.2",
+    "expo-speech": "~11.7.0",
+    "expo-av": "~13.10.4",
+    
+    "@react-native-community/netinfo": "11.2.1",
+    "react-native-mmkv": "^2.12.2",
+    "react-native-svg": "14.1.0",
+    "react-native-url-polyfill": "^2.0.0",
+    
+    "zustand": "^4.4.7",
+    "react-hook-form": "^7.48.2",
+    "@hookform/resolvers": "^3.3.2",
+    "zod": "^3.22.4",
+    "date-fns": "^3.0.6",
+    "react-native-heroicons": "^4.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.6",
+    "@types/react": "~18.2.45",
+    "@types/react-native": "~0.73.0",
+    "typescript": "~5.3.3",
+    "jest": "^29.7.0",
+    "@testing-library/react-native": "^12.4.2",
+    "@testing-library/jest-native": "^5.4.3",
+    "babel-plugin-module-resolver": "^5.0.0",
+    "eslint": "^8.57.0",
+    "eslint-config-expo": "^7.0.0",
+    "prettier": "^3.1.1"
+  },
+  "jest": {
+    "preset": "jest-expo",
+    "setupFilesAfterEnv": ["<rootDir>/jest-setup.ts"],
+    "transformIgnorePatterns": [
+      "node_modules/(?!((jest-)?react-native|@react-native(-community)?)|expo(nent)?|@expo(nent)?/.*|@expo-google-fonts/.*|react-navigation|@react-navigation/.*|@unimodules/.*|unimodules|sentry-expo|native-base|react-native-svg)"
+    ]
+  },
+  "private": true,
+  "expo": {
+    "install": {
+      "exclude": ["react-native-safe-area-context"]
+    }
+  }
+}