rails_ai 0.1.0

data/app/helpers/ai_helper.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module AiHelper
+  # Text-based AI operations
+  def ai_chat(prompt, model: nil, **options)
+    RailsAi.chat(prompt, model: model, **options)
+  end
+
+  def ai_stream(prompt, model: nil, **options, &block)
+    RailsAi.stream(prompt, model: model, **options, &block)
+  end
+
+  def ai_embed(texts, model: nil, **options)
+    RailsAi.embed(texts, model: model, **options)
+  end
+
+  # Image generation
+  def ai_generate_image(prompt, model: "dall-e-3", size: "1024x1024", **options)
+    RailsAi.generate_image(prompt, model: model, size: size, **options)
+  end
+
+  def ai_edit_image(image, prompt, **options)
+    RailsAi.edit_image(image, prompt, **options)
+  end
+
+  def ai_create_variation(image, **options)
+    RailsAi.create_variation(image, **options)
+  end
+
+  # Video generation
+  def ai_generate_video(prompt, model: "sora", duration: 5, **options)
+    RailsAi.generate_video(prompt, model: model, duration: duration, **options)
+  end
+
+  def ai_edit_video(video, prompt, **options)
+    RailsAi.edit_video(video, prompt, **options)
+  end
+
+  # Audio generation
+  def ai_generate_speech(text, voice: "alloy", **options)
+    RailsAi.generate_speech(text, voice: voice, **options)
+  end
+
+  def ai_transcribe_audio(audio, **options)
+    RailsAi.transcribe_audio(audio, **options)
+  end
+
+  # Multimodal analysis
+  def ai_analyze_image(image, prompt, **options)
+    RailsAi.analyze_image(image, prompt, **options)
+  end
+
+  def ai_analyze_video(video, prompt, **options)
+    RailsAi.analyze_video(video, prompt, **options)
+  end
+
+  # Context-aware AI operations
+  def ai_analyze_image_with_context(image, prompt, user_context: {}, window_context: {}, image_context: {}, **options)
+    RailsAi.analyze_image_with_context(image, prompt, 
+      user_context: user_context, 
+      window_context: window_context, 
+      image_context: image_context, 
+      **options
+    )
+  end
+
+  def ai_generate_with_context(prompt, user_context: {}, window_context: {}, **options)
+    RailsAi.generate_with_context(prompt, 
+      user_context: user_context, 
+      window_context: window_context, 
+      **options
+    )
+  end
+
+  def ai_generate_image_with_context(prompt, user_context: {}, window_context: {}, **options)
+    RailsAi.generate_image_with_context(prompt, 
+      user_context: user_context, 
+      window_context: window_context, 
+      **options
+    )
+  end
+
+  # Convenience methods for common AI tasks
+  def ai_summarize(content, model: nil, **options)
+    RailsAi.summarize(content, model: model, **options)
+  end
+
+  def ai_translate(content, target_language, **options)
+    RailsAi.translate(content, target_language, **options)
+  end
+
+  def ai_classify(content, categories, **options)
+    RailsAi.classify(content, categories, **options)
+  end
+
+  def ai_extract_entities(content, **options)
+    RailsAi.extract_entities(content, **options)
+  end
+
+  def ai_generate_code(prompt, language: "ruby", **options)
+    RailsAi.generate_code(prompt, language: language, **options)
+  end
+
+  def ai_explain_code(code, language: "ruby", **options)
+    RailsAi.explain_code(code, language: language, **options)
+  end
+
+  # Context extraction helpers
+  def ai_user_context
+    return {} unless respond_to?(:current_user) && current_user
+
+    {
+      id: current_user.id,
+      email: current_user.respond_to?(:email) ? current_user.email : nil,
+      role: current_user.respond_to?(:role) ? current_user.role : 'user',
+      created_at: current_user.created_at,
+      preferences: extract_user_preferences
+    }.compact
+  end
+
+  def ai_window_context
+    {
+      controller: controller_name,
+      action: action_name,
+      params: params.except('password', 'password_confirmation', 'token', 'secret', 'key'),
+      user_agent: request.user_agent,
+      referer: request.referer,
+      ip_address: request.remote_ip,
+      timestamp: Time.current.iso8601
+    }
+  end
+
+  def ai_image_context(image_data)
+    RailsAi::ImageContext.new(image_data).to_h
+  end
+
+  # Utility methods
+  def ai_stream_id
+    @ai_stream_id ||= SecureRandom.uuid
+  end
+
+  def ai_redact(text)
+    RailsAi::Redactor.call(text)
+  end
+
+  def ai_safe_content(text)
+    RailsAi::Redactor.call(text)
+  end
+
+  private
+
+  def extract_user_preferences
+    return {} unless current_user.respond_to?(:preferences)
+
+    case current_user.preferences
+    when Hash
+      current_user.preferences
+    when String
+      JSON.parse(current_user.preferences) rescue {}
+    else
+      {}
+    end
+  end
+end

