rails_agent_console 0.1.0

data/lib/rails_agent_console/model_picker.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  # Usage:
+  #   ai_model                             # what is in use, then a guided change
+  #   ai_model "gpt-4o"                    # the provider follows from the name
+  #   ai_model "ollama/qwen2.5-coder:7b"   # a provider, and its model
+  module ModelPicker
+    class << self
+      def run(target = nil, config: RailsAgentConsole.configuration, ui: UI.new(config))
+        return switch(target, config: config, ui: ui) unless target.nil?
+
+        report(config, ui)
+        return unless Setup.interactive?(config)
+        return unless ui.yes?("Change provider, base URL or model?", default: false)
+
+        Wizard.run(config: config, ui: ui)
+        nil
+      end
+
+      private
+
+      def switch(target, config:, ui:)
+        choice = parse(target, config)
+        return unknown(target, ui) if choice.nil?
+
+        before = config.snapshot
+        apply(choice, config)
+        unless ollama_has_model?(config, ui)
+          config.restore(before)
+          return
+        end
+
+        typed = config.api_key? ? nil : read_key(config, ui)
+        return refuse_without_key(before, config, ui) unless config.api_key?
+
+        RailsAgentConsole.agent.reset_provider!
+        ui.success "Now using #{label(config)}."
+        remember(config, ui, typed)
+        nil
+      end
+
+      def apply(choice, config)
+        if choice[:provider] != config.provider
+          config.provider = choice[:provider]
+          config.api_base = nil
+        end
+        config.model = choice[:model] || stored_model(config.provider) ||
+                       Configuration::DEFAULT_MODELS[config.provider]
+      end
+
+      def parse(target, config)
+        text = target.to_s.strip
+        return if text.empty?
+
+        provider, model = text.split("/", 2)
+        return { provider: provider.to_sym, model: model } if known?(provider) && !model.to_s.empty?
+        return { provider: provider.to_sym, model: nil } if known?(provider) && model.nil?
+        return if text.include?("/")
+
+        { provider: Configuration.provider_for(text) || config.provider, model: text }
+      end
+
+      def known?(name)
+        Configuration::PROVIDERS.include?(name.to_s.to_sym)
+      end
+
+      def unknown(target, ui)
+        ui.failure "#{target.inspect} names no provider. Known: #{Configuration::PROVIDERS.join(", ")}."
+        nil
+      end
+
+      def ollama_has_model?(config, ui)
+        return true unless config.provider == :ollama
+
+        installed = Providers::Ollama.new(config).installed_models
+        if installed.empty?
+          ui.warn "Ollama did not list any models on #{config.api_base || Providers::Ollama::DEFAULT_BASE}. " \
+                  "Start it with `ollama serve`, and get a model with `ollama pull #{config.model}`."
+          return true
+        end
+        return true if installed.include?(config.model) || installed.include?("#{config.model}:latest")
+
+        ui.failure "#{config.model} is not installed in Ollama. Installed: #{installed.join(", ")}."
+        ui.note "  Get it with `ollama pull #{config.model}`, or pick one of those with ai_model \"ollama/NAME\"."
+        false
+      end
+
+      def read_key(config, ui)
+        return unless Setup.interactive?(config)
+
+        env = Configuration::ENV_KEYS[config.provider]
+        ui.note "  #{Setup::PROVIDER_LABELS[config.provider]} needs an API key. It is read from #{env}; " \
+                "or type it here, it will not be shown."
+        key = ui.secret("#{config.provider} API key:")
+        return if key.empty?
+
+        config.api_key = key
+      end
+
+      def refuse_without_key(before, config, ui)
+        provider = config.provider
+        config.restore(before)
+        how = Setup.interactive?(config) ? "none was typed" : "run ai_model in a terminal to type one"
+        ui.failure "No key for #{provider} (set #{Configuration::ENV_KEYS[provider]}, or #{how}), " \
+                   "so this stays on #{label(config)}."
+        nil
+      end
+
+      def remember(config, ui, typed_key)
+        return unless Setup.interactive?(config)
+        return unless ui.yes?("Make #{label(config)} the default in #{Credentials.path}?", default: false)
+
+        Credentials.store(provider: config.provider, api_key: typed_key, model: config.model)
+        ui.success "Saved."
+      rescue StandardError => e
+        ui.failure "Could not write #{Credentials.path}: #{e.message}"
+      end
+
+      def stored_model(provider)
+        Credentials.read.dig(provider.to_s, "model")
+      end
+
+      def report(config, ui)
+        ui.blank
+        ui.say "#{ui.bold(label(config))}  |  #{where(config.provider, config)}"
+        ui.blank
+        Configuration::PROVIDERS.each { |name| ui.say "  #{row(name, config)}" }
+        ui.blank
+        ui.note '  ai_model "gpt-4o"                   any model; the provider follows from the name'
+        ui.note '  ai_model "ollama/qwen2.5-coder:7b"  a provider, and its model'
+        ui.blank
+      end
+
+      def row(name, config)
+        current = name == config.provider
+        model = current ? config.model : stored_model(name) || Configuration::DEFAULT_MODELS[name]
+        "#{current ? "*" : " "} #{name.to_s.ljust(10)} #{model.to_s.ljust(26)} #{where(name, config)}"
+      end
+
+      def where(name, config)
+        base = name == config.provider ? config.api_base : Credentials.read.dig(name.to_s, "base_url")
+        note = key_note(name, config, base)
+        base && name != :ollama ? "#{note}, via #{base}" : note
+      end
+
+      def key_note(name, config, base)
+        return "runs locally, needs Ollama on #{base || Providers::Ollama::DEFAULT_BASE}" if name == :ollama
+
+        env = Configuration::ENV_KEYS[name]
+        return "key from #{env}" unless ENV.fetch(env, "").strip.empty?
+        return "key from #{Credentials.path}" if stored_key?(name)
+
+        config.client ? "unused: config.client answers instead" : "no key (set #{env})"
+      end
+
+      def stored_key?(name)
+        !Credentials.read.dig(name.to_s, "api_key").to_s.strip.empty?
+      end
+
+      def label(config)
+        "#{config.provider}/#{config.model}"
+      end
+    end
+  end
+end

