ruby_llm-registry 0.1.0

data/lib/ruby_llm/registry/adapters/mongo.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyLLM
+  module Registry
+    module Adapters
+      # MongoDB-backed prompt repository.
+      class MongoDB < Base
+        def initialize(collection: nil, database: nil, collection_name: "ruby_llm_registry_prompts")
+          @collection = collection || resolve_collection(database, collection_name)
+        end
+
+        def get(path, version: nil, label: nil)
+          docs = collection.find(path: path).to_a
+          raise PromptNotFoundError, "Prompt path not found: #{path}" if docs.empty?
+
+          doc = if version
+                  docs.find { |record| record["version"] == Version.parse(version).to_s }
+                elsif label
+                  label = label.to_sym
+                  docs.find { |record| labels_for(record).include?(label) } || docs.find { |record| record["version"] == label.to_s }
+                else
+                  docs.max_by { |record| Version.parse(record["version"]) }
+                end
+
+          raise PromptNotFoundError, "Prompt not found: #{path}" unless doc
+
+          prompt_from_document(doc)
+        end
+
+        def available_versions(path)
+          collection.find(path: path).map { |doc| Version.parse(doc["version"]) }.sort
+        end
+
+        def store(prompt, overwrite: false)
+          existing = collection.find(path: prompt.path, version: prompt.version.to_s).first
+          if existing && !overwrite
+            raise Error, "Prompt #{prompt.path}@#{prompt.version} already exists"
+          end
+
+          doc = serialize_prompt(prompt)
+          existing ? collection.replace_one({ path: prompt.path, version: prompt.version.to_s }, doc) : collection.insert_one(doc)
+          prompt
+        end
+
+        private
+
+        attr_reader :collection
+
+        def resolve_collection(database, collection_name)
+          raise ArgumentError, "Provide a collection or database" unless database
+
+          database[collection_name]
+        end
+
+        def serialize_prompt(prompt)
+          {
+            "path" => prompt.path,
+            "namespace" => prompt.namespace,
+            "name" => prompt.name,
+            "version" => prompt.version.to_s,
+            "body" => prompt.body,
+            "labels" => prompt.labels.map(&:to_s),
+            "metadata" => prompt.metadata,
+            "required_vars" => prompt.required_vars.map(&:to_s),
+            "source_path" => prompt.source_path
+          }
+        end
+
+        def prompt_from_document(doc)
+          Prompt.new(
+            name: doc["name"],
+            namespace: doc["namespace"],
+            version: doc["version"],
+            body: doc["body"],
+            source_path: doc["source_path"],
+            labels: doc["labels"] || [],
+            metadata: doc["metadata"] || {},
+            required_vars: doc["required_vars"] || []
+          )
+        end
+
+        def labels_for(doc)
+          Array(doc["labels"]).map(&:to_sym)
+        end
+      end
+    end
+  end
+end
+

