rails_console_ai 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e038cc77de185b7afbbc1d859400948335adfe8d69e714ef35d57a8c49fb8b34
-  data.tar.gz: e614a1ccaa212bfaa93dfb1770f3d8c5b39ee2c1e678ba3a4cab3786f7e0c86f
+  metadata.gz: f6fc753a055c35cdf2aec7ffa98dff0cf5b0dd649e9fd44048d5f43577a69a9a
+  data.tar.gz: c9ce948130dae8a58ee8eaaa6d348f00369a9c2f63cb253a9728323493df04e6
 SHA512:
-  metadata.gz: ba68a62e707d3b35f2fc0f7f24d9d73d930c951936f37f8ec60c34dce7975bf67e184bf05fd418db1773c9ec7d58455cf25c122477ec67bde8fcee47247fcb25
-  data.tar.gz: 3fa2a64467e090b52ae68b21f93e9a1cc15f03b445f8f9a02ec0ca51d74514211f6a4eeff551ec91858adccb7c59e1a46218191480c7e749c28538c665897287
+  metadata.gz: c20f24123aafbef6c1e2dd218ba47f63c3773e0bae332081422aba1f52a821bf5e94baf09a5db13919e61a12cdb40124de139739a352fb9b8486f3cf3de9be77
+  data.tar.gz: 62808844bd51a0a5f3aadae221d2a9641b47dc497a548c0edbc1ccda247eaf0e24785920621850b387165d20698f9ccf77aa1f14b59f9432f0c9dcc17c034aac

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.18.0]
+
+- Handle "smart" quotes coming from Slack
+- Eager load when Slack bot starts up
+- Handle `>` in Slack for direct code execution
+- Handle stopping of sessions in Slack bot by recording the stop
+
+## [0.17.0]
+
+- Add `/retry` command
+- Print provider information when `ai!` starts
+- Keep Slack bot alive during long-running sessions
+- Improve Slack bot log prefixes for production log search
+- Catch safety errors even when swallowed by executed code
+- Fix Bedrock handling of multiple tool results
+
 ## [0.16.0]
 
 - Run migrations during setup

data/lib/rails_console_ai/channel/console.rb

@@ -158,6 +158,8 @@ module RailsConsoleAi
         guards = RailsConsoleAi.configuration.safety_guards
         name_display = @engine.session_name ? " (#{@engine.session_name})" : ""
         @real_stdout.puts "\e[36mRailsConsoleAi interactive mode#{name_display}. Type 'exit' or 'quit' to leave.\e[0m"
+        config = RailsConsoleAi.configuration
+        @real_stdout.puts "\e[2m  Provider: #{config.provider} | Model: #{config.resolved_model}\e[0m"
         safe_info = guards.empty? ? '' : " | Safe mode: #{guards.enabled? ? 'ON' : 'OFF'} (/danger to toggle)"
         @real_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle)#{safe_info} | > code | /usage | /cost | /compact | /think | /name <label>\e[0m"
 
@@ -259,6 +261,8 @@ module RailsConsoleAi
           else
             @real_stdout.puts "\e[33mNo omitted output with id #{expand_id}\e[0m"
           end
+        when '/retry'
+          retry_last_code
         when /\A\/name/
           handle_name_command(input)
         else
@@ -267,6 +271,10 @@ module RailsConsoleAi
         true
       end
 
+      def retry_last_code
+        @engine.retry_last_code
+      end
+
       def handle_direct_execution(input)
         raw_code = input.sub(/\A>\s?/, '')
         Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
