pocketrb 0.1.0

data/lib/pocketrb/agent/subagent_manager.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Pocketrb
+  module Agent
+    # Manages spawning and coordinating subagents
+    class SubagentManager
+      attr_reader :active_agents
+
+      def initialize(parent_loop:)
+        @parent_loop = parent_loop
+        @active_agents = {}
+        @mutex = Mutex.new
+      end
+
+      # Spawn a new subagent for a specific task
+      # @param task [String] Task description
+      # @param skills [Array<String>] Skills to load for this agent
+      # @param origin_channel [Symbol] Channel to report back to
+      # @param origin_chat_id [String] Chat to report back to
+      # @param model [String] Model to use (defaults to parent's model)
+      # @return [String] Agent ID
+      def spawn(task:, origin_channel:, origin_chat_id:, skills: [], model: nil)
+        agent_id = SecureRandom.uuid[0..7]
+
+        agent_info = {
+          id: agent_id,
+          task: task,
+          skills: skills,
+          origin_channel: origin_channel,
+          origin_chat_id: origin_chat_id,
+          model: model || @parent_loop.model,
+          status: :starting,
+          started_at: Time.now,
+          result: nil
+        }
+
+        @mutex.synchronize do
+          @active_agents[agent_id] = agent_info
+        end
+
+        # Run agent in async task
+        Async do
+          run_agent(agent_id, agent_info)
+        end
+
+        Pocketrb.logger.info("Spawned subagent #{agent_id} for task: #{task[0..50]}...")
+        agent_id
+      end
+
+      # Get status of a subagent
+      # @param agent_id [String]
+      # @return [Hash|nil]
+      def get_status(agent_id)
+        @mutex.synchronize { @active_agents[agent_id]&.dup }
+      end
+
+      # List all active agents
+      # @return [Array<Hash>]
+      def list_active
+        @mutex.synchronize do
+          @active_agents.values.select { |a| a[:status] == :running }
+        end
+      end
+
+      # Terminate a subagent
+      # @param agent_id [String]
+      def terminate(agent_id)
+        @mutex.synchronize do
+          @active_agents[agent_id][:status] = :terminated if @active_agents[agent_id]
+        end
+      end
+
+      # Wait for a subagent to complete
+      # @param agent_id [String]
+      # @param timeout [Integer] Timeout in seconds
+      # @return [String|nil] Result
+      def wait_for(agent_id, timeout: 300)
+        deadline = Time.now + timeout
+
+        loop do
+          status = get_status(agent_id)
+          return nil unless status
+
+          case status[:status]
+          when :completed
+            return status[:result]
+          when :failed, :terminated
+            return nil
+          end
+
+          break if Time.now > deadline
+
+          sleep 0.5
+        end
+
+        nil
+      end
+
+      private
+
+      def run_agent(agent_id, info)
+        update_status(agent_id, :running)
+
+        # Create isolated context for subagent
+        system_prompt = build_subagent_prompt(info)
+
+        # Create a mini message bus for this agent
+        sub_bus = Bus::MessageBus.new
+
+        # Create the subagent loop
+        sub_loop = Loop.new(
+          bus: sub_bus,
+          provider: @parent_loop.provider,
+          workspace: @parent_loop.workspace,
+          model: info[:model],
+          max_iterations: 30,
+          system_prompt: system_prompt
+        )
+
+        # Load requested skills
+        load_skills(sub_loop, info[:skills])
+
+        # Process the task
+        msg = Bus::InboundMessage.new(
+          channel: :subagent,
+          sender_id: "parent",
+          chat_id: agent_id,
+          content: info[:task]
+        )
+
+        response = sub_loop.process_message(msg)
+
+        # Report result
+        result = response&.content || "Task completed with no output"
+        update_status(agent_id, :completed, result: result)
+
+        # Send result back to origin
+        announce_result(info, result)
+      rescue StandardError => e
+        Pocketrb.logger.error("Subagent #{agent_id} failed: #{e.message}")
+        update_status(agent_id, :failed, result: "Error: #{e.message}")
+        announce_result(info, "Subagent failed: #{e.message}")
+      end
+
+      def update_status(agent_id, status, result: nil)
+        @mutex.synchronize do
+          if @active_agents[agent_id]
+            @active_agents[agent_id][:status] = status
+            @active_agents[agent_id][:result] = result if result
+            @active_agents[agent_id][:completed_at] = Time.now if %i[completed failed terminated].include?(status)
+          end
+        end
+      end
+
+      def build_subagent_prompt(info)
+        <<~PROMPT
+          You are a specialized subagent spawned to complete a specific task.
+          You should focus exclusively on the task and report your findings concisely.
+
+          Your task: #{info[:task]}
+
+          Guidelines:
+          - Focus only on the assigned task
+          - Be concise in your response
+          - If you need information you don't have, say so
+          - Complete the task as efficiently as possible
+        PROMPT
+      end
+
+      def load_skills(loop, skill_names)
+        return if skill_names.empty?
+
+        skills_loader = Skills::Loader.new(workspace: @parent_loop.workspace)
+        skill_content = skill_names.filter_map do |name|
+          skill = skills_loader.load_skill(name)
+          skill&.to_prompt
+        end.join("\n\n")
+
+        loop.context.append_to_system_prompt(skill_content) unless skill_content.empty?
+      end
+
+      def announce_result(info, result)
+        outbound = Bus::OutboundMessage.new(
+          channel: info[:origin_channel],
+          chat_id: info[:origin_chat_id],
+          content: "**Subagent completed:**\n\n#{result}",
+          metadata: { subagent_id: info[:id] }
+        )
+
+        @parent_loop.bus.publish_outbound(outbound)
+      end
+    end
+  end
+end

