rails_console_ai 0.13.0

data/lib/rails_console_ai/engine.rb

@@ -0,0 +1,5 @@
+module RailsConsoleAI
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsConsoleAI
+  end
+end

data/lib/rails_console_ai/executor.rb

@@ -0,0 +1,461 @@
+require 'stringio'
+
+module RailsConsoleAI
+  # Writes to two IO streams simultaneously
+  class TeeIO
+    attr_reader :secondary
+
+    def initialize(primary, secondary)
+      @primary = primary
+      @secondary = secondary
+    end
+
+    def write(str)
+      @primary.write(str)
+      @secondary.write(str)
+    end
+
+    def puts(*args)
+      @primary.puts(*args)
+      # Capture what puts would output
+      args.each { |a| @secondary.write("#{a}\n") }
+      @secondary.write("\n") if args.empty?
+    end
+
+    def print(*args)
+      @primary.print(*args)
+      args.each { |a| @secondary.write(a.to_s) }
+    end
+
+    def flush
+      @primary.flush if @primary.respond_to?(:flush)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @primary.respond_to?(method, include_private) || super
+    end
+
+    def method_missing(method, *args, &block)
+      @primary.send(method, *args, &block)
+    end
+  end
+
+  class Executor
+    CODE_REGEX = /```ruby\s*\n(.*?)```/m
+
+    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception
+    attr_accessor :on_prompt
+
+    def initialize(binding_context, channel: nil)
+      @binding_context = binding_context
+      @channel = channel
+      @omitted_outputs = {}
+      @omitted_counter = 0
+      @output_store = {}
+      @output_counter = 0
+    end
+
+    def extract_code(response)
+      match = response.match(CODE_REGEX)
+      match ? match[1].strip : ''
+    end
+
+    # Matches any fenced code block (```anything ... ```)
+    ANY_CODE_FENCE_REGEX = /```\w*\s*\n.*?```/m
+
+    def display_response(response)
+      code = extract_code(response)
+      explanation = response.gsub(ANY_CODE_FENCE_REGEX, '').strip
+
+      if @channel
+        $stdout.puts
+        @channel.display(explanation) unless explanation.empty?
+        @channel.display_code(code) unless code.empty?
+      else
+        $stdout.puts
+        $stdout.puts colorize(explanation, :cyan) unless explanation.empty?
+
+        unless code.empty?
+          $stdout.puts
+          $stdout.puts colorize("# Generated code:", :yellow)
+          $stdout.puts highlight_code(code)
+          $stdout.puts
+        end
+      end
+
+      code
+    end
+
+    def execute(code)
+      return nil if code.nil? || code.strip.empty?
+
+      @last_error = nil
+      @last_safety_error = false
+      @last_safety_exception = nil
+      captured_output = StringIO.new
+      old_stdout = $stdout
+      # Tee output: capture it and also print to the real stdout
+      $stdout = TeeIO.new(old_stdout, captured_output)
+
+      result = with_safety_guards do
+        binding_context.eval(code, "(rails_console_ai)", 1)
+      end
+
+      $stdout = old_stdout
+
+      # Send captured puts output through channel before the return value
+      if @channel && !captured_output.string.empty?
+        @channel.display_result_output(captured_output.string)
+      end
+
+      display_result(result)
+
+      @last_output = captured_output.string
+      result
+    rescue RailsConsoleAI::SafetyError => e
+      $stdout = old_stdout if old_stdout
+      @last_error = "SafetyError: #{e.message}"
+      @last_safety_error = true
+      @last_safety_exception = e
+      display_error("Blocked: #{e.message}")
+      @last_output = captured_output&.string
+      nil
+    rescue SyntaxError => e
+      $stdout = old_stdout if old_stdout
+      @last_error = "SyntaxError: #{e.message}"
+      display_error(@last_error)
+      @last_output = nil
+      nil
+    rescue => e
+      $stdout = old_stdout if 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)
+        safety_msg = safety_exc ? safety_exc.message : e.message
+        @last_error = "SafetyError: #{safety_msg}"
+        @last_safety_error = true
+        @last_safety_exception = safety_exc
+        display_error("Blocked: #{safety_msg}")
+        @last_output = captured_output&.string
+        return nil
+      end
+      @last_error = "#{e.class}: #{e.message}"
+      display_error("Error: #{@last_error}")
+      e.backtrace.first(3).each { |line| display_error("  #{line}") }
+      @last_output = captured_output&.string
+      nil
+    end
+
+    def last_output
+      @last_output
+    end
+
+    def expand_output(id)
+      @omitted_outputs[id]
+    end
+
+    def store_output(content)
+      @output_counter += 1
+      @output_store[@output_counter] = content
+      @output_counter
+    end
+
+    def recall_output(id)
+      @output_store[id]
+    end
+
+    def last_answer
+      @last_answer
+    end
+
+    def last_cancelled?
+      @last_cancelled
+    end
+
+    def confirm_and_execute(code)
+      return nil if code.nil? || code.strip.empty?
+
+      @last_cancelled = false
+      @last_answer = nil
+      prompt = execute_prompt
+
+      if @channel
+        answer = @channel.confirm(prompt)
+      else
+        $stdout.print colorize(prompt, :yellow)
+        @on_prompt&.call
+        answer = $stdin.gets.to_s.strip.downcase
+        echo_stdin(answer)
+      end
+      @last_answer = answer
+
+      loop do
+        case answer
+        when 'y', 'yes', 'a'
+          result = execute(code)
+          if @last_safety_error
+            return nil unless danger_allowed?
+            return offer_danger_retry(code)
+          end
+          return result
+        when 'd', 'danger'
+          unless danger_allowed?
+            display_error("Safety guards cannot be disabled in this channel.")
+            return nil
+          end
+          if @channel
+            @channel.display_error("Executing with safety guards disabled.")
+          else
+            $stdout.puts colorize("Executing with safety guards disabled.", :red)
+          end
+          return execute_unsafe(code)
+        when 'e', 'edit'
+          edited = if @channel && @channel.supports_editing?
+                     @channel.edit_code(code)
+                   else
+                     open_in_editor(code)
+                   end
+          if edited && edited != code
+            $stdout.puts colorize("# Edited code:", :yellow)
+            $stdout.puts highlight_code(edited)
+            if @channel
+              edit_answer = @channel.confirm("Execute edited code? [y/N] ")
+            else
+              $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
+              edit_answer = $stdin.gets.to_s.strip.downcase
+              echo_stdin(edit_answer)
+            end
+            if edit_answer == 'y'
+              return execute(edited)
+            else
+              $stdout.puts colorize("Cancelled.", :yellow)
+              return nil
+            end
+          else
+            return execute(code)
+          end
+        when 'n', 'no', ''
+          $stdout.puts colorize("Cancelled.", :yellow)
+          @last_cancelled = true
+          return nil
+        else
+          if @channel
+            answer = @channel.confirm(prompt)
+          else
+            $stdout.print colorize(prompt, :yellow)
+            @on_prompt&.call
+            answer = $stdin.gets.to_s.strip.downcase
+            echo_stdin(answer)
+          end
+          @last_answer = answer
+        end
+      end
+    end
+
+    def offer_danger_retry(code)
+      return nil unless danger_allowed?
+
+      exc = @last_safety_exception
+      blocked_key = exc&.blocked_key
+      guard = exc&.guard
+
+      if blocked_key && guard
+        allow_desc = allow_description(guard, blocked_key)
+        $stdout.puts colorize("  [d] re-run with all safe mode disabled", :yellow)
+        $stdout.puts colorize("  [a] allow #{allow_desc} for this session", :yellow)
+        $stdout.puts colorize("  [N] cancel", :yellow)
+        prompt_text = "Choice: "
+      else
+        prompt_text = "Re-run with safe mode disabled? [y/N] "
+      end
+
+      if @channel
+        answer = @channel.confirm(prompt_text)
+      else
+        $stdout.print colorize(prompt_text, :yellow)
+        answer = $stdin.gets.to_s.strip.downcase
+        echo_stdin(answer)
+      end
+
+      case answer
+      when 'a', 'allow'
+        if blocked_key && guard
+          RailsConsoleAI.configuration.safety_guards.allow(guard, blocked_key)
+          allow_desc = allow_description(guard, blocked_key)
+          $stdout.puts colorize("Allowed #{allow_desc} for this session.", :green)
+          return execute(code)
+        else
+          if @channel
+            answer = @channel.confirm("Nothing to allow — re-run with safe mode disabled instead? [y/N] ")
+          else
+            $stdout.puts colorize("Nothing to allow — re-run with safe mode disabled instead? [y/N]", :yellow)
+            answer = $stdin.gets.to_s.strip.downcase
+            echo_stdin(answer)
+          end
+        end
+      when 'd', 'danger', 'y', 'yes'
+        $stdout.puts colorize("Executing with safety guards disabled.", :red)
+        return execute_unsafe(code)
+      end
+
+      $stdout.puts colorize("Cancelled.", :yellow)
+      nil
+    end
+
+    private
+
+    def danger_allowed?
+      @channel.nil? || @channel.supports_danger?
+    end
+
+    def display_error(msg)
+      if @channel
+        @channel.display_error(msg)
+      else
+        $stderr.puts colorize(msg, :red)
+      end
+    end
+
+    def allow_description(guard, blocked_key)
+      case guard
+      when :database_writes
+        "all writes to #{blocked_key}"
+      when :http_mutations
+        "all HTTP mutations to #{blocked_key}"
+      else
+        "#{blocked_key} for :#{guard}"
+      end
+    end
+
+    def execute_unsafe(code)
+      guards = RailsConsoleAI.configuration.safety_guards
+      guards.disable!
+      execute(code)
+    ensure
+      guards.enable!
+    end
+
+    def execute_prompt
+      guards = RailsConsoleAI.configuration.safety_guards
+      if !guards.empty? && guards.enabled? && danger_allowed?
+        "Execute? [y/N/edit/danger] "
+      else
+        "Execute? [y/N/edit] "
+      end
+    end
+
+    def with_safety_guards(&block)
+      RailsConsoleAI.configuration.safety_guards.wrap(&block)
+    end
+
+    # Check if an exception is or wraps a SafetyError (e.g. AR::StatementInvalid wrapping it)
+    def safety_error?(exception)
+      return true if exception.is_a?(RailsConsoleAI::SafetyError)
+      return true if exception.message.include?("RailsConsoleAI safe mode")
+      cause = exception.cause
+      while cause
+        return true if cause.is_a?(RailsConsoleAI::SafetyError)
+        cause = cause.cause
+      end
+      false
+    end
+
+    def extract_safety_exception(exception)
+      return exception if exception.is_a?(RailsConsoleAI::SafetyError)
+      cause = exception.cause
+      while cause
+        return cause if cause.is_a?(RailsConsoleAI::SafetyError)
+        cause = cause.cause
+      end
+      nil
+    end
+
+    MAX_DISPLAY_LINES = 10
+    MAX_DISPLAY_CHARS = 2000
+
+    def display_result(result)
+      if @channel
+        @channel.display_result(result)
+      else
+        full = "=> #{result.inspect}"
+        lines = full.lines
+        total_lines = lines.length
+        total_chars = full.length
+
+        if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
+          $stdout.puts colorize(full, :green)
+        else
+          truncated = lines.first(MAX_DISPLAY_LINES).join
+          truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
+          $stdout.puts colorize(truncated, :green)
+
+          omitted_lines = [total_lines - MAX_DISPLAY_LINES, 0].max
+          omitted_chars = [total_chars - truncated.length, 0].max
+          parts = []
+          parts << "#{omitted_lines} lines" if omitted_lines > 0
+          parts << "#{omitted_chars} chars" if omitted_chars > 0
+
+          @omitted_counter += 1
+          @omitted_outputs[@omitted_counter] = full
+          $stdout.puts colorize("  (omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+        end
+      end
+    end
+
+    # Write stdin input to the capture IO only (avoids double-echo on terminal)
+    def echo_stdin(text)
+      $stdout.secondary.write("#{text}\n") if $stdout.respond_to?(:secondary)
+    end
+
+    def open_in_editor(code)
+      require 'tempfile'
+      editor = ENV['EDITOR'] || 'vi'
+      tmpfile = Tempfile.new(['rails_console_ai', '.rb'])
+      tmpfile.write(code)
+      tmpfile.flush
+
+      system("#{editor} #{tmpfile.path}")
+      File.read(tmpfile.path)
+    rescue => e
+      $stderr.puts colorize("Editor error: #{e.message}", :red)
+      code
+    ensure
+      tmpfile.close! if tmpfile
+    end
+
+    def highlight_code(code)
+      if coderay_available?
+        CodeRay.scan(code, :ruby).terminal
+      else
+        colorize(code, :white)
+      end
+    end
+
+    def coderay_available?
+      return @coderay_available unless @coderay_available.nil?
+      @coderay_available = begin
+        require 'coderay'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+    COLORS = {
+      red:    "\e[31m",
+      green:  "\e[32m",
+      yellow: "\e[33m",
+      cyan:   "\e[36m",
+      white:  "\e[37m",
+      reset:  "\e[0m"
+    }.freeze
+
+    def colorize(text, color)
+      if $stdout.respond_to?(:tty?) && $stdout.tty?
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      else
+        text
+      end
+    end
+  end
+end

data/lib/rails_console_ai/providers/anthropic.rb

@@ -0,0 +1,122 @@
+module RailsConsoleAI
+  module Providers
+    class Anthropic < Base
+      API_URL = 'https://api.anthropic.com'.freeze
+
+      def chat(messages, system_prompt: nil)
+        result = call_api(messages, system_prompt: system_prompt)
+        result
+      end
+
+      def chat_with_tools(messages, tools:, system_prompt: nil)
+        call_api(messages, system_prompt: system_prompt, tools: tools)
+      end
+
+      def format_assistant_message(result)
+        # Rebuild the assistant content blocks from the raw response
+        content_blocks = []
+        content_blocks << { 'type' => 'text', 'text' => result.text } if result.text && !result.text.empty?
+        (result.tool_calls || []).each do |tc|
+          content_blocks << {
+            'type' => 'tool_use',
+            'id' => tc[:id],
+            'name' => tc[:name],
+            'input' => tc[:arguments]
+          }
+        end
+        { role: 'assistant', content: content_blocks }
+      end
+
+      def format_tool_result(tool_call_id, result_string)
+        {
+          role: 'user',
+          content: [
+            {
+              'type' => 'tool_result',
+              'tool_use_id' => tool_call_id,
+              'content' => result_string.to_s
+            }
+          ]
+        }
+      end
+
+      private
+
+      def call_api(messages, system_prompt: nil, tools: nil)
+        conn = build_connection(API_URL, {
+          'x-api-key' => config.resolved_api_key,
+          'anthropic-version' => '2023-06-01'
+        })
+
+        body = {
+          model: config.resolved_model,
+          max_tokens: config.resolved_max_tokens,
+          temperature: config.temperature,
+          messages: format_messages(messages)
+        }
+        if system_prompt
+          body[:system] = [
+            { 'type' => 'text', 'text' => system_prompt, 'cache_control' => { 'type' => 'ephemeral' } }
+          ]
+        end
+        if tools
+          anthropic_tools = tools.to_anthropic_format
+          anthropic_tools.last['cache_control'] = { 'type' => 'ephemeral' } if anthropic_tools.any?
+          body[:tools] = anthropic_tools
+        end
+
+        json_body = JSON.generate(body)
+        debug_request("#{API_URL}/v1/messages", body)
+        response = conn.post('/v1/messages', json_body)
+        debug_response(response.body)
+        data = parse_response(response)
+        usage = data['usage'] || {}
+
+        tool_calls = extract_tool_calls(data)
+        stop = data['stop_reason'] == 'tool_use' ? :tool_use : :end_turn
+
+        ChatResult.new(
+          text: extract_text(data),
+          input_tokens: usage['input_tokens'],
+          output_tokens: usage['output_tokens'],
+          cache_read_input_tokens: usage['cache_read_input_tokens'],
+          cache_write_input_tokens: usage['cache_creation_input_tokens'],
+          tool_calls: tool_calls,
+          stop_reason: stop
+        )
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg[:content].is_a?(Array)
+            { role: msg[:role].to_s, content: msg[:content] }
+          else
+            { role: msg[:role].to_s, content: msg[:content].to_s }
+          end
+        end
+      end
+
+      def extract_text(data)
+        content = data['content']
+        return '' unless content.is_a?(Array)
+
+        content.select { |c| c['type'] == 'text' }
+               .map { |c| c['text'] }
+               .join("\n")
+      end
+
+      def extract_tool_calls(data)
+        content = data['content']
+        return [] unless content.is_a?(Array)
+
+        content.select { |c| c['type'] == 'tool_use' }.map do |c|
+          {
+            id: c['id'],
+            name: c['name'],
+            arguments: c['input'] || {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rails_console_ai/providers/base.rb

@@ -0,0 +1,118 @@
+require 'faraday'
+require 'json'
+
+module RailsConsoleAI
+  module Providers
+    class Base
+      attr_reader :config
+
+      def initialize(config = RailsConsoleAI.configuration)
+        @config = config
+      end
+
+      def chat(messages, system_prompt: nil)
+        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      end
+
+      def chat_with_tools(messages, tools:, system_prompt: nil)
+        raise NotImplementedError, "#{self.class}#chat_with_tools must be implemented"
+      end
+
+      def format_assistant_message(_result)
+        raise NotImplementedError, "#{self.class}#format_assistant_message must be implemented"
+      end
+
+      def format_tool_result(_tool_call_id, _result_string)
+        raise NotImplementedError, "#{self.class}#format_tool_result must be implemented"
+      end
+
+      private
+
+      def build_connection(url, headers = {})
+        Faraday.new(url: url) do |f|
+          t = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
+          f.options.timeout = t
+          f.options.open_timeout = t
+          f.headers.update(headers)
+          f.headers['Content-Type'] = 'application/json'
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def debug_request(url, body)
+        return unless config.debug
+
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed
+          # Support both symbol and string keys
+          model = parsed[:model] || parsed['model']
+          msgs = parsed[:messages] || parsed['messages']
+          sys = parsed[:system] || parsed['system']
+          tools = parsed[:tools] || parsed['tools']
+          $stderr.puts "\e[33m[debug] POST #{url} | model: #{model} | #{msgs&.length || 0} msgs | system: #{sys.to_s.length} chars | #{tools&.length || 0} tools\e[0m"
+        else
+          $stderr.puts "\e[33m[debug] POST #{url}\e[0m"
+        end
+      end
+
+      def debug_response(body)
+        return unless config.debug
+
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed && parsed['usage']
+          u = parsed['usage']
+          $stderr.puts "\e[36m[debug] response: #{parsed['stop_reason']} | in: #{u['input_tokens']} out: #{u['output_tokens']}\e[0m"
+        end
+      end
+
+      def parse_response(response)
+        unless response.success?
+          body = begin
+                   JSON.parse(response.body)
+                 rescue
+                   { 'error' => response.body }
+                 end
+          error_msg = body.dig('error', 'message') || body['error'] || response.body
+          raise ProviderError, "API error (#{response.status}): #{error_msg}"
+        end
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise ProviderError, "Failed to parse response: #{e.message}"
+      end
+    end
+
+    class ProviderError < StandardError; end
+
+    ChatResult = Struct.new(:text, :input_tokens, :output_tokens, :tool_calls, :stop_reason,
+                            :cache_read_input_tokens, :cache_write_input_tokens, keyword_init: true) do
+      def total_tokens
+        (input_tokens || 0) + (output_tokens || 0)
+      end
+
+      def tool_use?
+        stop_reason == :tool_use && tool_calls && !tool_calls.empty?
+      end
+    end
+
+    def self.build(config = RailsConsoleAI.configuration)
+      case config.provider
+      when :anthropic
+        require 'rails_console_ai/providers/anthropic'
+        Anthropic.new(config)
+      when :openai
+        require 'rails_console_ai/providers/openai'
+        OpenAI.new(config)
+      when :local
+        require 'rails_console_ai/providers/openai'
+        require 'rails_console_ai/providers/local'
+        Local.new(config)
+      when :bedrock
+        require 'rails_console_ai/providers/bedrock'
+        Bedrock.new(config)
+      else
+        raise ConfigurationError, "Unknown provider: #{config.provider}"
+      end
+    end
+  end
+end