@digilogiclabs/create-saas-app 2.10.0 → 2.12.0

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

@@ -1,25 +0,0 @@
-{
-  "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/dist/templates/mobile/ui-auth-payments-ai-rag/template/expo-env.d.ts

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

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

@@ -1,346 +0,0 @@
-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/jest-setup.ts

@@ -1,37 +0,0 @@
-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/dist/templates/mobile/ui-auth-payments-ai-rag/template/lib/rag/config.ts

@@ -1,180 +0,0 @@
-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/metro.config.js

@@ -1,11 +0,0 @@
-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' });