sorbet-baml 0.1.0 → 0.3.0

data/lib/sorbet_baml/converter.rb

@@ -1,9 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
-require "set"
-require_relative "comment_extractor"
+require 'sorbet-runtime'
+require_relative 'comment_extractor'
 
 module SorbetBaml
   # Main converter class for transforming Sorbet types to BAML
@@ -18,24 +17,24 @@ module SorbetBaml
     sig { params(klasses: T::Array[T.class_of(T::Struct)], options: T::Hash[Symbol, T.untyped]).returns(String) }
     def self.from_structs(klasses, options = {})
       converter = new(options)
-      
+
       if converter.instance_variable_get(:@include_dependencies)
         # When dependencies are enabled, collect all unique dependencies and convert once
         all_dependencies = Set.new
         enum_dependencies = Set.new
-        
+
         klasses.each do |klass|
           deps = DependencyResolver.resolve_dependencies(klass)
           all_dependencies.merge(deps)
           enum_deps = converter.send(:find_enum_dependencies, deps)
           enum_dependencies.merge(enum_deps)
         end
-        
+
         # Convert all unique types
         converted_types = []
         enum_dependencies.each { |enum_klass| converted_types << converter.convert_enum(enum_klass) }
         all_dependencies.each { |struct_klass| converted_types << converter.send(:convert_single_struct, struct_klass) }
-        
+
         converted_types.join("\n\n")
       else
         # When dependencies are disabled, convert each struct individually
@@ -43,6 +42,11 @@ module SorbetBaml
       end
     end
 
