glancer 1.0.0

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::SQLValidator do
+  before do
+    # Seed a schema embedding so the validator can find the "users" table.
+    Glancer::Embedding.create!(
+      content: "create_table users ...",
+      embedding: [],
+      source_type: "schema",
+      source_path: "db/schema.rb#users"
+    )
+    Glancer::Embedding.create!(
+      content: "create_table orders ...",
+      embedding: [],
+      source_type: "schema",
+      source_path: "db/schema.rb#orders"
+    )
+  end
+
+  # ── validate_tables_exist! ────────────────────────────────────────────────
+
+  describe ".validate_tables_exist!" do
+    it "does not raise when all tables in the SQL are indexed" do
+      sql = "SELECT * FROM users"
+      expect { described_class.validate_tables_exist!(sql) }.not_to raise_error
+    end
+
+    it "does not raise for a query referencing an indexed table via FROM" do
+      sql = "SELECT u.id FROM users u"
+      expect { described_class.validate_tables_exist!(sql) }.not_to raise_error
+    end
+
+    it "does not raise for a subquery referencing two indexed tables" do
+      sql = "SELECT * FROM orders WHERE user_id IN (SELECT id FROM users)"
+      expect { described_class.validate_tables_exist!(sql) }.not_to raise_error
+    end
+
+    it "raises Glancer::Error when a table is not indexed" do
+      sql = "SELECT * FROM missing_table"
+      expect { described_class.validate_tables_exist!(sql) }
+        .to raise_error(Glancer::Error, /missing_table/)
+    end
+
+    it "raises Glancer::Error wrapping the underlying message" do
+      sql = "SELECT * FROM ghost_table"
+      expect { described_class.validate_tables_exist!(sql) }
+        .to raise_error(Glancer::Error)
+    end
+
+    it "does not raise for system schema tables (sqlite_master)" do
+      sql = "SELECT * FROM sqlite_master"
+      expect { described_class.validate_tables_exist!(sql) }.not_to raise_error
+    end
+  end
+
+  # ── extract_table_names ───────────────────────────────────────────────────
+
+  describe ".extract_table_names" do
+    it "extracts a single table name" do
+      result = described_class.extract_table_names("SELECT * FROM users")
+      expect(result).to contain_exactly("users")
+    end
+
+    it "extracts the FROM table (JOIN tables are not captured by the FROM regex)" do
+      # extract_table_names only scans for 'from tablename' patterns.
+      # JOIN keyword tables are NOT extracted because they have no FROM before them.
+      sql = "SELECT * FROM orders JOIN users ON orders.user_id = users.id"
+      result = described_class.extract_table_names(sql)
+      expect(result).to include("orders")
+    end
+
+    it "extracts tables from multiple FROM clauses (e.g. subqueries)" do
+      sql = "SELECT * FROM orders WHERE user_id IN (SELECT id FROM users)"
+      result = described_class.extract_table_names(sql)
+      expect(result).to include("orders", "users")
+    end
+
+    it "extracts table names from subqueries" do
+      sql = "SELECT * FROM (SELECT id FROM products) sub"
+      result = described_class.extract_table_names(sql)
+      expect(result).to include("products")
+    end
+
+    it "is case-insensitive for the FROM keyword" do
+      result = described_class.extract_table_names("SELECT * from users")
+      expect(result).to include("users")
+    end
+
+    it "handles quoted table names by stripping quotes" do
+      result = described_class.extract_table_names('SELECT * FROM "users"')
+      expect(result).to include("users")
+    end
+
+    it "downcases table names" do
+      result = described_class.extract_table_names("SELECT * FROM Users")
+      expect(result).to include("users")
+    end
+
+    it "returns unique table names" do
+      sql = "SELECT * FROM users JOIN users u2 ON users.id = u2.id"
+      result = described_class.extract_table_names(sql)
+      expect(result.count("users")).to eq(1)
+    end
+  end
+
+  # ── system_table? ─────────────────────────────────────────────────────────
+
+  describe ".system_table?" do
+    it "returns true for sqlite_master when adapter is sqlite" do
+      expect(described_class.system_table?("sqlite_master")).to be(true)
+    end
+
+    it "returns false for a user table" do
+      expect(described_class.system_table?("orders")).to be(false)
+    end
+
+    it "returns true for a schema-qualified system table" do
+      Glancer.configuration.adapter = :postgres
+      expect(described_class.system_table?("information_schema.tables")).to be(true)
+    end
+
+    it "returns true for pg_catalog when adapter is postgres" do
+      Glancer.configuration.adapter = :postgres
+      expect(described_class.system_table?("pg_catalog")).to be(true)
+    end
+
+    it "returns true for information_schema when adapter is mysql2" do
+      Glancer.configuration.adapter = :mysql2
+      expect(described_class.system_table?("information_schema")).to be(true)
+    end
+
+    it "returns false for a user table with mysql2 adapter" do
+      Glancer.configuration.adapter = :mysql2
+      expect(described_class.system_table?("orders")).to be(false)
+    end
+
+    it "returns false for a user table with an unknown adapter" do
+      allow(Glancer.configuration).to receive(:resolved_adapter).and_return("unknown_db")
+      expect(described_class.system_table?("orders")).to be(false)
+    end
+  end
+
+  # ── indexed_schema_table_names ────────────────────────────────────────────
+
+  describe ".indexed_schema_table_names" do
+    it "returns table names from schema embeddings" do
+      result = described_class.indexed_schema_table_names
+      expect(result).to include("users", "orders")
+    end
+
+    it "returns an empty array when no schema embeddings exist" do
+      Glancer::Embedding.where(source_type: "schema").delete_all
+      expect(described_class.indexed_schema_table_names).to eq([])
+    end
+
+    it "ignores non-schema embeddings" do
+      Glancer::Embedding.create!(
+        content: "model content", embedding: [], source_type: "models", source_path: "user.rb"
+      )
+      result = described_class.indexed_schema_table_names
+      expect(result).not_to include(nil)
+    end
+  end
+end

