glancer 1.0.0

data/spec/lib/glancer/utils/logger_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+RSpec.describe Glancer::Utils::Logger do
+  describe ".with_debug_logs" do
+    it "temporarily sets log_verbosity to :debug and restores it" do
+      Glancer.configuration.log_verbosity = :none
+      described_class.with_debug_logs do
+        expect(Glancer.configuration.log_verbosity).to eq(:debug)
+      end
+      expect(Glancer.configuration.log_verbosity).to eq(:none)
+    end
+
+    it "restores the original verbosity even if the block raises" do
+      Glancer.configuration.log_verbosity = :info
+      expect do
+        described_class.with_debug_logs { raise "oops" }
+      end.to raise_error(RuntimeError)
+      expect(Glancer.configuration.log_verbosity).to eq(:info)
+    end
+
+    it "yields control to the caller's block" do
+      yielded = false
+      described_class.with_debug_logs { yielded = true }
+      expect(yielded).to be(true)
+    end
+  end
+
+  describe "log output to file" do
+    let(:log_file) { Tempfile.new(["glancer_test", ".log"]) }
+
+    after { log_file.unlink }
+
+    it "writes log lines to the configured output file" do
+      Glancer.configuration.log_output_path = log_file.path
+      Glancer.configuration.log_verbosity   = :info
+
+      described_class.info("TestTag", "hello from file logger")
+
+      content = File.read(log_file.path)
+      expect(content).to include("hello from file logger")
+    ensure
+      Glancer.configuration.log_output_path = nil
+    end
+  end
+
+  describe "verbosity filtering" do
+    before do
+      Glancer.configuration.log_verbosity = :none
+      Glancer.configuration.log_output_path = nil
+    end
+
+    it "suppresses info messages at :none verbosity" do
+      expect { described_class.info("T", "suppressed") }.not_to output.to_stdout
+    end
+
+    it "always outputs error messages regardless of verbosity" do
+      expect { described_class.error("T", "critical error") }.to output(/critical error/).to_stdout
+    end
+
+    it "always outputs warn messages regardless of verbosity" do
+      expect { described_class.warn("T", "a warning") }.to output(/a warning/).to_stdout
+    end
+
+    it "suppresses everything with :silent verbosity" do
+      Glancer.configuration.log_verbosity = :silent
+      expect { described_class.error("T", "silenced error") }.not_to output.to_stdout
+      expect { described_class.warn("T", "silenced warning") }.not_to output.to_stdout
+    end
+  end
+
+  describe "graceful degradation when configuration raises" do
+    it "falls back to :info verbosity when configuration is unavailable" do
+      Glancer.configuration.log_verbosity = :info
+      # Even with a mocked config that raises on log_verbosity, the logger shouldn't crash
+      original = Glancer.configuration
+      Glancer.configuration = nil
+      expect { described_class.warn("T", "safe call") }.not_to raise_error
+    ensure
+      Glancer.configuration = original
+    end
+  end
+end

