rails_agent_console 0.1.0

data/lib/rails_agent_console/schema.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Schema
+    INTERNAL_PREFIXES = %w[
+      ActiveRecord:: ActiveStorage:: ActionText:: ActionMailbox::
+      SolidQueue:: SolidCache:: SolidCable:: Delayed:: PgSearch::
+    ].freeze
+
+    Model = Struct.new(:name, :table, :columns, :associations, :referenced_by, :abstract,
+                       keyword_init: true) do
+      def column_names
+        columns.map(&:first)
+      end
+
+      def association_names
+        associations.map { |association| association[:name].to_s }
+      end
+
+      def keywords
+        [name.downcase, *name.gsub(/([a-z])([A-Z])/, '\1 \2').downcase.split, table.to_s,
+         *column_names, *association_names].uniq
+      end
+
+      def to_context(columns: true)
+        lines = ["#{name} (#{table})"]
+        lines << "  columns: #{column_list}" if columns
+        associations.each { |association| lines << "  #{association_line(association)}" }
+        lines += inbound_lines.map { |line| "  #{line}" } if inbound.any?
+        lines.join("\n")
+      end
+
+      def inbound
+        Array(referenced_by)
+      end
+
+      def inbound_lines
+        ["#{missing_joins} all raise: no such association exists here.",
+         "query from the other side instead -- #{inbound_list} -- " \
+         "or filter with a subquery: #{subquery_example}"]
+      end
+
+      def missing_joins
+        inbound.map { |reference| "#{name}.joins(:#{reference[:table]})" }.join(" and ")
+      end
+
+      def inbound_list
+        inbound.map do |reference|
+          "#{reference[:model]}.joins(:#{reference[:association]}) (#{reference[:foreign_key]})"
+        end.join(", ")
+      end
+
+      def subquery_example
+        reference = inbound.first
+        "#{name}.where(id: #{reference[:model]}.select(:#{reference[:foreign_key]}))"
+      end
+
+      def column_list
+        columns.map { |name, type, extra| extra ? "#{name}:#{type} #{extra}" : "#{name}:#{type}" }.join(", ")
+      end
+
+      def association_line(association)
+        line = "#{association[:macro]} :#{association[:name]}"
+        line += " (#{association[:class_name]})" if association[:class_name] != default_class_name(association)
+        line += " through: :#{association[:through]}" if association[:through]
+        line
+      end
+
+      private
+
+      def default_class_name(association)
+        base = association[:name].to_s
+        base = base.sub(/s\z/, "") if %i[has_many has_and_belongs_to_many].include?(association[:macro])
+        base.split("_").map(&:capitalize).join
+      end
+    end
+
+    class << self
+      def models
+        @models ||= load_models
+      end
+
+      def model_names
+        models.map(&:name)
+      end
+
+      def find(name)
+        models.find { |model| model.name == name.to_s }
+      end
+
+      def reset!
+        @models = nil
+        self
+      end
+
+      def context(prompt = nil)
+        return "No ActiveRecord models found." if models.empty?
+
+        focused, rest = split_by_relevance(prompt)
+        sections = [header]
+        sections << focused.map(&:to_context).join("\n\n")
+        sections << "Other models: #{rest.map(&:name).sort.join(", ")}" if rest.any?
+        sections << RailsAgentConsole.configuration.extra_context if RailsAgentConsole.configuration.extra_context
+        sections.compact.join("\n\n")
+      end
+
+      def tree(names)
+        Array(names).flat_map do |name|
+          model = find(name)
+          next [] unless model
+
+          lines = [model.name]
+          model.associations.each_with_index do |association, index|
+            last = index == model.associations.size - 1
+            lines << " #{last ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500"} #{model.association_line(association)}"
+          end
+          lines
+        end
+      end
+
+      def inspect
+        context
+      end
+
+      def print(prompt = nil)
+        RailsAgentConsole.configuration.out.puts(context(prompt))
+        nil
+      end
+
+      private
+
+      def header
+        parts = []
+        parts << "Rails #{Rails.version}" if defined?(Rails) && Rails.respond_to?(:version)
+        parts << "adapter: #{adapter_name}" if adapter_name
+        parts.empty? ? "Application schema:" : parts.join(", ").to_s
+      end
+
+      def adapter_name
+        return unless active_record?
+
+        ActiveRecord::Base.connection_db_config.adapter
+      rescue StandardError
+        nil
+      end
+
+      def split_by_relevance(prompt)
+        config = RailsAgentConsole.configuration
+        all = models.first(config.max_models)
+        return [all, models.drop(config.max_models)] if prompt.nil? || all.size <= config.max_focused_models
+
+        scored = all.sort_by { |model| [-relevance(model, prompt), model.name] }
+        focused = scored.first(config.max_focused_models)
+        focused = focused.sort_by(&:name)
+        [focused, all - focused]
+      end
+
+      def relevance(model, prompt)
+        tokens = prompt.to_s.downcase.scan(/[a-z_]{3,}/).map { |token| token.sub(/(ies|es|s)\z/, "") }
+        return 0 if tokens.empty?
+
+        model.keywords.sum do |keyword|
+          stem = keyword.sub(/(ies|es|s)\z/, "")
+          tokens.count { |token| stem.include?(token) || token.include?(stem) }
+        end
+      end
+
+      def load_models
+        return [] unless active_record?
+
+        eager_load!
+        candidates = ActiveRecord::Base.descendants.reject do |klass|
+          klass.name.nil? || klass.abstract_class? || internal?(klass.name) || excluded?(klass.name)
+        end
+
+        described = candidates.uniq(&:name).sort_by(&:name).filter_map { |klass| describe(klass) }
+        link_inbound(described)
+      end
+
+      def link_inbound(described)
+        by_name = described.to_h { |model| [model.name, model] }
+
+        described.each do |model|
+          model.associations.select { |association| association[:macro] == :belongs_to }.each do |association|
+            target = by_name[association[:class_name]]
+            next if target.nil? || target.name == model.name
+            next if target.associations.any? { |inverse| inverse[:class_name] == model.name }
+
+            target.referenced_by << inbound_reference(model, association)
+          end
+        end
+
+        described
+      end
+
+      def inbound_reference(model, association)
+        { model: model.name, association: association[:name],
+          foreign_key: association[:foreign_key], table: model.table }
+      end
+
+      def describe(klass)
+        return unless klass.table_exists?
+
+        Model.new(
+          name: klass.name,
+          table: klass.table_name,
+          columns: columns_for(klass),
+          associations: associations_for(klass),
+          referenced_by: [],
+          abstract: false
+        )
+      rescue StandardError
+        nil
+      end
+
+      def columns_for(klass)
+        klass.columns.map do |column|
+          extra = []
+          extra << "pk" if column.name == klass.primary_key
+          extra << "null" if column.null && column.name != klass.primary_key
+          [column.name, column.type, extra.empty? ? nil : "(#{extra.join(",")})"]
+        end
+      end
+
+      def associations_for(klass)
+        klass.reflect_on_all_associations.map do |reflection|
+          {
+            macro: reflection.macro,
+            name: reflection.name,
+            class_name: safe_class_name(reflection),
+            foreign_key: safe_foreign_key(reflection),
+            through: reflection.options[:through]
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      def safe_class_name(reflection)
+        reflection.options[:class_name]&.to_s || reflection.class_name
+      rescue StandardError
+        nil
+      end
+
+      def safe_foreign_key(reflection)
+        reflection.foreign_key.to_s
+      rescue StandardError
+        nil
+      end
+
+      def internal?(name)
+        return false if RailsAgentConsole.configuration.include_internal_models
+
+        INTERNAL_PREFIXES.any? { |prefix| name.start_with?(prefix) }
+      end
+
+      def excluded?(name)
+        RailsAgentConsole.configuration.excluded_models.map(&:to_s).include?(name)
+      end
+
+      def eager_load!
+        return unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+        return if Rails.application.config.eager_load
+
+        Rails.application.eager_load!
+      rescue StandardError
+        nil
+      end
+
+      def active_record?
+        defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:descendants)
+      end
+    end
+  end
+end

