rails_ai 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12fd9806ebab3a6d0f461ecc96a964eeee0f60656505374590e9fe12668ec587
-  data.tar.gz: 45e691a4d1de94de3db0ab1019690141d0d2f70bda24e32b629cf101763fd0a4
+  metadata.gz: f3462b92ede383e82fc730daa4a03aab2e25c03afde4d269345744658b726d39
+  data.tar.gz: 4e0d4a89fe63816f4f91e1782fa03c6a4eec49db2f7820216bf6aaf6d659604b
 SHA512:
-  metadata.gz: 787ac2d9154679ec0cb78f27b754812f06cefb1944e159d24726c070fc45dc5a7227c39f9eea3fbc841271e53eafa476a62358c772fd123be41e72557de70a53
-  data.tar.gz: '04892840f6787408f1a9b12cc3f09fa562b05578d947f709a10f4826975685fab7b744030cd1f5da81f9012772c38611a13e4b57427a2f59c303ff5339b13556'
+  metadata.gz: 4008bd2db4e5e0770c9847570e0db636dcdbb70a27adf6a4c941af33a2e63535b5f70fb341f93f1f12ca548e2e597b667bb4307851344c7a6497034f1c1f0f96
+  data.tar.gz: 1336af819a3971b20bf6570234ac73bf98796ae7a487cbe7a1b4d0b8a87a7f6e92c40b73478cd38b36487384cf6760df8ca38c245585b9f2d61a75f6f74b8efb

data/lib/rails_ai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAi
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/rails_ai.rb

@@ -48,169 +48,58 @@ module RailsAi
   class << self
     # Version compatibility helpers
     def rails_version
-      Rails.version.to_s
+      Rails.version.to_f
     end
 
-    def rails_8?
-      Rails.version >= "8.0"
+    def ruby_version
+      RUBY_VERSION.to_f
     end
 
-    def rails_7?
-      Rails.version >= "7.0" && Rails.version < "8.0"
+    # Configuration
+    def config
+      @config ||= Config.new
     end
 
-    def rails_6?
-      Rails.version >= "6.0" && Rails.version < "7.0"
+    def configure
+      yield(config)
     end
 
-    def rails_5?
-      Rails.version >= "5.2" && Rails.version < "6.0"
-    end
-
-    # Performance-optimized provider with lazy loading
-    def provider
-      @provider ||= Performance::LazyProvider.new do
-        case config.provider.to_sym
-        when :openai then Providers::SecureOpenAIAdapter.new
-        when :anthropic then Providers::SecureAnthropicAdapter.new
-        when :gemini then Providers::GeminiAdapter.new
-        when :dummy then Providers::DummyAdapter.new
-        else Providers::DummyAdapter.new
-        end
-      end
-    end
-
-    # Agent management
-    def agent_manager
-      @agent_manager ||= Agents::AgentManager.new
-    end
-
-    def create_agent(name:, role:, capabilities: [], **opts)
-      agent = Agents::BaseAgent.new(
-        name: name,
-        role: role,
-        capabilities: capabilities,
-        **opts
+    # Performance optimizations
+    def connection_pool
+      @connection_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: 2,
+        max_threads: 10,
+        max_queue: 100,
+        auto_terminate: true
       )
-      agent_manager.register_agent(agent)
-      agent
-    end
-
-    def create_research_agent(name: "ResearchAgent", **opts)
-      agent = Agents::ResearchAgent.new(name: name, **opts)
-      agent_manager.register_agent(agent)
-      agent
-    end
-
-    def create_creative_agent(name: "CreativeAgent", **opts)
-      agent = Agents::CreativeAgent.new(name: name, **opts)
-      agent_manager.register_agent(agent)
-      agent
     end
 
