looped 0.1.0

data/lib/looped/application.rb

@@ -0,0 +1,252 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'async'
+require 'readline'
+
+module Looped
+  class Application
+    extend T::Sig
+
+    sig { returns(Agent) }
+    attr_reader :agent
+
+    sig { returns(Optimizer) }
+    attr_reader :optimizer
+
+    sig { returns(State) }
+    attr_reader :state
+
+    sig do
+      params(
+        model: T.nilable(String),
+        judge_model: T.nilable(String),
+        reflection_model: T.nilable(String),
+        max_iterations: Integer,
+        optimizer_batch_size: Integer,
+        optimizer_interval: Integer
+      ).void
+    end
+    def initialize(
+      model: nil,
+      judge_model: nil,
+      reflection_model: nil,
+      max_iterations: 10,
+      optimizer_batch_size: 5,
+      optimizer_interval: 60
+    )
+      @state = T.let(State.new, State)
+      @agent = T.let(
+        Agent.new(
+          model: model,
+          max_iterations: max_iterations,
+          judge_model: judge_model
+        ),
+        Agent
+      )
+      @optimizer = T.let(
+        Optimizer.new(
+          state: @state,
+          batch_size: optimizer_batch_size,
+          check_interval: optimizer_interval,
+          reflection_model: reflection_model
+        ),
+        Optimizer
+      )
+      @running = T.let(false, T::Boolean)
+    end
+
+    sig { void }
+    def run
+      @running = true
+
+      puts banner
+      puts "Type a coding task and press Enter. Type 'quit' to exit."
+      puts "Type 'status' to see optimization status."
+      puts ""
+
+      Async do |task|
+        # Start the optimizer in the background
+        optimizer_task = task.async do
+          @optimizer.start
+        end
+
+        # Run the interactive loop
+        begin
+          interactive_loop
+        ensure
+          @optimizer.stop
+          optimizer_task.stop
+        end
+      end
+    end
+
+    sig { params(task: String, context: String).returns(Types::TrainingResult) }
+    def run_task(task:, context: '')
+      @agent.run(task: task, context: context)
+    end
+
+    sig { void }
+    def stop
+      @running = false
+      @optimizer.stop
+    end
+
+    private
+
+    sig { void }
+    def interactive_loop
+      while @running
+        input = Readline.readline('looped> ', true)
+
+        if input.nil? || input.strip.downcase == 'quit'
+          puts "\nGoodbye!"
+          @running = false
+          break
+        end
+
+        next if input.strip.empty?
+
+        handle_input(input.strip)
+      end
+    end
+
+    sig { params(input: String).void }
+    def handle_input(input)
+      case input.downcase
+      when 'status'
+        show_status
+      when 'history'
+        show_history
+      when 'help'
+        show_help
+      when /^context\s+(.+)/i
+        set_context(T.must($1))
+      else
+        execute_task(input)
+      end
+    end
+
+    sig { void }
+    def show_status
+      instructions = @state.load_instructions
+      buffer = @state.peek_training_buffer
+
+      puts ""
+      puts "=== Looped Status ==="
+      puts ""
+
+      if instructions
+        puts "Current Instructions:"
+        puts "  Generation: #{instructions.generation}"
+        puts "  Best Score: #{instructions.score.round(2)}/10"
+        puts "  Updated: #{instructions.updated_at}"
+      else
+        puts "No optimized instructions yet (using defaults)"
+      end
+
+      puts ""
+      puts "Training Buffer: #{buffer.length} results"
+      puts "Optimizer: #{@optimizer.running ? 'Running' : 'Stopped'}"
+      puts ""
+    end
+
+    sig { void }
+    def show_history
+      buffer = @state.peek_training_buffer
+
+      if buffer.empty?
+        puts "\nNo tasks completed yet.\n"
+        return
+      end
+
+      puts ""
+      puts "=== Recent Tasks ==="
+      puts ""
+
+      buffer.last(5).each_with_index do |result, i|
+        puts "#{i + 1}. #{result.task.truncate(60)}"
+        puts "   Score: #{result.score.round(2)}/10 | #{result.timestamp}"
+        puts ""
+      end
+    end
+
+    sig { void }
+    def show_help
+      puts <<~HELP
+
+        === Looped Commands ===
+
+        <task>     Execute a coding task
+        status     Show optimization status
+        history    Show recent task history
+        help       Show this help message
+        quit       Exit the application
+
+        === Environment Variables ===
+
+        LOOPED_MODEL           Agent model (default: gpt-4o-mini)
+        LOOPED_JUDGE_MODEL     Judge model (default: gpt-4o-mini)
+        LOOPED_REFLECTION_MODEL  GEPA reflection model (default: gpt-4o-mini)
+
+      HELP
+    end
+
+    sig { params(context: String).void }
+    def set_context(context)
+      @current_context = context
+      puts "\nContext set to: #{context}\n"
+    end
+
+    sig { params(task: String).void }
+    def execute_task(task)
+      puts "\nExecuting task..."
+      puts ""
+
+      context = @current_context || ''
+
+      begin
+        result = @agent.run(task: task, context: context)
+
+        puts "=== Result ==="
+        puts ""
+        puts "Score: #{result.score.round(2)}/10"
+        puts ""
+        puts "Solution:"
+        puts result.solution
+        puts ""
+        puts "Feedback:"
+        puts result.feedback
+        puts ""
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+        puts e.backtrace&.first(5)&.join("\n")
+        puts ""
+      end
+    end
+
+    sig { returns(String) }
+    def banner
+      <<~BANNER
+
+        ╦  ┌─┐┌─┐┌─┐┌─┐┌┬┐
+        ║  │ ││ │├─┘├┤  ││
+        ╩═╝└─┘└─┘┴  └─┘─┴┘
+
+        Self-improving coding agent powered by DSPy.rb + GEPA
+
+      BANNER
+    end
+  end
+end
+
+# Add String#truncate for display
+unless String.method_defined?(:truncate)
+  class String
+    def truncate(length, omission: '...')
+      return self if self.length <= length
+
+      "#{self[0, length - omission.length]}#{omission}"
+    end
+  end
+end