data/lib/rails_agent_console/setup.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Setup
+    PROVIDER_LABELS = {
+      openai: "OpenAI",
+      anthropic: "Anthropic",
+      gemini: "Gemini",
+      ollama: "Ollama"
+    }.freeze
+
+    class << self
+      def interactive?(config = RailsAgentConsole.configuration)
+        input = config.in
+        input.respond_to?(:tty?) && input.tty?
+      end
+
+      def needed?(config = RailsAgentConsole.configuration)
+        !config.api_key?
+      end
+
+      def run(config: RailsAgentConsole.configuration, ui: UI.new(config))
+        ui.blank
+        ui.heading "Rails Agent Console"
+        ui.say "No AI provider configured yet. A few short questions; Enter takes the suggestion."
+        return false unless Wizard.run(config: config, ui: ui)
+
+        ui.success "Ready. Try: ai \"how many #{example_model.downcase} records do we have?\""
+        ui.blank
+        true
+      end
+
+      private
+
+      def example_model
+        Schema.model_names.first || "User"
+      end
+    end
+  end
+end

data/lib/rails_agent_console/ui.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  class UI
+    COLORS = {
+      black: 30, red: 31, green: 32, yellow: 33,
+      blue: 34, magenta: 35, cyan: 36, white: 37, gray: 90
+    }.freeze
+
+    ROBOT = "\u{1F916}"
+    WARNING = "\u26A0\uFE0F"
+    CHECK = "\u2713"
+    CROSS = "\u2717"
+
+    def initialize(config = RailsAgentConsole.configuration)
+      @config = config
+    end
+
+    def say(text = "")
+      out.puts(text)
+    end
+
+    def blank
+      out.puts
+    end
+
+    def heading(text)
+      say "#{ROBOT} #{bold(text)}"
+    end
+
+    def note(text)
+      say dim(text)
+    end
+
+    def success(text)
+      say "#{colorize(CHECK, :green)} #{text}"
+    end
+
+    def failure(text)
+      say "#{colorize(CROSS, :red)} #{text}"
+    end
+
+    def warn(text)
+      say "#{WARNING}  #{colorize(text, :yellow)}"
+    end
+
+    def code(source)
+      source.to_s.each_line do |line|
+        say "  #{colorize(line.chomp, :cyan)}"
+      end
+    end
+
+    def tree(lines)
+      lines.each { |line| say "  #{dim(line)}" }
+    end
+
+    def ask(question, default: nil)
+      out.print("#{question} ")
+      out.flush
+      answer = read_line
+      return default if answer.nil? || answer.strip.empty?
+
+      answer.strip
+    end
+
+    def yes?(question, default: false)
+      suffix = default ? "[Y/n]" : "[y/N]"
+      answer = ask("#{question} #{suffix}", default: nil)
+      return default if answer.nil?
+
+      case answer.downcase
+      when "y", "yes" then true
+      when "n", "no", "" then false
+      else default
+      end
+    end
+
+    def secret(question)
+      out.print("#{question} ")
+      out.flush
+      value = read_secret
+      out.puts
+      value.to_s.strip
+    end
+
+    def bold(text)
+      @config.color? ? "\e[1m#{text}\e[0m" : text.to_s
+    end
+
+    def dim(text)
+      @config.color? ? "\e[2m#{text}\e[0m" : text.to_s
+    end
+
+    def colorize(text, color)
+      return text.to_s unless @config.color?
+
+      "\e[#{COLORS.fetch(color, 37)}m#{text}\e[0m"
+    end
+
+    private
+
+    def out
+      @config.out
+    end
+
+    def read_line
+      @config.in.gets
+    end
+
+    def read_secret
+      input = @config.in
+      require "io/console"
+
+      return input.gets.to_s.chomp unless echo_controllable?(input)
+
+      input.noecho { input.gets.to_s.chomp }
+    rescue LoadError, Errno::ENOTTY, Errno::ENODEV
+      input.gets.to_s.chomp
+    end
+
+    def echo_controllable?(input)
+      input.respond_to?(:noecho) && input.respond_to?(:tty?) && input.tty?
+    end
+  end
+end

