rails_ai 0.1.0

data/lib/rails_ai/agents/agent_team.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class AgentTeam
+      attr_reader :name, :agents, :strategy, :manager, :created_at
+
+      def initialize(name:, agents:, strategy: :round_robin, manager:)
+        @name = name
+        @agents = Array(agents)
+        @strategy = strategy
+        @manager = manager
+        @created_at = Time.now
+        @current_agent_index = 0
+        @team_memory = {}
+        @collaboration_history = []
+      end
+
+      # Team task assignment
+      def assign_task(task)
+        case @strategy
+        when :round_robin
+          assign_round_robin(task)
+        when :capability_based
+          assign_capability_based(task)
+        when :load_balanced
+          assign_load_balanced(task)
+        when :collaborative
+          assign_collaborative(task)
+        else
+          assign_round_robin(task)
+        end
+      end
+
+      def collaborate_on_task(task)
+        return false unless @strategy == :collaborative
+
+        collaboration = {
+          id: SecureRandom.uuid,
+          task: task,
+          agents: @agents.map(&:name),
+          started_at: Time.now,
+          status: :in_progress,
+          contributions: {}
+        }
+
+        # Each agent contributes to the task
+        @agents.each do |agent|
+          begin
+            contribution = agent.collaborate_with(agent, task, context: build_team_context)
+            collaboration[:contributions][agent.name] = contribution
+          rescue => e
+            defined?(Rails) && Rails.logger && Rails.logger.error("Agent #{agent.name} collaboration failed: #{e.message}")
+            collaboration[:contributions][agent.name] = { error: e.message }
+          end
+        end
+
+        collaboration[:completed_at] = Time.now
+        collaboration[:status] = :completed
+        @collaboration_history << collaboration
+
+        defined?(Rails) && Rails.logger && Rails.logger.info("Team #{@name} completed collaborative task: #{task[:description]}")
+        collaboration
+      end
+
+      # Team communication
+      def team_meeting(agenda)
+        meeting = {
+          id: SecureRandom.uuid,
+          agenda: agenda,
+          participants: @agents.map(&:name),
+          started_at: Time.now,
+          discussions: {}
+        }
+
+        # Each agent shares their perspective
+        @agents.each do |agent|
+          perspective = agent.think("Team meeting agenda: #{agenda}. Share your perspective and insights.", 
+                                  context: build_team_context)
+          meeting[:discussions][agent.name] = perspective
+        end
+
+        meeting[:ended_at] = Time.now
+        meeting[:duration] = meeting[:ended_at] - meeting[:started_at]
+
+        # Store meeting results in team memory
+        @team_memory["meeting_#{meeting[:id]}"] = meeting
+
+        defined?(Rails) && Rails.logger && Rails.logger.info("Team #{@name} meeting completed: #{agenda}")
+        meeting
+      end
+
+      def share_knowledge(agent_name, knowledge)
+        @team_memory["knowledge_#{Time.now.to_i}"] = {
+          shared_by: agent_name,
+          knowledge: knowledge,
+          shared_at: Time.now
+        }
+
+        # Broadcast knowledge to other agents
+        @manager.broadcast_message(agent_name, {
+          type: :knowledge_share,
+          knowledge: knowledge,
+          shared_by: agent_name
+        }, exclude: [agent_name])
+
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{agent_name} shared knowledge with team #{@name}")
+      end
+
+      # Team monitoring
+      def team_status
+        {
+          name: @name,
+          strategy: @strategy,
+          agent_count: @agents.length,
+          active_agents: @agents.count { |a| a.state == :active },
+          total_tasks: @agents.sum { |a| a.active_tasks.length },
+          team_memory_size: @team_memory.length,
+          collaboration_count: @collaboration_history.length,
+          created_at: @created_at
+        }
+      end
+
+      def team_health
+        agent_health = @agents.map do |agent|
+          { name: agent.name, health: agent.health_check }
+        end
+
+        {
+          overall_health: agent_health.all? { |ah| ah[:health].values.all? },
+          agent_health: agent_health,
+          memory_usage: calculate_team_memory_usage,
+          collaboration_success_rate: calculate_collaboration_success_rate
+        }
+      end
+
+      # Team learning
+      def learn_from_experience
+        recent_collaborations = @collaboration_history.last(10)
+        return if recent_collaborations.empty?
+
+        insights = analyze_collaboration_patterns(recent_collaborations)
+        
+        # Share insights with all agents
+        @agents.each do |agent|
+          agent.remember("team_insights_#{Time.now.to_i}", insights, importance: :high)
+        end
+
+        defined?(Rails) && Rails.logger && Rails.logger.info("Team #{@name} learned from recent collaborations")
+        insights
+      end
+
+      private
+
+      def assign_round_robin(task)
+        agent = @agents[@current_agent_index]
+        @current_agent_index = (@current_agent_index + 1) % @agents.length
+        
+        agent.assign_task(task)
+      end
+
+      def assign_capability_based(task)
+        required_capabilities = task[:required_capabilities] || []
+        return false if required_capabilities.empty?
+
+        best_agent = @agents
+          .select { |agent| agent.state == :active }
+          .max_by do |agent|
+            required_capabilities.count { |cap| agent.has_capability?(cap) }
+          end
+
+        best_agent&.assign_task(task)
+      end
+
+      def assign_load_balanced(task)
+        best_agent = @agents
+          .select { |agent| agent.state == :active }
+          .min_by { |agent| agent.active_tasks.length }
+
+        best_agent&.assign_task(task)
+      end
+
+      def assign_collaborative(task)
+        # For collaborative tasks, all agents work together
+        collaborate_on_task(task)
+      end
+
+      def build_team_context
+        {
+          team_name: @name,
+          team_strategy: @strategy,
+          team_members: @agents.map { |a| { name: a.name, role: a.role, capabilities: a.capabilities } },
+          team_memory: @team_memory,
+          recent_collaborations: @collaboration_history.last(5)
+        }
+      end
+
+      def calculate_team_memory_usage
+        total_memory = @agents.sum { |agent| agent.memory.size }
+        total_capacity = @agents.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 calculate_collaboration_success_rate
+        return 0 if @collaboration_history.empty?
+
+        successful = @collaboration_history.count { |c| c[:status] == :completed }
+        (successful.to_f / @collaboration_history.length * 100).round(2)
+      end
+
+      def analyze_collaboration_patterns(collaborations)
+        {
+          total_collaborations: collaborations.length,
+          success_rate: calculate_collaboration_success_rate,
+          average_contributors: collaborations.map { |c| c[:contributions].length }.sum.to_f / collaborations.length,
+          common_issues: extract_common_issues(collaborations),
+          best_practices: extract_best_practices(collaborations)
+        }
+      end
+
+      def extract_common_issues(collaborations)
+        issues = collaborations.flat_map do |collab|
+          collab[:contributions].values.select { |c| c[:error] }.map { |c| c[:error] }
+        end
+        issues.tally.sort_by { |_, count| -count }.first(3)
+      end
+
+      def extract_best_practices(collaborations)
+        successful_collaborations = collaborations.select { |c| c[:status] == :completed }
+        return [] if successful_collaborations.empty?
+
+        # Analyze what made successful collaborations work
+        {
+          average_duration: successful_collaborations.map { |c| c[:completed_at] - c[:started_at] }.sum / successful_collaborations.length,
+          most_active_contributors: successful_collaborations.flat_map { |c| c[:contributions].keys }.tally.sort_by { |_, count| -count }.first(3)
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai/agents/base_agent.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Agents
+    class BaseAgent
+      attr_reader :name, :role, :capabilities, :memory, :state, :created_at, :last_activity, :active_tasks, :completed_tasks, :failed_tasks
+
+      def initialize(name:, role:, capabilities: [], memory_size: 1000, **opts)
+        @name = name
+        @role = role
+        @capabilities = Array(capabilities)
+        @memory = Memory.new(max_size: memory_size)
+        @state = :idle
+        @created_at = Time.now
+        @last_activity = Time.now
+        @config = opts
+        @message_queue = []
+        @active_tasks = []
+        @completed_tasks = []
+        @failed_tasks = []
+      end
+
+      # Core agent lifecycle methods
+      def start!
+        @state = :active
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} started")
+        self
+      end
+
+      def stop!
+        @state = :stopped
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} stopped")
+        self
+      end
+
+      def pause!
+        @state = :paused
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} paused")
+        self
+      end
+
+      def resume!
+        @state = :active
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} resumed")
+        self
+      end
+
+      # Task management
+      def assign_task(task)
+        return false unless can_handle_task?(task)
+
+        @active_tasks << task.merge(
+          assigned_at: Time.now,
+          status: :in_progress
+        )
+        @last_activity = Time.now
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} assigned task: #{task[:description]}")
+        true
+      end
+
+      def complete_task(task_id, result)
+        task = @active_tasks.find { |t| t[:id] == task_id }
+        return false unless task
+
+        @active_tasks.delete(task)
+        @completed_tasks << task.merge(
+          completed_at: Time.now,
+          status: :completed,
+          result: result
+        )
+        @last_activity = Time.now
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} completed task: #{task[:description]}")
+        true
+      end
+
+      def fail_task(task_id, error)
+        task = @active_tasks.find { |t| t[:id] == task_id }
+        return false unless task
+
+        @active_tasks.delete(task)
+        @failed_tasks << task.merge(
+          failed_at: Time.now,
+          status: :failed,
+          error: error
+        )
+        @last_activity = Time.now
+        
+        defined?(Rails) && Rails.logger && Rails.logger.error("Agent #{@name} failed task: #{task[:description]} - #{error}")
+        true
+      end
+
+      # Communication methods
+      def send_message(to_agent, message)
+        message_obj = {
+          from: @name,
+          to: to_agent,
+          content: message,
+          timestamp: Time.now,
+          id: SecureRandom.uuid
+        }
+        
+        @message_queue << message_obj
+        @last_activity = Time.now
+        
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} sent message to #{to_agent}")
+        message_obj
+      end
+
+      def receive_message(message)
+        @memory.add(:message, message)
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} received message from #{message[:from]}")
+      end
+
+      def get_messages(from_agent = nil)
+        messages = @message_queue
+        messages = messages.select { |m| m[:from] == from_agent } if from_agent
+        messages
+      end
+
+      # AI-powered decision making
+      def think(prompt, context: {})
+        return "[stubbed] Agent #{@name} thinking: #{prompt}" if RailsAi.config.stub_responses
+
+        full_context = build_context(context)
+        enhanced_prompt = build_agent_prompt(prompt, full_context)
+        
+        RailsAi.chat(enhanced_prompt, model: RailsAi.config.default_model)
+      end
+
+      def decide_next_action(context: {})
+        return { action: :wait, reason: "Stubbed response" } if RailsAi.config.stub_responses
+
+        decision_prompt = build_decision_prompt(context)
+        response = think(decision_prompt, context: context)
+        
+        parse_decision(response)
+      end
+
+      def collaborate_with(other_agent, task, context: {})
+        return "[stubbed] Collaboration between #{@name} and #{other_agent.name}" if RailsAi.config.stub_responses
+
+        collaboration_prompt = build_collaboration_prompt(other_agent, task, context)
+        response = think(collaboration_prompt, context: context)
+        
+        # Send collaboration result to other agent
+        send_message(other_agent.name, {
+          type: :collaboration_result,
+          task: task,
+          result: response,
+          from_agent: @name
+        })
+        
+        response
+      end
+
+      # Capability checks
+      def can_handle_task?(task)
+        return false unless @state == :active
+        return false if @active_tasks.length >= max_concurrent_tasks
+
+        required_capabilities = task[:required_capabilities] || []
+        required_capabilities.all? { |cap| @capabilities.include?(cap) }
+      end
+
+      def has_capability?(capability)
+        @capabilities.include?(capability.to_sym)
+      end
+
+      # Status and monitoring
+      def status
+        {
+          name: @name,
+          role: @role,
+          state: @state,
+          capabilities: @capabilities,
+          active_tasks: @active_tasks.length,
+          completed_tasks: @completed_tasks.length,
+          failed_tasks: @failed_tasks.length,
+          memory_usage: @memory.usage_percentage,
+          last_activity: @last_activity,
+          uptime: Time.now - @created_at
+        }
+      end
+
+      def health_check
+        {
+          state: @state,
+          memory_healthy: @memory.usage_percentage < 90,
+          no_stuck_tasks: @active_tasks.none? { |t| Time.now - t[:assigned_at] > max_task_duration },
+          last_activity_recent: Time.now - @last_activity < 5 * 60
+        }
+      end
+
+      # Memory management
+      def remember(key, value, importance: :normal)
+        @memory.add(key, value, importance: importance)
+        @last_activity = Time.now
+      end
+
+      def recall(key)
+        @memory.get(key)
+      end
+
+      def forget(key)
+        @memory.remove(key)
+        @last_activity = Time.now
+      end
+
+      # Task delegation
+      def delegate_task(task, target_agent, reason: nil)
+        return false unless can_delegate_task?(task, target_agent)
+
+        delegation = {
+          task: task,
+          from_agent: @name,
+          to_agent: target_agent.name,
+          reason: reason,
+          delegated_at: Time.now,
+          status: :pending
+        }
+
+        send_message(target_agent.name, {
+          type: :task_delegation,
+          delegation: delegation
+        })
+
+        @last_activity = Time.now
+        defined?(Rails) && Rails.logger && Rails.logger.info("Agent #{@name} delegated task to #{target_agent.name}")
+        delegation
+      end
+
+      def accept_delegated_task(delegation)
+        task = delegation[:delegation][:task]
+        return false unless can_handle_task?(task)
+
+        assign_task(task.merge(
+          delegated_from: delegation[:from],
+          delegation_id: delegation[:delegation][:id]
+        ))
+      end
+
+      private
+
+      def max_concurrent_tasks
+        @config[:max_concurrent_tasks] || 3
+      end
+
+      def max_task_duration
+        @config[:max_task_duration] || 30.minutes
+      end
+
+      def can_delegate_task?(task, target_agent)
+        target_agent.can_handle_task?(task) && 
+        target_agent.state == :active &&
+        @state == :active
+      end
+
+      def build_context(context)
+        {
+          agent_name: @name,
+          agent_role: @role,
+          agent_capabilities: @capabilities,
+          current_tasks: @active_tasks,
+          recent_memory: @memory.recent(10),
+          current_time: Time.now,
+          **context
+        }
+      end
+
+      def build_agent_prompt(prompt, context)
+        <<~PROMPT
+          You are #{@name}, a #{@role} AI agent with the following capabilities: #{@capabilities.join(', ')}.
+
+          Current context:
+          #{context.map { |k, v| "#{k}: #{v}" }.join("\n")}
+
+          Your task: #{prompt}
+
+          Respond as this agent would, considering your role and capabilities.
+        PROMPT
+      end
+
+      def build_decision_prompt(context)
+        <<~PROMPT
+          As #{@name}, analyze the current situation and decide what to do next.
+
+          Current context:
+          #{context.map { |k, v| "#{k}: #{v}" }.join("\n")}
+
+          Available actions:
+          - :wait (if no immediate action needed)
+          - :think (if need more information)
+          - :act (if ready to take action)
+          - :collaborate (if need help from other agents)
+          - :delegate (if task should be handled by another agent)
+
+          Respond with a JSON object: {"action": "action_name", "reason": "explanation", "details": {...}}
+        PROMPT
+      end
+
+      def build_collaboration_prompt(other_agent, task, context)
+        <<~PROMPT
+          You are #{@name} collaborating with #{other_agent.name} (#{other_agent.role}).
+
+          Task: #{task[:description]}
+          Other agent's capabilities: #{other_agent.capabilities.join(', ')}
+
+          Context:
+          #{context.map { |k, v| "#{k}: #{v}" }.join("\n")}
+
+          Provide your contribution to this collaboration.
+        PROMPT
+      end
+
+      def parse_decision(response)
+        begin
+          JSON.parse(response)
+        rescue JSON::ParserError
+          { action: :wait, reason: "Failed to parse decision", error: response }
+        end
+      end
+    end
+  end
+end