data/lib/looped/judge.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Looped
+  class Judge
+    extend T::Sig
+
+    DEFAULT_MODEL = 'openai/gpt-4o-mini'
+
+    sig { returns(DSPy::Predict) }
+    attr_reader :predictor
+
+    sig { params(model: T.nilable(String), api_key: T.nilable(String)).void }
+    def initialize(model: nil, api_key: nil)
+      model_id = model || ENV.fetch('LOOPED_JUDGE_MODEL', DEFAULT_MODEL)
+      resolved_api_key = api_key || resolve_api_key(model_id)
+
+      # Configure DSPy with our LM
+      DSPy.configure do |c|
+        c.lm = DSPy::LM.new(model_id, api_key: resolved_api_key)
+      end
+
+      @predictor = T.let(DSPy::Predict.new(Looped::JudgeSignature), DSPy::Predict)
+    end
+
+    sig { params(task: String, solution: String, expected_behavior: String).returns(Types::Judgment) }
+    def evaluate(task:, solution:, expected_behavior: '')
+      result = predictor.call(
+        task: task,
+        solution: solution,
+        expected_behavior: expected_behavior.empty? ? infer_expected_behavior(task) : expected_behavior
+      )
+
+      Types::Judgment.new(
+        score: normalize_score(result.score),
+        passed: result.passed,
+        critique: result.critique,
+        suggestions: result.suggestions || []
+      )
+    end
+
+    sig { params(judgment: Types::Judgment).returns(String) }
+    def to_feedback(judgment)
+      parts = []
+      parts << "Score: #{judgment.score}/10"
+      parts << "Status: #{judgment.passed ? 'PASSED' : 'FAILED'}"
+      parts << ""
+      parts << "Critique:"
+      parts << judgment.critique
+
+      if judgment.suggestions.any?
+        parts << ""
+        parts << "Suggestions for improvement:"
+        judgment.suggestions.each_with_index do |suggestion, i|
+          parts << "  #{i + 1}. #{suggestion}"
+        end
+      end
+
+      parts.join("\n")
+    end
+
+    private
+
+    sig { params(model_id: String).returns(T.nilable(String)) }
+    def resolve_api_key(model_id)
+      provider = model_id.split('/').first
+      case provider
+      when 'openai'
+        ENV['OPENAI_API_KEY']
+      when 'anthropic'
+        ENV['ANTHROPIC_API_KEY']
+      when 'gemini', 'google'
+        ENV['GEMINI_API_KEY']
+      else
+        ENV['OPENAI_API_KEY'] # Default fallback
+      end
+    end
+
+    sig { params(task: String).returns(String) }
+    def infer_expected_behavior(task)
+      "The solution should correctly and completely address the task: #{task}"
+    end
+
+    sig { params(score: T.untyped).returns(Float) }
+    def normalize_score(score)
+      value = score.to_f
+      [[value, 0.0].max, 10.0].min
+    end
+  end
+end