data/lib/rails_agent_console/value_check.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  # Spots a condition that compares a column with a value the column never holds,
+  # such as country: "Croatia" where the data says "HR". The values it lists are
+  # printed in the console only; nothing here is sent to the model.
+  module ValueCheck
+    MAX_DISTINCT = 30
+    SHOWN = 10
+    TEXT_TYPES = %i[string text citext].freeze
+
+    module_function
+
+    def notes(relation)
+      conditions(relation.where_clause.ast).uniq.filter_map { |table, column, value| note(table, column, value) }
+    rescue StandardError
+      []
+    end
+
+    def conditions(node)
+      case node
+      when Arel::Nodes::HomogeneousIn
+        pairs(node.attribute, node.values)
+      when Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::In, Arel::Nodes::NotIn
+        comparison(node)
+      when Arel::Nodes::Binary, Arel::Nodes::And, Arel::Nodes::Or, Arel::Nodes::Grouping, Arel::Nodes::Not
+        children(node).flat_map { |child| conditions(child) }
+      else
+        []
+      end
+    end
+
+    def children(node)
+      return node.children if node.respond_to?(:children)
+      return [node.expr] if node.respond_to?(:expr)
+
+      [node.left, node.right]
+    end
+
+    def comparison(node)
+      pairs(node.left, node.right)
+    end
+
+    def pairs(attribute, values)
+      return [] unless attribute.is_a?(Arel::Attributes::Attribute)
+
+      Array(values).filter_map { |value| literal(value) }
+                   .map { |value| [attribute.relation.name.to_s, attribute.name.to_s, value] }
+    end
+
+    def literal(node)
+      value = node.respond_to?(:value) ? node.value : node
+      value = value.value_before_type_cast if value.respond_to?(:value_before_type_cast)
+      value if value.is_a?(String) && !value.empty?
+    end
+
+    def note(table, column, value)
+      klass = model_for(table, column)
+      return if klass.nil?
+
+      counts = klass.unscoped.where.not(column => nil).group(column).order(Arel.sql("COUNT(*) DESC"))
+                    .limit(MAX_DISTINCT + 1).count
+      return if counts.size > MAX_DISTINCT || counts.key?(value)
+
+      "#{table}.#{column} never holds #{value.inspect}. #{listing(counts.keys, value)}"
+    end
+
+    def listing(values, wanted)
+      close = values.find { |candidate| candidate.to_s.casecmp?(wanted) }
+      return "It holds #{close.inspect}, with different capitals." if close
+
+      shown = values.first(SHOWN).join(", ")
+      more = values.size > SHOWN ? " (+#{values.size - SHOWN} more)" : ""
+      "The values it holds are: #{shown}#{more}."
+    end
+
+    def model_for(table, column)
+      model = Schema.models.find { |candidate| candidate.table == table }
+      return if model.nil?
+
+      type = model.columns.find { |name, _| name == column }&.dig(1)
+      Object.const_get(model.name) if TEXT_TYPES.include?(type)
+    end
+  end
+end

data/lib/rails_agent_console/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  VERSION = "0.1.0"
+end