rails_ai 0.1.0

data/lib/rails_ai.rb

@@ -0,0 +1,502 @@
+# frozen_string_literal: true
+
+require "rails"
+require "concurrent-ruby"
+require "zlib"
+require "digest"
+require "net/http"
+require "json"
+require "base64"
+require "securerandom"
+require_relative "rails_ai/version"
+require_relative "rails_ai/config"
+require_relative "rails_ai/context"
+require_relative "rails_ai/cache"
+require_relative "rails_ai/redactor"
+require_relative "rails_ai/events"
+require_relative "rails_ai/provider"
+require_relative "rails_ai/engine"
+require_relative "rails_ai/railtie"
+require_relative "rails_ai/providers/base"
+require_relative "rails_ai/providers/secure_openai_adapter"
+require_relative "rails_ai/providers/secure_anthropic_adapter"
+require_relative "rails_ai/providers/gemini_adapter"
+require_relative "rails_ai/providers/dummy_adapter"
+require_relative "rails_ai/context_analyzer"
+require_relative "rails_ai/window_context"
+require_relative "rails_ai/image_context"
+require_relative "rails_ai/performance"
+require_relative "rails_ai/agents/base_agent"
+require_relative "rails_ai/agents/memory"
+require_relative "rails_ai/agents/agent_manager"
+require_relative "rails_ai/agents/message_bus"
+require_relative "rails_ai/agents/task_queue"
+require_relative "rails_ai/agents/agent_team"
+require_relative "rails_ai/agents/collaboration"
+require_relative "rails_ai/agents/specialized_agents"
+require_relative "rails_ai/security"
+
+module RailsAi
+  # Performance optimizations
+  @connection_pool = nil
+  @batch_processor = nil
+  @smart_cache = nil
+  @request_deduplicator = nil
+  @performance_monitor = nil
+  @agent_manager = nil
+
+  class << self
+    # Version compatibility helpers
+    def rails_version
+      Rails.version.to_s
+    end
+
+    def rails_8?
+      Rails.version >= "8.0"
+    end
+
+    def rails_7?
+      Rails.version >= "7.0" && Rails.version < "8.0"
+    end
+
+    def rails_6?
+      Rails.version >= "6.0" && Rails.version < "7.0"
+    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
+      )
+      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, 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)
+    end
+
+    # Agent monitoring
+    def agent_system_status
+      agent_manager.system_status
+    end
+
+    def agent_health_check
+      agent_manager.health_check
+    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
+      )
+    end
+
+    # Optimized text-based AI operations with performance monitoring
+    def chat(prompt_or_messages, model: config.default_model, **opts)
+      performance_monitor.measure(:chat) do
+        messages = normalize_messages(prompt_or_messages)
+        cache_key = [:chat, model, messages.hash]
+        
+        smart_cache.fetch(cache_key, expires_in: config.cache_ttl) do
+          request_deduplicator.deduplicate(cache_key) do
+            provider.chat!(messages: messages, model: model, **opts)
+          end
+        end
+      end
+    end
+
+    def stream(prompt_or_messages, model: config.default_model, **opts, &block)
+      performance_monitor.measure(:stream) do
+        messages = normalize_messages(prompt_or_messages)
+        
+        # Use connection pool for streaming
+        connection_pool.with_connection do |connection|
+          provider.stream_chat!(messages: messages, model: model, **opts, &block)
+        end
+      end
+    end
+
+    def embed(texts, model: config.default_model, **opts)
+      performance_monitor.measure(:embed) do
+        texts = Array(texts)
+        cache_key = [:embed, model, texts.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)
+          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
+      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
+      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
+      end
+    end
+
+    # Optimized video operations
+    def generate_video(prompt, model: "sora", duration: 5, **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
+      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
+      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
+      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
+      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
+      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
+      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
+    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
+    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
+    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
+    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
+    end
+
+    # Convenience methods for common AI tasks (optimized)
+    def summarize(content, **opts)
+      chat("Summarize the following content: #{content}", **opts)
+    end
+
+    def translate(content, target_language, **opts)
+      chat("Translate the following content to #{target_language}: #{content}", **opts)
+    end
+
+    def classify(content, categories, **opts)
+      chat("Classify the following content into one of these categories: #{categories.join(", ")}. Content: #{content}", **opts)
+    end
+
+    def extract_entities(content, **opts)
+      chat("Extract named entities from the following content: #{content}", **opts)
+    end
+
+    def generate_code(prompt, language: "ruby", **opts)
+      chat("Generate #{language} code for: #{prompt}", **opts)
+    end
+
+    def explain_code(code, language: "ruby", **opts)
+      chat("Explain this #{language} code: #{code}", **opts)
+    end
+
+    # Performance utilities
+    def warmup!
+      # Pre-initialize components for faster first requests
+      provider
+      connection_pool
+      smart_cache
+      request_deduplicator
+      batch_processor
+      agent_manager
+    end
+
+    def clear_cache!
+      Rails.cache.delete_matched("rails_ai:*") if defined?(Rails) && Rails.cache
+    end
+
+    def reset_performance_metrics!
+      @performance_monitor = Performance::PerformanceMonitor.new
+    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
+    end
+  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 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
+
+  def self.handle_security_error(error, context = {})
+    Security::ErrorHandler.handle_security_error(error, context)
+  end

data/monitoring/ci_setup_guide.md

@@ -0,0 +1,214 @@
+# CI Monitoring Setup Guide
+
+## 🚀 Continuous Monitoring via GitHub Actions
+
+Your Rails AI gem now has automated monitoring that runs continuously!
+
+## 📋 What's Set Up
+
+### 1. Daily Monitoring Workflow (`.github/workflows/monitoring.yml`)
+- **Runs**: Every day at 9 AM UTC
+- **Manual**: Can be triggered manually
+- **Triggers**: On pushes to main branch
+- **Checks**: RubyGems, GitHub, Google searches
+- **Outputs**: Monitoring reports and logs
+
+### 2. Security Monitoring Workflow (`.github/workflows/security-monitoring.yml`)
+- **Runs**: Every 6 hours
+- **Focus**: Security and plagiarism detection
+- **Checks**: Code similarity, package conflicts
+- **Outputs**: Security reports
+
+## 🔧 Setup Steps
+
+### Step 1: Enable GitHub Actions
+1. Go to your GitHub repository
+2. Click "Actions" tab
+3. Enable GitHub Actions if not already enabled
+
+### Step 2: Add API Keys (Optional but Recommended)
+1. Go to repository Settings → Secrets and variables → Actions
+2. Add these secrets:
+   - `GOOGLE_API_KEY`: For Google search monitoring
+   - `GITHUB_PAT`: For GitHub API access
+   - `RUBYGEMS_API_KEY`: For RubyGems API access
+
+### Step 3: Test the Workflows
+1. Go to Actions tab
+2. Click "Rails AI Monitoring"
+3. Click "Run workflow" to test manually
+
+## �� Monitoring Outputs
+
+### Daily Reports
+- **Location**: Actions → Artifacts
+- **Files**: `monitoring-results-{run_number}`
+- **Content**: Detailed monitoring logs
+
+### Security Reports
+- **Location**: Actions → Artifacts
+- **Files**: `security-report-{run_number}`
+- **Content**: Security and plagiarism checks
+
+## 🔔 Notifications
+
+### Email Notifications
+- GitHub will email you when workflows fail
+- Set up email notifications in GitHub settings
+
+### Slack/Discord Integration (Optional)
+Add this to your workflow for Slack notifications:
+
+```yaml
+- name: Notify Slack
+  if: failure()
+  uses: 8398a7/action-slack@v3
+  with:
+    status: failure
+    text: "Rails AI monitoring found potential issues!"
+  env:
+    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+```
+
+## 📈 Monitoring Schedule
+
+### Daily (9 AM UTC)
+- RubyGems package monitoring
+- GitHub repository searches
+- Google search monitoring
+- Generate monitoring report
+
+### Every 6 Hours
+- Security checks
+- Code plagiarism detection
+- Package conflict detection
+- Generate security report
+
+## 🛠️ Customization
+
+### Change Schedule
+Edit the cron expressions in the workflow files:
+```yaml
+schedule:
+  - cron: '0 9 * * *'  # Daily at 9 AM UTC
+  - cron: '0 */6 * * *'  # Every 6 hours
+```
+
+### Add More Checks
+Add new monitoring steps to the workflow:
+```yaml
+- name: Check specific website
+  run: |
+    curl -s "https://example.com/search?q=rails_ai" | grep -i "commercial"
+```
+
+### Add More APIs
+Add API keys to repository secrets and use them:
+```yaml
+env:
+  CUSTOM_API_KEY: ${{ secrets.CUSTOM_API_KEY }}
+```
+
+## 📱 Mobile Monitoring
+
+### GitHub Mobile App
+- Get notifications on your phone
+- View monitoring results anywhere
+- Respond to alerts immediately
+
+### Email Alerts
+- Set up email notifications for failures
+- Get daily monitoring summaries
+- Receive security alerts
+
+## 🔍 What Gets Monitored
+
+### RubyGems
+- New packages with similar names
+- Commercial usage in descriptions
+- Download statistics
+- Package dependencies
+
+### GitHub
+- Repositories using your gem
+- Forks of your code
+- Similar project names
+- Commercial usage indicators
+
+### Google Search
+- Web mentions of your gem
+- Commercial usage discussions
+- Competitor analysis
+- Brand monitoring
+
+## 🚨 Alert Conditions
+
+### High Priority
+- Direct code copying
+- Commercial use without license
+- Trademark infringement
+- Patent violations
+
+### Medium Priority
+- Similar package names
+- Competitive analysis
+- Usage discussions
+- Feature requests
+
+### Low Priority
+- General mentions
+- Educational usage
+- Open source contributions
+- Community discussions
+
+## 📊 Monitoring Dashboard
+
+### GitHub Actions Tab
+- View all monitoring runs
+- See success/failure status
+- Download monitoring reports
+- View detailed logs
+
+### Artifacts
+- Download monitoring results
+- View security reports
+- Analyze trends over time
+- Share reports with legal team
+
+## 🔧 Troubleshooting
+
+### Common Issues
+1. **Workflow not running**: Check if GitHub Actions is enabled
+2. **API errors**: Verify API keys are set correctly
+3. **Permission errors**: Check repository permissions
+4. **Rate limiting**: Add delays between API calls
+
+### Debug Mode
+Add this to see detailed logs:
+```yaml
+- name: Debug monitoring
+  run: |
+    echo "Debug information:"
+    echo "Date: $(date)"
+    echo "Ruby version: $(ruby --version)"
+    echo "Working directory: $(pwd)"
+```
+
+## 📞 Support
+
+### GitHub Actions Documentation
+- https://docs.github.com/en/actions
+
+### Monitoring Script Issues
+- Check the monitoring_script.rb file
+- Review the monitoring logs
+- Test locally first
+
+### Legal Questions
+- Contact your IP lawyer
+- Review the legal protection guide
+- Use the cease and desist template
+
+---
+
+**Your Rails AI gem is now continuously monitored! 🛡️**