smart_message 0.0.1

data/examples/tmux_chat/bot_agent.rb

@@ -0,0 +1,272 @@
+#!/usr/bin/env ruby
+# examples/tmux_chat/bot_agent.rb
+#
+# Bot agent for tmux chat visualization
+
+require_relative 'shared_chat_system'
+
+class BotChatAgent < BaseAgent
+  def initialize(bot_id:, name:, capabilities: [])
+    @capabilities = capabilities
+    @command_count = 0
+    super(agent_id: bot_id, name: name, agent_type: 'bot')
+    
+    log_display("🤖 Bot #{@name} online!")
+    log_display("🔧 Capabilities: #{@capabilities.join(', ')}")
+    log_display("⚡ Listening for commands and messages...")
+    log_display("")
+  end
+
+  def setup_subscriptions
+    # Subscribe to bot commands and chat messages
+    BotCommandMessage.subscribe("BotChatAgent.handle_bot_command_#{@agent_id}")
+    ChatMessage.subscribe("BotChatAgent.handle_chat_message_#{@agent_id}")
+    
+    # Register this instance
+    @@bots ||= {}
+    @@bots[@agent_id] = self
+  end
+
+  def run
+    # Start processing messages and wait
+    begin
+      while true
+        sleep(1)
+      end
+    rescue Interrupt
+      shutdown
+    end
+  end
+
+  # Class method routing for SmartMessage
+  def self.method_missing(method_name, *args)
+    if method_name.to_s.start_with?('handle_bot_command_')
+      bot_id = method_name.to_s.split('_').last
+      bot = (@@bots ||= {})[bot_id]
+      bot&.handle_bot_command(*args)
+    elsif method_name.to_s.start_with?('handle_chat_message_')
+      bot_id = method_name.to_s.split('_').last
+      bot = (@@bots ||= {})[bot_id]
+      bot&.handle_chat_message(*args)
+    else
+      super
+    end
+  end
+
+  def handle_bot_command(message_header, message_payload)
+    command_data = JSON.parse(message_payload)
+    
+    # Only handle commands in rooms we're in and commands we can handle
+    return unless @active_rooms.include?(command_data['room_id'])
+    return unless can_handle_command?(command_data['command'])
+    
+    @command_count += 1
+    log_display("⚡ Processing command: /#{command_data['command']} (#{@command_count})")
+    
+    process_command(command_data)
+  end
+
+  def handle_chat_message(message_header, message_payload)
+    chat_data = JSON.parse(message_payload)
+    
+    # Only process messages from rooms we're in and not our own messages
+    return unless @active_rooms.include?(chat_data['room_id'])
+    return if chat_data['sender_id'] == @agent_id
+    
+    # Log the message
+    log_display("👁️  [#{chat_data['room_id']}] #{chat_data['sender_name']}: #{chat_data['content']}")
+    
+    # Check if it's a bot command
+    if chat_data['content'].start_with?('/')
+      handle_inline_command(chat_data)
+    else
+      # Respond to certain keywords
+      respond_to_keywords(chat_data)
+    end
+  end
+
+  def can_handle_command?(command)
+    @capabilities.include?(command)
+  end
+
+  private
+
+  def handle_inline_command(chat_data)
+    content = chat_data['content']
+    command_parts = content[1..-1].split(' ')
+    command = command_parts.first
+    parameters = command_parts[1..-1]
+    
+    return unless can_handle_command?(command)
+    
+    # Create bot command message
+    bot_command = BotCommandMessage.new(
+      command_id: "CMD-#{@agent_id}-#{Time.now.to_i}-#{rand(1000)}",
+      room_id: chat_data['room_id'],
+      user_id: chat_data['sender_id'],
+      user_name: chat_data['sender_name'],
+      command: command,
+      parameters: parameters,
+      timestamp: Time.now.iso8601
+    )
+    
+    bot_command.publish
+  end
+
+  def process_command(command_data)
+    case command_data['command']
+    when 'weather'
+      handle_weather_command(command_data)
+    when 'joke'
+      handle_joke_command(command_data)
+    when 'help'
+      handle_help_command(command_data)
+    when 'stats'
+      handle_stats_command(command_data)
+    when 'time'
+      handle_time_command(command_data)
+    when 'echo'
+      handle_echo_command(command_data)
+    else
+      send_bot_response(
+        room_id: command_data['room_id'],
+        content: "🤷‍♂️ Sorry, I don't know how to handle /#{command_data['command']}"
+      )
+    end
+  end
+
+  def respond_to_keywords(chat_data)
+    content = chat_data['content'].downcase
+    
+    if content.include?('hello') || content.include?('hi')
+      send_bot_response(
+        room_id: chat_data['room_id'],
+        content: "Hello #{chat_data['sender_name']}! 👋"
+      )
+    elsif content.include?('help') && !content.start_with?('/')
+      send_bot_response(
+        room_id: chat_data['room_id'],
+        content: "Type /help to see my commands! 🤖"
+      )
+    elsif content.include?('thank')
+      send_bot_response(
+        room_id: chat_data['room_id'], 
+        content: "You're welcome! 😊"
+      )
+    end
+  end
+
+  def handle_weather_command(command_data)
+    location = command_data['parameters'].first || 'your location'
+    weather_responses = [
+      "☀️ It's sunny and 72°F in #{location}!",
+      "🌧️ Looks like rain and 65°F in #{location}",
+      "❄️ Snow expected, 32°F in #{location}",
+      "⛅ Partly cloudy, 68°F in #{location}",
+      "🌪️ Tornado warning in #{location}! (Just kidding, it's nice)"
+    ]
+    
+    # Simulate API delay
+    Thread.new do
+      sleep(0.5)
+      send_bot_response(
+        room_id: command_data['room_id'],
+        content: weather_responses.sample
+      )
+    end
+  end
+
+  def handle_joke_command(command_data)
+    jokes = [
+      "Why don't scientists trust atoms? Because they make up everything! 😄",
+      "Why did the scarecrow win an award? He was outstanding in his field! 🌾",
+      "What do you call a fake noodle? An impasta! 🍝",
+      "Why don't eggs tell jokes? They'd crack each other up! 🥚",
+      "What do you call a sleeping bull? A bulldozer! 😴",
+      "Why don't robots ever panic? They have enough bytes! 🤖"
+    ]
+    
+    send_bot_response(
+      room_id: command_data['room_id'],
+      content: jokes.sample
+    )
+  end
+
+  def handle_help_command(command_data)
+    help_text = @capabilities.map do |cmd|
+      "  /#{cmd} - #{get_command_description(cmd)}"
+    end.join("\n")
+    
+    send_bot_response(
+      room_id: command_data['room_id'],
+      content: "🤖 #{@name} Commands:\n#{help_text}"
+    )
+  end
+
+  def handle_stats_command(command_data)
+    send_bot_response(
+      room_id: command_data['room_id'],
+      content: "📊 Bot Stats:\n" +
+               "  • Active rooms: #{@active_rooms.length}\n" +
+               "  • Commands processed: #{@command_count}\n" +
+               "  • Capabilities: #{@capabilities.length}\n" +
+               "  • Uptime: #{Time.now.strftime('%H:%M:%S')}"
+    )
+  end
+
+  def handle_time_command(command_data)
+    timezone = command_data['parameters'].first || 'local'
+    current_time = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+    
+    send_bot_response(
+      room_id: command_data['room_id'],
+      content: "🕒 Current time (#{timezone}): #{current_time}"
+    )
+  end
+
+  def handle_echo_command(command_data)
+    message = command_data['parameters'].join(' ')
+    if message.empty?
+      message = "Echo! Echo! Echo! 📢"
+    end
+    
+    send_bot_response(
+      room_id: command_data['room_id'],
+      content: "🔊 Echo: #{message}"
+    )
+  end
+
+  def get_command_description(command)
+    descriptions = {
+      'weather' => 'Get weather information',
+      'joke' => 'Tell a random joke',
+      'help' => 'Show this help message',
+      'stats' => 'Show bot statistics',
+      'time' => 'Show current time',
+      'echo' => 'Echo your message'
+    }
+    
+    descriptions[command] || 'No description available'
+  end
+
+  def send_bot_response(room_id:, content:)
+    send_message(room_id: room_id, content: content, message_type: 'bot')
+    log_display("💬 Replied to [#{room_id}]: #{content}")
+  end
+end
+
+# Main execution
+if __FILE__ == $0
+  if ARGV.length < 2
+    puts "Usage: #{$0} <bot_id> <name> [capability1,capability2,...]"
+    puts "Example: #{$0} helpbot HelpBot help,stats,time"
+    exit 1
+  end
+  
+  bot_id = ARGV[0]
+  name = ARGV[1]
+  capabilities = ARGV[2] ? ARGV[2].split(',') : ['help']
+  
+  bot = BotChatAgent.new(bot_id: bot_id, name: name, capabilities: capabilities)
+  bot.run
+end