data/spec/lib/glancer/utils/markdown_helper_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Utils::MarkdownHelper do
+  describe ".markdown_to_html" do
+    it "converts basic markdown headings to HTML" do
+      result = described_class.markdown_to_html("# Hello")
+      expect(result).to include("<h1>")
+      expect(result).to include("Hello")
+    end
+
+    it "converts bold markdown to <strong>" do
+      result = described_class.markdown_to_html("**bold text**")
+      expect(result).to include("<strong>")
+    end
+
+    it "converts a markdown paragraph" do
+      result = described_class.markdown_to_html("simple paragraph")
+      expect(result).to include("simple paragraph")
+    end
+
+    it "wraps markdown tables in .table-scroll-wrapper" do
+      md = "| col1 | col2 |\n|------|------|\n| a    | b    |"
+      result = described_class.markdown_to_html(md)
+      expect(result).to include("table-scroll-wrapper")
+      expect(result).to include("table-scroll-inner")
+      expect(result).to include("<table")
+    end
+
+    it "wraps multiple tables independently" do
+      md = "| a | b |\n|---|---|\n| 1 | 2 |\n\ntext\n\n| c | d |\n|---|---|\n| 3 | 4 |"
+      result = described_class.markdown_to_html(md)
+      expect(result.scan("table-scroll-wrapper").size).to eq(2)
+    end
+
+    it "returns a String" do
+      expect(described_class.markdown_to_html("hello")).to be_a(String)
+    end
+  end
+
+  describe ".highlight_mentions" do
+    it "leaves content inside fenced code blocks untouched" do
+      text = "```\n@users table here\n```"
+      result = described_class.highlight_mentions(text)
+      expect(result).to include("@users")
+      expect(result).not_to include("glancer-mention")
+    end
+
+    it "skips @mention when valid_set is provided and mention is not in it" do
+      result = described_class.highlight_mentions("check @unknown table", valid_tables: %w[users orders])
+      expect(result).to include("@unknown")
+      expect(result).not_to include("glancer-mention")
+    end
+
+    it "wraps a valid @mention in a link without schema_base" do
+      result = described_class.highlight_mentions("check @users table", valid_tables: %w[users])
+      expect(result).to include('class="glancer-mention"')
+      expect(result).to include("@users")
+      expect(result).to include('href="#"')
+    end
+
+    it "wraps a valid @mention in a link with schema_base" do
+      result = described_class.highlight_mentions("see @orders", schema_base: "/glancer", valid_tables: %w[orders])
+      expect(result).to include('href="/glancer?table=orders"')
+      expect(result).to include('target="_blank"')
+    end
+  end
+
+  describe ".extract_sql_from_markdown" do
+    it "extracts SQL from a ```sql...``` fenced block" do
+      markdown = "Some text\n```sql\nSELECT 1\n```\nMore text"
+      expect(described_class.extract_sql_from_markdown(markdown)).to eq("SELECT 1")
+    end
+
+    it "returns empty string when no sql block is present" do
+      expect(described_class.extract_sql_from_markdown("no code here")).to eq("")
+    end
+
+    it "returns empty string for a plain ``` block without sql hint" do
+      markdown = "```\nSELECT 1\n```"
+      expect(described_class.extract_sql_from_markdown(markdown)).to eq("")
+    end
+
+    it "handles multi-line SQL correctly" do
+      markdown = "```sql\nSELECT id,\n  name\nFROM users\n```"
+      result = described_class.extract_sql_from_markdown(markdown)
+      expect(result).to include("SELECT id,")
+      expect(result).to include("FROM users")
+    end
+  end
+end

data/spec/lib/glancer/utils/result_formatter_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Utils::ResultFormatter do
+  describe ".normalize" do
+    context "when rows is empty" do
+      it "returns the empty array as-is" do
+        expect(described_class.normalize([])).to eq([])
+      end
+    end
+
+    context "when all rows have the same keys" do
+      let(:rows) do
+        [
+          { "id" => 1, "name" => "Alice" },
+          { "id" => 2, "name" => "Bob" },
+          { "id" => 3, "name" => "Carol" }
+        ]
+      end
+
+      it "pivots to a hash of key => [values...]" do
+        result = described_class.normalize(rows)
+        expect(result).to be_a(Hash)
+        expect(result["id"]).to eq([1, 2, 3])
+        expect(result["name"]).to eq(%w[Alice Bob Carol])
+      end
+
+      it "preserves all original keys" do
+        result = described_class.normalize(rows)
+        expect(result.keys).to contain_exactly("id", "name")
+      end
+    end
+
+    context "when rows have different keys" do
+      let(:rows) do
+        [
+          { "id" => 1, "name" => "Alice" },
+          { "id" => 2, "email" => "bob@example.com" }
+        ]
+      end
+
+      it "returns the rows array as-is" do
+        result = described_class.normalize(rows)
+        expect(result).to eq(rows)
+      end
+    end
+
+    context "with a single-row result set" do
+      let(:rows) { [{ "count" => 42 }] }
+
+      it "pivots to { 'count' => [42] }" do
+        result = described_class.normalize(rows)
+        expect(result).to eq({ "count" => [42] })
+      end
+    end
+
+    context "with symbol keys" do
+      let(:rows) do
+        [
+          { id: 1, score: 9.5 },
+          { id: 2, score: 7.3 }
+        ]
+      end
+
+      it "pivots correctly using symbol keys" do
+        result = described_class.normalize(rows)
+        expect(result[:id]).to eq([1, 2])
+        expect(result[:score]).to eq([9.5, 7.3])
+      end
+    end
+  end
+end

data/spec/lib/glancer/utils/table_stats_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Utils::TableStats do
+  describe ".count_for" do
+    context "when the table exists and is valid" do
+      it "returns the row count" do
+        Glancer::Chat.create!(title: "A")
+        Glancer::Chat.create!(title: "B")
+        expect(described_class.count_for("glancer_chats")).to eq(2)
+      end
+
+      it "returns 0 for an empty table" do
+        expect(described_class.count_for("glancer_chats")).to eq(0)
+      end
+    end
+
+    context "when the table name is invalid" do
+      it "returns -1 for a table not in the DB" do
+        expect(described_class.count_for("nonexistent_xyz_table")).to eq(-1)
+      end
+    end
+
+    context "when the DB query fails" do
+      it "returns -1 and logs a warning" do
+        allow(Glancer::Configuration).to receive(:valid_table_name?).and_return(true)
+        allow(ActiveRecord::Base.connection).to receive(:select_value)
+          .and_raise(StandardError, "DB down")
+        expect(described_class.count_for("glancer_chats")).to eq(-1)
+      end
+    end
+  end
+end