data/lib/pocketrb/bus/events.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  # Bus module provides the message bus architecture for multi-channel communication
+  module Bus
+    # Inbound message from a channel to the agent
+    InboundMessage = Data.define(
+      :channel,      # Symbol - channel identifier (:cli, :telegram, :discord, etc.)
+      :sender_id,    # String - unique sender identifier
+      :chat_id,      # String - unique chat/conversation identifier
+      :content,      # String - text content of the message
+      :media,        # Array<Media> - attached media (images, files, etc.)
+      :metadata      # Hash - channel-specific metadata
+    ) do
+      def initialize(channel:, sender_id:, chat_id:, content:, media: [], metadata: {})
+        super
+      end
+
+      # Unique key for session management
+      def session_key
+        "#{channel}:#{chat_id}"
+      end
+
+      # Check if message has media attachments
+      def has_media?
+        media && !media.empty?
+      end
+    end
+
+    # Outbound message from the agent to a channel
+    OutboundMessage = Data.define(
+      :channel,      # Symbol - target channel
+      :chat_id,      # String - target chat/conversation
+      :content,      # String - text content to send
+      :media,        # Array<Media> - media to attach
+      :reply_to,     # String|nil - message ID to reply to
+      :metadata      # Hash - channel-specific options
+    ) do
+      def initialize(channel:, chat_id:, content:, media: [], reply_to: nil, metadata: {})
+        super
+      end
+    end
+
+    # Media attachment
+    Media = Data.define(
+      :type,         # Symbol - :image, :file, :audio, :video
+      :path,         # String - file path or URL
+      :mime_type,    # String - MIME type
+      :filename,     # String|nil - original filename
+      :data          # String|nil - base64 encoded data (for inline media)
+    ) do
+      def initialize(type:, path:, mime_type:, filename: nil, data: nil)
+        super
+      end
+
+      def image?
+        type == :image
+      end
+
+      def file?
+        type == :file
+      end
+    end
+
+    # Tool execution event
+    ToolExecution = Data.define(
+      :tool_call_id, # String - unique tool call identifier
+      :name,         # String - tool name
+      :arguments,    # Hash - tool arguments
+      :result,       # String|nil - execution result
+      :error,        # String|nil - error message if failed
+      :duration_ms   # Integer|nil - execution time in milliseconds
+    ) do
+      def initialize(tool_call_id:, name:, arguments:, result: nil, error: nil, duration_ms: nil)
+        super
+      end
+
+      def success?
+        error.nil?
+      end
+
+      def failed?
+        !success?
+      end
+    end
+
+    # Agent state change event
+    StateChange = Data.define(
+      :session_key,  # String - session identifier
+      :from_state,   # Symbol - previous state
+      :to_state,     # Symbol - new state
+      :reason        # String|nil - reason for change
+    ) do
+      def initialize(session_key:, from_state:, to_state:, reason: nil)
+        super
+      end
+    end
+  end
+end