-    def create_technical_agent(name: "TechnicalAgent", **opts)
-      agent = Agents::TechnicalAgent.new(name: name, **opts)
-      agent_manager.register_agent(agent)
-      agent
-    end
-
-    def create_coordinator_agent(name: "CoordinatorAgent", **opts)
-      agent = Agents::CoordinatorAgent.new(name: name, **opts)
-      agent_manager.register_agent(agent)
-      agent
-    end
-
-    def get_agent(name)
-      agent_manager.get_agent(name)
-    end
-
-    def list_agents
-      agent_manager.list_agents
-    end
-
-    def start_agents!
-      agent_manager.start!
-    end
-
-    def stop_agents!
-      agent_manager.stop!
-    end
-
-    # Task management
-    def submit_task(task)
-      agent_manager.submit_task(task)
-    end
-
-    def assign_task(task, agent_name)
-      agent_manager.assign_task_to_agent(task, agent_name)
-    end
-
-    def auto_assign_task(task)
-      agent_manager.auto_assign_task(task)
-    end
-
-    # Agent teams
-    def create_agent_team(name, agents, strategy: :round_robin)
-      agent_manager.create_agent_team(name, agents, collaboration_strategy: strategy)
-    end
-
-    def orchestrate_collaboration(task, agent_names)
-      agent_manager.orchestrate_collaboration(task, agent_names)
-    end
-
-    # Agent communication
-    def send_agent_message(from_agent, to_agent, message)
-      agent_manager.send_message(from_agent, to_agent, message)
-    end
-
-    def broadcast_agent_message(from_agent, message, exclude: [])
-      agent_manager.broadcast_message(from_agent, message, exclude: exclude)
+    def batch_processor
+      @batch_processor ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: 5,
+        max_queue: 50,
+        auto_terminate: true
+      )
     end
 
-    # Agent monitoring
-    def agent_system_status
-      agent_manager.system_status
+    def smart_cache
+      @smart_cache ||= Cache.new
     end
 
-    def agent_health_check
-      agent_manager.health_check
+    def request_deduplicator
+      @request_deduplicator ||= RequestDeduplicator.new
     end
 
-    # Performance monitoring
     def performance_monitor
-      @performance_monitor ||= Performance::PerformanceMonitor.new
+      @performance_monitor ||= Performance::Monitor.new
     end
 
-    def metrics
-      performance_monitor.metrics
-    end
-
-    # Connection pool for HTTP requests
-    def connection_pool
-      @connection_pool ||= Performance::ConnectionPool.new(size: config.connection_pool_size)
-    end
-
-    # Smart caching with compression
-    def smart_cache
-      @smart_cache ||= Performance::SmartCache.new(
-        compression_threshold: config.compression_threshold
-      )
-    end
-
-    # Request deduplication
-    def request_deduplicator
-      @request_deduplicator ||= Performance::RequestDeduplicator.new
-    end
-
-    # Batch processor for multiple operations
-    def batch_processor
-      @batch_processor ||= Performance::BatchProcessor.new(
-        batch_size: config.batch_size,
-        flush_interval: config.flush_interval
-      )
+    def agent_manager
+      @agent_manager ||= Agents::AgentManager.new
     end
 
-    # Optimized text-based AI operations with performance monitoring
+    # Core AI methods
     def chat(prompt_or_messages, model: config.default_model, **opts)
       performance_monitor.measure(:chat) do
         messages = normalize_messages(prompt_or_messages)
@@ -235,331 +124,220 @@ module RailsAi
       end
     end
 
-    def embed(texts, model: config.default_model, **opts)
+    def embed(texts, model: "text-embedding-3-small", **opts)
       performance_monitor.measure(:embed) do
-        texts = Array(texts)
-        cache_key = [:embed, model, texts.hash]
+        texts_array = Array(texts)
+        cache_key = [:embed, model, texts_array.hash]
         
         smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
           request_deduplicator.deduplicate(cache_key) do
-            provider.embed!(texts: texts, model: model, **opts)
+            provider.embed!(texts: texts_array, model: model, **opts)
           end
         end
       end
     end
 
-    # Optimized image operations
-    def generate_image(prompt, model: "dall-e-3", size: "1024x1024", quality: "standard", **opts)
-      performance_monitor.measure(:generate_image) do
-        cache_key = [:image, model, prompt.hash, size, quality]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.generate_image!(prompt: prompt, model: model, size: size, quality: quality, **opts)
-          end
-        end
+    # Multimodal capabilities
+    def analyze_image(image, prompt, model: "gpt-4o", **opts)
+      performance_monitor.measure(:analyze_image) do
+        provider.analyze_image!(image: image, prompt: prompt, model: model, **opts)
       end
     end
 
-    def edit_image(image, prompt, mask: nil, size: "1024x1024", **opts)
-      performance_monitor.measure(:edit_image) do
-        cache_key = [:image_edit, prompt.hash, image.hash, size]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.edit_image!(image: image, prompt: prompt, mask: mask, size: size, **opts)
-          end
-        end
+    def generate_image(prompt, model: "dall-e-3", **opts)
+      performance_monitor.measure(:generate_image) do
+        provider.generate_image!(prompt: prompt, model: model, **opts)
       end
     end
 
