earl-bot 0.1.0

data/lib/earl/runner/response_lifecycle.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Earl
+  class Runner
+    # Streaming response lifecycle: creates responses, wires callbacks, handles completion.
+    module ResponseLifecycle
+      # Bundles response context that travels together through the lifecycle.
+      ResponseBundle = Struct.new(:session, :response, :thread_id, keyword_init: true)
+
+      private
+
+      def prepare_response(session, thread_id, channel_id)
+        response = StreamingResponse.new(thread_id: thread_id, mattermost: @services.mattermost, channel_id: channel_id)
+        @responses.active_responses[thread_id] = response
+        response.start_typing
+        bundle = ResponseBundle.new(session: session, response: response, thread_id: thread_id)
+        wire_all_callbacks(bundle)
+        response
+      end
+
+      def wire_all_callbacks(bundle)
+        session, response, thread_id = bundle.deconstruct
+        resp_channel_id = response.channel_id
+        wire_text_callbacks(session, response)
+        session.on_complete { |_| handle_response_complete(thread_id) }
+        session.on_tool_use do |tool_use|
+          response.on_tool_use(tool_use)
+          handle_tool_use(thread_id: thread_id, tool_use: tool_use, channel_id: resp_channel_id)
+        end
+      end
+
+      def wire_text_callbacks(session, response)
+        session.on_text { |text| response.on_text(text) }
+        session.on_system { |event| response.on_text(event[:message]) }
+      end
+
+      def handle_tool_use(thread_id:, tool_use:, channel_id:)
+        result = @services.question_handler.handle_tool_use(thread_id: thread_id, tool_use: tool_use,
+                                                            channel_id: channel_id)
+        return unless result.is_a?(Hash)
+
+        tool_use_id = result[:tool_use_id]
+        @responses.question_threads[tool_use_id] = thread_id if tool_use_id
+      end
+
+      def handle_response_complete(thread_id)
+        response = @responses.active_responses.delete(thread_id)
+        session = @services.session_manager.get(thread_id)
+
+        if session && response
+          bundle = ResponseBundle.new(session: session, response: response, thread_id: thread_id)
+          finalize_response(bundle)
+        else
+          log_missing_completion(thread_id, response)
+        end
+
+        process_next_queued(thread_id)
+      end
+
+      def finalize_response(bundle)
+        session, response, thread_id = bundle.deconstruct
+        stats = session.stats
+        response.on_complete
+        log_session_stats(stats, thread_id)
+        @services.session_manager.save_stats(thread_id)
+      end
+
+      def log_missing_completion(thread_id, response)
+        log(:warn, "Completion for thread #{thread_id[0..7]} with missing session or response (likely killed)")
+        response&.stop_typing
+      end
+
+      def log_session_stats(stats, thread_id)
+        summary = stats.format_summary("Thread #{thread_id[0..7]} complete")
+        log(:info, summary)
+      end
+
+      def log_processing_error(thread_id, error)
+        log(:error, "Error processing message for thread #{thread_id[0..7]}: #{error.message}")
+        log(:error, error.backtrace&.first(5)&.join("\n"))
+      end
+
+      def stop_active_response(thread_id)
+        response = @responses.active_responses.delete(thread_id)
+        response&.stop_typing
+        @app_state.message_queue.dequeue(thread_id)
+      end
+
+      def cleanup_failed_send(thread_id)
+        response = @responses.active_responses.delete(thread_id)
+        response&.stop_typing
+        @app_state.message_queue.release(thread_id)
+      end
+    end
+  end
+end

data/lib/earl/runner/service_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Earl
+  class Runner
+    # Constructs and wires together the service dependency graph.
+    module ServiceBuilder
+      private
+
+      def build_services
+        core = build_core_services
+        assemble_services(core)
+      end
+
+      def build_core_services
+        config = Config.new
+        session_store = SessionStore.new
+        mattermost = Mattermost.new(config)
+        { config: config, session_store: session_store, mattermost: mattermost,
+          tmux_store: TmuxSessionStore.new,
+          session_manager: SessionManager.new(config: config, session_store: session_store) }
+      end
+
+      def assemble_services(core)
+        config, mattermost, tmux_store = core.values_at(:config, :mattermost, :tmux_store)
+        Services.new(
+          **core,
+          heartbeat_scheduler: HeartbeatScheduler.new(config: config, mattermost: mattermost),
+          command_executor: build_command_executor(core),
+          question_handler: QuestionHandler.new(mattermost: mattermost),
+          tmux_monitor: TmuxMonitor.new(mattermost: mattermost, tmux_store: tmux_store)
+        )
+      end
+
+      def build_command_executor(core)
+        CommandExecutor.new(
+          session_manager: core[:session_manager], mattermost: core[:mattermost],
+          config: core[:config], heartbeat_scheduler: nil, tmux_store: core[:tmux_store]
+        )
+      end
+
+      def wire_circular_deps
+        executor_deps = @services.command_executor.instance_variable_get(:@deps)
+        executor_deps.heartbeat_scheduler = @services.heartbeat_scheduler
+        executor_deps.runner = self
+      end
+    end
+  end
+end