data/lib/pocketrb/bus/message_bus.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/queue"
+
+module Pocketrb
+  module Bus
+    # Thread-safe async message bus for agent communication
+    class MessageBus
+      attr_reader :stats
+
+      def initialize
+        @inbound = Async::Queue.new
+        @outbound = Async::Queue.new
+        @tool_events = Async::Queue.new
+        @state_events = Async::Queue.new
+        @subscribers = { inbound: [], outbound: [], tool: [], state: [] }
+        @mutex = Mutex.new
+        @stats = Stats.new
+        @running = false
+      end
+
+      # Publish an inbound message from a channel
+      def publish_inbound(message)
+        raise ArgumentError, "Expected InboundMessage" unless message.is_a?(InboundMessage)
+
+        @stats.increment(:inbound)
+        @inbound.enqueue(message)
+        notify_subscribers(:inbound, message)
+      end
+
+      # Consume the next inbound message (blocking)
+      def consume_inbound
+        @inbound.dequeue
+      end
+
+      # Publish an outbound message to a channel
+      def publish_outbound(message)
+        raise ArgumentError, "Expected OutboundMessage" unless message.is_a?(OutboundMessage)
+
+        @stats.increment(:outbound)
+        @outbound.enqueue(message)
+        notify_subscribers(:outbound, message)
+      end
+
+      # Consume the next outbound message (blocking)
+      def consume_outbound
+        @outbound.dequeue
+      end
+
+      # Publish a tool execution event
+      def publish_tool_event(event)
+        raise ArgumentError, "Expected ToolExecution" unless event.is_a?(ToolExecution)
+
+        @stats.increment(:tool_executions)
+        @tool_events.enqueue(event)
+        notify_subscribers(:tool, event)
+      end
+
+      # Consume the next tool event (blocking)
+      def consume_tool_event
+        @tool_events.dequeue
+      end
+
+      # Publish a state change event
+      def publish_state_event(event)
+        raise ArgumentError, "Expected StateChange" unless event.is_a?(StateChange)
+
+        @stats.increment(:state_changes)
+        @state_events.enqueue(event)
+        notify_subscribers(:state, event)
+      end
+
+      # Subscribe to events
+      def subscribe(type, &block)
+        raise ArgumentError, "Unknown event type: #{type}" unless @subscribers.key?(type)
+
+        @mutex.synchronize do
+          @subscribers[type] << block
+        end
+      end
+
+      # Unsubscribe from events
+      def unsubscribe(type, block)
+        @mutex.synchronize do
+          @subscribers[type].delete(block)
+        end
+      end
+
+      # Check if queues have pending messages
+      def pending_inbound?
+        !@inbound.empty?
+      end
+
+      def pending_outbound?
+        !@outbound.empty?
+      end
+
+      # Clear all queues
+      def clear!
+        @inbound = Async::Queue.new
+        @outbound = Async::Queue.new
+        @tool_events = Async::Queue.new
+        @state_events = Async::Queue.new
+        @stats.reset!
+      end
+
+      private
+
+      def notify_subscribers(type, event)
+        subscribers = @mutex.synchronize { @subscribers[type].dup }
+        subscribers.each do |handler|
+          handler.call(event)
+        rescue StandardError => e
+          Pocketrb.logger.error("Subscriber error for #{type}: #{e.message}")
+        end
+      end
+
+      # Statistics tracker
+      class Stats
+        attr_reader :data
+
+        def initialize
+          @data = { inbound: 0, outbound: 0, tool_executions: 0, state_changes: 0 }
+          @mutex = Mutex.new
+        end
+
+        def increment(key)
+          @mutex.synchronize { @data[key] += 1 }
+        end
+
+        def [](key)
+          @mutex.synchronize { @data[key] }
+        end
+
+        def reset!
+          @mutex.synchronize do
+            @data.transform_values! { 0 }
+          end
+        end
+
+        def to_h
+          @mutex.synchronize { @data.dup }
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/channels/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Channels
+    # Base class for channel adapters
+    class Base
+      attr_reader :bus, :name
+
+      def initialize(bus:, name: nil)
+        @bus = bus
+        @name = name || self.class.name.split("::").last.downcase.to_sym
+        @running = false
+      end
+
+      # Start the channel
+      def run
+        @running = true
+        start_outbound_consumer
+        run_inbound_loop
+      end
+
+      # Stop the channel
+      def stop
+        @running = false
+      end
+
+      # Check if channel is running
+      def running?
+        @running
+      end
+
+      protected
+
+      # Override in subclasses to implement inbound message handling
+      def run_inbound_loop
+        raise NotImplementedError
+      end
+
+      # Override in subclasses to send outbound messages
+      def send_message(message)
+        raise NotImplementedError
+      end
+
+      private
+
+      def start_outbound_consumer
+        Async do
+          while @running
+            message = @bus.consume_outbound
+            next unless message.channel == @name
+
+            send_message(message)
+          end
+        end
+      end
+
+      def create_inbound_message(sender_id:, chat_id:, content:, media: [], metadata: {})
+        Bus::InboundMessage.new(
+          channel: @name,
+          sender_id: sender_id,
+          chat_id: chat_id,
+          content: content,
+          media: media,
+          metadata: metadata
+        )
+      end
+    end
+  end
+end