+    sig { params(klass: T.class_of(T::Struct), options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def self.from_tool(klass, options = {})
+      new(options).convert_tool(klass)
+    end
+
     sig { params(klass: T.class_of(T::Enum), options: T::Hash[Symbol, T.untyped]).returns(String) }
     def self.from_enum(klass, options = {})
       new(options).convert_enum(klass)
@@ -61,15 +65,15 @@ module SorbetBaml
       if @include_dependencies
         # Get all dependencies in correct order and convert them all
         dependencies = DependencyResolver.resolve_dependencies(klass)
-        
+
         # Also find all enum dependencies
         enum_dependencies = find_enum_dependencies(dependencies)
-        
+
         # Convert enums first, then structs
         converted_types = []
         enum_dependencies.each { |enum_klass| converted_types << convert_enum(enum_klass) }
         dependencies.each { |dep_klass| converted_types << convert_single_struct(dep_klass) }
-        
+
         converted_types.join("\n\n")
       else
         # Just convert the single struct
@@ -82,17 +86,17 @@ module SorbetBaml
       class_name = klass.name || klass.to_s
       simple_name = class_name.split('::').last
       lines = ["enum #{simple_name} {"]
-      
+
       # Extract comments if requested
       comments = @include_descriptions ? CommentExtractor.extract_enum_comments(klass) : {}
-      
+
       # Get all enum values by calling values method
       enum_values = klass.values
       enum_values.each do |enum_instance|
         value = enum_instance.serialize
-        
+
         # Find the constant name for this value
-        constant_name = nil
+        constant_name = T.let(nil, T.nilable(String))
         klass.constants.each do |const_name|
           const_value = klass.const_get(const_name)
           if const_value.is_a?(klass) && const_value.serialize == value
@@ -100,18 +104,48 @@ module SorbetBaml
             break
           end
         end
-        
+
         line = "#{' ' * @indent_size}\"#{value}\""
-        
+
         # Add description if available (BAML uses @description annotations, not comments)
         if @include_descriptions && constant_name && comments[constant_name]
-          line += " @description(\"#{comments[constant_name].gsub('"', '\\"')}\")"
+          line += " @description(\"#{T.must(comments[constant_name]).gsub('"', '\\"')}\")"
+        end
+
+        lines << line
+      end
+
+      lines << '}'
+      lines.join("\n")
+    end
+
+    sig { params(klass: T.class_of(T::Struct)).returns(String) }
+    def convert_tool(klass)
+      # Tools generate BAML class definitions similar to structs but for tool specifications
+      # They can include action fields with @description annotations
+      props = klass.props
+
+      class_name = klass.name || klass.to_s
+      simple_name = class_name.split('::').last
+      lines = ["class #{simple_name} {"]
+
+      # Extract comments if requested
+      comments = @include_descriptions ? CommentExtractor.extract_field_comments(klass) : {}
+
+      props.each do |name, prop_info|
+        baml_type = TypeMapper.map_type(prop_info[:type_object])
+        line = "#{' ' * @indent_size}#{name} #{baml_type}"
+
+        # Add description if available (BAML uses @description annotations)
+        if @include_descriptions && comments[name.to_s]
+          escaped_comment = T.must(comments[name.to_s]).gsub('"', '\\"')
+          line += " @description(\"#{escaped_comment}\")"
         end
-        
+
         lines << line
       end
-      
-      lines << "}"
+
+      lines << '}'
       lines.join("\n")
     end
 
@@ -120,49 +154,49 @@ module SorbetBaml
     sig { params(klass: T.class_of(T::Struct)).returns(String) }
     def convert_single_struct(klass)
       props = klass.props
-      
+
       class_name = klass.name || klass.to_s
       simple_name = class_name.split('::').last
       lines = ["class #{simple_name} {"]
-      
+
       # Extract comments if requested
       comments = @include_descriptions ? CommentExtractor.extract_field_comments(klass) : {}
-      
+
       props.each do |name, prop_info|
         baml_type = TypeMapper.map_type(prop_info[:type_object])
         line = "#{' ' * @indent_size}#{name} #{baml_type}"
-        
+
         # Add description if available (BAML uses @description annotations)
         if @include_descriptions && comments[name.to_s]
-          escaped_comment = comments[name.to_s].gsub('"', '\\"')
+          escaped_comment = T.must(comments[name.to_s]).gsub('"', '\\"')
           line += " @description(\"#{escaped_comment}\")"
         end
-        
+
         lines << line
       end
-      
-      lines << "}"
+
+      lines << '}'
       lines.join("\n")
     end
-    
+
     sig { params(struct_classes: T::Array[T.class_of(T::Struct)]).returns(T::Array[T.class_of(T::Enum)]) }
     def find_enum_dependencies(struct_classes)
       enum_deps = Set.new
-      
+
       struct_classes.each do |struct_klass|
         struct_klass.props.each do |_name, prop_info|
           type_object = prop_info[:type_object]
           enum_deps.merge(extract_enum_types(type_object))
         end
       end
-      
+
       enum_deps.to_a
     end
-    
+
     sig { params(type_object: T.untyped).returns(T::Array[T.class_of(T::Enum)]) }
     def extract_enum_types(type_object)
       return [] if type_object.nil?
-      
+
       case type_object
       when T::Types::Simple
         extract_enum_from_simple_type(type_object.raw_type)
@@ -182,7 +216,7 @@ module SorbetBaml
         end
       end
     end
-    
+
     sig { params(raw_type: T.untyped).returns(T::Array[T.class_of(T::Enum)]) }
     def extract_enum_from_simple_type(raw_type)
       # Check if this raw_type is a T::Enum subclass
@@ -193,4 +227,4 @@ module SorbetBaml
       end
     end
   end
-end
+end

data/lib/sorbet_baml/dependency_resolver.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
+require 'sorbet-runtime'
 
 module SorbetBaml
   # Resolves dependencies between T::Struct types and orders them topologically
@@ -23,10 +23,10 @@ module SorbetBaml
     def resolve_dependencies(klass)
       @visited.clear
       @dependencies.clear
-      
+
       # Perform depth-first search to find all dependencies
       visit(klass)
-      
+
       # Dependencies are already in correct topological order
       # (dependencies first, then the types that depend on them)
       @dependencies
@@ -37,15 +37,15 @@ module SorbetBaml
     sig { params(klass: T.class_of(T::Struct)).void }
     def visit(klass)
       return if @visited.include?(klass)
-      
+
       @visited.add(klass)
-      
+
       # Find all T::Struct dependencies in this class
       struct_dependencies = find_struct_dependencies(klass)
-      
+
       # Visit dependencies first (depth-first)
       struct_dependencies.each { |dep| visit(dep) }
-      
+
       # Add this class after its dependencies
       @dependencies << klass
     end
@@ -53,19 +53,19 @@ module SorbetBaml
     sig { params(klass: T.class_of(T::Struct)).returns(T::Array[T.class_of(T::Struct)]) }
     def find_struct_dependencies(klass)
       dependencies = []
-      
+
       klass.props.each do |_name, prop_info|
         type_object = prop_info[:type_object]
         dependencies.concat(extract_struct_types(type_object))
       end
-      
+
       dependencies.uniq
     end
 
     sig { params(type_object: T.untyped).returns(T::Array[T.class_of(T::Struct)]) }
     def extract_struct_types(type_object)
       return [] if type_object.nil?
-      
+
       case type_object
       when T::Types::Simple
         extract_from_simple_type(type_object.raw_type)
@@ -96,4 +96,4 @@ module SorbetBaml
       end
     end
   end
-end
+end

data/lib/sorbet_baml/description_extension.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module SorbetBaml
+  # Extension module to add description: parameter support to T::Struct
+  module DescriptionExtension
+    extend T::Sig
+
+    # Override const to support description parameter
+    sig { params(name: Symbol, type: T.untyped, description: T.nilable(String), kwargs: T.untyped).void }
+    def const(name, type, description: nil, **kwargs)
+      if description
+        super(name, type, extra: { description: description }, **kwargs)
+      else
+        super(name, type, **kwargs)
+      end
+    end
+
+    # Override prop to support description parameter
+    sig { params(name: Symbol, type: T.untyped, description: T.nilable(String), kwargs: T.untyped).void }
+    def prop(name, type, description: nil, **kwargs)
+      if description
+        super(name, type, extra: { description: description }, **kwargs)
+      else
+        super(name, type, **kwargs)
+      end
+    end
+  end
+end
+
+# Automatically extend T::Struct with description support
+T::Struct.extend(SorbetBaml::DescriptionExtension)

data/lib/sorbet_baml/description_extractor.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module SorbetBaml
+  # Extracts description parameters from T::Struct prop and const declarations
+  class DescriptionExtractor
+    extend T::Sig
+
+    sig { params(klass: T::Class[T.anything]).returns(T::Hash[String, T.nilable(String)]) }
+    def self.extract_prop_descriptions(klass)
+      descriptions = {}
+
+      # Check if this is a T::Struct with props
+      return descriptions unless klass.respond_to?(:props)
+
+      begin
+        T.unsafe(klass).props.each do |field_name, prop_info|
+          next unless prop_info.is_a?(Hash)
+
+          # Check if the prop has a description in the :extra field
+          extra = prop_info[:extra]
+          descriptions[field_name.to_s] = extra[:description] if extra.is_a?(Hash) && extra[:description].is_a?(String)
+        end
+      rescue StandardError
+        # Handle any errors gracefully and return empty hash
+        return {}
+      end
+
+      descriptions
+    end
+  end
+end

data/lib/sorbet_baml/dspy_tool_converter.rb

@@ -0,0 +1,97 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module SorbetBaml
+  # Converter for DSPy tools to BAML format
+  class DSPyToolConverter
+    extend T::Sig
+
+    sig { params(klass: T.class_of(DSPy::Tools::Base), options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def self.from_dspy_tool(klass, options = {})
+      new(options).convert_dspy_tool(klass)
+    end
+
+    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    def initialize(options = {})
+      @options = options
+      @indent_size = T.let(options.fetch(:indent_size, 2), Integer)
+      @include_descriptions = T.let(options.fetch(:include_descriptions, true), T::Boolean)
+    end
+
+    sig { params(klass: T.class_of(DSPy::Tools::Base)).returns(String) }
+    def convert_dspy_tool(klass)
+      # Extract tool metadata from DSPy tool
+      tool_name = klass.tool_name_value || klass.name&.split('::')&.last
+      tool_description = klass.tool_description_value
+
+      # Get parameters from DSPy's call_schema which extracts from Sorbet signatures
+      call_schema = klass.call_schema
+      parameters = call_schema[:properties] || {}
+      required_params = call_schema[:required] || []
+
+      lines = []
+
+      # Add tool description as class-level comment if available
+      lines << "// #{tool_description}" if @include_descriptions && tool_description
+
+      # Generate BAML class definition
+      lines << "class #{tool_name} {"
+
+      parameters.each do |param_name, param_info|
+        # Convert JSON schema type to BAML type
+        baml_type = json_schema_type_to_baml(param_info)
+
+        # Add optional marker if parameter is not required
+        baml_type += '?' unless required_params.include?(param_name.to_s)
+
+        line = "#{' ' * @indent_size}#{param_name} #{baml_type}"
+
+        # Add description from schema if available
+        if @include_descriptions && param_info[:description]
+          escaped_description = param_info[:description].gsub('"', '\\"')
+          line += " @description(\"#{escaped_description}\")"
+        end
+
+        lines << line
+      end
+
+      lines << '}'
+      lines.join("\n")
+    end
+
+    private
+
+    sig { params(json_schema_info: T::Hash[Symbol, T.untyped]).returns(String) }
+    def json_schema_type_to_baml(json_schema_info)
+      type = json_schema_info[:type]
+
+      case type
+      when :string, 'string'
+        'string'
+      when :integer, 'integer'
+        'int'
+      when :number, 'number'
+        'float'
+      when :boolean, 'boolean'
+        'bool'
+      when :array, 'array'
+        item_type = json_schema_info.dig(:items, :type)
+        case item_type
+        when :string, 'string' then 'string[]'
+        when :integer, 'integer' then 'int[]'
+        when :number, 'number' then 'float[]'
+        when :boolean, 'boolean' then 'bool[]'
+        else 'string[]' # fallback
+        end
+      when :object, 'object'
+        # For object types, we'll default to a map<string, string>
+        # In a more sophisticated implementation, we'd handle nested objects
+        'map<string, string>'
+      else
+        'string' # fallback for unknown types
+      end
+    end
+  end
+end

data/lib/sorbet_baml/dspy_tool_extensions.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module SorbetBaml
+  # Extensions to add BAML conversion methods to DSPy::Tools::Base
+  module DSPyToolExtensions
+    extend T::Sig
+
+    # Convert this DSPy tool to BAML tool definition
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def to_baml(options = {})
+      baml_tool_definition(options)
+    end
+
+    # Convert this DSPy tool to BAML tool definition with options
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def baml_tool_definition(options = {})
+      SorbetBaml::DSPyToolConverter.from_dspy_tool(T.cast(self, T.class_of(DSPy::Tools::Base)), options)
+    end
+  end
+end

data/lib/sorbet_baml/enum_extensions.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
+require 'sorbet-runtime'
 
 module SorbetBaml
   # Extensions to add BAML conversion methods to T::Enum
@@ -20,4 +20,4 @@ module SorbetBaml
       SorbetBaml::Converter.from_enum(T.cast(self, T.class_of(T::Enum)), options)
     end
   end
-end
+end

data/lib/sorbet_baml/struct_extensions.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
+require 'sorbet-runtime'
 
 module SorbetBaml
   # Extensions to add BAML conversion methods to T::Struct
@@ -20,4 +20,4 @@ module SorbetBaml
       SorbetBaml::Converter.from_struct(T.cast(self, T.class_of(T::Struct)), options)
     end
   end
-end
+end

data/lib/sorbet_baml/tool_extensions.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module SorbetBaml
+  # Extensions to add BAML tool conversion methods to T::Struct
+  module ToolExtensions
+    extend T::Sig
+
+    # Convert this struct to BAML tool definition
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def to_baml_tool(options = {})
+      baml_tool_definition(options)
+    end
+
+    # Convert this struct to BAML tool definition with options
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(String) }
+    def baml_tool_definition(options = {})
+      SorbetBaml::Converter.from_tool(T.cast(self, T.class_of(T::Struct)), options)
+    end
+  end
+end

data/lib/sorbet_baml/type_mapper.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
+require 'sorbet-runtime'
 
 module SorbetBaml
   # Maps Sorbet type objects to BAML type strings
@@ -10,8 +10,8 @@ module SorbetBaml
 
     sig { params(type_object: T.untyped).returns(String) }
     def self.map_type(type_object)
-      return "string" if type_object.nil?
-      
+      return 'string' if type_object.nil?
+
       case type_object
       when T::Types::Simple
         map_simple_type(type_object.raw_type)
@@ -25,7 +25,7 @@ module SorbetBaml
           map_union_type(type_object)
         else
           # Fallback for unknown types
-          "unknown"
+          'unknown'
         end
       end
     end
@@ -33,27 +33,27 @@ module SorbetBaml
     sig { params(raw_type: T.untyped).returns(String) }
     def self.map_simple_type(raw_type)
       case raw_type.name
-      when "String"
-        "string"
-      when "Integer"
-        "int"
-      when "Float"
-        "float"
-      when "TrueClass", "FalseClass"
-        "bool"
-      when "NilClass"
-        "null"
-      when "Symbol"
-        "string"
-      when "Date", "DateTime", "Time"
-        "string"
+      when 'String'
+        'string'
+      when 'Integer'
+        'int'
+      when 'Float'
+        'float'
+      when 'TrueClass', 'FalseClass'
+        'bool'
+      when 'NilClass'
+        'null'
+      when 'Symbol'
+        'string'
+      when 'Date', 'DateTime', 'Time'
+        'string'
       else
         # Check if it's a T::Struct or T::Enum
         if raw_type < T::Struct || raw_type < T::Enum
           type_name = raw_type.name || raw_type.to_s
-          type_name.split('::').last || "unknown"
+          type_name.split('::').last || 'unknown'
         else
-          "unknown"
+          'unknown'
         end
       end
     end
@@ -63,28 +63,26 @@ module SorbetBaml
       types = type_object.types
       nil_type = types.find { |t| t.raw_type == NilClass }
       non_nil_types = types.reject { |t| t.raw_type == NilClass }
-      
-      if non_nil_types.empty?
-        return "null"
-      end
-      
+
+      return 'null' if non_nil_types.empty?
+
       if non_nil_types.size == 1
         # This is T.nilable(T) - single type with nil
         base_type = map_type(non_nil_types.first)
         return nil_type ? "#{base_type}?" : base_type
       end
-      
+
       # This is T.any with multiple types
       mapped_types = non_nil_types.map { |t| map_type(t) }
-      
+
       # Special case: TrueClass + FalseClass = bool
-      if mapped_types.sort == ["bool", "bool"]
-        union_string = "bool"
-      else
-        # Remove duplicates and join
-        union_string = mapped_types.uniq.join(" | ")
-      end
-      
+      union_string = if mapped_types.sort == %w[bool bool]
+                       'bool'
+                     else
+                       # Remove duplicates and join
+                       mapped_types.uniq.join(' | ')
+                     end
+
       # If nil is present, wrap in parentheses and add ?
       if nil_type
         "(#{union_string})?"
@@ -96,9 +94,9 @@ module SorbetBaml
     sig { params(type_object: T.untyped).returns(String) }
     def self.map_array_type(type_object)
       element_type = map_type(type_object.type)
-      
+
       # If element type contains union (|), wrap in parentheses for correct precedence
-      if element_type.include?("|")
+      if element_type.include?('|')
         "(#{element_type})[]"
       else
         "#{element_type}[]"
@@ -113,4 +111,4 @@ module SorbetBaml
       "map<#{key_type}, #{value_type}>"
     end
   end
-end
+end

data/lib/sorbet_baml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SorbetBaml
-  VERSION = "0.1.0"
+  VERSION = '0.3.0'
 end