data/lib/earl/runner/startup.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Earl
+  class Runner
+    # Startup, channel configuration, and restart notification logic.
+    module Startup
+      private
+
+      def configure_channels
+        channels = @services.config.channels
+        @services.mattermost.configure_channels(Set.new(channels.keys)) if channels.size > 1
+      end
+
+      def log_startup
+        config = @services.config
+        channel_names = resolve_channel_names(config.channels.keys)
+        count = channel_names.size
+        log(:info,
+            "EARL is running. Listening in #{count} channel#{"s" unless count == 1}: #{channel_names.join(", ")}")
+        log(:info, "Allowed users: #{config.allowed_users.join(", ")}")
+        notify_restart
+      end
+
+      def notify_restart
+        data = read_restart_context
+        return unless data
+
+        verb = data["command"] == "update" ? "updated" : "restarted"
+        @services.mattermost.create_post(
+          channel_id: data["channel_id"],
+          message: ":white_check_mark: EARL #{verb} successfully.",
+          root_id: data["thread_id"]
+        )
+      rescue StandardError => error
+        log(:warn, "Failed to post restart notification: #{error.message}")
+      end
+
+      def read_restart_context
+        path = File.join(Earl.config_root, "restart_context.json")
+        data = JSON.parse(File.read(path))
+        File.delete(path)
+        data
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def resolve_channel_names(channel_ids)
+        channel_ids.map do |id|
+          info = @services.mattermost.get_channel(channel_id: id)
+          info&.fetch("display_name", nil) || info&.fetch("name", nil) || id[0..7]
+        end
+      end
+
+      def start_background_services
+        start_idle_checker
+        @services.heartbeat_scheduler.start
+        @services.tmux_monitor.start
+      end
+
+      def setup_handlers
+        setup_signal_handlers
+        setup_message_handler
+        setup_reaction_handler
+        setup_close_handler
+      end
+
+      def setup_signal_handlers
+        %w[INT TERM].each { |signal| trap(signal) { handle_shutdown_signal } }
+        trap("HUP") { handle_restart_signal }
+      end
+    end
+  end
+end

data/lib/earl/runner/thread_context_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Earl
+  class Runner
+    # Builds contextual messages for new Claude sessions by prepending
+    # Mattermost thread transcripts so Claude has conversation history.
+    class ThreadContextBuilder
+      MAX_PRIOR_POSTS = 20
+
+      def initialize(mattermost:)
+        @mattermost = mattermost
+      end
+
+      # When a Claude session is first created for a thread that already has messages
+      # (e.g., from !commands and EARL replies), prepend the thread transcript so
+      # Claude has context. Returns the original text if no prior messages exist.
+      def build(thread_id, text)
+        prior_posts = fetch_prior_posts(thread_id, text)
+        return text if prior_posts.empty?
+
+        transcript = format_transcript(prior_posts)
+        "Here is the conversation so far in this Mattermost thread:\n\n#{transcript}\n\n" \
+          "---\n\nUser's latest message: #{text}"
+      end
+
+      private
+
+      def fetch_prior_posts(thread_id, current_text)
+        posts = @mattermost.get_thread_posts(thread_id)
+        posts.reject { |post| post[:message] == current_text }.last(MAX_PRIOR_POSTS)
+      end
+
+      def format_transcript(posts)
+        posts.map { |post| format_post(post) }.join("\n\n")
+      end
+
+      def format_post(post)
+        role = post[:is_bot] ? "EARL" : "User"
+        "#{role}: #{post[:message]}"
+      end
+    end
+  end
+end

data/lib/earl/runner.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Earl
+  # Main event loop that connects Mattermost messages to Claude sessions,
+  # managing per-thread message queuing, command parsing, question handling,
+  # and streaming response delivery.
+  class Runner
+    include Logging
+    include Formatting
+
+    # Tracks runtime state: shutdown flag, restart intent, and per-thread message queue.
+    AppState = Struct.new(:shutting_down, :pending_restart, :pending_update, :shutdown_thread, :message_queue,
+                          :idle_checker_thread, keyword_init: true)
+
+    # Bundles user message parameters that travel together through message routing.
+    UserMessage = Data.define(:thread_id, :text, :channel_id, :sender_name)
+
+    # Groups injected service dependencies to keep ivar count low.
+    Services = Struct.new(:config, :session_store, :session_manager, :mattermost,
+                          :command_executor, :question_handler, :heartbeat_scheduler,
+                          :tmux_store, :tmux_monitor, keyword_init: true)
+
+    # Groups per-thread response tracking state.
+    ResponseState = Struct.new(:question_threads, :active_responses, keyword_init: true)
+
+    IDLE_CHECK_INTERVAL = 300 # 5 minutes
+    IDLE_TIMEOUT = 1800 # 30 minutes
+
+    def initialize
+      @services = build_services
+      wire_circular_deps
+      @app_state = AppState.new(shutting_down: false, pending_restart: false, pending_update: false,
+                                shutdown_thread: nil, message_queue: MessageQueue.new)
+      @responses = ResponseState.new(question_threads: {}, active_responses: {})
+
+      configure_channels
+    end
+
+    def start
+      setup_handlers
+      ClaudeSession.cleanup_mcp_configs
+      @services.session_manager.resume_all
+      @services.tmux_store.cleanup!
+      start_background_services
+      @services.mattermost.connect
+      log_startup
+      sleep 0.5 until @app_state.shutting_down
+      wait_and_exec_restart if @app_state.pending_restart
+    end
+
+    def request_restart
+      @app_state.pending_restart = true
+      begin_shutdown { restart }
+    end
+
+    def request_update
+      @app_state.pending_restart = true
+      @app_state.pending_update = true
+      begin_shutdown { restart }
+    end
+
+    include ServiceBuilder
+    include Startup
+    include Lifecycle
+    include MessageHandling
+    include ReactionHandling
+    include ResponseLifecycle
+    include IdleManagement
+  end
+end