rails_ai 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd41e43064e7f3fb5a20789cebafb4b70f0730eef3661cef6590acf6754d9fa4
-  data.tar.gz: 520a12e5c6eaf27bc300055094a8082160077bdd842c28df4f758ab982a4210f
+  metadata.gz: f3462b92ede383e82fc730daa4a03aab2e25c03afde4d269345744658b726d39
+  data.tar.gz: 4e0d4a89fe63816f4f91e1782fa03c6a4eec49db2f7820216bf6aaf6d659604b
 SHA512:
-  metadata.gz: 5403c48a1d712a95c926574ab8194d3522005e713b77ef39d1db93b71c716ecf1125f79ae6f3beb12c357c075e8aca49d3ad1825ae46e1c75787c8e50b40b926
-  data.tar.gz: 953e4d8c8f0c3490440e953df128a914167b0ea2a9e8c3f6c3d725d4e83c77f8a9a8d284dd5a09b441b4e71810b371626d745fb85b9f0dd3dd6ab860149641da
+  metadata.gz: 4008bd2db4e5e0770c9847570e0db636dcdbb70a27adf6a4c941af33a2e63535b5f70fb341f93f1f12ca548e2e597b667bb4307851344c7a6497034f1c1f0f96
+  data.tar.gz: 1336af819a3971b20bf6570234ac73bf98796ae7a487cbe7a1b4d0b8a87a7f6e92c40b73478cd38b36487384cf6760df8ca38c245585b9f2d61a75f6f74b8efb

data/CHANGELOG.md

