rails_ai 0.1.0

data/lib/rails_ai/agents/collaboration.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class Collaboration
+      attr_reader :id, :task, :agents, :manager, :status, :created_at
+
+      def initialize(task:, agents:, manager:)
+        @id = SecureRandom.uuid
+        @task = task
+        @agents = Array(agents)
+        @manager = manager
+        @status = :pending
+        @created_at = Time.now
+        @contributions = {}
+        @workflow = []
+        @current_phase = 0
+        @phases = build_workflow_phases
+      end
+
+      def start!
+        @status = :in_progress
+        @started_at = Time.now
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Collaboration #{@id} started with #{@agents.length} agents")
+        
+        # Begin the collaboration workflow
+        execute_workflow_phase
+        self
+      end
+
+      def add_contribution(agent_name, contribution)
+        @contributions[agent_name] = {
+          content: contribution,
+          timestamp: Time.now,
+          phase: @current_phase
+        }
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{agent_name} contributed to collaboration #{@id}")
+        
+        # Check if current phase is complete
+        if phase_complete?
+          advance_to_next_phase
+        end
+      end
+
+      def get_contributions(agent_name = nil)
+        if agent_name
+          @contributions[agent_name]
+        else
+          @contributions
+        end
+      end
+
+      def get_phase_contributions(phase)
+        @contributions.select { |_, contrib| contrib[:phase] == phase }
+      end
+
+      def current_phase_info
+        return nil if @current_phase >= @phases.length
+        
+        @phases[@current_phase]
+      end
+
+      def is_complete?
+        @status == :completed
+      end
+
+      def is_failed?
+        @status == :failed
+      end
+
+      def duration
+        return nil unless @started_at
+        
+        end_time = @completed_at || Time.now
+        end_time - @started_at
+      end
+
+      def summary
+        {
+          id: @id,
+          task: @task,
+          agents: @agents.map(&:name),
+          status: @status,
+          current_phase: @current_phase,
+          total_phases: @phases.length,
+          contributions_count: @contributions.length,
+          duration: duration,
+          created_at: @created_at,
+          started_at: @started_at,
+          completed_at: @completed_at
+        }
+      end
+
+      def complete!(result = nil)
+        @status = :completed
+        @completed_at = Time.now
+        @result = result
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Collaboration #{@id} completed in #{duration&.round(2)} seconds")
+        
+        # Notify all participating agents
+        @agents.each do |agent|
+          @manager.send_message("collaboration_system", agent.name, {
+            type: :collaboration_completed,
+            collaboration_id: @id,
+            result: result
+          })
+        end
+        
+        self
+      end
+
+      def fail!(error)
+        @status = :failed
+        @failed_at = Time.now
+        @error = error
+        
+        defined?(Rails) && Rails.logger && Rails.logger.error("Collaboration #{@id} failed: #{error}")
+        
+        # Notify all participating agents
+        @agents.each do |agent|
+          @manager.send_message("collaboration_system", agent.name, {
+            type: :collaboration_failed,
+            collaboration_id: @id,
+            error: error
+          })
+        end
+        
+        self
+      end
+
+      private
+
+      def build_workflow_phases
+        case @task[:type] || :general
+        when :analysis
+          [
+            { name: "data_gathering", description: "Gather and analyze data", required_agents: @agents.length },
+            { name: "pattern_recognition", description: "Identify patterns and insights", required_agents: @agents.length },
+            { name: "synthesis", description: "Synthesize findings into conclusions", required_agents: 1 }
+          ]
+        when :creative
+          [
+            { name: "brainstorming", description: "Generate creative ideas", required_agents: @agents.length },
+            { name: "refinement", description: "Refine and improve ideas", required_agents: @agents.length },
+            { name: "finalization", description: "Finalize the creative output", required_agents: 1 }
+          ]
+        when :problem_solving
+          [
+            { name: "problem_analysis", description: "Analyze the problem thoroughly", required_agents: @agents.length },
+            { name: "solution_generation", description: "Generate potential solutions", required_agents: @agents.length },
+            { name: "solution_evaluation", description: "Evaluate and select best solution", required_agents: @agents.length },
+            { name: "implementation_plan", description: "Create implementation plan", required_agents: 1 }
+          ]
+        else
+          [
+            { name: "discussion", description: "Discuss the task", required_agents: @agents.length },
+            { name: "consensus", description: "Reach consensus on approach", required_agents: @agents.length },
+            { name: "execution", description: "Execute the agreed approach", required_agents: 1 }
+          ]
+        end
+      end
+
+      def execute_workflow_phase
+        return if @current_phase >= @phases.length
+        
+        phase = @phases[@current_phase]
+        
+        # Notify agents about the new phase
+        @agents.each do |agent|
+          @manager.send_message("collaboration_system", agent.name, {
+            type: :collaboration_phase,
+            collaboration_id: @id,
+            phase: phase,
+            phase_number: @current_phase + 1,
+            total_phases: @phases.length
+          })
+        end
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Collaboration #{@id} started phase #{@current_phase + 1}: #{phase[:name]}")
+      end
+
+      def phase_complete?
+        return false if @current_phase >= @phases.length
+        
+        phase = @phases[@current_phase]
+        current_contributions = get_phase_contributions(@current_phase)
+        
+        current_contributions.length >= phase[:required_agents]
+      end
+
+      def advance_to_next_phase
+        @current_phase += 1
+        
+        if @current_phase >= @phases.length
+          # All phases complete, synthesize final result
+          synthesize_result
+        else
+          # Start next phase
+          execute_workflow_phase
+        end
+      end
+
+      def synthesize_result
+        # Combine all contributions into a final result
+        all_contributions = @contributions.values.map { |c| c[:content] }
+        
+        synthesis_prompt = build_synthesis_prompt(all_contributions)
+        
+        # Use the first agent to synthesize (or could use a dedicated synthesis agent)
+        synthesizer = @agents.first
+        result = synthesizer.think(synthesis_prompt, context: {
+          task: @task,
+          contributions: all_contributions,
+          collaboration_id: @id
+        })
+        
+        complete!(result)
+      end
+
+      def build_synthesis_prompt(contributions)
+        <<~PROMPT
+          You are synthesizing the results of a multi-agent collaboration.
+
+          Original Task: #{@task[:description]}
+
+          Agent Contributions:
+          #{contributions.map.with_index { |c, i| "#{i + 1}. #{c}" }.join("\n")}
+
+          Please synthesize these contributions into a coherent, comprehensive result that addresses the original task.
+          Consider the different perspectives and insights provided by each agent.
+        PROMPT
+      end
+    end
+  end
+end

