myavana-bot-test-core 2.0.6 → 2.0.7

package/migrations/003_sienna_naturals_enhancements.sql

@@ -0,0 +1,305 @@
+-- Migration 003: Sienna Naturals Enhancements and Optimizations
+-- Extends the database schema with Sienna Naturals specific tables and optimizations
+-- Run this after 001_add_analytics_tables.sql and 002_add_advanced_features_tables.sql
+
+-- Sienna Naturals specific brand tracking
+CREATE TABLE IF NOT EXISTS brand_interactions (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255) NOT NULL,
+    conversation_id VARCHAR(255),
+    brand_name VARCHAR(100) NOT NULL, -- 'sienna_naturals', 'myavana', etc.
+    interaction_type VARCHAR(100), -- product_inquiry, store_locator, discount_request
+    interaction_data JSONB,
+    user_satisfaction INTEGER,
+    created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Store locator requests (Sienna Naturals specific)
+CREATE TABLE IF NOT EXISTS store_locator_requests (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255) NOT NULL,
+    location_query VARCHAR(255),
+    user_location JSONB, -- {city, state, zip, coordinates if available}
+    stores_found INTEGER DEFAULT 0,
+    stores_data JSONB, -- array of store information returned
+    created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Product availability tracking by brand
+CREATE TABLE IF NOT EXISTS product_availability_tracking (
+    id SERIAL PRIMARY KEY,
+    brand_name VARCHAR(100) NOT NULL,
+    product_name VARCHAR(255) NOT NULL,
+    availability_status VARCHAR(50) DEFAULT 'available', -- available, out_of_stock, discontinued
+    inventory_level VARCHAR(50), -- high, medium, low
+    last_checked TIMESTAMP DEFAULT NOW(),
+    notifications_sent INTEGER DEFAULT 0,
+    UNIQUE(brand_name, product_name)
+);
+
+-- Enhanced circuit breaker states for AI models
+CREATE TABLE IF NOT EXISTS circuit_breaker_states (
+    id SERIAL PRIMARY KEY,
+    model_name VARCHAR(100) NOT NULL UNIQUE,
+    state VARCHAR(20) DEFAULT 'closed', -- closed, open, half_open
+    failure_count INTEGER DEFAULT 0,
+    last_failure_time TIMESTAMP,
+    last_success_time TIMESTAMP,
+    threshold_failures INTEGER DEFAULT 5,
+    timeout_duration INTERVAL DEFAULT '5 minutes',
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Response caching with brand-specific keys
+CREATE TABLE IF NOT EXISTS response_cache (
+    id SERIAL PRIMARY KEY,
+    cache_key VARCHAR(512) NOT NULL UNIQUE, -- hash of query + user context + brand
+    brand_name VARCHAR(100),
+    cached_response JSONB NOT NULL,
+    user_context_hash VARCHAR(64), -- hash of user profile for personalization
+    query_hash VARCHAR(64), -- hash of the query
+    context_analysis JSONB, -- context analysis data
+    hit_count INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT NOW(),
+    expires_at TIMESTAMP DEFAULT NOW() + INTERVAL '24 hours'
+);
+
+-- Smart prompt analytics
+CREATE TABLE IF NOT EXISTS smart_prompt_analytics (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255) NOT NULL,
+    conversation_id VARCHAR(255),
+    brand_name VARCHAR(100),
+    query_analysis JSONB, -- topics, intent, complexity
+    prompt_strategy VARCHAR(100), -- educational, sales, support, etc.
+    context_elements_used JSONB, -- faqs, products, previous_conversations
+    prompt_length INTEGER,
+    response_quality_score FLOAT, -- 0-1 based on user engagement
+    created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- User engagement patterns
+CREATE TABLE IF NOT EXISTS user_engagement_patterns (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255) NOT NULL UNIQUE,
+    brand_name VARCHAR(100),
+    total_interactions INTEGER DEFAULT 0,
+    avg_session_duration INTERVAL,
+    preferred_interaction_time TIME,
+    preferred_day_of_week INTEGER, -- 0-6, 0=Sunday
+    response_style_preference VARCHAR(100), -- detailed, concise, visual, etc.
+    topic_preferences JSONB, -- array of preferred topics
+    engagement_score FLOAT DEFAULT 0, -- 0-1 based on overall engagement
+    last_interaction TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Model performance benchmarks
+CREATE TABLE IF NOT EXISTS model_performance_benchmarks (
+    id SERIAL PRIMARY KEY,
+    model_name VARCHAR(100) NOT NULL,
+    brand_name VARCHAR(100),
+    benchmark_type VARCHAR(100), -- response_time, accuracy, user_satisfaction
+    benchmark_value FLOAT,
+    sample_size INTEGER,
+    measurement_date DATE DEFAULT CURRENT_DATE,
+    measurement_context JSONB, -- conditions during measurement
+    UNIQUE(model_name, brand_name, benchmark_type, measurement_date)
+);
+
+-- Advanced indexes for performance
+CREATE INDEX IF NOT EXISTS idx_brand_interactions_user_brand ON brand_interactions(user_id, brand_name, created_at);
+CREATE INDEX IF NOT EXISTS idx_store_locator_location ON store_locator_requests(user_location);
+CREATE INDEX IF NOT EXISTS idx_response_cache_key ON response_cache(cache_key, expires_at) WHERE expires_at > NOW();
+CREATE INDEX IF NOT EXISTS idx_response_cache_brand_context ON response_cache(brand_name, user_context_hash) WHERE expires_at > NOW();
+CREATE INDEX IF NOT EXISTS idx_smart_prompt_user_brand ON smart_prompt_analytics(user_id, brand_name, created_at);
+CREATE INDEX IF NOT EXISTS idx_user_engagement_brand ON user_engagement_patterns(brand_name, engagement_score DESC);
+CREATE INDEX IF NOT EXISTS idx_circuit_breaker_model ON circuit_breaker_states(model_name, state);
+
+-- Composite indexes for common query patterns
+CREATE INDEX IF NOT EXISTS idx_conversation_metrics_composite ON conversation_metrics(user_id, ai_model_used, created_at);
+CREATE INDEX IF NOT EXISTS idx_user_journey_composite ON user_journey_events(user_id, event_type, hair_journey_stage, created_at);
+CREATE INDEX IF NOT EXISTS idx_error_logs_composite ON error_logs(model_name, error_type, recovery_successful, created_at);
+
+-- Partitioning preparation (for high-volume tables)
+-- Note: These are preparation steps for future partitioning
+CREATE INDEX IF NOT EXISTS idx_conversation_metrics_created_monthly ON conversation_metrics(DATE_TRUNC('month', created_at));
+CREATE INDEX IF NOT EXISTS idx_user_journey_events_created_monthly ON user_journey_events(DATE_TRUNC('month', created_at));
+CREATE INDEX IF NOT EXISTS idx_error_logs_created_monthly ON error_logs(DATE_TRUNC('month', created_at));
+
+-- Views for Sienna Naturals specific analytics
+CREATE OR REPLACE VIEW sienna_naturals_user_stats AS
+SELECT 
+    DATE(created_at) as date,
+    COUNT(DISTINCT user_id) as unique_users,
+    COUNT(*) as total_interactions,
+    COUNT(CASE WHEN interaction_type = 'product_inquiry' THEN 1 END) as product_inquiries,
+    COUNT(CASE WHEN interaction_type = 'store_locator' THEN 1 END) as store_locator_requests,
+    COUNT(CASE WHEN interaction_type = 'discount_request' THEN 1 END) as discount_requests,
+    AVG(user_satisfaction) as avg_satisfaction
+FROM brand_interactions 
+WHERE brand_name = 'sienna_naturals'
+GROUP BY DATE(created_at)
+ORDER BY date DESC;
+
+CREATE OR REPLACE VIEW brand_performance_comparison AS
+SELECT 
+    brand_name,
+    COUNT(DISTINCT user_id) as unique_users,
+    COUNT(*) as total_interactions,
+    AVG(user_satisfaction) as avg_satisfaction,
+    COUNT(CASE WHEN user_satisfaction >= 4 THEN 1 END) as satisfied_interactions,
+    ROUND(
+        COUNT(CASE WHEN user_satisfaction >= 4 THEN 1 END)::float / 
+        COUNT(CASE WHEN user_satisfaction IS NOT NULL THEN 1 END) * 100, 2
+    ) as satisfaction_rate
+FROM brand_interactions 
+WHERE created_at >= CURRENT_DATE - INTERVAL '30 days'
+GROUP BY brand_name
+ORDER BY satisfaction_rate DESC;
+
+CREATE OR REPLACE VIEW cache_performance_stats AS
+SELECT 
+    brand_name,
+    COUNT(*) as total_cached_responses,
+    SUM(hit_count) as total_cache_hits,
+    COUNT(CASE WHEN expires_at > NOW() THEN 1 END) as active_cache_entries,
+    AVG(hit_count) as avg_hits_per_entry,
+    ROUND(
+        COUNT(CASE WHEN hit_count > 0 THEN 1 END)::float / 
+        COUNT(*) * 100, 2
+    ) as cache_utilization_rate
+FROM response_cache
+GROUP BY brand_name
+ORDER BY cache_utilization_rate DESC;
+
+CREATE OR REPLACE VIEW model_circuit_breaker_status AS
+SELECT 
+    model_name,
+    state,
+    failure_count,
+    last_failure_time,
+    last_success_time,
+    CASE 
+        WHEN state = 'open' AND last_failure_time + timeout_duration < NOW() THEN 'ready_for_half_open'
+        WHEN state = 'closed' AND failure_count >= threshold_failures THEN 'approaching_threshold'
+        ELSE 'normal'
+    END as status_indicator
+FROM circuit_breaker_states
+ORDER BY 
+    CASE state
+        WHEN 'open' THEN 1
+        WHEN 'half_open' THEN 2
+        WHEN 'closed' THEN 3
+    END,
+    failure_count DESC;
+
+-- Functions for automatic maintenance
+CREATE OR REPLACE FUNCTION cleanup_expired_cache()
+RETURNS INTEGER AS $$
+DECLARE
+    deleted_count INTEGER;
+BEGIN
+    DELETE FROM response_cache WHERE expires_at < NOW();
+    GET DIAGNOSTICS deleted_count = ROW_COUNT;
+    RETURN deleted_count;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION update_engagement_patterns()
+RETURNS VOID AS $$
+BEGIN
+    -- Update engagement scores based on recent activity
+    UPDATE user_engagement_patterns 
+    SET 
+        engagement_score = COALESCE((
+            SELECT 
+                CASE 
+                    WHEN AVG(user_satisfaction) >= 4.5 THEN 0.9
+                    WHEN AVG(user_satisfaction) >= 4.0 THEN 0.8
+                    WHEN AVG(user_satisfaction) >= 3.5 THEN 0.7
+                    WHEN AVG(user_satisfaction) >= 3.0 THEN 0.6
+                    ELSE 0.5
+                END
+            FROM brand_interactions bi 
+            WHERE bi.user_id = user_engagement_patterns.user_id
+            AND bi.created_at >= NOW() - INTERVAL '30 days'
+        ), 0.5),
+        total_interactions = COALESCE((
+            SELECT COUNT(*) 
+            FROM brand_interactions bi 
+            WHERE bi.user_id = user_engagement_patterns.user_id
+        ), 0),
+        last_interaction = COALESCE((
+            SELECT MAX(created_at) 
+            FROM brand_interactions bi 
+            WHERE bi.user_id = user_engagement_patterns.user_id
+        ), last_interaction),
+        updated_at = NOW();
+END;
+$$ LANGUAGE plpgsql;
+
+-- Triggers for automatic updates
+CREATE OR REPLACE FUNCTION update_user_engagement_on_interaction()
+RETURNS TRIGGER AS $$
+BEGIN
+    INSERT INTO user_engagement_patterns (user_id, brand_name, total_interactions, last_interaction)
+    VALUES (NEW.user_id, NEW.brand_name, 1, NEW.created_at)
+    ON CONFLICT (user_id) 
+    DO UPDATE SET 
+        total_interactions = user_engagement_patterns.total_interactions + 1,
+        last_interaction = NEW.created_at,
+        updated_at = NOW();
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS update_engagement_on_brand_interaction ON brand_interactions;
+CREATE TRIGGER update_engagement_on_brand_interaction
+    AFTER INSERT ON brand_interactions
+    FOR EACH ROW
+    EXECUTE FUNCTION update_user_engagement_on_interaction();
+
+-- Initialize circuit breaker states for known models
+INSERT INTO circuit_breaker_states (model_name, state, threshold_failures, timeout_duration)
+VALUES 
+    ('gemini20FlashExp', 'closed', 5, '5 minutes'),
+    ('gemini15Flash', 'closed', 5, '5 minutes'),
+    ('xai-grok-3-mini-fast', 'closed', 3, '10 minutes')
+ON CONFLICT (model_name) DO NOTHING;
+
+-- Create materialized views for expensive queries (refresh periodically)
+CREATE MATERIALIZED VIEW IF NOT EXISTS daily_brand_performance AS
+SELECT 
+    brand_name,
+    DATE(created_at) as date,
+    COUNT(DISTINCT user_id) as unique_users,
+    COUNT(*) as total_interactions,
+    AVG(user_satisfaction) as avg_satisfaction,
+    COUNT(CASE WHEN interaction_type = 'product_inquiry' THEN 1 END) as product_inquiries,
+    COUNT(CASE WHEN interaction_type = 'store_locator' THEN 1 END) as store_requests,
+    COUNT(CASE WHEN user_satisfaction >= 4 THEN 1 END) as satisfied_users
+FROM brand_interactions
+WHERE created_at >= CURRENT_DATE - INTERVAL '90 days'
+GROUP BY brand_name, DATE(created_at)
+ORDER BY date DESC, brand_name;
+
+-- Index on materialized view
+CREATE UNIQUE INDEX IF NOT EXISTS idx_daily_brand_performance_unique ON daily_brand_performance (brand_name, date);
+
+-- Comments for documentation
+COMMENT ON TABLE brand_interactions IS 'Tracks user interactions specific to each brand (Sienna Naturals, Myavana)';
+COMMENT ON TABLE store_locator_requests IS 'Tracks store locator requests for physical location recommendations';
+COMMENT ON TABLE response_cache IS 'Intelligent response caching with brand and user context';
+COMMENT ON TABLE circuit_breaker_states IS 'Circuit breaker states for AI model reliability';
+COMMENT ON TABLE smart_prompt_analytics IS 'Analytics for smart prompt generation effectiveness';
+COMMENT ON TABLE user_engagement_patterns IS 'User engagement patterns and preferences by brand';
+
+COMMENT ON FUNCTION cleanup_expired_cache() IS 'Removes expired cache entries, should be run periodically';
+COMMENT ON FUNCTION update_engagement_patterns() IS 'Updates user engagement scores based on recent activity';
+
+-- Grant permissions (adjust as needed for your setup)
+-- GRANT SELECT, INSERT, UPDATE ON ALL TABLES IN SCHEMA public TO your_app_user;
+-- GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO your_app_user;
+-- GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO your_app_user;

package/migrations/run_migrations.sql

@@ -0,0 +1,437 @@
+-- Complete Migration Runner Script
+-- Run this to apply all migrations in the correct order
+-- This script is safe to run multiple times (idempotent)
+
+-- Migration tracking table
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    id SERIAL PRIMARY KEY,
+    migration_name VARCHAR(255) NOT NULL UNIQUE,
+    applied_at TIMESTAMP DEFAULT NOW(),
+    checksum VARCHAR(64)
+);
+
+-- Check if migration has been applied
+CREATE OR REPLACE FUNCTION migration_applied(migration_name TEXT)
+RETURNS BOOLEAN AS $$
+BEGIN
+    RETURN EXISTS(SELECT 1 FROM schema_migrations WHERE schema_migrations.migration_name = migration_applied.migration_name);
+END;
+$$ LANGUAGE plpgsql;
+
+-- Apply migration if not already applied
+CREATE OR REPLACE FUNCTION apply_migration(migration_name TEXT, migration_checksum TEXT DEFAULT NULL)
+RETURNS VOID AS $$
+BEGIN
+    IF NOT migration_applied(migration_name) THEN
+        INSERT INTO schema_migrations (migration_name, checksum) 
+        VALUES (migration_name, migration_checksum);
+        RAISE NOTICE 'Applied migration: %', migration_name;
+    ELSE
+        RAISE NOTICE 'Migration already applied: %', migration_name;
+    END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Start migration process
+DO $$
+BEGIN
+    RAISE NOTICE 'Starting database migrations for Sienna Naturals Enhanced System...';
+    RAISE NOTICE 'Timestamp: %', NOW();
+END $$;
+
+-- Core tables (should already exist, but ensure they're there)
+CREATE TABLE IF NOT EXISTS users (
+    user_id VARCHAR(255) PRIMARY KEY,
+    name VARCHAR(255),
+    hair_type VARCHAR(100),
+    hair_concerns TEXT[],
+    location VARCHAR(255),
+    brand_preference VARCHAR(100) DEFAULT 'myavana',
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS conversations (
+    id SERIAL PRIMARY KEY,
+    conversation_id VARCHAR(255) UNIQUE NOT NULL,
+    user_id VARCHAR(255) REFERENCES users(user_id),
+    chat_history JSONB,
+    summary TEXT,
+    brand VARCHAR(100) DEFAULT 'myavana',
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id VARCHAR(255) PRIMARY KEY,
+    user_id VARCHAR(255),
+    session_data JSONB,
+    brand VARCHAR(100),
+    last_accessed_at TIMESTAMP DEFAULT NOW(),
+    expires_at TIMESTAMP DEFAULT NOW() + INTERVAL '7 days'
+);
+
+-- Core indexes
+CREATE INDEX IF NOT EXISTS idx_users_brand_created ON users(brand_preference, created_at);
+CREATE INDEX IF NOT EXISTS idx_conversations_user_brand ON conversations(user_id, brand, created_at);
+CREATE INDEX IF NOT EXISTS idx_sessions_user_expires ON sessions(user_id, expires_at);
+
+SELECT apply_migration('000_core_tables');
+
+-- Migration 001: Analytics Tables
+DO $$
+BEGIN
+    IF NOT migration_applied('001_add_analytics_tables') THEN
+        RAISE NOTICE 'Applying Migration 001: Analytics Tables...';
+        
+        -- All the analytics tables from 001_add_analytics_tables.sql
+        CREATE TABLE IF NOT EXISTS prompt_analytics (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            query_type VARCHAR(100),
+            topics_detected JSONB,
+            prompt_length INTEGER,
+            faqs_used INTEGER,
+            products_used INTEGER,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS conversation_metrics (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            conversation_id VARCHAR(255) NOT NULL,
+            message_count INTEGER DEFAULT 0,
+            ai_model_used VARCHAR(100),
+            response_time_ms INTEGER,
+            user_satisfaction INTEGER,
+            conversion_event VARCHAR(100),
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS user_journey_events (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            event_type VARCHAR(100) NOT NULL,
+            event_data JSONB,
+            hair_journey_stage VARCHAR(100),
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS ai_model_performance (
+            id SERIAL PRIMARY KEY,
+            model_name VARCHAR(100) NOT NULL,
+            request_count INTEGER DEFAULT 1,
+            success_count INTEGER DEFAULT 0,
+            failure_count INTEGER DEFAULT 0,
+            avg_response_time_ms FLOAT,
+            date_tracked DATE DEFAULT CURRENT_DATE,
+            UNIQUE(model_name, date_tracked)
+        );
+
+        CREATE TABLE IF NOT EXISTS cache_analytics (
+            id SERIAL PRIMARY KEY,
+            cache_type VARCHAR(100) NOT NULL,
+            hit_count INTEGER DEFAULT 0,
+            miss_count INTEGER DEFAULT 0,
+            cache_key_pattern VARCHAR(255),
+            date_tracked DATE DEFAULT CURRENT_DATE,
+            UNIQUE(cache_type, cache_key_pattern, date_tracked)
+        );
+
+        -- Indexes
+        CREATE INDEX IF NOT EXISTS idx_prompt_analytics_user_created ON prompt_analytics(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_conversation_metrics_user ON conversation_metrics(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_user_journey_events_user ON user_journey_events(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_ai_model_performance_date ON ai_model_performance(date_tracked);
+
+        -- Views
+        CREATE OR REPLACE VIEW daily_conversation_stats AS
+        SELECT 
+            DATE(created_at) as date,
+            COUNT(DISTINCT user_id) as unique_users,
+            COUNT(*) as total_conversations,
+            AVG(message_count) as avg_messages_per_conversation,
+            COUNT(CASE WHEN conversion_event IS NOT NULL THEN 1 END) as conversions
+        FROM conversation_metrics 
+        GROUP BY DATE(created_at)
+        ORDER BY date DESC;
+
+        CREATE OR REPLACE VIEW model_reliability_stats AS
+        SELECT 
+            model_name,
+            SUM(request_count) as total_requests,
+            SUM(success_count) as total_successes,
+            SUM(failure_count) as total_failures,
+            ROUND((SUM(success_count)::float / SUM(request_count)::float * 100), 2) as success_rate,
+            ROUND(AVG(avg_response_time_ms), 2) as avg_response_time
+        FROM ai_model_performance 
+        WHERE date_tracked >= CURRENT_DATE - INTERVAL '30 days'
+        GROUP BY model_name;
+
+        SELECT apply_migration('001_add_analytics_tables');
+    END IF;
+END $$;
+
+-- Migration 002: Advanced Features
+DO $$
+BEGIN
+    IF NOT migration_applied('002_add_advanced_features_tables') THEN
+        RAISE NOTICE 'Applying Migration 002: Advanced Features Tables...';
+        
+        -- All tables from 002_add_advanced_features_tables.sql
+        CREATE TABLE IF NOT EXISTS error_logs (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            conversation_id VARCHAR(255),
+            error_type VARCHAR(100) NOT NULL,
+            error_message TEXT,
+            model_name VARCHAR(100),
+            context_data JSONB,
+            recovery_attempted BOOLEAN DEFAULT FALSE,
+            recovery_successful BOOLEAN DEFAULT FALSE,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS personalization_metrics (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            persona_assigned VARCHAR(100),
+            query_length INTEGER,
+            response_length INTEGER,
+            personalization_applied BOOLEAN DEFAULT FALSE,
+            user_satisfaction_score INTEGER,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS user_preferences (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL UNIQUE,
+            persona_type VARCHAR(100),
+            communication_style VARCHAR(100),
+            preferred_response_format VARCHAR(100),
+            hair_priorities JSONB,
+            product_preferences JSONB,
+            engagement_preferences JSONB,
+            created_at TIMESTAMP DEFAULT NOW(),
+            updated_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS proactive_campaigns (
+            id SERIAL PRIMARY KEY,
+            campaign_name VARCHAR(255) NOT NULL,
+            campaign_type VARCHAR(100) NOT NULL,
+            target_persona VARCHAR(100),
+            trigger_conditions JSONB,
+            message_template JSONB,
+            active BOOLEAN DEFAULT TRUE,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS proactive_engagement_schedule (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            trigger_type VARCHAR(100) NOT NULL,
+            scheduled_time TIMESTAMP NOT NULL,
+            context_data JSONB,
+            sent BOOLEAN DEFAULT FALSE,
+            sent_at TIMESTAMP,
+            active BOOLEAN DEFAULT TRUE,
+            created_at TIMESTAMP DEFAULT NOW(),
+            UNIQUE(user_id, trigger_type)
+        );
+
+        CREATE TABLE IF NOT EXISTS proactive_engagement_history (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            campaign_id INTEGER REFERENCES proactive_campaigns(id),
+            message_sent JSONB,
+            delivery_status VARCHAR(50) DEFAULT 'pending',
+            user_response TEXT,
+            engagement_score FLOAT,
+            created_at TIMESTAMP DEFAULT NOW(),
+            responded_at TIMESTAMP
+        );
+
+        CREATE TABLE IF NOT EXISTS hair_issues (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            issue_description TEXT NOT NULL,
+            severity_level INTEGER,
+            issue_category VARCHAR(100),
+            reported_context TEXT,
+            resolution_status VARCHAR(50) DEFAULT 'open',
+            resolution_notes TEXT,
+            created_at TIMESTAMP DEFAULT NOW(),
+            resolved_at TIMESTAMP
+        );
+
+        -- Indexes
+        CREATE INDEX IF NOT EXISTS idx_error_logs_user_created ON error_logs(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_error_logs_type_model ON error_logs(error_type, model_name);
+        CREATE INDEX IF NOT EXISTS idx_personalization_metrics_user ON personalization_metrics(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_user_preferences_user ON user_preferences(user_id);
+        CREATE INDEX IF NOT EXISTS idx_proactive_engagement_user ON proactive_engagement_history(user_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_hair_issues_user_status ON hair_issues(user_id, resolution_status);
+
+        -- Update trigger for user_preferences
+        CREATE OR REPLACE FUNCTION update_user_preferences_updated_at()
+        RETURNS TRIGGER AS $func$
+        BEGIN
+            NEW.updated_at = NOW();
+            RETURN NEW;
+        END;
+        $func$ LANGUAGE plpgsql;
+
+        DROP TRIGGER IF EXISTS update_user_preferences_updated_at_trigger ON user_preferences;
+        CREATE TRIGGER update_user_preferences_updated_at_trigger
+            BEFORE UPDATE ON user_preferences
+            FOR EACH ROW
+            EXECUTE FUNCTION update_user_preferences_updated_at();
+
+        SELECT apply_migration('002_add_advanced_features_tables');
+    END IF;
+END $$;
+
+-- Migration 003: Sienna Naturals Enhancements
+DO $$
+BEGIN
+    IF NOT migration_applied('003_sienna_naturals_enhancements') THEN
+        RAISE NOTICE 'Applying Migration 003: Sienna Naturals Enhancements...';
+        
+        -- Brand-specific tables
+        CREATE TABLE IF NOT EXISTS brand_interactions (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            conversation_id VARCHAR(255),
+            brand_name VARCHAR(100) NOT NULL,
+            interaction_type VARCHAR(100),
+            interaction_data JSONB,
+            user_satisfaction INTEGER,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS store_locator_requests (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL,
+            location_query VARCHAR(255),
+            user_location JSONB,
+            stores_found INTEGER DEFAULT 0,
+            stores_data JSONB,
+            created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS circuit_breaker_states (
+            id SERIAL PRIMARY KEY,
+            model_name VARCHAR(100) NOT NULL UNIQUE,
+            state VARCHAR(20) DEFAULT 'closed',
+            failure_count INTEGER DEFAULT 0,
+            last_failure_time TIMESTAMP,
+            last_success_time TIMESTAMP,
+            threshold_failures INTEGER DEFAULT 5,
+            timeout_duration INTERVAL DEFAULT '5 minutes',
+            updated_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE TABLE IF NOT EXISTS response_cache (
+            id SERIAL PRIMARY KEY,
+            cache_key VARCHAR(512) NOT NULL UNIQUE,
+            brand_name VARCHAR(100),
+            cached_response JSONB NOT NULL,
+            user_context_hash VARCHAR(64),
+            query_hash VARCHAR(64),
+            context_analysis JSONB,
+            hit_count INTEGER DEFAULT 0,
+            created_at TIMESTAMP DEFAULT NOW(),
+            expires_at TIMESTAMP DEFAULT NOW() + INTERVAL '24 hours'
+        );
+
+        CREATE TABLE IF NOT EXISTS user_engagement_patterns (
+            id SERIAL PRIMARY KEY,
+            user_id VARCHAR(255) NOT NULL UNIQUE,
+            brand_name VARCHAR(100),
+            total_interactions INTEGER DEFAULT 0,
+            avg_session_duration INTERVAL,
+            preferred_interaction_time TIME,
+            preferred_day_of_week INTEGER,
+            response_style_preference VARCHAR(100),
+            topic_preferences JSONB,
+            engagement_score FLOAT DEFAULT 0,
+            last_interaction TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT NOW()
+        );
+
+        -- Indexes
+        CREATE INDEX IF NOT EXISTS idx_brand_interactions_user_brand ON brand_interactions(user_id, brand_name, created_at);
+        CREATE INDEX IF NOT EXISTS idx_response_cache_key ON response_cache(cache_key, expires_at) WHERE expires_at > NOW();
+        CREATE INDEX IF NOT EXISTS idx_circuit_breaker_model ON circuit_breaker_states(model_name, state);
+        CREATE INDEX IF NOT EXISTS idx_user_engagement_brand ON user_engagement_patterns(brand_name, engagement_score DESC);
+
+        -- Initialize circuit breaker states
+        INSERT INTO circuit_breaker_states (model_name, state, threshold_failures, timeout_duration)
+        VALUES 
+            ('gemini20FlashExp', 'closed', 5, '5 minutes'),
+            ('gemini15Flash', 'closed', 5, '5 minutes'),
+            ('xai-grok-3-mini-fast', 'closed', 3, '10 minutes')
+        ON CONFLICT (model_name) DO NOTHING;
+
+        -- Trigger for engagement patterns
+        CREATE OR REPLACE FUNCTION update_user_engagement_on_interaction()
+        RETURNS TRIGGER AS $func$
+        BEGIN
+            INSERT INTO user_engagement_patterns (user_id, brand_name, total_interactions, last_interaction)
+            VALUES (NEW.user_id, NEW.brand_name, 1, NEW.created_at)
+            ON CONFLICT (user_id) 
+            DO UPDATE SET 
+                total_interactions = user_engagement_patterns.total_interactions + 1,
+                last_interaction = NEW.created_at,
+                updated_at = NOW();
+            
+            RETURN NEW;
+        END;
+        $func$ LANGUAGE plpgsql;
+
+        DROP TRIGGER IF EXISTS update_engagement_on_brand_interaction ON brand_interactions;
+        CREATE TRIGGER update_engagement_on_brand_interaction
+            AFTER INSERT ON brand_interactions
+            FOR EACH ROW
+            EXECUTE FUNCTION update_user_engagement_on_interaction();
+
+        SELECT apply_migration('003_sienna_naturals_enhancements');
+    END IF;
+END $$;
+
+-- Final cleanup and optimization
+DO $$
+BEGIN
+    RAISE NOTICE 'Running post-migration optimizations...';
+    
+    -- Update statistics
+    ANALYZE;
+    
+    -- Clean up any expired cache entries
+    DELETE FROM response_cache WHERE expires_at < NOW();
+    
+    RAISE NOTICE 'All migrations completed successfully!';
+    RAISE NOTICE 'Database is now ready for Sienna Naturals Enhanced System';
+    
+    -- Show migration status
+    RAISE NOTICE 'Applied migrations:';
+    FOR rec IN SELECT migration_name, applied_at FROM schema_migrations ORDER BY applied_at LOOP
+        RAISE NOTICE '  - % (applied: %)', rec.migration_name, rec.applied_at;
+    END LOOP;
+END $$;
+
+-- Verification queries
+SELECT 'Migration Status' as info;
+SELECT migration_name, applied_at FROM schema_migrations ORDER BY applied_at;
+
+SELECT 'Table Counts' as info;
+SELECT 
+    schemaname as schema,
+    tablename as table_name,
+    n_tup_ins as inserts,
+    n_tup_upd as updates,
+    n_tup_del as deletes
+FROM pg_stat_user_tables 
+WHERE schemaname = 'public'
+ORDER BY tablename;

package/package.json

@@ -1,37 +1,37 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.0.6",
+    "version": "2.0.7",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {
-      "test": "jest",
-      "test:watch": "jest --watch",
-      "test:coverage": "jest --coverage",
-      "lint": "eslint src/",
-      "lint:fix": "eslint src/ --fix"
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        "lint": "eslint src/",
+        "lint:fix": "eslint src/ --fix"
     },
     "dependencies": {
-      "@genkit-ai/googleai": "^0.9.12",
-      "dotenv": "^16.4.7",
-      "genkit": "^0.9.12",
-      "pg": "^8.13.1",
-      "redis": "^4.7.0",
-      "winston": "^3.11.0",
-      "joi": "^17.11.0",
-      "isomorphic-dompurify": "^2.9.0",
-      "express-rate-limit": "^7.1.5",
-      "express-slow-down": "^2.0.1",
-      "node-cache": "^5.1.2",
-      "uuid": "^9.0.1"
+        "@genkit-ai/googleai": "^0.9.12",
+        "dotenv": "^16.4.7",
+        "express-rate-limit": "^7.1.5",
+        "express-slow-down": "^2.0.1",
+        "genkit": "^0.9.12",
+        "isomorphic-dompurify": "^2.9.0",
+        "joi": "^17.11.0",
+        "node-cache": "^5.1.2",
+        "pg": "^8.13.1",
+        "redis": "^4.7.0",
+        "uuid": "^9.0.1",
+        "winston": "^3.11.0"
     },
     "devDependencies": {
-      "jest": "^29.7.0",
-      "babel-jest": "^29.7.0",
-      "@babel/preset-env": "^7.23.6",
-      "eslint": "^8.56.0",
-      "supertest": "^6.3.3"
+        "@babel/preset-env": "^7.23.6",
+        "babel-jest": "^29.7.0",
+        "eslint": "^8.56.0",
+        "jest": "^29.7.0",
+        "supertest": "^6.3.3"
     },
     "engines": {
-      "node": ">=18.0.0"
+        "node": ">=18.0.0"
     }
-  }
+}

package/src/ai.js

@@ -1,13 +1,13 @@
 // ai.js
 const { genkit } = require('genkit');
-const { googleAI, gemini15Flash, gemini20FlashExp } = require('@genkit-ai/googleai');
+const { googleAI, gemini15Flash, gemini20FlashExp, gemini } = require('@genkit-ai/googleai');
 const config = require('./config');
 
 const ai = genkit({
     plugins: [googleAI({
         apiKey: config.genkitApiKey,
     })],
-    model: gemini20FlashExp,
+    model: gemini('gemini-3-flash-preview'),
 });
 
 module.exports = ai;

package/src/conversation.js

@@ -1,7 +1,7 @@
 // conversation.js
 const { pgClient, redisClient } = require('./database');
 const ai = require('./ai');
-const {gemini15Flash} = require("@genkit-ai/googleai");
+const {gemini15Flash, gemini} = require("@genkit-ai/googleai");
 
 const saveConversationSummary = async (conversationId, userId, summary) => {
     const query = `
@@ -28,7 +28,7 @@ const generateConversationSummary = async (chatHistory) => {
     }
     const summaryPrompt = `Summarize the following conversation, getting all important information, especially the user's hair details, name, and location: ${JSON.stringify(chatHistory)}`;
     const { text } = await ai.chat({
-        model: gemini15Flash,
+        model: gemini('gemini-2.5-flash'),
         system: summaryPrompt,
     });
     return text;

package/src/postResponseProcessing.js

@@ -1,6 +1,6 @@
 // postResponseProcessing.js
 const ai = require("./ai");
-const {gemini15Flash} = require("@genkit-ai/googleai");
+const {gemini15Flash, gemini} = require("@genkit-ai/googleai");
 const DatabaseSessionStore = require("./session");
 const { pgClient, redisClient } = require('./database');
 const {generateAndSaveSummary, saveConversationSummary, saveConversation} = require("./conversation");
@@ -226,7 +226,7 @@ const postProcessConversation = async (chatHistory, message) => {
     //console.log('Extraction prompt: ', extractionPrompt);
     try {
         const chat = ai.chat({
-            model: gemini15Flash,
+            model: gemini('gemini-2.5-flash'),
             config: {
                 temperature: 1.1,
             },
@@ -385,7 +385,7 @@ const postResponseProductCheck = async (chatHistory, message) => {
     // Try Gemini first
     try {
         const chat = ai.chat({
-            model: gemini15Flash, // or gemini20FlashExp
+            model: gemini('gemini-2.5-flash'), // or gemini20FlashExp
             config: {
                 temperature: 0.3, // Reduced temperature for more consistent JSON formatting
             },

package/src/unifiedChatHandler.js

@@ -1,6 +1,6 @@
 // unifiedChatHandler.js - Fixed version with proper model prioritization
 const { genkit, z } = require('genkit');
-const { gemini15Flash, gemini15Pro, gemini20FlashExp } = require('@genkit-ai/googleai');
+const { gemini15Flash, gemini15Pro, gemini20FlashExp, gemini } = require('@genkit-ai/googleai');
 
 class UnifiedChatHandler {
     constructor(config) {
@@ -17,9 +17,9 @@ class UnifiedChatHandler {
         
         // Initialize model priority list - GEMINI FIRST!
         this.modelPriority = [
-            { name: 'gemini20FlashExp', model: gemini20FlashExp, type: 'primary' },
-            { name: 'gemini15Flash', model: gemini15Flash, type: 'primary' },
-            { name: 'gemini15Pro', model: gemini15Pro, type: 'backup' }
+            { name: 'gemini20FlashExp', model: gemini('gemini-3-flash-preview'), type: 'primary' },
+            { name: 'gemini15Flash', model: gemini('gemini-2.5-flash'), type: 'primary' },
+            { name: 'gemini15Pro', model: gemini('gemini-3-pro-preview'), type: 'backup' }
         ];
 
         // Only initialize xAI as last resort if API key exists