data/app/jobs/ai/generate_embedding_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsAi
+  class GenerateEmbeddingJob < ApplicationJob
+    queue_as :default
+
+    def perform(text, model: nil, **options)
+      model ||= RailsAi.config.default_model
+
+      embedding = RailsAi.provider.embed!(
+        texts: [text],
+        model: model,
+        **options
+      ).first
+
+      RailsAi::Events.log!(
+        kind: :embedding,
+        name: "generated",
+        payload: {text_length: text.length, model: model}
+      )
+
+      embedding
+    end
+  end
+end

data/app/jobs/ai/generate_summary_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsAi
+  class GenerateSummaryJob < ApplicationJob
+    queue_as :default
+
+    def perform(content, model: nil, **options)
+      model ||= RailsAi.config.default_model
+
+      summary = RailsAi.chat(
+        "Please provide a concise summary of the following content: #{content}",
+        model: model,
+        **options
+      )
+
+      RailsAi::Events.log!(
+        kind: :summary,
+        name: "generated",
+        payload: {content_length: content.length, model: model}
+      )
+
+      summary
+    end
+  end
+end

data/app/models/concerns/ai/embeddable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Embeddable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :ai_embeddings, as: :embeddable, dependent: :destroy
+    end
+
+    def generate_embedding!(field: :content, model: nil)
+      text = send(field)
+      return if text.blank?
+
+      model ||= RailsAi.config.default_model
+
+      embedding = RailsAi.provider.embed!(
+        texts: [text],
+        model: model
+      ).first
+
+      ai_embeddings.create!(
+        content: text,
+        embedding: embedding,
+        model: model,
+        field: field.to_s
+      )
+    end
+
+    def similar_records(limit: 5, threshold: 0.8)
+      return [] unless ai_embeddings.any?
+
+      # This would need to be implemented based on your vector database
+      # For now, return empty array
+      []
+    end
+  end
+end

data/app/views/rails_ai/dashboard/index.html.erb