data/spec/lib/glancer/workflow_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow do
+  # ── Common doubles ────────────────────────────────────────────────────────
+
+  let(:question) { "How many users are there?" }
+  let(:sql)      { "SELECT COUNT(*) AS cnt FROM users" }
+  let(:chat)     { Glancer::Chat.create!(title: "Test Chat") }
+
+  let(:embedding) do
+    Glancer::Embedding.create!(
+      content: "create_table users ...",
+      embedding: [0.1, 0.2, 0.3],
+      source_type: "schema",
+      source_path: "db/schema.rb#users"
+    ).tap do |e|
+      # Workflow.run calls e.score on each embedding from Retriever.search.
+      # Retriever.search attaches score via define_singleton_method; add it here too.
+      e.define_singleton_method(:score) { 1.3 }
+    end
+  end
+
+  let(:fake_embed_response) { double("EmbedResponse", vectors: [0.1, 0.2, 0.3]) }
+  let(:fake_sql_response)   { double("SqlResponse",   content: "```sql\n#{sql}\n```") }
+  let(:fake_chat_response)  { double("ChatResponse",  content: "There are 42 users.") }
+
+  let(:fake_llm_chat) do
+    double("Chat").tap do |c|
+      allow(c).to receive(:ask).and_return(fake_sql_response)
+      allow(c).to receive(:with_instructions).and_return(c)
+    end
+  end
+
+  let(:fake_humanize_chat) do
+    double("HumanizeChat").tap do |c|
+      allow(c).to receive(:ask).and_return(fake_chat_response)
+      allow(c).to receive(:with_instructions).and_return(c)
+    end
+  end
+
+  before do
+    embedding # ensure it is persisted
+
+    allow(RubyLLM).to receive(:embed).and_return(fake_embed_response)
+    allow(RubyLLM).to receive(:chat).and_return(fake_llm_chat)
+  end
+
+  # Helper to stub the humanized response separately
+  def stub_humanize_separately
+    call_count = 0
+    allow(RubyLLM).to receive(:chat) do
+      call_count += 1
+      call_count == 1 ? fake_llm_chat : fake_humanize_chat
+    end
+  end
+
+  # ── Cache hit ─────────────────────────────────────────────────────────────
+
+  describe ".run — cache hit" do
+    before do
+      Glancer::Workflow::Cache.write(question, {
+                                       question: question,
+                                       content: "Cached answer",
+                                       code: sql,
+                                       code_type: "sql",
+                                       successful: true
+                                     })
+    end
+
+    it "returns the cached result when cache: true (default)" do
+      result = described_class.run(chat.id, question, cache: true)
+      expect(result[:content]).to eq("Cached answer")
+    end
+
+    it "includes from_cache: true in the returned hash" do
+      result = described_class.run(chat.id, question, cache: true)
+      expect(result[:from_cache]).to be(true)
+    end
+
+    it "skips the LLM entirely when a cache hit is available" do
+      expect(RubyLLM).not_to receive(:chat)
+      described_class.run(chat.id, question, cache: true)
+    end
+
+    it "bypasses the cache when cache: false" do
+      # cache: false → LLM is called
+      expect(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return(sql)
+      allow(Glancer::Workflow::SQLValidator).to receive(:validate_tables_exist!)
+      allow(Glancer::Workflow::Executor).to receive(:execute).and_return([{ "cnt" => 42 }])
+      allow(Glancer::Workflow::LLM).to receive(:humanized_response).and_return("42 users")
+
+      result = described_class.run(chat.id, question, cache: false)
+      expect(result[:from_cache]).to be_nil
+    end
+  end
+
+  # ── Full happy path ───────────────────────────────────────────────────────
+
+  describe ".run — full pipeline" do
+    before do
+      # Seed the users table in the schema embeddings so validation passes
+      Glancer::Workflow::Cache.clear
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return("```sql\n#{sql}\n```")
+      allow(Glancer::Workflow::SQLValidator).to receive(:validate_tables_exist!)
+      allow(Glancer::Workflow::Executor).to receive(:execute).and_return([{ "cnt" => 42 }])
+      allow(Glancer::Workflow::LLM).to receive(:humanized_response).and_return("There are 42 users.")
+    end
+
+    it "returns a hash with :question" do
+      result = described_class.run(chat.id, question)
+      expect(result[:question]).to eq(question)
+    end
+
+    it "returns :successful true on success" do
+      result = described_class.run(chat.id, question)
+      expect(result[:successful]).to be(true)
+    end
+
+    it "returns :code with the extracted SQL" do
+      result = described_class.run(chat.id, question)
+      expect(result[:code]).to include("SELECT")
+    end
+
+    it "returns :content with the humanized response" do
+      result = described_class.run(chat.id, question)
+      expect(result[:content]).to eq("There are 42 users.")
+    end
+
+    it "returns :sources array from the embeddings" do
+      result = described_class.run(chat.id, question)
+      expect(result[:sources]).to be_an(Array)
+      expect(result[:sources].first).to have_key(:type)
+    end
+
+    it "writes the result to cache when cache: true" do
+      described_class.run(chat.id, question, cache: true)
+      cached = Glancer::Workflow::Cache.fetch(question)
+      expect(cached).not_to be_nil
+    end
+
+    it "does not write to cache when cache: false" do
+      described_class.run(chat.id, question, cache: false)
+      expect(Glancer::Workflow::Cache.fetch(question)).to be_nil
+    end
+  end
+
+  # ── Table validation failure ───────────────────────────────────────────────
+
+  describe ".run — table validation failure" do
+    before do
+      Glancer::Workflow::Cache.clear
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return(sql)
+      allow(Glancer::Workflow::SQLValidator)
+        .to receive(:validate_tables_exist!)
+        .and_raise(Glancer::Error, "Missing table(s) in indexed schema: users")
+      allow(Glancer::Workflow::LLM)
+        .to receive(:explain_missing_tables)
+        .and_return("The table 'users' was not found in the schema.")
+    end
+
+    it "returns :successful false" do
+      result = described_class.run(chat.id, question)
+      expect(result[:successful]).to be(false)
+    end
+
+    it "returns an explanation in :content" do
+      result = described_class.run(chat.id, question)
+      expect(result[:content]).to include("users")
+    end
+
+    it "includes the code that failed validation" do
+      result = described_class.run(chat.id, question)
+      expect(result[:code]).to be_a(String)
+    end
+  end
+
+  # ── Execution failure ─────────────────────────────────────────────────────
+
+  describe ".run — execution failure after retries" do
+    before do
+      Glancer::Workflow::Cache.clear
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return(sql)
+      allow(Glancer::Workflow::SQLValidator).to receive(:validate_tables_exist!)
+      allow(Glancer::Workflow::Executor).to receive(:execute).and_return(
+        { error: true, message: "no such table: users", last_code: sql }
+      )
+      allow(Glancer::Workflow::LLM)
+        .to receive(:explain_error)
+        .and_return("I couldn't process the query after 3 attempts.")
+    end
+
+    it "returns :successful false" do
+      result = described_class.run(chat.id, question)
+      expect(result[:successful]).to be(false)
+    end
+
+    it "returns the error explanation in :content" do
+      result = described_class.run(chat.id, question)
+      expect(result[:content]).to include("3 attempts")
+    end
+  end
+
+  # ── Sanitization blocks the pipeline ─────────────────────────────────────
+
+  describe ".run — SQL sanitizer blocks execution" do
+    before do
+      Glancer::Workflow::Cache.clear
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      # LLM returns a DROP statement (malicious)
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return("DROP TABLE users")
+    end
+
+    it "raises Glancer::Error (via the sanitizer)" do
+      expect { described_class.run(chat.id, question) }.to raise_error(Glancer::Error)
+    end
+  end
+
+  # ── chat not found ────────────────────────────────────────────────────────
+
+  describe ".run — chat not found" do
+    it "raises Glancer::Error wrapping the ActiveRecord error" do
+      expect { described_class.run(999_999, question) }.to raise_error(Glancer::Error)
+    end
+  end
+
+  # ── ActiveRecord mode ─────────────────────────────────────────────────────
+
+  describe ".run — activerecord pipeline" do
+    let(:ar_code) { "Glancer::Chat.count" }
+
+    before do
+      Glancer::Workflow::Cache.clear
+      Glancer.configuration.query_mode = :activerecord
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_ar_code).and_return("```ruby\n#{ar_code}\n```")
+      allow(Glancer::Workflow::ARExecutor).to receive(:execute).and_return([{ "result" => 0 }])
+      allow(Glancer::Workflow::LLM).to receive(:humanized_response).and_return("Zero chats.")
+    end
+
+    after { Glancer.configuration.query_mode = :sql }
+
+    it "returns :successful true" do
+      result = described_class.run(chat.id, question)
+      expect(result[:successful]).to be(true)
+    end
+
+    it "returns code_type 'activerecord'" do
+      result = described_class.run(chat.id, question)
+      expect(result[:code_type]).to eq("activerecord")
+    end
+
+    it "returns the humanized content" do
+      result = described_class.run(chat.id, question)
+      expect(result[:content]).to eq("Zero chats.")
+    end
+
+    it "returns :successful false and explanation when AR executor reports an error" do
+      allow(Glancer::Workflow::ARExecutor).to receive(:execute).and_return(
+        { error: true, message: "undefined constant", last_code: ar_code }
+      )
+      allow(Glancer::Workflow::LLM).to receive(:explain_error).and_return("I couldn't fix it.")
+      result = described_class.run(chat.id, question)
+      expect(result[:successful]).to be(false)
+      expect(result[:content]).to eq("I couldn't fix it.")
+    end
+  end
+
+  # ── enrich_question ───────────────────────────────────────────────────────
+
+  describe ".run — question enrichment enabled" do
+    before do
+      Glancer::Workflow::Cache.clear
+      Glancer.configuration.query_enrichment_enabled = true
+
+      allow(Glancer::Retriever).to receive(:search).and_return([embedding])
+      allow(Glancer::Workflow::Builder).to receive(:build_sql).and_return("```sql\n#{sql}\n```")
+      allow(Glancer::Workflow::SQLValidator).to receive(:validate_tables_exist!)
+      allow(Glancer::Workflow::Executor).to receive(:execute).and_return([{ "cnt" => 42 }])
+      allow(Glancer::Workflow::LLM).to receive(:humanized_response).and_return("42 users.")
+      allow(Glancer::Workflow::QueryEnricher).to receive(:known_table_names).and_return(["users"])
+      allow(Glancer::Workflow::QueryEnricher).to receive(:enrich).and_return("enriched: #{question}")
+    end
+
+    after { Glancer.configuration.query_enrichment_enabled = false }
+
+    it "stores enriched_question in the result" do
+      result = described_class.run(chat.id, question)
+      expect(result[:enriched_question]).to eq("enriched: #{question}")
+    end
+
+    it "falls back to the original question when enrichment raises" do
+      allow(Glancer::Workflow::QueryEnricher).to receive(:enrich).and_raise(StandardError, "LLM timeout")
+      result = described_class.run(chat.id, question)
+      expect(result[:enriched_question]).to eq(question)
+    end
+  end
+end

