desiru 0.1.0 → 0.1.1

data/lib/desiru/optimizers/copro.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Optimizers
+    # COPRO (Cooperative Prompt Optimization) optimizer
+    # Generates and refines instructions for each module using coordinate ascent
+    class COPRO < Base
+      def initialize(config = {})
+        super
+        @max_iterations = config[:max_iterations] || 10
+        @num_candidates = config[:num_candidates] || 5
+        @temperature = config[:temperature] || 0.7
+        @improvement_threshold = config[:improvement_threshold] || 0.01
+      end
+
+      def compile(program, trainset, valset = nil, **kwargs)
+        valset ||= trainset # Use trainset for validation if no valset provided
+
+        # Initialize best score
+        best_score = evaluate_program(program, valset, kwargs[:metric])
+        best_program = program.dup
+
+        Desiru.logger.info("[COPRO] Initial score: #{best_score}")
+
+        # Iterate through optimization rounds
+        @max_iterations.times do |iteration|
+          Desiru.logger.info("[COPRO] Starting iteration #{iteration + 1}/#{@max_iterations}")
+
+          # Try to improve each predictor
+          improved = false
+
+          program.predictors.each do |name, predictor|
+            Desiru.logger.info("[COPRO] Optimizing predictor: #{name}")
+
+            # Generate instruction candidates
+            candidates = generate_instruction_candidates(predictor, trainset, name)
+
+            # Evaluate each candidate
+            best_candidate_score = best_score
+            best_candidate_instruction = nil
+
+            candidates.each do |instruction|
+              # Create program with new instruction
+              candidate_program = create_program_with_instruction(
+                best_program,
+                name,
+                instruction
+              )
+
+              # Evaluate
+              score = evaluate_program(candidate_program, valset, kwargs[:metric])
+
+              if score > best_candidate_score
+                best_candidate_score = score
+                best_candidate_instruction = instruction
+              end
+            end
+
+            # Update if improved
+            next unless best_candidate_instruction && (best_candidate_score - best_score) > @improvement_threshold
+
+            Desiru.logger.info("[COPRO] Improved #{name}: #{best_score} -> #{best_candidate_score}")
+            best_program = create_program_with_instruction(
+              best_program,
+              name,
+              best_candidate_instruction
+            )
+            best_score = best_candidate_score
+            improved = true
+          end
+
+          # Early stopping if no improvement
+          break unless improved
+        end
+
+        Desiru.logger.info("[COPRO] Final score: #{best_score}")
+        best_program
+      end
+
+      private
+
+      def generate_instruction_candidates(predictor, trainset, predictor_name)
+        candidates = []
+
+        # Get examples of good performance
+        good_examples = select_good_examples(predictor, trainset)
+
+        # Generate initial instruction based on signature
+        signature = predictor.signature
+        base_instruction = generate_base_instruction(signature, predictor_name)
+        candidates << base_instruction
+
+        # Generate variations
+        (@num_candidates - 1).times do |i|
+          variation_prompt = build_variation_prompt(
+            base_instruction,
+            signature,
+            good_examples,
+            i
+          )
+
+          response = model.complete(
+            messages: [{ role: 'user', content: variation_prompt }],
+            temperature: @temperature
+          )
+
+          instruction = extract_instruction(response[:content])
+          candidates << instruction if instruction
+        end
+
+        candidates.compact.uniq
+      end
+
+      def generate_base_instruction(signature, predictor_name)
+        instruction = "You are solving a #{predictor_name} task.\n\n"
+
+        # Add input description
+        if signature.input_fields.any?
+          instruction += "Given the following inputs:\n"
+          signature.input_fields.each do |name, field|
+            instruction += "- #{name}: #{field.description || field.type}\n"
+          end
+          instruction += "\n"
+        end
+
+        # Add output description
+        if signature.output_fields.any?
+          instruction += "Produce the following outputs:\n"
+          signature.output_fields.each do |name, field|
+            instruction += "- #{name}: #{field.description || field.type}\n"
+          end
+        end
+
+        instruction
+      end
+
+      def build_variation_prompt(base_instruction, signature, good_examples, variation_index)
+        prompt = "Improve the following instruction for better performance:\n\n"
+        prompt += "Current instruction:\n#{base_instruction}\n\n"
+
+        # Add task context
+        prompt += "Task signature: #{signature}\n\n"
+
+        # Add examples of good performance
+        if good_examples.any?
+          prompt += "Examples of successful completions:\n"
+          good_examples.take(3).each do |example|
+            prompt += format_example(example)
+          end
+        end
+
+        # Request specific type of improvement
+        improvement_types = [
+          "Make the instruction more specific and detailed",
+          "Add helpful constraints or guidelines",
+          "Clarify any ambiguous requirements",
+          "Add examples or patterns to follow",
+          "Emphasize important aspects of the task"
+        ]
+
+        prompt += "\n#{improvement_types[variation_index % improvement_types.length]}.\n"
+        prompt += "Provide only the improved instruction:"
+
+        prompt
+      end
+
+      def select_good_examples(predictor, trainset)
+        good_examples = []
+
+        trainset.each do |example|
+          # Run predictor on example inputs
+          result = predictor.call(example[:inputs])
+
+          # Check if output matches expected
+          good_examples << example if outputs_match?(result, example[:outputs])
+        rescue StandardError
+          # Skip failed examples
+        end
+
+        good_examples
+      end
+
+      def outputs_match?(actual, expected)
+        return false unless actual.is_a?(Hash) && expected.is_a?(Hash)
+
+        expected.all? do |key, expected_value|
+          actual_value = actual[key]
+
+          # Flexible matching for different types
+          case expected_value
+          when String
+            actual_value.to_s.strip.downcase == expected_value.strip.downcase
+          when Numeric
+            (actual_value.to_f - expected_value.to_f).abs < 0.001
+          else
+            actual_value == expected_value
+          end
+        end
+      end
+
+      def format_example(example)
+        formatted = "\nExample:\n"
+
+        if example[:inputs]
+          formatted += "Inputs: "
+          formatted += example[:inputs].map { |k, v| "#{k}=#{v}" }.join(", ")
+          formatted += "\n"
+        end
+
+        if example[:outputs]
+          formatted += "Outputs: "
+          formatted += example[:outputs].map { |k, v| "#{k}=#{v}" }.join(", ")
+          formatted += "\n"
+        end
+
+        formatted
+      end
+
+      def extract_instruction(response)
+        # Clean up the response
+        instruction = response.strip
+
+        # Remove any meta-commentary
+        instruction = instruction.sub(/^(Here's |This is )?the improved instruction:?\s*/i, '')
+        instruction = instruction.sub(/^Improved instruction:?\s*/i, '')
+
+        # Remove quotes if wrapped
+        instruction.gsub(/^["']|["']$/, '')
+      end
+
+      def create_program_with_instruction(program, predictor_name, instruction)
+        new_program = program.dup
+
+        # Get the predictor
+        predictor = new_program.predictors[predictor_name]
+        return new_program unless predictor
+
+        # Create new predictor with updated instruction
+        new_predictor = predictor.dup
+        new_predictor.instance_variable_set(:@instruction, instruction)
+
+        # Update the program
+        new_program.instance_variable_set("@#{predictor_name}", new_predictor)
+
+        new_program
+      end
+
+      def evaluate_program(program, dataset, metric)
+        scores = []
+
+        dataset.each do |example|
+          # Run program
+          prediction = program.forward(**example[:inputs])
+
+          # Calculate score
+          score = metric.call(prediction, example[:outputs])
+          scores << score
+        rescue StandardError => e
+          Desiru.logger.debug("[COPRO] Evaluation error: #{e.message}")
+          scores << 0.0
+        end
+
+        # Return average score
+        scores.empty? ? 0.0 : scores.sum.to_f / scores.length
+      end
+    end
+  end
+end

data/lib/desiru/optimizers/knn_few_shot.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Optimizers
+    # KNNFewShot optimizer that uses k-Nearest Neighbors to find similar examples
+    # for few-shot learning. It finds the most similar training examples to each
+    # input and uses them as demonstrations.
+    class KNNFewShot < Base
+      def initialize(config = {})
+        super
+        @k = config[:k] || 3 # Number of nearest neighbors
+        @similarity_metric = config[:similarity_metric] || :cosine
+        @embedding_cache = {}
+      end
+
+      def compile(program, trainset, **_kwargs)
+        # Build index of training examples
+        build_example_index(trainset)
+
+        # Create optimized program with KNN-based few-shot selection
+        optimized_program = program.dup
+
+        # Wrap each predict module with KNN few-shot enhancement
+        optimized_program.predictors.each do |name, predictor|
+          optimized_predictor = create_knn_predictor(predictor, name)
+          optimized_program.instance_variable_set("@#{name}", optimized_predictor)
+        end
+
+        optimized_program
+      end
+
+      private
+
+      def build_example_index(trainset)
+        @example_embeddings = []
+        @example_data = []
+
+        trainset.each do |example|
+          # Create text representation of the example
+          example_text = serialize_example(example)
+
+          # Generate embedding (simplified - in practice, use a real embedding model)
+          embedding = generate_embedding(example_text)
+
+          @example_embeddings << embedding
+          @example_data << example
+        end
+      end
+
+      def create_knn_predictor(original_predictor, predictor_name)
+        knn_predictor = original_predictor.dup
+        example_embeddings = @example_embeddings
+        example_data = @example_data
+        k = @k
+        similarity_metric = @similarity_metric
+
+        # Override the forward method to include KNN examples
+        knn_predictor.define_singleton_method(:forward) do |**inputs|
+          # Find nearest neighbors for this input
+          input_text = inputs.map { |k, v| "#{k}: #{v}" }.join("\n")
+          input_embedding = generate_embedding(input_text)
+
+          nearest_examples = find_nearest_neighbors(
+            input_embedding,
+            example_embeddings,
+            example_data,
+            k,
+            similarity_metric
+          )
+
+          # Format examples for few-shot learning
+          demonstrations = format_demonstrations(nearest_examples, predictor_name)
+
+          # Enhance the prompt with demonstrations
+          enhanced_prompt = build_enhanced_prompt(inputs, demonstrations)
+
+          # Call original predictor with enhanced prompt
+          super(**inputs, few_shot_examples: enhanced_prompt)
+        end
+
+        knn_predictor
+      end
+
+      def generate_embedding(text)
+        # Cache embeddings to avoid recomputation
+        return @embedding_cache[text] if @embedding_cache.key?(text)
+
+        # Simplified embedding generation
+        # In practice, use a real embedding model like OpenAI's text-embedding-ada-002
+        words = text.downcase.split(/\W+/)
+        embedding = Array.new(100, 0.0)
+
+        words.each do |word|
+          # Simple hash-based pseudo-embedding
+          hash_value = word.hash
+          100.times do |i|
+            embedding[i] += Math.sin(hash_value * (i + 1)) / Math.sqrt(words.length + 1)
+          end
+        end
+
+        # Normalize
+        magnitude = Math.sqrt(embedding.sum { |x| x * x })
+        embedding = embedding.map { |x| x / (magnitude + 1e-10) }
+
+        @embedding_cache[text] = embedding
+        embedding
+      end
+
+      def find_nearest_neighbors(query_embedding, embeddings, data, num_neighbors, metric)
+        # Calculate distances
+        distances = embeddings.map.with_index do |embedding, idx|
+          distance = case metric
+                     when :cosine
+                       cosine_distance(query_embedding, embedding)
+                     when :euclidean
+                       euclidean_distance(query_embedding, embedding)
+                     else
+                       raise ArgumentError, "Unknown similarity metric: #{metric}"
+                     end
+          { distance: distance, index: idx }
+        end
+
+        # Sort by distance and take top k
+        nearest = distances.sort_by { |d| d[:distance] }.take(num_neighbors)
+        nearest.map { |d| data[d[:index]] }
+      end
+
+      def cosine_distance(vec1, vec2)
+        dot_product = vec1.zip(vec2).sum { |a, b| a * b }
+        1.0 - dot_product # Convert similarity to distance
+      end
+
+      def euclidean_distance(vec1, vec2)
+        Math.sqrt(vec1.zip(vec2).sum { |a, b| (a - b)**2 })
+      end
+
+      def serialize_example(example)
+        parts = []
+
+        # Add inputs
+        if example[:inputs]
+          parts << "Inputs:"
+          example[:inputs].each { |k, v| parts << "  #{k}: #{v}" }
+        end
+
+        # Add expected outputs
+        if example[:outputs]
+          parts << "Outputs:"
+          example[:outputs].each { |k, v| parts << "  #{k}: #{v}" }
+        end
+
+        parts.join("\n")
+      end
+
+      def format_demonstrations(examples, _predictor_name)
+        demonstrations = []
+
+        examples.each_with_index do |example, idx|
+          demo = "Example #{idx + 1}:\n"
+
+          if example[:inputs]
+            demo += "Input:\n"
+            example[:inputs].each { |k, v| demo += "  #{k}: #{v}\n" }
+          end
+
+          if example[:outputs]
+            demo += "Output:\n"
+            example[:outputs].each { |k, v| demo += "  #{k}: #{v}\n" }
+          end
+
+          demonstrations << demo
+        end
+
+        demonstrations.join("\n---\n")
+      end
+
+      def build_enhanced_prompt(_inputs, demonstrations)
+        prompt = "Here are some similar examples:\n\n"
+        prompt += demonstrations
+        prompt += "\n\nNow, given the following input, provide the output:\n"
+        prompt
+      end
+    end
+  end
+end

data/lib/desiru/persistence/database.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'logger'
+
+module Desiru
+  module Persistence
+    # Database connection and migration management
+    module Database
+      class << self
+        attr_reader :connection
+
+        def connect(database_url = nil)
+          url = database_url || Persistence.database_url
+
+          @connection = Sequel.connect(
+            url,
+            logger: logger,
+            max_connections: max_connections
+          )
+
+          # Enable foreign keys for SQLite
+          @connection.run('PRAGMA foreign_keys = ON') if sqlite?
+
+          @connection
+        end
+
+        def disconnect
+          @connection&.disconnect
+          @connection = nil
+        end
+
+        def migrate!
+          raise 'Not connected to database' unless @connection
+
+          Sequel.extension :migration
+          migrations_path = File.expand_path('../../../db/migrations', __dir__)
+          Sequel::Migrator.run(@connection, migrations_path)
+
+          # Initialize persistence layer after migrations
+          require_relative 'setup'
+          Setup.initialize!(@connection)
+        end
+
+        def transaction(&)
+          raise 'Not connected to database' unless @connection
+
+          @connection.transaction(&)
+        end
+
+        private
+
+        def logger
+          return nil unless ENV['DESIRU_DEBUG'] || ENV['DEBUG']
+
+          Logger.new($stdout).tap do |logger|
+            logger.level = Logger::INFO
+          end
+        end
+
+        def max_connections
+          ENV['DESIRU_DB_MAX_CONNECTIONS']&.to_i || 10
+        end
+
+        def sqlite?
+          @connection&.adapter_scheme == :sqlite
+        end
+      end
+    end
+  end
+end

data/lib/desiru/persistence/models/api_request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Persistence
+    module Models
+      # Tracks REST API requests
+      class ApiRequest < Base
+        set_dataset :api_requests
+        one_to_many :module_executions
+
+        json_column :headers
+        json_column :params
+        json_column :response_body
+
+        def validate
+          super
+          # Validate method column separately due to name conflict with Ruby's method method
+          if self[:method].nil? || self[:method].to_s.empty?
+            errors.add(:method, 'is required')
+          elsif !%w[GET POST PUT PATCH DELETE].include?(self[:method])
+            errors.add(:method, 'must be GET, POST, PUT, PATCH, or DELETE')
+          end
+          validates_presence %i[path status_code]
+        end
+
+        def success?
+          status_code >= 200 && status_code < 300
+        end
+
+        def duration_ms
+          return nil unless response_time
+
+          (response_time * 1000).round
+        end
+      end
+    end
+  end
+end

data/lib/desiru/persistence/models/job_result.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Persistence
+    module Models
+      # Model for storing background job results
+      class JobResult < Base
+        set_dataset :job_results
+
+        # Status constants
+        STATUS_PENDING = 'pending'
+        STATUS_PROCESSING = 'processing'
+        STATUS_COMPLETED = 'completed'
+        STATUS_FAILED = 'failed'
+
+        # Validations
+        def validate
+          super
+          validates_presence %i[job_id job_class queue status enqueued_at]
+          validates_unique :job_id if db&.table_exists?(:job_results)
+          validates_includes %w[pending processing completed failed], :status
+        end
+
+        # Scopes
+        dataset_module do
+          def pending
+            where(status: STATUS_PENDING)
+          end
+
+          def processing
+            where(status: STATUS_PROCESSING)
+          end
+
+          def completed
+            where(status: STATUS_COMPLETED)
+          end
+
+          def failed
+            where(status: STATUS_FAILED)
+          end
+
+          def expired
+            where { expires_at < Time.now }
+          end
+
+          def active
+            where { (expires_at > Time.now) | (expires_at =~ nil) }
+          end
+
+          def by_job_class(job_class)
+            where(job_class: job_class)
+          end
+
+          def recent(limit = 10)
+            order(Sequel.desc(:created_at)).limit(limit)
+          end
+        end
+
+        # Instance methods
+        def pending?
+          status == STATUS_PENDING
+        end
+
+        def processing?
+          status == STATUS_PROCESSING
+        end
+
+        def completed?
+          status == STATUS_COMPLETED
+        end
+
+        def failed?
+          status == STATUS_FAILED
+        end
+
+        def expired?
+          expires_at && expires_at < Time.now
+        end
+
+        def duration
+          return nil unless started_at && finished_at
+
+          finished_at - started_at
+        end
+
+        # JSON field accessors
+        def inputs_data
+          return {} unless inputs
+
+          JSON.parse(inputs, symbolize_names: true)
+        rescue JSON::ParserError
+          {}
+        end
+
+        def result_data
+          return {} unless result
+
+          JSON.parse(result, symbolize_names: true)
+        rescue JSON::ParserError
+          {}
+        end
+
+        def mark_as_processing!
+          update(
+            status: STATUS_PROCESSING,
+            started_at: Time.now,
+            progress: 0
+          )
+        end
+
+        def mark_as_completed!(result_data, message: nil)
+          update(
+            status: STATUS_COMPLETED,
+            finished_at: Time.now,
+            progress: 100,
+            result: result_data.to_json,
+            message: message
+          )
+        end
+
+        def mark_as_failed!(error, backtrace: nil)
+          update(
+            status: STATUS_FAILED,
+            finished_at: Time.now,
+            error_message: error.to_s,
+            error_backtrace: backtrace&.join("\n")
+          )
+        end
+
+        def update_progress(progress, message: nil)
+          updates = { progress: progress }
+          updates[:message] = message if message
+          update(updates)
+        end
+      end
+    end
+  end
+end