smart_message 0.0.10 → 0.0.13

data/examples/tmux_chat/human_agent.rb

@@ -1,199 +0,0 @@
-#!/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(wrapper)
-    message_header, message_payload = wrapper.split
-    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(wrapper)
-    message_header, message_payload = wrapper.split
-    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

@@ -1,160 +0,0 @@
-#!/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(wrapper)
-    message_header, message_payload = wrapper.split
-    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(wrapper)
-    message_header, message_payload = wrapper.split
-    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

data/examples/tmux_chat/shared_chat_system.rb

@@ -1,328 +0,0 @@
-#!/usr/bin/env ruby
-# examples/tmux_chat/shared_chat_system.rb
-#
-# Shared messaging system for the tmux chat visualization
-# This provides the core message types and file-based transport for inter-pane communication
-
-require_relative '../../lib/smart_message'
-require 'fileutils'
-
-# Create shared message queues directory
-SHARED_DIR = '/tmp/smart_message_chat'
-FileUtils.mkdir_p(SHARED_DIR)
-
-# File-based transport for tmux communication
-class FileTransport < SmartMessage::Transport::Base
-  def default_options
-    {
-      queue_dir: SHARED_DIR,
-      poll_interval: 0.1
-    }
-  end
-
-  def configure
-    @queue_dir = @options[:queue_dir]
-    @poll_interval = @options[:poll_interval]
-    @running = false
-    @subscriber_thread = nil
-    
-    FileUtils.mkdir_p(@queue_dir)
-  end
-
-  def publish(message_header, message_payload)
-    message_data = {
-      header: message_header.to_h,
-      payload: message_payload,
-      timestamp: Time.now.to_f
-    }
-    
-    # Write to room-specific queue file
-    room_id = extract_room_id(message_payload)
-    queue_file = File.join(@queue_dir, "#{room_id}.queue")
-    
-    File.open(queue_file, 'a') do |f|
-      f.puts(JSON.generate(message_data))
-      f.flush
-    end
-  end
-
-  def start_subscriber
-    return if @running
-    
-    @running = true
-    @subscriber_thread = Thread.new do
-      processed_positions = {}
-      
-      while @running
-        Dir.glob(File.join(@queue_dir, "*.queue")).each do |queue_file|
-          room_id = File.basename(queue_file, '.queue')
-          
-          if File.exist?(queue_file)
-            lines = File.readlines(queue_file)
-            start_pos = processed_positions[room_id] || 0
-            
-            lines[start_pos..-1].each do |line|
-              begin
-                message_data = JSON.parse(line.strip)
-                header = SmartMessage::Header.new(message_data['header'])
-                receive(header, message_data['payload'])
-              rescue JSON::ParserError
-                # Skip malformed lines
-              end
-            end
-            
-            processed_positions[room_id] = lines.length
-          end
-        end
-        
-        sleep(@poll_interval)
-      end
-    end
-  end
-
-  def stop_subscriber
-    @running = false
-    @subscriber_thread&.join
-  end
-
-  private
-
-  def extract_room_id(payload)
-    begin
-      data = JSON.parse(payload)
-      data['room_id'] || 'global'
-    rescue
-      'global'
-    end
-  end
-end
-
-# Register the file transport
-SmartMessage::Transport.register(:file, FileTransport)
-
-# Define the Chat Message
-class ChatMessage < SmartMessage::Base
-  description "Chat messages for tmux-based multi-pane chat demonstration"
-  
-  property :message_id, 
-    description: "Unique identifier for this chat message"
-  property :room_id, 
-    description: "Chat room identifier for message routing"
-  property :sender_id, 
-    description: "Unique ID of the user or bot sending the message"
-  property :sender_name, 
-    description: "Display name of the message sender"
-  property :content, 
-    description: "The actual text content of the chat message"
-  property :message_type, 
-    description: "Message type: 'user', 'bot', or 'system'"
-  property :timestamp, 
-    description: "ISO8601 timestamp when message was sent"
-  property :mentions, 
-    description: "Array of user IDs mentioned in the message"
-  property :metadata, 
-    description: "Additional message metadata for tmux display"
-
-  config do
-    transport SmartMessage::Transport.create(:file)
-    serializer SmartMessage::Serializer::JSON.new
-  end
-
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
-    # Default processing - agents will override this
-  end
-end
-
-# Define Bot Command Message
-class BotCommandMessage < SmartMessage::Base
-  description "Commands sent to chat bots in the tmux chat system"
-  
-  property :command_id, 
-    description: "Unique identifier for this bot command"
-  property :room_id, 
-    description: "Chat room where the command was issued"
-  property :user_id, 
-    description: "User who issued the bot command"
-  property :user_name, 
-    description: "Display name of the user issuing the command"
-  property :command, 
-    description: "Bot command name (help, joke, weather, etc.)"
-  property :parameters, 
-    description: "Array of parameters for the bot command"
-  property :timestamp, 
-    description: "ISO8601 timestamp when command was issued"
-
-  config do
-    transport SmartMessage::Transport.create(:file)
-    serializer SmartMessage::Serializer::JSON.new
-  end
-
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
-    # Default processing - bots will override this
-  end
-end
-
-# Define System Notification Message
-class SystemNotificationMessage < SmartMessage::Base
-  description "System notifications for tmux chat room events and status updates"
-  
-  property :notification_id, 
-    description: "Unique identifier for this system notification"
-  property :room_id, 
-    description: "Chat room affected by this notification"
-  property :notification_type, 
-    description: "Type of notification (user_joined, user_left, etc.)"
-  property :content, 
-    description: "Human-readable description of the system event"
-  property :timestamp, 
-    description: "ISO8601 timestamp when the event occurred"
-  property :metadata, 
-    description: "Additional system event metadata for tmux display"
-
-  config do
-    transport SmartMessage::Transport.create(:file)
-    serializer SmartMessage::Serializer::JSON.new
-  end
-
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
-    # Default processing
-  end
-end
-
-# Base Agent class with display utilities
-class BaseAgent
-  attr_reader :agent_id, :name, :active_rooms
-
-  def initialize(agent_id:, name:, agent_type: 'agent')
-    @agent_id = agent_id
-    @name = name
-    @agent_type = agent_type
-    @active_rooms = []
-    @display_buffer = []
-    @transport = SmartMessage::Transport.create(:file)
-    
-    setup_display
-    setup_subscriptions
-    start_message_processing
-  end
-
-  def join_room(room_id)
-    return if @active_rooms.include?(room_id)
-    
-    @active_rooms << room_id
-    log_display("📥 Joined room: #{room_id}")
-    
-    send_system_notification(
-      room_id: room_id,
-      notification_type: 'user_joined',
-      content: "#{@name} joined the room"
-    )
-  end
-
-  def leave_room(room_id)
-    return unless @active_rooms.include?(room_id)
-    
-    @active_rooms.delete(room_id)
-    log_display("📤 Left room: #{room_id}")
-    
-    send_system_notification(
-      room_id: room_id,
-      notification_type: 'user_left',
-      content: "#{@name} left the room"
-    )
-  end
-
-  def send_message(room_id:, content:, message_type: 'user')
-    return unless @active_rooms.include?(room_id)
-    
-    message = ChatMessage.new(
-      message_id: generate_message_id,
-      room_id: room_id,
-      sender_id: @agent_id,
-      sender_name: @name,
-      content: content,
-      message_type: message_type,
-      timestamp: Time.now.iso8601,
-      mentions: extract_mentions(content),
-      metadata: { agent_type: @agent_type },
-      from: @agent_id
-    )
-    
-    log_display("💬 [#{room_id}] #{@name}: #{content}")
-    message.publish
-  end
-
-  def shutdown
-    @active_rooms.dup.each { |room_id| leave_room(room_id) }
-    @transport.stop_subscriber
-    log_display("🔴 #{@name} shutdown")
-  end
-
-  protected
-
-  def setup_display
-    puts "\033[2J\033[H"  # Clear screen
-    puts "┌─" + "─" * 50 + "┐"
-    puts "│ #{@agent_type.upcase}: #{@name.center(44)} │"
-    puts "├─" + "─" * 50 + "┤"
-    puts "│ Rooms: #{@active_rooms.join(', ').ljust(42)} │"
-    puts "├─" + "─" * 50 + "┤"
-    puts "│ Messages:".ljust(51) + " │"
-    puts "└─" + "─" * 50 + "┘"
-    puts
-  end
-
-  def log_display(message)
-    timestamp = Time.now.strftime("%H:%M:%S")
-    puts "[#{timestamp}] #{message}"
-  end
-
-  def setup_subscriptions
-    # Override in subclasses
-  end
-
-  def start_message_processing
-    @transport.start_subscriber
-  end
-
-  def send_system_notification(room_id:, notification_type:, content:)
-    notification = SystemNotificationMessage.new(
-      notification_id: "NOTIF-#{Time.now.to_i}-#{rand(1000)}",
-      room_id: room_id,
-      notification_type: notification_type,
-      content: content,
-      timestamp: Time.now.iso8601,
-      metadata: { triggered_by: @agent_id },
-      from: @agent_id
-    )
-    
-    notification.publish
-  end
-
-  def generate_message_id
-    "MSG-#{@agent_id}-#{Time.now.to_i}-#{rand(1000)}"
-  end
-
-  def extract_mentions(content)
-    content.scan(/@(\w+)/).flatten
-  end
-end
-
-# Cleanup utility
-def cleanup_shared_queues
-  FileUtils.rm_rf(SHARED_DIR) if Dir.exist?(SHARED_DIR)
-end
-
-# Signal handling for cleanup
-trap('INT') do
-  cleanup_shared_queues
-  exit
-end
-
-trap('TERM') do
-  cleanup_shared_queues
-  exit
-end