data/lib/rails_agent_console/prompt/dates.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Prompt
+    module Dates
+      MONTHS = %w[january february march april may june july august september october november december].freeze
+      MONTH_YEAR = /\b(#{MONTHS.join("|")})\s+((?:19|20)\d{2})\b/i
+      YEAR = %r{(?<![\d./-])((?:19|20)\d{2})(?![\d./-])}
+
+      module_function
+
+      def annotate(prompt)
+        ranges = month_ranges(prompt) + year_ranges(prompt)
+        return prompt if ranges.empty?
+
+        "#{prompt}\n\nDates in this request, as ranges to filter on: #{ranges.join("; ")}."
+      end
+
+      def month_ranges(prompt)
+        prompt.scan(MONTH_YEAR).map do |month, year|
+          number = MONTHS.index(month.downcase) + 1
+          %(#{month.capitalize} #{year} is Time.zone.parse("#{year}-#{format("%02d", number)}-01").all_month)
+        end.uniq
+      end
+
+      def year_ranges(prompt)
+        within_months = prompt.scan(MONTH_YEAR).map(&:last)
+        (prompt.scan(YEAR).flatten.uniq - within_months).map do |year|
+          %(#{year} is Time.zone.parse("#{year}-01-01").all_year)
+        end
+      end
+    end
+  end
+end

data/lib/rails_agent_console/prompt/follow_up.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Prompt
+    module FollowUp
+      BACK_REFERENCE = /\b(them|those|these|they|their|the same|ih|njih|njima|njihov\w*|tih|isto)\b/i
+      EARLIER_QUERY = /\b(quer(y|ies)|that|this|last|previous|earlier|you gave|upit\w*|prethodn\w*|zadnj\w*)\b/i
+      ASKED_ABOUT = 3
+      TERMINALS = %w[count size length sum average minimum maximum pluck ids first last exists? any? to_a].freeze
+      TERMINAL = /\.\s*(#{Regexp.union(TERMINALS).source})(?<args>\((?:[^()]|\g<args>)*\))?\s*\z/m
+
+      module_function
+
+      def annotate(prompt, previous_code)
+        base = base_of(previous_code)
+        return prompt if base.nil? || !prompt.match?(BACK_REFERENCE)
+
+        "#{prompt}\n\nThis continues the previous query. Keep its conditions and build on: #{base}"
+      end
+
+      def for_ask(question, history)
+        return question if history.empty?
+        return question unless question.match?(BACK_REFERENCE) || question.match?(EARLIER_QUERY)
+
+        recent = history.turns.last(ASKED_ABOUT).map { |turn| "- #{turn.prompt}\n  #{turn.code}" }
+        "#{question}\n\nQueries run earlier in this console session, oldest first:\n#{recent.join("\n")}"
+      end
+
+      def base_of(code)
+        base = code.to_s.strip
+        return if base.empty?
+
+        base = base.sub(TERMINAL, "") while base.match?(TERMINAL)
+        base unless base.empty?
+      end
+    end
+  end
+end

data/lib/rails_agent_console/prompt.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Prompt
+    QUERY_RULES = <<~RULES
+      You translate requests into ActiveRecord code for the application described below.
+
+      Answer with a single JSON object and nothing else:
+      {"code": "<ruby expression>", "explanation": "<1-2 sentences>", "assumptions": ["<optional>"]}
+
+      Hard rules for "code":
+      - Exactly one Ruby expression. Chaining across several lines is fine, `;` and multiple statements are not.
+      - No assignments, no `puts`, no comments, no markdown fences.
+      - Only use models, columns and associations that appear in the schema below. Never invent a column.
+      - Associations are not symmetrical: a model listed as "referenced by" has no inverse association,
+        so start the query from the model that owns the belongs_to and reach across it.
+      - Aggregate in the database (count/sum/average/group/pluck) instead of loading records into Ruby.
+      - Wrap raw SQL fragments passed to order/group/select in Arel.sql("...").
+        Quote them with double quotes, so the single quotes SQL needs around its own
+        literals do not end the Ruby string: Arel.sql("SUM(CASE WHEN status = 'cancelled' THEN 1 ELSE 0 END)").
+      - A column name is never a Ruby value: comparing two columns happens inside the SQL string,
+        as in where("email LIKE '%' || city || '%'"). Written as "%" || city in Ruby it silently
+        becomes "%", and the query answers with every row in the table.
+      - SQL cannot nest one aggregate inside another, so there is no average of a count.
+        Divide two aggregates instead: SearchResult.count.to_f / SearchResult.distinct.count(:customer_id).
+      - "show", "list", "display" and "find" ask for the records themselves, so return the relation
+        on its own: the console prints it, so it needs no .load, .to_a or trailing .all.
+        Reach for count, sum or average only when the request asks how many, or for a total.
+      - Return whole records. Only add select(...) when the request names the columns it wants,
+        because a partial select raises ActiveRecord::MissingAttributeError on every other attribute.
+      - Always finish a group with an aggregate: count, sum, average, minimum, maximum or pluck.
+        A bare Model.group(:city) relation cannot even be printed, so it is never the answer.
+      - To count rows per related record, group by the column you want to read back and count from the
+        model that owns the rows: SearchResult.joins(:brand).group("brands.name").count.
+        Never call count on a relation that uses select(...), and never group by :id plus select(...):
+        both end up as COUNT(id, name), which is not a function, or as an ambiguous column.
+      - group(...) and order(...) take expressions, never aliases, and no AS: one argument per
+        column, as in SearchResult.group(Arel.sql("EXTRACT(YEAR FROM created_at)"), :source).count.
+      - To sort grouped counts, order by the aggregate itself: Model.group(:city).order(Arel.sql("COUNT(*) DESC")).limit(5).count.
+        There is no count_id, count_all or counter column to order by.
+      - Use Time.current, Date.current and ActiveSupport durations (30.days.ago, 1.month.ago) instead of Time.now.
+      - Beginless/endless ranges are preferred for date filters: where(created_at: 30.days.ago..).
+      - When the request refers to "them", "those" or "that", continue from the previous query in this conversation.
+      - An empty "code" is the honest answer when the request needs a write, or when the schema really
+        has nothing to answer it with. Say why in "explanation", and name the column you looked for.
+        Never stand in for an empty answer with Model.none, {} or [], and never invent a column.
+      - Reach that conclusion last, though, and only after reading every column above it. A request
+        rarely uses the same words as the schema does: "in 2025" is created_at, a "failure" is an error
+        column being present, and the column that answers the request is often named something else
+        entirely. Almost every request about this application can be answered from these tables.
+      - An alias from select(...) exists only in the rows that come back. Nothing else in the query
+        can see it: not a block, not where, not group, not pluck, not another expression in the same
+        select. Repeat the expression instead, and compute ratios with SQL inside the aggregate.
+    RULES
+
+    READ_ONLY_RULES = <<~RULES
+      This console runs in READ-ONLY mode. The generated code is rejected by a static
+      validator unless every call is read-only, so never use create, save, update,
+      update_all, delete, delete_all, destroy, destroy_all, insert_all, upsert,
+      transaction, connection.execute, send, eval or shell commands.
+
+      Reading is never a write. Returning records, a relation, a count or a group is
+      exactly what this mode is for, so a request to show, list or display records is
+      always answerable: read-only is never the reason to refuse one.
+    RULES
+
+    WRITE_RULES = <<~RULES
+      This console runs in WRITE mode: data-changing code is allowed, but the human
+      has to confirm it. Keep the change as narrow as possible, always scope writes
+      with an explicit `where`, and never use connection.execute, send, eval or shell
+      commands.
+    RULES
+
+    EXPLAIN_RULES = <<~RULES
+      You are a senior Rails engineer answering a question in a teammate's console.
+      Explain clearly and concretely, in plain prose with short code snippets where
+      they help. Reference the real models, columns and associations from the schema
+      below. Mention the SQL that ActiveRecord would generate when it is relevant,
+      and call out N+1 queries, missing indexes or loaded-vs-lazy relations when you
+      see them. Do not ask the user to run anything destructive. Keep it under 200 words
+      unless the question really needs more.
+    RULES
+
+    class << self
+      def query_system(prompt, write_mode: false)
+        [
+          QUERY_RULES,
+          write_mode ? WRITE_RULES : READ_ONLY_RULES,
+          "# Application",
+          Schema.context(prompt)
+        ].join("\n")
+      end
+
+      def explain_system(prompt)
+        [EXPLAIN_RULES, "# Application", Schema.context(prompt)].join("\n")
+      end
+
+      def repair_user(prompt, attempts)
+        lines = ["These queries were tried for this request and did not work:"]
+        Array(attempts).each { |attempt| lines += ["", attempt[:code].to_s, attempt[:reason].to_s] }
+
+        (lines + [
+          "",
+          "Answer with a corrected query for the original request: #{prompt}",
+          "Do not propose any of the queries above again, and do not guess: check the schema first.",
+          "If an error names an association, that association does not exist on that model. " \
+          "Start from the model whose belongs_to points at it, as the schema spells out.",
+          "If the request cannot be answered from this schema, answer with an empty code."
+        ]).join("\n")
+      end
+
+      def explain_code_user(code, question)
+        parts = ["Explain this ActiveRecord code:", "", code.to_s]
+        parts += ["", "The specific question is: #{question}"] if question
+        parts.join("\n")
+      end
+    end
+  end
+end
+
+require_relative "prompt/dates"
+require_relative "prompt/follow_up"

data/lib/rails_agent_console/proposal.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsAgentConsole
+  class Proposal
+    attr_reader :code, :explanation, :assumptions, :raw, :validation, :corrections
+
+    def self.parse(raw, write_mode: false)
+      payload = extract_json(raw) || { "code" => extract_code_block(raw) }
+      code = payload["code"].to_s.strip
+
+      new(
+        code: code,
+        explanation: payload["explanation"],
+        assumptions: Array(payload["assumptions"]),
+        raw: raw,
+        write_mode: write_mode
+      )
+    end
+
+    NO_OP_TAIL = /\.\s*(?:load|all)\s*\z/
+
+    BARE_COUNT_TAIL = /\.\s*count\s*(?:\(\s*\))?\s*\z/
+
+    FENCED = /\A```[a-zA-Z]*[ \t]*\r?\n?(.*?)```\z/m
+
+    def initialize(code:, explanation: nil, assumptions: [], raw: nil, write_mode: false)
+      rewritten = Rewriter.apply(count_all(trim_no_ops(unfence(code))))
+      @code = rewritten.code
+      @corrections = rewritten.notes
+      @explanation = explanation
+      @assumptions = assumptions
+      @raw = raw
+      @validation = QueryValidator.validate(@code, write_mode: write_mode)
+    end
+
+    def safe?
+      @validation.valid?
+    end
+
+    def destructive?
+      @validation.destructive?
+    end
+
+    def writes?
+      @validation.writes?
+    end
+
+    def violations
+      @validation.violations
+    end
+
+    def models
+      @validation.models
+    end
+
+    NO_CODE = ["", "nil", "null", "none", "n/a", "{}", "[]", "0"].freeze
+
+    NO_QUERY = /\A[A-Z]\w*(?:::[A-Z]\w*)*\s*\.\s*none\z/
+
+    def empty?
+      NO_CODE.include?(@code.downcase) || NO_QUERY.match?(@code) || statements.empty?
+    end
+
+    private
+
+    def unfence(code)
+      text = code.to_s.strip
+      text = Regexp.last_match(1).to_s.strip if FENCED.match(text)
+      text.gsub(/\A`+|`+\z/, "").strip
+    end
+
+    def trim_no_ops(code)
+      loop do
+        trimmed = code.sub(NO_OP_TAIL, "")
+        break unless trimmed != code && trimmed.include?(".")
+
+        code = trimmed
+      end
+      code
+    end
+
+    def count_all(code)
+      return code unless BARE_COUNT_TAIL.match?(code) && several_selected?(code)
+
+      code.sub(BARE_COUNT_TAIL, ".count(:all)")
+    end
+
+    def several_selected?(code)
+      code.to_s.enum_for(:scan, /\.\s*select\s*\(/).any? do
+        several_columns?(code[Regexp.last_match.end(0)..])
+      end
+    end
+
+    Scan = Struct.new(:quote, :sql, :ruby)
+
+    def several_columns?(arguments)
+      scan = Scan.new(nil, 0, 0)
+
+      arguments.to_s.each_char do |char|
+        verdict = scan.quote ? read_in_string(scan, char) : read_in_ruby(scan, char)
+        return verdict unless verdict.nil?
+      end
+      false
+    end
+
+    def read_in_string(scan, char)
+      case char
+      when scan.quote then scan.quote = nil
+      when "(" then scan.sql += 1
+      when ")" then scan.sql -= 1 unless scan.sql.zero?
+      when "," then return true if scan.sql.zero?
+      end
+      nil
+    end
+
+    def read_in_ruby(scan, char)
+      case char
+      when "'", '"' then scan.quote = char
+      when "(" then scan.ruby += 1
+      when ")"
+        return false if scan.ruby.zero? # the select call ends here
+
+        scan.ruby -= 1
+      when "," then return true if scan.sql.zero?
+      end
+      nil
+    end
+
+    def statements
+      @code.lines.map(&:strip).reject { |line| line.empty? || line.start_with?("#") }
+    end
+
+    class << self
+      private
+
+      def extract_json(raw)
+        candidate = balanced_object(strip_fences(raw.to_s.strip))
+        return unless candidate
+
+        parse_json(candidate) || salvage(candidate)
+      end
+
+      def strip_fences(text)
+        text.gsub(/\A```[a-zA-Z]*[ \t]*\r?\n?/, "").gsub(/```\z/, "").strip
+      end
+
+      def balanced_object(text)
+        start = text.index("{")
+        return unless start
+
+        depth = 0
+        in_string = false
+        escaped = false
+        text[start..].each_char.with_index do |char, index|
+          if in_string
+            if escaped then escaped = false
+            elsif char == "\\" then escaped = true
+            elsif char == '"' then in_string = false
+            end
+            next
+          end
+
+          case char
+          when '"' then in_string = true
+          when "{" then depth += 1
+          when "}"
+            depth -= 1
+            return text[start, index + 1] if depth.zero?
+          end
+        end
+        nil
+      end
+
+      def salvage(text)
+        code = json_string(text, "code")
+        return if code.nil?
+
+        { "code" => code, "explanation" => json_string(text, "explanation") }
+      end
+
+      def json_string(text, key)
+        raw = text[/"#{key}"\s*:\s*"((?:[^"\\]|\\.)*)"/, 1]
+        return if raw.nil?
+
+        JSON.parse("\"#{raw}\"")
+      rescue JSON::ParserError
+        raw
+      end
+
+      def parse_json(candidate)
+        payload = JSON.parse(candidate)
+        payload if payload.is_a?(Hash) && payload.key?("code")
+      rescue JSON::ParserError
+        nil
+      end
+
+      def extract_code_block(raw)
+        text = raw.to_s
+        fenced = text[/```[a-zA-Z]*[ \t]*\r?\n(.*?)```/m, 1]
+        return fenced.strip if fenced
+
+        text.strip
+      end
+    end
+  end
+end

data/lib/rails_agent_console/providers/anthropic.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Providers
+    class Anthropic < Base
+      DEFAULT_BASE = "https://api.anthropic.com/v1"
+      API_VERSION = "2023-06-01"
+
+      def name
+        "Anthropic"
+      end
+
+      def models
+        listed = get("#{base_url(DEFAULT_BASE)}/models?limit=100", headers)
+        Array(listed&.dig("data")).filter_map { |entry| entry["id"] }
+      rescue ConfigurationError
+        []
+      end
+
+      private
+
+      def endpoint
+        "#{base_url(DEFAULT_BASE)}/messages"
+      end
+
+      def headers
+        super.merge("x-api-key" => api_key!, "anthropic-version" => API_VERSION)
+      end
+
+      def payload(system:, messages:)
+        {
+          model: model,
+          system: system,
+          max_tokens: 1024,
+          temperature: config.temperature,
+          messages: messages
+        }
+      end
+
+      def extract(response)
+        content = Array(response["content"]).filter_map { |part| part["text"] }.join.strip
+        raise InvalidResponseError, "Anthropic returned no content" if content.empty?
+
+        content
+      end
+    end
+  end
+end