desiru 0.1.0 → 0.2.0

data/lib/desiru/modules/multi_chain_comparison.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # MultiChainComparison module that generates multiple chain-of-thought
+    # reasoning paths and compares them to produce the best answer
+    class MultiChainComparison < Desiru::Module
+      DEFAULT_SIGNATURE = 'question: string -> answer: string, reasoning: string'
+
+      def initialize(signature = nil, model: nil, **kwargs)
+        # Extract our specific options before passing to parent
+        @num_chains = kwargs.delete(:num_chains) || 3
+        @comparison_strategy = kwargs.delete(:comparison_strategy) || :vote
+        @temperature = kwargs.delete(:temperature) || 0.7
+
+        # Use default signature if none provided
+        signature ||= DEFAULT_SIGNATURE
+
+        # Pass remaining kwargs to parent (config, demos, metadata)
+        super
+      end
+
+      def forward(**inputs)
+        # Handle edge case of zero chains
+        return {} if @num_chains <= 0
+
+        # Generate multiple reasoning chains
+        chains = generate_chains(inputs)
+
+        # Compare chains to determine best answer
+        best_result = case @comparison_strategy
+                      when :vote
+                        vote_on_chains(chains)
+                      when :llm_judge
+                        llm_judge_chains(chains, inputs)
+                      when :confidence
+                        select_by_confidence(chains)
+                      else
+                        chains.first || {} # Fallback to first chain or empty hash
+                      end
+
+        # Ensure best_result is not nil
+        best_result ||= {}
+
+        # Include comparison metadata if requested
+        if signature.output_fields.key?('comparison_data') || signature.output_fields.key?(:comparison_data)
+          best_result[:comparison_data] = {
+            num_chains: chains.length,
+            strategy: @comparison_strategy,
+            all_chains: chains.map { |c| c[:reasoning] }
+          }
+        end
+
+        best_result
+      end
+
+      private
+
+      def generate_chains(inputs)
+        chains = []
+
+        @num_chains.times do |i|
+          chain_prompt = build_chain_prompt(inputs, i)
+
+          response = model.complete(
+            messages: [{ role: 'user', content: chain_prompt }],
+            temperature: @temperature
+          )
+
+          chain_result = parse_chain_response(response[:content])
+          chains << chain_result
+        end
+
+        chains
+      end
+
+      def build_chain_prompt(inputs, chain_index)
+        prompt = "Please solve this problem step by step (Approach #{chain_index + 1}):\n\n"
+
+        # Add inputs
+        inputs.each do |key, value|
+          prompt += "#{key}: #{value}\n"
+        end
+
+        prompt += "\nProvide your reasoning step by step, then give your final answer.\n"
+        prompt += "Format your response as:\n"
+        prompt += "REASONING: [Your step-by-step reasoning]\n"
+        prompt += "ANSWER: [Your final answer]\n"
+
+        # Add output field descriptions
+        if signature.output_fields.any?
+          prompt += "\nMake sure your answer includes:\n"
+          signature.output_fields.each do |name, field|
+            next if %w[reasoning comparison_data].include?(name.to_s)
+
+            prompt += "- #{name}: #{field.description || field.type}\n"
+          end
+        end
+
+        prompt
+      end
+
+      def parse_chain_response(response)
+        result = {}
+
+        # Extract reasoning
+        reasoning_match = response.match(/REASONING:\s*(.+?)(?=ANSWER:|$)/mi)
+        result[:reasoning] = reasoning_match ? reasoning_match[1].strip : response
+
+        # Extract answer
+        answer_match = response.match(/ANSWER:\s*(.+)/mi)
+
+        if answer_match
+          answer_text = answer_match[1].strip
+
+          # Try to parse structured answer
+          if answer_text.include?(':') || answer_text.include?('{')
+            result.merge!(parse_structured_answer(answer_text))
+          elsif !answer_text.empty?
+            # Single value answer
+            main_output_field = signature.output_fields.keys.map(&:to_sym).find do |k|
+              !%i[reasoning comparison_data].include?(k)
+            end
+            result[main_output_field] = answer_text if main_output_field
+          end
+        else
+          # No ANSWER: section found - check if we should extract from reasoning
+          signature.output_fields.keys.map(&:to_sym).find do |k|
+            !%i[reasoning comparison_data].include?(k)
+          end
+          # Don't set the field if there's no clear answer
+          # result[main_output_field] = nil if main_output_field
+        end
+
+        # Parse any additional fields that might be in the response
+        response.scan(/(\w+):\s*([^\n]+)/).each do |key, value|
+          key_sym = key.downcase.to_sym
+          result[key_sym] = value.strip if signature.output_fields.key?(key_sym) && !result.key?(key_sym)
+        end
+
+        result
+      end
+
+      def parse_structured_answer(answer_text)
+        parsed = {}
+
+        # Try to parse as key-value pairs
+        answer_text.scan(/(\w+):\s*([^\n,}]+)/).each do |key, value|
+          key_sym = key.downcase.to_sym
+          if signature.output_fields.key?(key_sym) || signature.output_fields.key?(key.downcase)
+            parsed[key_sym] =
+              value.strip
+          end
+        end
+
+        parsed
+      end
+
+      def vote_on_chains(chains)
+        return {} if chains.empty?
+
+        # Count votes for each unique answer
+        votes = Hash.new(0)
+        answer_to_chain = {}
+
+        chains.each do |chain|
+          # Get the main answer field (first non-metadata field)
+          answer_key = signature.output_fields.keys.map(&:to_sym).find do |k|
+            !%i[reasoning comparison_data].include?(k)
+          end
+          answer_value = chain[answer_key]
+
+          if answer_value && !answer_value.to_s.empty?
+            votes[answer_value] += 1
+            answer_to_chain[answer_value] ||= chain
+          end
+        end
+
+        # Return the chain with the most common answer
+        if votes.empty?
+          chains.first || {}
+        else
+          winning_answer = votes.max_by { |_, count| count }.first
+          answer_to_chain[winning_answer] || chains.first || {}
+        end
+      end
+
+      def llm_judge_chains(chains, original_inputs)
+        judge_prompt = "Given the following problem and multiple solution attempts, select the best answer:\n\n"
+
+        # Add original inputs
+        judge_prompt += "Original Problem:\n"
+        original_inputs.each do |key, value|
+          judge_prompt += "#{key}: #{value}\n"
+        end
+
+        # Add all chains
+        judge_prompt += "\nSolution Attempts:\n"
+        chains.each_with_index do |chain, i|
+          judge_prompt += "\n--- Attempt #{i + 1} ---\n"
+          judge_prompt += "Reasoning: #{chain[:reasoning]}\n"
+
+          answer_key = signature.output_fields.keys.map(&:to_sym).find do |k|
+            !%i[reasoning comparison_data].include?(k)
+          end
+          judge_prompt += "Answer: #{chain[answer_key]}\n" if chain[answer_key]
+        end
+
+        judge_prompt += "\nSelect the best attempt (1-#{chains.length}) and explain why:"
+
+        response = model.complete(
+          messages: [{ role: 'user', content: judge_prompt }],
+          temperature: 0.1 # Low temperature for more consistent judgment
+        )
+
+        # Extract selected chain index
+        selection_match = response[:content].match(/(?:attempt|option|choice)\s*#?(\d+)/i)
+        selected_index = selection_match ? selection_match[1].to_i - 1 : 0
+        selected_index = selected_index.clamp(0, chains.length - 1)
+
+        chains[selected_index]
+      end
+
+      def select_by_confidence(chains)
+        # Ask model to rate confidence for each chain
+        chains_with_confidence = chains.map do |chain|
+          confidence_prompt = "Rate your confidence (0-100) in this reasoning and answer:\n"
+          confidence_prompt += "Reasoning: #{chain[:reasoning]}\n"
+
+          answer_key = signature.output_fields.keys.map(&:to_sym).find do |k|
+            !%i[reasoning comparison_data].include?(k)
+          end
+          confidence_prompt += "Answer: #{chain[answer_key]}\n" if chain[answer_key]
+
+          confidence_prompt += "\nRespond with just a number between 0 and 100:"
+
+          response = model.complete(
+            messages: [{ role: 'user', content: confidence_prompt }],
+            temperature: 0.1
+          )
+
+          confidence = response[:content].scan(/\d+/).first&.to_i || 50
+          chain.merge(confidence: confidence)
+        end
+
+        # Select chain with highest confidence
+        chains_with_confidence.max_by { |c| c[:confidence] }
+      end
+    end
+  end
+end
+
+# Register in the main module namespace for convenience
+module Desiru
+  MultiChainComparison = Modules::MultiChainComparison
+end

data/lib/desiru/modules/predict.rb

@@ -4,6 +4,13 @@ module Desiru
   module Modules
     # Basic prediction module - the fundamental building block
     class Predict < Module
+      DEFAULT_SIGNATURE = 'question: string -> answer: string'
+
+      def initialize(signature = nil, model: nil, **)
+        signature ||= DEFAULT_SIGNATURE
+        super
+      end
+
       def forward(inputs)
         prompt = build_prompt(inputs)
 
@@ -14,6 +21,8 @@ module Desiru
           demos: demos
         )
 