data/lib/ruby_llm/registry/adapters/s3.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyLLM
+  module Registry
+    module Adapters
+      # S3-backed prompt repository.
+      class S3 < Base
+        def initialize(client:, bucket:, prefix: "prompts")
+          @client = client
+          @bucket = bucket
+          @prefix = prefix.to_s.sub(%r{\A/+|/+$}, "")
+        end
+
+        def get(path, version: nil, label: nil)
+          key = object_key(path, version: version, label: label)
+          raise PromptNotFoundError, "Prompt not found: #{path}" unless key
+
+          payload = client.get_object(bucket: bucket, key: key).body.read
+          Importer.new(payload, format: :json, path: path).to_prompt
+        rescue NoMethodError
+          raise PromptNotFoundError, "Prompt not found: #{path}"
+        end
+
+        def available_versions(path)
+          prefix_key = object_prefix(path)
+          response = client.list_objects_v2(bucket: bucket, prefix: prefix_key)
+          Array(response.contents).map do |object|
+            version_from_key(object.key)
+          end.compact.map { |value| Version.parse(value) }.sort
+        end
+
+        def store(prompt, overwrite: false)
+          key = object_key(prompt.path, version: prompt.version.to_s)
+          if !overwrite && object_exists?(key)
+            raise Error, "Prompt #{prompt.path}@#{prompt.version} already exists"
+          end
+
+          client.put_object(
+            bucket: bucket,
+            key: key,
+            body: Exporter.new(prompt).to_json,
+            content_type: "application/json"
+          )
+          prompt
+        end
+
+        private
+
+        attr_reader :client, :bucket, :prefix
+
+        def object_key(path, version: nil, label: nil)
+          if version
+            "#{object_prefix(path)}/v#{Version.parse(version)}.json"
+          elsif label
+            label = label.to_sym
+            manifest_key = "#{object_prefix(path)}/#{label}.json"
+            object_exists?(manifest_key) ? manifest_key : nil
+          else
+            latest_key(path)
+          end
+        end
+
+        def latest_key(path)
+          keys = list_keys(path)
+          versioned = keys.map { |key| [version_from_key(key), key] }.compact
+          versioned.max_by { |version, _key| Version.parse(version) }&.last
+        end
+
+        def list_keys(path)
+          response = client.list_objects_v2(bucket: bucket, prefix: object_prefix(path))
+          Array(response.contents).map(&:key)
+        end
+
+        def object_exists?(key)
+          client.head_object(bucket: bucket, key: key)
+          true
+        rescue StandardError
+          false
+        end
+
+        def object_prefix(path)
+          [prefix, path].reject(&:empty?).join("/")
+        end
+
+        def version_from_key(key)
+          basename = key.split("/").last
+          basename.sub(/\.(json|yaml|yml)\z/, "").sub(/\Av/, "")
+        end
+      end
+    end
+  end
+end
+