data/examples/tmux_chat/human_agent.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+# examples/tmux_chat/human_agent.rb
+#
+# Human chat agent for tmux visualization
+
+require_relative 'shared_chat_system'
+
+begin
+  require 'io/console'
+rescue LoadError
+  # Console methods may not be available, handled gracefully
+end
+
+class HumanChatAgent < BaseAgent
+  def initialize(user_id:, name:)
+    @message_counter = 0
+    super(agent_id: user_id, name: name, agent_type: 'human')
+    
+    log_display("👤 Human agent #{@name} ready!")
+    log_display("Commands: /join <room>, /leave <room>, /list, /quit")
+    log_display("Type messages to send to current rooms")
+    log_display("")
+  end
+
+  def setup_subscriptions
+    # Subscribe to chat messages
+    ChatMessage.subscribe("HumanChatAgent.handle_chat_message_#{@agent_id}")
+    SystemNotificationMessage.subscribe("HumanChatAgent.handle_system_notification_#{@agent_id}")
+    
+    # Register this instance for method dispatch
+    @@agents ||= {}
+    @@agents[@agent_id] = self
+  end
+
+  def start_interactive_session
+    while true
+      begin
+        print "> "
+        input = STDIN.gets&.chomp
+        break if input.nil?
+        
+        next if input.strip.empty?
+        
+        if input.start_with?('/')
+          handle_command(input)
+        else
+          send_to_active_rooms(input)
+        end
+      rescue Interrupt
+        break
+      end
+    end
+    
+    shutdown
+  end
+
+  # Class method routing for SmartMessage
+  def self.method_missing(method_name, *args)
+    if method_name.to_s.start_with?('handle_chat_message_')
+      user_id = method_name.to_s.split('_').last
+      agent = (@@agents ||= {})[user_id]
+      agent&.handle_chat_message(*args)
+    elsif method_name.to_s.start_with?('handle_system_notification_')
+      user_id = method_name.to_s.split('_').last
+      agent = (@@agents ||= {})[user_id]
+      agent&.handle_system_notification(*args)
+    else
+      super
+    end
+  end
+
+  def handle_chat_message(message_header, message_payload)
+    chat_data = JSON.parse(message_payload)
+    
+    # Only process messages from rooms we're in and not our own messages
+    return unless @active_rooms.include?(chat_data['room_id'])
+    return if chat_data['sender_id'] == @agent_id
+    
+    sender_emoji = case chat_data['message_type']
+                   when 'bot' then '🤖'
+                   when 'system' then '🔔'
+                   else '👤'
+                   end
+    
+    log_display("#{sender_emoji} [#{chat_data['room_id']}] #{chat_data['sender_name']}: #{chat_data['content']}")
+    
+    # Auto-respond if mentioned
+    if chat_data['mentions']&.include?(@name.downcase) || chat_data['content'].include?("@#{@name}")
+      respond_to_mention(chat_data)
+    end
+  end
+
+  def handle_system_notification(message_header, message_payload)
+    notif_data = JSON.parse(message_payload)
+    
+    # Only process notifications from rooms we're in
+    return unless @active_rooms.include?(notif_data['room_id'])
+    
+    log_display("🔔 [#{notif_data['room_id']}] #{notif_data['content']}")
+  end
+
+  private
+
+  def handle_command(input)
+    parts = input[1..-1].split(' ')
+    command = parts[0]
+    args = parts[1..-1]
+    
+    case command
+    when 'join'
+      if args.empty?
+        log_display("❌ Usage: /join <room_id>")
+      else
+        join_room(args[0])
+        update_display_header
+      end
+    when 'leave'
+      if args.empty?
+        log_display("❌ Usage: /leave <room_id>")
+      else
+        leave_room(args[0])
+        update_display_header
+      end
+    when 'list'
+      log_display("📋 Active rooms: #{@active_rooms.empty? ? 'none' : @active_rooms.join(', ')}")
+    when 'quit', 'exit'
+      log_display("👋 Goodbye!")
+      exit(0)
+    when 'help'
+      log_display("📖 Commands:")
+      log_display("   /join <room>  - Join a chat room")
+      log_display("   /leave <room> - Leave a chat room") 
+      log_display("   /list         - List active rooms")
+      log_display("   /quit         - Exit the chat")
+    else
+      log_display("❌ Unknown command: /#{command}. Type /help for help.")
+    end
+  end
+
+  def send_to_active_rooms(message)
+    if @active_rooms.empty?
+      log_display("❌ You're not in any rooms. Use /join <room> to join a room.")
+      return
+    end
+    
+    @active_rooms.each do |room_id|
+      send_message(room_id: room_id, content: message)
+    end
+  end
+
+  def respond_to_mention(chat_data)
+    responses = [
+      "Thanks for mentioning me!",
+      "I'm here, what's up?", 
+      "How can I help?",
+      "Yes, I saw that!",
+      "Interesting point!"
+    ]
+    
+    # Delay response slightly to make it feel natural
+    Thread.new do
+      sleep(0.5 + rand)
+      send_message(
+        room_id: chat_data['room_id'],
+        content: responses.sample
+      )
+    end
+  end
+
+  def update_display_header
+    # Move cursor to update rooms line
+    print "\033[4;9H"  # Move to line 4, column 9
+    print "#{@active_rooms.join(', ').ljust(42)}"
+    # Move cursor to bottom (default to 40 lines if console unavailable)
+    max_lines = begin
+      IO.console&.winsize&.first || 40
+    rescue
+      40
+    end
+    print "\033[#{max_lines};1H"
+  end
+end
+
+# Main execution
+if __FILE__ == $0
+  if ARGV.length < 2
+    puts "Usage: #{$0} <user_id> <name>"
+    puts "Example: #{$0} alice Alice"
+    exit 1
+  end
+  
+  user_id = ARGV[0]
+  name = ARGV[1]
+  
+  agent = HumanChatAgent.new(user_id: user_id, name: name)
+  agent.start_interactive_session
+end

