rails_agent_console 0.1.0

data/lib/rails_agent_console/credentials.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module RailsAgentConsole
+  # ~/.rails_agent_console/config (0600, inside a 0700 directory):
+  #
+  #     default_provider: openai
+  #     openai:
+  #       api_key: sk-...
+  #       model: gpt-4o-mini
+  module Credentials
+    DIRECTORY = File.join(Dir.home, ".rails_agent_console")
+    PATH = File.join(DIRECTORY, "config")
+
+    class << self
+      def path
+        ENV.fetch("RAILS_AGENT_CONSOLE_CONFIG", PATH)
+      end
+
+      def exist?
+        File.exist?(path)
+      end
+
+      def read
+        return {} unless exist?
+
+        data = YAML.safe_load_file(path) || {}
+        data.is_a?(Hash) ? data : {}
+      rescue StandardError
+        {}
+      end
+
+      def store(provider:, api_key: nil, model: nil, base_url: :keep)
+        data = read
+        data["default_provider"] = provider.to_s
+        entry = data[provider.to_s].is_a?(Hash) ? data[provider.to_s] : {}
+        entry["api_key"] = api_key if api_key
+        entry["model"] = model if model
+        store_base_url(entry, base_url)
+        data[provider.to_s] = entry
+        write(data)
+      end
+
+      def store_base_url(entry, base_url)
+        return if base_url == :keep
+
+        base_url.to_s.strip.empty? ? entry.delete("base_url") : entry["base_url"] = base_url
+      end
+
+      def write(data)
+        directory = File.dirname(path)
+        FileUtils.mkdir_p(directory)
+        File.chmod(0o700, directory) if File.owned?(directory) && directory == DIRECTORY
+        File.write(path, YAML.dump(data))
+        File.chmod(0o600, path)
+        path
+      end
+
+      def delete!
+        FileUtils.rm_f(path)
+      end
+    end
+  end
+end

data/lib/rails_agent_console/diagnosis/extra.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Diagnosis
+    module Extra
+      QUALIFIED_MISSING = /column (\w+)\.(\w+) does not exist/
+      BARE_MISSING = /column "(\w+)" does not exist/
+      FIND_BY_NAME = /Couldn't find (\w+) with '(\w+)'=([a-z_]\w*)\b/
+      WINDOW_IN_AGGREGATE = /aggregate function calls cannot contain window function calls/
+
+      module_function
+
+      def hint(code, message)
+        missing_column_hint(code, message) || find_hint(message) || window_hint(message)
+      end
+
+      def missing_column_hint(code, message)
+        table, column = message.match(QUALIFIED_MISSING)&.captures
+        column ||= message[BARE_MISSING, 1]
+        model = table ? Schema.models.find { |candidate| candidate.table == table } : receiver(code)
+        return unless column && model
+
+        "#{model.table} has no #{column} column. Its columns are " \
+          "#{model.column_names.first(30).join(", ")}; use one of them or leave the code empty."
+      end
+
+      def shared_column(owner, name)
+        source = Schema.find(owner)
+        target = Schema.models.find { |model| [name, name.pluralize].include?(model.table) }
+        return unless source && target
+        return if source.inbound.any? { |reference| reference[:table] == target.table }
+
+        pair = matching_columns(source, target)
+        return unless pair
+
+        "#{source.name} and #{target.name} are not associated, but both hold #{pair.last}: " \
+          "#{source.name}.where(#{pair.first}: #{target.name}.select(:#{pair.last}))."
+      end
+
+      def matching_columns(source, target)
+        ignored = %w[id created_at updated_at]
+        source.column_names.product(target.column_names).find do |left, right|
+          next false if ignored.include?(left) || ignored.include?(right)
+
+          left == right || left.end_with?("_#{right}") || right.end_with?("_#{left}")
+        end
+      end
+
+      def receiver(code)
+        Schema.find(code.to_s[/\A\s*([A-Z]\w*(?:::[A-Z]\w*)*)/, 1].to_s)
+      end
+
+      def find_hint(message)
+        model, key, value = message.match(FIND_BY_NAME)&.captures
+        return unless model
+
+        "find(:#{value}) looks up the literal value #{value.inspect} in #{model}.#{key}. Comparing " \
+          "with a column of another table needs a join and SQL, such as " \
+          "joins(:association).where(\"table_a.column <> table_b.column\")."
+      end
+
+      def window_hint(message)
+        return unless WINDOW_IN_AGGREGATE.match?(message)
+
+        "A window function (LAG, ROW_NUMBER) cannot sit inside an aggregate. Compute it in a " \
+          "subquery and aggregate the outer query: " \
+          "Model.from(Model.select(\"model_table.*, LAG(created_at) OVER (PARTITION BY customer_id " \
+          "ORDER BY created_at) AS previous_at\"), :model_table).average(...)."
+      end
+    end
+  end
+end