data/lib/ruby_llm/registry/adapters/sqlite.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module RubyLLM
+  module Registry
+    module Adapters
+      # SQLite-backed prompt repository.
+      class SQLite < Base
+        def initialize(path:, table_name: "ruby_llm_registry_prompts")
+          require_sqlite3!
+          @database = SQLite3::Database.new(path)
+          @database.results_as_hash = true
+          @table_name = table_name
+          ensure_schema!
+        end
+
+        def get(path, version: nil, label: nil)
+          rows = rows_for_path(path)
+          raise PromptNotFoundError, "Prompt path not found: #{path}" if rows.empty?
+
+          row = if version
+                  rows.find { |record| record["version"] == Version.parse(version).to_s }
+                elsif label
+                  label = label.to_sym
+                  rows.find { |record| labels_for(record).include?(label) } || rows.find { |record| record["version"] == label.to_s }
+                else
+                  rows.max_by { |record| Version.parse(record["version"]) }
+                end
+
+          raise PromptNotFoundError, "Prompt not found: #{path}" unless row
+
+          prompt_from_row(row)
+        end
+
+        def available_versions(path)
+          rows_for_path(path).map { |row| Version.parse(row["version"]) }.sort
+        end
+
+        def store(prompt, overwrite: false)
+          existing = rows_for_path(prompt.path).find { |row| row["version"] == prompt.version.to_s }
+          if existing && !overwrite
+            raise Error, "Prompt #{prompt.path}@#{prompt.version} already exists"
+          end
+
+          data = serialize_prompt(prompt)
+          if existing
+            update_row(data)
+          else
+            insert_row(data)
+          end
+          prompt
+        end
+
+        private
+
+        attr_reader :database, :table_name
+
+        def require_sqlite3!
+          require "sqlite3"
+        rescue LoadError => e
+          raise LoadError, "sqlite3 gem is required for the SQLite adapter"
+        end
+
+        def ensure_schema!
+          database.execute <<~SQL
+            CREATE TABLE IF NOT EXISTS #{table_name} (
+              path TEXT NOT NULL,
+              namespace TEXT NOT NULL,
+              name TEXT NOT NULL,
+              version TEXT NOT NULL,
+              body TEXT NOT NULL,
+              labels_json TEXT NOT NULL,
+              metadata_json TEXT NOT NULL,
+              required_vars_json TEXT NOT NULL,
+              source_path TEXT,
+              created_at TEXT NOT NULL,
+              updated_at TEXT NOT NULL,
+              UNIQUE(path, version)
+            )
+          SQL
+        end
+
+        def rows_for_path(path)
+          database.execute("SELECT * FROM #{table_name} WHERE path = ?", [path])
+        end
+
+        def serialize_prompt(prompt)
+          {
+            path: prompt.path,
+            namespace: prompt.namespace,
+            name: prompt.name,
+            version: prompt.version.to_s,
+            body: prompt.body,
+            labels_json: JSON.generate(prompt.labels),
+            metadata_json: JSON.generate(prompt.metadata),
+            required_vars_json: JSON.generate(prompt.required_vars),
+            source_path: prompt.source_path,
+            created_at: Time.now.utc.iso8601,
+            updated_at: Time.now.utc.iso8601
+          }
+        end
+
+        def insert_row(data)
+          database.execute(
+            <<~SQL,
+              INSERT INTO #{table_name}
+                (path, namespace, name, version, body, labels_json, metadata_json, required_vars_json, source_path, created_at, updated_at)
+              VALUES
+                (:path, :namespace, :name, :version, :body, :labels_json, :metadata_json, :required_vars_json, :source_path, :created_at, :updated_at)
+            SQL
+            data
+          )
+        end
+
+        def update_row(data)
+          database.execute(
+            <<~SQL,
+              UPDATE #{table_name}
+              SET namespace = :namespace,
+                  name = :name,
+                  body = :body,
+                  labels_json = :labels_json,
+                  metadata_json = :metadata_json,
+                  required_vars_json = :required_vars_json,
+                  source_path = :source_path,
+                  updated_at = :updated_at
+              WHERE path = :path AND version = :version
+            SQL
+            data
+          )
+        end
+
+        def prompt_from_row(row)
+          Prompt.new(
+            name: row["name"],
+            namespace: row["namespace"],
+            version: row["version"],
+            body: row["body"],
+            source_path: row["source_path"],
+            labels: JSON.parse(row["labels_json"] || "[]"),
+            metadata: JSON.parse(row["metadata_json"] || "{}"),
+            required_vars: JSON.parse(row["required_vars_json"] || "[]")
+          )
+        end
+
+        def labels_for(row)
+          JSON.parse(row["labels_json"] || "[]").map(&:to_sym)
+        end
+      end
+    end
+  end
+end
+

data/lib/ruby_llm/registry/adapters.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "adapters/base"
+require_relative "adapters/sqlite"
+require_relative "adapters/active_record"
+require_relative "adapters/mongo"
+require_relative "adapters/s3"
+
+module RubyLLM
+  module Registry
+    module Adapters
+      module_function
+
+      def build(type = :filesystem, **options)
+        case type.to_sym
+        when :filesystem then FilesystemBackend.new(**options)
+        when :sqlite then SQLite.new(**options)
+        when :active_record, :ar then ActiveRecord.new(**options)
+        when :mongo, :mongodb then MongoDB.new(**options)
+        when :s3 then S3.new(**options)
+        else
+          raise ArgumentError, "Unknown adapter type: #{type.inspect}"
+        end
+      end
+    end
+  end
+end
+

