@digilogiclabs/create-saas-app 1.0.1

package/dist/templates/mobile/ui-auth-payments-ai-rag/template/scripts/setup-rag.js

@@ -0,0 +1,599 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+
+console.log('🚀 Setting up RAG Knowledge System for React Native...\n')
+
+// Colors for console output
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  reset: '\x1b[0m'
+}
+
+function log(message, color = 'white') {
+  console.log(`${colors[color]}${message}${colors.reset}`)
+}
+
+function step(number, message) {
+  log(`\n📋 Step ${number}: ${message}`, 'cyan')
+}
+
+function success(message) {
+  log(`✅ ${message}`, 'green')
+}
+
+function warning(message) {
+  log(`⚠️  ${message}`, 'yellow')
+}
+
+function error(message) {
+  log(`❌ ${message}`, 'red')
+}
+
+function checkRequirements() {
+  step(1, 'Checking React Native requirements')
+
+  try {
+    // Check if we're in an Expo project
+    if (!fs.existsSync('package.json')) {
+      throw new Error('package.json not found. Please run this script from your project root.')
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+
+    if (!packageJson.dependencies?.expo && !packageJson.dependencies?.['react-native']) {
+      throw new Error('This appears to be not a React Native/Expo project.')
+    }
+
+    if (packageJson.dependencies?.expo) {
+      success('Expo project detected')
+    } else {
+      success('React Native project detected')
+    }
+
+    // Check for required dependencies
+    const requiredDeps = [
+      '@digilogiclabs/saas-factory-ai',
+      '@digilogiclabs/saas-factory-ai-types',
+      '@supabase/supabase-js',
+      '@react-native-async-storage/async-storage',
+      '@react-native-community/netinfo'
+    ]
+
+    const missingDeps = requiredDeps.filter(dep =>
+      !packageJson.dependencies?.[dep] && !packageJson.devDependencies?.[dep]
+    )
+
+    if (missingDeps.length > 0) {
+      warning(`Missing dependencies: ${missingDeps.join(', ')}`)
+      log('Installing missing dependencies...')
+
+      if (packageJson.dependencies?.expo) {
+        execSync(`npx expo install ${missingDeps.join(' ')}`, { stdio: 'inherit' })
+      } else {
+        execSync(`npm install ${missingDeps.join(' ')}`, { stdio: 'inherit' })
+      }
+      success('Dependencies installed')
+    } else {
+      success('All required dependencies found')
+    }
+
+  } catch (err) {
+    error(err.message)
+    process.exit(1)
+  }
+}
+
+function setupEnvironmentVariables() {
+  step(2, 'Setting up environment variables')
+
+  const requiredEnvVars = [
+    'EXPO_PUBLIC_SUPABASE_URL',
+    'EXPO_PUBLIC_SUPABASE_ANON_KEY',
+    'EXPO_PUBLIC_OPENAI_API_KEY'
+  ]
+
+  // Check app.config.js/ts or expo config
+  const configFiles = ['app.config.js', 'app.config.ts', 'expo.json']
+  let configFile = null
+
+  for (const file of configFiles) {
+    if (fs.existsSync(file)) {
+      configFile = file
+      break
+    }
+  }
+
+  if (!configFile) {
+    // Create basic app.config.js
+    const configContent = `const IS_DEV = process.env.APP_VARIANT === 'development'
+const IS_PREVIEW = process.env.APP_VARIANT === 'preview'
+
+const getUniqueIdentifier = () => {
+  if (IS_DEV) {
+    return '{{bundleId}}.dev'
+  }
+
+  if (IS_PREVIEW) {
+    return '{{bundleId}}.preview'
+  }
+
+  return '{{bundleId}}'
+}
+
+const getAppName = () => {
+  if (IS_DEV) {
+    return '{{displayName}} (Dev)'
+  }
+
+  if (IS_PREVIEW) {
+    return '{{displayName}} (Preview)'
+  }
+
+  return '{{displayName}}'
+}
+
+export default {
+  expo: {
+    name: getAppName(),
+    slug: '{{slug}}',
+    version: '1.0.0',
+    orientation: 'portrait',
+    icon: './assets/icon.png',
+    userInterfaceStyle: 'automatic',
+    splash: {
+      image: './assets/splash.png',
+      resizeMode: 'contain',
+      backgroundColor: '#ffffff'
+    },
+    assetBundlePatterns: ['**/*'],
+    ios: {
+      supportsTablet: true,
+      bundleIdentifier: getUniqueIdentifier()
+    },
+    android: {
+      adaptiveIcon: {
+        foregroundImage: './assets/adaptive-icon.png',
+        backgroundColor: '#ffffff'
+      },
+      package: getUniqueIdentifier()
+    },
+    web: {
+      favicon: './assets/favicon.png',
+      bundler: 'metro'
+    },
+    extra: {
+      supabaseUrl: process.env.EXPO_PUBLIC_SUPABASE_URL,
+      supabaseAnonKey: process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY,
+      openaiApiKey: process.env.EXPO_PUBLIC_OPENAI_API_KEY,
+      eas: {
+        projectId: '{{easProjectId}}'
+      }
+    },
+    owner: '{{expoUsername}}'
+  }
+}
+`
+    fs.writeFileSync('app.config.js', configContent)
+    success('Created app.config.js')
+    configFile = 'app.config.js'
+  }
+
+  // Check .env files
+  const envFiles = ['.env.local', '.env']
+  let envFileExists = false
+
+  for (const envFile of envFiles) {
+    if (fs.existsSync(envFile)) {
+      envFileExists = true
+      success(`Found ${envFile}`)
+      break
+    }
+  }
+
+  if (!envFileExists) {
+    warning('No environment file found. Creating .env.local...')
+
+    const envTemplate = `# RAG Knowledge System Configuration for React Native
+EXPO_PUBLIC_SUPABASE_URL=your_supabase_url_here
+EXPO_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key_here
+
+# OpenAI Configuration (exposed to client - use with caution)
+EXPO_PUBLIC_OPENAI_API_KEY=your_openai_api_key_here
+
+# Server-only keys (for API routes if using Expo Router API routes)
+SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key_here
+OPENAI_API_KEY=your_openai_api_key_here
+
+# App Configuration
+APP_VARIANT=development
+EAS_PROJECT_ID=your_eas_project_id_here
+`
+
+    fs.writeFileSync('.env.local', envTemplate)
+    success('Created .env.local template')
+    warning('Please update .env.local with your actual API keys before proceeding')
+    warning('Note: In React Native, environment variables are embedded in the build!')
+  } else {
+    success('Environment configuration found')
+  }
+}
+
+function createMobileSpecificConfig() {
+  step(3, 'Creating mobile-specific RAG configuration')
+
+  // Create lib directory structure
+  const dirs = ['lib/rag', 'hooks', 'components/rag', 'scripts']
+  dirs.forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+      success(`Created directory: ${dir}`)
+    }
+  })
+
+  // Create mobile-specific Supabase configuration
+  const supabaseConfig = `import AsyncStorage from '@react-native-async-storage/async-storage'
+import { createClient } from '@supabase/supabase-js'
+import Constants from 'expo-constants'
+import type { Database } from '../types/supabase'
+
+const supabaseUrl = Constants.expoConfig?.extra?.supabaseUrl || process.env.EXPO_PUBLIC_SUPABASE_URL
+const supabaseAnonKey = Constants.expoConfig?.extra?.supabaseAnonKey || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY
+
+if (!supabaseUrl || !supabaseAnonKey) {
+  throw new Error(
+    'Supabase URL and Anon Key are required. Please check your environment configuration.'
+  )
+}
+
+export const supabase = createClient<Database>(supabaseUrl, supabaseAnonKey, {
+  auth: {
+    storage: AsyncStorage,
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: false,
+  },
+})
+
+export default supabase
+`
+
+  fs.writeFileSync('lib/supabase.ts', supabaseConfig)
+  success('Created Supabase configuration for React Native')
+}
+
+function createSeedScript() {
+  step(4, 'Creating knowledge seeding script')
+
+  const seedScript = `#!/usr/bin/env node
+
+const { createClient } = require('@supabase/supabase-js')
+require('dotenv').config({ path: '.env.local' })
+
+const supabase = createClient(
+  process.env.EXPO_PUBLIC_SUPABASE_URL,
+  process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY
+)
+
+const sampleMobileDocuments = [
+  {
+    namespace: '{{packageName}}-mobile',
+    category: 'getting-started',
+    content: 'Welcome to your mobile AI-powered knowledge app! This React Native app uses RAG to provide intelligent responses based on your knowledge base. Swipe through tabs to explore different features.',
+    fields: {
+      title: 'Mobile App Welcome',
+      difficulty: 'beginner',
+      platform: 'mobile'
+    },
+    metadata: {
+      featured: true,
+      priority: 1,
+      mobileOptimized: true
+    },
+    source: { type: 'seed', version: '1.0', platform: 'react-native' }
+  },
+  {
+    namespace: '{{packageName}}-mobile',
+    category: 'features',
+    content: 'Mobile features include: Voice input for queries, offline caching, push notifications for new knowledge, touch-optimized interface, and seamless sync across devices.',
+    fields: {
+      title: 'Mobile Platform Features',
+      difficulty: 'beginner',
+      platform: 'mobile'
+    },
+    metadata: {
+      featured: true,
+      priority: 2,
+      mobileOptimized: true
+    },
+    source: { type: 'seed', version: '1.0', platform: 'react-native' }
+  },
+  {
+    namespace: '{{packageName}}-mobile',
+    category: 'tutorials',
+    content: 'To use voice input: 1. Tap the microphone icon in the chat, 2. Speak your question clearly, 3. The app will convert speech to text and process your query, 4. Get AI responses with relevant sources.',
+    fields: {
+      title: 'Voice Input Tutorial',
+      difficulty: 'intermediate',
+      platform: 'mobile'
+    },
+    metadata: {
+      tutorial: true,
+      priority: 3,
+      mobileOptimized: true
+    },
+    source: { type: 'seed', version: '1.0', platform: 'react-native' }
+  },
+  {
+    namespace: '{{packageName}}-mobile',
+    category: 'offline',
+    content: 'Offline mode: The app caches recent queries and responses for offline access. When offline, you can still browse cached content and queue new queries that will be processed when connection is restored.',
+    fields: {
+      title: 'Offline Mode Guide',
+      difficulty: 'intermediate',
+      platform: 'mobile'
+    },
+    metadata: {
+      featured: true,
+      priority: 4,
+      mobileOptimized: true,
+      offlineCapable: true
+    },
+    source: { type: 'seed', version: '1.0', platform: 'react-native' }
+  }
+]
+
+async function seedMobileKnowledge() {
+  console.log('🌱 Seeding mobile knowledge base...')
+
+  try {
+    for (const doc of sampleMobileDocuments) {
+      const { data, error } = await supabase
+        .from('rag_knowledge_base')
+        .insert(doc)
+
+      if (error) {
+        console.error('Error inserting document:', error)
+      } else {
+        console.log('✅ Inserted:', doc.fields.title)
+      }
+    }
+
+    console.log('🎉 Mobile knowledge base seeded successfully!')
+    console.log('📱 Next steps for React Native:')
+    console.log('   1. Run: npm start or npx expo start')
+    console.log('   2. Open in Expo Go or simulator')
+    console.log('   3. Navigate to the AI tab')
+    console.log('   4. Start chatting with your knowledge base!')
+    console.log('   5. Test offline mode by disabling network')
+
+  } catch (error) {
+    console.error('❌ Mobile seeding failed:', error)
+    process.exit(1)
+  }
+}
+
+seedMobileKnowledge()
+`
+
+  fs.writeFileSync('scripts/seed-mobile-knowledge.js', seedScript)
+  fs.chmodSync('scripts/seed-mobile-knowledge.js', 0o755)
+  success('Created mobile seed script')
+}
+
+function setupTypeScript() {
+  step(5, 'Setting up TypeScript types')
+
+  // Create types directory
+  if (!fs.existsSync('types')) {
+    fs.mkdirSync('types', { recursive: true })
+  }
+
+  // Create basic RAG types for mobile
+  const ragTypes = `// RAG System Types for React Native
+export interface MobileRAGConfig {
+  domain: string
+  enableOffline: boolean
+  cacheSize: number
+  syncStrategy: 'immediate' | 'batch' | 'manual'
+  voiceInput?: boolean
+  hapticFeedback?: boolean
+}
+
+export interface OfflineQuery {
+  id: string
+  query: string
+  timestamp: Date
+  synced: boolean
+}
+
+export interface CachedResponse {
+  query: string
+  response: string
+  sources: any[]
+  confidence: number
+  timestamp: Date
+  expiresAt: Date
+}
+
+export interface MobileRAGState {
+  isOnline: boolean
+  isLoading: boolean
+  cacheSize: number
+  offlineQueueSize: number
+  lastSync: Date | null
+}
+`
+
+  fs.writeFileSync('types/rag.ts', ragTypes)
+  success('Created mobile RAG types')
+
+  // Create Supabase types placeholder
+  const supabaseTypes = `// Basic Supabase types for RAG system
+// Replace with generated types: supabase gen types --local > types/supabase.ts
+
+export interface Database {
+  public: {
+    Tables: {
+      rag_knowledge_base: {
+        Row: {
+          id: string
+          namespace: string
+          category: string
+          content: string
+          fields: Record<string, any>
+          metadata: Record<string, any>
+          source: Record<string, any>
+          embedding: number[] | null
+          created_at: string
+          updated_at: string
+          version: number
+        }
+        Insert: {
+          id?: string
+          namespace?: string
+          category?: string
+          content: string
+          fields?: Record<string, any>
+          metadata?: Record<string, any>
+          source?: Record<string, any>
+          embedding?: number[] | null
+          created_at?: string
+          updated_at?: string
+          version?: number
+        }
+        Update: {
+          id?: string
+          namespace?: string
+          category?: string
+          content?: string
+          fields?: Record<string, any>
+          metadata?: Record<string, any>
+          source?: Record<string, any>
+          embedding?: number[] | null
+          created_at?: string
+          updated_at?: string
+          version?: number
+        }
+      }
+    }
+    Views: {
+      [_ in never]: never
+    }
+    Functions: {
+      rag_similarity_search: {
+        Args: {
+          query_embedding: number[]
+          search_namespace?: string
+          search_category?: string
+          similarity_threshold?: number
+          max_results?: number
+        }
+        Returns: {
+          id: string
+          content: string
+          category: string
+          fields: Record<string, any>
+          metadata: Record<string, any>
+          similarity: number
+        }[]
+      }
+    }
+    Enums: {
+      [_ in never]: never
+    }
+  }
+}
+`
+
+  fs.writeFileSync('types/supabase.ts', supabaseTypes)
+  success('Created basic Supabase types')
+}
+
+function updatePackageJson() {
+  step(6, 'Updating package.json scripts')
+
+  const packageJsonPath = 'package.json'
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      'setup:rag': 'node scripts/setup-rag.js',
+      'seed:knowledge': 'node scripts/seed-mobile-knowledge.js',
+      'db:types': 'supabase gen types --local > types/supabase.ts'
+    }
+
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+    success('Updated package.json scripts')
+  }
+}
+
+function displayMobileNextSteps() {
+  step(7, 'Setup complete! Mobile-specific next steps')
+
+  log('\n🎉 Mobile RAG Knowledge System setup complete!\n', 'green')
+
+  log('📱 Mobile-specific next steps:', 'cyan')
+  log('   1. Update your .env.local with actual API keys')
+  log('   2. Ensure your Supabase database has the RAG tables')
+  log('   3. Run the mobile seed script: npm run seed:knowledge')
+  log('   4. Start Expo: npx expo start')
+  log('   5. Open in simulator or Expo Go app')
+  log('   6. Test the AI tab with voice input and offline mode')
+
+  log('\n🔧 Available commands:', 'cyan')
+  log('   npm run setup:rag      - Run this setup script')
+  log('   npm run seed:knowledge - Add mobile-optimized knowledge')
+  log('   npm run db:types       - Generate TypeScript types')
+  log('   npx expo start         - Start development server')
+  log('   npx expo start --offline - Start in offline mode')
+
+  log('\n📚 Mobile-specific files:', 'cyan')
+  log('   • RAG Hook: hooks/useRAGSystem.ts')
+  log('   • AI Screen: app/(tabs)/ai.tsx')
+  log('   • Config: lib/rag/config.ts')
+  log('   • Supabase: lib/supabase.ts')
+  log('   • Types: types/rag.ts, types/supabase.ts')
+
+  log('\n💡 Mobile tips:', 'yellow')
+  log('   • Test offline functionality by disabling network')
+  log('   • Voice input works in simulator with computer microphone')
+  log('   • Haptic feedback enhances user experience')
+  log('   • Cache settings can be adjusted in config')
+  log('   • Consider push notifications for knowledge updates')
+
+  log('\n📊 Performance considerations:', 'yellow')
+  log('   • Embeddings are computed server-side to save battery')
+  log('   • Responses are cached locally for offline access')
+  log('   • Background sync keeps knowledge base updated')
+  log('   • Network requests are debounced to reduce API calls')
+
+  log('\n🚀 Happy building with Mobile RAG!', 'green')
+}
+
+// Main execution
+async function main() {
+  try {
+    checkRequirements()
+    setupEnvironmentVariables()
+    createMobileSpecificConfig()
+    createSeedScript()
+    setupTypeScript()
+    updatePackageJson()
+    displayMobileNextSteps()
+  } catch (err) {
+    error(`Mobile setup failed: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+main()

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

@@ -0,0 +1,32 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./*"],
+      "@/components/*": ["./components/*"],
+      "@/hooks/*": ["./hooks/*"],
+      "@/utils/*": ["./utils/*"],
+      "@/types/*": ["./types/*"],
+      "@/constants/*": ["./constants/*"],
+      "@/lib/*": ["./lib/*"]
+    },
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    ".expo/types/**/*.ts",
+    "expo-env.d.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/dist/templates/shared/auth/firebase/web/config.ts

@@ -0,0 +1,23 @@
+import { initializeApp } from 'firebase/app';
+import { getAuth } from 'firebase/auth';
+import { getFirestore } from 'firebase/firestore';
+
+const firebaseConfig = {
+  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+  authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.NEXT_PUBLIC_FIREBASE_APP_ID,
+};
+
+// Initialize Firebase
+const app = initializeApp(firebaseConfig);
+
+// Initialize Firebase Authentication and get a reference to the service
+export const auth = getAuth(app);
+
+// Initialize Cloud Firestore and get a reference to the service
+export const db = getFirestore(app);
+
+export default app;

package/dist/templates/shared/auth/supabase/web/config.ts

@@ -0,0 +1,8 @@
+import { createClient } from '@supabase/supabase-js';
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL!;
+const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!;
+
+export const supabase = createClient(supabaseUrl, supabaseAnonKey);
+
+export default supabase;

package/dist/templates/web/base/template/.env.example

@@ -0,0 +1,15 @@
+# Auth Configuration
+NEXT_PUBLIC_AUTH_PROVIDER=supabase|firebase
+
+# Supabase
+NEXT_PUBLIC_SUPABASE_URL=
+NEXT_PUBLIC_SUPABASE_ANON_KEY=
+
+# Firebase
+NEXT_PUBLIC_FIREBASE_API_KEY=
+NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN=
+NEXT_PUBLIC_FIREBASE_PROJECT_ID=
+
+# Payments
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=
+STRIPE_SECRET_KEY=

package/dist/templates/web/base/template/.eslintrc.js

@@ -0,0 +1,8 @@
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  extends: ['next/core-web-vitals'],
+  rules: {
+    // Add any custom rules here
+  },
+}
+