data/spec/models/glancer/audit_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Audit do
+  let(:valid_attrs) do
+    {
+      code: "SELECT 1 /*glancer,run_id:abc*/",
+      adapter: "sqlite",
+      run_id: SecureRandom.uuid,
+      executed_at: Time.current
+    }
+  end
+
+  subject(:audit) { described_class.new(valid_attrs) }
+
+  # ── Validations ───────────────────────────────────────────────────────────
+
+  describe "validations" do
+    it "is valid with all required attributes" do
+      expect(audit).to be_valid
+    end
+
+    it "is invalid without code" do
+      audit.code = nil
+      expect(audit).not_to be_valid
+      expect(audit.errors[:code]).to be_present
+    end
+
+    it "is invalid without adapter" do
+      audit.adapter = nil
+      expect(audit).not_to be_valid
+    end
+
+    it "is invalid without run_id" do
+      audit.run_id = nil
+      expect(audit).not_to be_valid
+    end
+
+    it "is invalid without executed_at" do
+      audit.executed_at = nil
+      expect(audit).not_to be_valid
+    end
+
+    it "enforces uniqueness of run_id" do
+      uuid = SecureRandom.uuid
+      described_class.create!(valid_attrs.merge(run_id: uuid))
+      duplicate = described_class.new(valid_attrs.merge(run_id: uuid))
+      expect(duplicate).not_to be_valid
+      expect(duplicate.errors[:run_id]).to be_present
+    end
+  end
+
+  # ── Associations ─────────────────────────────────────────────────────────
+
+  describe "associations" do
+    it "belongs_to message optionally" do
+      expect(audit).to be_valid # message_id is nil
+    end
+
+    it "links to a message when provided" do
+      chat = Glancer::Chat.create!(title: "C")
+      msg  = Glancer::Message.create!(chat: chat, role: "assistant", content: "x")
+      audit.message = msg
+      audit.save!
+      expect(audit.reload.message).to eq(msg)
+    end
+  end
+
+  # ── Persistence ───────────────────────────────────────────────────────────
+
+  describe "persistence" do
+    it "saves successfully with valid attributes" do
+      expect { described_class.create!(valid_attrs) }.to change(described_class, :count).by(1)
+    end
+
+    it "stores the question (optional)" do
+      a = described_class.create!(valid_attrs.merge(question: "How many users?"))
+      expect(a.reload.question).to eq("How many users?")
+    end
+  end
+end

