glancer 1.0.0

data/lib/glancer/workflow.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Glancer
+  module Workflow
+    def self.run(chat_id, question, cache: true, &status_callback)
+      Glancer::Utils::Logger.info("Workflow",
+                                  "Running workflow for chat_id: #{chat_id.inspect}, " \
+                                  "question: #{question.inspect}, " \
+                                  "mode: #{Glancer.configuration.query_mode}, cache: #{cache}")
+
+      if cache && (cached = Workflow::Cache.fetch(question))
+        Glancer::Utils::Logger.info("Workflow", "Using cached result for question: #{question.inspect}")
+        return cached.merge(from_cache: true)
+      end
+
+      chat = Glancer::Chat.find(chat_id)
+      history = chat.messages.order(created_at: :desc).limit(Glancer.configuration.history_limit).reverse
+
+      enrichment_enabled = Glancer.configuration.query_enrichment_enabled
+      adapter            = Glancer.configuration.query_mode
+
+      status_callback&.call(:enriching) if enrichment_enabled
+      effective_question = enrich_question(question, history, adapter: adapter)
+
+      status_callback&.call(:retrieving_context)
+      embeddings = Retriever.search(effective_question)
+      Glancer::Utils::Logger.debug("Workflow", "Retrieved #{embeddings.size} relevant document(s) for context")
+
+      result = if adapter == :activerecord
+                 run_activerecord(question, effective_question, embeddings, history, status_callback)
+               else
+                 run_sql(question, effective_question, embeddings, history, status_callback)
+               end
+
+      # Always persist the enriched question so the info panel can show it on every message
+      result[:enriched_question] = effective_question if enrichment_enabled
+
+      if cache && result[:successful]
+        Workflow::Cache.write(question, result)
+        Glancer::Utils::Logger.info("Workflow", "Result cached for question: #{question.inspect}")
+      end
+
+      result
+    rescue StandardError => e
+      Glancer::Utils::Logger.error("Workflow", "Workflow execution failed: #{e.class} - #{e.message}")
+      Glancer::Utils::Logger.debug("Workflow", "Backtrace:\n#{e.backtrace.join("\n")}")
+      raise Glancer::Error, "Workflow failed: #{e.message}"
+    end
+
+    def self.enrich_question(question, history = [], adapter: nil)
+      return question unless Glancer.configuration.query_enrichment_enabled
+
+      Glancer::Utils::Logger.info("Workflow", "Enriching question before retrieval...")
+      table_names = Glancer::Workflow::QueryEnricher.known_table_names
+      enriched    = Glancer::Workflow::QueryEnricher.enrich(question, table_names, history: history,
+                                                                                   adapter: adapter)
+      Glancer::Utils::Logger.info("Workflow", "Enriched question: #{enriched.inspect}")
+      enriched
+    rescue StandardError => e
+      Glancer::Utils::Logger.warn("Workflow", "Question enrichment failed, using original: #{e.message}")
+      question
+    end
+    private_class_method :enrich_question
+
+    def self.run_sql(question, effective_question, embeddings, history, status_callback = nil)
+      Glancer::Utils::Logger.info("Workflow", "Running SQL code generation mode...")
+
+      status_callback&.call(:generating_code)
+      sql = Workflow::Builder.build_sql(effective_question, embeddings, history: history)
+      Glancer::Utils::Logger.debug("Workflow", "Generated raw SQL:\n#{sql}")
+
+      sql = Workflow::SQLExtractor.extract(sql)
+      Glancer::Utils::Logger.debug("Workflow", "Extracted SQL:\n#{sql}")
+
+      Workflow::SQLSanitizer.ensure_safe!(sql)
+
+      begin
+        status_callback&.call(:validating)
+        Workflow::SQLValidator.validate_tables_exist!(sql)
+      rescue Glancer::Error => e
+        Glancer::Utils::Logger.warn("Workflow", "Table validation failed: #{e.message}. Returning friendly response.")
+        explanation = Glancer::Workflow::LLM.explain_missing_tables(question, e.message)
+        return {
+          question: question,
+          content: explanation,
+          code: sql,
+          code_type: "sql",
+          successful: false
+        }
+      end
+
+      status_callback&.call(:executing)
+      raw_data = Workflow::Executor.execute(sql, original_question: question)
+
+      if raw_data.is_a?(Hash) && raw_data[:error]
+        explanation = Glancer::Workflow::LLM.explain_error(question, raw_data[:message], raw_data[:last_code])
+        return {
+          question: question,
+          content: explanation,
+          code: raw_data[:last_code],
+          code_type: "sql",
+          successful: false
+        }
+      end
+
+      status_callback&.call(:humanizing)
+      {
+        question: question,
+        content: Glancer::Workflow::LLM.humanized_response(question, raw_data, sql),
+        code: sql,
+        code_type: "sql",
+        successful: true,
+        sources: embeddings.map { |e| { id: e.id, type: e.source_type, path: e.source_path, score: e.score } }
+      }
+    end
+    private_class_method :run_sql
+
+    def self.run_activerecord(question, effective_question, embeddings, history, status_callback = nil)
+      Glancer::Utils::Logger.info("Workflow", "Running ActiveRecord mode...")
+
+      status_callback&.call(:generating_code)
+      code = Workflow::Builder.build_ar_code(effective_question, embeddings, history: history)
+      Glancer::Utils::Logger.debug("Workflow", "Generated raw AR code:\n#{code}")
+
+      code = Workflow::ARExtractor.extract(code)
+      Glancer::Utils::Logger.debug("Workflow", "Extracted AR code:\n#{code}")
+
+      Workflow::ARSanitizer.ensure_safe!(code)
+
+      status_callback&.call(:executing)
+      raw_data = Workflow::ARExecutor.execute(code, original_question: question)
+
+      if raw_data.is_a?(Hash) && raw_data[:error]
+        explanation = Glancer::Workflow::LLM.explain_error(
+          question, raw_data[:message], raw_data[:last_code], mode: :activerecord
+        )
+        return {
+          question: question,
+          content: explanation,
+          code: raw_data[:last_code],
+          code_type: "activerecord",
+          successful: false
+        }
+      end
+
+      status_callback&.call(:humanizing)
+      {
+        question: question,
+        content: Glancer::Workflow::LLM.humanized_response(question, raw_data, code, mode: :activerecord),
+        code: code,
+        code_type: "activerecord",
+        successful: true,
+        sources: embeddings.map { |e| { id: e.id, type: e.source_type, path: e.source_path, score: e.score } }
+      }
+    end
+    private_class_method :run_activerecord
+  end
+end

