glancer 1.0.0

data/spec/lib/glancer/indexer/schema_indexer_spec.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Indexer::SchemaIndexer do
+  let(:schema_path) { Pathname.new("/fake/root/db/schema.rb") }
+  let(:schema_content) do
+    # NOTE: The schema split regex is /^  create_table / (with 2 leading spaces).
+    # Indentation must NOT be stripped (do not use <<~RUBY — use <<RUBY or
+    # explicit leading spaces so each create_table block is indented correctly).
+    "ActiveRecord::Schema[7.0].define(version: 2024_01_01) do\n" \
+    "  create_table \"users\", force: :cascade do |t|\n" \
+    "    t.string \"name\"\n" \
+    "    t.string \"email\"\n" \
+    "    t.timestamps\n" \
+    "  end\n\n" \
+    "  create_table \"orders\", force: :cascade do |t|\n" \
+    "    t.integer \"user_id\"\n" \
+    "    t.decimal \"total\"\n" \
+    "    t.timestamps\n" \
+    "  end\n\n" \
+    "  add_foreign_key \"orders\", \"users\", column: \"user_id\"\n" \
+    "end\n"
+  end
+
+  let(:inflections_path) { Pathname.new("/fake/root/config/initializers/inflections.rb") }
+
+  before do
+    allow(Rails).to receive(:root).and_return(Pathname.new("/fake/root"))
+    allow(Rails).to receive(:application).and_return(double("app", eager_load!: nil))
+    allow(File).to receive(:exist?).with(schema_path).and_return(true)
+    allow(File).to receive(:exist?).with(inflections_path).and_return(false)
+    allow(File).to receive(:read).with(schema_path).and_return(schema_content)
+    # Prevent AR descendants from polluting results
+    allow(ActiveRecord::Base).to receive(:descendants).and_return([])
+  end
+
+  # ── index! ────────────────────────────────────────────────────────────────
+
+  describe ".index!" do
+    it "returns an array of chunk hashes" do
+      result = described_class.index!
+      expect(result).to be_an(Array)
+      expect(result).not_to be_empty
+    end
+
+    it "includes a chunk for each recognized create_table block" do
+      result = described_class.index!
+      table_chunks = result.select do |c|
+        c[:source_type] == "schema" &&
+          !c[:source_path].end_with?("#foreign_keys") &&
+          (c[:source_path].include?("#users") || c[:source_path].include?("#orders"))
+      end
+      # Schema has 2 tables (users, orders).
+      expect(table_chunks.size).to eq(2)
+    end
+
+    it "sets source_type to 'schema' on all chunks" do
+      result = described_class.index!
+      expect(result.map { |c| c[:source_type] }).to all(eq("schema"))
+    end
+
+    it "includes the table name in the source_path" do
+      result = described_class.index!
+      paths  = result.map { |c| c[:source_path] }
+      expect(paths.any? { |p| p.include?("#users") }).to be(true)
+      expect(paths.any? { |p| p.include?("#orders") }).to be(true)
+    end
+
+    it "includes a foreign keys chunk when add_foreign_key lines exist" do
+      result = described_class.index!
+      fk_chunk = result.find { |c| c[:source_path].to_s.end_with?("#foreign_keys") }
+      expect(fk_chunk).not_to be_nil
+    end
+
+    it "includes the FK relationship in the foreign keys chunk content" do
+      result   = described_class.index!
+      fk_chunk = result.find { |c| c[:source_path].to_s.end_with?("#foreign_keys") }
+      expect(fk_chunk[:content]).to include("orders")
+      expect(fk_chunk[:content]).to include("users")
+    end
+
+    it "returns [] when the schema file does not exist" do
+      allow(File).to receive(:exist?).and_return(false)
+      expect(described_class.index!).to eq([])
+    end
+
+    it "silently skips chunks whose table name cannot be extracted" do
+      # Use {nonstandard} so extract_table_name regex cannot match [a-zA-Z0-9_]+
+      schema_without_name = "  create_table {nonstandard} do |t|\n    t.string :foo\n  end\n"
+      allow(File).to receive(:read).with(schema_path).and_return(schema_without_name)
+      result = described_class.index!
+      table_chunks = result.reject { |c| c[:source_path].to_s.end_with?("#foreign_keys") }
+      expect(table_chunks).to be_empty
+    end
+
+    it "raises Glancer::Error when File.read raises" do
+      allow(File).to receive(:read).and_raise(IOError, "disk failure")
+      expect { described_class.index! }.to raise_error(Glancer::Error, /Schema indexing failed/)
+    end
+  end
+
+  # ── split_into_chunks ─────────────────────────────────────────────────────
+
+  describe ".split_into_chunks" do
+    it "splits a schema string into create_table chunks" do
+      # schema_content has 2 tables; the preamble before the first `  create_table`
+      # is a separate (non-table) chunk — we only care that there are >= 2 table chunks.
+      chunks = described_class.split_into_chunks(schema_content)
+      table_chunks = chunks.select { |c| c =~ /create_table "(users|orders)"/ }
+      expect(table_chunks.size).to eq(2)
+    end
+
+    it "each chunk starts with 'create_table'" do
+      chunks = described_class.split_into_chunks(schema_content)
+      chunks.each { |c| expect(c).to start_with("create_table") }
+    end
+
+    it "returns a single non-table chunk for schema text with no create_table blocks" do
+      # The split produces one element (the whole text prepended with 'create_table')
+      # when no `  create_table ` lines are present.
+      result = described_class.split_into_chunks("# empty schema\n")
+      # All chunks start with create_table, but none match a real table name
+      expect(result.any? { |c| c =~ /create_table "/ }).to be(false)
+    end
+  end
+
+  # ── extract_table_name ────────────────────────────────────────────────────
+
+  describe ".extract_table_name" do
+    it "extracts a double-quoted table name" do
+      chunk = 'create_table "users", force: :cascade do |t|'
+      expect(described_class.extract_table_name(chunk)).to eq("users")
+    end
+
+    it "extracts a single-quoted table name" do
+      chunk = "create_table 'products' do |t|"
+      expect(described_class.extract_table_name(chunk)).to eq("products")
+    end
+
+    it "extracts an unquoted table name" do
+      chunk = "create_table orders do |t|"
+      expect(described_class.extract_table_name(chunk)).to eq("orders")
+    end
+
+    it "returns nil for a chunk that has no create_table pattern" do
+      expect(described_class.extract_table_name("add_index :users, :email")).to be_nil
+    end
+  end
+
+  # ── extract_foreign_keys ──────────────────────────────────────────────────
+
+  describe ".extract_foreign_keys" do
+    it "returns nil when no add_foreign_key lines are present" do
+      text = "create_table users do; end\n"
+      expect(described_class.extract_foreign_keys(text, schema_path)).to be_nil
+    end
+
+    it "returns a hash with content, source_type, and source_path" do
+      result = described_class.extract_foreign_keys(schema_content, schema_path)
+      expect(result).to be_a(Hash)
+      expect(result[:source_type]).to eq("schema")
+      expect(result[:source_path].to_s).to include("#foreign_keys")
+    end
+
+    it "describes the relationship in the content" do
+      result = described_class.extract_foreign_keys(schema_content, schema_path)
+      expect(result[:content]).to include("orders.user_id → users.id")
+    end
+
+    it "infers the column name when no explicit column is given" do
+      text = <<~RUBY
+        add_foreign_key "order_items", "orders"
+      RUBY
+      result = described_class.extract_foreign_keys(text, schema_path)
+      expect(result[:content]).to include("order_items.order_id → orders.id")
+    end
+  end
+
+  # ── eager_load_models! ────────────────────────────────────────────────────
+
+  describe ".eager_load_models!" do
+    it "calls Rails.application.eager_load!" do
+      app = double("app")
+      allow(Rails).to receive(:application).and_return(app)
+      expect(app).to receive(:eager_load!)
+      described_class.eager_load_models!
+    end
+
+    it "does not raise when eager_load! raises" do
+      allow(Rails).to receive(:application).and_return(double("app", eager_load!: nil).tap do |a|
+        allow(a).to receive(:eager_load!).and_raise(StandardError, "boom")
+      end)
+      expect { described_class.eager_load_models! }.not_to raise_error
+    end
+  end
+
+  # ── find_model_for_table ──────────────────────────────────────────────────
+
+  describe ".find_model_for_table" do
+    let(:fake_model) do
+      Class.new(ActiveRecord::Base) do
+        def self.name = "FakeUser"
+        def self.table_name = "users"
+        def self.abstract_class? = false
+      end
+    end
+
+    it "returns nil when no descendants match" do
+      allow(ActiveRecord::Base).to receive(:descendants).and_return([])
+      expect(described_class.find_model_for_table("users")).to be_nil
+    end
+
+    it "returns the model whose table_name matches" do
+      allow(ActiveRecord::Base).to receive(:descendants).and_return([fake_model])
+      expect(described_class.find_model_for_table("users")).to eq(fake_model)
+    end
+
+    it "excludes Glancer-namespaced models" do
+      glancer_model = Class.new(ActiveRecord::Base) do
+        def self.name = "Glancer::Embedding"
+        def self.table_name = "users"
+        def self.abstract_class? = false
+      end
+      allow(ActiveRecord::Base).to receive(:descendants).and_return([glancer_model])
+      expect(described_class.find_model_for_table("users")).to be_nil
+    end
+
+    it "returns nil when descendants raises" do
+      allow(ActiveRecord::Base).to receive(:descendants).and_raise(StandardError, "fail")
+      expect(described_class.find_model_for_table("users")).to be_nil
+    end
+  end
+
+  # ── model_associations_block ──────────────────────────────────────────────
+
+  describe ".model_associations_block" do
+    it "returns empty string when no model found for table" do
+      allow(described_class).to receive(:find_model_for_table).and_return(nil)
+      expect(described_class.model_associations_block("users")).to eq("")
+    end
+
+    it "returns empty string when model has no associations" do
+      model = Class.new(ActiveRecord::Base) do
+        def self.name = "FakeUser"
+        def self.reflect_on_all_associations = []
+      end
+      allow(described_class).to receive(:find_model_for_table).and_return(model)
+      expect(described_class.model_associations_block("users")).to eq("")
+    end
+
+    it "returns a formatted associations block when associations exist" do
+      assoc = double("assoc",
+                     macro: :has_many,
+                     name: :orders,
+                     class_name: "Order",
+                     foreign_key: "user_id",
+                     options: {})
+      model = double("FakeUser", name: "FakeUser", reflect_on_all_associations: [assoc])
+      allow(described_class).to receive(:find_model_for_table).and_return(model)
+      result = described_class.model_associations_block("users")
+      expect(result).to include("ActiveRecord Associations (FakeUser)")
+      expect(result).to include("has_many :orders")
+    end
+  end
+
+  # ── format_association ────────────────────────────────────────────────────
+
+  describe ".format_association" do
+    def make_assoc(macro:, name:, class_name:, foreign_key:, options: {})
+      double("assoc", macro: macro, name: name, class_name: class_name,
+                      foreign_key: foreign_key, options: options)
+    end
+
+    it "formats a simple belongs_to" do
+      assoc = make_assoc(macro: :belongs_to, name: :user, class_name: "User", foreign_key: "user_id")
+      result = described_class.format_association(assoc)
+      expect(result).to include("belongs_to :user")
+      expect(result).to include('class_name: "User"')
+      expect(result).to include('foreign_key: "user_id"')
+    end
+
+    it "includes through option when present" do
+      assoc = make_assoc(macro: :has_many, name: :products, class_name: "Product",
+                         foreign_key: "id", options: { through: :line_items })
+      result = described_class.format_association(assoc)
+      expect(result).to include("through: :line_items")
+    end
+
+    it "includes polymorphic: true when set" do
+      assoc = make_assoc(macro: :belongs_to, name: :imageable, class_name: "Imageable",
+                         foreign_key: "imageable_id", options: { polymorphic: true })
+      result = described_class.format_association(assoc)
+      expect(result).to include("polymorphic: true")
+    end
+
+    it "includes dependent option when present" do
+      assoc = make_assoc(macro: :has_many, name: :posts, class_name: "Post",
+                         foreign_key: "user_id", options: { dependent: :destroy })
+      result = described_class.format_association(assoc)
+      expect(result).to include("dependent: :destroy")
+    end
+
+    it "silently skips an association that raises during formatting" do
+      bad_assoc = double("assoc")
+      allow(bad_assoc).to receive(:macro).and_raise(StandardError, "broken")
+      good_assoc = make_assoc(macro: :has_many, name: :orders, class_name: "Order", foreign_key: "user_id")
+      model = double("Model", name: "User", reflect_on_all_associations: [bad_assoc, good_assoc])
+      allow(described_class).to receive(:find_model_for_table).and_return(model)
+      result = described_class.model_associations_block("users")
+      expect(result).to include("has_many :orders")
+    end
+  end
+
+  # ── extract_inflections ───────────────────────────────────────────────────
+
+  describe ".extract_inflections" do
+    it "returns nil when inflections file does not exist" do
+      allow(File).to receive(:exist?).with(inflections_path).and_return(false)
+      expect(described_class.extract_inflections).to be_nil
+    end
+
+    it "returns nil when file exists but has no inflect.* rules" do
+      allow(File).to receive(:exist?).with(inflections_path).and_return(true)
+      allow(File).to receive(:read).with(inflections_path).and_return("# empty\n")
+      expect(described_class.extract_inflections).to be_nil
+    end
+
+    it "returns a chunk hash when inflect rules are present" do
+      raw = "ActiveSupport::Inflector.inflections(:en) do |inflect|\n  inflect.irregular 'person', 'people'\nend\n"
+      allow(File).to receive(:exist?).with(inflections_path).and_return(true)
+      allow(File).to receive(:read).with(inflections_path).and_return(raw)
+      result = described_class.extract_inflections
+      expect(result).to be_a(Hash)
+      expect(result[:source_type]).to eq("schema")
+      expect(result[:content]).to include("Custom Rails Inflections")
+      expect(result[:content]).to include("inflect.irregular")
+    end
+
+    it "returns nil when File.read raises" do
+      allow(File).to receive(:exist?).with(inflections_path).and_return(true)
+      allow(File).to receive(:read).with(inflections_path).and_raise(IOError, "no read")
+      expect(described_class.extract_inflections).to be_nil
+    end
+  end
+
+  # ── index! enrichment ─────────────────────────────────────────────────────
+
+  describe ".index! with associations and inflections" do
+    it "appends associations block to table chunks when a model is found" do
+      assoc = double("assoc", macro: :has_many, name: :orders, class_name: "Order",
+                              foreign_key: "user_id", options: {})
+      model = double("User", name: "User", reflect_on_all_associations: [assoc])
+      allow(described_class).to receive(:find_model_for_table).and_return(nil)
+      allow(described_class).to receive(:find_model_for_table).with("users").and_return(model)
+
+      result = described_class.index!
+      users_chunk = result.find { |c| c[:source_path].to_s.include?("#users") }
+      expect(users_chunk[:content]).to include("ActiveRecord Associations (User)")
+    end
+
+    it "appends inflections chunk when inflections file contains rules" do
+      raw = "ActiveSupport::Inflector.inflections(:en) do |inflect|\n  inflect.irregular 'ox', 'oxen'\nend\n"
+      allow(File).to receive(:exist?).with(inflections_path).and_return(true)
+      allow(File).to receive(:read).with(inflections_path).and_return(raw)
+
+      result = described_class.index!
+      inflect_chunk = result.find { |c| c[:source_path].to_s.include?("inflections.rb") }
+      expect(inflect_chunk).not_to be_nil
+      expect(inflect_chunk[:content]).to include("inflect.irregular")
+    end
+
+    it "does not append inflections chunk when file has no rules" do
+      allow(File).to receive(:exist?).with(inflections_path).and_return(true)
+      allow(File).to receive(:read).with(inflections_path).and_return("# nothing here\n")
+
+      result = described_class.index!
+      inflect_chunk = result.find { |c| c[:source_path].to_s.include?("inflections.rb") }
+      expect(inflect_chunk).to be_nil
+    end
+  end
+end

data/spec/lib/glancer/indexer_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Indexer do
+  let(:schema_chunk)  { { content: "create_table users", source_type: "schema", source_path: "db/schema.rb#users" } }
+  let(:model_chunk)   { { content: "class User",         source_type: "models", source_path: "app/models/user.rb" } }
+  let(:context_chunk) { { content: "# Context",          source_type: "context", source_path: "config/context.md" } }
+
+  before do
+    allow(Glancer::Retriever).to receive(:store_documents)
+    allow(Glancer::Indexer::SchemaIndexer).to receive(:index!).and_return([schema_chunk])
+    allow(Glancer::Indexer::ModelIndexer).to receive(:index!).and_return([model_chunk])
+    allow(Glancer::Indexer::ContextIndexer).to receive(:index!).and_return([context_chunk])
+  end
+
+  describe ".rebuild_all!" do
+    context "when schema_permission is false (default)" do
+      it "does not call SchemaIndexer.index!" do
+        expect(Glancer::Indexer::SchemaIndexer).not_to receive(:index!)
+        described_class.rebuild_all!
+      end
+    end
+
+    context "when schema_permission is true" do
+      before { Glancer.configuration.schema_permission = true }
+
+      it "calls SchemaIndexer.index!" do
+        expect(Glancer::Indexer::SchemaIndexer).to receive(:index!).and_return([schema_chunk])
+        described_class.rebuild_all!
+      end
+
+      it "includes schema chunks in the result" do
+        chunks = described_class.rebuild_all!
+        expect(chunks).to include(schema_chunk)
+      end
+    end
+
+    context "when models_permission is false (default)" do
+      it "does not call ModelIndexer.index!" do
+        expect(Glancer::Indexer::ModelIndexer).not_to receive(:index!)
+        described_class.rebuild_all!
+      end
+    end
+
+    context "when models_permission is true" do
+      before { Glancer.configuration.models_permission = true }
+
+      it "calls ModelIndexer.index!" do
+        expect(Glancer::Indexer::ModelIndexer).to receive(:index!).and_return([model_chunk])
+        described_class.rebuild_all!
+      end
+    end
+
+    context "when context_file_path is set (default is set)" do
+      it "calls ContextIndexer.index!" do
+        expect(Glancer::Indexer::ContextIndexer).to receive(:index!).and_return([context_chunk])
+        described_class.rebuild_all!
+      end
+
+      it "includes context chunks in the result" do
+        chunks = described_class.rebuild_all!
+        expect(chunks).to include(context_chunk)
+      end
+    end
+
+    context "when context_file_path is nil" do
+      before { allow(Glancer.configuration).to receive(:context_file_path).and_return(nil) }
+
+      it "skips ContextIndexer.index!" do
+        expect(Glancer::Indexer::ContextIndexer).not_to receive(:index!)
+        described_class.rebuild_all!
+      end
+    end
+
+    it "calls Retriever.store_documents with accumulated chunks" do
+      Glancer.configuration.schema_permission = true
+      Glancer.configuration.models_permission = true
+      expect(Glancer::Retriever).to receive(:store_documents).with(array_including(schema_chunk, model_chunk, context_chunk))
+      described_class.rebuild_all!
+    end
+
+    it "returns the combined chunks array" do
+      Glancer.configuration.schema_permission = true
+      Glancer.configuration.models_permission = true
+      chunks = described_class.rebuild_all!
+      expect(chunks).to be_an(Array)
+    end
+
+    it "raises Glancer::Error when an indexer raises" do
+      allow(Glancer::Indexer::ContextIndexer).to receive(:index!).and_raise(StandardError, "disk error")
+      expect { described_class.rebuild_all! }.to raise_error(Glancer::Error, /Index rebuilding failed/)
+    end
+  end
+end

data/spec/lib/glancer/retriever_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Retriever do
+  let(:fake_embed_response) { double("EmbedResponse", vectors: [0.1, 0.2, 0.3]) }
+
+  before do
+    allow(RubyLLM).to receive(:embed).and_return(fake_embed_response)
+  end
+
+  # ── store_documents ───────────────────────────────────────────────────────
+
+  describe ".store_documents" do
+    let(:chunks) do
+      [
+        { content: "create_table users ...", source_type: "schema", source_path: "db/schema.rb#users" },
+        { content: "class User < ApplicationRecord", source_type: "models", source_path: "app/models/user.rb" }
+      ]
+    end
+
+    it "creates an Embedding record for each chunk" do
+      expect { described_class.store_documents(chunks) }.to change(Glancer::Embedding, :count).by(2)
+    end
+
+    it "stores the content from each chunk" do
+      described_class.store_documents(chunks)
+      contents = Glancer::Embedding.pluck(:content)
+      expect(contents).to include("create_table users ...", "class User < ApplicationRecord")
+    end
+
+    it "stores the source_type from each chunk" do
+      described_class.store_documents(chunks)
+      types = Glancer::Embedding.pluck(:source_type)
+      expect(types).to include("schema", "models")
+    end
+
+    it "stores the source_path from each chunk" do
+      described_class.store_documents(chunks)
+      paths = Glancer::Embedding.pluck(:source_path)
+      expect(paths).to include("db/schema.rb#users", "app/models/user.rb")
+    end
+
+    it "stores the embedding vector returned by RubyLLM.embed" do
+      described_class.store_documents([chunks.first])
+      emb = Glancer::Embedding.last
+      expect(emb.embedding.map(&:to_f)).to eq([0.1, 0.2, 0.3])
+    end
+
+    it "calls RubyLLM.embed once per chunk" do
+      expect(RubyLLM).to receive(:embed).exactly(2).times.and_return(fake_embed_response)
+      described_class.store_documents(chunks)
+    end
+
+    it "raises Glancer::Error when RubyLLM.embed fails" do
+      allow(RubyLLM).to receive(:embed).and_raise(StandardError, "API down")
+      expect { described_class.store_documents(chunks) }.to raise_error(Glancer::Error, /Document storage failed/)
+    end
+  end
+
+  # ── search ────────────────────────────────────────────────────────────────
+
+  describe ".search" do
+    before do
+      Glancer::Embedding.create!(
+        content: "create_table users ...", embedding: [0.1, 0.2, 0.3],
+        source_type: "schema", source_path: "db/schema.rb#users"
+      )
+    end
+
+    it "returns an array of Embedding records" do
+      results = described_class.search("count users")
+      expect(results).to all(be_a(Glancer::Embedding))
+    end
+
+    it "attaches a score singleton method to each result" do
+      results = described_class.search("something")
+      expect(results.first).to respond_to(:score)
+    end
+
+    it "calls RubyLLM.embed with the query" do
+      expect(RubyLLM).to receive(:embed).with("find users", anything).and_return(fake_embed_response)
+      described_class.search("find users")
+    end
+  end
+
+  # ── perform_ruby_search ───────────────────────────────────────────────────
+
+  describe ".perform_ruby_search" do
+    before do
+      Glancer::Embedding.create!(
+        content: "schema doc", embedding: [1.0, 0.0, 0.0],
+        source_type: "schema", source_path: "schema.rb#t"
+      )
+      Glancer::Embedding.create!(
+        content: "model doc", embedding: [0.0, 1.0, 0.0],
+        source_type: "models", source_path: "user.rb"
+      )
+    end
+
+    it "returns results filtered by min_score" do
+      Glancer.configuration.min_score = 0.99
+      results = described_class.perform_ruby_search([1.0, 0.0, 0.0])
+      expect(results.size).to eq(1)
+    end
+
+    it "limits results to k embeddings" do
+      Glancer.configuration.k = 1
+      Glancer.configuration.min_score = 0.0
+      results = described_class.perform_ruby_search([1.0, 0.0, 0.0])
+      expect(results.size).to eq(1)
+    end
+
+    it "applies schema weight (1.3) to schema embeddings" do
+      Glancer.configuration.min_score = 0.0
+      results = described_class.perform_ruby_search([1.0, 0.0, 0.0])
+      schema_result = results.find { |r| r.source_type == "schema" }
+      # Score for a perfect match should be ~1.3 (1.0 cosine * 1.3 weight)
+      expect(schema_result.score).to be_within(0.01).of(1.3)
+    end
+
+    it "falls back to top-k results when no embedding exceeds min_score" do
+      Glancer.configuration.min_score = 0.99
+      # Query vector orthogonal to both stored embeddings → cosine similarity ≈ 0
+      results = described_class.perform_ruby_search([0.0, 0.0, 1.0])
+      expect(results).not_to be_empty
+    end
+  end
+
+  # ── cosine_similarity ─────────────────────────────────────────────────────
+
+  describe ".cosine_similarity" do
+    it "returns 1.0 for identical vectors" do
+      vec = [1.0, 2.0, 3.0]
+      expect(described_class.cosine_similarity(vec, vec)).to be_within(1e-9).of(1.0)
+    end
+
+    it "returns 0.0 for orthogonal vectors" do
+      expect(described_class.cosine_similarity([1.0, 0.0], [0.0, 1.0])).to eq(0.0)
+    end
+
+    it "returns 0.0 when the first vector is all zeros" do
+      expect(described_class.cosine_similarity([0.0, 0.0], [1.0, 2.0])).to eq(0.0)
+    end
+
+    it "returns 0.0 when the second vector is all zeros" do
+      expect(described_class.cosine_similarity([1.0, 2.0], [0.0, 0.0])).to eq(0.0)
+    end
+
+    it "is symmetric" do
+      a = [0.3, 0.7, 0.1]
+      b = [0.5, 0.2, 0.8]
+      expect(described_class.cosine_similarity(a, b)).to eq(described_class.cosine_similarity(b, a))
+    end
+  end
+
+  # ── weight_for ────────────────────────────────────────────────────────────
+
+  describe ".weight_for" do
+    it "returns schema_documents_weight for 'schema'" do
+      Glancer.configuration.schema_documents_weight = 1.3
+      expect(described_class.weight_for("schema")).to eq(1.3)
+    end
+
+    it "returns context_documents_weight for 'context'" do
+      Glancer.configuration.context_documents_weight = 1.2
+      expect(described_class.weight_for("context")).to eq(1.2)
+    end
+
+    it "returns models_documents_weight for 'models'" do
+      Glancer.configuration.models_documents_weight = 1.1
+      expect(described_class.weight_for("models")).to eq(1.1)
+    end
+
+    it "returns 1.0 for any other source type" do
+      expect(described_class.weight_for("unknown")).to eq(1.0)
+    end
+  end
+end