-    def create_variation(image, size: "1024x1024", **opts)
-      performance_monitor.measure(:create_variation) do
-        cache_key = [:image_variation, image.hash, size]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.create_variation!(image: image, size: size, **opts)
-          end
-        end
+    def analyze_video(video, prompt, model: "gpt-4o", **opts)
+      performance_monitor.measure(:analyze_video) do
+        provider.analyze_video!(video: video, prompt: prompt, model: model, **opts)
       end
     end
 
-    # Optimized video operations
-    def generate_video(prompt, model: "sora", duration: 5, **opts)
+    def generate_video(prompt, model: "runway-gen-3", **opts)
       performance_monitor.measure(:generate_video) do
-        cache_key = [:video, model, prompt.hash, duration]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.generate_video!(prompt: prompt, model: model, duration: duration, **opts)
-          end
-        end
+        provider.generate_video!(prompt: prompt, model: model, **opts)
       end
     end
 
-    def edit_video(video, prompt, **opts)
-      performance_monitor.measure(:edit_video) do
-        cache_key = [:video_edit, prompt.hash, video.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.edit_video!(video: video, prompt: prompt, **opts)
-          end
-        end
+    def analyze_audio(audio, prompt, model: "whisper-1", **opts)
+      performance_monitor.measure(:analyze_audio) do
+        provider.analyze_audio!(audio: audio, prompt: prompt, model: model, **opts)
       end
     end
 
-    # Optimized audio operations
-    def generate_speech(text, model: "tts-1", voice: "alloy", **opts)
-      performance_monitor.measure(:generate_speech) do
-        cache_key = [:speech, model, text.hash, voice]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.generate_speech!(text: text, model: model, voice: voice, **opts)
-          end
-        end
+    def generate_audio(prompt, model: "tts-1", **opts)
+      performance_monitor.measure(:generate_audio) do
+        provider.generate_audio!(prompt: prompt, model: model, **opts)
       end
     end
 
-    def transcribe_audio(audio, model: "whisper-1", **opts)
-      performance_monitor.measure(:transcribe_audio) do
-        cache_key = [:transcription, model, audio.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.transcribe_audio!(audio: audio, model: model, **opts)
-          end
-        end
+    # Context awareness
+    def chat_with_context(prompt, context_objects = [], model: config.default_model, **opts)
+      performance_monitor.measure(:chat_with_context) do
+        context_analyzer = ContextAnalyzer.new
+        enhanced_prompt = context_analyzer.enhance_prompt(prompt, context_objects)
+        chat(enhanced_prompt, model: model, **opts)
       end
     end
 
-    # Optimized multimodal analysis
-    def analyze_image(image, prompt, model: "gpt-4o", **opts)
-      performance_monitor.measure(:analyze_image) do
-        cache_key = [:image_analysis, model, prompt.hash, image.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.analyze_image!(image: image, prompt: prompt, model: model, **opts)
-          end
-        end
+    def analyze_window_context(url, referrer, user_agent, **opts)
+      performance_monitor.measure(:analyze_window_context) do
+        window_context = WindowContext.new(url: url, referrer: referrer, user_agent: user_agent)
+        window_context.analyze(**opts)
       end
     end
 
-    def analyze_video(video, prompt, model: "gpt-4o", **opts)
-      performance_monitor.measure(:analyze_video) do
-        cache_key = [:video_analysis, model, prompt.hash, video.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          request_deduplicator.deduplicate(cache_key) do
-            provider.analyze_video!(video: video, prompt: prompt, model: model, **opts)
-          end
-        end
+    def analyze_image_context(image, **opts)
+      performance_monitor.measure(:analyze_image_context) do
+        image_context = ImageContext.new(image)
+        image_context.analyze(**opts)
       end
     end
 
-    # Batch operations for multiple requests
-    def batch_chat(requests)
-      performance_monitor.measure(:batch_chat) do
-        requests.map do |request|
-          batch_processor.add_operation(-> { chat(request[:prompt], **request.except(:prompt)) })
-        end
-      end
+    # Agent system
+    def create_agent(name, type: :general, **opts)
+      agent_manager.create_agent(name, type: type, **opts)
     end
 
-    def batch_embed(texts_array)
-      performance_monitor.measure(:batch_embed) do
-        texts_array.map do |texts|
-          batch_processor.add_operation(-> { embed(texts) })
-        end
-      end
+    def create_research_agent(name: "Research Agent", **opts)
+      agent_manager.create_agent(name, type: :research, **opts)
     end
 
-    # Context-aware AI operations (optimized)
-    def analyze_image_with_context(image, prompt, user_context: {}, window_context: {}, image_context: {}, **opts)
-      performance_monitor.measure(:analyze_image_with_context) do
-        cache_key = [:context_image_analysis, prompt.hash, image.hash, user_context.hash, window_context.hash, image_context.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          analyzer = ContextAnalyzer.new(
-            user_context: user_context,
-            window_context: window_context,
-            image_context: image_context
-          )
-          analyzer.analyze_with_context(image, prompt, **opts)
-        end
-      end
+    def create_creative_agent(name: "Creative Agent", **opts)
+      agent_manager.create_agent(name, type: :creative, **opts)
     end
 
-    def generate_with_context(prompt, user_context: {}, window_context: {}, **opts)
-      performance_monitor.measure(:generate_with_context) do
-        cache_key = [:context_generate, prompt.hash, user_context.hash, window_context.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          analyzer = ContextAnalyzer.new(
-            user_context: user_context,
-            window_context: window_context
-          )
-          analyzer.generate_with_context(prompt, **opts)
-        end
-      end
+    def create_technical_agent(name: "Technical Agent", **opts)
+      agent_manager.create_agent(name, type: :technical, **opts)
     end
 
-    def generate_image_with_context(prompt, user_context: {}, window_context: {}, **opts)
-      performance_monitor.measure(:generate_image_with_context) do
-        cache_key = [:context_image_generate, prompt.hash, user_context.hash, window_context.hash]
-        
-        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
-          analyzer = ContextAnalyzer.new(
-            user_context: user_context,
-            window_context: window_context
-          )
-          analyzer.generate_image_with_context(prompt, **opts)
-        end
-      end
+    def create_agent_team(name, agents, strategy: :round_robin, **opts)
+      agent_manager.create_agent_team(name, agents, collaboration_strategy: strategy, **opts)
     end
 
-    # Convenience methods for common AI tasks (optimized)
-    def summarize(content, **opts)
-      chat("Summarize the following content: #{content}", **opts)
+    def submit_task(task, agent_team = nil)
+      if agent_team
+        agent_team.assign_task(task)
+      else
+        agent_manager.submit_task(task)
+      end
     end
 
-    def translate(content, target_language, **opts)
-      chat("Translate the following content to #{target_language}: #{content}", **opts)
+    # Provider management
+    def provider
+      case config.provider.to_sym
+      when :openai then Providers::SecureOpenAIAdapter.new
+      when :anthropic then Providers::SecureAnthropicAdapter.new
+      when :gemini then Providers::GeminiAdapter.new
+      when :dummy then Providers::DummyAdapter.new
+      else Providers::DummyAdapter.new
+      end
     end
 
-    def classify(content, categories, **opts)
-      chat("Classify the following content into one of these categories: #{categories.join(", ")}. Content: #{content}", **opts)
+    def provider=(new_provider)
+      config.provider = new_provider
     end
 
-    def extract_entities(content, **opts)
-      chat("Extract named entities from the following content: #{content}", **opts)
+    # Utility methods
+    def normalize_messages(prompt_or_messages)
+      if prompt_or_messages.is_a?(String)
+        [{ role: "user", content: prompt_or_messages }]
+      else
+        prompt_or_messages
+      end
     end
 
-    def generate_code(prompt, language: "ruby", **opts)
-      chat("Generate #{language} code for: #{prompt}", **opts)
+    def redact_sensitive_data(text)
+      Redactor.call(text)
     end
 
-    def explain_code(code, language: "ruby", **opts)
-      chat("Explain this #{language} code: #{code}", **opts)
+    def log_event(kind:, name:, payload: {}, latency_ms: nil)
+      Events.log!(kind: kind, name: name, payload: payload, latency_ms: latency_ms)
     end
 
-    # Performance utilities
-    def warmup!
-      # Pre-initialize components for faster first requests
-      provider
-      connection_pool
-      smart_cache
-      request_deduplicator
-      batch_processor
-      agent_manager
+    # Security methods
+    def validate_input(input, type: :text)
+      Security::InputValidator.validate(input, type: type)
     end
 
-    def clear_cache!
-      Rails.cache.delete_matched("rails_ai:*") if defined?(Rails) && Rails.cache
+    def sanitize_content(content)
+      Security::ContentSanitizer.sanitize(content)
     end
 
-    def reset_performance_metrics!
-      @performance_monitor = Performance::PerformanceMonitor.new
+    def check_rate_limit(identifier, limit: 100, window: 1.hour)
+      Security::RateLimiter.check(identifier, limit: limit, window: window)
     end
 
-    private
-
-    def normalize_messages(prompt_or_messages)
-      messages = prompt_or_messages.is_a?(Array) ? prompt_or_messages : [{role: "user", content: prompt_or_messages}]
-      text = RailsAi::Redactor.call(messages.last[:content])
-      messages[-1] = messages.last.merge(content: text)
-      messages
+    def scan_for_vulnerabilities
+      Security::VulnerabilityScanner.scan
     end
-  end
-
-  # Security methods
-  def self.validate_input(input, type: :text)
-    Security::InputValidator.send("validate_#{type}_input", input)
-  end
-
-  def self.sanitize_content(content)
-    Security::ContentSanitizer.sanitize_content(content)
-  end
 
-  def self.secure_api_key(env_var, required: true)
-    Security::APIKeyManager.secure_fetch(env_var, required: required)
-  end
+    def handle_security_error(error, context = {})
+      Security::ErrorHandler.handle_security_error(error, context)
+    end
 
-  def self.mask_api_key(key)
-    Security::APIKeyManager.mask_key(key)
-  end
+    # Response cleaning utility
+    def clean_response(raw_response)
+      return nil if raw_response.nil?
 
-  def self.log_security_event(event_type, details = {})
-    Security::AuditLogger.log_security_event(event_type, details)
-  end
+      # Convert to string
+      response = raw_response.to_s
+      
+      # Ensure UTF-8 encoding
+      response = response.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: '?')
+      
+      # Remove any control characters that might cause issues
+      response = response.gsub(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/, '')
+      
+      response
+    end
 
-  def self.handle_security_error(error, context = {})
-    Security::ErrorHandler.handle_security_error(error, context)
-  end
-require_relative "rails_ai/web_search"
+    # Enhanced chat method with automatic response cleaning
+    def chat_clean(prompt_or_messages, model: config.default_model, **opts)
+      raw_response = chat(prompt_or_messages, model: model, **opts)
+      clean_response(raw_response)
+    end
 
-  # Web-enhanced chat with real-time information
-
-  # Web-enhanced chat with real-time information
-  def self.chat_with_web_search(prompt, model: config.default_model, **opts)
-    # Check if the prompt needs web search
-    web_keywords = ['current', 'latest', 'today', 'now', 'recent', 'weather', 'news', 'stock', 'price']
-    needs_web_search = web_keywords.any? { |keyword| prompt.downcase.include?(keyword) }
-    
-    if needs_web_search
-      begin
-        # Perform web search
-        search_results = WebSearch.search(prompt, num_results: 3)
-        
-        # Enhance the prompt with web results
-        web_context = "\n\nRecent web search results:\n"
-        search_results.each_with_index do |result, index|
-          web_context += "#{index + 1}. #{result[:title]}\n   #{result[:snippet]}\n   Source: #{result[:link]}\n\n"
-        end
-        
-        enhanced_prompt = "#{prompt}\n\nPlease use the following web search results to provide current, up-to-date information:#{web_context}"
-        
-        # Get AI response with web context
-        chat(enhanced_prompt, model: model, **opts)
-      rescue WebSearch::SearchError => e
-        # Fallback to regular chat if web search fails
-        chat(prompt, model: model, **opts)
-      end
-    else
-      # Regular chat for non-time-sensitive queries
-      chat(prompt, model: model, **opts)
+    # Enhanced web search chat with automatic response cleaning
+    def chat_with_web_search_clean(prompt, model: config.default_model, **opts)
+      raw_response = chat_with_web_search(prompt, model: model, **opts)
+      clean_response(raw_response)
     end
   end
 end
 
-  # Response cleaning utility
-  def self.clean_response(raw_response)
-    return nil if raw_response.nil?
-
-    # Convert to string
-    response = raw_response.to_s
-    
-    # Ensure UTF-8 encoding
-    response = response.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: '?')
-    
-    # Remove any control characters that might cause issues
-    response = response.gsub(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/, '')
-    
-    response
-  end
-
-  # Enhanced chat method with automatic response cleaning
-  def self.chat_clean(prompt_or_messages, model: config.default_model, **opts)
-    raw_response = chat(prompt_or_messages, model: model, **opts)
-    clean_response(raw_response)
-  end
+require_relative "rails_ai/web_search"
 
-  # Enhanced web search chat with automatic response cleaning
-  def self.chat_with_web_search_clean(prompt, model: config.default_model, **opts)
-    raw_response = chat_with_web_search(prompt, model: model, **opts)
-    clean_response(raw_response)
+# Web-enhanced chat with real-time information
+def RailsAi.chat_with_web_search(prompt, model: RailsAi.config.default_model, **opts)
+  # Check if the prompt needs web search
+  web_keywords = ['current', 'latest', 'today', 'now', 'recent', 'weather', 'news', 'stock', 'price']
+  needs_web_search = web_keywords.any? { |keyword| prompt.downcase.include?(keyword) }
+  
+  if needs_web_search
+    begin
+      # Perform web search
+      search_results = WebSearch.search(prompt, num_results: 3)
+      
+      # Enhance the prompt with web results
+      web_context = "\n\nRecent web search results:\n"
+      search_results.each_with_index do |result, index|
+        web_context += "#{index + 1}. #{result[:title]}\n   #{result[:snippet]}\n   Source: #{result[:link]}\n\n"
+      end
+      
+      enhanced_prompt = "#{prompt}\n\nPlease use the following web search results to provide current, up-to-date information:#{web_context}"
+      
+      # Get AI response with web context
+      RailsAi.chat(enhanced_prompt, model: model, **opts)
+    rescue WebSearch::SearchError => e
+      # Fallback to regular chat if web search fails
+      RailsAi.chat(prompt, model: model, **opts)
+    end
+  else
+    # Regular chat for non-time-sensitive queries
+    RailsAi.chat(prompt, model: model, **opts)
   end
 end

data/setup_wiki.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# Setup GitHub Wiki for Rails AI Gem
+echo "Setting up GitHub Wiki for Rails AI Gem..."
+
+# Check if we're in the right directory
+if [ ! -d "wiki" ]; then
+    echo "Error: wiki directory not found. Please run this script from the rails_ai root directory."
+    exit 1
+fi
+
+# Clone the wiki repository
+echo "Cloning wiki repository..."
+git clone https://github.com/DanielAmah/rails_ai.wiki.git wiki_repo
+
+if [ $? -ne 0 ]; then
+    echo "Error: Could not clone wiki repository. Make sure the wiki is enabled on GitHub."
+    echo "To enable wiki:"
+    echo "1. Go to https://github.com/DanielAmah/rails_ai"
+    echo "2. Click on 'Settings' tab"
+    echo "3. Scroll down to 'Features' section"
+    echo "4. Check 'Wikis' to enable it"
+    echo "5. Run this script again"
+    exit 1
+fi
+
+# Copy wiki files
+echo "Copying wiki files..."
+cp wiki/*.md wiki_repo/
+
+# Navigate to wiki repo
+cd wiki_repo
+
+# Add and commit files
+echo "Adding wiki files to git..."
+git add .
+git commit -m "Add comprehensive wiki documentation for Rails AI Gem"
+
+# Push to GitHub
+echo "Pushing wiki to GitHub..."
+git push origin master
+
+if [ $? -eq 0 ]; then
+    echo "✅ Wiki successfully set up!"
+    echo "You can now view it at: https://github.com/DanielAmah/rails_ai/wiki"
+else
+    echo "❌ Error pushing wiki to GitHub"
+    exit 1
+fi
+
+# Clean up
+cd ..
+rm -rf wiki_repo
+
+echo "Wiki setup complete!"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_ai
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Daniel Amah
@@ -349,6 +349,7 @@ files:
 - rails_ai.gemspec
 - scripts/security_scanner.rb
 - setup_monitoring.sh
+- setup_wiki.sh
 - wiki/API-Documentation.md
 - wiki/Architecture-Overview.md
 - wiki/Contributing-Guide.md