data/lib/glancer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "glancer/version"
+require "glancer/configuration"
+
+module Glancer
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+end
+
+require "glancer/utils/logger" # Glancer::Utils::Logger
+require "glancer/utils/markdown_helper" # Glancer::Utils::MarkdownHelper
+require "glancer/utils/result_formatter" # Glancer::Utils::ResultFormatter
+require "glancer/utils/table_stats" # Glancer::Utils::TableStats
+require "glancer/utils/transaction" # Glancer::Utils::Transaction
+
+require "glancer/engine" # Glancer::Engine
+
+require "glancer/indexer" # Glancer::Indexer
+require "glancer/indexer/context_indexer" # Glancer::Indexer::ContextIndexer
+require "glancer/indexer/model_indexer" # Glancer::Indexer::ModelIndexer
+require "glancer/indexer/schema_indexer" # Glancer::Indexer::SchemaIndexer
+
+require "glancer/retriever" # Glancer::Retriever
+
+require "glancer/workflow" # Glancer::Workflow
+require "glancer/workflow/builder" # Glancer::Workflow::Builder
+require "glancer/workflow/cache" # Glancer::Workflow::Cache
+require "glancer/workflow/executor" # Glancer::Workflow::Executor
+require "glancer/workflow/prompt_builder" # Glancer::Workflow::PromptBuilder
+require "glancer/workflow/sql_extractor" # Glancer::Workflow::SQLExtractor
+require "glancer/workflow/sql_sanitizer" # Glancer::Workflow::SQLSanitizer
+require "glancer/workflow/sql_validator" # Glancer::Workflow::SQLValidator
+require "glancer/workflow/llm" # Glancer::Workflow::LLM
+require "glancer/workflow/ar_prompt_builder" # Glancer::Workflow::ARPromptBuilder
+require "glancer/workflow/ar_extractor" # Glancer::Workflow::ARExtractor
+require "glancer/workflow/ar_sanitizer" # Glancer::Workflow::ARSanitizer
+require "glancer/workflow/ar_executor" # Glancer::Workflow::ARExecutor
+require "glancer/workflow/query_enricher" # Glancer::Workflow::QueryEnricher
+
+require "glancer/chart_analyzer" # Glancer::ChartAnalyzer
+require "glancer/async_runner"   # Glancer::AsyncRunner

data/lib/tasks/glancer/tailwind.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+namespace :glancer do
+  desc "Install Tailwind CSS"
+  task :install do
+    system "#{RbConfig.ruby} ./bin/rails app:tailwindcss:install"
+  end
+end

