desiru 0.1.0 → 0.1.1

data/lib/desiru/modules/program_of_thought.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # ProgramOfThought module that generates executable code to solve problems
+    # Similar to ChainOfThought but produces code instead of reasoning steps
+    class ProgramOfThought < Desiru::Module
+      def initialize(signature = nil, model: nil, **kwargs)
+        super
+        @max_iterations = kwargs[:max_iterations] || 1
+        @code_language = kwargs[:code_language] || 'ruby'
+      end
+
+      def forward(**inputs)
+        # 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])
+
+        # Execute the generated code if safe
+        result = if safe_to_execute?(generated_code)
+                   execute_code(generated_code, inputs)
+                 else
+                   { error: "Generated code deemed unsafe to execute", code: generated_code }
+                 end
+
+        # Format outputs according to signature
+        format_outputs(result, generated_code)
+      end
+
+      private
+
+      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"
+        inputs.each do |key, value|
+          prompt += "#{key}: #{value}\n"
+        end
+
+        # Add expected output format
+        prompt += "\nExpected outputs:\n"
+        signature.output_fields.each do |name, field|
+          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"
+        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."
+
+        prompt
+      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)
+        # Basic safety checks - in production, use proper sandboxing
+        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/
+        ]
+
+        dangerous_patterns.none? { |pattern| code.match?(pattern) }
+      end
+
+      def execute_code(code, inputs)
+        # Create a safe execution context
+        context = Object.new
+
+        # 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
+      rescue StandardError => e
+        { error: "Code execution failed: #{e.message}" }
+      end
+
+      def format_outputs(result, generated_code)
+        outputs = {}
+
+        # Always include the generated code
+        outputs[:code] = generated_code if signature.output_fields.key?(:code)
+
+        if result[:error]
+          # Handle error case
+          outputs[:error] = result[:error]
+          signature.output_fields.each do |name, field|
+            next if %i[code error].include?(name)
+
+            outputs[name] = field.default || nil
+          end
+        else
+          # Map result to expected outputs
+          signature.output_fields.each do |name, field|
+            next if name == :code
+
+            outputs[name] = result[name] || field.default || nil
+          end
+        end
+
+        outputs
+      end
+    end
+  end
+end

