rack-ai 0.1.0

data/lib/rack/ai/features/caching.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "redis"
+require "json"
+
+module Rack
+  module AI
+    module Features
+      class Caching
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :caching
+          @provider = provider
+          @config = config
+          @redis = build_redis_client if @config.config.caching.predictive_enabled
+        end
+
+        def enabled?
+          @config.feature_enabled?(:caching) && @config.config.cache_enabled
+        end
+
+        def process_response?
+          true
+        end
+
+        def process_request(env)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          cache_key = generate_cache_key(env)
+          
+          # Check if we have cached AI analysis for this request pattern
+          cached_result = get_cached_analysis(cache_key)
+          if cached_result
+            return {
+              cache_hit: true,
+              cached_result: cached_result,
+              feature: @name,
+              timestamp: Time.now.iso8601
+            }
+          end
+
+          # Analyze request patterns for predictive caching
+          request_pattern = extract_request_pattern(env)
+          pattern_analysis = analyze_access_patterns(request_pattern)
+          
+          result = {
+            cache_hit: false,
+            pattern_analysis: pattern_analysis,
+            should_prefetch: should_prefetch?(pattern_analysis),
+            feature: @name,
+            timestamp: Time.now.iso8601
+          }
+
+          # Store analysis for future use
+          cache_analysis(cache_key, result)
+          
+          # Trigger prefetching if recommended
+          if result[:should_prefetch]
+            schedule_prefetch(request_pattern)
+          end
+
+          result
+        end
+
+        def process_response(env, status, headers, body)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # Analyze response for caching recommendations
+          response_analysis = analyze_response_cachability(env, status, headers, body)
+          
+          # Update access patterns
+          update_access_patterns(env, status)
+
+          {
+            response_analysis: response_analysis,
+            feature: "#{@name}_response",
+            timestamp: Time.now.iso8601
+          }
+        end
+
+        private
+
+        def build_redis_client
+          Redis.new(url: @config.config.caching.redis_url)
+        rescue => e
+          Utils::Logger.warn("Failed to connect to Redis for caching", error: e.message)
+          nil
+        end
+
+        def generate_cache_key(env)
+          path = env["PATH_INFO"]
+          method = env["REQUEST_METHOD"]
+          query = env["QUERY_STRING"]
+          user_agent_hash = Digest::MD5.hexdigest(env["HTTP_USER_AGENT"] || "")
+          
+          "rack_ai:cache:#{method}:#{path}:#{Digest::MD5.hexdigest(query)}:#{user_agent_hash}"
+        end
+
+        def get_cached_analysis(cache_key)
+          return nil unless @redis
+
+          cached = @redis.get(cache_key)
+          cached ? JSON.parse(cached) : nil
+        rescue => e
+          Utils::Logger.warn("Cache read error", error: e.message, key: cache_key)
+          nil
+        end
+
+        def cache_analysis(cache_key, result)
+          return unless @redis
+
+          @redis.setex(cache_key, @config.config.cache_ttl, result.to_json)
+        rescue => e
+          Utils::Logger.warn("Cache write error", error: e.message, key: cache_key)
+        end
+
+        def extract_request_pattern(env)
+          {
+            path: env["PATH_INFO"],
+            method: env["REQUEST_METHOD"],
+            user_agent: env["HTTP_USER_AGENT"],
+            referer: env["HTTP_REFERER"],
+            timestamp: Time.now.to_i,
+            hour: Time.now.hour,
+            day_of_week: Time.now.wday
+          }
+        end
+
+        def analyze_access_patterns(pattern)
+          return { confidence: 0.0, patterns: [] } unless @redis
+
+          # Get recent access patterns for this path
+          pattern_key = "rack_ai:patterns:#{pattern[:path]}"
+          recent_accesses = @redis.lrange(pattern_key, 0, 99)
+          
+          return { confidence: 0.0, patterns: [] } if recent_accesses.empty?
+
+          # Analyze patterns
+          access_data = recent_accesses.map { |data| JSON.parse(data) }
+          
+          {
+            confidence: calculate_pattern_confidence(access_data),
+            patterns: identify_patterns(access_data),
+            frequency: calculate_frequency(access_data),
+            peak_hours: identify_peak_hours(access_data)
+          }
+        rescue => e
+          Utils::Logger.warn("Pattern analysis error", error: e.message)
+          { confidence: 0.0, patterns: [] }
+        end
+
+        def should_prefetch?(pattern_analysis)
+          return false unless pattern_analysis[:confidence]
+          
+          confidence_threshold = @config.config.caching.prefetch_threshold
+          pattern_analysis[:confidence] > confidence_threshold
+        end
+
+        def schedule_prefetch(request_pattern)
+          # In a real implementation, this would queue prefetch jobs
+          Utils::Logger.info("Prefetch scheduled", pattern: request_pattern[:path])
+        end
+
+        def analyze_response_cachability(env, status, headers, body)
+          cacheable = determine_cachability(status, headers)
+          content_type = headers["Content-Type"] || ""
+          
+          {
+            cacheable: cacheable,
+            content_type: content_type,
+            status: status,
+            has_cache_headers: has_cache_control_headers?(headers),
+            recommended_ttl: recommend_ttl(content_type, status)
+          }
+        end
+
+        def update_access_patterns(env, status)
+          return unless @redis
+
+          pattern_key = "rack_ai:patterns:#{env['PATH_INFO']}"
+          access_data = {
+            timestamp: Time.now.to_i,
+            status: status,
+            method: env["REQUEST_METHOD"],
+            user_agent: env["HTTP_USER_AGENT"],
+            hour: Time.now.hour,
+            day_of_week: Time.now.wday
+          }
+
+          @redis.lpush(pattern_key, access_data.to_json)
+          @redis.ltrim(pattern_key, 0, 999) # Keep last 1000 accesses
+          @redis.expire(pattern_key, 86400 * 7) # Expire after 7 days
+        rescue => e
+          Utils::Logger.warn("Pattern update error", error: e.message)
+        end
+
+        def calculate_pattern_confidence(access_data)
+          return 0.0 if access_data.size < 5
+
+          # Simple confidence based on access frequency and regularity
+          time_intervals = access_data.each_cons(2).map do |curr, prev|
+            curr["timestamp"] - prev["timestamp"]
+          end
+
+          return 0.0 if time_intervals.empty?
+
+          # Calculate coefficient of variation (lower = more regular)
+          mean_interval = time_intervals.sum.to_f / time_intervals.size
+          variance = time_intervals.map { |i| (i - mean_interval) ** 2 }.sum / time_intervals.size
+          cv = Math.sqrt(variance) / mean_interval
+
+          # Convert to confidence (0-1, where lower CV = higher confidence)
+          [1.0 - (cv / 2.0), 0.0].max
+        end
+
+        def identify_patterns(access_data)
+          patterns = []
+          
+          # Check for hourly patterns
+          hourly_counts = access_data.group_by { |d| d["hour"] }.transform_values(&:count)
+          if hourly_counts.values.max > hourly_counts.values.min * 2
+            patterns << "hourly_variation"
+          end
+
+          # Check for daily patterns
+          daily_counts = access_data.group_by { |d| d["day_of_week"] }.transform_values(&:count)
+          if daily_counts.values.max > daily_counts.values.min * 2
+            patterns << "daily_variation"
+          end
+
+          patterns
+        end
+
+        def calculate_frequency(access_data)
+          return 0.0 if access_data.size < 2
+
+          time_span = access_data.first["timestamp"] - access_data.last["timestamp"]
+          return 0.0 if time_span <= 0
+
+          access_data.size.to_f / time_span * 3600 # requests per hour
+        end
+
+        def identify_peak_hours(access_data)
+          hourly_counts = access_data.group_by { |d| d["hour"] }.transform_values(&:count)
+          avg_count = hourly_counts.values.sum.to_f / hourly_counts.size
+          
+          hourly_counts.select { |hour, count| count > avg_count * 1.5 }.keys.sort
+        end
+
+        def determine_cachability(status, headers)
+          return false unless (200..299).include?(status)
+          return false if headers["Set-Cookie"]
+          return false if headers["Cache-Control"]&.include?("no-cache")
+          
+          true
+        end
+
+        def has_cache_control_headers?(headers)
+          !!(headers["Cache-Control"] || headers["Expires"] || headers["ETag"])
+        end
+
+        def recommend_ttl(content_type, status)
+          case content_type
+          when /image|css|javascript/
+            3600 # 1 hour for static assets
+          when /json|xml/
+            300 # 5 minutes for API responses
+          when /html/
+            600 # 10 minutes for HTML
+          else
+            300 # Default 5 minutes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/features/classification.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class Classification
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :classification
+          @provider = provider
+          @config = config
+        end
+
+        def enabled?
+          @config.feature_enabled?(:classification)
+        end
+
+        def process_response?
+          false
+        end
+
+        def process_request(env)
+          request_data = @provider.build_request_data(env)
+          result = @provider.classify_request(request_data)
+          
+          # Apply confidence threshold
+          threshold = @config.classification.confidence_threshold
+          if result[:confidence] < threshold
+            result[:classification] = :uncertain
+            result[:action] = :allow
+          else
+            result[:action] = determine_action(result[:classification])
+          end
+
+          # Add metadata
+          result[:feature] = @name
+          result[:timestamp] = Time.now.iso8601
+          result[:request_id] = generate_request_id(env)
+
+          result
+        end
+
+        private
+
+        def determine_action(classification)
+          case classification
+          when :spam
+            :block
+          when :suspicious
+            @config.routing.smart_routing_enabled ? :route : :allow
+          when :bot
+            @config.routing.smart_routing_enabled ? :route : :allow
+          when :human
+            :allow
+          else
+            :allow
+          end
+        end
+
+        def generate_request_id(env)
+          "#{Time.now.to_i}-#{env.object_id}"
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/features/enhancement.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class Enhancement
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :enhancement
+          @provider = provider
+          @config = config
+        end
+
+        def enabled?
+          @config.feature_enabled?(:enhancement)
+        end
+
+        def process_response?
+          true
+        end
+
+        def process_request(env)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # Enhancement is primarily a response-processing feature
+          {
+            feature: @name,
+            timestamp: Time.now.iso8601,
+            enhancement_ready: true
+          }
+        end
+
+        def process_response(env, status, headers, body)
+          return { processed: false, reason: "disabled" } unless enabled?
+          return { processed: false, reason: "non_success_status" } unless (200..299).include?(status)
+
+          content_type = headers["Content-Type"] || ""
+          return { processed: false, reason: "unsupported_content_type" } unless enhanceable_content?(content_type)
+
+          # Extract content from response body
+          content = extract_content(body)
+          return { processed: false, reason: "no_content" } if content.empty?
+
+          # Determine enhancement type based on content and request context
+          enhancement_type = determine_enhancement_type(env, content_type, content)
+          return { processed: false, reason: "no_enhancement_needed" } unless enhancement_type
+
+          begin
+            # Apply AI enhancement
+            enhancement_result = @provider.enhance_content(content, enhancement_type)
+            
+            # Update response body if enhancement was successful
+            if enhancement_result[:enhanced_content] && 
+               enhancement_result[:enhanced_content] != content
+              update_response_body(body, enhancement_result[:enhanced_content])
+              headers["X-AI-Enhanced"] = "true"
+              headers["X-AI-Enhancement-Type"] = enhancement_type.to_s
+            end
+
+            {
+              enhancement_applied: true,
+              enhancement_type: enhancement_type,
+              original_length: content.length,
+              enhanced_length: enhancement_result[:enhanced_content]&.length || content.length,
+              improvement_ratio: calculate_improvement_ratio(content, enhancement_result[:enhanced_content]),
+              feature: "#{@name}_response",
+              timestamp: Time.now.iso8601
+            }
+          rescue => e
+            Utils::Logger.warn("Content enhancement failed", error: e.message, enhancement_type: enhancement_type)
+            {
+              enhancement_applied: false,
+              error: e.message,
+              feature: "#{@name}_response",
+              timestamp: Time.now.iso8601
+            }
+          end
+        end
+
+        private
+
+        def enhanceable_content?(content_type)
+          enhanceable_types = [
+            "text/html",
+            "text/plain",
+            "application/json",
+            "text/markdown"
+          ]
+          
+          enhanceable_types.any? { |type| content_type.include?(type) }
+        end
+
+        def extract_content(body)
+          content = ""
+          if body.respond_to?(:each)
+            body.each { |chunk| content += chunk.to_s }
+          elsif body.respond_to?(:read)
+            content = body.read
+            body.rewind if body.respond_to?(:rewind)
+          else
+            content = body.to_s
+          end
+          content
+        end
+
+        def determine_enhancement_type(env, content_type, content)
+          path = env["PATH_INFO"] || ""
+          user_agent = env["HTTP_USER_AGENT"] || ""
+
+          # SEO enhancement for HTML pages
+          if content_type.include?("text/html") && needs_seo_enhancement?(content)
+            return :seo
+          end
+
+          # Readability enhancement for long text content
+          if content.length > 1000 && needs_readability_improvement?(content)
+            return :readability
+          end
+
+          # Accessibility enhancement for HTML
+          if content_type.include?("text/html") && needs_accessibility_improvement?(content)
+            return :accessibility
+          end
+
+          # API response optimization
+          if path.start_with?("/api/") && content_type.include?("application/json")
+            return :api_optimization
+          end
+
+          # Mobile optimization based on user agent
+          if mobile_user_agent?(user_agent) && content_type.include?("text/html")
+            return :mobile_optimization
+          end
+
+          nil
+        end
+
+        def needs_seo_enhancement?(content)
+          # Simple heuristics for SEO improvement needs
+          return true if content.scan(/<title>/).length != 1
+          return true if content.scan(/<meta name="description"/).empty?
+          return true if content.scan(/<h1>/).length != 1
+          return true if content.scan(/<img[^>]*alt=/).length < content.scan(/<img/).length
+          
+          false
+        end
+
+        def needs_readability_improvement?(content)
+          # Simple readability checks
+          sentences = content.split(/[.!?]+/)
+          return true if sentences.any? { |s| s.split.length > 25 } # Long sentences
+          
+          # Check for complex words (more than 3 syllables - simplified)
+          words = content.downcase.scan(/\b[a-z]+\b/)
+          complex_words = words.select { |word| word.length > 10 }
+          return true if complex_words.length > words.length * 0.1
+          
+          false
+        end
+
+        def needs_accessibility_improvement?(content)
+          # Basic accessibility checks
+          return true if content.scan(/<img[^>]*alt=/).length < content.scan(/<img/).length
+          return true if content.scan(/<input[^>]*aria-label=/).length < content.scan(/<input/).length
+          return true if content.scan(/<button[^>]*aria-label=/).length < content.scan(/<button/).length
+          
+          false
+        end
+
+        def mobile_user_agent?(user_agent)
+          mobile_patterns = [
+            /Mobile/i,
+            /Android/i,
+            /iPhone/i,
+            /iPad/i,
+            /Windows Phone/i
+          ]
+          
+          mobile_patterns.any? { |pattern| user_agent.match?(pattern) }
+        end
+
+        def update_response_body(body, enhanced_content)
+          # Update the response body with enhanced content
+          if body.respond_to?(:clear) && body.respond_to?(:<<)
+            body.clear
+            body << enhanced_content
+          elsif body.is_a?(Array)
+            body.clear
+            body << enhanced_content
+          end
+        end
+
+        def calculate_improvement_ratio(original, enhanced)
+          return 1.0 unless enhanced && original != enhanced
+          
+          # Simple improvement metric based on length and complexity
+          original_complexity = calculate_complexity(original)
+          enhanced_complexity = calculate_complexity(enhanced)
+          
+          return 1.0 if original_complexity == 0
+          
+          enhanced_complexity.to_f / original_complexity
+        end
+
+        def calculate_complexity(text)
+          # Simple complexity score based on sentence length and word complexity
+          sentences = text.split(/[.!?]+/)
+          return 1 if sentences.empty?
+          
+          avg_sentence_length = sentences.map(&:split).map(&:length).sum.to_f / sentences.length
+          long_words = text.scan(/\b\w{7,}\b/).length
+          
+          (avg_sentence_length + long_words).to_i
+        end
+      end
+    end
+  end
+end