ruby_llm-schema 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 228903cdd6e6080b7c687147ecc609349601d315da71e861b1d900f7c252ac00
-  data.tar.gz: ecdc3e346f33710ceff0d68c8eb13266956bddc1a36852f02128e3d3f2d94ff5
+  metadata.gz: 21c3e0ee2e5a1034eb571749cc2f27af5db9e4abaf07e2df677325f9270db6f1
+  data.tar.gz: 57db5c67a751f4e31f1ed2d56bba8bac76ddb989fee7b49add969b1c50be844e
 SHA512:
-  metadata.gz: ca4ee64989087583e4a15e3b608b7e867034f0682a5f67753efeedee2f98bdc60ce933ff9a0823c93a633d43a9258e550c51b4d3fdbcddc0b3b2462ff40c5586
-  data.tar.gz: 03affcdc52ba81f9c7c5d62fcd23e58f800dad7be7580df6c73d6c00b7d1941db0eacd867c83e075aee51090d52e418159472fe72b456533d4cbf1c1141c5ecc
+  metadata.gz: cd93b24110859806ee43a5a794353849e51273797696d84469b998c69d9e93e761ef817ede4d89377e34e227f8b6115d2e9133d58496bfcb2399f7720e4087e3
+  data.tar.gz: 1153950f2917a95e00744cb832a2c3ce7b1bd61965314f5652dc4337333d3b9f258d52b01257e62739b997bbd6ede840c9a7adfcd339477dc996bca093bf2a0d

data/README.md

