rails_console_ai 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41b94c2b3a01cba1210242c6c8752510fc1976bf9b7195272f4a109dceadcdab
-  data.tar.gz: 6c813abfeeda804b115dfd2a385bc67e1796b0af80cc438e5f41d66886fa519e
+  metadata.gz: 89e0f9e402a40af4755fe61d2029f10a90c487c1d957e007032dcdd1f54a1c82
+  data.tar.gz: 7e68825010aed2bd0f7a07cdcd68a39d54edec2616913ab14c9a10aa972e6d4f
 SHA512:
-  metadata.gz: 52281835764610528b039d12ac786ec7056d035e9055d5574bee3a3143c9833e8fa5943a5932980c7ee28ae77351a178186dc15b3afb2f0e9acb7c71b1104c5f
-  data.tar.gz: d1f56cd511ff3411b6e2783c0790bbc3d012a420971fe2cd400f7f573ffc168f5b6bca5c692618bf5c4ef2eaa9d0d0283958afcf1b7ac71d426dd4f2f4377425
+  metadata.gz: f0efcfa92b22f8cd4df14a643904aba9c0e3c05ac7873de6a303f72fd6cdd4df5c457cf1fdcafb120a02784c7247663e48141500f69214ac5bbfafa945ec9ce0
+  data.tar.gz: 2aed178645529500d0b1d72772e19307d4b42de2a0db586f928a46df2a6503d78f3693cde4222006ad0e4227ea840b4bd510a6ef5631e9395466cf9035db679a

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.25.0]
+
+- Expand truncation limits
+- Allow any user on allow list to interact with Slack bot in a thread
+- Handle ctrl-c better in console
+- Fix stdout capture in Slack sessions
+- Improve Slack bot logging
+- Fix thread safety issues in Slack bot
+
 ## [0.24.0]
 
 - Refactor thinking text display and include in Slack with more technical detail

data/lib/rails_console_ai/channel/console.rb

@@ -127,8 +127,8 @@ module RailsConsoleAi
 
       # --- Omitted output tracking (shared with Executor) ---
 
-      MAX_DISPLAY_LINES = 10
-      MAX_DISPLAY_CHARS = 2000
+      MAX_DISPLAY_LINES = 20
+      MAX_DISPLAY_CHARS = 4000
 
       def init_omitted_tracking
         @omitted_outputs = {}
@@ -230,7 +230,16 @@ module RailsConsoleAi
           @interactive_console_capture.write("ai> #{input}\n")
           @engine.log_interactive_turn
 
-          status = @engine.send_and_execute
+          expected_stdout = $stdout
+          begin
+            status = @engine.send_and_execute
+          rescue Interrupt
+            $stdout = expected_stdout
+            $stdout.puts "\n\e[33m  Cancelled.\e[0m"
+            @engine.pop_last_message
+            @engine.log_interactive_turn
+            next
+          end
           if status == :interrupted
             @engine.pop_last_message
             @engine.log_interactive_turn