data/lib/rails_agent_console/diagnosis.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Diagnosis
+    MISSING_COLUMN = /column "([^"]+)" does not exist/
+    NESTED_AGGREGATE = /aggregate function calls cannot be nested/
+    MISSING_GROUP = /column "([^"]+)" must appear in the GROUP BY clause/
+    MISSING_ASSOCIATION = /Can't join '([^']+)' to association named '([^']+)'/
+    MISSING_TABLE = /missing FROM-clause entry for table "([^"]+)"/
+    ALIAS_IN_CLAUSE = /syntax error at or near "AS"/
+    HASH_CHAIN = /undefined method [`']([^`']+)['`] for .*Hash/m
+    NOT_A_TIME = /invalid input syntax for type (timestamp|date)[^:]*: "([^"]*)"/
+    TYPE_MISMATCH = /operator does not exist: (\w[\w ]*) = (\w[\w ]*)/
+
+    class << self
+      def hint(code, message)
+        text = message.to_s
+        alias_hint(code, text) || nested_aggregate_hint(text) || group_by_hint(text) ||
+          association_hint(text) || missing_table_hint(text) || type_mismatch_hint(text) ||
+          alias_in_clause_hint(text) || hash_chain_hint(text) || not_a_time_hint(text) ||
+          Extra.hint(code, text)
+      end
+
+      private
+
+      def alias_hint(code, message)
+        name = message[MISSING_COLUMN, 1]
+        return unless name && aliased?(code, name)
+
+        "`#{name}` is an alias from select(...). SQL cannot see it anywhere else in the " \
+          "same query, so repeat the expression instead of naming the alias."
+      end
+
+      def aliased?(code, name)
+        code.to_s.match?(/\bAS\s+"?#{Regexp.escape(name)}"?\b/i)
+      end
+
+      def nested_aggregate_hint(message)
+        return unless NESTED_AGGREGATE.match?(message)
+
+        "One aggregate cannot wrap another. Divide two separate aggregates instead, " \
+          "such as Model.count.to_f / Model.distinct.count(:customer_id)."
+      end
+
+      def group_by_hint(message)
+        name = message[MISSING_GROUP, 1]
+        return unless name
+
+        "Every column that is selected has to be either grouped by or wrapped in an " \
+          "aggregate. Group by `#{name}` as well, or leave it out of the select."
+      end
+
+      def association_hint(message)
+        match = MISSING_ASSOCIATION.match(message)
+        return unless match
+
+        owner, name = match.captures
+        return column_hint(owner, name) if column?(owner, name)
+
+        ["There is no `#{name}` association on #{owner}, and there never will be: nothing",
+         "declares it. #{ways_around(owner, name)}"].join(" ")
+      end
+
+      def column_hint(owner, name)
+        "`#{name}` is a column on #{owner}, not an association. Read it or filter on it " \
+          "directly -- #{owner}.where(#{name}: nil) -- with no join at all."
+      end
+
+      def column?(owner, name)
+        Schema.find(owner)&.column_names&.include?(name.to_s) || false
+      rescue StandardError
+        false
+      end
+
+      def not_a_time_hint(message)
+        type, value = NOT_A_TIME.match(message)&.captures
+        return unless type
+
+        "A #{type} column was compared with #{value.inspect}, which is not a #{type}. A condition " \
+          "on part of a date is evaluated per row in SQL: " \
+          "where(\"EXTRACT(DOW FROM created_at) IN (0, 6)\") for weekends, EXTRACT(HOUR FROM ...) for hours."
+      end
+
+      def hash_chain_hint(message)
+        name = message[HASH_CHAIN, 1]
+        return unless name
+
+        "count, sum and average on a grouped relation return a Hash of results, so `#{name}` " \
+          "has nothing to act on. Chain everything onto the relation first and aggregate last: " \
+          "group(:source).order(Arel.sql(\"AVG(LENGTH(query)) DESC\")).average(Arel.sql(\"LENGTH(query)\"))."
+      end
+
+      def ways_around(owner, name)
+        shared = Extra.shared_column(owner, name)
+        return shared if shared
+
+        other = referring_model(owner, name)
+        return "Answer it from the model that declares the belongs_to instead." unless other
+
+        "Either start from #{other[:model]} and join back -- " \
+          "#{other[:model]}.joins(:#{other[:association]}) -- or keep #{owner} as the subject and " \
+          "filter with a subquery: #{owner}.where(id: #{other[:model]}.select(:#{other[:foreign_key]})), " \
+          "or where.not for the ones without."
+      end
+
+      def referring_model(owner, name)
+        inbound = Schema.find(owner)&.inbound
+        return if inbound.nil? || inbound.empty?
+
+        inbound.find { |reference| same_model?(reference[:model], name) } || inbound.first
+      rescue StandardError
+        nil
+      end
+
+      def missing_table_hint(message)
+        table = message[MISSING_TABLE, 1]
+        return unless table
+
+        "The query reads columns from `#{table}` without that table being in the query. " \
+          "Move the condition into a subquery on #{table} -- counting rows per owner is " \
+          "where(id: Other.group(:owner_id).having(Arel.sql(\"COUNT(*) > 10\")).select(:owner_id)) -- " \
+          "or drop it: the column you want may well be on the table you already select from."
+      end
+
+      def alias_in_clause_hint(message)
+        return unless ALIAS_IN_CLAUSE.match?(message)
+
+        "Only a select list may name an alias with AS. Pass group(...) and order(...) the " \
+          "expression itself, as a separate argument per column: " \
+          "group(Arel.sql(\"EXTRACT(YEAR FROM created_at)\"), :source).count."
+      end
+
+      def type_mismatch_hint(message)
+        left, right = TYPE_MISMATCH.match(message)&.captures
+        return unless left
+
+        "A #{left.strip} column is being compared with a #{right.strip} one, which is what " \
+          "where(id: Model.select(:some_string)) does. Compare columns that hold the same kind " \
+          "of value: if one table refers to another by email rather than by id, join the emails."
+      end
+
+      def same_model?(model, name)
+        model.to_s.split("::").last.downcase == name.to_s.delete("_").sub(/s\z/, "")
+      end
+    end
+  end
+end
+
+require_relative "diagnosis/extra"

data/lib/rails_agent_console/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class InvalidResponseError < Error; end
+
+  class ProviderError < Error; end
+
+  class UnsafeCodeError < Error
+    attr_reader :violations
+
+    def initialize(message, violations: [])
+      super(message)
+      @violations = violations
+    end
+  end
+end

data/lib/rails_agent_console/executor.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module RailsAgentConsole
+  module Executor
+    AGGREGATES = %w[count sum average minimum maximum size length pluck ids exists? any? empty? tally].freeze
+    DESTRUCTIVE_TAIL = /\.\s*(delete_all|destroy_all|update_all|delete|destroy)\s*(\([^()]*\))?\s*\z/m
+    ASSIGNMENT = /(?<![=!<>])=(?![=~>])/
+    NO_AGGREGATE_NOTE = "The query had no aggregate after `group`, so the groups were counted."
+    GROUPED_ROWS_NOTE = "Grouped rows have no id, so each one is shown as its selected values."
+    COMPUTED_NOTE = "The rows carry computed columns a record would hide, so each one is shown as its values."
+
+    Outcome = Struct.new(:value, :error, :duration, :note, keyword_init: true) do
+      def ok?
+        error.nil?
+      end
+    end
+
+    class << self
+      def run(code)
+        started = now
+        raw = with_timeout { evaluate(code) }
+        value, note = resolve(raw)
+        duration = now - started
+        notes = [note, *value_notes(code, raw)].compact
+        Outcome.new(value: value, error: nil, duration: duration, note: notes.empty? ? nil : notes.join("\n"))
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        Outcome.new(value: nil, error: e, duration: now - started)
+      end
+
+      def preflight_count(code)
+        return unless RailsAgentConsole.configuration.preflight_count
+        return if aggregate?(code)
+
+        count_rows(code)
+      end
+
+      def impact_estimate(code)
+        stripped = code.sub(DESTRUCTIVE_TAIL, "")
+        return if stripped == code || stripped.strip.empty?
+
+        count_rows(stripped)
+      end
+
+      def describe(value)
+        limit = RailsAgentConsole.configuration.inspect_limit
+
+        case value
+        when ->(v) { relation?(v) } then describe_relation(value)
+        when Array then pluralize(value.size, "item")
+        when Hash then pluralize(value.size, "group")
+        when nil then "nil"
+        else truncate(value.inspect, limit * 20)
+        end
+      rescue StandardError
+        value.class.name.to_s
+      end
+
+      def relation?(value)
+        defined?(ActiveRecord::Relation) && value.is_a?(ActiveRecord::Relation)
+      end
+
+      def sandbox_binding
+        @sandbox_binding ||= Object.new.instance_eval { binding }
+      end
+
+      def reset!
+        @sandbox_binding = nil
+      end
+
+      private
+
+      def count_rows(code)
+        counting = "(#{code}).count(:all)"
+        return unless QueryValidator.validate(counting, write_mode: false).valid?
+
+        value = with_timeout { evaluate(counting) }
+        value if value.is_a?(Integer)
+      rescue Exception # rubocop:disable Lint/RescueException
+        nil
+      end
+
+      def resolve(value)
+        return [readable_keys(value), nil] if value.is_a?(Hash)
+        return [value, nil] unless relation?(value) && !value.loaded?
+        return [readable_keys(value.count), NO_AGGREGATE_NOTE] if bare_group?(value)
+        return [value.load, nil] unless grouped_select?(value)
+
+        rows = value.to_a
+        return [value, nil] if rows.empty?
+        return [rows.map { |row| grouped_row(row) }, GROUPED_ROWS_NOTE] if rows.all? { |row| row.id.nil? }
+        return [rows.map { |row| grouped_row(row) }, COMPUTED_NOTE] if computed_columns?(value, rows)
+
+        [value, nil]
+      end
+
+      def computed_columns?(relation, rows)
+        (rows.first.attributes.keys - relation.klass.column_names).any?
+      end
+
+      def value_notes(code, raw)
+        relation = raw if relation?(raw)
+        base = Prompt::FollowUp.base_of(code)
+        relation ||= evaluate(base) if base && base != code.strip && !assigns?(code)
+        relation?(relation) ? ValueCheck.notes(relation) : []
+      rescue StandardError
+        []
+      end
+
+      def assigns?(code)
+        code.gsub(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/, "''").match?(ASSIGNMENT)
+      end
+
+      def grouped_row(row)
+        row.attributes.compact.transform_values do |value|
+          value.is_a?(BigDecimal) && !value.frac.zero? ? value.to_f : whole(value)
+        end
+      end
+
+      def readable_keys(hash)
+        return hash unless hash.keys.flatten.any?(BigDecimal)
+
+        hash.transform_keys { |key| key.is_a?(Array) ? key.map { |part| whole(part) } : whole(key) }
+      end
+
+      def whole(value)
+        value.is_a?(BigDecimal) && value.frac.zero? ? value.to_i : value
+      end
+
+      def bare_group?(value)
+        value.group_values.any? && value.select_values.empty?
+      end
+
+      def grouped_select?(value)
+        value.group_values.any? && value.select_values.any?
+      end
+
+      def describe_relation(relation)
+        size = relation.size
+        size.is_a?(Hash) ? pluralize(size.size, "group") : pluralize(size, "record")
+      end
+
+      def evaluate(code)
+        eval(code, sandbox_binding, "(rails-agent)", 1) # rubocop:disable Security/Eval
+      end
+
+      def aggregate?(code)
+        AGGREGATES.include?(trailing_method(code).to_s)
+      end
+
+      def trailing_method(code)
+        source = code.strip
+        source = strip_trailing_arguments(source) if source.end_with?(")")
+        source[/([a-z_]\w*[?!]?)\s*\z/, 1]
+      end
+
+      def strip_trailing_arguments(source)
+        depth = 0
+        source.length.downto(1) do |index|
+          case source[index - 1]
+          when ")" then depth += 1
+          when "(" then depth -= 1
+          end
+          return source[0, index - 1] if depth.zero?
+        end
+        source
+      end
+
+      def with_timeout(&block)
+        seconds = RailsAgentConsole.configuration.execution_timeout
+        return block.call if seconds.nil? || seconds.to_i <= 0
+
+        Timeout.timeout(seconds.to_i, &block)
+      end
+
+      def pluralize(count, noun)
+        "#{count} #{count == 1 ? noun : "#{noun}s"}"
+      end
+
+      def truncate(string, length)
+        string.length > length ? "#{string[0, length]}..." : string
+      end
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/rails_agent_console/history.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsAgentConsole
+  class History
+    Turn = Struct.new(:prompt, :code, :explanation, :outcome, keyword_init: true)
+
+    def initialize(limit: nil)
+      @limit = limit
+      @turns = []
+    end
+
+    def limit
+      @limit || RailsAgentConsole.configuration.max_history
+    end
+
+    def add(prompt:, code:, explanation: nil, outcome: nil)
+      @turns << Turn.new(prompt: prompt, code: code, explanation: explanation, outcome: outcome)
+      @turns.shift while @turns.size > limit
+      self
+    end
+
+    def turns
+      @turns.dup
+    end
+
+    def last
+      @turns.last
+    end
+
+    def empty?
+      @turns.empty?
+    end
+
+    def clear
+      @turns.clear
+      self
+    end
+
+    def messages
+      @turns.flat_map do |turn|
+        [
+          { role: "user", content: turn.prompt },
+          { role: "assistant", content: assistant_content(turn) }
+        ]
+      end
+    end
+
+    def to_s
+      return "(no queries yet)" if empty?
+
+      @turns.map.with_index(1) { |turn, i| "#{i}. #{turn.prompt}\n   #{turn.code}" }.join("\n")
+    end
+
+    private
+
+    def assistant_content(turn)
+      payload = { "code" => turn.code }
+      payload["explanation"] = turn.explanation if turn.explanation
+      payload["result"] = turn.outcome if turn.outcome
+      JSON.generate(payload)
+    end
+  end
+end