data/lib/tasks/glancer.rake

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+namespace :glancer do
+  desc "Show current Glancer and RubyLLM versions"
+  task :version do
+    puts "\n\e[36m✱ glancer@v#{Glancer::VERSION}\e[0m\n"
+    puts
+  end
+
+  namespace :index do
+    desc "Rebuild all Glancer indexes"
+    task all: :environment do
+      existing = Glancer::Embedding.count
+      if existing.positive?
+        puts "\n\e[33m✱ There are currently #{existing} embeddings stored.\e[0m"
+        puts "\e[31m└→ This operation will delete all existing embeddings and reindex everything.\e[0m"
+      end
+
+      Glancer::Utils::Transaction.make do
+        Glancer::Embedding.where(source_type: %w[schema models context]).delete_all
+
+        Glancer::Utils::Logger.with_debug_logs do
+          Glancer::Indexer.rebuild_all!
+        end
+
+        puts "\e[32m✔ All indexes rebuilt!\e[0m"
+      end
+    end
+
+    desc "Rebuild schema index only"
+    task schema: :environment do
+      if confirm_rebuild?(:schema)
+        Glancer::Utils::Transaction.make do
+          Glancer::Embedding.where(source_type: "schema").delete_all
+
+          Glancer::Utils::Logger.with_debug_logs do
+            chunks = Glancer::Indexer::SchemaIndexer.index!
+            Glancer::Retriever.store_documents(chunks)
+          end
+
+          puts "\e[32m✔ Schema index rebuilt!\e[0m"
+        end
+      end
+    end
+
+    desc "Rebuild models index only"
+    task models: :environment do
+      if confirm_rebuild?(:models)
+        Glancer::Utils::Transaction.make do
+          Glancer::Embedding.where(source_type: "models").delete_all
+
+          Glancer::Utils::Logger.with_debug_logs do
+            chunks = Glancer::Indexer::ModelIndexer.index!
+            Glancer::Retriever.store_documents(chunks)
+          end
+
+          puts "\e[32m✔ Models index rebuilt!\e[0m"
+        end
+      end
+    end
+
+    desc "Rebuild context index only"
+    task context: :environment do
+      if confirm_rebuild?(:context)
+        Glancer::Utils::Transaction.make do
+          Glancer::Embedding.where(source_type: "context").delete_all
+
+          Glancer::Utils::Logger.with_debug_logs do
+            chunks = Glancer::Indexer::ContextIndexer.index!
+            Glancer::Retriever.store_documents(chunks)
+          end
+
+          puts "\e[32m✔ Context index rebuilt!\e[0m"
+        end
+      end
+    end
+  end
+
+  def confirm_rebuild?(type)
+    existing = Glancer::Embedding.where(source_type: type.to_s)
+    if existing.exists?
+      last = existing.order(created_at: :desc).first.created_at
+      puts "\n\e[33m✱ Existing #{existing.count} '#{type}' embeddings found. Last updated: #{last.strftime("%Y-%m-%d %H:%M:%S")}.\e[0m"
+      print "\e[31m└→ Do you want to delete and reindex? [y/N]: \e[0m"
+      input = $stdin.gets.strip.upcase
+
+      puts "\n\e[31m✖ Operation cancelled.\e[0m\n" unless input == "Y"
+
+      return input == "Y"
+    end
+    true
+  rescue Interrupt
+    puts "\n\n\e[31m✖ Operation cancelled\e[0m\n"
+    false
+  rescue StandardError => e
+    puts "\n\n\e[31m✖ Error: #{e.message}\e[0m\n"
+    false
+  end
+end

data/spec/glancer_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer do
+  describe "::VERSION" do
+    it "is defined and non-nil" do
+      expect(Glancer::VERSION).not_to be_nil
+    end
+
+    it "is a String" do
+      expect(Glancer::VERSION).to be_a(String)
+    end
+
+    it "follows semantic versioning format" do
+      expect(Glancer::VERSION).to match(/\A\d+\.\d+\.\d+/)
+    end
+  end
+
+  describe "::Error" do
+    it "is a subclass of StandardError" do
+      expect(Glancer::Error.ancestors).to include(StandardError)
+    end
+
+    it "can be raised and rescued" do
+      expect { raise Glancer::Error, "test" }.to raise_error(Glancer::Error, "test")
+    end
+  end
+
+  describe ".configure" do
+    it "yields the configuration object" do
+      Glancer.configure do |c|
+        expect(c).to be_a(Glancer::Configuration)
+      end
+    end
+
+    it "persists changes made inside the block" do
+      Glancer.configure { |c| c.k = 42 }
+      expect(Glancer.configuration.k).to eq(42)
+    end
+
+    it "re-uses the existing configuration on repeated calls" do
+      Glancer.configure { |c| c.k = 7 }
+      Glancer.configure { |c| c.min_score = 0.5 }
+      expect(Glancer.configuration.k).to eq(7)
+      expect(Glancer.configuration.min_score).to eq(0.5)
+    end
+  end
+
+  describe ".configuration" do
+    it "is accessible after configure" do
+      expect(Glancer.configuration).to be_a(Glancer::Configuration)
+    end
+
+    it "can be replaced by assignment" do
+      new_config = Glancer::Configuration.new
+      new_config.k = 99
+      Glancer.configuration = new_config
+      expect(Glancer.configuration.k).to eq(99)
+    end
+  end
+end

