looped 0.1.0

data/lib/looped/signatures.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'dspy'
+
+module Looped
+  # Main coding task signature
+  class CodingTaskSignature < DSPy::Signature
+    description "Complete a coding task in any programming language."
+
+    input do
+      const :task, String
+      const :context, String, default: ''
+      const :history, T::Array[Types::ActionSummary], default: []
+    end
+
+    output do
+      const :solution, String
+      const :files_modified, T::Array[String], default: []
+    end
+  end
+
+  # LLM-as-Judge signature
+  class JudgeSignature < DSPy::Signature
+    description "Evaluate code quality and correctness. Be critical and thorough."
+
+    input do
+      const :task, String
+      const :solution, String
+      const :expected_behavior, String
+    end
+
+    output do
+      const :score, Float
+      const :passed, T::Boolean
+      const :critique, String
+      const :suggestions, T::Array[String]
+    end
+  end
+end

data/lib/looped/state.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Looped
+  class State
+    extend T::Sig
+
+    DEFAULT_STORAGE_DIR = T.let(File.expand_path('~/.looped'), String)
+
+    sig { returns(String) }
+    attr_reader :storage_dir
+
+    sig { params(storage_dir: T.nilable(String)).void }
+    def initialize(storage_dir: nil)
+      @storage_dir = T.let(
+        storage_dir || ENV['LOOPED_STORAGE_DIR'] || DEFAULT_STORAGE_DIR,
+        String
+      )
+      FileUtils.mkdir_p(@storage_dir)
+      FileUtils.mkdir_p(File.join(@storage_dir, 'history'))
+    end
+
+    sig { returns(T.nilable(Types::Instructions)) }
+    def load_instructions
+      path = instructions_path
+      return nil unless File.exist?(path)
+
+      data = JSON.parse(File.read(path), symbolize_names: true)
+      instructions_data = data[:instructions] || {}
+
+      Types::Instructions.new(
+        thought_generator: instructions_data[:thought_generator],
+        observation_processor: instructions_data[:observation_processor],
+        score: data[:score]&.to_f || 0.0,
+        generation: data[:generation]&.to_i || 0,
+        updated_at: data[:updated_at] || Time.now.utc.iso8601
+      )
+    rescue JSON::ParserError
+      nil
+    end
+
+    sig { params(instructions: T::Hash[Symbol, T.nilable(String)], score: Float, generation: Integer).void }
+    def save_instructions(instructions:, score:, generation:)
+      data = {
+        instructions: instructions,
+        score: score,
+        generation: generation,
+        updated_at: Time.now.utc.iso8601
+      }
+      File.write(instructions_path, JSON.pretty_generate(data))
+    end
+
+    sig { params(result: Types::TrainingResult).void }
+    def append_training_result(result)
+      buffer = load_training_buffer_raw
+      buffer << {
+        task: result.task,
+        solution: result.solution,
+        score: result.score,
+        feedback: result.feedback,
+        timestamp: result.timestamp
+      }
+      File.write(training_buffer_path, JSON.pretty_generate(buffer))
+    end
+
+    sig { returns(T::Array[Types::TrainingResult]) }
+    def peek_training_buffer
+      load_training_buffer_raw.map { |data| deserialize_training_result(data) }
+    end
+
+    sig { returns(T::Array[Types::TrainingResult]) }
+    def consume_training_buffer
+      buffer = peek_training_buffer
+      return [] if buffer.empty?
+
+      # Archive to history
+      archive_path = File.join(@storage_dir, 'history', "#{Time.now.to_i}.json")
+      File.write(archive_path, JSON.pretty_generate(load_training_buffer_raw))
+
+      # Clear buffer
+      File.write(training_buffer_path, '[]')
+
+      buffer
+    end
+
+    private
+
+    sig { returns(String) }
+    def instructions_path
+      File.join(@storage_dir, 'instructions.json')
+    end
+
+    sig { returns(String) }
+    def training_buffer_path
+      File.join(@storage_dir, 'training_buffer.json')
+    end
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    def load_training_buffer_raw
+      return [] unless File.exist?(training_buffer_path)
+      JSON.parse(File.read(training_buffer_path), symbolize_names: true)
+    rescue JSON::ParserError
+      []
+    end
+
+    sig { params(data: T::Hash[Symbol, T.untyped]).returns(Types::TrainingResult) }
+    def deserialize_training_result(data)
+      Types::TrainingResult.new(
+        task: data[:task] || '',
+        solution: data[:solution] || '',
+        score: data[:score]&.to_f || 0.0,
+        feedback: data[:feedback] || '',
+        timestamp: data[:timestamp] || Time.now.utc.iso8601
+      )
+    end
+  end
+end