@@ -0,0 +1,51 @@
+<%# frozen_string_literal: true %>
+
+<div class="rails-ai-dashboard">
+  <h1>Rails AI Dashboard</h1>
+  
+  <div class="ai-chat-interface">
+    <%= render RailsAi::PromptComponent.new(
+      prompt: "Hello, how can I help you today?",
+      stream_id: ai_stream_id
+    ) %>
+  </div>
+
+  <div class="ai-features">
+    <h2>Available Features</h2>
+    <ul>
+      <li>AI Chat Interface</li>
+      <li>Content Summarization</li>
+      <li>Embedding Generation</li>
+      <li>Streaming Responses</li>
+    </ul>
+  </div>
+
+  <div class="ai-config">
+    <h2>Configuration</h2>
+    <p>Provider: <%= RailsAi.config.provider %></p>
+    <p>Model: <%= RailsAi.config.default_model %></p>
+    <p>Cache TTL: <%= RailsAi.config.cache_ttl %></p>
+  </div>
+</div>
+
+<style>
+.rails-ai-dashboard {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+.ai-chat-interface {
+  margin: 20px 0;
+  padding: 20px;
+  border: 1px solid #ddd;
+  border-radius: 8px;
+}
+
+.ai-features, .ai-config {
+  margin: 20px 0;
+  padding: 15px;
+  background-color: #f9f9f9;
+  border-radius: 8px;
+}
+</style>

data/config/routes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RailsAi::Engine.routes.draw do
+  root "dashboard#index"
+
+  resources :streams, only: [:create] do
+    member do
+      post :stream
+    end
+  end
+
+  namespace :api do
+    namespace :v1 do
+      resources :chat, only: [:create]
+      resources :embeddings, only: [:create]
+      resources :summarize, only: [:create]
+    end
+  end
+end

data/lib/generators/rails_ai/install/install_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_initializer
+        copy_file "initializer.rb", "config/initializers/rails_ai.rb"
+      end
+
+      def create_migrations
+        copy_file "ai_migrations.rb", "db/migrate/#{Time.current.strftime("%Y%m%d%H%M%S")}_create_ai_tables.rb"
+      end
+
+      def create_jobs
+        copy_file "summarizer_job.rb", "app/jobs/ai/generate_summary_job.rb"
+        copy_file "summarizer_service.rb", "app/services/ai/summarizer_service.rb"
+      end
+
+      def create_helpers
+        copy_file "ai_helper.rb", "app/helpers/ai_helper.rb"
+      end
+
+      def create_components
+        copy_file "ai_widget_component.rb", "app/components/ai/prompt_component.rb"
+      end
+
+      def add_routes
+        route 'mount RailsAi::Engine, at: "/rails_ai"'
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/rails_ai/agents/agent_manager.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class AgentManager
+      attr_reader :agents, :message_bus, :task_queue
+
+      def initialize
+        @agents = {}
+        @message_bus = MessageBus.new
+        @task_queue = TaskQueue.new
+        @running = false
+        @thread_pool = Concurrent::ThreadPoolExecutor.new(
+          min_threads: 2,
+          max_threads: 10,
+          max_queue: 100
+        )
+      end
+
+      # Agent lifecycle management
+      def register_agent(agent)
+        @agents[agent.name] = agent
+        @message_bus.subscribe(agent.name, agent)
+        defined?(Rails) && Rails.logger && Rails.logger.info("Registered agent: #{agent.name}")
+        agent
+      end
+
+      def unregister_agent(agent_name)
+        agent = @agents.delete(agent_name)
+        return false unless agent
+
+        @message_bus.unsubscribe(agent_name)
+        agent.stop!
+        defined?(Rails) && Rails.logger && Rails.logger.info("Unregistered agent: #{agent_name}")
+        true
+      end
+
+      def get_agent(agent_name)
+        @agents[agent_name]
+      end
+
+      def list_agents
+        @agents.values.map(&:status)
+      end
+
+      # Task management
+      def submit_task(task)
+        @task_queue.enqueue(task)
+        defined?(Rails) && Rails.logger && Rails.logger.info("Submitted task: #{task[:description]}")
+        task
+      end
+
+      def assign_task_to_agent(task, agent_name)
+        agent = get_agent(agent_name)
+        return false unless agent
+
+        agent.assign_task(task)
+      end
+
+      def find_best_agent_for_task(task)
+        available_agents = @agents.values.select { |agent| agent.state == :active }
+        
+        return nil if available_agents.empty?
+
+        # Score agents based on capabilities and current workload
+        scored_agents = available_agents.map do |agent|
+          score = calculate_agent_score(agent, task)
+          { agent: agent, score: score }
+        end
+
+        scored_agents.max_by { |item| item[:score] }&.dig(:agent)
+      end
+
+      def auto_assign_task(task)
+        best_agent = find_best_agent_for_task(task)
+        return false unless best_agent
+
+        assign_task_to_agent(task, best_agent.name)
+      end
+
+      # Communication
+      def send_message(from_agent, to_agent, message)
+        @message_bus.send_message(from_agent, to_agent, message)
+      end
+
+      def broadcast_message(from_agent, message, exclude: [])
+        @message_bus.broadcast(from_agent, message, exclude: exclude)
+      end
+
+      # System control
+      def start!
+        return false if @running
+
+        @running = true
+        start_task_processor
+        start_agent_monitor
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent Manager started")
+        true
+      end
+
+      def stop!
+        return false unless @running
+
+        @running = false
+        @thread_pool.shutdown
+        @thread_pool.wait_for_termination(30)
+        
+        @agents.each_value(&:stop!)
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent Manager stopped")
+        true
+      end
+
+      def pause!
+        @running = false
+        @agents.each_value(&:pause!)
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent Manager paused")
+      end
+
+      def resume!
+        @running = true
+        @agents.each_value(&:resume!)
+        start_task_processor
+        start_agent_monitor
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent Manager resumed")
+      end
+
+      # Monitoring and health
+      def system_status
+        {
+          running: @running,
+          total_agents: @agents.length,
+          active_agents: @agents.values.count { |a| a.state == :active },
+          paused_agents: @agents.values.count { |a| a.state == :paused },
+          stopped_agents: @agents.values.count { |a| a.state == :stopped },
+          pending_tasks: @task_queue.size,
+          total_tasks_processed: @task_queue.total_processed,
+          thread_pool_status: @thread_pool.running?
+        }
+      end
+
+      def health_check
+        agent_health = @agents.values.map do |agent|
+          { name: agent.name, health: agent.health_check }
+        end
+
+        {
+          system_healthy: @running && @thread_pool.running?,
+          agent_health: agent_health,
+          memory_usage: calculate_memory_usage,
+          task_queue_healthy: @task_queue.size < 1000
+        }
+      end
+
+      # Agent collaboration
+      def create_agent_team(team_name, agents, collaboration_strategy: :round_robin)
+        team = AgentTeam.new(
+          name: team_name,
+          agents: agents,
+          strategy: collaboration_strategy,
+          manager: self
+        )
+        
+        team.agents.each { |agent| register_agent(agent) }
+        team
+      end
+
+      def orchestrate_collaboration(task, agent_names)
+        agents = agent_names.map { |name| get_agent(name) }.compact
+        return false if agents.empty?
+
+        collaboration = Collaboration.new(
+          task: task,
+          agents: agents,
+          manager: self
+        )
+
+        collaboration.start!
+        collaboration
+      end
+
+      private
+
+      def calculate_agent_score(agent, task)
+        score = 0
+
+        # Capability match (40% of score)
+        required_capabilities = task[:required_capabilities] || []
+        capability_match = required_capabilities.count { |cap| agent.has_capability?(cap) }
+        score += (capability_match.to_f / required_capabilities.length * 40) if required_capabilities.any?
+
+        # Current workload (30% of score)
+        workload_score = [0, 30 - (agent.active_tasks.length * 10)].max
+        score += workload_score
+
+        # Memory health (20% of score)
+        memory_score = agent.memory.usage_percentage < 80 ? 20 : 10
+        score += memory_score
+
+        # Recent activity (10% of score)
+        activity_score = (Time.now - agent.last_activity) < 5 * 60 ? 10 : 5
+        score += activity_score
+
+        score
+      end
+
+      def calculate_memory_usage
+        total_memory = @agents.values.sum { |agent| agent.memory.size }
+        total_capacity = @agents.values.sum { |agent| agent.memory.instance_variable_get(:@max_size) }
+        
+        return 0 if total_capacity.zero?
+        
+        (total_memory.to_f / total_capacity * 100).round(2)
+      end
+
+      def start_task_processor
+        @thread_pool.post do
+          while @running
+            begin
+              task = @task_queue.dequeue(timeout: 1)
+              next unless task
+
+              best_agent = find_best_agent_for_task(task)
+              if best_agent
+                assign_task_to_agent(task, best_agent.name)
+              else
+                # No available agent, re-queue task
+                @task_queue.enqueue(task, priority: :high)
+                sleep(5) # Wait before retrying
+              end
+            rescue => e
+              defined?(Rails) && Rails.logger && Rails.logger.error("Task processor error: #{e.message}")
+              sleep(1)
+            end
+          end
+        end
+      end
+
+      def start_agent_monitor
+        @thread_pool.post do
+          while @running
+            begin
+              @agents.each_value do |agent|
+                health = agent.health_check
+                unless health.values.all?
+                  defined?(Rails) && Rails.logger && Rails.logger.warn("Agent #{agent.name} health issues: #{health}")
+                end
+              end
+              sleep(30) # Check every 30 seconds
+            rescue => e
+              defined?(Rails) && Rails.logger && Rails.logger.error("Agent monitor error: #{e.message}")
+              sleep(5)
+            end
+          end
+        end
+      end
+    end
+  end
+end