data/lib/looped/memory.rb

@@ -0,0 +1,96 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Looped
+  class Memory
+    extend T::Sig
+
+    DEFAULT_MAX_ENTRIES = 10
+    DEFAULT_MAX_RESULT_LENGTH = 500
+
+    sig { params(max_entries: Integer, max_result_length: Integer).void }
+    def initialize(max_entries: DEFAULT_MAX_ENTRIES, max_result_length: DEFAULT_MAX_RESULT_LENGTH)
+      @entries = T.let([], T::Array[Types::MemoryEntry])
+      @max_entries = max_entries
+      @max_result_length = max_result_length
+    end
+
+    sig do
+      params(
+        action_type: String,
+        action_input: T::Hash[T.any(String, Symbol), T.untyped],
+        action_output: String,
+        model_id: T.nilable(String),
+        tokens_used: T.nilable(Integer),
+        error: T.nilable(String)
+      ).void
+    end
+    def add(action_type:, action_input:, action_output:, model_id: nil, tokens_used: nil, error: nil)
+      @entries << Types::MemoryEntry.new(
+        action_type: action_type,
+        action_input: stringify_keys(action_input),
+        action_output: action_output,
+        timestamp: Time.now.utc.iso8601,
+        model_id: model_id,
+        error: error,
+        tokens_used: tokens_used
+      )
+
+      # Enforce max_entries limit
+      @entries.shift while @entries.size > @max_entries
+    end
+
+    sig { returns(T::Array[Types::ActionSummary]) }
+    def to_context
+      @entries.last(@max_entries).map do |entry|
+        Types::ActionSummary.new(
+          action: summarize_action(entry),
+          result: truncate(entry.action_output)
+        )
+      end
+    end
+
+    sig { returns(T::Array[Types::MemoryEntry]) }
+    def entries
+      @entries.dup
+    end
+
+    sig { returns(Integer) }
+    def size
+      @entries.size
+    end
+
+    sig { void }
+    def clear
+      @entries.clear
+    end
+
+    sig { params(n: Integer).returns(T::Array[Types::MemoryEntry]) }
+    def recent(n)
+      @entries.last(n)
+    end
+
+    private
+
+    sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def stringify_keys(hash)
+      hash.transform_keys(&:to_s)
+    end
+
+    sig { params(entry: Types::MemoryEntry).returns(String) }
+    def summarize_action(entry)
+      input_parts = entry.action_input.map do |k, v|
+        value_str = v.to_s
+        value_str = "#{value_str[0..47]}..." if value_str.length > 50
+        "#{k}=#{value_str}"
+      end
+      "#{entry.action_type}(#{input_parts.join(', ')})"
+    end
+
+    sig { params(text: String).returns(String) }
+    def truncate(text)
+      return text if text.length <= @max_result_length
+      "#{text[0...@max_result_length]}..."
+    end
+  end
+end

data/lib/looped/optimizer.rb