data/lib/pocketrb/channels/cli.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  # Channels module provides multi-channel support (CLI, Telegram, WhatsApp, etc.)
+  module Channels
+    # Interactive CLI channel
+    class CLI < Base
+      def initialize(bus:, prompt: "> ")
+        super(bus: bus, name: :cli)
+        @prompt = prompt
+        @output_mutex = Mutex.new
+      end
+
+      protected
+
+      def run_inbound_loop
+        Async do
+          while @running
+            print @prompt
+            input = read_input
+            break if input.nil?
+
+            next if input.empty?
+
+            # Handle special commands
+            next if handle_command(input)
+
+            # Create and publish inbound message
+            message = create_inbound_message(
+              sender_id: "user",
+              chat_id: "cli",
+              content: input
+            )
+
+            @bus.publish_inbound(message)
+          end
+        end
+      end
+
+      def send_message(message)
+        @output_mutex.synchronize do
+          puts "\n#{format_output(message.content)}\n"
+        end
+      end
+
+      private
+
+      def read_input
+        line = $stdin.gets
+        return nil if line.nil?
+
+        line.chomp
+      rescue Interrupt
+        nil
+      end
+
+      def handle_command(input)
+        case input.downcase
+        when "exit", "quit", "/exit", "/quit"
+          @running = false
+          puts "Goodbye!"
+          true
+        when "/help"
+          print_help
+          true
+        when "/clear"
+          system("clear") || system("cls")
+          true
+        when "/stats"
+          print_stats
+          true
+        else
+          false
+        end
+      end
+
+      def print_help
+        puts <<~HELP
+
+          Commands:
+            /help   - Show this help
+            /clear  - Clear the screen
+            /stats  - Show message statistics
+            /exit   - Exit the chat
+
+        HELP
+      end
+
+      def print_stats
+        stats = @bus.stats.to_h
+        puts <<~STATS
+
+          Statistics:
+            Inbound messages:  #{stats[:inbound]}
+            Outbound messages: #{stats[:outbound]}
+            Tool executions:   #{stats[:tool_executions]}
+
+        STATS
+      end
+
+      def format_output(content)
+        return "" if content.nil? || content.empty?
+
+        # Simple formatting - could be enhanced with tty-markdown
+        content
+      end
+    end
+  end
+end