rails_console_ai 0.13.0

data/lib/rails_console_ai/configuration.rb

@@ -0,0 +1,185 @@
+module RailsConsoleAI
+  class Configuration
+    PROVIDERS = %i[anthropic openai local bedrock].freeze
+
+    # cache_read: 0.1x input, cache_write: 1.25x input for Anthropic models
+    PRICING = {
+      'claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000, cache_read: 0.30 / 1_000_000, cache_write: 3.75 / 1_000_000 },
+      'claude-opus-4-6'   => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000, cache_read: 1.50 / 1_000_000, cache_write: 18.75 / 1_000_000 },
+      'claude-haiku-4-5-20251001' => { input: 0.80 / 1_000_000, output: 4.0 / 1_000_000, cache_read: 0.08 / 1_000_000, cache_write: 1.0 / 1_000_000 },
+      # Bedrock model IDs (same pricing as direct API)
+      'us.anthropic.claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000, cache_read: 0.30 / 1_000_000, cache_write: 3.75 / 1_000_000 },
+      'us.anthropic.claude-opus-4-6-v1' => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000, cache_read: 1.50 / 1_000_000, cache_write: 18.75 / 1_000_000 },
+    }.freeze
+
+    DEFAULT_MAX_TOKENS = {
+      'claude-sonnet-4-6' => 16_000,
+      'claude-haiku-4-5-20251001' => 16_000,
+      'claude-opus-4-6'   => 4_096,
+    }.freeze
+
+    attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
+                  :auto_execute, :temperature,
+                  :timeout, :debug, :max_tool_rounds,
+                  :storage_adapter, :memories_enabled,
+                  :session_logging, :connection_class,
+                  :admin_username, :admin_password,
+                  :authenticate,
+                  :slack_bot_token, :slack_app_token, :slack_channel_ids, :slack_allowed_usernames,
+                  :local_url, :local_model, :local_api_key,
+                  :bedrock_region
+
+    def initialize
+      @provider     = :anthropic
+      @api_key      = nil
+      @model        = nil
+      @thinking_model = nil
+      @max_tokens   = nil
+      @auto_execute = false
+      @temperature  = 0.2
+      @timeout      = 30
+      @debug        = false
+      @max_tool_rounds = 200
+      @storage_adapter  = nil
+      @memories_enabled = true
+      @session_logging  = true
+      @connection_class = nil
+      @admin_username   = nil
+      @admin_password   = nil
+      @authenticate     = nil
+      @safety_guards    = nil
+      @slack_bot_token  = nil
+      @slack_app_token  = nil
+      @slack_channel_ids = nil
+      @slack_allowed_usernames = nil
+      @local_url        = 'http://localhost:11434'
+      @local_model      = 'qwen2.5:7b'
+      @local_api_key    = nil
+      @bedrock_region   = nil
+    end
+
+    def safety_guards
+      @safety_guards ||= begin
+        require 'rails_console_ai/safety_guards'
+        SafetyGuards.new
+      end
+    end
+
+    # Register a custom safety guard by name with an around-block.
+    #
+    #   config.safety_guard :mailers do |&execute|
+    #     ActionMailer::Base.perform_deliveries = false
+    #     execute.call
+    #   ensure
+    #     ActionMailer::Base.perform_deliveries = true
+    #   end
+    def safety_guard(name, &block)
+      safety_guards.add(name, &block)
+    end
+
+    # Register a built-in safety guard by name.
+    # Available: :database_writes, :http_mutations, :mailers
+    #
+    # Options:
+    #   allow: Array of strings or regexps to allowlist for this guard.
+    #     - :http_mutations  → hosts (e.g. "s3.amazonaws.com", /googleapis\.com/)
+    #     - :database_writes → table names (e.g. "rails_console_ai_sessions")
+    def use_builtin_safety_guard(name, allow: nil)
+      require 'rails_console_ai/safety_guards'
+      guard_name = name.to_sym
+      case guard_name
+      when :database_writes
+        safety_guards.add(:database_writes, &BuiltinGuards.database_writes)
+      when :http_mutations
+        safety_guards.add(:http_mutations, &BuiltinGuards.http_mutations)
+      when :mailers
+        safety_guards.add(:mailers, &BuiltinGuards.mailers)
+      else
+        raise ConfigurationError, "Unknown built-in safety guard: #{name}. Available: database_writes, http_mutations, mailers"
+      end
+
+      if allow
+        Array(allow).each { |key| safety_guards.allow(guard_name, key) }
+      end
+    end
+
+    def resolved_api_key
+      return @api_key if @api_key && !@api_key.empty?
+
+      case @provider
+      when :anthropic
+        ENV['ANTHROPIC_API_KEY']
+      when :openai
+        ENV['OPENAI_API_KEY']
+      when :local
+        @local_api_key || 'no-key'
+      when :bedrock
+        'aws-sdk'
+      end
+    end
+
+    def resolved_model
+      return @model if @model && !@model.empty?
+
+      case @provider
+      when :anthropic
+        'claude-sonnet-4-6'
+      when :openai
+        'gpt-5.3-codex'
+      when :local
+        @local_model
+      when :bedrock
+        'us.anthropic.claude-sonnet-4-6'
+      end
+    end
+
+    def resolved_max_tokens
+      return @max_tokens if @max_tokens
+
+      DEFAULT_MAX_TOKENS.fetch(resolved_model, 4096)
+    end
+
+    def resolved_thinking_model
+      return @thinking_model if @thinking_model && !@thinking_model.empty?
+
+      case @provider
+      when :anthropic
+        'claude-opus-4-6'
+      when :openai
+        'gpt-5.3-codex'
+      when :local
+        @local_model
+      when :bedrock
+        'us.anthropic.claude-opus-4-6-v1'
+      end
+    end
+
+    def resolved_timeout
+      @provider == :local ? [@timeout, 300].max : @timeout
+    end
+
+    def validate!
+      unless PROVIDERS.include?(@provider)
+        raise ConfigurationError, "Unknown provider: #{@provider}. Valid: #{PROVIDERS.join(', ')}"
+      end
+
+      if @provider == :local
+        raise ConfigurationError, "No local_url configured for :local provider." unless @local_url && !@local_url.empty?
+      elsif @provider == :bedrock
+        begin
+          require 'aws-sdk-bedrockruntime'
+        rescue LoadError
+          raise ConfigurationError,
+            "aws-sdk-bedrockruntime gem is required for the :bedrock provider. Add it to your Gemfile."
+        end
+      else
+        unless resolved_api_key
+          env_var = @provider == :anthropic ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'
+          raise ConfigurationError, "No API key. Set config.api_key or #{env_var} env var."
+        end
+      end
+    end
+  end
+
+  class ConfigurationError < StandardError; end
+end