data/spec/models/glancer/chat_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Chat do
+  subject(:chat) { described_class.new(title: "Test Chat") }
+
+  # ── Validations ───────────────────────────────────────────────────────────
+
+  describe "validations" do
+    it "is valid with a title" do
+      expect(chat).to be_valid
+    end
+
+    it "is invalid without a title" do
+      chat.title = nil
+      expect(chat).not_to be_valid
+      expect(chat.errors[:title]).to include("can't be blank")
+    end
+
+    it "is invalid with an empty title string" do
+      chat.title = ""
+      expect(chat).not_to be_valid
+    end
+  end
+
+  # ── Associations ─────────────────────────────────────────────────────────
+
+  describe "associations" do
+    let!(:saved_chat) { described_class.create!(title: "Chat") }
+
+    it "has many messages" do
+      msg = Glancer::Message.create!(chat: saved_chat, role: "user", content: "Hello")
+      expect(saved_chat.messages).to include(msg)
+    end
+
+    it "destroys associated messages when the chat is destroyed" do
+      Glancer::Message.create!(chat: saved_chat, role: "user", content: "Hello")
+      expect { saved_chat.destroy }.to change(Glancer::Message, :count).by(-1)
+    end
+  end
+
+  # ── Persistence ───────────────────────────────────────────────────────────
+
+  describe "persistence" do
+    it "can be saved" do
+      expect(chat.save).to be(true)
+    end
+
+    it "increments the count on create!" do
+      expect { described_class.create!(title: "New") }.to change(described_class, :count).by(1)
+    end
+
+    it "has timestamps after save" do
+      chat.save!
+      expect(chat.created_at).not_to be_nil
+      expect(chat.updated_at).not_to be_nil
+    end
+  end
+end