@@ -0,0 +1,310 @@
+# Changelog
+
+All notable changes to the Rails AI gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.3] - 2024-09-21
+
+### Fixed
+- Fixed `create_agent_team` method to use correct parameter name (`collaboration_strategy` instead of `strategy`)
+- Resolved `ArgumentError: unknown keyword: :strategy` in agent team creation
+- Improved agent task execution to return meaningful AI-generated results instead of just task confirmation
+
+### Changed
+- Updated agent demo to show actual AI responses from collaborative agent work
+- Enhanced agent controller to simulate multi-agent collaboration with specialized prompts
+
+## [0.2.2] - 2024-09-21
+
+### Fixed
+- Fixed streaming demo EventSource MIME type error by properly handling GET requests for Server-Sent Events
+- Resolved `CookieOverflow` error by implementing file-based storage for large AI responses
+- Fixed compressed response display by adding Zlib decompression in streaming controller
+- Updated streaming view to handle plain text responses instead of expecting JSON
+
+### Changed
+- Improved streaming response handling with proper decompression of compressed chunks
+- Enhanced error handling for streaming connections
+- Updated demo controller to use file storage instead of session for large responses
+
+## [0.2.1] - 2024-09-21
+
+### Added
+- Web search integration with `WebSearch` module supporting Google Search and DuckDuckGo
+- `chat_with_web_search` method for real-time information retrieval
+- Support for current, latest, today, now, recent, weather, news, stock, price keywords
+- Web search fallback to regular chat if search fails
+
+### Fixed
+- Fixed `ArgumentError: unknown keyword: :num_results` in web search integration
+- Resolved method visibility issues with `validate_messages` method
+- Fixed file loading conflicts between duplicate `InputValidator` classes
+
+### Changed
+- Updated demo app to use GPT-4o instead of non-existent GPT-5
+- Enhanced chat demo with web search checkbox option
+- Improved error handling for web search failures
+
+## [0.2.0] - 2024-09-21
+
+### Added
+- Comprehensive security framework with input validation, rate limiting, and content sanitization
+- Secure HTTP client with SSL/TLS enforcement and security headers
+- API key management with encryption and secure storage
+- SSRF protection and secure file handling
+- Audit logging for security events
+- Custom security scanner with vulnerability detection
+- CI/CD security monitoring with multiple security tools
+
+### Fixed
+- Fixed syntax error with extra `end` keyword in main module
+- Resolved character encoding issues with UTF-8 conversion
+- Fixed method visibility and file loading conflicts
+
+### Security
+- Implemented input validation for text, file paths, URLs, and Base64 data
+- Added rate limiting per user and endpoint
+- Content sanitization to prevent XSS and injection attacks
+- Secure file handling with path validation and size limits
+- API security with SSL/TLS enforcement and error handling
+- SSRF protection with URL validation and host blocking
+
+## [0.1.9] - 2024-09-21
+
+### Fixed
+- Fixed CI validation errors by excluding `.gem` files from gemspec
+- Resolved `NoMethodError: undefined method 'megabytes'` by adding ActiveSupport dependency
+- Fixed method visibility issues with `validate_messages` method
+
+### Changed
+- Updated gemspec to exclude generated files and security reports
+- Added `activesupport` dependency for numeric extensions
+- Improved error handling and method accessibility
+
+## [0.1.8] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` by making method public
+- Resolved method visibility conflicts in security module
+- Fixed file loading order issues
+
+### Changed
+- Updated security module to properly load input validator
+- Improved method accessibility and error handling
+
+## [0.1.7] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` in chat functionality
+- Resolved method visibility issues in security module
+- Fixed file loading conflicts between duplicate classes
+
+### Changed
+- Updated security module to use proper file loading
+- Improved error handling and method accessibility
+
+## [0.1.6] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` by updating security module
+- Resolved method visibility issues
+- Fixed file loading conflicts
+
+### Changed
+- Updated security module to properly load input validator
+- Improved method accessibility
+
+## [0.1.5] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` by updating security module
+- Resolved method visibility conflicts
+- Fixed file loading order issues
+
+### Changed
+- Updated security module to use proper file loading
+- Improved method accessibility
+
+## [0.1.4] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` by making method public
+- Resolved method visibility issues in security module
+- Fixed file loading conflicts
+
+### Changed
+- Updated security module to properly load input validator
+- Improved method accessibility
+
+## [0.1.3] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'validate_messages'` by making method public
+- Resolved method visibility issues in security module
+- Fixed file loading conflicts
+
+### Changed
+- Updated security module to properly load input validator
+- Improved method accessibility
+
+## [0.1.2] - 2024-09-21
+
+### Fixed
+- Fixed CI validation errors by excluding `.gem` files from gemspec
+- Resolved `NoMethodError: undefined method 'megabytes'` by adding ActiveSupport dependency
+- Fixed method visibility issues
+
+### Changed
+- Updated gemspec to exclude generated files
+- Added `activesupport` dependency for numeric extensions
+- Improved error handling
+
+## [0.1.1] - 2024-09-21
+
+### Fixed
+- Fixed `NoMethodError: undefined method 'megabytes'` by adding ActiveSupport dependency
+- Resolved method visibility issues in security module
+- Fixed file loading conflicts
+
+### Changed
+- Added `activesupport` dependency for numeric extensions
+- Updated security module to properly load input validator
+- Improved method accessibility
+
+## [0.1.0] - 2024-09-21
+
+### Added
+- Initial release of Rails AI gem
+- Multi-provider support for OpenAI, Anthropic (Claude), and Google Gemini
+- Direct API integration without external gem dependencies
+- Full multimodal capabilities (text, image, video, audio, embeddings)
+- Context awareness with UserContext, WindowContext, and ImageContext
+- Performance optimizations with caching, connection pooling, and batch processing
+- Agent AI system with BaseAgent, specialized agents, and team collaboration
+- Memory system with importance-based retention and search
+- Message bus for inter-agent communication
+- Task queue with priority-based management and deduplication
+- Specialized agents: ResearchAgent, CreativeAgent, TechnicalAgent, CoordinatorAgent
+- Agent teams with various collaboration strategies
+- Agent Manager for centralized system management
+- Comprehensive security framework
+- Input validation and sanitization
+- Rate limiting and content filtering
+- Secure file handling and API security
+- SSRF protection and API key management
+- Audit logging and error handling
+- Custom security scanner
+- CI/CD security monitoring
+- Legal protection framework for Canadian jurisdiction
+- Commercial license template and monitoring system
+- Comprehensive documentation and wiki
+- Rails 5.2+ compatibility with Ruby 3+ support
+- MIT License with non-commercial use restrictions
+
+### Features
+- **Text Generation**: Support for GPT-4o, GPT-4, GPT-3.5-turbo, Claude, and Gemini models
+- **Image Generation**: DALL-E 3, DALL-E 2, and Gemini image generation
+- **Image Analysis**: Vision models for image understanding and analysis
+- **Video Generation**: Video creation and editing capabilities
+- **Audio Processing**: Speech generation and audio transcription
+- **Embeddings**: Vector embeddings for semantic search and similarity
+- **Streaming**: Real-time streaming responses for better user experience
+- **Caching**: Intelligent caching system for improved performance
+- **Context Awareness**: User, window, and image context integration
+- **Agent System**: Autonomous AI agents with collaboration capabilities
+- **Security**: Comprehensive security framework with multiple protection layers
+- **Performance**: Optimized for speed with connection pooling and batch processing
+- **Monitoring**: Continuous monitoring for security and unauthorized use
+- **Legal Protection**: Canadian legal framework with commercial licensing
+
+### Technical Details
+- **Rails Compatibility**: Rails 5.2, 6.x, 7.x, 8.x
+- **Ruby Compatibility**: Ruby 3.0+
+- **Dependencies**: Minimal external dependencies for maximum compatibility
+- **Performance**: Optimized for speed with caching and connection pooling
+- **Security**: Multiple security layers with input validation and sanitization
+- **Monitoring**: Continuous monitoring with CI/CD integration
+- **Documentation**: Comprehensive documentation and wiki
+- **Legal**: Non-commercial license with commercial licensing available
+
+### Breaking Changes
+- None in initial release
+
+### Deprecated
+- None in initial release
+
+### Removed
+- None in initial release
+
+### Security
+- Comprehensive security framework implemented
+- Input validation and sanitization
+- Rate limiting and content filtering
+- Secure file handling and API security
+- SSRF protection and API key management
+- Audit logging and error handling
+- Custom security scanner
+- CI/CD security monitoring
+
+### Performance
+- Intelligent caching system
+- Connection pooling for HTTP requests
+- Batch processing capabilities
+- Lazy loading for improved performance
+- Performance monitoring and optimization
+- Memory management and optimization
+
+### Documentation
+- Comprehensive README with usage examples
+- Complete API documentation
+- Installation and setup guides
+- Contributing guidelines
+- Security documentation
+- Legal protection guide
+- Commercial license template
+- GitHub wiki with detailed documentation
+
+### Legal
+- MIT License with non-commercial use restrictions
+- Commercial licensing available for $999/year
+- Canadian legal framework
+- Copyright protection and monitoring
+- Cease and desist templates
+- Legal protection guide
+
+---
+
+## Version History Summary
+
+- **0.2.3**: Fixed agent team creation and improved task execution
+- **0.2.2**: Fixed streaming demo and cookie overflow issues
+- **0.2.1**: Added web search integration and real-time information
+- **0.2.0**: Added comprehensive security framework
+- **0.1.9**: Fixed CI validation and ActiveSupport dependencies
+- **0.1.8**: Fixed method visibility and file loading issues
+- **0.1.7**: Fixed validate_messages method accessibility
+- **0.1.6**: Updated security module and method accessibility
+- **0.1.5**: Fixed method visibility and file loading conflicts
+- **0.1.4**: Made validate_messages method public
+- **0.1.3**: Fixed method visibility issues
+- **0.1.2**: Fixed CI validation and added ActiveSupport dependency
+- **0.1.1**: Fixed megabytes method and added ActiveSupport dependency
+- **0.1.0**: Initial release with comprehensive AI capabilities
+
+## Contributing
+
+Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this project.
+
+## License
+
+This project is licensed under the MIT License with Non-Commercial Use Restrictions - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+For support, please open an issue on GitHub or contact the maintainer at amahdanieljack@gmail.com.
+
+## Commercial Licensing
+
+For commercial use, please contact amahdanieljack@gmail.com for licensing information. Commercial license fee: $999/year.

