glancer 1.0.0

data/lib/glancer/chart_analyzer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+module Glancer
+  # Analyzes query result data and returns an array of Chart.js-compatible config hashes.
+  # Returns [] when no meaningful chart can be produced. No data is sent to any AI.
+  class ChartAnalyzer
+    MIN_ROWS           = 2
+    MAX_PIE_CATEGORIES = 8
+    MAX_LINE_POINTS    = 500
+    MAX_BAR_CATEGORIES = 60
+    MAX_SCATTER_POINTS = 1000
+
+    def self.analyze(data)
+      return [] unless suitable?(data)
+
+      keys        = data.first.keys
+      date_col    = detect_date_column(data, keys)
+      id_cols     = detect_id_columns(keys)
+      all_numeric = detect_all_numeric(data, keys)
+
+      measure_cols = (all_numeric - id_cols).select do |k|
+        data.map { |r| r[k] }.compact.map { |v| to_f(v) }.uniq.size > 1
+      end
+
+      group_col = detect_group_column(data, keys, date_col: date_col, measure_cols: measure_cols)
+      label_col = detect_label_column(data, keys, exclude: [date_col, group_col].compact + all_numeric)
+
+      charts = []
+
+      charts << build_multi_series(data, date_col, group_col, measure_cols.first) \
+        if date_col && group_col && measure_cols.any?
+
+      if date_col && measure_cols.any? && !group_col && data.size <= MAX_LINE_POINTS
+        filled = fill_monthly_gaps(data, date_col, measure_cols)
+        charts << build_line(filled, date_col, measure_cols)
+        charts << build_bar(filled, date_col, measure_cols)
+      end
+
+      if !date_col && !group_col && label_col && measure_cols.any?
+        unique_labels = data.map { |r| r[label_col] }.uniq.size
+        if unique_labels <= MAX_BAR_CATEGORIES
+          charts << build_bar(data, label_col, measure_cols)
+          charts << build_doughnut(data, label_col, measure_cols.first) if measure_cols.size == 1 && unique_labels <= MAX_PIE_CATEGORIES
+        end
+      end
+
+      if measure_cols.size >= 2 && date_col.nil? && group_col.nil? && data.size <= MAX_SCATTER_POINTS
+        charts << build_scatter(data, measure_cols[0], measure_cols[1])
+      end
+
+      charts.compact
+    rescue StandardError
+      []
+    end
+
+    # ── Column classification ─────────────────────────────────────────────────
+
+    def self.detect_id_columns(keys)
+      keys.select { |k| k.to_s.match?(/\A\w+_id\z|\Aid\z/i) }
+    end
+
+    def self.detect_all_numeric(data, keys)
+      keys.select do |k|
+        vals = data.map { |r| r[k] }.compact
+        vals.any? && vals.all? { |v| numeric?(v) }
+      end
+    end
+
+    def self.detect_group_column(data, keys, date_col:, measure_cols:)
+      return nil unless date_col
+
+      id_like = keys.select { |k| k.to_s.match?(/\A\w+_id\z|\Aid\z/i) }
+      strings = (keys - [date_col]).select { |k| data.first[k].is_a?(String) || data.first[k].is_a?(Symbol) }
+      candidates = (id_like + strings) - measure_cols
+      candidates.find { |k| low_cardinality?(data, k) }
+    end
+
+    def self.low_cardinality?(data, col)
+      uniq = data.map { |r| r[col] }.uniq.size
+      uniq <= 30 && uniq < (data.size / 2.0).ceil
+    end
+
+    def self.detect_label_column(data, keys, exclude: [])
+      (keys - exclude).find { |k| data.first[k].is_a?(String) || data.first[k].is_a?(Symbol) }
+    end
+
+    # ── Date detection ────────────────────────────────────────────────────────
+
+    def self.detect_date_column(data, keys)
+      date_kw = /\A(date|time|month|year|day|week|quarter|period|created|updated|at)\z/i
+      loose   = /date|time|month|year|day|week|period|created|updated/i
+
+      named = keys.find { |k| k.to_s.match?(date_kw) } ||
+              keys.find { |k| k.to_s.match?(loose) }
+      return named if named && date_values?(data, named)
+
+      keys.find { |k| date_values?(data, k) }
+    end
+
+    def self.date_values?(data, col)
+      samples = data.first(5).map { |r| r[col] }.compact
+      return false if samples.empty?
+
+      samples.all? { |v| v.is_a?(Date) || v.is_a?(Time) || date_string?(v) }
+    end
+
+    def self.date_string?(val)
+      return false unless val.is_a?(String)
+
+      val.match?(%r{\A\d{4}[-/]\d{2}([-/]\d{2})?|\A\d{2}[-/]\d{2}[-/]\d{4}|\A\d{4}-\d{2}\z})
+    rescue StandardError
+      false
+    end
+
+    def self.monthly_period?(str)
+      str.to_s.match?(/\A\d{4}-\d{2}\z/)
+    end
+
+    # ── Date gap filling ──────────────────────────────────────────────────────
+
+    def self.fill_monthly_gaps(data, date_col, measure_cols)
+      dates = data.map { |r| r[date_col].to_s }
+      return data unless dates.all? { |d| monthly_period?(d) }
+
+      by_date    = data.each_with_object({}) { |row, h| h[row[date_col].to_s] = row }
+      all_months = expand_month_range(dates.min, dates.max)
+      base_row   = data.first.transform_values { nil }
+      zero_fill  = measure_cols.each_with_object({}) { |c, h| h[c] = 0 }
+
+      all_months.map do |month|
+        by_date[month] || base_row.merge({ date_col => month }).merge(zero_fill)
+      end
+    end
+
+    def self.expand_month_range(min_str, max_str)
+      current = Date.parse("#{min_str}-01")
+      last    = Date.parse("#{max_str}-01")
+      months  = []
+      while current <= last
+        months << current.strftime("%Y-%m")
+        current >>= 1
+      end
+      months
+    end
+
+    # ── Multi-series pivot builder ────────────────────────────────────────────
+
+    def self.build_multi_series(data, date_col, group_col, metric_col)
+      raw_dates = data.map { |r| r[date_col].to_s }.uniq
+      x_labels = if raw_dates.all? { |d| monthly_period?(d) }
+                   expand_month_range(raw_dates.min, raw_dates.max)
+                 else
+                   raw_dates.sort
+                 end
+      group_vals = data.map { |r| r[group_col] }.uniq.sort_by(&:to_s)
+      return nil if group_vals.size > MAX_BAR_CATEGORIES
+
+      lookup   = data.each_with_object({}) { |r, h| h[[r[date_col].to_s, r[group_col]]] = to_f(r[metric_col]) }
+      datasets = group_vals.map { |gv| { label: gv.to_s, data: x_labels.map { |xl| lookup[[xl, gv]] || 0 } } }
+
+      { type: "line", labels: x_labels, datasets: datasets }
+    end
+
+    # ── Simple chart builders ─────────────────────────────────────────────────
+
+    def self.build_line(data, date_col, measure_cols)
+      sets = measure_cols.map { |col| { label: humanize(col), data: data.map { |r| to_f(r[col]) } } }
+      { type: "line", labels: data.map { |r| r[date_col].to_s }, datasets: sets }
+    end
+
+    def self.build_bar(data, label_col, measure_cols)
+      sets = measure_cols.map { |col| { label: humanize(col), data: data.map { |r| to_f(r[col]) } } }
+      { type: "bar", labels: data.map { |r| r[label_col].to_s }, datasets: sets }
+    end
+
+    def self.build_doughnut(data, label_col, metric_col)
+      {
+        type: "doughnut",
+        labels: data.map { |r| r[label_col].to_s },
+        datasets: [{ label: humanize(metric_col), data: data.map { |r| to_f(r[metric_col]) } }]
+      }
+    end
+
+    def self.build_scatter(data, x_col, y_col)
+      {
+        type: "scatter",
+        labels: nil,
+        xLabel: humanize(x_col),
+        yLabel: humanize(y_col),
+        datasets: [{
+          label: "#{humanize(x_col)} × #{humanize(y_col)}",
+          data: data.map { |r| { x: to_f(r[x_col]), y: to_f(r[y_col]) } }
+        }]
+      }
+    end
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def self.suitable?(data)
+      data.is_a?(Array) &&
+        data.size >= MIN_ROWS &&
+        data.first.is_a?(Hash) &&
+        data.first.keys.size >= 2
+    end
+
+    def self.numeric?(val)
+      val.is_a?(Integer) || val.is_a?(Float) ||
+        (val.is_a?(String) && val.strip.match?(/\A-?\d+(\.\d+)?\z/))
+    end
+
+    def self.to_f(val)
+      return val.to_f if val.is_a?(Numeric)
+
+      val.to_s.gsub(",", ".").to_f
+    end
+
+    def self.humanize(col)
+      col.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+    end
+
+    private_class_method :suitable?, :detect_id_columns, :detect_all_numeric,
+                         :detect_group_column, :low_cardinality?, :detect_label_column,
+                         :detect_date_column, :date_values?, :date_string?, :monthly_period?,
+                         :fill_monthly_gaps, :expand_month_range, :build_multi_series,
+                         :build_line, :build_bar, :build_doughnut, :build_scatter,
+                         :numeric?, :to_f, :humanize
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/glancer/configuration.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Configuration
+    ADAPTERS_SUPPORTED = %i[postgres mysql mysql2 sqlite].freeze
+    LLM_PROVIDERS = %i[gemini openai openrouter].freeze
+    LOG_VERBOSITY_LEVELS = %i[silent none info debug].freeze
+    QUERY_MODES = %i[sql activerecord].freeze
+
+    # Default embedding models per provider.
+    # OpenRouter does not expose a native embedding API; the recommended approach
+    # is to set embedding_provider to :gemini or :openai and only use openrouter
+    # for chat/sql roles.
+    EMBEDDING_DEFAULTS = {
+      gemini: "text-embedding-004",
+      openai: "text-embedding-3-large",
+      openrouter: "openai/text-embedding-3-small"
+    }.freeze
+
+    def initialize
+      self.adapter = Glancer::Configuration.infer_adapter || :mysql2
+      self.read_only_db = nil
+      self.llm_provider = :gemini
+      self.llm_model = "gemini-2.0-flash"
+      self.schema_permission = false
+      self.models_permission = false
+      self.workflow_cache_ttl = 5.minutes
+      self.context_file_path = "config/glancer/llm_context.glancer.md"
+      self.api_key = nil
+      self.gemini_api_key = nil
+      self.openai_api_key = nil
+      self.openrouter_api_key = nil
+      self.log_output_path = nil
+      self.log_verbosity = :info
+      self.k = 5
+      self.min_score = 0.6
+      self.schema_documents_weight = 1.3
+      self.context_documents_weight = 1.2
+      self.models_documents_weight = 1.1
+      self.chunk_size = 1000
+      self.chunk_overlap = 150
+      self.history_limit = 6
+      self.statement_timeout = 30.seconds
+      self.embedding_provider = nil  # nil → uses llm_provider
+      self.embedding_model = nil     # nil → uses provider default
+      self.code_provider = nil        # nil → uses llm_provider (for SQL generation)
+      self.code_model = nil           # nil → uses llm_model (for SQL generation)
+      self.chat_provider = nil       # nil → uses llm_provider (for humanized responses)
+      self.chat_model = nil          # nil → uses llm_model (for humanized responses)
+      self.blazer_path = nil         # nil → auto-detected if Blazer::Engine is mounted
+      self.query_mode = :sql         # :sql (default) or :activerecord
+      self.query_enrichment_enabled = false # enrich question with table names before retrieval
+      self.enrichment_provider = nil        # nil → falls back to llm_provider
+      self.enrichment_model = nil           # nil → falls back to llm_model
+    end
+
+    # === READERS ===
+    attr_reader :adapter, :read_only_db, :llm_provider, :llm_model,
+                :schema_permission, :models_permission, :workflow_cache_ttl,
+                :context_file_path, :api_key, :gemini_api_key, :openai_api_key, :openrouter_api_key,
+                :log_output_path, :log_verbosity,
+                :k, :min_score,
+                :schema_documents_weight, :context_documents_weight, :models_documents_weight,
+                :chunk_size, :chunk_overlap, :history_limit, :statement_timeout,
+                :embedding_provider, :embedding_model,
+                :code_provider, :code_model,
+                :chat_provider, :chat_model,
+                :blazer_path, :query_mode,
+                :query_enrichment_enabled, :enrichment_provider, :enrichment_model
+
+    # === WRITERS ===
+    def adapter=(value)
+      unless ADAPTERS_SUPPORTED.join(", ").include?(value.to_s)
+        raise ArgumentError, "adapter must be #{
+          ADAPTERS_SUPPORTED.join(", ")
+        }" || value.nil?
+      end
+
+      @adapter = value
+    end
+
+    def read_only_db=(value)
+      unless value.nil? || value.is_a?(String) || value == :read_only
+        raise ArgumentError, "read_only_db must be nil, a connection URL string, or :read_only"
+      end
+
+      @read_only_db = value
+    end
+
+    def llm_provider=(value)
+      unless LLM_PROVIDERS.include?(value)
+        raise ArgumentError, "llm_provider must be #{
+          LLM_PROVIDERS.join(", ")
+        }"
+      end
+
+      @llm_provider = value
+    end
+
+    def llm_model=(value)
+      raise ArgumentError, "llm_model must be a String" unless value.is_a?(String)
+
+      @llm_model = value
+    end
+
+    def schema_permission=(value)
+      raise ArgumentError, "schema_permission must be true or false" unless [true, false].include?(value)
+
+      @schema_permission = value
+    end
+
+    def models_permission=(value)
+      raise ArgumentError, "models_permission must be true or false" unless [true, false].include?(value)
+
+      @models_permission = value
+    end
+
+    def workflow_cache_ttl=(value)
+      raise ArgumentError, "workflow_cache_ttl must respond to to_i" unless value.respond_to?(:to_i)
+
+      @workflow_cache_ttl = value
+    end
+
+    def context_file_path=(value)
+      raise ArgumentError, "context_file_path must be a String" unless value.is_a?(String)
+
+      @context_file_path = value
+    end
+
+    def api_key=(value)
+      raise ArgumentError, "api_key must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @api_key = value
+    end
+
+    def gemini_api_key=(value)
+      raise ArgumentError, "gemini_api_key must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @gemini_api_key = value
+    end
+
+    def openai_api_key=(value)
+      raise ArgumentError, "openai_api_key must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @openai_api_key = value
+    end
+
+    def openrouter_api_key=(value)
+      raise ArgumentError, "openrouter_api_key must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @openrouter_api_key = value
+    end
+
+    def log_output_path=(value)
+      raise ArgumentError, "log_output_path must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @log_output_path = value
+    end
+
+    def log_verbosity=(value)
+      raise ArgumentError, "log_verbosity must be :silent, :none, :info, or :debug" unless LOG_VERBOSITY_LEVELS.include?(value)
+
+      @log_verbosity = value
+    end
+
+    def k=(value)
+      raise ArgumentError, "k must be an integer ≥ 1" unless value.is_a?(Integer) && value >= 1
+
+      @k = value
+    end
+
+    def min_score=(value)
+      unless value.is_a?(Numeric) && value.between?(
+        0.0, 1.0
+      )
+        raise ArgumentError,
+              "min_score must be a number between 0.0 and 1.0"
+      end
+
+      @min_score = value
+    end
+
+    def schema_documents_weight=(value)
+      unless value.is_a?(Numeric) && value >= 1
+        raise ArgumentError,
+              "schema_documents_weight must be a positive number greater than or equal to 1"
+      end
+
+      @schema_documents_weight = value
+    end
+
+    def context_documents_weight=(value)
+      unless value.is_a?(Numeric) && value >= 1
+        raise ArgumentError,
+              "context_documents_weight must be a positive number greater than or equal to 1"
+      end
+
+      @context_documents_weight = value
+    end
+
+    def models_documents_weight=(value)
+      unless value.is_a?(Numeric) && value >= 1
+        raise ArgumentError,
+              "models_documents_weight must be a positive number greater than or equal to 1"
+      end
+
+      @models_documents_weight = value
+    end
+
+    def chunk_size=(value)
+      raise ArgumentError, "chunk_size must be an integer ≥ 100" unless value.is_a?(Integer) && value >= 100
+
+      @chunk_size = value
+    end
+
+    def chunk_overlap=(value)
+      raise ArgumentError, "chunk_overlap must be an integer ≥ 0" unless value.is_a?(Integer) && value >= 0
+
+      @chunk_overlap = value
+    end
+
+    def history_limit=(value)
+      raise ArgumentError, "history_limit must be an integer ≥ 1" unless value.is_a?(Integer) && value >= 1
+
+      @history_limit = value
+    end
+
+    def statement_timeout=(value)
+      raise ArgumentError, "statement_timeout must respond to to_i" unless value.respond_to?(:to_i)
+
+      @statement_timeout = value
+    end
+
+    def embedding_provider=(value)
+      unless value.nil? || LLM_PROVIDERS.include?(value)
+        raise ArgumentError, "embedding_provider must be nil or one of: #{LLM_PROVIDERS.join(", ")}"
+      end
+
+      @embedding_provider = value
+    end
+
+    def embedding_model=(value)
+      raise ArgumentError, "embedding_model must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @embedding_model = value
+    end
+
+    # Returns the provider to use for embedding calls (falls back to llm_provider).
+    def resolved_embedding_provider
+      embedding_provider || llm_provider
+    end
+
+    # Returns the model to use for embedding calls.
+    # Falls back to EMBEDDING_DEFAULTS for the resolved provider.
+    def resolved_embedding_model
+      embedding_model || EMBEDDING_DEFAULTS[resolved_embedding_provider] || "text-embedding-004"
+    end
+
+    def code_provider=(value)
+      unless value.nil? || LLM_PROVIDERS.include?(value)
+        raise ArgumentError, "code_provider must be nil or one of: #{LLM_PROVIDERS.join(", ")}"
+      end
+
+      @code_provider = value
+    end
+
+    def code_model=(value)
+      raise ArgumentError, "code_model must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @code_model = value
+    end
+
+    def chat_provider=(value)
+      unless value.nil? || LLM_PROVIDERS.include?(value)
+        raise ArgumentError, "chat_provider must be nil or one of: #{LLM_PROVIDERS.join(", ")}"
+      end
+
+      @chat_provider = value
+    end
+
+    def chat_model=(value)
+      raise ArgumentError, "chat_model must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @chat_model = value
+    end
+
+    def resolved_code_provider
+      code_provider || llm_provider
+    end
+
+    def resolved_code_model
+      code_model || llm_model
+    end
+
+    def resolved_chat_provider
+      chat_provider || llm_provider
+    end
+
+    def resolved_chat_model
+      chat_model || llm_model
+    end
+
+    def query_enrichment_enabled=(value)
+      raise ArgumentError, "query_enrichment_enabled must be true or false" unless [true, false].include?(value)
+
+      @query_enrichment_enabled = value
+    end
+
+    def enrichment_provider=(value)
+      unless value.nil? || LLM_PROVIDERS.include?(value)
+        raise ArgumentError, "enrichment_provider must be nil or one of: #{LLM_PROVIDERS.join(", ")}"
+      end
+
+      @enrichment_provider = value
+    end
+
+    def enrichment_model=(value)
+      raise ArgumentError, "enrichment_model must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @enrichment_model = value
+    end
+
+    def resolved_enrichment_provider
+      enrichment_provider || llm_provider
+    end
+
+    def resolved_enrichment_model
+      enrichment_model || llm_model
+    end
+
+    def blazer_path=(value)
+      raise ArgumentError, "blazer_path must be nil or a String" unless value.nil? || value.is_a?(String)
+
+      @blazer_path = value
+    end
+
+    def query_mode=(value)
+      raise ArgumentError, "query_mode must be one of: #{QUERY_MODES.join(", ")}" unless QUERY_MODES.include?(value)
+
+      @query_mode = value
+    end
+
+    # Returns the Blazer base path if Blazer is available, nil otherwise.
+    def resolved_blazer_path
+      return @blazer_path unless @blazer_path.nil?
+
+      defined?(Blazer::Engine) ? "/blazer" : nil
+    end
+
+    # Returns the adapter in use, auto-detecting from ActiveRecord when nil.
+    # Normalizes "postgresql" → :postgres so callers don't need to handle both.
+    def resolved_adapter
+      raw = adapter || self.class.infer_adapter || :mysql2
+      raw.to_s == "postgresql" ? :postgres : raw
+    end
+
+    # === Auxiliary methods ===
+
+    def self.infer_adapter
+      raw = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+      raw.to_s == "postgresql" ? :postgres : raw
+    rescue StandardError
+      nil
+    end
+
+    def self.valid_table_name?(table_name)
+      ActiveRecord::Base.connection.tables.include?(table_name.to_s)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/glancer/engine.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Engine < ::Rails::Engine
+    isolate_namespace Glancer
+
+    config.i18n.load_path += Dir[root.join("config/locales/*.yml").to_s]
+
+    initializer "glancer.append_migrations" do |app|
+      unless app.root.to_s.match?(root.to_s)
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+
+    initializer "glancer.assets" do |app|
+      app.config.assets.paths << root.join("app/assets/javascripts")
+      app.config.assets.precompile += %w[
+        glancer/application.js
+      ]
+
+      app.config.assets.paths << root.join("app/assets/stylesheets")
+      app.config.assets.precompile += %w[
+        glancer/application.css
+        glancer/code-blocks.css
+        glancer/table.css
+        glancer/list.css
+        glancer/scrollbar.css
+      ]
+      app.config.assets.paths << root.join("app/assets/config")
+      app.config.assets.paths << root.join("app/assets/images")
+    end
+
+    initializer "glancer.load_tasks" do
+      Dir[File.join(__dir__, "../../tasks/**/*.rake")].each { |f| load f }
+    end
+
+    initializer "glancer.configure_ruby_llm" do
+      next unless Glancer.configuration
+
+      Glancer::Utils::Logger.info("Engine", "Configuring RubyLLM with Glancer settings...")
+
+      RubyLLM.configure do |config|
+        glancer_cfg = Glancer.configuration
+        provider = glancer_cfg.llm_provider.to_sym
+        embed_provider = glancer_cfg.resolved_embedding_provider.to_sym
+
+        Glancer::Utils::Logger.debug("Engine", "LLM provider: #{provider}, embedding provider: #{embed_provider}")
+
+        Glancer::Engine.configure_provider_key(config, glancer_cfg, provider)
+        Glancer::Engine.configure_provider_key(config, glancer_cfg, embed_provider) if embed_provider != provider
+
+        config.default_embedding_model = glancer_cfg.resolved_embedding_model
+
+        Glancer::Utils::Logger.info("Engine",
+                                    "RubyLLM configured — chat: #{provider}/#{glancer_cfg.llm_model}, " \
+                                    "embeddings: #{embed_provider}/#{config.default_embedding_model}")
+      end
+
+      Glancer::Utils::Logger.info("Engine", "RubyLLM configuration completed.")
+    rescue StandardError => e
+      Glancer::Utils::Logger.error("Engine", "Failed to configure RubyLLM: #{e.class} - #{e.message}")
+      Glancer::Utils::Logger.debug("Engine", "Backtrace:\n#{e.backtrace.join("\n")}")
+      raise Glancer::Error, "RubyLLM configuration failed: #{e.message}"
+    end
+
+    def self.configure_provider_key(config, glancer_cfg, provider)
+      case provider
+      when :gemini
+        key = glancer_cfg.gemini_api_key || glancer_cfg.api_key
+        raise Glancer::Error, "Gemini API key is required but not configured." if key.nil? || key.empty?
+
+        config.gemini_api_key = key
+      when :openai
+        key = glancer_cfg.openai_api_key || glancer_cfg.api_key
+        raise Glancer::Error, "OpenAI API key is required but not configured." if key.nil? || key.empty?
+
+        config.openai_api_key = key
+      when :openrouter
+        key = glancer_cfg.openrouter_api_key || glancer_cfg.api_key
+        raise Glancer::Error, "OpenRouter API key is required but not configured." if key.nil? || key.empty?
+
+        config.openrouter_api_key = key
+      else
+        raise Glancer::Error, "Unsupported LLM provider: #{provider.inspect}"
+      end
+    end
+  end
+end