data/lib/looped/tools/read_file.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Looped
+  module Tools
+    class ReadFile < DSPy::Tools::Base
+      extend T::Sig
+
+      tool_name 'read_file'
+      tool_description 'Read contents of a file at the given path'
+
+      sig { params(path: String).returns(String) }
+      def call(path:)
+        resolved_path = resolve_path(path)
+        File.read(resolved_path)
+      rescue Errno::ENOENT
+        "Error: File not found: #{path}"
+      rescue Errno::EACCES
+        "Error: Permission denied: #{path}"
+      rescue StandardError => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      sig { params(path: String).returns(String) }
+      def resolve_path(path)
+        sandbox = ENV['LOOPED_SANDBOX_DIR']
+        return path if sandbox.nil? || path.start_with?('/')
+
+        File.join(sandbox, path)
+      end
+    end
+  end
+end

data/lib/looped/tools/run_command.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'open3'
+
+module Looped
+  module Tools
+    class RunCommand < DSPy::Tools::Base
+      extend T::Sig
+
+      DEFAULT_TIMEOUT = 30
+
+      tool_name 'run_command'
+      tool_description 'Execute a shell command and return its output. Use for running tests, linters, or other development tools.'
+
+      sig { params(command: String, timeout: Integer).returns(String) }
+      def call(command:, timeout: DEFAULT_TIMEOUT)
+        # TODO: Implement Docker sandbox via trusted-sandbox gem for production
+        pid = T.let(nil, T.nilable(Integer))
+        output = +''
+
+        begin
+          stdin, stdout_err, wait_thr = Open3.popen2e(command)
+          pid = wait_thr.pid
+          stdin.close
+
+          # Wait for process with timeout using a thread
+          reader = Thread.new { stdout_err.read }
+
+          if wait_thr.join(timeout)
+            # Process completed in time
+            output = reader.value
+            exit_status = wait_thr.value
+            "Exit code: #{exit_status.exitstatus}\n#{output}"
+          else
+            # Timeout - kill the process
+            reader.kill
+            Process.kill('TERM', pid)
+            sleep 0.1
+            begin
+              Process.kill('KILL', pid) if wait_thr.alive?
+            rescue Errno::ESRCH
+              # Process already dead
+            end
+            wait_thr.join
+            "Error: Command timed out after #{timeout} seconds"
+          end
+        rescue StandardError => e
+          "Error: #{e.message}"
+        ensure
+          stdout_err&.close rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/looped/tools/search_code.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'open3'
+
+module Looped
+  module Tools
+    class SearchCode < DSPy::Tools::Base
+      extend T::Sig
+
+      tool_name 'search_code'
+      tool_description 'Search for a pattern in code files using ripgrep. Returns matching lines with file paths and line numbers.'
+
+      sig { params(pattern: String, path: String, file_type: T.nilable(String)).returns(String) }
+      def call(pattern:, path: '.', file_type: nil)
+        cmd = build_command(pattern, path, file_type)
+        output, status = Open3.capture2e(*cmd)
+
+        if status.success?
+          output.empty? ? "No matches found for: #{pattern}" : output
+        else
+          "No matches found for: #{pattern}"
+        end
+      rescue StandardError => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      sig { params(pattern: String, path: String, file_type: T.nilable(String)).returns(T::Array[String]) }
+      def build_command(pattern, path, file_type)
+        cmd = ['rg', '--line-number', '--no-heading', '--max-count', '50', pattern, path]
+        cmd += ['--type', file_type] if file_type
+        cmd
+      end
+    end
+  end
+end

data/lib/looped/tools/write_file.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Looped
+  module Tools
+    class WriteFile < DSPy::Tools::Base
+      extend T::Sig
+
+      tool_name 'write_file'
+      tool_description 'Write content to a file at the given path. Creates parent directories if needed.'
+
+      sig { params(path: String, content: String).returns(String) }
+      def call(path:, content:)
+        resolved_path = resolve_path(path)
+        FileUtils.mkdir_p(File.dirname(resolved_path))
+        File.write(resolved_path, content)
+        "Successfully wrote #{content.length} bytes to #{path}"
+      rescue Errno::EACCES
+        "Error: Permission denied: #{path}"
+      rescue StandardError => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      sig { params(path: String).returns(String) }
+      def resolve_path(path)
+        sandbox = ENV['LOOPED_SANDBOX_DIR']
+        return path if sandbox.nil? || path.start_with?('/')
+
+        File.join(sandbox, path)
+      end
+    end
+  end
+end