data/spec/lib/glancer/utils/transaction_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Utils::Transaction do
+  describe ".make" do
+    it "yields the connection to the block" do
+      yielded = nil
+      described_class.make { |conn| yielded = conn }
+      expect(yielded).not_to be_nil
+    end
+
+    it "returns the result of the block" do
+      result = described_class.make { |_conn| 42 }
+      expect(result).to eq(42)
+    end
+
+    it "re-raises standard errors from the block" do
+      expect { described_class.make { raise StandardError, "boom" } }
+        .to raise_error(StandardError, "boom")
+    end
+
+    it "logs a warning when connection is still open after transaction" do
+      conn = ActiveRecord::Base.connection
+      allow(conn).to receive(:transaction_open?).and_return(true)
+
+      expect(Glancer::Utils::Logger).to receive(:warn).with("Utils::Transaction", /not closed/)
+      described_class.make { |_conn| }
+    end
+  end
+
+  describe ".read_only_connection" do
+    context "when read_only_db is nil" do
+      it "returns nil" do
+        Glancer.configuration.read_only_db = nil
+        expect(described_class.read_only_connection).to be_nil
+      end
+    end
+
+    context "when read_only_db is set" do
+      before { Glancer.configuration.read_only_db = "sqlite3::memory:" }
+
+      after { Glancer.configuration.read_only_db = nil }
+
+      it "sets @used_read_only to true and returns the connection" do
+        fake_pool = double("pool", connection: ActiveRecord::Base.connection)
+        allow(ActiveRecord::Base).to receive(:establish_connection).and_return(fake_pool)
+        conn = described_class.read_only_connection
+        expect(conn).not_to be_nil
+      end
+
+      it "raises Glancer::Error when establish_connection fails" do
+        allow(ActiveRecord::Base).to receive(:establish_connection).and_raise(StandardError, "connection refused")
+        expect { described_class.read_only_connection }
+          .to raise_error(Glancer::Error, /Read-only DB connection failed/)
+      end
+    end
+  end
+
+  describe ".connection_config_name" do
+    it "returns the pool db_config name for a real connection" do
+      conn = ActiveRecord::Base.connection
+      result = described_class.connection_config_name(conn)
+      expect(result).to be_a(String)
+    end
+
+    it "returns 'unknown' when pool info is unavailable" do
+      fake_conn = double("connection")
+      allow(fake_conn).to receive(:pool).and_raise(StandardError, "no pool")
+      expect(described_class.connection_config_name(fake_conn)).to eq("unknown")
+    end
+  end
+end