data/lib/ruby_llm/registry/comparison.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Registry
+    # Represents a comparison between two prompt revisions.
+    class Comparison
+      attr_reader :left, :right, :changes
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+        @changes = build_changes
+      end
+
+      def changed?
+        changes.any?
+      end
+
+      def changed_fields
+        changes.keys
+      end
+
+      def body_diff
+        DiffLines.new(left.body.to_s, right.body.to_s).to_s
+      end
+
+      def to_h
+        {
+          left: snapshot(left),
+          right: snapshot(right),
+          changes: changes,
+          body_diff: body_diff
+        }
+      end
+
+      def to_s
+        return "No changes" unless changed?
+
+        parts = changes.map do |field, change|
+          "#{field}: #{change[:from].inspect} -> #{change[:to].inspect}"
+        end
+        "#{parts.join('; ')}\n#{body_diff}"
+      end
+
+      private
+
+      def build_changes
+        fields = %i[version labels metadata required_vars body]
+        fields.each_with_object({}) do |field, hash|
+          left_value = normalize_field(left.public_send(field))
+          right_value = normalize_field(right.public_send(field))
+          hash[field] = { from: left_value, to: right_value } unless left_value == right_value
+        end
+      end
+
+      def normalize_field(value)
+        case value
+        when Version
+          value.to_s
+        when Array
+          value.map { |item| normalize_field(item) }
+        when Hash
+          value.each_with_object({}) do |(key, item), hash|
+            hash[key] = normalize_field(item)
+          end
+        else
+          value
+        end
+      end
+
+      def snapshot(prompt)
+        prompt.respond_to?(:to_h) ? prompt.to_h : prompt
+      end
+    end
+
+    # Minimal line-oriented diff representation for prompt bodies.
+    class DiffLines
+      def initialize(left, right)
+        @left = left.to_s.split("\n")
+        @right = right.to_s.split("\n")
+      end
+
+      def to_s
+        build.join("\n")
+      end
+
+      private
+
+      attr_reader :left, :right
+
+      def build
+        output = []
+        max = [left.length, right.length].max
+
+        max.times do |index|
+          l = left[index]
+          r = right[index]
+
+          if l == r
+            output << " #{l}" if l
+          else
+            output << "-#{l}" if l
+            output << "+#{r}" if r
+          end
+        end
+
+        output
+      end
+    end
+  end
+end
+

data/lib/ruby_llm/registry/context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Registry
+    # Context object used while rendering ERB prompts.
+    class RenderContext
+      def initialize(values = {})
+        @values = normalize(values)
+      end
+
+      def method_missing(name, *args)
+        raise NoMethodError, "undefined method `#{name}` for #{self}" unless args.empty?
+
+        @values[name]
+      end
+
+      def respond_to_missing?(name, _include_private = false)
+        @values.key?(name)
+      end
+
+      def current_date
+        Date.today
+      end
+
+      def current_time
+        Time.now
+      end
+
+      alias today current_date
+
+      private
+
+      def normalize(values)
+        values.each_with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = value
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/registry/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Registry
+    class Error < StandardError; end
+    class PromptNotFoundError < Error; end
+    class InvalidVersionError < Error; end
+    class MissingVariableError < Error; end
+    class UnknownLabelError < Error; end
+  end
+end

data/lib/ruby_llm/registry/exporter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module RubyLLM
+  module Registry
+    # Serializes prompt objects into portable formats.
+    class Exporter
+      def initialize(prompt)
+        @prompt = prompt
+      end
+
+      def to_h
+        prompt.to_h
+      end
+
+      def to_yaml
+        YAML.dump(to_h)
+      end
+
+      def to_json(*args)
+        JSON.pretty_generate(to_h, *args)
+      end
+
+      def to_markdown
+        <<~MARKDOWN.chomp
+          ---
+          #{YAML.dump(front_matter).sub(/\A---\s*\n/, "").sub(/\n\z/, "")}
+          ---
+
+          #{prompt.body}
+        MARKDOWN
+      end
+
+      private
+
+      attr_reader :prompt
+
+      def front_matter
+        {
+          version: prompt.version.to_s,
+          labels: prompt.labels,
+          required_vars: prompt.required_vars,
+          metadata: prompt.metadata,
+          name: prompt.name,
+          namespace: prompt.namespace,
+          source_path: prompt.source_path
+        }
+      end
+    end
+  end
+end
+