rails_ai 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12fd9806ebab3a6d0f461ecc96a964eeee0f60656505374590e9fe12668ec587
-  data.tar.gz: 45e691a4d1de94de3db0ab1019690141d0d2f70bda24e32b629cf101763fd0a4
+  metadata.gz: c840d854535a0a9d4ecd6d2feab11eaf3b41d57774e95f1ea4106d4e85273c6b
+  data.tar.gz: a60c7e6aa407e2b81758209862b13a368716dd271131745657527adb67d0df89
 SHA512:
-  metadata.gz: 787ac2d9154679ec0cb78f27b754812f06cefb1944e159d24726c070fc45dc5a7227c39f9eea3fbc841271e53eafa476a62358c772fd123be41e72557de70a53
-  data.tar.gz: '04892840f6787408f1a9b12cc3f09fa562b05578d947f709a10f4826975685fab7b744030cd1f5da81f9012772c38611a13e4b57427a2f59c303ff5339b13556'
+  metadata.gz: 6ca12e397057425ff91739697b1ee75249aa19bc5db807e6181cd43514257750eeb372a4c25172575943bc6e7aa98cf61da24f5e674b5b97d3d200d232255fa1
+  data.tar.gz: 0b00092ed6b79d49c4bae8ae22eabc49f83386bed45ad18d1c8b72fdc85e2c3d3156438612df900fc3266c37a78b9734a1dd0a03619e9416e3dd4756c6db305c

data/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.5] - 2024-09-21
+
+### Fixed
+- Fixed critical syntax error with unmatched `end` statements in `lib/rails_ai.rb`
+- Resolved `SyntaxError: unexpected 'end'` that was preventing gem loading
+- Properly structured module and method definitions within correct scope
+- Fixed gem loading issues that were causing Rails applications to fail
+
+### Added
+- `clean_response` utility method for automatic UTF-8 encoding and character cleaning
+- `chat_clean` method that automatically cleans AI responses
+- `chat_with_web_search_clean` method with automatic response cleaning
+- Enhanced error handling for malformed responses
+
+### Changed
+- Improved response handling to prevent encoding issues
+- Better UTF-8 character replacement for invalid characters
+- Enhanced error handling for character encoding problems
+
+## [0.2.4] - 2024-09-21
+
+### Fixed
+- Fixed character encoding issues in AI responses
+- Resolved `JSON::GeneratorError` in agent functionality
+- Fixed garbled character display in agent responses
+
+### Added
+- Response cleaning utility methods
+- Enhanced UTF-8 encoding handling
+- Better error handling for malformed responses
+
+### Changed
+- Improved response processing to handle compressed and encoded data
+- Enhanced character encoding validation
+
 ## [0.2.3] - 2024-09-21
 
 ### Fixed