data/lib/rails_ai/agents/memory.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class Memory
+      IMPORTANCE_LEVELS = {
+        critical: 4,
+        high: 3,
+        normal: 2,
+        low: 1
+      }.freeze
+
+      def initialize(max_size: 1000)
+        @max_size = max_size
+        @memories = []
+        @index = {}
+      end
+
+      def add(key, value, importance: :normal)
+        memory_item = {
+          key: key,
+          value: value,
+          importance: importance,
+          importance_score: IMPORTANCE_LEVELS[importance] || 2,
+          created_at: Time.now,
+          accessed_at: Time.now,
+          access_count: 0
+        }
+
+        # Remove oldest low-importance memory if at capacity
+        if @memories.length >= @max_size
+          remove_oldest_low_importance
+        end
+
+        @memories << memory_item
+        @index[key] = memory_item
+        memory_item
+      end
+
+      def get(key)
+        memory_item = @index[key]
+        return nil unless memory_item
+
+        memory_item[:accessed_at] = Time.now
+        memory_item[:access_count] += 1
+        memory_item[:value]
+      end
+
+      def remove(key)
+        memory_item = @index.delete(key)
+        return nil unless memory_item
+
+        @memories.delete(memory_item)
+        memory_item[:value]
+      end
+
+      def search(query, limit: 10)
+        query_lower = query.downcase
+        
+        @memories
+          .select do |memory|
+            memory[:value].to_s.downcase.include?(query_lower) ||
+            memory[:key].to_s.downcase.include?(query_lower)
+          end
+          .sort_by { |memory| -memory[:importance_score] }
+          .first(limit)
+          .map { |memory| memory[:value] }
+      end
+
+      def recent(count = 10)
+        @memories
+          .sort_by { |memory| -memory[:created_at].to_f }
+          .first(count)
+          .map { |memory| { key: memory[:key], value: memory[:value], created_at: memory[:created_at] } }
+      end
+
+      def important(count = 5)
+        @memories
+          .select { |memory| memory[:importance_score] >= 3 }
+          .sort_by { |memory| -memory[:importance_score] }
+          .first(count)
+          .map { |memory| { key: memory[:key], value: memory[:value], importance: memory[:importance] } }
+      end
+
+      def usage_percentage
+        (@memories.length.to_f / @max_size * 100).round(2)
+      end
+
+      def clear!
+        @memories.clear
+        @index.clear
+      end
+
+      def size
+        @memories.length
+      end
+
+      def empty?
+        @memories.empty?
+      end
+
+      private
+
+      def remove_oldest_low_importance
+        oldest_low_importance = @memories
+          .select { |memory| memory[:importance_score] <= 2 }
+          .min_by { |memory| memory[:created_at] }
+
+        if oldest_low_importance
+          @memories.delete(oldest_low_importance)
+          @index.delete(oldest_low_importance[:key])
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai/agents/message_bus.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class MessageBus
+      def initialize
+        @subscribers = {}
+        @message_history = []
+        @max_history = 10000
+      end
+
+      def subscribe(agent_name, agent)
+        @subscribers[agent_name] = agent
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{agent_name} subscribed to message bus")
+      end
+
+      def unsubscribe(agent_name)
+        @subscribers.delete(agent_name)
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{agent_name} unsubscribed from message bus")
+      end
+
+      def send_message(from_agent, to_agent, message)
+        return false unless @subscribers[to_agent]
+
+        message_obj = {
+          id: SecureRandom.uuid,
+          from: from_agent,
+          to: to_agent,
+          content: message,
+          timestamp: Time.now,
+          delivered: false
+        }
+
+        begin
+          @subscribers[to_agent].receive_message(message_obj)
+          message_obj[:delivered] = true
+          @message_history << message_obj
+          trim_history
+          defined?(Rails) && Rails.logger && Rails.logger.info("Message sent from #{from_agent} to #{to_agent}")
+          true
+        rescue => e
+          defined?(Rails) && Rails.logger && Rails.logger.error("Failed to deliver message: #{e.message}")
+          false
+        end
+      end
+
+      def broadcast(from_agent, message, exclude: [])
+        delivered_count = 0
+        
+        @subscribers.each do |agent_name, agent|
+          next if exclude.include?(agent_name) || agent_name == from_agent
+
+          if send_message(from_agent, agent_name, message)
+            delivered_count += 1
+          end
+        end
+
+        defined?(Rails) && Rails.logger && Rails.logger.info("Broadcast message from #{from_agent} to #{delivered_count} agents")
+        delivered_count
+      end
+
+      def get_messages_for_agent(agent_name, from_agent: nil, limit: 100)
+        messages = @message_history.select { |m| m[:to] == agent_name }
+        messages = messages.select { |m| m[:from] == from_agent } if from_agent
+        messages.last(limit)
+      end
+
+      def get_message_history(limit: 1000)
+        @message_history.last(limit)
+      end
+
+      def clear_history!
+        @message_history.clear
+        defined?(Rails) && Rails.logger && Rails.logger.info("Message history cleared")
+      end
+
+      def stats
+        {
+          total_subscribers: @subscribers.length,
+          total_messages: @message_history.length,
+          delivered_messages: @message_history.count { |m| m[:delivered] },
+          failed_messages: @message_history.count { |m| !m[:delivered] }
+        }
+      end
+
+      private
+
+      def trim_history
+        return if @message_history.length <= @max_history
+
+        @message_history = @message_history.last(@max_history)
+      end
+    end
+  end
+end