data/examples/tmux_chat/room_monitor.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+# examples/tmux_chat/room_monitor.rb
+#
+# Room activity monitor for tmux chat visualization
+
+require_relative 'shared_chat_system'
+
+begin
+  require 'io/console'
+rescue LoadError
+  # Console methods may not be available, handled gracefully
+end
+
+class RoomMonitor < BaseAgent
+  def initialize(room_id)
+    @room_id = room_id
+    @message_count = 0
+    @user_count = 0
+    @last_activity = Time.now
+    @participants = Set.new
+    
+    super(agent_id: "monitor-#{room_id}", name: "Room Monitor", agent_type: 'monitor')
+    
+    join_room(@room_id)
+    log_display("🏠 Monitoring room: #{@room_id}")
+    log_display("📊 Waiting for activity...")
+    log_display("")
+  end
+
+  def setup_subscriptions
+    ChatMessage.subscribe("RoomMonitor.handle_chat_message_#{@agent_id}")
+    SystemNotificationMessage.subscribe("RoomMonitor.handle_system_notification_#{@agent_id}")
+    
+    @@monitors ||= {}
+    @@monitors[@agent_id] = self
+  end
+
+  def run
+    # Update display every few seconds
+    begin
+      while true
+        sleep(2)
+        update_stats_display
+      end
+    rescue Interrupt
+      shutdown
+    end
+  end
+
+  # Class method routing
+  def self.method_missing(method_name, *args)
+    if method_name.to_s.start_with?('handle_chat_message_')
+      monitor_id = method_name.to_s.split('_', 4).last
+      monitor = (@@monitors ||= {})[monitor_id]
+      monitor&.handle_chat_message(*args)
+    elsif method_name.to_s.start_with?('handle_system_notification_')
+      monitor_id = method_name.to_s.split('_', 4).last
+      monitor = (@@monitors ||= {})[monitor_id]
+      monitor&.handle_system_notification(*args)
+    else
+      super
+    end
+  end
+
+  def handle_chat_message(message_header, message_payload)
+    chat_data = JSON.parse(message_payload)
+    
+    return unless chat_data['room_id'] == @room_id
+    return if chat_data['sender_id'] == @agent_id
+    
+    @message_count += 1
+    @last_activity = Time.now
+    @participants.add(chat_data['sender_name'])
+    
+    sender_emoji = case chat_data['message_type']
+                   when 'bot' then '🤖'
+                   when 'system' then '🔔'
+                   else '👤'
+                   end
+    
+    # Show the message with metadata
+    timestamp = Time.now.strftime("%H:%M:%S")
+    log_display("#{sender_emoji} [#{timestamp}] #{chat_data['sender_name']}: #{chat_data['content']}")
+    
+    # Check for commands
+    if chat_data['content'].start_with?('/')
+      log_display("⚡ Command detected: #{chat_data['content']}")
+    end
+    
+    # Check for mentions
+    if chat_data['mentions'] && !chat_data['mentions'].empty?
+      log_display("🏷️  Mentions: #{chat_data['mentions'].join(', ')}")
+    end
+  end
+
+  def handle_system_notification(message_header, message_payload)
+    notif_data = JSON.parse(message_payload)
+    
+    return unless notif_data['room_id'] == @room_id
+    
+    case notif_data['notification_type']
+    when 'user_joined'
+      @user_count += 1
+      log_display("📥 #{notif_data['content']}")
+    when 'user_left'
+      @user_count = [@user_count - 1, 0].max
+      log_display("📤 #{notif_data['content']}")
+    else
+      log_display("🔔 #{notif_data['content']}")
+    end
+    
+    @last_activity = Time.now
+  end
+
+  private
+
+  def update_stats_display
+    # Move cursor to update stats
+    time_since_activity = Time.now - @last_activity
+    activity_status = if time_since_activity < 10
+                       "🟢 Active"
+                     elsif time_since_activity < 60
+                       "🟡 Quiet (#{time_since_activity.to_i}s ago)"
+                     else
+                       "🔴 Inactive (#{(time_since_activity / 60).to_i}m ago)"
+                     end
+    
+    # Update the header area with stats
+    print "\033[2;2H"  # Move to line 2
+    room_info = " ROOM: #{@room_id} | #{activity_status} "
+    print room_info.center(50)
+    
+    print "\033[4;2H"  # Move to line 4  
+    stats_info = " Messages: #{@message_count} | Participants: #{@participants.size} "
+    print stats_info.center(50)
+    
+    # Move cursor back to bottom (default to 40 lines if console unavailable)
+    max_lines = begin
+      IO.console&.winsize&.first || 40
+    rescue
+      40
+    end
+    print "\033[#{max_lines};1H"
+  end
+end
+
+# Main execution
+if __FILE__ == $0
+  if ARGV.empty?
+    puts "Usage: #{$0} <room_id>"
+    puts "Example: #{$0} general"
+    exit 1
+  end
+  
+  room_id = ARGV[0]
+  monitor = RoomMonitor.new(room_id)
+  monitor.run
+end