data/spec/lib/glancer/async_runner_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::AsyncRunner do
+  let(:chat)    { Glancer::Chat.create!(title: "Test") }
+  let(:message) do
+    Glancer::Message.create!(
+      chat: chat, role: :assistant, content: "", code_type: "sql", status: :processing
+    )
+  end
+  let(:question) { "How many users?" }
+
+  let(:workflow_result) do
+    {
+      content: "There are 5 users.",
+      code: "SELECT COUNT(*) FROM users",
+      code_type: "sql",
+      successful: true,
+      enriched_question: nil
+    }
+  end
+
+  before do
+    allow(Glancer::Workflow).to receive(:run).and_return(workflow_result)
+    allow(Glancer::Workflow::LLM).to receive(:generate_title).and_return("User count")
+    # Stub resolved_chat_provider/model so the model string builds without config errors
+    allow(Glancer.configuration).to receive(:resolved_chat_provider).and_return("gemini")
+    allow(Glancer.configuration).to receive(:resolved_chat_model).and_return("gemini-2.0-flash")
+  end
+
+  # ── .run ──────────────────────────────────────────────────────────────────
+
+  describe ".run" do
+    it "updates the message status to :processing then :complete" do
+      described_class.run(message.id, question)
+      expect(message.reload.status).to eq("complete")
+    end
+
+    it "stores the workflow content on the message" do
+      described_class.run(message.id, question)
+      expect(message.reload.content).to eq("There are 5 users.")
+    end
+
+    it "stores the generated code on the message" do
+      described_class.run(message.id, question)
+      expect(message.reload.code).to eq("SELECT COUNT(*) FROM users")
+    end
+
+    it "marks the message as successful" do
+      described_class.run(message.id, question)
+      expect(message.reload.successful).to be(true)
+    end
+
+    it "creates a code_version record for the generated code" do
+      expect { described_class.run(message.id, question) }
+        .to change(Glancer::CodeVersion, :count).by(1)
+    end
+
+    it "does not create a code_version when the result has no code" do
+      allow(Glancer::Workflow).to receive(:run).and_return(workflow_result.merge(code: nil))
+      expect { described_class.run(message.id, question) }
+        .not_to change(Glancer::CodeVersion, :count)
+    end
+
+    it "updates the chat title on the first user message" do
+      chat.messages.create!(role: :user, content: question)
+      described_class.run(message.id, question)
+      expect(chat.reload.title).to eq("User count")
+    end
+
+    it "does not update the chat title when multiple user messages exist" do
+      2.times { chat.messages.create!(role: :user, content: question) }
+      expect(Glancer::Workflow::LLM).not_to receive(:generate_title)
+      described_class.run(message.id, question)
+    end
+
+    context "when the workflow raises" do
+      before { allow(Glancer::Workflow).to receive(:run).and_raise(StandardError, "LLM down") }
+
+      it "marks the message as failed" do
+        described_class.run(message.id, question)
+        expect(message.reload.status).to eq("failed")
+      end
+
+      it "stores the error message as content" do
+        described_class.run(message.id, question)
+        expect(message.reload.content).to eq("LLM down")
+      end
+
+      it "marks the message as not successful" do
+        described_class.run(message.id, question)
+        expect(message.reload.successful).to be(false)
+      end
+    end
+
+    context "when both workflow and the rescue update raise" do
+      before do
+        allow(Glancer::Workflow).to receive(:run).and_raise(StandardError, "boom")
+        allow_any_instance_of(Glancer::Message).to receive(:update!).and_call_original
+        allow_any_instance_of(Glancer::Message).to receive(:update!)
+          .with(hash_including(status: :failed))
+          .and_raise(StandardError, "db gone")
+      end
+
+      it "does not propagate the secondary error" do
+        expect { described_class.run(message.id, question) }.not_to raise_error
+      end
+    end
+  end
+
+  # ── .call ─────────────────────────────────────────────────────────────────
+
+  describe ".call" do
+    it "returns a Thread" do
+      t = described_class.call(message.id, question)
+      t.join
+      expect(t).to be_a(Thread)
+    end
+
+    it "executes .run inside the thread" do
+      expect(described_class).to receive(:run).with(message.id, question)
+      described_class.call(message.id, question).join
+    end
+
+    it "does not raise when the thread encounters an error outside with_connection" do
+      msg_id = message.id # force lazy let evaluation before stubbing connection_pool
+      allow(ActiveRecord::Base).to receive(:connection_pool)
+        .and_raise(StandardError, "pool error")
+      expect { described_class.call(msg_id, question).join }.not_to raise_error
+    end
+  end
+end