data/lib/rails_console_ai/console_methods.rb

@@ -0,0 +1,277 @@
+module RailsConsoleAI
+  module ConsoleMethods
+    def ai_status
+      RailsConsoleAI.status
+    end
+
+    def ai_memories(n = nil)
+      require 'yaml'
+      require 'rails_console_ai/tools/memory_tools'
+      storage = RailsConsoleAI.storage
+      keys = storage.list('memories/*.md').sort
+
+      if keys.empty?
+        $stdout.puts "\e[2mNo memories stored yet.\e[0m"
+        return nil
+      end
+
+      memories = keys.filter_map do |key|
+        content = storage.read(key)
+        next if content.nil? || content.strip.empty?
+        next unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
+        fm = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
+        fm.merge('description' => $2.strip, 'file' => key)
+      end
+
+      if memories.empty?
+        $stdout.puts "\e[2mNo memories stored yet.\e[0m"
+        return nil
+      end
+
+      shown = n ? memories.last(n) : memories.last(5)
+      total = memories.length
+
+      $stdout.puts "\e[36m[Memories — showing last #{shown.length} of #{total}]\e[0m"
+      shown.each do |m|
+        $stdout.puts "\e[33m  #{m['name']}\e[0m"
+        $stdout.puts "\e[2m  #{m['description']}\e[0m"
+        tags = Array(m['tags'])
+        $stdout.puts "\e[2m  tags: #{tags.join(', ')}\e[0m" unless tags.empty?
+        $stdout.puts
+      end
+
+      path = storage.respond_to?(:root_path) ? File.join(storage.root_path, 'memories') : 'memories/'
+      $stdout.puts "\e[2mStored in: #{path}/\e[0m"
+      $stdout.puts "\e[2mUse ai_memories(n) to show last n.\e[0m"
+      nil
+    end
+
+    def ai_sessions(n = 10, search: nil)
+      require 'rails_console_ai/session_logger'
+      session_class = Object.const_get('RailsConsoleAI::Session')
+
+      scope = session_class.recent
+      scope = scope.search(search) if search
+      sessions = scope.limit(n)
+
+      if sessions.empty?
+        $stdout.puts "\e[2mNo sessions found.\e[0m"
+        return nil
+      end
+
+      $stdout.puts "\e[36m[Sessions — showing #{sessions.length}#{search ? " matching \"#{search}\"" : ''}]\e[0m"
+      $stdout.puts
+
+      sessions.each do |s|
+        id_str = "\e[2m##{s.id}\e[0m"
+        name_str = s.name ? "\e[33m#{s.name}\e[0m " : ""
+        query_str = s.name ? "\e[2m#{truncate_str(s.query, 50)}\e[0m" : truncate_str(s.query, 50)
+        mode_str = "\e[2m[#{s.mode}]\e[0m"
+        time_str = "\e[2m#{time_ago(s.created_at)}\e[0m"
+        tokens = (s.input_tokens || 0) + (s.output_tokens || 0)
+        token_str = tokens > 0 ? "\e[2m#{tokens} tokens\e[0m" : ""
+
+        $stdout.puts "  #{id_str} #{name_str}#{query_str}"
+        $stdout.puts "     #{mode_str} #{time_str} #{token_str}"
+        $stdout.puts
+      end
+
+      $stdout.puts "\e[2mUse ai_resume(id_or_name) to resume a session.\e[0m"
+      $stdout.puts "\e[2mUse ai_sessions(n, search: \"term\") to filter.\e[0m"
+      nil
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai_resume(identifier = nil)
+      __ensure_rails_console_ai_user
+
+      require 'rails_console_ai/context_builder'
+      require 'rails_console_ai/providers/base'
+      require 'rails_console_ai/executor'
+      require 'rails_console_ai/repl'
+      require 'rails_console_ai/session_logger'
+
+      session = if identifier
+                  __find_session(identifier)
+                else
+                  session_class = Object.const_get('RailsConsoleAI::Session')
+                  session_class.where(mode: 'interactive', user_name: RailsConsoleAI.current_user).recent.first
+                end
+
+      unless session
+        msg = identifier ? "Session not found: #{identifier}" : "No interactive sessions found."
+        $stderr.puts "\e[31m#{msg}\e[0m"
+        return nil
+      end
+
+      repl = Repl.new(__rails_console_ai_binding)
+      repl.resume(session)
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai_name(identifier, new_name)
+      require 'rails_console_ai/session_logger'
+
+      session = __find_session(identifier)
+      unless session
+        $stderr.puts "\e[31mSession not found: #{identifier}\e[0m"
+        return nil
+      end
+
+      RailsConsoleAI::SessionLogger.update(session.id, name: new_name)
+      $stdout.puts "\e[36mSession ##{session.id} named: #{new_name}\e[0m"
+      nil
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai_setup
+      RailsConsoleAI.setup!
+    end
+
+    def ai_init
+      require 'rails_console_ai/context_builder'
+      require 'rails_console_ai/providers/base'
+      require 'rails_console_ai/executor'
+      require 'rails_console_ai/repl'
+
+      repl = Repl.new(__rails_console_ai_binding)
+      repl.init_guide
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai(query = nil)
+      if query.nil?
+        $stderr.puts "\e[33mUsage: ai \"your question here\"\e[0m"
+        $stderr.puts "\e[33m  ai  \"query\"  - ask + confirm execution\e[0m"
+        $stderr.puts "\e[33m  ai! \"query\"  - enter interactive mode (or ai! with no args)\e[0m"
+        $stderr.puts "\e[33m  ai? \"query\"  - explain only, no execution\e[0m"
+        $stderr.puts "\e[33m  ai_init      - generate/update app guide for better AI context\e[0m"
+        $stderr.puts "\e[33m  ai_sessions  - list recent sessions\e[0m"
+        $stderr.puts "\e[33m  ai_resume    - resume a session by name or id\e[0m"
+        $stderr.puts "\e[33m  ai_name      - name a session: ai_name 42, \"my_label\"\e[0m"
+        $stderr.puts "\e[33m  ai_setup     - install session logging table\e[0m"
+        $stderr.puts "\e[33m  ai_status    - show current configuration\e[0m"
+        $stderr.puts "\e[33m  ai_memories  - show recent memories (ai_memories(n) for last n)\e[0m"
+        return nil
+      end
+
+      __ensure_rails_console_ai_user
+
+      require 'rails_console_ai/context_builder'
+      require 'rails_console_ai/providers/base'
+      require 'rails_console_ai/executor'
+      require 'rails_console_ai/repl'
+
+      repl = Repl.new(__rails_console_ai_binding)
+      repl.one_shot(query.to_s)
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai!(query = nil)
+      __ensure_rails_console_ai_user
+
+      require 'rails_console_ai/context_builder'
+      require 'rails_console_ai/providers/base'
+      require 'rails_console_ai/executor'
+      require 'rails_console_ai/repl'
+
+      repl = Repl.new(__rails_console_ai_binding)
+
+      if query
+        repl.one_shot(query.to_s)
+      else
+        repl.interactive
+      end
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    def ai?(query = nil)
+      unless query
+        $stderr.puts "\e[33mUsage: ai? \"your question here\" - explain without executing\e[0m"
+        return nil
+      end
+
+      __ensure_rails_console_ai_user
+
+      require 'rails_console_ai/context_builder'
+      require 'rails_console_ai/providers/base'
+      require 'rails_console_ai/executor'
+      require 'rails_console_ai/repl'
+
+      repl = Repl.new(__rails_console_ai_binding)
+      repl.explain(query.to_s)
+    rescue => e
+      $stderr.puts "\e[31mRailsConsoleAI error: #{e.message}\e[0m"
+      nil
+    end
+
+    private
+
+    def __find_session(identifier)
+      session_class = Object.const_get('RailsConsoleAI::Session')
+      if identifier.is_a?(Integer)
+        session_class.find_by(id: identifier)
+      else
+        session_class.where(name: identifier.to_s).recent.first ||
+          session_class.find_by(id: identifier.to_i)
+      end
+    end
+
+    def truncate_str(str, max)
+      return '' if str.nil?
+      str.length > max ? str[0...max] + '...' : str
+    end
+
+    def time_ago(time)
+      return '' unless time
+      seconds = Time.now - time
+      case seconds
+      when 0...60       then "just now"
+      when 60...3600    then "#{(seconds / 60).to_i}m ago"
+      when 3600...86400 then "#{(seconds / 3600).to_i}h ago"
+      else                   "#{(seconds / 86400).to_i}d ago"
+      end
+    end
+
+    def __ensure_rails_console_ai_user
+      return if RailsConsoleAI.current_user
+      $stdout.puts "\e[36mRailsConsoleAI logs all AI sessions for audit purposes.\e[0m"
+      $stdout.print "\e[36mPlease enter your name: \e[0m"
+      name = $stdin.gets.to_s.strip
+      RailsConsoleAI.current_user = name.empty? ? ENV['USER'] : name
+    end
+
+    def __rails_console_ai_binding
+      # Try Pry first (pry-rails replaces IRB but IRB may still be loaded)
+      if defined?(Pry)
+        pry_inst = ObjectSpace.each_object(Pry).find { |p|
+          p.respond_to?(:binding_stack) && !p.binding_stack.empty?
+        } rescue nil
+        return pry_inst.current_binding if pry_inst
+      end
+
+      # Try IRB workspace binding
+      if defined?(IRB) && IRB.respond_to?(:CurrentContext)
+        ctx = IRB.CurrentContext rescue nil
+        if ctx && ctx.respond_to?(:workspace) && ctx.workspace.respond_to?(:binding)
+          return ctx.workspace.binding
+        end
+      end
+
+      # Fallback
+      TOPLEVEL_BINDING
+    end
+  end
+end

data/lib/rails_console_ai/context_builder.rb

@@ -0,0 +1,120 @@
+module RailsConsoleAI
+  class ContextBuilder
+    def initialize(config = RailsConsoleAI.configuration)
+      @config = config
+    end
+
+    def build
+      build_smart
+    rescue => e
+      RailsConsoleAI.logger.warn("RailsConsoleAI: context build error: #{e.message}")
+      smart_system_instructions + "\n\n" + environment_context
+    end
+
+    def build_smart
+      parts = []
+      parts << smart_system_instructions
+      parts << environment_context
+      parts << guide_context
+      parts << memory_context
+      parts.compact.join("\n\n")
+    end
+
+    def environment_context
+      lines = ["## Environment"]
+      lines << "- Ruby #{RUBY_VERSION}"
+      lines << "- Rails #{Rails.version}" if defined?(Rails) && Rails.respond_to?(:version)
+
+      if defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+        adapter = ActiveRecord::Base.connection.adapter_name rescue 'unknown'
+        lines << "- Database adapter: #{adapter}"
+      end
+
+      if defined?(Bundler)
+        key_gems = %w[devise cancancan pundit sidekiq delayed_job resque
+                      paperclip carrierwave activestorage shrine
+                      pg mysql2 sqlite3 mongoid]
+        loaded = key_gems.select { |g| Gem.loaded_specs.key?(g) }
+        lines << "- Key gems: #{loaded.join(', ')}" unless loaded.empty?
+      end
+
+      lines.join("\n")
+    end
+
+    private
+
+    def smart_system_instructions
+      <<~PROMPT.strip
+        You are a Ruby on Rails console assistant. The user is in a `rails console` session.
+        You help them query data, debug issues, and understand their application.
+
+        You have tools available to introspect the app's database schema, models, and source code.
+        Use them as needed to write accurate queries. For example, call list_tables to see what
+        tables exist, then describe_table to get column details for the ones you need.
+
+        You also have an ask_user tool to ask the console user clarifying questions. Use it when
+        you need specific information to write accurate code — such as which user they are, which
+        record to target, or what value to use.
+
+        You have memory tools to persist what you learn across sessions:
+        - save_memory: persist facts or procedures you learn about this codebase.
+          If a memory with the same name already exists, it will be updated in place.
+        - delete_memory: remove a memory by name
+        - recall_memories: search your saved memories for details
+
+        IMPORTANT: Check the Memories section below BEFORE answering. If a memory is relevant,
+        use recall_memories to get full details and apply that knowledge to your answer.
+        When you use a memory, mention it briefly (e.g. "Based on what I know about sharding...").
+        When you discover important patterns about this app, save them as memories.
+
+        You have an execute_plan tool to run multi-step code. When a task requires multiple
+        sequential operations, use execute_plan with an array of steps (each with a description
+        and Ruby code). The plan is shown to the user for review before execution begins.
+        After each step runs, its return value is stored as step1, step2, etc. — use these
+        variables in later steps to reference earlier results (e.g. `api = SalesforceApi.new(step1)`).
+        For simple single-expression answers, you may respond with a ```ruby code block instead.
+
+        RULES:
+        - Give ONE concise answer. Do not offer multiple alternatives or variations.
+        - For multi-step tasks, use execute_plan to break the work into small, clear steps.
+        - For simple queries, respond with a single ```ruby code block.
+        - Include a brief one-line explanation before any code block.
+        - Use the app's actual model names, associations, and schema.
+        - Prefer ActiveRecord query interface over raw SQL.
+        - For destructive operations, add a comment warning.
+        - NEVER use placeholder values like YOUR_USER_ID or YOUR_EMAIL in code. If you need
+          a specific value from the user, call the ask_user tool to get it first.
+        - Keep code concise and idiomatic.
+        - Use tools to look up schema/model details rather than guessing column names.
+      PROMPT
+    end
+
+    def guide_context
+      content = RailsConsoleAI.storage.read(RailsConsoleAI::GUIDE_KEY)
+      return nil if content.nil? || content.strip.empty?
+
+      "## Application Guide\n\n#{content.strip}"
+    rescue => e
+      RailsConsoleAI.logger.debug("RailsConsoleAI: guide context failed: #{e.message}")
+      nil
+    end
+
+    def memory_context
+      return nil unless @config.memories_enabled
+
+      require 'rails_console_ai/tools/memory_tools'
+      summaries = Tools::MemoryTools.new.memory_summaries
+      return nil if summaries.nil? || summaries.empty?
+
+      lines = ["## Memories"]
+      lines.concat(summaries)
+      lines << ""
+      lines << "Call recall_memories to get details before answering. Do NOT guess from the name alone."
+      lines.join("\n")
+    rescue => e
+      RailsConsoleAI.logger.debug("RailsConsoleAI: memory context failed: #{e.message}")
+      nil
+    end
+
+  end
+end