dspy 0.27.1 → 0.27.2

data/lib/dspy/tools/base.rb

@@ -2,6 +2,8 @@
 
 require 'sorbet-runtime'
 require 'json'
+require_relative '../type_system/sorbet_json_schema'
+require_relative '../mixins/type_coercion'
 
 module DSPy
   module Tools
@@ -9,6 +11,7 @@ module DSPy
     class Base
       extend T::Sig
       extend T::Helpers
+      include DSPy::Mixins::TypeCoercion
 
       class << self
         extend T::Sig
@@ -30,14 +33,14 @@ module DSPy
 
         # Get the JSON schema for the call method based on its Sorbet signature
         sig { returns(T::Hash[Symbol, T.untyped]) }
-        def call_schema
+        def call_schema_object
           method_obj = instance_method(:call)
           sig_info = T::Utils.signature_for_method(method_obj)
 
           if sig_info.nil?
             # Fallback for methods without signatures
             return {
-              type: :object,
+              type: "object",
               properties: {},
               required: []
             }
@@ -50,10 +53,8 @@ module DSPy
           sig_info.arg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
 
-            properties[param_name] = {
-              type: sorbet_type_to_json_schema(param_type)[:type],
-              description: "Parameter #{param_name}"
-            }
+            schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(param_type)
+            properties[param_name] = schema.merge({ description: "Parameter #{param_name}" })
 
             # Check if parameter is required (not nilable)
             unless param_type.class.name.include?('Union') && param_type.name.include?('NilClass')
@@ -65,10 +66,8 @@ module DSPy
           sig_info.kwarg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
 
-            properties[param_name] = {
-              type: sorbet_type_to_json_schema(param_type)[:type],
-              description: "Parameter #{param_name}"
-            }
+            schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(param_type)
+            properties[param_name] = schema.merge({ description: "Parameter #{param_name}" })
 
             # Check if parameter is required by looking at required kwarg names
             if sig_info.req_kwarg_names.include?(param_name)
@@ -79,54 +78,25 @@ module DSPy
           end
 
           {
-            type: :object,
+            type: "object",
             properties: properties,
             required: required
           }
         end
 
