@digilogiclabs/create-saas-app 1.0.1

package/src/templates/web/ui-auth-payments-ai-rag/template/scripts/setup-rag.js

@@ -0,0 +1,622 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+
+console.log('🚀 Setting up RAG Knowledge System...\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 requirements')
+  
+  try {
+    // Check if we're in a Next.js 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?.next) {
+      throw new Error('This appears to be not a Next.js project. RAG templates require Next.js.')
+    }
+
+    success('Next.js project detected')
+
+    // Check for required dependencies
+    const requiredDeps = [
+      '@digilogiclabs/saas-factory-ai',
+      '@digilogiclabs/saas-factory-ai-types',
+      '@supabase/supabase-js'
+    ]
+
+    const missingDeps = requiredDeps.filter(dep => !packageJson.dependencies?.[dep])
+    
+    if (missingDeps.length > 0) {
+      warning(`Missing dependencies: ${missingDeps.join(', ')}`)
+      log('Installing missing dependencies...')
+      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 checkEnvironmentVariables() {
+  step(2, 'Checking environment variables')
+  
+  const requiredEnvVars = [
+    'NEXT_PUBLIC_SUPABASE_URL',
+    'NEXT_PUBLIC_SUPABASE_ANON_KEY',
+    'OPENAI_API_KEY'
+  ]
+
+  const missingVars = []
+  const envFiles = ['.env.local', '.env']
+  let envFileExists = false
+
+  for (const envFile of envFiles) {
+    if (fs.existsSync(envFile)) {
+      envFileExists = true
+      const envContent = fs.readFileSync(envFile, 'utf8')
+      
+      for (const varName of requiredEnvVars) {
+        if (!envContent.includes(varName) || envContent.includes(`${varName}=`)) {
+          missingVars.push(varName)
+        }
+      }
+      break
+    }
+  }
+
+  if (!envFileExists) {
+    warning('No environment file found. Creating .env.local...')
+    
+    const envTemplate = `# RAG Knowledge System Configuration
+NEXT_PUBLIC_SUPABASE_URL=your_supabase_url_here
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key_here
+SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key_here
+
+# OpenAI Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Optional: App Configuration
+NEXT_PUBLIC_APP_NAME={{packageName}}
+NODE_ENV=development
+`
+    
+    fs.writeFileSync('.env.local', envTemplate)
+    success('Created .env.local template')
+    warning('Please update .env.local with your actual API keys before proceeding')
+  } else if (missingVars.length > 0) {
+    warning(`Missing environment variables: ${missingVars.join(', ')}`)
+    warning('Please add these to your .env.local file')
+  } else {
+    success('Environment variables configured')
+  }
+}
+
+function setupDatabaseMigrations() {
+  step(3, 'Setting up database migrations')
+  
+  try {
+    // Check if Supabase CLI is available
+    try {
+      execSync('supabase --version', { stdio: 'pipe' })
+      success('Supabase CLI found')
+    } catch {
+      warning('Supabase CLI not found. Please install it: npm install -g supabase')
+      log('You can also run migrations manually using the SQL files in supabase/migrations/')
+      return
+    }
+
+    // Check if supabase is initialized
+    if (!fs.existsSync('supabase')) {
+      log('Initializing Supabase project...')
+      execSync('supabase init', { stdio: 'inherit' })
+    }
+
+    // Create migrations directory if it doesn't exist
+    const migrationsDir = 'supabase/migrations'
+    if (!fs.existsSync(migrationsDir)) {
+      fs.mkdirSync(migrationsDir, { recursive: true })
+    }
+
+    // Create RAG migration file
+    const migrationContent = `-- RAG Knowledge Base Tables
+-- This migration creates the necessary tables for the RAG system
+
+-- Enable the vector extension for embeddings
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create the main knowledge base table
+CREATE TABLE IF NOT EXISTS rag_knowledge_base (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    namespace TEXT NOT NULL DEFAULT 'default',
+    category TEXT NOT NULL DEFAULT 'general',
+    content TEXT NOT NULL,
+    fields JSONB DEFAULT '{}'::jsonb,
+    metadata JSONB DEFAULT '{}'::jsonb,
+    source JSONB DEFAULT '{}'::jsonb,
+    embedding vector(1536),
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW(),
+    version INTEGER DEFAULT 1,
+    
+    -- Indexes for performance
+    CONSTRAINT rag_knowledge_base_content_check CHECK (length(content) > 0)
+);
+
+-- Create indexes
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_namespace ON rag_knowledge_base(namespace);
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_category ON rag_knowledge_base(category);
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_created_at ON rag_knowledge_base(created_at);
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_updated_at ON rag_knowledge_base(updated_at);
+
+-- Vector similarity search index
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_embedding ON rag_knowledge_base 
+USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+
+-- Full-text search index
+CREATE INDEX IF NOT EXISTS idx_rag_knowledge_content_fts ON rag_knowledge_base 
+USING gin(to_tsvector('english', content));
+
+-- Create search functions
+CREATE OR REPLACE FUNCTION rag_similarity_search(
+    query_embedding vector(1536),
+    search_namespace text DEFAULT 'default',
+    search_category text DEFAULT NULL,
+    similarity_threshold float DEFAULT 0.5,
+    max_results int DEFAULT 10
+)
+RETURNS TABLE (
+    id text,
+    content text,
+    category text,
+    fields jsonb,
+    metadata jsonb,
+    similarity float
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT 
+        kb.id,
+        kb.content,
+        kb.category,
+        kb.fields,
+        kb.metadata,
+        1 - (kb.embedding <=> query_embedding) as similarity
+    FROM rag_knowledge_base kb
+    WHERE 
+        kb.namespace = search_namespace
+        AND (search_category IS NULL OR kb.category = search_category)
+        AND kb.embedding IS NOT NULL
+        AND 1 - (kb.embedding <=> query_embedding) > similarity_threshold
+    ORDER BY similarity DESC
+    LIMIT max_results;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create hybrid search function (vector + text)
+CREATE OR REPLACE FUNCTION rag_hybrid_search(
+    query_text text,
+    query_embedding vector(1536),
+    search_namespace text DEFAULT 'default',
+    search_category text DEFAULT NULL,
+    similarity_threshold float DEFAULT 0.5,
+    text_weight float DEFAULT 0.3,
+    vector_weight float DEFAULT 0.7,
+    max_results int DEFAULT 10
+)
+RETURNS TABLE (
+    id text,
+    content text,
+    category text,
+    fields jsonb,
+    metadata jsonb,
+    combined_score float
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT 
+        kb.id,
+        kb.content,
+        kb.category,
+        kb.fields,
+        kb.metadata,
+        (
+            text_weight * ts_rank(to_tsvector('english', kb.content), plainto_tsquery('english', query_text)) +
+            vector_weight * (1 - (kb.embedding <=> query_embedding))
+        ) as combined_score
+    FROM rag_knowledge_base kb
+    WHERE 
+        kb.namespace = search_namespace
+        AND (search_category IS NULL OR kb.category = search_category)
+        AND kb.embedding IS NOT NULL
+        AND (
+            to_tsvector('english', kb.content) @@ plainto_tsquery('english', query_text)
+            OR 1 - (kb.embedding <=> query_embedding) > similarity_threshold
+        )
+    ORDER BY combined_score DESC
+    LIMIT max_results;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create analytics function
+CREATE OR REPLACE FUNCTION rag_get_stats(search_namespace text DEFAULT 'default')
+RETURNS TABLE (
+    total_documents bigint,
+    categories_count bigint,
+    avg_content_length float,
+    last_updated timestamptz
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT 
+        COUNT(*) as total_documents,
+        COUNT(DISTINCT category) as categories_count,
+        AVG(length(content))::float as avg_content_length,
+        MAX(updated_at) as last_updated
+    FROM rag_knowledge_base 
+    WHERE namespace = search_namespace;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Enable RLS (Row Level Security)
+ALTER TABLE rag_knowledge_base ENABLE ROW LEVEL SECURITY;
+
+-- Create RLS policies
+CREATE POLICY "Public read access" ON rag_knowledge_base
+    FOR SELECT USING (true);
+
+CREATE POLICY "Authenticated users can insert" ON rag_knowledge_base
+    FOR INSERT WITH CHECK (auth.role() = 'authenticated');
+
+CREATE POLICY "Authenticated users can update" ON rag_knowledge_base
+    FOR UPDATE USING (auth.role() = 'authenticated');
+
+CREATE POLICY "Authenticated users can delete" ON rag_knowledge_base
+    FOR DELETE USING (auth.role() = 'authenticated');
+
+-- Create updated_at trigger
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER update_rag_knowledge_base_updated_at
+    BEFORE UPDATE ON rag_knowledge_base
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Create app-specific views for common domains
+CREATE VIEW plant_knowledge AS
+SELECT * FROM rag_knowledge_base 
+WHERE namespace LIKE '%-plants' OR category IN ('plant-care', 'botanical', 'gardening');
+
+CREATE VIEW product_knowledge AS
+SELECT * FROM rag_knowledge_base 
+WHERE namespace LIKE '%-store' OR category IN ('products', 'ecommerce', 'catalog');
+
+CREATE VIEW education_knowledge AS
+SELECT * FROM rag_knowledge_base 
+WHERE namespace LIKE '%-learning' OR category IN ('courses', 'education', 'tutorials');
+
+-- Insert sample data
+INSERT INTO rag_knowledge_base (namespace, category, content, fields, metadata, source) VALUES
+('{{packageName}}', 'faq', 'How do I get started with this platform? Getting started is easy! Simply sign up for an account, complete the onboarding process, and begin exploring the features. Our comprehensive documentation will guide you through each step.', 
+ '{"title": "Getting Started Guide", "tags": ["beginner", "setup"]}', 
+ '{"difficulty": "beginner", "popularity": 95}', 
+ '{"type": "manual", "author": "system"}'),
+
+('{{packageName}}', 'faq', 'What features are available in the platform? Our platform offers AI-powered chat, knowledge base management, real-time analytics, user authentication, payment processing, and much more. Check our features page for a complete list.', 
+ '{"title": "Platform Features", "tags": ["features", "overview"]}', 
+ '{"difficulty": "beginner", "popularity": 88}', 
+ '{"type": "manual", "author": "system"}'),
+
+('{{packageName}}', 'guide', 'To set up your knowledge base: 1. Navigate to the Knowledge section, 2. Click Add Document, 3. Enter your content and categorize it, 4. Save and your content will be automatically indexed for AI search.', 
+ '{"title": "Knowledge Base Setup", "tags": ["knowledge", "setup", "guide"]}', 
+ '{"difficulty": "intermediate", "popularity": 76}', 
+ '{"type": "manual", "author": "system"}'),
+
+('{{packageName}}', 'reference', 'API endpoints: GET /api/rag/search - Search knowledge base, POST /api/rag/chat - Chat with AI, POST /api/knowledge - Add document, PUT /api/knowledge/:id - Update document, DELETE /api/knowledge/:id - Delete document', 
+ '{"title": "API Reference", "tags": ["api", "developer", "reference"]}', 
+ '{"difficulty": "advanced", "popularity": 65}', 
+ '{"type": "manual", "author": "system"}');
+
+COMMENT ON TABLE rag_knowledge_base IS 'Stores knowledge base documents with vector embeddings for RAG system';
+COMMENT ON COLUMN rag_knowledge_base.embedding IS 'Vector embedding for semantic search (1536 dimensions for OpenAI ada-002)';
+COMMENT ON COLUMN rag_knowledge_base.fields IS 'Flexible schema for domain-specific structured data';
+COMMENT ON COLUMN rag_knowledge_base.metadata IS 'Additional metadata like tags, difficulty, popularity scores';
+COMMENT ON COLUMN rag_knowledge_base.source IS 'Information about where this document came from';
+`
+
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '').replace('T', '_')
+    const migrationFile = path.join(migrationsDir, `${timestamp}_create_rag_tables.sql`)
+    
+    fs.writeFileSync(migrationFile, migrationContent)
+    success(`Created migration file: ${migrationFile}`)
+
+    // Try to apply migration if Supabase is running
+    try {
+      log('Applying database migration...')
+      execSync('supabase db reset', { stdio: 'inherit' })
+      success('Database migration applied successfully')
+    } catch (err) {
+      warning('Could not apply migration automatically.')
+      warning('Please run: supabase db reset')
+      warning('Or apply the SQL migration manually to your database')
+    }
+
+  } catch (err) {
+    error(`Database setup failed: ${err.message}`)
+    warning('Please set up the database manually using the generated SQL files')
+  }
+}
+
+function generateTypes() {
+  step(4, 'Generating TypeScript types')
+  
+  try {
+    // Try to generate types
+    execSync('supabase gen types --local > types/supabase.ts', { stdio: 'pipe' })
+    success('TypeScript types generated')
+  } catch (err) {
+    warning('Could not generate types automatically')
+    warning('Please run: supabase gen types --local > types/supabase.ts')
+    
+    // Create types directory and basic type file
+    if (!fs.existsSync('types')) {
+      fs.mkdirSync('types', { recursive: true })
+    }
+    
+    const basicTypes = `// Basic RAG types - replace with generated Supabase types
+export interface Database {
+  public: {
+    Tables: {
+      rag_knowledge_base: {
+        Row: {
+          id: string
+          namespace: string
+          category: string
+          content: string
+          fields: any
+          metadata: any
+          source: any
+          embedding: number[] | null
+          created_at: string
+          updated_at: string
+          version: number
+        }
+        Insert: {
+          id?: string
+          namespace?: string
+          category?: string
+          content: string
+          fields?: any
+          metadata?: any
+          source?: any
+          embedding?: number[] | null
+          created_at?: string
+          updated_at?: string
+          version?: number
+        }
+        Update: {
+          id?: string
+          namespace?: string
+          category?: string
+          content?: string
+          fields?: any
+          metadata?: any
+          source?: any
+          embedding?: number[] | null
+          created_at?: string
+          updated_at?: string
+          version?: number
+        }
+      }
+    }
+  }
+}
+`
+    
+    fs.writeFileSync('types/supabase.ts', basicTypes)
+    success('Created basic types file')
+  }
+}
+
+function createConfigFiles() {
+  step(5, 'Creating configuration files')
+  
+  // Create lib directory structure
+  const dirs = ['lib/rag', 'components/rag', 'hooks', 'scripts']
+  dirs.forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+      success(`Created directory: ${dir}`)
+    }
+  })
+
+  // Create a seed data script
+  const seedScript = `#!/usr/bin/env node
+
+const { createClient } = require('@supabase/supabase-js')
+require('dotenv').config({ path: '.env.local' })
+
+const supabase = createClient(
+  process.env.NEXT_PUBLIC_SUPABASE_URL,
+  process.env.SUPABASE_SERVICE_ROLE_KEY
+)
+
+const sampleDocuments = [
+  {
+    namespace: '{{packageName}}',
+    category: 'getting-started',
+    content: 'Welcome to your AI-powered knowledge platform! This system uses RAG (Retrieval-Augmented Generation) to provide intelligent responses based on your knowledge base.',
+    fields: { title: 'Welcome Guide', difficulty: 'beginner' },
+    metadata: { featured: true, priority: 1 },
+    source: { type: 'seed', version: '1.0' }
+  },
+  {
+    namespace: '{{packageName}}',
+    category: 'features',
+    content: 'Key features include: AI chat with your documents, semantic search, knowledge management, real-time analytics, and seamless integration with your existing data.',
+    fields: { title: 'Platform Features', difficulty: 'beginner' },
+    metadata: { featured: true, priority: 2 },
+    source: { type: 'seed', version: '1.0' }
+  },
+  {
+    namespace: '{{packageName}}',
+    category: 'tutorials',
+    content: 'To add new knowledge: 1. Go to Knowledge Manager, 2. Click Add Document, 3. Fill in the content and metadata, 4. The system will automatically create embeddings for semantic search.',
+    fields: { title: 'Adding Knowledge Tutorial', difficulty: 'intermediate' },
+    metadata: { tutorial: true, priority: 3 },
+    source: { type: 'seed', version: '1.0' }
+  }
+]
+
+async function seedKnowledge() {
+  console.log('🌱 Seeding knowledge base...')
+  
+  try {
+    for (const doc of sampleDocuments) {
+      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('🎉 Knowledge base seeded successfully!')
+    console.log('📝 Next steps:')
+    console.log('   1. Run: npm run dev')
+    console.log('   2. Visit: http://localhost:3000/ai')
+    console.log('   3. Start chatting with your knowledge base!')
+    
+  } catch (error) {
+    console.error('❌ Seeding failed:', error)
+    process.exit(1)
+  }
+}
+
+seedKnowledge()
+`
+
+  fs.writeFileSync('scripts/seed-knowledge.js', seedScript)
+  fs.chmodSync('scripts/seed-knowledge.js', 0o755)
+  success('Created seed script')
+
+  // Update 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-knowledge.js',
+      'db:types': 'supabase gen types --local > types/supabase.ts',
+      'db:reset': 'supabase db reset',
+      'db:push': 'supabase db push'
+    }
+    
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+    success('Updated package.json scripts')
+  }
+}
+
+function displayNextSteps() {
+  step(6, 'Setup complete! Next steps')
+  
+  log('\n🎉 RAG Knowledge System setup complete!\n', 'green')
+  
+  log('📋 Next steps:', 'cyan')
+  log('   1. Update your .env.local with actual API keys')
+  log('   2. Ensure your Supabase database is running')
+  log('   3. Run the seed script: npm run seed:knowledge')
+  log('   4. Start your development server: npm run dev')
+  log('   5. Visit /ai to test your RAG system')
+  
+  log('\n🔧 Available commands:', 'cyan')
+  log('   npm run setup:rag      - Run this setup script')
+  log('   npm run seed:knowledge - Add sample knowledge documents')
+  log('   npm run db:types       - Generate TypeScript types')
+  log('   npm run db:reset       - Reset and migrate database')
+  log('   npm run db:push        - Push migrations to remote')
+  
+  log('\n📚 Documentation:', 'cyan')
+  log('   • RAG Configuration: lib/rag/config.ts')
+  log('   • React Hook: hooks/useRAGSystem.ts')
+  log('   • Components: components/rag/')
+  log('   • Database: supabase/migrations/')
+  
+  log('\n💡 Tips:', 'yellow')
+  log('   • Customize domain in lib/rag/config.ts')
+  log('   • Add your own knowledge via the web interface')
+  log('   • Monitor usage in the Analytics dashboard')
+  log('   • Check system health in the AI dashboard')
+  
+  log('\n🚀 Happy building with RAG!', 'green')
+}
+
+// Main execution
+async function main() {
+  try {
+    checkRequirements()
+    checkEnvironmentVariables()
+    setupDatabaseMigrations()
+    generateTypes()
+    createConfigFiles()
+    displayNextSteps()
+  } catch (err) {
+    error(`Setup failed: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+main()
+`