@@ -1,21 +1,25 @@
 # RubyLLM::Schema
 
 [![Gem Version](https://badge.fury.io/rb/ruby_llm-schema.svg)](https://rubygems.org/gems/ruby_llm-schema)
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/danielfriis/ruby_llm-schema/blob/main/LICENSE.txt)
-[![CI](https://github.com/danielfriis/ruby_llm-schema/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/danielfriis/ruby_llm-schema/actions/workflows/ci.yml)
+[![Gem Downloads](https://img.shields.io/gem/dt/ruby_llm-schema)](https://rubygems.org/gems/ruby_llm-schema)
+[![codecov](https://codecov.io/gh/crmne/ruby_llm-schema/branch/main/graph/badge.svg)](https://codecov.io/gh/crmne/ruby_llm-schema)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
 
-A Ruby DSL for creating JSON schemas with a clean, Rails-inspired API. Perfect for defining structured data schemas for LLM function calling or structured outputs.
+A Ruby DSL for creating JSON schemas with a clean, Rails-inspired API.
+
+Originally created by [Daniel Friis](https://github.com/danielfriis).
 
 ## Use Cases
 
-Structured output is a powerful tool for LLMs to generate consistent and predictable responses.
+JSON Schema is useful wherever Ruby code needs to describe structured data in a portable format.
 
 Some ideal use cases:
 
-- Extracting *metadata, topics, and summary* from articles or blog posts
-- Organizing unstructured feedback or reviews with *sentiment and summary* 
-- Defining structured *actions* from user messages or emails
-- Extracting *entities and relationships* from documents
+- Defining API request and response shapes
+- Describing configuration files or structured payloads
+- Sharing validation contracts across systems
+- Generating structured output schemas for LLM workflows
+- Defining structured parameters for RubyLLM tools
 
 ### Simple Example
 
@@ -24,22 +28,22 @@ class PersonSchema < RubyLLM::Schema
   string :name, description: "Person's full name"
   number :age, description: "Age in years", minimum: 0, maximum: 120
   boolean :active, required: false
-  
+
   object :address do
     string :street
     string :city
     string :country, required: false
   end
-  
+
   array :tags, of: :string, description: "User tags"
-  
+
   array :contacts do
     object do
       string :email, format: "email"
       string :phone, required: false
     end
   end
-  
+
   any_of :status do
     string enum: ["active", "pending", "inactive"]
     null
@@ -51,7 +55,7 @@ schema = PersonSchema.new
 puts schema.to_json
 ```
 
-### Most common use case with RubyLLM
+### RubyLLM structured output
 
 ```ruby
 class PersonSchema < RubyLLM::Schema
@@ -70,6 +74,43 @@ puts response.content # => {"name" => "Alice", "age" => 30}
 puts response.content.class # => Hash
 ```
 
+### RubyLLM tools
+
+RubyLLM tools can use schema classes for structured parameters. This is useful when the same argument shape is shared across tools or elsewhere in your app.
+
+```ruby
+class SearchParams < RubyLLM::Schema
+  string :query, description: "Search query"
+  integer :limit, required: false, description: "Maximum results"
+end
+
+class SearchDocuments < RubyLLM::Tool
+  desc "Searches internal documents"
+  params SearchParams
+
+  def execute(query:, limit: 10)
+    DocumentSearch.call(query:, limit:)
+  end
+end
+```
+
+For tool-specific parameters, define the schema inline with `params do ... end`.
+
+```ruby
+class Weather < RubyLLM::Tool
+  desc "Gets current weather"
+
+  params do
+    string :city, description: "City name"
+    string :units, enum: %w[celsius fahrenheit], required: false
+  end
+
+  def execute(city:, units: "celsius")
+    WeatherAPI.current(city:, units:)
+  end
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -101,12 +142,12 @@ class PersonSchema < RubyLLM::Schema
   string :name, description: "Person's full name"
   number :age
   boolean :active, required: false
-  
+
   object :address do
     string :street
     string :city
   end
-  
+
   array :tags, of: :string
 end
 
@@ -121,12 +162,12 @@ PersonSchema = RubyLLM::Schema.create do
   string :name, description: "Person's full name"
   number :age
   boolean :active, required: false
-  
+
   object :address do
     string :street
     string :city
   end
-  
+
   array :tags, of: :string
 end
 
@@ -144,12 +185,12 @@ person_schema = schema "PersonData", description: "A person object" do
   string :name, description: "Person's full name"
   number :age
   boolean :active, required: false
-  
+
   object :address do
     string :street
     string :city
   end
-  
+
   array :tags, of: :string
 end
 
@@ -269,7 +310,7 @@ Union types are a way to specify that a property can be one of several types.
 ```ruby
 any_of :value do
   string
-  number  
+  number
   null
 end
 
@@ -289,7 +330,7 @@ class MySchema < RubyLLM::Schema
     string :latitude
     string :longitude
   end
-  
+
   # Using a reference in an array
   array :coordinates, of: :location
 
@@ -324,7 +365,7 @@ class CompanySchema < RubyLLM::Schema
   # Using 'of' parameter
   object :ceo, of: PersonSchema
   array :employees, of: PersonSchema
-  
+
   # Using Schema.new in block
   object :founder do
     PersonSchema.new
@@ -403,6 +444,65 @@ schema.to_json_schema
 # }
 ```
 
+### Dependencies
+
+Use `requires:` inline or `dependent` block to express that the presence of one property requires others. Maps to [`dependentRequired`](https://json-schema.org/understanding-json-schema/reference/conditionals#dependentRequired) (Draft 2019-09) and [`dependentSchemas`](https://json-schema.org/understanding-json-schema/reference/conditionals#dependentSchemas) (Draft 2019-09). Check your provider's documentation for compatibility.
+
+```ruby
+class PaymentSchema < RubyLLM::Schema
+  string :name
+  number :credit_card, required: false, requires: %i[billing_address cvv]
+  string :billing_address, required: false
+  string :cvv, required: false
+end
+```
+
+Use a `dependent` block when you also need validations — this upgrades the output to `dependentSchemas`:
+
+```ruby
+dependent :credit_card do
+  requires :billing_address
+  validates :billing_address, type: :string, min_length: 1
+end
+```
+
+### Conditionals
+
+Use `given` to add [JSON Schema `if`/`then`/`else`](https://json-schema.org/understanding-json-schema/reference/conditionals#ifthenelse) (Draft 7) rules. Condition values are automatically coerced: strings → `const`, arrays → `enum`, regexps → `pattern`, hashes → raw schema.
+
+```ruby
+class OrderSchema < RubyLLM::Schema
+  string :status, enum: ["pending", "shipped", "cancelled"]
+  string :tracking_number, required: false
+  string :cancellation_reason, required: false
+
+  given status: "shipped" do
+    requires :tracking_number
+  end
+
+  given status: "cancelled" do
+    requires :cancellation_reason
+    validates :cancellation_reason, type: :string, min_length: 1
+  end
+end
+```
+
+`validates` supports: `type:`, `not_value:`, `min_length:`, `max_length:`, `pattern:` (string or regexp), `enum:`, `const:`, `minimum:`, `maximum:`.
+
+Use `otherwise` for an `else` branch:
+
+```ruby
+given domestic: true do
+  requires :state
+
+  otherwise do
+    requires :country
+  end
+end
+```
+
+Conditions propagate through nested schemas via `of:`.
+
 ## JSON Output
 
 ```ruby

data/lib/ruby_llm/schema/dsl/complex_types.rb

@@ -4,20 +4,20 @@ module RubyLLM
   class Schema
     module DSL
       module ComplexTypes
-        def object(name, description: nil, required: true, **options, &block)
-          add_property(name, object_schema(description: description, **options, &block), required: required)
+        def object(name, description: nil, required: true, requires: nil, **options, &block)
+          add_property(name, object_schema(description: description, **options, &block), required: required, requires: requires)
         end
 
-        def array(name, description: nil, required: true, **options, &block)
-          add_property(name, array_schema(description: description, **options, &block), required: required)
+        def array(name, description: nil, required: true, requires: nil, **options, &block)
+          add_property(name, array_schema(description: description, **options, &block), required: required, requires: requires)
         end
 
-        def any_of(name, description: nil, required: true, **options, &block)
-          add_property(name, any_of_schema(description: description, **options, &block), required: required)
+        def any_of(name, description: nil, required: true, requires: nil, **options, &block)
+          add_property(name, any_of_schema(description: description, **options, &block), required: required, requires: requires)
         end
 
-        def one_of(name, description: nil, required: true, **options, &block)
-          add_property(name, one_of_schema(description: description, **options, &block), required: required)
+        def one_of(name, description: nil, required: true, requires: nil, **options, &block)
+          add_property(name, one_of_schema(description: description, **options, &block), required: required, requires: requires)
         end
 
         def optional(name, description: nil, &block)

data/lib/ruby_llm/schema/dsl/conditionals.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Schema
+    module DSL
+      module Conditionals
+        def conditions
+          @conditions ||= []
+        end
+
+        def dependencies
+          @dependencies ||= {}
+        end
+
+        def dependent(property, &block)
+          builder = ConditionalBuilder.new
+          builder.instance_eval(&block)
+
+          dependencies[property.to_s] = builder
+        end
+
+        def given(**properties, &block)
+          raise ArgumentError, "given requires at least one property condition" if properties.empty?
+
+          if_schema = {
+            properties: properties.transform_keys(&:to_s).transform_values { |v| coerce_condition(v) },
+            required: properties.keys.map(&:to_s)
+          }
+
+          then_builder = ConditionalBuilder.new
+          else_builder = ConditionalBuilder.new
+
+          context = ConditionalContext.new(then_builder, else_builder)
+          context.instance_eval(&block)
+
+          condition = {if: if_schema, then: then_builder.to_schema}
+          condition[:else] = else_builder.to_schema unless else_builder.empty?
+
+          conditions << condition
+        end
+
+        private
+
+        def merge_conditions(schema, schema_class)
+          if schema_class.respond_to?(:conditions) && schema_class.conditions.any?
+            if schema_class.conditions.length == 1
+              schema.merge!(schema_class.conditions.first)
+            else
+              schema[:allOf] = schema_class.conditions
+            end
+          end
+
+          if schema_class.respond_to?(:dependencies) && schema_class.dependencies.any?
+            dependent_required = {}
+            dependent_schemas = {}
+
+            schema_class.dependencies.each do |property, builder|
+              if builder.validations_empty?
+                dependent_required[property] = builder.required_fields
+              else
+                dependent_schemas[property] = builder.to_schema
+              end
+            end
+
+            schema[:dependentRequired] = dependent_required if dependent_required.any?
+            schema[:dependentSchemas] = dependent_schemas if dependent_schemas.any?
+          end
+
+          schema
+        end
+
+        def coerce_condition(value)
+          case value
+          when Array then {enum: value}
+          when Regexp then {pattern: value.source}
+          when Hash then value
+          else {const: value}
+          end
+        end
+      end
+
+      class ConditionalContext
+        def initialize(then_builder, else_builder)
+          @then_builder = then_builder
+          @else_builder = else_builder
+        end
+
+        def requires(*fields)
+          @then_builder.requires(*fields)
+        end
+
+        def validates(field, **options)
+          @then_builder.validates(field, **options)
+        end
+
+        def otherwise(&block)
+          @else_builder.instance_eval(&block)
+        end
+      end
+
+      class ConditionalBuilder
+        def requires(*fields)
+          required.concat(fields.map(&:to_s))
+        end
+
+        VALIDATES_KEY_MAP = {
+          type: :type,
+          const: :const,
+          enum: :enum,
+          not_value: :not,
+          min_length: :minLength,
+          max_length: :maxLength,
+          pattern: :pattern,
+          minimum: :minimum,
+          maximum: :maximum
+        }.freeze
+
+        def validates(field, **options)
+          constraints = {}
+
+          options.each do |key, value|
+            schema_key = VALIDATES_KEY_MAP[key]
+            raise ArgumentError, "unknown validates option: #{key.inspect}" unless schema_key
+
+            case key
+            when :type then constraints[:type] = value.to_s
+            when :not_value then constraints[:not] = {const: value}
+            when :pattern then constraints[:pattern] = value.is_a?(Regexp) ? value.source : value
+            else constraints[schema_key] = value
+            end
+          end
+
+          validations[field.to_s] = constraints
+        end
+
+        def to_schema
+          schema = {}
+
+          schema[:required] = required if required.any?
+          schema[:properties] = validations if validations.any?
+
+          schema
+        end
+
+        def empty?
+          required.empty? && validations.empty?
+        end
+
+        def required_fields
+          required.dup
+        end
+
+        def validations_empty?
+          validations.empty?
+        end
+
+        private
+
+        def required
+          @required ||= []
+        end
+
+        def validations
+          @validations ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/schema/dsl/primitive_types.rb

@@ -4,24 +4,24 @@ module RubyLLM
   class Schema
     module DSL
       module PrimitiveTypes
-        def string(name, description: nil, required: true, **options)
-          add_property(name, string_schema(description: description, **options), required: required)
+        def string(name, description: nil, required: true, requires: nil, **options)
+          add_property(name, string_schema(description: description, **options), required: required, requires: requires)
         end
 
-        def number(name, description: nil, required: true, **options)
-          add_property(name, number_schema(description: description, **options), required: required)
+        def number(name, description: nil, required: true, requires: nil, **options)
+          add_property(name, number_schema(description: description, **options), required: required, requires: requires)
         end
 
-        def integer(name, description: nil, required: true, **options)
-          add_property(name, integer_schema(description: description, **options), required: required)
+        def integer(name, description: nil, required: true, requires: nil, **options)
+          add_property(name, integer_schema(description: description, **options), required: required, requires: requires)
         end
 
-        def boolean(name, description: nil, required: true, **options)
-          add_property(name, boolean_schema(description: description, **options), required: required)
+        def boolean(name, description: nil, required: true, requires: nil, **options)
+          add_property(name, boolean_schema(description: description, **options), required: required, requires: requires)
         end
 
-        def null(name, description: nil, required: true, **options)
-          add_property(name, null_schema(description: description, **options), required: required)
+        def null(name, description: nil, required: true, requires: nil, **options)
+          add_property(name, null_schema(description: description, **options), required: required, requires: requires)
         end
       end
     end

data/lib/ruby_llm/schema/dsl/schema_builders.rb

@@ -64,13 +64,15 @@ module RubyLLM
               schema_class_to_inline_schema(result).merge(description ? {description: description} : {})
             # Block didn't return reference or schema, so we build an inline object schema
             else
-              {
+              schema = {
                 type: "object",
                 properties: sub_schema.properties,
                 required: sub_schema.required_properties,
                 additionalProperties: sub_schema.additional_properties,
                 description: description
               }.compact
+
+              merge_conditions(schema, sub_schema)
             end
           end
         end
@@ -118,21 +120,19 @@ module RubyLLM
 
         def determine_object_reference(of, description = nil)
           result = case of
-          when Symbol
-            reference(of)
-          when Class
-            if schema_class?(of)
-              schema_class_to_inline_schema(of)
-            else
-              raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Class must inherit from RubyLLM::Schema."
-            end
-          else
-            if schema_class?(of)
-              schema_class_to_inline_schema(of)
-            else
-              raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Must be a symbol reference, a Schema class, or a Schema instance."
-            end
-          end
+                   when Symbol
+                     reference(of)
+                   when Class
+                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Class must inherit from RubyLLM::Schema." unless schema_class?(of)
+
+                     schema_class_to_inline_schema(of)
+
+                   else
+                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Must be a symbol reference, a Schema class, or a Schema instance." unless schema_class?(of)
+
+                     schema_class_to_inline_schema(of)
+
+                   end
 
           description ? result.merge(description: description) : result
         end
@@ -147,7 +147,7 @@ module RubyLLM
           schema_builder.methods.grep(/_schema$/).each do |schema_method|
             type_name = schema_method.to_s.sub(/_schema$/, "")
 
-            context.define_singleton_method(type_name) do |name = nil, **options, &blk|
+            context.define_singleton_method(type_name) do |_name = nil, **options, &blk|
               schemas << schema_builder.send(schema_method, **options, &blk)
             end
           end
@@ -164,10 +164,10 @@ module RubyLLM
         def schema_class_to_inline_schema(schema_class_or_instance)
           # Handle both Schema classes and Schema instances
           schema_class = if schema_class_or_instance.is_a?(Class)
-            schema_class_or_instance
-          else
-            schema_class_or_instance.class
-          end
+                           schema_class_or_instance
+                         else
+                           schema_class_or_instance.class
+                         end
 
           # Directly convert schema class to inline object schema
           {
@@ -178,11 +178,14 @@ module RubyLLM
           }.tap do |schema|
             # For instances, prefer instance description over class description
             description = if schema_class_or_instance.is_a?(Class)
-              schema_class.description
-            else
-              schema_class_or_instance.instance_variable_get(:@description) || schema_class.description
-            end
+                            schema_class.description
+                          else
+                            schema_class_or_instance.instance_variable_get(:@description) || schema_class.description
+                          end
+
             schema[:description] = description if description
+
+            merge_conditions(schema, schema_class)
           end
         end
       end

data/lib/ruby_llm/schema/dsl/utilities.rb

@@ -9,12 +9,16 @@ module RubyLLM
           sub_schema = Class.new(Schema)
           sub_schema.class_eval(&)
 
-          definitions[name] = {
+          schema = {
             type: "object",
             properties: sub_schema.properties,
             required: sub_schema.required_properties,
             additionalProperties: sub_schema.additional_properties
           }
+
+          merge_conditions(schema, sub_schema)
+
+          definitions[name] = schema
         end
 
         def reference(schema_name)
@@ -27,9 +31,23 @@ module RubyLLM
 
         private
 
-        def add_property(name, definition, required:)
-          properties[name.to_sym] = definition
-          required_properties << name.to_sym if required
+        def add_property(name, definition, required:, requires: nil)
+          property_name = name.to_sym
+
+          properties[property_name] = definition
+          if required
+            required_properties << property_name unless required_properties.include?(property_name)
+          else
+            required_properties.delete(property_name)
+          end
+
+          if requires
+            builder = ConditionalBuilder.new
+            builder.requires(*Array(requires))
+            dependencies[name.to_s] = builder
+          end
+
+          nil
         end
 
         def primitive_type?(type)

data/lib/ruby_llm/schema/dsl.rb

@@ -3,6 +3,7 @@
 require_relative "dsl/schema_builders"
 require_relative "dsl/primitive_types"
 require_relative "dsl/complex_types"
+require_relative "dsl/conditionals"
 require_relative "dsl/utilities"
 
 module RubyLLM
@@ -11,6 +12,7 @@ module RubyLLM
       include SchemaBuilders
       include PrimitiveTypes
       include ComplexTypes
+      include Conditionals
       include Utilities
     end
   end

data/lib/ruby_llm/schema/errors.rb

@@ -13,18 +13,10 @@ module RubyLLM
     end
 
     # Raised when an invalid array type is specified
-    class InvalidArrayTypeError < Error
-      def initialize(message)
-        super
-      end
-    end
+    class InvalidArrayTypeError < Error; end
 
     # Raised when an invalid object type is specified
-    class InvalidObjectTypeError < Error
-      def initialize(message)
-        super
-      end
-    end
+    class InvalidObjectTypeError < Error; end
 
     # Raised when schema definition is invalid
     class InvalidSchemaError < Error; end

data/lib/ruby_llm/schema/json_output.rb

@@ -4,7 +4,7 @@ module RubyLLM
   class Schema
     module JsonOutput
       def to_json_schema
-        validate!  # Validate schema before generating JSON
+        validate! # Validate schema before generating JSON
 
         schema_hash = {
           type: "object",
@@ -18,6 +18,8 @@ module RubyLLM
         # Only include $defs if there are definitions
         schema_hash["$defs"] = self.class.definitions unless self.class.definitions.empty?
 
+        self.class.send(:merge_conditions, schema_hash, self.class)
+
         {
           name: @name,
           description: @description || self.class.description,
@@ -26,7 +28,7 @@ module RubyLLM
       end
 
       def to_json(*_args)
-        validate!  # Validate schema before generating JSON string
+        validate! # Validate schema before generating JSON string
         JSON.pretty_generate(to_json_schema)
       end
     end

data/lib/ruby_llm/schema/validator.rb

@@ -45,9 +45,7 @@ module RubyLLM
         return if marks[node] == BLACK
 
         # If node has a temporary mark, we found a cycle
-        if marks[node] == GRAY
-          raise ValidationError, "Circular reference detected involving '#{node}'"
-        end
+        raise ValidationError, "Circular reference detected involving '#{node}'" if marks[node] == GRAY
 
         # Mark node with temporary mark
         marks[node] = GRAY

data/lib/ruby_llm/schema/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module RubyLlm
+module RubyLLM
   class Schema
-    VERSION = "0.3.0"
+    VERSION = '0.4.0'
   end
 end

data/lib/ruby_llm/schema.rb

@@ -48,6 +48,7 @@ module RubyLLM
 
       def additional_properties(value = nil)
         return @additional_properties ||= false if value.nil?
+
         @additional_properties = value
       end
 

data/lib/tasks/release.rake

@@ -1,53 +1,8 @@
-# 1. Bump the version
-# Update VERSION in lib/ruby_llm/schema/version.rb
-
-# 2. Update Gemfile.lock
-# bundle install
-
-# 3. Commit everything
-# git add .
-# git commit -m "Bump version to X.Y.Z"
-
-# 4. Push to main
-# git push origin main
-
-# 5. Trigger the release
-# bundle exec rake release:prepare
-
-# 6. Delete the release branch locally and remotely
-# git branch -d release/X.Y.Z
-# git push origin --delete release/X.Y.Z
+# frozen_string_literal: true
 
 namespace :release do
-  desc "Prepare and push the release branch to trigger the automated pipeline"
+  desc 'Prepare for release'
   task :prepare do
-    abort "Git working directory not clean. Commit or stash changes first." unless `git status --porcelain`.strip.empty?
-    abort "Not on main branch. Releases must be run from main branch" unless `git rev-parse --abbrev-ref HEAD`.strip == "main"
-
-    require_relative "../ruby_llm/schema/version"
-    version = RubyLlm::Schema::VERSION or abort "Could not determine version"
-
-    branch = "release/#{version}"
-
-    if system("git rev-parse --quiet --verify refs/tags/v#{version} > /dev/null 2>&1")
-      abort "Tag v#{version} already exists. Bump the version first."
-    end
-
-    if system("git show-ref --verify --quiet refs/heads/#{branch}")
-      abort "Local branch #{branch} already exists. Remove it or choose a new version."
-    end
-
-    sh "git fetch origin"
-
-    if system("git ls-remote --exit-code --heads origin #{branch} > /dev/null 2>&1")
-      abort "Release branch #{branch} already exists on origin. Remove it or choose a new version."
-    end
-
-    sh "git checkout -b #{branch}"
-    sh "git push -u origin #{branch}"
-
-    puts "Release branch #{branch} pushed. GitHub Actions will run tests and publish if they pass."
-  ensure
-    system "git checkout main"
+    sh 'overcommit --run'
   end
 end

metadata

@@ -1,58 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-schema
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel Friis
-autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2026-01-08 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: standard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description:
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A compact Ruby DSL for building standards-oriented JSON Schema documents
+  from Ruby.
 email:
 - d@friis.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- LICENSE.txt
+- LICENSE
 - README.md
-- RELEASE.md
-- Rakefile
 - lib/ruby_llm/schema.rb
 - lib/ruby_llm/schema/dsl.rb
 - lib/ruby_llm/schema/dsl/complex_types.rb
+- lib/ruby_llm/schema/dsl/conditionals.rb
 - lib/ruby_llm/schema/dsl/primitive_types.rb
 - lib/ruby_llm/schema/dsl/schema_builders.rb
 - lib/ruby_llm/schema/dsl/utilities.rb
@@ -62,15 +32,15 @@ files:
 - lib/ruby_llm/schema/validator.rb
 - lib/ruby_llm/schema/version.rb
 - lib/tasks/release.rake
-homepage: https://github.com/danielfriis/ruby_llm-schema
+homepage: https://github.com/crmne/ruby_llm-schema#readme
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/danielfriis/ruby_llm-schema
-  source_code_uri: https://github.com/danielfriis/ruby_llm-schema
-  changelog_uri: https://github.com/danielfriis/ruby_llm-schema/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/crmne/ruby_llm-schema#readme
+  source_code_uri: https://github.com/crmne/ruby_llm-schema
+  changelog_uri: https://github.com/crmne/ruby_llm-schema/releases
+  bug_tracker_uri: https://github.com/crmne/ruby_llm-schema/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -78,15 +48,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.1.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
-summary: A simple and clean Ruby DSL for creating JSON schemas.
+summary: A simple Ruby DSL for creating JSON schemas.
 test_files: []

data/.rspec

@@ -1,3 +0,0 @@
---require spec_helper
---color
---format documentation 

data/RELEASE.md

@@ -1,8 +0,0 @@
-# Release process
-
-1. Bump the version in `lib/ruby_llm/schema/version.rb`
-2. Run `bundle install` to update the gemspec
-3. Commit the changes with a message like "Bump version to X.Y.Z"
-4. Run `bundle exec rake release:prepare` to create a release branch and push it to GitHub
-5. Github Actions will run the tests and publish the gem if they pass
-6. Delete the release branch: `git branch -d release/<version> && git push origin --delete release/<version>`

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "standard/rake"
-
-# Load custom tasks
-Dir.glob("lib/tasks/**/*.rake").each { |r| load r }
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: %i[standard spec]