@digilogiclabs/create-saas-app 1.0.1

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

@@ -0,0 +1,25 @@
+{
+  "cli": {
+    "version": ">= 5.7.0"
+  },
+  "build": {
+    "development": {
+      "developmentClient": true,
+      "distribution": "internal"
+    },
+    "preview": {
+      "distribution": "internal",
+      "ios": {
+        "resourceClass": "m-medium"
+      }
+    },
+    "production": {
+      "ios": {
+        "resourceClass": "m-medium"
+      }
+    }
+  },
+  "submit": {
+    "production": {}
+  }
+}

package/src/templates/mobile/ui-auth-payments-ai-rag/template/expo-env.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="expo/types" />
+
+// NOTE: This file should not be edited and should be in your git ignore

package/src/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/src/templates/mobile/ui-auth-payments-ai-rag/template/jest-setup.ts

@@ -0,0 +1,37 @@
+import '@testing-library/jest-native/extend-expect';
+
+// Mock react-native-reanimated
+jest.mock('react-native-reanimated', () => {
+  const Reanimated = require('react-native-reanimated/mock');
+  Reanimated.default.call = () => {};
+  return Reanimated;
+});
+
+// Mock expo modules
+jest.mock('expo-constants', () => ({
+  default: {
+    expoConfig: {
+      extra: {}
+    }
+  }
+}));
+
+jest.mock('expo-status-bar', () => ({
+  StatusBar: 'StatusBar'
+}));
+
+jest.mock('expo-router', () => ({
+  router: {
+    push: jest.fn(),
+    replace: jest.fn(),
+    back: jest.fn(),
+  },
+  Link: 'Link',
+  useRouter: () => ({
+    push: jest.fn(),
+    replace: jest.fn(),
+    back: jest.fn(),
+  }),
+  usePathname: () => '/',
+  useLocalSearchParams: () => ({}),
+}));

package/src/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/src/templates/mobile/ui-auth-payments-ai-rag/template/metro.config.js

@@ -0,0 +1,11 @@
+const { getDefaultConfig } = require('expo/metro-config');
+const { withNativeWind } = require('nativewind/metro');
+
+const config = getDefaultConfig(__dirname);
+
+// Configure SVG support
+config.transformer.babelTransformerPath = require.resolve('react-native-svg-transformer');
+config.resolver.assetExts = config.resolver.assetExts.filter((ext) => ext !== 'svg');
+config.resolver.sourceExts = [...config.resolver.sourceExts, 'svg'];
+
+module.exports = withNativeWind(config, { input: './global.css' });