rack-ai 0.1.0

data/lib/rack/ai/providers/huggingface.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "json"
+
+module Rack
+  module AI
+    module Providers
+      class HuggingFace < Base
+        API_BASE_URL = "https://api-inference.huggingface.co"
+
+        def initialize(config)
+          super
+          @client = build_client
+        end
+
+        def classify_request(request_data)
+          # Use a text classification model for request analysis
+          text = build_request_text(request_data)
+          
+          response = @client.post("models/microsoft/DialoGPT-medium") do |req|
+            req.body = {
+              inputs: "Classify this web request as human, bot, spam, or suspicious: #{text}",
+              parameters: {
+                max_length: 50,
+                temperature: 0.1
+              }
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          generated_text = result.first&.dig("generated_text") || ""
+          
+          # Parse classification from generated text
+          classification = extract_classification(generated_text)
+          
+          {
+            classification: classification,
+            confidence: 0.8, # HuggingFace doesn't always provide confidence scores
+            reasoning: generated_text,
+            provider: :huggingface
+          }
+        end
+
+        def moderate_content(content, options = {})
+          # Use toxicity detection model
+          response = @client.post("models/unitary/toxic-bert") do |req|
+            req.body = {
+              inputs: content
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          # HuggingFace toxicity models return classification results
+          toxic_score = result.first&.find { |r| r["label"] == "TOXIC" }&.dig("score") || 0.0
+          
+          {
+            flagged: toxic_score > 0.5,
+            categories: { toxicity: toxic_score > 0.5 },
+            category_scores: { toxicity: toxic_score },
+            provider: :huggingface
+          }
+        end
+
+        def analyze_patterns(data)
+          # Use a general text analysis approach
+          text = "Analyze these web traffic patterns: #{data.to_json}"
+          
+          response = @client.post("models/facebook/bart-large-cnn") do |req|
+            req.body = {
+              inputs: text,
+              parameters: {
+                max_length: 200,
+                min_length: 50
+              }
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          summary = result.first&.dig("summary_text") || ""
+          
+          {
+            anomalies: extract_anomalies(summary),
+            trends: extract_trends(summary),
+            recommendations: extract_recommendations(summary),
+            confidence: 0.7,
+            provider: :huggingface
+          }
+        end
+
+        def detect_anomalies(request_data)
+          # Use anomaly detection approach
+          text = build_security_analysis_text(request_data)
+          
+          response = @client.post("models/microsoft/DialoGPT-medium") do |req|
+            req.body = {
+              inputs: "Security analysis: #{text}. Threat level (low/medium/high):",
+              parameters: {
+                max_length: 100,
+                temperature: 0.1
+              }
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          analysis = result.first&.dig("generated_text") || ""
+          
+          {
+            threat_level: extract_threat_level(analysis),
+            anomalies: extract_security_anomalies(analysis),
+            confidence: 0.7,
+            provider: :huggingface
+          }
+        end
+
+        def enhance_content(content, enhancement_type)
+          model = case enhancement_type
+                  when :seo
+                    "models/facebook/bart-large-cnn"
+                  when :readability
+                    "models/facebook/bart-large"
+                  else
+                    "models/t5-base"
+                  end
+
+          prompt = build_enhancement_prompt(content, enhancement_type)
+          
+          response = @client.post(model) do |req|
+            req.body = {
+              inputs: prompt,
+              parameters: {
+                max_length: 500,
+                temperature: 0.3
+              }
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          enhanced = result.first&.dig("generated_text") || content
+          
+          {
+            original_content: content,
+            enhanced_content: enhanced,
+            enhancement_type: enhancement_type,
+            provider: :huggingface
+          }
+        end
+
+        def ping
+          response = @client.get("models")
+          response.success?
+        end
+
+        protected
+
+        def requires_api_url?
+          false
+        end
+
+        private
+
+        def build_client
+          Faraday.new(
+            url: @config[:api_url] || API_BASE_URL,
+            headers: {
+              "Authorization" => "Bearer #{@config[:api_key]}",
+              "Content-Type" => "application/json"
+            }
+          ) do |f|
+            f.request :retry, max: @config[:retries] || 3, interval: 1.0
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        def build_request_text(request_data)
+          "#{request_data[:method]} #{request_data[:path]} from #{request_data[:user_agent]} at #{request_data[:remote_ip]}"
+        end
+
+        def build_security_analysis_text(request_data)
+          "Request: #{request_data[:method]} #{request_data[:path]}?#{request_data[:query_string]} Headers: #{request_data[:headers].keys.join(',')}"
+        end
+
+        def extract_classification(text)
+          text_lower = text.downcase
+          return :spam if text_lower.include?("spam")
+          return :bot if text_lower.include?("bot")
+          return :suspicious if text_lower.include?("suspicious")
+          return :human if text_lower.include?("human")
+          :unknown
+        end
+
+        def extract_threat_level(text)
+          text_lower = text.downcase
+          return :high if text_lower.include?("high")
+          return :medium if text_lower.include?("medium")
+          :low
+        end
+
+        def extract_anomalies(text)
+          # Simple keyword extraction for anomalies
+          anomalies = []
+          anomalies << "unusual_traffic" if text.include?("unusual") || text.include?("anomal")
+          anomalies << "high_frequency" if text.include?("frequent") || text.include?("rapid")
+          anomalies << "suspicious_patterns" if text.include?("suspicious") || text.include?("pattern")
+          anomalies
+        end
+
+        def extract_trends(text)
+          trends = []
+          trends << "increasing_traffic" if text.include?("increas") || text.include?("grow")
+          trends << "decreasing_traffic" if text.include?("decreas") || text.include?("drop")
+          trends << "stable_patterns" if text.include?("stable") || text.include?("consistent")
+          trends
+        end
+
+        def extract_recommendations(text)
+          recommendations = []
+          recommendations << "monitor_closely" if text.include?("monitor") || text.include?("watch")
+          recommendations << "increase_security" if text.include?("security") || text.include?("protect")
+          recommendations << "optimize_performance" if text.include?("optim") || text.include?("performance")
+          recommendations
+        end
+
+        def extract_security_anomalies(text)
+          anomalies = []
+          anomalies << "sql_injection_attempt" if text.include?("sql") || text.include?("injection")
+          anomalies << "xss_attempt" if text.include?("xss") || text.include?("script")
+          anomalies << "unusual_user_agent" if text.include?("user-agent") || text.include?("bot")
+          anomalies
+        end
+
+        def build_enhancement_prompt(content, enhancement_type)
+          case enhancement_type
+          when :seo
+            "Optimize for SEO: #{content}"
+          when :readability
+            "Improve readability: #{content}"
+          when :accessibility
+            "Enhance accessibility: #{content}"
+          else
+            "Improve: #{content}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/providers/local.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Rack
+  module AI
+    module Providers
+      class Local < Base
+        DEFAULT_PORT = 8080
+
+        def initialize(config)
+          super
+          @client = build_client
+        end
+
+        def classify_request(request_data)
+          response = @client.post("classify") do |req|
+            req.body = {
+              request_data: request_data,
+              task: "classification"
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          {
+            classification: result["classification"]&.to_sym || :unknown,
+            confidence: result["confidence"] || 0.0,
+            reasoning: result["reasoning"],
+            provider: :local
+          }
+        end
+
+        def moderate_content(content, options = {})
+          response = @client.post("moderate") do |req|
+            req.body = {
+              content: content,
+              options: options
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          {
+            flagged: result["flagged"] || false,
+            categories: result["categories"] || {},
+            category_scores: result["category_scores"] || {},
+            provider: :local
+          }
+        end
+
+        def analyze_patterns(data)
+          response = @client.post("analyze") do |req|
+            req.body = {
+              data: data,
+              analysis_type: "patterns"
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          {
+            anomalies: result["anomalies"] || [],
+            trends: result["trends"] || [],
+            recommendations: result["recommendations"] || [],
+            confidence: result["confidence"] || 0.0,
+            provider: :local
+          }
+        end
+
+        def detect_anomalies(request_data)
+          response = @client.post("detect") do |req|
+            req.body = {
+              request_data: request_data,
+              detection_type: "anomalies"
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          {
+            threat_level: result["threat_level"]&.to_sym || :low,
+            anomalies: result["anomalies"] || [],
+            confidence: result["confidence"] || 0.0,
+            provider: :local
+          }
+        end
+
+        def enhance_content(content, enhancement_type)
+          response = @client.post("enhance") do |req|
+            req.body = {
+              content: content,
+              enhancement_type: enhancement_type
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          
+          {
+            original_content: content,
+            enhanced_content: result["enhanced_content"] || content,
+            enhancement_type: enhancement_type,
+            provider: :local
+          }
+        end
+
+        def ping
+          response = @client.get("health")
+          response.success?
+        end
+
+        protected
+
+        def requires_api_key?
+          false
+        end
+
+        def requires_api_url?
+          true
+        end
+
+        private
+
+        def build_client
+          base_url = @config[:api_url] || "http://localhost:#{DEFAULT_PORT}"
+          
+          Faraday.new(
+            url: base_url,
+            headers: {
+              "Content-Type" => "application/json",
+              "User-Agent" => "rack-ai/#{Rack::AI::VERSION}"
+            }
+          ) do |f|
+            f.request :retry, max: @config[:retries] || 2, interval: 0.5
+            f.adapter Faraday.default_adapter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/providers/openai.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "json"
+
+module Rack
+  module AI
+    module Providers
+      class OpenAI < Base
+        API_BASE_URL = "https://api.openai.com/v1"
+
+        def initialize(config)
+          super
+          @client = build_client
+        end
+
+        def classify_request(data)
+          prompt = build_classification_prompt(data)
+          
+          response = @client.post("chat/completions") do |req|
+            req.body = {
+              model: "gpt-3.5-turbo",
+              messages: [
+                {
+                  role: "system",
+                  content: "You are a web request classifier. Analyze the request and classify it as one of: human, bot, spam, suspicious. Respond with JSON containing 'classification' and 'confidence' (0-1)."
+                },
+                {
+                  role: "user",
+                  content: prompt
+                }
+              ],
+              temperature: 0.1,
+              max_tokens: 100
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          content = JSON.parse(result.dig("choices", 0, "message", "content") || "{}")
+          
+          {
+            classification: content["classification"]&.to_sym || :unknown,
+            confidence: content["confidence"] || 0.0,
+            reasoning: content["reasoning"],
+            provider: :openai
+          }
+        end
+
+        def moderate_content(content, options = {})
+          response = @client.post("moderations") do |req|
+            req.body = {
+              input: content,
+              model: "text-moderation-latest"
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          moderation_result = result["results"]&.first || {}
+          
+          {
+            flagged: moderation_result["flagged"] || false,
+            categories: moderation_result["categories"] || {},
+            category_scores: moderation_result["category_scores"] || {},
+            provider: :openai
+          }
+        end
+
+        def analyze_patterns(data)
+          prompt = build_pattern_analysis_prompt(data)
+          
+          response = @client.post("chat/completions") do |req|
+            req.body = {
+              model: "gpt-3.5-turbo",
+              messages: [
+                {
+                  role: "system",
+                  content: "You are a traffic pattern analyst. Analyze the provided request patterns and identify anomalies, trends, and recommendations. Respond with JSON."
+                },
+                {
+                  role: "user",
+                  content: prompt
+                }
+              ],
+              temperature: 0.2,
+              max_tokens: 500
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          content = JSON.parse(result.dig("choices", 0, "message", "content") || "{}")
+          
+          {
+            anomalies: content["anomalies"] || [],
+            trends: content["trends"] || [],
+            recommendations: content["recommendations"] || [],
+            confidence: content["confidence"] || 0.0,
+            provider: :openai
+          }
+        end
+
+        def detect_anomalies(request_data)
+          prompt = build_anomaly_detection_prompt(request_data)
+          
+          response = @client.post("chat/completions") do |req|
+            req.body = {
+              model: "gpt-3.5-turbo",
+              messages: [
+                {
+                  role: "system",
+                  content: "You are a security analyst. Detect potential security threats, anomalies, or suspicious patterns in web requests. Respond with JSON containing 'threat_level' (low/medium/high), 'anomalies', and 'confidence'."
+                },
+                {
+                  role: "user",
+                  content: prompt
+                }
+              ],
+              temperature: 0.1,
+              max_tokens: 200
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          content = JSON.parse(result.dig("choices", 0, "message", "content") || "{}")
+          
+          {
+            threat_level: content["threat_level"]&.to_sym || :low,
+            anomalies: content["anomalies"] || [],
+            confidence: content["confidence"] || 0.0,
+            provider: :openai
+          }
+        end
+
+        def enhance_content(content, enhancement_type)
+          prompt = build_enhancement_prompt(content, enhancement_type)
+          
+          response = @client.post("chat/completions") do |req|
+            req.body = {
+              model: "gpt-3.5-turbo",
+              messages: [
+                {
+                  role: "system",
+                  content: "You are a content enhancement assistant. Improve the provided content based on the specified enhancement type."
+                },
+                {
+                  role: "user",
+                  content: prompt
+                }
+              ],
+              temperature: 0.3,
+              max_tokens: 1000
+            }.to_json
+          end
+
+          handle_api_error(response) unless response.success?
+          
+          result = JSON.parse(response.body)
+          enhanced_content = result.dig("choices", 0, "message", "content")
+          
+          {
+            original_content: content,
+            enhanced_content: enhanced_content,
+            enhancement_type: enhancement_type,
+            provider: :openai
+          }
+        end
+
+        def ping
+          response = @client.get("models")
+          response.success?
+        end
+
+        private
+
+        def build_client
+          Faraday.new(
+            url: @config[:api_url] || API_BASE_URL,
+            headers: {
+              "Authorization" => "Bearer #{@config[:api_key]}",
+              "Content-Type" => "application/json"
+            }
+          ) do |f|
+            f.request :retry, max: @config[:retries] || 3, interval: 0.5
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        def build_classification_prompt(request_data)
+          <<~PROMPT
+            Analyze this web request:
+            
+            Method: #{request_data[:method]}
+            Path: #{request_data[:path]}
+            Query: #{request_data[:query_string]}
+            User-Agent: #{request_data[:user_agent]}
+            IP: #{request_data[:remote_ip]}
+            Headers: #{request_data[:headers].to_json}
+            
+            Classify this request and provide your reasoning.
+          PROMPT
+        end
+
+        def build_pattern_analysis_prompt(data)
+          <<~PROMPT
+            Analyze these traffic patterns:
+            
+            #{data.to_json}
+            
+            Identify anomalies, trends, and provide actionable recommendations.
+          PROMPT
+        end
+
+        def build_anomaly_detection_prompt(request_data)
+          <<~PROMPT
+            Analyze this request for security threats:
+            
+            #{request_data.to_json}
+            
+            Look for: SQL injection, XSS, CSRF, unusual patterns, bot behavior, etc.
+          PROMPT
+        end
+
+        def build_enhancement_prompt(content, enhancement_type)
+          case enhancement_type
+          when :seo
+            "Optimize this content for SEO while maintaining its meaning:\n\n#{content}"
+          when :readability
+            "Improve the readability and clarity of this content:\n\n#{content}"
+          when :accessibility
+            "Enhance this content for better accessibility:\n\n#{content}"
+          else
+            "Improve this content:\n\n#{content}"
+          end
+        end
+      end
+    end
+  end
+end