@@ -413,6 +422,7 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    /debug       Toggle debug summaries (context stats, cost per call)\e[0m"
         @real_stdout.puts "\e[2m    /retry       Re-execute the last code block\e[0m"
         @real_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
+        @real_stdout.puts "\e[2m    Ctrl-C       Cancel the current operation\e[0m"
         @real_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
       end
 

data/lib/rails_console_ai/channel/slack.rb

@@ -42,7 +42,7 @@ module RailsConsoleAi
           post(stripped)
         else
           @output_log.write("#{stripped}\n")
-          STDOUT.puts "#{@log_prefix} (status) #{stripped}"
+          log_prefixed("(status)", stripped)
         end
       end
 
@@ -56,7 +56,7 @@ module RailsConsoleAi
 
       def display_tool_call(text)
         @output_log.write("-> #{text}\n")
-        STDOUT.puts "#{@log_prefix} -> #{text}"
+        log_prefixed("->", text)
       end
 
       def display_code(code)
@@ -161,7 +161,7 @@ module RailsConsoleAi
       def post(text)
         return if text.nil? || text.strip.empty?
         @output_log.write("#{text}\n")
-        STDOUT.puts "#{@log_prefix} >> #{text}"
+        log_prefixed(">>", text)
         @slack_bot.send(:post_message,
           channel: @channel_id,
           thread_ts: @thread_ts,
@@ -171,6 +171,10 @@ module RailsConsoleAi
         RailsConsoleAi.logger.error("Slack post failed: #{e.message}")
       end
 
+      def log_prefixed(tag, text)
+        text.each_line { |line| STDOUT.puts "#{@log_prefix} #{tag} #{line.rstrip}" }
+      end
+
       def strip_ansi(text)
         text.to_s.gsub(ANSI_REGEX, '')
       end

data/lib/rails_console_ai/configuration.rb

@@ -135,7 +135,7 @@ module RailsConsoleAi
       end
 
       if allow
-        Array(allow).each { |key| safety_guards.allow(guard_name, key) }
+        Array(allow).each { |key| safety_guards.allow_global(guard_name, key) }
       end
     end
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -3,8 +3,8 @@ module RailsConsoleAi
     attr_reader :history, :total_input_tokens, :total_output_tokens,
                 :interactive_session_id, :session_name
 
-    LARGE_OUTPUT_THRESHOLD = 10_000      # chars — truncate tool results larger than this immediately
-    LARGE_OUTPUT_PREVIEW_CHARS = 8_000   # chars — how much of the output the LLM sees upfront
+    LARGE_OUTPUT_THRESHOLD = 20_000      # chars — truncate tool results larger than this immediately
+    LARGE_OUTPUT_PREVIEW_CHARS = 16_000  # chars — how much of the output the LLM sees upfront
     LOOP_WARN_THRESHOLD = 3              # same tool+args repeated → inject warning
     LOOP_BREAK_THRESHOLD = 5             # same tool+args repeated → break loop
 

data/lib/rails_console_ai/executor.rb

@@ -100,13 +100,18 @@ module RailsConsoleAi
       @last_safety_exception = nil
       captured_output = StringIO.new
       old_stdout = $stdout
-      # When a channel is present it handles display (with truncation), so capture only.
-      # Without a channel, tee so output appears live on the terminal.
-      $stdout = if @channel
-                  captured_output
-                else
-                  TeeIO.new(old_stdout, captured_output)
-                end
+      # Three capture strategies:
+      # 1. Slack mode (PrefixedIO active): thread-local capture to avoid cross-thread pollution
+      # 2. Console mode (channel present): capture-only, channel.display_result_output shows it after
+      # 3. No channel (tests/one-shot): TeeIO so output appears live AND is captured
+      use_thread_local = defined?(RailsConsoleAi::PrefixedIO) && $stdout.is_a?(RailsConsoleAi::PrefixedIO)
+      if use_thread_local
+        Thread.current[:capture_io] = captured_output
+      elsif @channel
+        $stdout = captured_output
+      else
+        $stdout = TeeIO.new(old_stdout, captured_output)
+      end
 
       RailsConsoleAi::SafetyError.clear!
 
@@ -114,7 +119,7 @@ module RailsConsoleAi
         binding_context.eval(code, "(rails_console_ai)", 1)
       end
 
-      $stdout = old_stdout
+      restore_stdout(use_thread_local, old_stdout)
 
       # Check if a SafetyError was raised but swallowed by a rescue inside the eval'd code
       if (swallowed = RailsConsoleAi::SafetyError.last_raised)
@@ -136,8 +141,12 @@ module RailsConsoleAi
 
       @last_output = captured_output.string
       result
+    rescue Interrupt
+      restore_stdout(use_thread_local, old_stdout)
+      @last_output = captured_output&.string
+      raise
     rescue RailsConsoleAi::SafetyError => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       RailsConsoleAi::SafetyError.clear!
       @last_error = "SafetyError: #{e.message}"
       @last_safety_error = true
@@ -146,13 +155,13 @@ module RailsConsoleAi
       @last_output = captured_output&.string
       nil
     rescue SyntaxError => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       @last_error = "SyntaxError: #{e.message}"
       log_execution_error(@last_error)
       @last_output = nil
       nil
     rescue => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       # Check if a SafetyError is wrapped (e.g. ActiveRecord::StatementInvalid wrapping our error)
       if safety_error?(e)
         safety_exc = extract_safety_exception(e)
@@ -333,6 +342,14 @@ module RailsConsoleAi
 
     private
 
+    def restore_stdout(use_thread_local, old_stdout)
+      if use_thread_local
+        Thread.current[:capture_io] = nil
+      else
+        $stdout = old_stdout if old_stdout
+      end
+    end
+
     def danger_allowed?
       @channel.nil? || @channel.supports_danger?
     end

data/lib/rails_console_ai/prefixed_io.rb

@@ -5,6 +5,9 @@ module RailsConsoleAi
     end
 
     def write(str)
+      if (capture = Thread.current[:capture_io])
+        return capture.write(str)
+      end
       prefix = Thread.current[:log_prefix]
       if prefix && str.is_a?(String) && !str.strip.empty?
         prefixed = str.gsub(/^(?=.)/, "#{prefix} ")
@@ -15,6 +18,9 @@ module RailsConsoleAi
     end
 
     def puts(*args)
+      if (capture = Thread.current[:capture_io])
+        return capture.puts(*args)
+      end
       prefix = Thread.current[:log_prefix]
       if prefix
         args = [""] if args.empty?
@@ -32,6 +38,9 @@ module RailsConsoleAi
     end
 
     def print(*args)
+      if (capture = Thread.current[:capture_io])
+        return capture.print(*args)
+      end
       @io.print(*args)
     end
 

data/lib/rails_console_ai/safety_guards.rb

@@ -41,15 +41,15 @@ module RailsConsoleAi
     end
 
     def enabled?
-      @enabled
+      @enabled && !Thread.current[:rails_console_ai_guards_disabled]
     end
 
     def enable!
-      @enabled = true
+      Thread.current[:rails_console_ai_guards_disabled] = nil
     end
 
     def disable!
-      @enabled = false
+      Thread.current[:rails_console_ai_guards_disabled] = true
     end
 
     def empty?
@@ -60,33 +60,52 @@ module RailsConsoleAi
       @guards.keys
     end
 
-    def allow(guard_name, key)
+    # Add a permanent (config-time) allowlist entry visible to all threads.
+    def allow_global(guard_name, key)
       guard_name = guard_name.to_sym
       @allowlist[guard_name] ||= []
       @allowlist[guard_name] << key unless @allowlist[guard_name].include?(key)
     end
 
-    def allowed?(guard_name, key)
-      entries = @allowlist[guard_name.to_sym]
-      return false unless entries
+    # Add a thread-local allowlist entry (runtime "allow for this session").
+    def allow(guard_name, key)
+      thread_list = Thread.current[:rails_console_ai_allowlist] ||= {}
+      guard_name = guard_name.to_sym
+      thread_list[guard_name] ||= []
+      thread_list[guard_name] << key unless thread_list[guard_name].include?(key)
+    end
 
-      entries.any? do |entry|
-        case entry
-        when Regexp then key.match?(entry)
-        else entry.to_s == key.to_s
+    def allowed?(guard_name, key)
+      guard_name = guard_name.to_sym
+      match = ->(entries) {
+        entries&.any? do |entry|
+          case entry
+          when Regexp then key.match?(entry)
+          else entry.to_s == key.to_s
+          end
         end
-      end
+      }
+      # Check global (config-time) allowlist
+      return true if match.call(@allowlist[guard_name])
+      # Check thread-local (runtime session) allowlist
+      thread_list = Thread.current[:rails_console_ai_allowlist]
+      return true if thread_list && match.call(thread_list[guard_name])
+      false
     end
 
     def allowlist
-      @allowlist
+      thread_list = Thread.current[:rails_console_ai_allowlist]
+      return @allowlist unless thread_list
+      merged = @allowlist.dup
+      thread_list.each { |k, v| merged[k] = (merged[k] || []) + v }
+      merged
     end
 
     # Compose all guards around a block of code.
     # Each guard is an around-block: guard.call { inner }
     # Result: guard_1 { guard_2 { guard_3 { yield } } }
     def wrap(channel_mode: nil, additional_bypass_methods: nil, &block)
-      return yield unless @enabled && !@guards.empty?
+      return yield unless enabled? && !@guards.empty?
 
       install_skills_once!
       bypass_set = resolve_bypass_methods(channel_mode)

data/lib/rails_console_ai/slack_bot.rb

@@ -281,6 +281,19 @@ module RailsConsoleAi
       slack_api("chat.postMessage", channel: channel, thread_ts: thread_ts, text: text)
     end
 
+    # Cancel any in-progress thread on this session before spawning a new one.
+    # Prevents concurrent engine access when users send messages faster than
+    # the LLM can respond.
+    def replace_session_thread(session, &block)
+      old_thread = session[:thread]
+      if old_thread&.alive?
+        session[:channel].cancel!
+        old_thread.join(5) # wait up to 5s for graceful shutdown
+        session[:channel].instance_variable_set(:@cancelled, false)
+      end
+      session[:thread] = Thread.new(&block)
+    end
+
     # --- Event handling ---
 
     def handle_event(msg)
@@ -314,17 +327,14 @@ module RailsConsoleAi
 
         session = @mutex.synchronize { @sessions[thread_ts] }
         if session
-          # Enforce session ownership
-          unless session[:owner_user_id] == user_id
-            # Non-owner: tell unrecognized users, silently ignore recognized non-owners
-            chk_name = resolve_user_name(user_id)
-            unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', chk_name)
-              puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{chk_name} << (ignored — not in allowed usernames)"
-              post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{chk_name}). Ask an admin to add you to the allowed usernames list.")
-            end
+          # Any allowed user can interact with an existing session
+          chk_name = resolve_user_name(user_id)
+          unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', chk_name)
+            puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{chk_name} << (ignored — not in allowed usernames)"
+            post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{chk_name}). Ask an admin to add you to the allowed usernames list.")
             return
           end