data/spec/lib/glancer/workflow/ar_executor_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::ARExecutor do
+  # ── normalize ─────────────────────────────────────────────────────────────
+
+  describe ".normalize" do
+    it "converts an ActiveRecord::Relation to an array of attribute hashes" do
+      chat = Glancer::Chat.create!(title: "Test")
+      relation = Glancer::Chat.where(id: chat.id)
+      result = described_class.normalize(relation)
+      expect(result).to be_an(Array)
+      expect(result.first).to include("id" => chat.id, "title" => "Test")
+    end
+
+    it "converts an Array of AR objects to attribute hashes" do
+      chat = Glancer::Chat.create!(title: "AR")
+      result = described_class.normalize([chat])
+      expect(result).to be_an(Array)
+      expect(result.first).to include("title" => "AR")
+    end
+
+    it "wraps a Numeric in a result hash" do
+      result = described_class.normalize(42)
+      expect(result).to eq([{ "result" => 42 }])
+    end
+
+    it "wraps a String in a result hash" do
+      result = described_class.normalize("hello")
+      expect(result).to eq([{ "result" => "hello" }])
+    end
+
+    it "normalizes an all-numeric hash (group/count result) to one row per entry" do
+      result = described_class.normalize({ "05/2026" => 6, "04/2026" => 2 })
+      expect(result).to contain_exactly(
+        { "key" => "05/2026", "value" => 6 },
+        { "key" => "04/2026", "value" => 2 }
+      )
+    end
+
+    it "keeps a mixed-type hash as a single attribute row" do
+      result = described_class.normalize({ "name" => "Alice", "age" => 30 })
+      expect(result).to eq([{ "name" => "Alice", "age" => 30 }])
+    end
+
+    it "returns [] for nil" do
+      expect(described_class.normalize(nil)).to eq([])
+    end
+
+    it "handles an Array of primitives" do
+      result = described_class.normalize(%w[a b])
+      expect(result).to eq([{ "value" => "a" }, { "value" => "b" }])
+    end
+
+    it "stringifies keys of hashes inside an array" do
+      result = described_class.normalize([{ count: 3 }])
+      expect(result.first).to include("count" => 3)
+    end
+
+    it "wraps an unknown object (no attributes) in a result/inspect hash" do
+      obj = Object.new
+      result = described_class.normalize(obj)
+      expect(result).to eq([{ "result" => obj.inspect }])
+    end
+
+    it "returns a single-row attribute hash for an AR object with respond_to?(:attributes)" do
+      chat = Glancer::Chat.create!(title: "Single")
+      result = described_class.normalize(chat)
+      expect(result).to be_an(Array)
+      expect(result.first).to include("title" => "Single")
+    end
+
+    it "drops columns where every row has nil value" do
+      rows = [{ "name" => "Alice", "phantom" => nil }, { "name" => "Bob", "phantom" => nil }]
+      result = described_class.drop_all_nil_columns(rows)
+      expect(result.first.keys).not_to include("phantom")
+      expect(result.first).to include("name" => "Alice")
+    end
+
+    it "keeps columns where at least one row has a non-nil value" do
+      rows = [{ "name" => "Alice", "age" => nil }, { "name" => "Bob", "age" => 30 }]
+      result = described_class.drop_all_nil_columns(rows)
+      expect(result.first.keys).to include("age")
+    end
+  end
+
+  # ── execute ───────────────────────────────────────────────────────────────
+
+  describe ".execute" do
+    let(:safe_code) { "Glancer::Chat.count" }
+
+    it "returns an array of result hashes for a successful expression" do
+      result = described_class.execute(safe_code)
+      expect(result).to be_an(Array)
+      expect(result.first).to include("result" => 0)
+    end
+
+    it "creates a Glancer::Audit record after success" do
+      expect { described_class.execute(safe_code, original_question: "How many chats?") }
+        .to change(Glancer::Audit, :count).by(1)
+    end
+
+    it "stores the Ruby expression in the audit code column" do
+      described_class.execute(safe_code)
+      expect(Glancer::Audit.last.code).to eq(safe_code)
+    end
+
+    it "stores the run_id in the audit record" do
+      described_class.execute(safe_code)
+      expect(Glancer::Audit.last.run_id).to be_a(String).and be_present
+    end
+
+    it "stores original_question in the audit record" do
+      described_class.execute(safe_code, original_question: "count chats")
+      expect(Glancer::Audit.last.question).to eq("count chats")
+    end
+
+    it "rolls back the transaction — side effects inside eval are reverted" do
+      # The AR expression itself is read-only, so this just verifies the mechanism works
+      result = described_class.execute("Glancer::Chat.count")
+      expect(result).to be_an(Array)
+    end
+  end
+
+  # ── retry on failure ──────────────────────────────────────────────────────
+
+  describe ".execute — retry with Builder.fix_ar_code" do
+    let(:bad_code)   { "NonExistentModel.all" }
+    let(:fixed_code) { "Glancer::Chat.count" }
+
+    before do
+      allow(Glancer::Workflow::Builder).to receive(:fix_ar_code).and_return(fixed_code)
+    end
+
+    it "calls Builder.fix_ar_code on failure and retries" do
+      expect(Glancer::Workflow::Builder).to receive(:fix_ar_code).at_least(:once).and_return(fixed_code)
+      described_class.execute(bad_code)
+    end
+
+    it "returns the result from the fixed code" do
+      result = described_class.execute(bad_code)
+      expect(result).to be_an(Array)
+    end
+
+    it "returns an error hash after 3 failed attempts" do
+      allow(Glancer::Workflow::Builder).to receive(:fix_ar_code).and_return(bad_code)
+      result = described_class.execute(bad_code, attempt: 1)
+      expect(result).to be_a(Hash)
+      expect(result[:error]).to be(true)
+      expect(result[:message]).to be_a(String)
+      expect(result[:last_code]).to eq(bad_code)
+    end
+  end
+end