@@ -341,6 +349,7 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    /system      Show the system prompt\e[0m"
         @real_stdout.puts "\e[2m    /expand <id> Show full omitted output\e[0m"
         @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    exit/quit    Leave interactive mode\e[0m"
       end

data/lib/rails_console_ai/channel/slack.rb

@@ -37,14 +37,14 @@ module RailsConsoleAi
         elsif stripped =~ /\ACalling LLM/
           # Technical LLM round status — suppress in Slack
           @output_log.write("#{stripped}\n")
-          $stdout.puts "#{@log_prefix} (dim) #{stripped}"
+          STDOUT.puts "#{@log_prefix} (dim) #{stripped}"
         elsif raw =~ /\A {2,4}\S/ && stripped.length > 10
           # LLM thinking text (2-space indent from conversation engine) — show as status
           post(stripped)
         else
           # Tool result previews (5+ space indent) and other technical noise — log only
           @output_log.write("#{stripped}\n")
-          $stdout.puts "#{@log_prefix} (dim) #{stripped}"
+          STDOUT.puts "#{@log_prefix} (dim) #{stripped}"
         end
       end
 
@@ -150,7 +150,7 @@ module RailsConsoleAi
       def post(text)
         return if text.nil? || text.strip.empty?
         @output_log.write("#{text}\n")
-        $stdout.puts "#{@log_prefix} >> #{text}"
+        STDOUT.puts "#{@log_prefix} >> #{text}"
         @slack_bot.send(:post_message,
           channel: @channel_id,
           thread_ts: @thread_ts,

data/lib/rails_console_ai/conversation_engine.rb

@@ -221,6 +221,16 @@ module RailsConsoleAi
       end
     end
 
+    def retry_last_code
+      code = @last_interactive_code
+      unless code
+        @channel.display_warning("No code to retry.")
+        return
+      end
+      @channel.display_dim("  Retrying last code...")
+      execute_direct(code)
+    end
+
     def execute_direct(raw_code)
       exec_result = @executor.execute(raw_code)
 

data/lib/rails_console_ai/executor.rb

@@ -1,4 +1,5 @@
 require 'stringio'
+require_relative 'safety_guards'
 
 module RailsConsoleAi
   # Writes to two IO streams simultaneously
@@ -97,12 +98,25 @@ module RailsConsoleAi
       # Tee output: capture it and also print to the real stdout
       $stdout = TeeIO.new(old_stdout, captured_output)
 
+      RailsConsoleAi::SafetyError.clear!
+
       result = with_safety_guards do
         binding_context.eval(code, "(rails_console_ai)", 1)
       end
 
       $stdout = old_stdout
 
+      # Check if a SafetyError was raised but swallowed by a rescue inside the eval'd code
+      if (swallowed = RailsConsoleAi::SafetyError.last_raised)
+        RailsConsoleAi::SafetyError.clear!
+        @last_error = "SafetyError: #{swallowed.message}"
+        @last_safety_error = true
+        @last_safety_exception = swallowed
+        display_error("Blocked: #{swallowed.message}")
+        @last_output = captured_output&.string
+        return nil
+      end
+
       # Send captured puts output through channel before the return value
       if @channel && !captured_output.string.empty?
         @channel.display_result_output(captured_output.string)
@@ -114,6 +128,7 @@ module RailsConsoleAi
       result
     rescue RailsConsoleAi::SafetyError => e
       $stdout = old_stdout if old_stdout
+      RailsConsoleAi::SafetyError.clear!
       @last_error = "SafetyError: #{e.message}"
       @last_safety_error = true
       @last_safety_exception = e

data/lib/rails_console_ai/prefixed_io.rb

@@ -0,0 +1,50 @@
+module RailsConsoleAi
+  class PrefixedIO
+    def initialize(io)
+      @io = io
+    end
+
+    def write(str)
+      prefix = Thread.current[:log_prefix]
+      if prefix && str.is_a?(String) && !str.strip.empty?
+        prefixed = str.gsub(/^(?=.)/, "#{prefix} ")
+        @io.write(prefixed)
+      else
+        @io.write(str)
+      end
+    end
+
+    def puts(*args)
+      prefix = Thread.current[:log_prefix]
+      if prefix
+        args = [""] if args.empty?
+        args.each do |a|
+          line = a.to_s
+          if line.strip.empty?
+            @io.write("\n")
+          else
+            @io.write("#{prefix} #{line}\n")
+          end
+        end
+      else
+        @io.puts(*args)
+      end
+    end
+
+    def print(*args)
+      @io.print(*args)
+    end
+
+    def flush
+      @io.flush
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @io.respond_to?(method, include_private) || super
+    end
+
+    def method_missing(method, *args, &block)
+      @io.send(method, *args, &block)
+    end
+  end
+end

data/lib/rails_console_ai/providers/bedrock.rb

@@ -115,7 +115,7 @@ module RailsConsoleAi
       end
 
       def format_messages(messages)
-        messages.map do |msg|
+        formatted = messages.map do |msg|
           content = if msg[:content].is_a?(Array)
                       msg[:content]
                     else
@@ -123,6 +123,18 @@ module RailsConsoleAi
                     end
           { role: msg[:role].to_s, content: content }
         end
+
+        # Bedrock requires all tool_result blocks for a single assistant turn
+        # to be in one user message. Merge consecutive same-role messages.
+        merged = []
+        formatted.each do |msg|
+          if merged.last && merged.last[:role] == msg[:role]
+            merged.last[:content].concat(msg[:content])
+          else
+            merged << msg
+          end
+        end
+        merged
       end
 
       def extract_text(response)

data/lib/rails_console_ai/safety_guards.rb

@@ -5,10 +5,21 @@ module RailsConsoleAi
   class SafetyError < StandardError
     attr_reader :guard, :blocked_key
 
+    # Thread-local tracking so the executor can detect safety errors
+    # even when swallowed by a rescue inside eval'd code.
+    def self.last_raised
+      Thread.current[:rails_console_ai_last_safety_error]
+    end
+
+    def self.clear!
+      Thread.current[:rails_console_ai_last_safety_error] = nil
+    end
+
     def initialize(message, guard: nil, blocked_key: nil)
       super(message)
       @guard = guard
       @blocked_key = blocked_key
+      Thread.current[:rails_console_ai_last_safety_error] = self
     end
   end
 

data/lib/rails_console_ai/slack_bot.rb

@@ -2,6 +2,7 @@ require 'json'
 require 'uri'
 require 'net/http'
 require 'openssl'
+require 'rails_console_ai/prefixed_io'
 require 'rails_console_ai/channel/slack'
 require 'rails_console_ai/conversation_engine'
 require 'rails_console_ai/context_builder'
@@ -10,6 +11,9 @@ require 'rails_console_ai/executor'
 
 module RailsConsoleAi
   class SlackBot
+    PING_INTERVAL = 30  # seconds — send ping if no data received
+    PONG_TIMEOUT  = 60  # seconds — reconnect if no pong after ping
+
     def initialize
       @bot_token = RailsConsoleAi.configuration.slack_bot_token || ENV['SLACK_BOT_TOKEN']
       @app_token = RailsConsoleAi.configuration.slack_app_token || ENV['SLACK_APP_TOKEN']
@@ -26,6 +30,18 @@ module RailsConsoleAi
     end
 
     def start
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = RailsConsoleAi::PrefixedIO.new($stdout) unless $stdout.is_a?(RailsConsoleAi::PrefixedIO)
+      $stderr = RailsConsoleAi::PrefixedIO.new($stderr) unless $stderr.is_a?(RailsConsoleAi::PrefixedIO)
+
+      # Eager load the Rails app so class-level initializers (e.g. Secret.get)
+      # run before safety guards are active during user code execution.
+      if defined?(Rails) && Rails.application.respond_to?(:eager_load!)
+        puts "Eager loading application..."
+        Rails.application.eager_load!
+      end
+
       @bot_user_id = slack_api("auth.test", token: @bot_token).dig("user_id")
       log_startup
 
@@ -78,9 +94,27 @@ module RailsConsoleAi
 
       puts "Connected to Slack Socket Mode."
 
-      # Main read loop
+      # Main read loop with keepalive
+      last_activity = Time.now
+      ping_sent = false
+
       loop do
+        ready = IO.select([ssl.to_io], nil, nil, PING_INTERVAL)
+
+        if ready.nil?
+          # Timeout — no data received
+          if ping_sent && (Time.now - last_activity) > PONG_TIMEOUT
+            puts "Slack connection timed out (no pong received). Reconnecting..."
+            break
+          end
+          send_ws_ping(ssl)
+          ping_sent = true
+          next
+        end
+
         data = read_ws_frame(ssl)
+        last_activity = Time.now
+        ping_sent = false
         next unless data
 
         begin
@@ -130,6 +164,11 @@ module RailsConsoleAi
         send_ws_pong(ssl, payload)
         return nil
       end
+      # Handle pong (opcode 10) — response to our keepalive ping
+      if opcode == 0xA
+        read_ws_payload(ssl) # consume payload
+        return nil
+      end
       # Close frame (opcode 8)
       return nil if opcode == 8
       # Only process text frames (opcode 1)
@@ -194,6 +233,14 @@ module RailsConsoleAi
       ssl.write(frame)
     end
 
+    def send_ws_ping(ssl)
+      mask_key = 4.times.map { rand(256) }
+      frame = [0x89].pack("C") # FIN + ping opcode
+      frame << [0x80].pack("C") # masked, zero-length payload
+      frame << mask_key.pack("C*")
+      ssl.write(frame)
+    end
+
     # --- Slack Web API (minimal, uses Net::HTTP) ---
 
     def slack_api(method, token: @bot_token, **params)
@@ -232,7 +279,7 @@ module RailsConsoleAi
       return if event[:user] == @bot_user_id
       return if event[:subtype]
 
-      text = event[:text]
+      text = unescape_slack(event[:text])
       return unless text && !text.strip.empty?
 
       channel_id = event[:channel]
@@ -276,6 +323,15 @@ module RailsConsoleAi
         return
       end
 
+      # Direct code execution: "> User.count" runs code without LLM
+      if text.strip.start_with?('>')
+        raw_code = text.strip.sub(/\A>\s*/, '')
+        unless raw_code.empty?
+          handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
+          return
+        end
+      end
+
       if session
         handle_thread_reply(session, text.strip)
       else
@@ -309,6 +365,7 @@ module RailsConsoleAi
 
       session[:thread] = Thread.new do
         Thread.current.report_on_exception = false
+        Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}] @#{user_name}"
         begin
           channel.display_dim("_session: #{channel_id}/#{thread_ts}_")
           if restored
@@ -351,6 +408,7 @@ module RailsConsoleAi
       # Otherwise treat as a new message in the conversation
       session[:thread] = Thread.new do
         Thread.current.report_on_exception = false
+        Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
         begin
           engine.process_message(text)
         rescue => e
@@ -362,11 +420,76 @@ module RailsConsoleAi
       end
     end
 
+    def handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
+      # Ensure a session exists for this thread
+      unless session
+        start_direct_session(channel_id, thread_ts, user_name)
+        session = @mutex.synchronize { @sessions[thread_ts] }
+      end
+
+      channel = session[:channel]
+      engine = session[:engine]
+
+      session[:thread] = Thread.new do
+        Thread.current.report_on_exception = false
+        Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
+        begin
+          engine.execute_direct(raw_code)
+          # Post return value to Slack (execute_direct suppresses it via display_result no-op)
+          result_value = engine.instance_variable_get(:@last_interactive_result)
+          unless result_value.nil?
+            display_text = "=> #{result_value}"
+            display_text = display_text[0, 3000] + "\n... (truncated)" if display_text.length > 3000
+            post_message(channel: channel_id, thread_ts: thread_ts, text: "```#{display_text}```")
+          end
+          engine.send(:log_interactive_turn)
+        rescue => e
+          channel.display_error("Error: #{e.class}: #{e.message}")
+          RailsConsoleAi.logger.error("SlackBot direct code error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+        ensure
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+    end
+
+    def start_direct_session(channel_id, thread_ts, user_name)
+      channel = Channel::Slack.new(
+        slack_bot: self,
+        channel_id: channel_id,
+        thread_ts: thread_ts,
+        user_name: user_name
+      )
+
+      sandbox_binding = Object.new.instance_eval { binding }
+      engine = ConversationEngine.new(
+        binding_context: sandbox_binding,
+        channel: channel,
+        slack_thread_ts: thread_ts
+      )
+
+      restore_from_db(engine, thread_ts)
+      engine.init_interactive unless engine.instance_variable_get(:@interactive_start)
+
+      session = { channel: channel, engine: engine, thread: nil }
+      @mutex.synchronize { @sessions[thread_ts] = session }
+    end
+
     def cancel_session(session, channel_id, thread_ts)
       if session
         session[:channel].cancel!
         session[:channel].display("Stopped.")
         puts "[#{channel_id}/#{thread_ts}] cancel requested"
+
+        # Record stop in conversation history so restored sessions know
+        # the previous topic was abandoned by the user
+        engine = session[:engine]
+        engine.history << { role: :user, content: "stop" }
+        engine.history << { role: :assistant, content: "Stopped. Awaiting new instructions." }
+        begin
+          engine.send(:log_interactive_turn)
+        rescue => e
+          RailsConsoleAi.logger.warn("SlackBot: failed to save cancel state: #{e.message}")
+        end
       else
         post_message(channel: channel_id, thread_ts: thread_ts, text: "No active session to stop.")
         puts "[#{channel_id}/#{thread_ts}] cancel: no session"
@@ -412,6 +535,13 @@ module RailsConsoleAi
       { "ok" => false, "error" => e.message }
     end
 
+    def unescape_slack(text)
+      return text unless text
+      text.gsub("&amp;", "&").gsub("&lt;", "<").gsub("&gt;", ">")
+          .gsub("\u2018", "'").gsub("\u2019", "'")   # smart single quotes → straight
+          .gsub("\u201C", '"').gsub("\u201D", '"')    # smart double quotes → straight
+    end
+
     def waiting_for_reply?(channel)
       channel.instance_variable_get(:@reply_queue).num_waiting > 0
     end

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.16.0'.freeze
+  VERSION = '0.18.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Cortfr
@@ -109,6 +109,7 @@ files:
 - lib/rails_console_ai/conversation_engine.rb
 - lib/rails_console_ai/engine.rb
 - lib/rails_console_ai/executor.rb
+- lib/rails_console_ai/prefixed_io.rb
 - lib/rails_console_ai/providers/anthropic.rb
 - lib/rails_console_ai/providers/base.rb
 - lib/rails_console_ai/providers/bedrock.rb