-          # Owner must @mention unless bot asked a question (waiting_for_reply?)
+          # Must @mention unless bot asked a question (waiting_for_reply?)
           return unless mentioned || waiting_for_reply?(session[:channel])
           # Log thread messages since last mention
           thread_msgs = fetch_thread_messages(channel_id, thread_ts, since_ts: session[:last_seen_ts], exclude_ts: event[:ts])
@@ -482,7 +492,7 @@ module RailsConsoleAi
       end
 
       # Otherwise treat as a new message in the conversation
-      session[:thread] = Thread.new do
+      replace_session_thread(session) do
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
         begin
@@ -514,7 +524,7 @@ module RailsConsoleAi
       channel = session[:channel]
       engine = session[:engine]
 
-      session[:thread] = Thread.new do
+      replace_session_thread(session) do
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
         begin
@@ -614,7 +624,7 @@ module RailsConsoleAi
         summary = bang_cost(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
       when 'compact'
-        session[:thread] = Thread.new do
+        replace_session_thread(session) do
           Thread.current.report_on_exception = false
           begin
             before = engine.history.length
@@ -646,7 +656,7 @@ module RailsConsoleAi
         summary = bang_context(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
       when 'retry'
-        session[:thread] = Thread.new do
+        replace_session_thread(session) do
           Thread.current.report_on_exception = false
           Thread.current[:log_prefix] = session[:channel].instance_variable_get(:@log_prefix)
           begin

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.24.0'.freeze
+  VERSION = '0.25.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Cortfr