+        Desiru.logger.info("Predict response: #{response}")
+
         parse_response(response[:content])
       end
 
@@ -32,7 +41,12 @@ module Desiru
 
           #{format_signature}
 
-          Respond with only the requested output fields in a clear format.
+          Format your response with each output field on its own line using the pattern:
+          field_name: value
+
+          For example, if the output field is "answer", write:
+          answer: Your answer here
+
           #{format_descriptions}
         PROMPT
       end

data/lib/desiru/modules/program_of_thought.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Desiru
+  module Modules
+    # ProgramOfThought module that generates executable code to solve problems
+    # Similar to ChainOfThought but produces code instead of reasoning steps
+    # Supports both Ruby and Python code generation
+    class ProgramOfThought < Desiru::Module
+      DEFAULT_SIGNATURE = 'question: string -> answer: string, code: string'
+
+      def initialize(signature = nil, model: nil, **kwargs)
+        # Extract our specific options before passing to parent
+        @max_iterations = kwargs.delete(:max_iterations) || 1
+        @code_language = validate_language(kwargs.delete(:code_language) || 'ruby')
+        @timeout = kwargs.delete(:timeout) || 5 # seconds
+        @safe_mode = kwargs.delete(:safe_mode) != false # default true
+
+        # Use default signature if none provided
+        signature ||= DEFAULT_SIGNATURE
+
+        # If signature is a double/mock (for testing), store it directly
+        if signature.respond_to?(:output_fields) && signature.respond_to?(:input_fields) &&
+           !signature.is_a?(Signature) && !signature.is_a?(String)
+          @signature = signature
+          @model = model || Desiru.configuration.default_model
+          @config = default_config.merge(kwargs[:config] || {})
+          @demos = kwargs[:demos] || []
+          @metadata = kwargs[:metadata] || {}
+          @call_count = 0
+          validate_model! if respond_to?(:validate_model!, true)
+          register_module if respond_to?(:register_module, true)
+        else
+          # Pass remaining kwargs to parent (config, demos, metadata)
+          super
+        end
+      end
+
+      def forward(**inputs)
+        trace_metadata = { code_language: @code_language, safe_mode: @safe_mode }
+
+        if defined?(Desiru::TraceContext) && Desiru::TraceContext.respond_to?(:current) && Desiru::TraceContext.current
+          Desiru::TraceContext.add_metadata(trace_metadata)
+        elsif defined?(Desiru::Core) && Desiru::Core.respond_to?(:trace_context) &&
+              Desiru::Core.trace_context.respond_to?(:current) && Desiru::Core.trace_context.current
+          Desiru::Core.trace_context.add_metadata(trace_metadata)
+        end
+
+        # Enhance the prompt to request code generation
+        code_prompt = build_code_prompt(inputs)
+
+        # Get the model to generate code
+        response = model.complete(
+          messages: [{ role: 'user', content: code_prompt }],
+          temperature: 0.3 # Lower temperature for more deterministic code
+        )
+
+        generated_code = extract_code(response[:content])
+
+        Desiru.logger.debug("Generated #{@code_language} code: #{generated_code}")
+
+        # Execute the generated code if safe
+        result = if @safe_mode && !safe_to_execute?(generated_code)
+                   { error: "Generated code deemed unsafe to execute" }
+                 else
+                   execute_code(generated_code, inputs)
+                 end
+
+        # Format outputs according to signature
+        format_outputs(result, generated_code)
+      rescue StandardError => e
+        Desiru.logger.error("ProgramOfThought error: #{e.message}")
+        format_error_output(e, '')
+      end
+
+      private
+
+      def validate_language(language)
+        supported = %w[ruby python]
+        unless supported.include?(language.to_s.downcase)
+          raise ModuleError, "Unsupported language: #{language}. Supported: #{supported.join(', ')}"
+        end
+
+        language.to_s.downcase
+      end
+
+      def build_code_prompt(inputs)
+        prompt = "You are a programming assistant. Generate #{@code_language} code to solve this problem.\n\n"
+
+        # Add input context
+        prompt += "Given inputs:\n" if inputs.any?
+        if inputs.any?
+          inputs.each do |key, value|
+            prompt += "#{key}: #{format_input_value(value)}\n"
+          end
+          prompt += "\n"
+        end
+
+        # Add expected output format
+        prompt += "Expected outputs:\n"
+        signature.output_fields.each do |name, field|
+          next if name == :code # Skip the code field itself
+
+          prompt += "- #{name} (#{field.type}): #{field.description || 'No description'}\n"
+        end
+
+        prompt += "\nGenerate executable #{@code_language} code that processes the inputs "
+        prompt += "and returns the expected outputs. "
+        prompt += "Wrap your code in triple backticks with the language identifier.\n"
+
+        if @code_language == 'ruby'
+          prompt += "The code should define a method called 'solve' that takes the inputs "
+          prompt += "as keyword arguments and returns a hash with the output values."
+        else # python
+          prompt += "The code should define a function called 'solve' that takes the inputs "
+          prompt += "as keyword arguments and returns a dictionary with the output values."
+        end
+
+        prompt
+      end
+
+      def format_input_value(value)
+        case value
+        when Array
+          "[#{value.map { |v| format_input_value(v) }.join(', ')}]"
+        when Hash
+          value.to_json
+        else
+          value.to_s
+        end
+      end
+
+      def extract_code(response)
+        # Extract code from markdown code blocks
+        code_match = response.match(/```#{@code_language}?\n(.*?)```/m)
+        return code_match[1].strip if code_match
+
+        # Fallback: try to extract any code block
+        code_match = response.match(/```\n(.*?)```/m)
+        return code_match[1].strip if code_match
+
+        # Last resort: assume the entire response is code
+        response.strip
+      end
+
+      def safe_to_execute?(code)
+        return true unless @safe_mode
+
+        # Language-specific dangerous patterns
+        dangerous_patterns = case @code_language
+                             when 'ruby'
+                               ruby_dangerous_patterns
+                             when 'python'
+                               python_dangerous_patterns
+                             else
+                               []
+                             end
+
+        dangerous_patterns.none? { |pattern| code.match?(pattern) }
+      end
+
+      def ruby_dangerous_patterns
+        [
+          /system\s*\(/,
+          /exec\s*\(/,
+          /eval\s*\(/,
+          /%x\{/,
+          /`.*`/,
+          /File\s*\.\s*delete/,
+          /FileUtils\s*\.\s*rm/,
+          /Dir\s*\.\s*delete/,
+          /require\s+['"]net/,
+          /Socket/,
+          /Process\s*\.\s*kill/,
+          /IO\s*\.\s*popen/,
+          /Open3/,
+          /\$SAFE\s*=/
+        ]
+      end
+
+      def python_dangerous_patterns
+        [
+          /os\.system/,
+          /subprocess/,
+          /eval\s*\(/,
+          /exec\s*\(/,
+          /compile\s*\(/,
+          /__import__/,
+          /open\s*\([^,)]*,\s*['"][wa]/,
+          /os\.remove/,
+          /shutil\.rmtree/,
+          /socket/,
+          /requests/,
+          /urllib/
+        ]
+      end
+
+      def execute_code(code, inputs)
+        case @code_language
+        when 'ruby'
+          execute_ruby_code(code, inputs)
+        when 'python'
+          execute_python_code(code, inputs)
+        else
+          { error: "Unsupported language for execution: #{@code_language}" }
+        end
+      end
+
+      def execute_ruby_code(code, inputs)
+        # Create a safe execution context
+        context = Object.new
+
+        # Use timeout for safety
+        result = Timeout.timeout(@timeout) do
+          # Define the code in the context
+          context.instance_eval(code)
+
+          # Call the solve method if it exists
+          if context.respond_to?(:solve)
+            context.solve(**inputs.transform_keys(&:to_sym))
+          else
+            { error: "Generated code does not define a 'solve' method" }
+          end
+        end
+
+        # Ensure result is a hash
+        result.is_a?(Hash) ? result : { result: result }
+      rescue Timeout::Error
+        { error: "Code execution timed out after #{@timeout} seconds" }
+      rescue StandardError => e
+        { error: "Code execution failed: #{e.message}" }
+      end
+
+      def execute_python_code(code, _inputs)
+        # For Python execution, we would need to use a Python interpreter
+        # This is a placeholder that returns a message about Python support
+        {
+          error: "Python code execution not yet implemented. Generated code saved.",
+          python_code: code,
+          note: "To execute Python code, integrate with a Python runtime or use system calls in non-safe mode."
+        }
+      end
+
+      def format_outputs(result, generated_code)
+        outputs = {}
+
+        # Always include the generated code if requested in signature
+        outputs[:code] = generated_code if signature.output_fields.key?(:code)
+
+        if result[:error]
+          # Handle error case - always include error
+          outputs[:error] = result[:error]
+
+          # Add any additional error info
+          outputs[:python_code] = result[:python_code] if result[:python_code]
+          outputs[:note] = result[:note] if result[:note]
+
+          # Fill other fields with defaults
+          signature.output_fields.each do |name, field|
+            next if outputs.key?(name)
+
+            outputs[name] = field.default || nil
+          end
+        else
+          # Map result to expected outputs
+          signature.output_fields.each do |name, field|
+            next if name == :code # Already handled
+
+            # Don't use || here because it will treat false as falsy
+            value = result.key?(name) ? result[name] : result[name.to_s]
+            outputs[name] = if value.nil?
+                              field.default || nil
+                            else
+                              coerce_output_value(value, field)
+                            end
+          end
+        end
+
+        outputs
+      end
+
+      def format_error_output(error, code = '')
+        outputs = {}
+
+        # Always include code field if it's in the signature, even if empty
+        outputs[:code] = code if signature.output_fields.key?(:code)
+        outputs[:error] = "ProgramOfThought error: #{error.message}"
+
+        # Fill other fields with defaults
+        signature.output_fields.each do |name, field|
+          next if outputs.key?(name)
+
+          outputs[name] = field.default || nil
+        end
+
+        outputs
+      end
+
+      def coerce_output_value(value, field)
+        return value unless value && field.type
+
+        case field.type
+        when :int
+          # Only coerce if it's a valid integer representation
+          return value unless value.to_s.match?(/\A-?\d+\z/)
+
+          value.to_i
+        when :float
+          # Only coerce if it's a valid float representation
+          begin
+            Float(value.to_s)
+          rescue StandardError
+            (value)
+          end
+        when :bool
+          return true if value.to_s.downcase == 'true'
+          return false if value.to_s.downcase == 'false'
+
+          !!value
+        when :list
+          Array(value)
+        when :hash
+          value.is_a?(Hash) ? value : { value: value }
+        else
+          value
+        end
+      rescue StandardError
+        value
+      end
+    end
+  end
+end
+
+# Register in the main module namespace for convenience
+module Desiru
+  ProgramOfThought = Modules::ProgramOfThought
+end