-        private
-
-        # Convert Sorbet types to JSON Schema types
-        sig { params(sorbet_type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
-        def sorbet_type_to_json_schema(sorbet_type)
-          if sorbet_type.is_a?(T::Types::Simple)
-            raw_type = sorbet_type.raw_type
-
-            if raw_type == String
-              { type: :string }
-            elsif raw_type == Integer
-              { type: :integer }
-            elsif raw_type == Float
-              { type: :number }
-            elsif raw_type == Numeric
-              { type: :number }
-            elsif raw_type == TrueClass || raw_type == FalseClass
-              { type: :boolean }
-            elsif raw_type == T::Boolean
-              { type: :boolean }
-            else
-              { type: :string, description: "#{raw_type} (converted to string)" }
-            end
-          elsif sorbet_type.is_a?(T::Types::Union)
-            # Handle nilable types
-            non_nil_types = sorbet_type.types.reject { |t| t == T::Utils.coerce(NilClass) }
-            if non_nil_types.length == 1
-              result = sorbet_type_to_json_schema(non_nil_types.first)
-              result[:description] = "#{result[:description] || ''} (optional)".strip
-              result
-            else
-              { type: :string, description: "Union type (converted to string)" }
-            end
-          elsif sorbet_type.is_a?(T::Types::TypedArray)
-            {
-              type: :array,
-              items: sorbet_type_to_json_schema(sorbet_type.type)
+        # Get the full tool schema for LLM tools format
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        def call_schema
+          {
+            type: 'function',
+            function: {
+              name: 'call',
+              description: "Call the #{self.name} tool",
+              parameters: call_schema_object
             }
-          else
-            { type: :string, description: "#{sorbet_type} (converted to string)" }
-          end
+          }
         end
+
       end
 
       # Instance methods that tools can use
@@ -143,7 +113,7 @@ module DSPy
       # Get the JSON schema string for the tool, formatted for LLM consumption
       sig { returns(String) }
       def schema
-        schema_obj = self.class.call_schema
+        schema_obj = self.class.call_schema_object
         tool_info = {
           name: name,
           description: description,
@@ -152,11 +122,17 @@ module DSPy
         JSON.generate(tool_info)
       end
 
+      # Get the full call schema compatible with LLM tools format
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def call_schema
+        self.class.call_schema
+      end
+
       # Dynamic call method for ReAct agent - parses JSON arguments and calls the typed method
       sig { params(args_json: T.untyped).returns(T.untyped) }
       def dynamic_call(args_json)
         # Parse arguments based on the call schema
-        schema = self.class.call_schema
+        schema = self.class.call_schema_object
 
         if schema[:properties].empty?
           # No parameters - call without arguments
@@ -178,12 +154,34 @@ module DSPy
 
           # Convert string keys to symbols and validate types
           kwargs = {}
-          schema[:properties].each do |param_name, param_schema|
-            key = param_name.to_s
-            if args.key?(key)
-              kwargs[param_name] = convert_argument_type(args[key], param_schema)
-            elsif schema[:required].include?(key)
-              return "Error: Missing required parameter: #{key}"
+          
+          # Get method signature for type information
+          method_obj = self.class.instance_method(:call)
+          sig_info = T::Utils.signature_for_method(method_obj)
+          
+          if sig_info
+            # Handle kwargs using type signature information
+            sig_info.kwarg_types.each do |param_name, param_type|
+              next if param_name == :block
+              
+              key = param_name.to_s
+              if args.key?(key)
+                kwargs[param_name] = coerce_value_to_type(args[key], param_type)
+              elsif schema[:required].include?(key)
+                return "Error: Missing required parameter: #{key}"
+              end
+            end
+            
+            # Handle positional args if any
+            sig_info.arg_types.each do |param_name, param_type|
+              next if param_name == :block
+              
+              key = param_name.to_s
+              if args.key?(key)
+                kwargs[param_name] = coerce_value_to_type(args[key], param_type)
+              elsif schema[:required].include?(key)
+                return "Error: Missing required parameter: #{key}"
+              end
             end
           end
 
@@ -195,32 +193,6 @@ module DSPy
 
       # Subclasses must implement their own call method with their own signature
 
-      protected
-
-      # Convert argument to the expected type based on JSON schema
-      sig { params(value: T.untyped, schema: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
-      def convert_argument_type(value, schema)
-        case schema[:type]
-        when :integer
-          value.is_a?(Integer) ? value : value.to_i
-        when :number
-          # Always convert to Float for :number types to ensure compatibility with strict Float signatures
-          value.to_f
-        when :boolean
-          case value
-          when true, false
-            value
-          when "true", "1", 1
-            true
-          when "false", "0", 0
-            false
-          else
-            !!value
-          end
-        else
-          value.to_s
-        end
-      end
     end
   end
 end

data/lib/dspy/tools/github_cli_toolset.rb

@@ -0,0 +1,437 @@
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'json'
+require_relative 'toolset'
+
+module DSPy
+  module Tools
+    # Enums for GitHub CLI operations
+    class IssueState < T::Enum
+      enums do
+        Open = new('open')
+        Closed = new('closed') 
+        All = new('all')
+      end
+    end
+
+    class PRState < T::Enum
+      enums do
+        Open = new('open')
+        Closed = new('closed')
+        Merged = new('merged')
+        All = new('all')
+      end
+    end
+
+    class ReviewState < T::Enum
+      enums do
+        Approve = new('approve')
+        Comment = new('comment')
+        RequestChanges = new('request-changes')
+      end
+    end
+
+    # Structs for complex return types
+    class IssueDetails < T::Struct
+      prop :number, Integer
+      prop :title, String
+      prop :state, String
+      prop :body, String
+      prop :url, String
+      prop :labels, T::Array[String]
+      prop :assignees, T::Array[String]
+    end
+
+    class PRDetails < T::Struct
+      prop :number, Integer
+      prop :title, String
+      prop :state, String
+      prop :body, String
+      prop :url, String
+      prop :base, String
+      prop :head, String
+      prop :mergeable, T::Boolean
+    end
+
+    # GitHub CLI toolset for common GitHub operations
+    class GitHubCLIToolset < Toolset
+      extend T::Sig
+
+      toolset_name "github"
+
+      # Expose methods as tools with descriptions
+      tool :create_issue, description: "Create a new GitHub issue"
+      tool :create_pr, description: "Create a new GitHub pull request"
+      tool :list_issues, description: "List GitHub issues with optional filters"
+      tool :list_prs, description: "List GitHub pull requests with optional filters"
+      tool :get_issue, description: "Get details of a specific GitHub issue"
+      tool :get_pr, description: "Get details of a specific GitHub pull request"
+      tool :comment_on_issue, description: "Add a comment to a GitHub issue"
+      tool :review_pr, description: "Add a review to a GitHub pull request"
+      tool :api_request, description: "Make an arbitrary GitHub API request"
+
+      sig { void }
+      def initialize
+        # No persistent state needed
+      end
+
+      sig { params(
+        title: String,
+        body: String,
+        labels: T::Array[String],
+        assignees: T::Array[String],
+        repo: T.nilable(String)
+      ).returns(String) }
+      def create_issue(title:, body:, labels: [], assignees: [], repo: nil)
+        cmd = build_gh_command(['issue', 'create'])
+        cmd << ['--title', shell_escape(title)]
+        cmd << ['--body', shell_escape(body)]
+        
+        labels.each { |label| cmd << ['--label', shell_escape(label)] }
+        assignees.each { |assignee| cmd << ['--assignee', shell_escape(assignee)] }
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          "Issue created successfully: #{result[:output].strip}"
+        else
+          "Failed to create issue: #{result[:error]}"
+        end
+      rescue => e
+        "Error creating issue: #{e.message}"
+      end
+
+      sig { params(
+        title: String,
+        body: String,
+        base: String,
+        head: String,
+        repo: T.nilable(String)
+      ).returns(String) }
+      def create_pr(title:, body:, base:, head:, repo: nil)
+        cmd = build_gh_command(['pr', 'create'])
+        cmd << ['--title', shell_escape(title)]
+        cmd << ['--body', shell_escape(body)]
+        cmd << ['--base', shell_escape(base)]
+        cmd << ['--head', shell_escape(head)]
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          "Pull request created successfully: #{result[:output].strip}"
+        else
+          "Failed to create pull request: #{result[:error]}"
+        end
+      rescue => e
+        "Error creating pull request: #{e.message}"
+      end
+
+      sig { params(
+        state: IssueState,
+        labels: T::Array[String],
+        assignee: T.nilable(String),
+        repo: T.nilable(String),
+        limit: Integer
+      ).returns(String) }
+      def list_issues(state: IssueState::Open, labels: [], assignee: nil, repo: nil, limit: 20)
+        cmd = build_gh_command(['issue', 'list', '--json', 'number,title,state,labels,assignees,url'])
+        cmd << ['--state', state.serialize]
+        cmd << ['--limit', limit.to_s]
+        
+        labels.each { |label| cmd << ['--label', shell_escape(label)] }
+        
+        if assignee
+          cmd << ['--assignee', shell_escape(assignee)]
+        end
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          parse_issue_list(result[:output])
+        else
+          "Failed to list issues: #{result[:error]}"
+        end
+      rescue => e
+        "Error listing issues: #{e.message}"
+      end
+
+      sig { params(
+        state: PRState,
+        author: T.nilable(String),
+        base: T.nilable(String),
+        repo: T.nilable(String),
+        limit: Integer
+      ).returns(String) }
+      def list_prs(state: PRState::Open, author: nil, base: nil, repo: nil, limit: 20)
+        cmd = build_gh_command(['pr', 'list', '--json', 'number,title,state,baseRefName,headRefName,url'])
+        cmd << ['--state', state.serialize]
+        cmd << ['--limit', limit.to_s]
+        
+        if author
+          cmd << ['--author', shell_escape(author)]
+        end
+        
+        if base
+          cmd << ['--base', shell_escape(base)]
+        end
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          parse_pr_list(result[:output])
+        else
+          "Failed to list pull requests: #{result[:error]}"
+        end
+      rescue => e
+        "Error listing pull requests: #{e.message}"
+      end
+
+      sig { params(issue_number: Integer, repo: T.nilable(String)).returns(String) }
+      def get_issue(issue_number:, repo: nil)
+        cmd = build_gh_command(['issue', 'view', issue_number.to_s, '--json', 'number,title,state,body,labels,assignees,url'])
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          parse_issue_details(result[:output])
+        else
+          "Failed to get issue: #{result[:error]}"
+        end
+      rescue => e
+        "Error getting issue: #{e.message}"
+      end
+
+      sig { params(pr_number: Integer, repo: T.nilable(String)).returns(String) }
+      def get_pr(pr_number:, repo: nil)
+        cmd = build_gh_command(['pr', 'view', pr_number.to_s, '--json', 'number,title,state,body,baseRefName,headRefName,mergeable,url'])
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          parse_pr_details(result[:output])
+        else
+          "Failed to get pull request: #{result[:error]}"
+        end
+      rescue => e
+        "Error getting pull request: #{e.message}"
+      end
+
+      sig { params(
+        issue_number: Integer,
+        comment: String,
+        repo: T.nilable(String)
+      ).returns(String) }
+      def comment_on_issue(issue_number:, comment:, repo: nil)
+        cmd = build_gh_command(['issue', 'comment', issue_number.to_s])
+        cmd << ['--body', shell_escape(comment)]
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          "Comment added successfully to issue ##{issue_number}"
+        else
+          "Failed to add comment: #{result[:error]}"
+        end
+      rescue => e
+        "Error adding comment: #{e.message}"
+      end
+
+      sig { params(
+        pr_number: Integer,
+        review_type: ReviewState,
+        comment: T.nilable(String),
+        repo: T.nilable(String)
+      ).returns(String) }
+      def review_pr(pr_number:, review_type:, comment: nil, repo: nil)
+        cmd = build_gh_command(['pr', 'review', pr_number.to_s])
+        cmd << ['--' + review_type.serialize.tr('_', '-')]
+        
+        if comment
+          cmd << ['--body', shell_escape(comment)]
+        end
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          "Review added successfully to PR ##{pr_number}"
+        else
+          "Failed to add review: #{result[:error]}"
+        end
+      rescue => e
+        "Error adding review: #{e.message}"
+      end
+
+      sig { params(
+        endpoint: String,
+        method: String,
+        fields: T::Hash[String, String],
+        repo: T.nilable(String)
+      ).returns(String) }
+      def api_request(endpoint:, method: 'GET', fields: {}, repo: nil)
+        cmd = build_gh_command(['api', endpoint])
+        cmd << ['--method', method.upcase]
+        
+        fields.each do |key, value|
+          cmd << ['-f', "#{key}=#{shell_escape(value)}"]
+        end
+        
+        if repo
+          cmd << ['--repo', shell_escape(repo)]
+        end
+
+        result = execute_command(cmd.flatten.join(' '))
+        
+        if result[:success]
+          result[:output]
+        else
+          "API request failed: #{result[:error]}"
+        end
+      rescue => e
+        "Error making API request: #{e.message}"
+      end
+
+      private
+
+      sig { params(args: T::Array[String]).returns(T::Array[String]) }
+      def build_gh_command(args)
+        ['gh'] + args
+      end
+
+      sig { params(str: String).returns(String) }
+      def shell_escape(str)
+        "\"#{str.gsub(/"/, '\\"')}\""
+      end
+
+      sig { params(cmd: String).returns(T::Hash[Symbol, T.untyped]) }
+      def execute_command(cmd)
+        output = `#{cmd} 2>&1`
+        success = Process.last_status.success?
+        
+        {
+          success: success,
+          output: success ? output : '',
+          error: success ? '' : output
+        }
+      end
+
+      sig { params(json_output: String).returns(String) }
+      def parse_issue_list(json_output)
+        issues = JSON.parse(json_output)
+        
+        if issues.empty?
+          "No issues found"
+        else
+          result = ["Found #{issues.length} issue(s):"]
+          issues.each do |issue|
+            labels = issue['labels']&.map { |l| l['name'] } || []
+            assignees = issue['assignees']&.map { |a| a['login'] } || []
+            
+            result << "##{issue['number']}: #{issue['title']} (#{issue['state']})"
+            result << "  Labels: #{labels.join(', ')}" unless labels.empty?
+            result << "  Assignees: #{assignees.join(', ')}" unless assignees.empty?
+            result << "  URL: #{issue['url']}"
+            result << ""
+          end
+          result.join("\n")
+        end
+      rescue JSON::ParserError => e
+        "Failed to parse issues data: #{e.message}"
+      end
+
+      sig { params(json_output: String).returns(String) }
+      def parse_pr_list(json_output)
+        prs = JSON.parse(json_output)
+        
+        if prs.empty?
+          "No pull requests found"
+        else
+          result = ["Found #{prs.length} pull request(s):"]
+          prs.each do |pr|
+            result << "##{pr['number']}: #{pr['title']} (#{pr['state']})"
+            result << "  #{pr['headRefName']} → #{pr['baseRefName']}"
+            result << "  URL: #{pr['url']}"
+            result << ""
+          end
+          result.join("\n")
+        end
+      rescue JSON::ParserError => e
+        "Failed to parse pull requests data: #{e.message}"
+      end
+
+      sig { params(json_output: String).returns(String) }
+      def parse_issue_details(json_output)
+        issue = JSON.parse(json_output)
+        labels = issue['labels']&.map { |l| l['name'] } || []
+        assignees = issue['assignees']&.map { |a| a['login'] } || []
+        
+        result = []
+        result << "Issue ##{issue['number']}: #{issue['title']}"
+        result << "State: #{issue['state']}"
+        result << "Labels: #{labels.join(', ')}" unless labels.empty?
+        result << "Assignees: #{assignees.join(', ')}" unless assignees.empty?
+        result << "URL: #{issue['url']}"
+        result << ""
+        result << "Body:"
+        body = issue['body']
+        result << (body && !body.empty? ? body : "No description provided")
+        
+        result.join("\n")
+      rescue JSON::ParserError => e
+        "Failed to parse issue details: #{e.message}"
+      end
+
+      sig { params(json_output: String).returns(String) }
+      def parse_pr_details(json_output)
+        pr = JSON.parse(json_output)
+        
+        result = []
+        result << "Pull Request ##{pr['number']}: #{pr['title']}"
+        result << "State: #{pr['state']}"
+        result << "Branch: #{pr['headRefName']} → #{pr['baseRefName']}"
+        result << "Mergeable: #{pr['mergeable'] ? 'Yes' : 'No'}"
+        result << "URL: #{pr['url']}"
+        result << ""
+        result << "Body:"
+        body = pr['body']
+        result << (body && !body.empty? ? body : "No description provided")
+        
+        result.join("\n")
+      rescue JSON::ParserError => e
+        "Failed to parse pull request details: #{e.message}"
+      end
+    end
+  end
+end