@@ -0,0 +1,267 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'async'
+
+module Looped
+  class Optimizer
+    extend T::Sig
+
+    DEFAULT_BATCH_SIZE = 5
+    DEFAULT_MAX_METRIC_CALLS = 32
+    DEFAULT_CHECK_INTERVAL = 60
+
+    sig { returns(State) }
+    attr_reader :state
+
+    sig { returns(T::Boolean) }
+    attr_reader :running
+
+    sig do
+      params(
+        state: State,
+        batch_size: Integer,
+        max_metric_calls: Integer,
+        check_interval: Integer,
+        reflection_model: T.nilable(String)
+      ).void
+    end
+    def initialize(
+      state:,
+      batch_size: DEFAULT_BATCH_SIZE,
+      max_metric_calls: DEFAULT_MAX_METRIC_CALLS,
+      check_interval: DEFAULT_CHECK_INTERVAL,
+      reflection_model: nil
+    )
+      @state = state
+      @batch_size = batch_size
+      @max_metric_calls = max_metric_calls
+      @check_interval = check_interval
+      @reflection_model = T.let(
+        reflection_model || ENV.fetch('LOOPED_REFLECTION_MODEL', 'openai/gpt-4o-mini'),
+        String
+      )
+      @running = T.let(false, T::Boolean)
+    end
+
+    sig { void }
+    def start
+      @running = true
+
+      Async do |task|
+        while @running
+          check_and_optimize
+          task.sleep(@check_interval)
+        end
+      end
+    end
+
+    sig { void }
+    def stop
+      @running = false
+    end
+
+    sig { void }
+    def check_and_optimize
+      buffer = @state.peek_training_buffer
+      return if buffer.length < @batch_size
+
+      optimize(buffer)
+    end
+
+    sig { params(training_results: T::Array[Types::TrainingResult]).void }
+    def optimize(training_results)
+      # Build trainset from training results
+      trainset = build_trainset(training_results)
+      return if trainset.empty?
+
+      # Load current instructions
+      current_instructions = @state.load_instructions
+
+      # Build the base agent for optimization
+      agent = build_agent_for_optimization(current_instructions)
+
+      # Configure GEPA metric
+      metric = build_metric
+
+      # Create reflection LM for GEPA
+      reflection_lm = DSPy::ReflectionLM.new(@reflection_model, api_key: resolve_api_key(@reflection_model))
+
+      # Build feedback map for multi-predictor optimization
+      feedback_map = build_feedback_map
+
+      # Run GEPA optimization
+      gepa = DSPy::Teleprompt::GEPA.new(
+        metric: metric,
+        reflection_lm: reflection_lm,
+        feedback_map: feedback_map,
+        config: {
+          max_metric_calls: @max_metric_calls,
+          minibatch_size: [@batch_size, trainset.length].min,
+          perfect_score: 10.0,
+          skip_perfect_score: true,
+          use_merge: trainset.length >= 4
+        }
+      )
+
+      # Split trainset - use majority for training, rest for validation
+      split_point = [(trainset.length * 0.8).ceil, trainset.length - 1].min
+      train_examples = trainset[0...split_point]
+      val_examples = trainset[split_point..]
+
+      result = gepa.compile(agent.react, trainset: train_examples, valset: val_examples)
+
+      # Extract optimized instructions from the best program
+      save_optimized_instructions(result, current_instructions)
+
+      # Consume the training buffer after successful optimization
+      @state.consume_training_buffer
+    end
+
+    private
+
+    sig { params(training_results: T::Array[Types::TrainingResult]).returns(T::Array[DSPy::Example]) }
+    def build_trainset(training_results)
+      training_results.map do |result|
+        DSPy::Example.new(
+          signature_class: CodingTaskSignature,
+          input: {
+            task: result.task,
+            context: '',
+            history: []
+          },
+          expected: {
+            solution: result.solution,
+            files_modified: []
+          },
+          metadata: {
+            score: result.score,
+            feedback: result.feedback
+          }
+        )
+      end
+    end
+
+    sig { params(instructions: T.nilable(Types::Instructions)).returns(Agent) }
+    def build_agent_for_optimization(instructions)
+      agent = Agent.new
+
+      # Apply existing instructions if present
+      if instructions
+        agent.reload_instructions
+      end
+
+      agent
+    end
+
+    sig { returns(T.proc.params(arg0: DSPy::Example, arg1: T.untyped).returns(T::Hash[Symbol, T.untyped])) }
+    def build_metric
+      lambda do |example, prediction|
+        # Extract the pre-computed score and feedback from metadata
+        metadata = example.metadata || {}
+        score = metadata[:score] || 0.0
+        feedback = metadata[:feedback] || ''
+
+        # Return score + feedback for GEPA reflection
+        { score: score, feedback: feedback }
+      end
+    end
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def build_feedback_map
+      # Provide feedback functions for each predictor in ReAct
+      {
+        'thought_generator' => lambda do |predictor_output:, predictor_inputs:, module_inputs:, module_outputs:, captured_trace:|
+          metadata = module_inputs.metadata || {}
+          feedback = metadata[:feedback] || ''
+          score = metadata[:score] || 0.0
+
+          # Filter feedback to focus on thought generation quality
+          thought_feedback = extract_thought_feedback(feedback)
+
+          { score: score, feedback: thought_feedback }
+        end,
+        'observation_processor' => lambda do |predictor_output:, predictor_inputs:, module_inputs:, module_outputs:, captured_trace:|
+          metadata = module_inputs.metadata || {}
+          feedback = metadata[:feedback] || ''
+          score = metadata[:score] || 0.0
+
+          # Filter feedback to focus on observation processing
+          observation_feedback = extract_observation_feedback(feedback)
+
+          { score: score, feedback: observation_feedback }
+        end
+      }
+    end
+
+    sig { params(feedback: String).returns(String) }
+    def extract_thought_feedback(feedback)
+      # Extract feedback relevant to reasoning and planning
+      lines = feedback.lines.select do |line|
+        line.match?(/reason|think|plan|approach|logic|decision/i) ||
+          line.match?(/score|critique|suggestion/i)
+      end
+
+      lines.empty? ? feedback : lines.join
+    end
+
+    sig { params(feedback: String).returns(String) }
+    def extract_observation_feedback(feedback)
+      # Extract feedback relevant to observation interpretation
+      lines = feedback.lines.select do |line|
+        line.match?(/observ|interpret|understand|result|output/i) ||
+          line.match?(/score|critique|suggestion/i)
+      end
+
+      lines.empty? ? feedback : lines.join
+    end
+
+    sig { params(result: T.untyped, current: T.nilable(Types::Instructions)).void }
+    def save_optimized_instructions(result, current)
+      optimized_program = result.optimized_program
+
+      # Extract instructions from the optimized predictors
+      thought_instruction = extract_predictor_instruction(optimized_program, 'thought_generator')
+      observation_instruction = extract_predictor_instruction(optimized_program, 'observation_processor')
+
+      # Calculate new generation number
+      generation = current ? current.generation + 1 : 1
+      best_score = result.best_score_value || 0.0
+
+      # Save to state
+      @state.save_instructions(
+        instructions: {
+          thought_generator: thought_instruction,
+          observation_processor: observation_instruction
+        },
+        score: best_score,
+        generation: generation
+      )
+    end
+
+    sig { params(program: DSPy::Module, predictor_name: String).returns(T.nilable(String)) }
+    def extract_predictor_instruction(program, predictor_name)
+      predictors = program.named_predictors
+      predictor = predictors.find { |name, _| name == predictor_name }&.last
+
+      return nil unless predictor
+
+      if predictor.respond_to?(:prompt) && predictor.prompt.respond_to?(:instruction)
+        predictor.prompt.instruction
+      elsif predictor.respond_to?(:instruction)
+        predictor.instruction
+      end
+    end
+
+    sig { params(model_id: String).returns(T.nilable(String)) }
+    def resolve_api_key(model_id)
+      provider = model_id.split('/').first
+      case provider
+      when 'openai' then ENV['OPENAI_API_KEY']
+      when 'anthropic' then ENV['ANTHROPIC_API_KEY']
+      when 'gemini', 'google' then ENV['GEMINI_API_KEY']
+      else ENV['OPENAI_API_KEY']
+      end
+    end
+  end
+end