data/lib/looped/types.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Looped
+  module Types
+    extend T::Sig
+
+    # Rich memory entry for storage/analytics
+    class MemoryEntry < T::Struct
+      const :action_type, String
+      const :action_input, T::Hash[String, T.untyped]
+      const :action_output, String
+      const :timestamp, String
+      const :model_id, T.nilable(String)
+      const :error, T.nilable(String)
+      const :tokens_used, T.nilable(Integer)
+    end
+
+    # Lean context entry for prompts
+    class ActionSummary < T::Struct
+      const :action, String
+      const :result, String
+    end
+
+    # Training result stored to buffer
+    class TrainingResult < T::Struct
+      const :task, String
+      const :solution, String
+      const :score, Float
+      const :feedback, String
+      const :timestamp, String
+    end
+
+    # Persisted instructions with metadata
+    class Instructions < T::Struct
+      const :thought_generator, T.nilable(String)
+      const :observation_processor, T.nilable(String)
+      const :score, Float, default: 0.0
+      const :generation, Integer, default: 0
+      const :updated_at, String
+    end
+
+    # Judgment from LLM-as-judge
+    class Judgment < T::Struct
+      const :score, Float
+      const :passed, T::Boolean
+      const :critique, String
+      const :suggestions, T::Array[String], default: []
+    end
+  end
+end

data/lib/looped/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Looped
+  VERSION = '0.1.0'
+end

data/lib/looped.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'dspy'
+require 'dspy/openai'
+
+# Load GEPA extension
+begin
+  require 'dspy/teleprompt/gepa'
+rescue LoadError
+  # GEPA not available - optimization will be limited
+end
+
+require_relative 'looped/version'
+require_relative 'looped/types'
+require_relative 'looped/signatures'
+require_relative 'looped/memory'
+require_relative 'looped/state'
+
+# Tools
+require_relative 'looped/tools/read_file'
+require_relative 'looped/tools/write_file'
+require_relative 'looped/tools/search_code'
+require_relative 'looped/tools/run_command'
+
+require_relative 'looped/judge'
+require_relative 'looped/agent'
+require_relative 'looped/optimizer'
+require_relative 'looped/application'
+
+module Looped
+  extend T::Sig
+
+  class Error < StandardError; end
+
+  # Convenience method to create and run the application
+  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 self.run(
+    model: nil,
+    judge_model: nil,
+    reflection_model: nil,
+    max_iterations: 10,
+    optimizer_batch_size: 5,
+    optimizer_interval: 60
+  )
+    app = Application.new(
+      model: model,
+      judge_model: judge_model,
+      reflection_model: reflection_model,
+      max_iterations: max_iterations,
+      optimizer_batch_size: optimizer_batch_size,
+      optimizer_interval: optimizer_interval
+    )
+    app.run
+  end
+
+  # Run a single task without the interactive loop
+  sig do
+    params(
+      task: String,
+      context: String,
+      model: T.nilable(String),
+      judge_model: T.nilable(String),
+      reflection_model: T.nilable(String),
+      max_iterations: Integer,
+      optimizer_batch_size: Integer,
+      optimizer_interval: Integer
+    ).returns(Types::TrainingResult)
+  end
+  def self.execute(
+    task:,
+    context: '',
+    model: nil,
+    judge_model: nil,
+    reflection_model: nil,
+    max_iterations: 10,
+    optimizer_batch_size: 5,
+    optimizer_interval: 60
+  )
+    app = Application.new(
+      model: model,
+      judge_model: judge_model,
+      reflection_model: reflection_model,
+      max_iterations: max_iterations,
+      optimizer_batch_size: optimizer_batch_size,
+      optimizer_interval: optimizer_interval
+    )
+    app.run_task(task: task, context: context)
+  end
+end

data/looped.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/looped/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'looped'
+  spec.version = Looped::VERSION
+  spec.authors = ['Vicente Reig']
+  spec.email = ['hey@vicente.services']
+
+  spec.summary = 'Self-improving coding agent with continuous prompt optimization'
+  spec.description = 'A coding agent that learns from its own performance using GEPA prompt optimization running in the background.'
+  spec.homepage = 'https://github.com/vicentereig/looped'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/vicentereig/looped'
+  spec.metadata['changelog_uri'] = 'https://github.com/vicentereig/looped/blob/main/CHANGELOG.md'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = ['looped']
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  spec.add_dependency 'async', '~> 2.23'
+  spec.add_dependency 'dspy', '~> 0.31.1'
+  spec.add_dependency 'dspy-openai', '~> 1.0'
+  spec.add_dependency 'dspy-gepa', '~> 1.0.3'
+  spec.add_dependency 'gepa', '~> 1.0.2'
+  spec.add_dependency 'polars-df', '~> 0.23'
+  spec.add_dependency 'sorbet-runtime', '~> 0.5'
+
+  # Development dependencies
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'vcr', '~> 6.2'
+  spec.add_development_dependency 'webmock', '~> 3.18'
+  spec.add_development_dependency 'byebug', '~> 11.1'
+end