data/spec/lib/glancer/workflow/ar_extractor_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::ARExtractor do
+  describe ".extract" do
+    it "extracts code from a ```ruby block" do
+      text = "```ruby\nUser.where(active: true).count\n```"
+      expect(described_class.extract(text)).to eq("User.where(active: true).count")
+    end
+
+    it "extracts code from a plain ``` block" do
+      text = "```\nOrder.joins(:items).count\n```"
+      expect(described_class.extract(text)).to eq("Order.joins(:items).count")
+    end
+
+    it "strips surrounding whitespace from the code block content" do
+      text = "```ruby\n  User.all  \n```"
+      expect(described_class.extract(text)).to eq("User.all")
+    end
+
+    it "returns the raw text when there is no code block" do
+      text = "User.count"
+      expect(described_class.extract(text)).to eq("User.count")
+    end
+
+    it "strips the raw text when there is no code block" do
+      text = "  User.count  "
+      expect(described_class.extract(text)).to eq("User.count")
+    end
+
+    it "handles multi-line expressions inside a code block" do
+      text = "```ruby\nUser\n  .where(active: true)\n  .order(:name)\n```"
+      expect(described_class.extract(text)).to include("User")
+      expect(described_class.extract(text)).to include(".where(active: true)")
+    end
+
+    it "raises Glancer::Error if extraction fails unexpectedly" do
+      allow(described_class).to receive(:extract).and_call_original
+      # normal path; just verify it doesn't raise on valid input
+      expect { described_class.extract("User.count") }.not_to raise_error
+    end
+
+    it "raises Glancer::Error wrapping an unexpected StandardError" do
+      allow(Glancer::Utils::Logger).to receive(:info).and_raise(StandardError, "unexpected")
+      expect { described_class.extract("User.count") }
+        .to raise_error(Glancer::Error, /AR code extraction failed/)
+    end
+  end
+end

data/spec/lib/glancer/workflow/ar_prompt_builder_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::ARPromptBuilder do
+  let(:chat)       { Glancer::Chat.create!(title: "Chat") }
+  let(:embeddings) { [] }
+  let(:question)   { "How many active users?" }
+
+  # ── .custom_instructions_block ────────────────────────────────────────────
+
+  describe ".custom_instructions_block" do
+    it "returns an empty string when no custom instructions are set" do
+      expect(described_class.custom_instructions_block).to eq("")
+    end
+
+    it "returns the instructions wrapped in a header when set" do
+      Glancer::Setting.set("custom_instructions", "Always respond in Portuguese.")
+      result = described_class.custom_instructions_block
+      expect(result).to include("Always respond in Portuguese.")
+      expect(result).to include("CUSTOM RULES")
+    end
+
+    it "returns an empty string when Setting.get raises" do
+      allow(Glancer::Setting).to receive(:get).and_raise(StandardError, "db error")
+      expect(described_class.custom_instructions_block).to eq("")
+    end
+  end
+
+  # ── .call ─────────────────────────────────────────────────────────────────
+
+  describe ".call" do
+    it "returns a String" do
+      result = described_class.call(question, embeddings)
+      expect(result).to be_a(String)
+    end
+
+    it "includes the question in the prompt" do
+      result = described_class.call(question, embeddings)
+      expect(result).to include(question)
+    end
+
+    it "includes the schema context from embeddings" do
+      embedding = Glancer::Embedding.new(content: "create_table users ...")
+      result = described_class.call(question, [embedding])
+      expect(result).to include("create_table users")
+    end
+
+    it "includes user history messages" do
+      msg = Glancer::Message.create!(chat: chat, role: :user, content: "prior question")
+      result = described_class.call(question, embeddings, history: [msg])
+      expect(result).to include("prior question")
+    end
+
+    it "formats assistant messages with code in history" do
+      msg = Glancer::Message.create!(
+        chat: chat, role: :assistant, content: "There are 5.",
+        code: "User.count", code_type: "activerecord"
+      )
+      result = described_class.call(question, embeddings, history: [msg])
+      expect(result).to include("User.count")
+      expect(result).to include("There are 5.")
+    end
+
+    it "formats assistant messages without code in history" do
+      msg = Glancer::Message.create!(
+        chat: chat, role: :assistant, content: "I couldn't process that.", code: nil
+      )
+      result = described_class.call(question, embeddings, history: [msg])
+      expect(result).to include("I couldn't process that.")
+    end
+
+    it "raises Glancer::Error when building fails" do
+      allow(Time).to receive(:current).and_raise(StandardError, "time error")
+      expect { described_class.call(question, embeddings) }
+        .to raise_error(Glancer::Error, /AR prompt construction failed/)
+    end
+  end
+end