data/lib/desiru/modules/react.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative '../module'
+require_relative 'chain_of_thought'
+
+module Desiru
+  module Modules
+    # ReAct (Reasoning and Acting) module for tool-using AI agents
+    # This module allows the language model to iteratively reason about a task
+    # and use tools to gather information before producing a final answer
+    class ReAct < Desiru::Module
+      attr_reader :max_iterations, :tools, :react_module, :extract_module
+
+      def initialize(signature, tools: [], max_iterations: 5, model: nil)
+        super(signature, model: model)
+        @tools = normalize_tools(tools)
+        @max_iterations = max_iterations
+
+        # Build the ReAct signature for reasoning and tool selection
+        react_signature = build_react_signature
+        @react_module = ChainOfThought.new(react_signature, model: @model)
+
+        # Build extraction signature for final output
+        extract_signature = build_extract_signature
+        @extract_module = ChainOfThought.new(extract_signature, model: @model)
+      end
+
+      def forward(inputs)
+        trajectory = []
+
+        max_iterations.times do |_iteration|
+          # Get the next action from the model
+          react_inputs = prepare_react_inputs(inputs, trajectory)
+          react_output = react_module.call(react_inputs)
+
+          # Extract the tool name and arguments
+          tool_name = react_output[:next_tool_name]
+          tool_args = parse_tool_args(react_output[:next_tool_args])
+
+          # Add reasoning to trajectory
+          trajectory << {
+            thought: react_output[:next_thought],
+            tool: tool_name,
+            args: tool_args
+          }
+
+          # Check if we're done
+          break if tool_name == "finish"
+
+          # Execute the tool
+          begin
+            tool_result = execute_tool(tool_name, tool_args)
+            trajectory.last[:observation] = tool_result
+          rescue StandardError => e
+            trajectory.last[:observation] = "Error: #{e.message}"
+          end
+        end
+
+        # Extract final outputs from trajectory
+        extract_inputs = prepare_extract_inputs(inputs, trajectory)
+        extract_module.call(extract_inputs)
+      end
+
+      private
+
+      def normalize_tools(tools)
+        # Convert tools to a consistent format
+        normalized = {}
+
+        tools.each do |tool|
+          case tool
+          when Hash
+            # Assume hash has name and function keys
+            normalized[tool[:name] || tool["name"]] = tool[:function] || tool["function"]
+          when Array
+            # Assume array of [name, function] pairs
+            name, function = tool
+            normalized[name] = function
+          else
+            # Assume it's a callable with a name method
+            if tool.respond_to?(:name) && tool.respond_to?(:call)
+              normalized[tool.name] = tool
+            elsif tool.is_a?(Method) || tool.is_a?(Proc)
+              # Use the method/proc name or generate one
+              name = tool.respond_to?(:name) ? tool.name.to_s : "tool_#{normalized.size}"
+              normalized[name] = tool
+            end
+          end
+        end
+
+        # Always include the finish tool
+        normalized["finish"] = -> { "Task completed" }
+
+        normalized
+      end
+
+      def build_react_signature
+        # Build signature for reasoning and tool selection
+        input_fields = signature.input_fields.keys.join(", ")
+
+        # Create the ReAct signature
+        react_sig = "#{input_fields}, trajectory -> next_thought, next_tool_name, next_tool_args"
+
+        # Add instructions
+        instructions = <<~INST
+          You are an AI agent that can use tools to accomplish tasks.
+
+          Available tools:
+          #{format_tool_descriptions}
+
+          Based on the input and trajectory so far, reason about what to do next.
+          Then select a tool to use and provide the arguments for that tool.
+
+          When you have gathered enough information to answer the question,
+          use the "finish" tool to complete the task.
+        INST
+
+        Signature.new(react_sig, descriptions: { 'next_thought' => instructions })
+      end
+
+      def build_extract_signature
+        # Build signature for extracting final outputs
+        input_fields = signature.input_fields.keys.join(", ")
+        output_fields = signature.output_fields.keys.join(", ")
+
+        extract_sig = "#{input_fields}, trajectory -> #{output_fields}"
+
+        instructions = <<~INST
+          Based on the trajectory of thoughts and tool observations,
+          extract the final #{output_fields} to answer the original question.
+        INST
+
+        Signature.new(extract_sig, descriptions: { output_fields => instructions })
+      end
+
+      def format_tool_descriptions
+        tools.map do |name, function|
+          if name == "finish"
+            "- finish: Mark the task as complete when you have enough information"
+          else
+            # Try to extract description from function
+            desc = if function.respond_to?(:description)
+                     function.description
+                   elsif function.respond_to?(:to_s)
+                     function.to_s
+                   else
+                     "Tool: #{name}"
+                   end
+            "- #{name}: #{desc}"
+          end
+        end.join("\n")
+      end
+
+      def prepare_react_inputs(inputs, trajectory)
+        inputs.merge(
+          trajectory: format_trajectory(trajectory)
+        )
+      end
+
+      def prepare_extract_inputs(inputs, trajectory)
+        inputs.merge(
+          trajectory: format_trajectory(trajectory)
+        )
+      end
+
+      def format_trajectory(trajectory)
+        return "No actions taken yet." if trajectory.empty?
+
+        trajectory.map.with_index do |step, i|
+          parts = ["Step #{i + 1}:"]
+          parts << "Thought: #{step[:thought]}" if step[:thought]
+          parts << "Tool: #{step[:tool]}" if step[:tool]
+          parts << "Args: #{step[:args]}" if step[:args] && !step[:args].empty?
+          parts << "Observation: #{step[:observation]}" if step[:observation]
+          parts.join("\n")
+        end.join("\n\n")
+      end
+
+      def parse_tool_args(args_string)
+        # Parse tool arguments from string format
+        return {} if args_string.nil? || args_string.strip.empty?
+
+        # Try to parse as JSON first
+        begin
+          require 'json'
+          JSON.parse(args_string, symbolize_names: true)
+        rescue JSON::ParserError
+          # Fallback: parse simple key:value pairs
+          parse_simple_args(args_string)
+        end
+      end
+
+      def parse_simple_args(args_string)
+        # Parse simple key:value format
+        args = {}
+
+        # Match patterns like key:value or key=value
+        args_string.scan(/(\w+)[:=]\s*([^,]+)/).each do |key, value|
+          # Clean up the value
+          value = value.strip.gsub(/^["']|["']$/, '') # Remove quotes
+
+          # Try to convert to appropriate type
+          args[key.to_sym] = case value.downcase
+                             when 'true' then true
+                             when 'false' then false
+                             when /^\d+$/ then value.to_i
+                             when /^\d+\.\d+$/ then value.to_f
+                             else value
+                             end
+        end
+
+        args
+      end
+
+      def execute_tool(tool_name, args)
+        tool = tools[tool_name]
+
+        raise "Unknown tool: #{tool_name}" unless tool
+
+        # Call the tool with arguments
+        if tool.arity.zero?
+          tool.call
+        elsif tool.arity == 1 && args.is_a?(Hash)
+          # Pass args as keyword arguments if possible
+          if tool.respond_to?(:parameters)
+            param_types = tool.parameters.map(&:first)
+            if param_types.include?(:keyreq) || param_types.include?(:key)
+              tool.call(**args)
+            else
+              tool.call(args)
+            end
+          else
+            tool.call(args)
+          end
+        else
+          # Pass args as positional arguments
+          tool.call(*args.values)
+        end
+      end
+
+      # Support for truncating trajectory if it gets too long
+      def truncate_trajectory(trajectory, max_length: 3000)
+        formatted = format_trajectory(trajectory)
+
+        return trajectory if formatted.length <= max_length
+
+        # Remove oldest steps until we're under the limit
+        truncated = trajectory.dup
+
+        # Keep removing the oldest steps until we're under the limit
+        while truncated.length > 1
+          truncated_formatted = format_trajectory(truncated)
+          break if truncated_formatted.length <= max_length
+
+          truncated.shift
+        end
+
+        # If even a single step is too long, truncate its content
+        if truncated.length == 1 && format_trajectory(truncated).length > max_length
+          step = truncated[0]
+          # Truncate the observation if it exists and is long
+          if step[:observation] && step[:observation].length > 100
+            step[:observation] = "#{step[:observation][0..100]}... (truncated)"
+          end
+          # Truncate thought if it's very long
+          step[:thought] = "#{step[:thought][0..100]}... (truncated)" if step[:thought] && step[:thought].length > 100
+        end
+
+        truncated
+      end
+    end
+  end
+end

data/lib/desiru/modules/retrieve.rb

@@ -21,6 +21,7 @@ module Desiru
       def forward(**inputs)
         query = inputs[:query]
         # Handle k parameter - it might come as nil if optional
+        # Note: 'k' is the standard parameter name in information retrieval
         k = inputs.fetch(:k, 5)
         k = 5 if k.nil? # Ensure we have a value even if nil was passed
 
@@ -67,7 +68,7 @@ module Desiru
         raise NotImplementedError, 'Subclasses must implement #add'
       end
 
-      def search(_query, k: 5)
+      def search(_query, k: 5) # rubocop:disable Naming/MethodParameterName
         raise NotImplementedError, 'Subclasses must implement #search'
       end
 
@@ -83,6 +84,7 @@ module Desiru
     # In-memory backend implementation for development and testing
     class InMemoryBackend < Backend
       def initialize(distance_metric: :cosine)
+        super()
         @documents = []
         @embeddings = []
         @distance_metric = distance_metric
@@ -107,7 +109,7 @@ module Desiru
         @embeddings.concat(embeddings)
       end
 
-      def search(query, k: 5)
+      def search(query, k: 5) # rubocop:disable Naming/MethodParameterName
         return [] if @documents.empty?
 
         # Generate query embedding

data/lib/desiru/optimizers/base.rb

@@ -22,7 +22,7 @@ module Desiru
 
       def evaluate(program, dataset)
         scores = dataset.map do |example|
-          prediction = program.call(example.reject { |k, _| %i[answer output].include?(k) })
+          prediction = program.call(example.except(:answer, :output))
           score_prediction(prediction, example)
         end
 
@@ -88,11 +88,9 @@ module Desiru
 
       def extract_answer(data)
         case data
-        when ModuleResult, ProgramResult
+        when ModuleResult, ProgramResult, Hash
           # Try common answer fields
           data[:answer] || data[:output] || data[:result] || data.values.first
-        when Hash
-          data[:answer] || data[:output] || data[:result] || data.values.first
         else
           data
         end

data/lib/desiru/optimizers/bootstrap_few_shot.rb

@@ -80,7 +80,7 @@ module Desiru
 
           begin
             # Get module prediction
-            inputs = example.reject { |k, _| %i[answer output].include?(k) }
+            inputs = example.except(:answer, :output)
             prediction = module_instance.call(inputs)
 
             # Score the prediction
@@ -110,7 +110,7 @@ module Desiru
         # Add labeled examples if available
         labeled = examples.select { |ex| ex[:answer] || ex[:output] }
         labeled_demos = labeled.first(config[:max_labeled_demos]).map do |ex|
-          inputs = ex.reject { |k, _| %i[answer output].include?(k) }
+          inputs = ex.except(:answer, :output)
           {
             input: format_demo_input(inputs),
             output: format_demo_output(ex),