gemchat 0.1.0

data/exe/gemchat

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/gemchat"
+require_relative "../lib/gemchat/cli"
+
+exit Gemchat::CLI.start(ARGV)

data/lib/gemchat/chunker.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Gemchat
+  # Turns ri structs into indexable chunks. One chunk per method (signature +
+  # description is the unit an agent acts on) and one per class, so a query for
+  # an API name lands on something directly usable.
+  #
+  # Plain Ruby only: this gem does not depend on ActiveSupport.
+  class Chunker
+    MIN_CHARS = 20
+    MAX_BODY_CHARS = 2000
+    MAX_SIGNATURE_CHARS = 200
+
+    # Labelled fields, so BM25 can weight a signature match above a prose match.
+    # Blank fields are dropped by Chunk#searchable_text rather than emitted as
+    # "method_name: ", which would pad every class-level chunk with dead tokens.
+    SEARCH_FIELDS = {
+      "title" => :title,
+      "source_type" => :source_type,
+      "class_name" => :class_name,
+      "method_name" => :method_name,
+      "signature" => :signature
+    }.freeze
+
+    # `source_path` and `source_line` come from the Prism pass, not from ri --
+    # ri cannot tell us which file a method lives in. See `Gemchat::Symbols`.
+    Chunk = Struct.new(
+      :gem_name, :gem_version, :source_type, :title, :body,
+      :class_name, :method_name, :method_type, :signature,
+      :source_path, :source_line
+    ) do
+      def content
+        [signature.to_s, body.to_s].reject { |s| s.strip.empty? }.join("\n\n")
+      end
+
+      def searchable_text
+        labelled = SEARCH_FIELDS.filter_map { |label, attr|
+          value = public_send(attr).to_s.strip
+          "#{label}: #{value}" unless value.empty?
+        }
+
+        (labelled << content).reject { |s| s.to_s.strip.empty? }.join("\n")
+      end
+
+      # Includes the source location. A chunk whose definition moved to another
+      # file is a changed chunk, and reusing the old row would leave a citation
+      # pointing at the wrong line.
+      def content_digest
+        Digest::SHA256.hexdigest([searchable_text, source_path.to_s, source_line.to_s].join("\n"))
+      end
+    end
+
+    def self.from_ri(gem_name, gem_version, classes)
+      new(gem_name, gem_version).from_ri(classes)
+    end
+
+    def initialize(gem_name, gem_version)
+      @gem_name = gem_name
+      @gem_version = gem_version
+    end
+
+    # An unreadable or empty ri store yields nil rather than raising, so this
+    # has to tolerate a nil argument.
+    def from_ri(classes)
+      classes.to_a.flat_map { |klass| chunks_for(klass) }.compact
+    end
+
+    private
+
+    def chunks_for(klass)
+      class_name = klass[:class_name].to_s
+      out = []
+
+      description = klass[:description].to_s
+      if description.length >= MIN_CHARS
+        out << build(
+          title: class_name,
+          body: description,
+          class_name: class_name,
+          method_name: nil,
+          method_type: nil,
+          signature: nil
+        )
+      end
+
+      (klass[:methods] || []).each do |method|
+        separator = (method[:type] == "class") ? "::" : "#"
+        qualified = "#{class_name}#{separator}#{method[:name]}"
+        body = [method[:description].to_s, method[:signature].to_s]
+          .reject { |s| s.strip.empty? }.join("\n")
+        next if body.length < MIN_CHARS
+
+        out << build(
+          title: qualified,
+          body: body,
+          class_name: class_name,
+          method_name: method[:name],
+          method_type: method[:type],
+          signature: method[:signature]
+        )
+      end
+
+      out
+    end
+
+    def build(title:, body:, class_name:, method_name:, method_type:, signature:)
+      Chunk.new(
+        gem_name: @gem_name,
+        gem_version: @gem_version,
+        source_type: "ri",
+        title: title,
+        body: body[0, MAX_BODY_CHARS],
+        class_name: class_name,
+        method_name: method_name,
+        method_type: method_type,
+        signature: signature.to_s[0, MAX_SIGNATURE_CHARS]
+      )
+    end
+  end
+end