@@ -50,261 +85,183 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [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
+- Web search integration with Google Search and DuckDuckGo providers
+- `WebSearch` module with `GoogleSearch` and `DuckDuckGoSearch` classes
+- `chat_with_web_search` method for real-time information retrieval
+- Support for current events, news, weather, and time-sensitive queries
+- Web search fallback to regular chat if search fails
 
 ### Fixed
-- Fixed `NoMethodError: undefined method 'validate_messages'` in chat functionality
-- Resolved method visibility issues in security module
-- Fixed file loading conflicts between duplicate classes
+- Fixed `SyntaxError: unexpected 'end'` in `lib/rails_ai.rb`
+- Resolved `ArgumentError: unknown keyword: :num_results` in web search
+- Fixed method parameter passing in `WebSearch.search` method
 
 ### Changed
-- Updated security module to use proper file loading
-- Improved error handling and method accessibility
+- Enhanced chat functionality with web search capabilities
+- Improved error handling for web search failures
+- Updated demo application with web search integration
 
 ## [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
+- Fixed `NoMethodError: undefined method 'megabytes'` by adding ActiveSupport dependency
+- Resolved gem loading issues in demo application
+- Fixed `ArgumentError: unknown keyword: :collaboration_strategy` in agent team creation
 
 ### Changed
-- Updated security module to properly load input validator
-- Improved method accessibility
+- Updated `rails_ai.gemspec` to include `activesupport` dependency
+- Enhanced agent team creation with proper parameter handling
+- Improved error handling for missing ActiveSupport extensions
 
 ## [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
+- Fixed method visibility issues with `validate_messages` method
+- Resolved `NoMethodError: undefined method 'validate_messages'` in security validation
+- Fixed file loading conflicts between duplicate `InputValidator` classes
 
 ### Changed
-- Updated security module to use proper file loading
-- Improved method accessibility
+- Updated `lib/rails_ai/security.rb` to properly require input validator
+- Removed duplicate `InputValidator` class definition
+- Enhanced security validation method availability
 
 ## [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
+- Resolved security validation issues in demo application
+- Fixed method visibility in `InputValidator` class
 
 ### Changed
-- Updated security module to properly load input validator
-- Improved method accessibility
+- Moved `validate_messages` method above `private` keyword in `InputValidator`
+- Enhanced security validation 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
+- Fixed `NoMethodError: undefined method 'validate_messages'` in security validation
+- Resolved method availability issues in demo application
+- Fixed security validation method calls
 
 ### Changed
-- Updated security module to properly load input validator
-- Improved method accessibility
+- Updated security validation method definitions
+- Enhanced error handling for security validation
 
 ## [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
+- Fixed CI failure with `rails_ai-0.1.1 contains itself` error
+- Resolved gemspec file inclusion issues
+- Fixed `.gem` file inclusion in `s.files` list
 
 ### Changed
-- Updated gemspec to exclude generated files
-- Added `activesupport` dependency for numeric extensions
-- Improved error handling
+- Updated `rails_ai.gemspec` to exclude generated `.gem` files
+- Added `*.gem` to `.gitignore`
+- Enhanced gemspec file filtering
 
 ## [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
+- Resolved gem loading issues in demo application
+- Fixed `ArgumentError: unknown keyword: :collaboration_strategy` in agent team creation
 
 ### Changed
-- Added `activesupport` dependency for numeric extensions
-- Updated security module to properly load input validator
-- Improved method accessibility
+- Updated `rails_ai.gemspec` to include `activesupport` dependency
+- Enhanced agent team creation with proper parameter handling
+- Improved error handling for missing ActiveSupport extensions
 
 ## [0.1.0] - 2024-09-21
 
 ### Added
 - Initial release of Rails AI gem
-- Multi-provider support for OpenAI, Anthropic (Claude), and Google Gemini
+- Multi-provider support (OpenAI, Anthropic, 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
+- Multimodal capabilities (text, image, video, audio)
+- Agent system with specialized agents and collaboration
+- Context awareness with user and window context
+- Security features including input validation and rate limiting
+- Performance optimizations with connection pooling and caching
+- Web search integration for real-time information
+- Comprehensive demo Rails application
+- Extensive documentation and wiki pages
 
 ### 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
+- **Text Generation**: Support for GPT-4o, GPT-4, GPT-3.5-turbo models
+- **Image Analysis**: Vision models for image understanding
+- **Image Generation**: DALL-E 3 and DALL-E 2 integration
+- **Video Analysis**: Frame extraction and analysis capabilities
+- **Audio Processing**: Whisper integration for speech-to-text
+- **Agent System**: Multi-agent collaboration with specialized roles
+- **Context Awareness**: User preferences and window context integration
+- **Security**: Input validation, rate limiting, content sanitization
+- **Performance**: Connection pooling, smart caching, request deduplication
+- **Web Search**: Real-time information retrieval with Google and DuckDuckGo
 
 ### 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
+- Rate limiting and abuse prevention
+- Content filtering and safety checks
+- API key management and security
+- SSRF protection and secure HTTP client
+- Comprehensive error handling
 
 ### Performance
-- Intelligent caching system
-- Connection pooling for HTTP requests
+- Connection pooling for concurrent requests
+- Smart caching with TTL support
+- Request deduplication to prevent duplicate API calls
+- Performance monitoring and metrics
 - Batch processing capabilities
-- Lazy loading for improved performance
-- Performance monitoring and optimization
-- Memory management and optimization
+- Memory 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
+- API documentation with all methods and parameters
+- Architecture overview and design decisions
+- Security guide and best practices
+- Contributing guidelines and development setup
+- Wiki pages with detailed feature explanations
 
 ### 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
+- Non-commercial license with commercial licensing available
+- Legal protection guide for Canadian jurisdiction
+- Monitoring system for unauthorized commercial use
+- Cease and desist template for enforcement
+- Commercial license template ($999/year)
+
+### Demo Application
+- Complete Rails demo application (`rails_ai_demo`)
+- All features demonstrated with working examples
+- Modern UI with responsive design
+- Real-time streaming chat
+- Image analysis and generation demos
+- Agent system demonstration
+- Context awareness examples
 
----
+### Breaking Changes
+- None (initial release)
 
-## 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
+### Deprecations
+- None (initial release)
 
-## Contributing
+### Removals
+- None (initial release)
 
-Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this project.
+---
 
-## License
+## Contributing
 
-This project is licensed under the MIT License with Non-Commercial Use Restrictions - see the [LICENSE](LICENSE) file for details.
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
 
 ## Support
 
-For support, please open an issue on GitHub or contact the maintainer at amahdanieljack@gmail.com.
+For support and questions:
+- Create an issue on GitHub
+- Check the wiki documentation
+- Review the API documentation
+
+## License
 
-## Commercial Licensing
+This project is licensed under the PolyForm-Noncommercial-1.0.0 License - see the [LICENSE](LICENSE) file for details.
 
-For commercial use, please contact amahdanieljack@gmail.com for licensing information. Commercial license fee: $999/year.
+For commercial use, please contact the author for licensing terms.

data/lib/rails_ai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAi
-  VERSION = "0.2.4"
+  VERSION = "0.2.6"
 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 ||= Performance::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)
-    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 handle_security_error(error, context = {})
+      Security::ErrorHandler.handle_security_error(error, context)
+    end
 
-  def self.secure_api_key(env_var, required: true)
-    Security::APIKeyManager.secure_fetch(env_var, required: required)
-  end
+    # Response cleaning utility
+    def clean_response(raw_response)
+      return nil if raw_response.nil?
 
-  def self.mask_api_key(key)
-    Security::APIKeyManager.mask_key(key)
-  end
-
-  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.6
 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