data/spec/models/glancer/code_version_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::CodeVersion do
+  let(:chat)    { Glancer::Chat.create!(title: "Chat") }
+  let(:message) { Glancer::Message.create!(chat: chat, role: "assistant", content: "result", code: "SELECT 1") }
+
+  subject(:code_version) { described_class.new(message: message, code: "SELECT 1", source: "generated") }
+
+  # ── Validations ───────────────────────────────────────────────────────────
+
+  describe "validations" do
+    it "is valid with all required attributes" do
+      expect(code_version).to be_valid
+    end
+
+    it "is invalid without code" do
+      code_version.code = nil
+      expect(code_version).not_to be_valid
+      expect(code_version.errors[:code]).to be_present
+    end
+
+    it "is invalid without source" do
+      code_version.source = nil
+      expect(code_version).not_to be_valid
+    end
+  end
+
+  # ── Enum: source ─────────────────────────────────────────────────────────
+
+  describe "source enum" do
+    it "accepts 'generated'" do
+      sv = described_class.create!(message: message, code: "SELECT 1", source: "generated")
+      expect(sv.generated?).to be(true)
+    end
+
+    it "accepts 'user_edited'" do
+      sv = described_class.create!(message: message, code: "SELECT 2", source: "user_edited")
+      expect(sv.user_edited?).to be(true)
+    end
+
+    it "raises on an invalid source" do
+      expect { described_class.create!(message: message, code: "SELECT 1", source: "unknown") }
+        .to raise_error(ArgumentError)
+    end
+  end
+
+  # ── Associations ─────────────────────────────────────────────────────────
+
+  describe "associations" do
+    it "belongs_to a message" do
+      sv = described_class.create!(message: message, code: "SELECT 1", source: "generated")
+      expect(sv.message).to eq(message)
+    end
+  end
+
+  # ── Persistence ───────────────────────────────────────────────────────────
+
+  describe "persistence" do
+    it "increments count on create!" do
+      expect { described_class.create!(message: message, code: "SELECT 1", source: "generated") }
+        .to change(described_class, :count).by(1)
+    end
+
+    it "stores the code content" do
+      sv = described_class.create!(message: message, code: "SELECT id FROM users", source: "generated")
+      expect(sv.reload.code).to eq("SELECT id FROM users")
+    end
+  end
+end