data/lib/rails_ai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAi
-  VERSION = "0.2.3"
+  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
-    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)
+      @performance_monitor ||= Performance::Monitor.new
     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,302 +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 handle_security_error(error, context = {})
+      Security::ErrorHandler.handle_security_error(error, context)
+    end
 
-  def self.sanitize_content(content)
-    Security::ContentSanitizer.sanitize_content(content)
-  end
+    # Response cleaning utility
+    def clean_response(raw_response)
+      return nil if raw_response.nil?
 
-  def self.secure_api_key(env_var, required: true)
-    Security::APIKeyManager.secure_fetch(env_var, required: required)
-  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.mask_api_key(key)
-    Security::APIKeyManager.mask_key(key)
-  end
+    # 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
 
-  def self.log_security_event(event_type, details = {})
-    Security::AuditLogger.log_security_event(event_type, details)
+    # 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
 
-  def self.handle_security_error(error, context = {})
-    Security::ErrorHandler.handle_security_error(error, context)
-  end
 require_relative "rails_ai/web_search"
 
-  # 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)
+# 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
-    else
-      # Regular chat for non-time-sensitive queries
-      chat(prompt, model: model, **opts)
-    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.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Daniel Amah
@@ -279,6 +279,7 @@ files:
 - ".rspec_status"
 - AGENT_GUIDE.md
 - Appraisals
+- CHANGELOG.md
 - COMMERCIAL_LICENSE_TEMPLATE.md
 - FEATURES.md
 - LEGAL_PROTECTION_GUIDE.md
@@ -348,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