ralph.rb 1.2.435535439

data/lib/ralph/storage/state.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Ralph
+  module Storage
+    # Represents and persists Ralph loop state
+    class State
+      attr_accessor :active, :iteration
+      attr_reader :min_iterations, :max_iterations, :completion_promise,
+                  :tasks_mode, :task_promise, :prompt, :started_at,
+                  :model, :agent
+
+      def initialize(active:, iteration:, min_iterations:, max_iterations:,
+                     completion_promise:, tasks_mode:, task_promise:, prompt:,
+                     started_at:, model:, agent:)
+        @active = active
+        @iteration = iteration
+        @min_iterations = min_iterations
+        @max_iterations = max_iterations
+        @completion_promise = completion_promise
+        @tasks_mode = tasks_mode
+        @task_promise = task_promise
+        @prompt = prompt
+        @started_at = started_at
+        @model = model
+        @agent = agent
+      end
+
+      def save
+        FileUtils.mkdir_p(self.class.dir)
+        File.write(self.class.path, JSON.pretty_generate(to_h))
+      end
+
+      def clear
+        File.delete(self.class.path) if File.exist?(self.class.path)
+      rescue StandardError
+        # ignore
+      end
+
+      def to_h
+        {
+          active: @active,
+          iteration: @iteration,
+          minIterations: @min_iterations,
+          maxIterations: @max_iterations,
+          completionPromise: @completion_promise,
+          tasksMode: @tasks_mode,
+          taskPromise: @task_promise,
+          prompt: @prompt,
+          startedAt: @started_at,
+          model: @model,
+          agent: @agent
+        }
+      end
+
+      class << self
+        def from_config(config, prompt:)
+          new(
+
+            iteration: 1,
+            active: true,
+            prompt: prompt.to_s,
+            started_at: Time.now.utc.iso8601,
+
+            model:              config.model,
+            agent:              config.chosen_agent,
+            tasks_mode:         config.tasks_mode,
+            task_promise:       config.task_promise,
+            min_iterations:     config.min_iterations,
+            max_iterations:     config.max_iterations,
+            completion_promise: config.completion_promise,
+          )
+        end
+
+        def dir
+          File.join(Dir.pwd, '.ralph')
+        end
+
+        def path
+          File.join(dir, 'ralph-loop.state.json')
+        end
+
+        def load
+          if File.exist?(path)
+            JSON.parse(File.read(path)).then do |data|
+              new(
+                active:             data['active'],
+                iteration:          data['iteration'],
+                min_iterations:     data['minIterations'],
+                max_iterations:     data['maxIterations'],
+                completion_promise: data['completionPromise'],
+                tasks_mode:         data['tasksMode'],
+                task_promise:       data['taskPromise'],
+                prompt:             data['prompt'],
+                started_at:         data['startedAt'],
+                model:              data['model'],
+                agent:              data['agent']
+              )
+            end
+          end
+        rescue StandardError
+          nil
+        end
+
+        def clear
+          File.delete(path) if File.exist?(path)
+        rescue StandardError
+          # ignore
+        end
+      end
+
+      # --- Configuration Management ---
+      # NOTE: Commented out — this was generating a synthetic OpenCode config
+      # to inject via OPENCODE_CONFIG env var. It worked around OpenCode's
+      # permission system and reimplemented its config resolution logic.
+      # If needed again, this should be an OpenCode feature, not a workaround.
+      #
+      # def self.load_plugins_from_config(config_path)
+      #   return [] unless File.exist?(config_path)
+      #   raw = File.read(config_path)
+      #   without_block = raw.gsub(/\/\*[\s\S]*?\*\//, "")
+      #   without_line = without_block.gsub(/^\s*\/\/.*$/, "")
+      #   parsed = JSON.parse(without_line)
+      #   plugins = parsed["plugin"]
+      #   return [] unless plugins.is_a?(Array)
+      #   plugins.select { |p| p.is_a?(String) }
+      # rescue StandardError
+      #   []
+      # end
+      #
+      # def self.ensure_ralph_config(filter_plugins: false, allow_all_permissions: false)
+      #   FileUtils.mkdir_p(dir)
+      #   config_path = File.join(dir, "ralph-opencode.config.json")
+      #
+      #   xdg_config = ENV["XDG_CONFIG_HOME"] || File.join(ENV["HOME"] || "", ".config")
+      #   user_config_path = File.join(xdg_config, "opencode", "opencode.json")
+      #   project_config_path = File.join(Dir.pwd, ".ralph", "opencode.json")
+      #   legacy_project_config_path = File.join(Dir.pwd, ".opencode", "opencode.json")
+      #
+      #   config = { "$schema" => "https://opencode.ai/config.json" }
+      #
+      #   if filter_plugins
+      #     plugins = [
+      #       *load_plugins_from_config(user_config_path),
+      #       *load_plugins_from_config(project_config_path),
+      #       *load_plugins_from_config(legacy_project_config_path)
+      #     ].uniq.select { |p| p =~ /auth/i }
+      #     config["plugin"] = plugins
+      #   end
+      #
+      #   if allow_all_permissions
+      #     config["permission"] = {
+      #       "read" => "allow",
+      #       "edit" => "allow",
+      #       "glob" => "allow",
+      #       "grep" => "allow",
+      #       "list" => "allow",
+      #       "bash" => "allow",
+      #       "task" => "allow",
+      #       "webfetch" => "allow",
+      #       "websearch" => "allow",
+      #       "codesearch" => "allow",
+      #       "todowrite" => "allow",
+      #       "todoread" => "allow",
+      #       "question" => "allow",
+      #       "lsp" => "allow",
+      #       "external_directory" => "allow"
+      #     }
+      #   end
+      #
+      #   File.write(config_path, JSON.pretty_generate(config))
+      #   config_path
+      # end
+    end
+  end
+end

data/lib/ralph/storage/tasks.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ralph
+  module Storage
+    # Manages task tracking and workflow coordination.
+    #
+    # Always instantiate with Tasks.new — it represents the tasks file on disk.
+    # Follows the same instance-based pattern as Context and History.
+    class Tasks
+      def initialize
+        FileUtils.mkdir_p(dir)
+      end
+
+      def self.dir
+        File.join(Dir.pwd, ".ralph")
+      end
+
+      def dir = self.class.dir
+
+      def self.path
+        File.join(dir, "ralph-tasks.md")
+      end
+
+      def path = self.class.path
+
+      # --- Tasks Management ---
+      def load_tasks
+        if File.exist?(path)
+          content = File.read(path)
+          TasksCollection.parse(content)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def save_tasks(tasks)
+        content = "# Ralph Tasks\n\n"
+        tasks.each do |task|
+          content << task.to_s << "\n"
+          task.subtasks.each do |subtask|
+            content << "  #{subtask}\n"
+          end
+        end
+        File.write(path, content)
+      end
+
+      def clear_tasks
+        File.delete(path) if File.exist?(path)
+      rescue StandardError
+        # ignore
+      end
+
+      def tasks_exist?
+        File.exist?(path)
+      end
+
+      # --- Single Task Operations ---
+
+      # Add a new task by description string.
+      # Creates the tasks file if it doesn't exist.
+      def add_task(description)
+        tasks = load_tasks || TasksCollection.new
+        task = Task.new(text: description, status: :todo)
+        tasks.add(task)
+        save_tasks(tasks)
+        task
+      end
+
+      # Remove a task by 1-based index.
+      # Returns the removed Task.
+      # Raises IndexError if index is out of range.
+      # Raises RuntimeError if no tasks file exists.
+      def remove_task(index)
+        raise "No tasks file found" unless tasks_exist?
+
+        tasks = load_tasks
+        removed = tasks.remove_at(index)
+        save_tasks(tasks)
+        removed
+      end
+
+      # --- Task Initialization ---
+      def initialize_tasks_file
+        content = "# Ralph Tasks\n\nAdd your tasks below using: `ralph --add-task \"description\"`\n"
+        File.write(path, content)
+        path
+      end
+    end
+
+    # --- Task Models ---
+
+    # Individual task with status and subtasks
+    class Task
+      attr_accessor :text, :status, :subtasks, :original_line
+
+      def initialize(text:, status: :todo, subtasks: [], original_line: nil)
+        @text = text
+        @status = status
+        @subtasks = subtasks
+        @original_line = original_line
+      end
+
+      def status_char
+        case status
+        when :complete then "x"
+        when :in_progress then "/"
+        else " "
+        end
+      end
+
+      def to_s
+        "- [#{status_char}] #{text}"
+      end
+
+      def todo?        = status == :todo
+      def in_progress? = status == :in_progress
+      def complete?    = status == :complete
+
+      def toggle_status
+        case status
+        when :todo        then @status = :in_progress
+        when :in_progress then @status = :complete
+        when :complete    then @status = :todo
+        end
+      end
+
+      def mark_complete!    = @status = :complete
+      def mark_in_progress! = @status = :in_progress
+      def mark_todo!        = @status = :todo
+    end
+
+    # Collection of tasks with enumerable interface
+    class TasksCollection
+      include Enumerable
+
+      def initialize(tasks = [])
+        @tasks = tasks
+      end
+
+      def each(&block)  = @tasks.each(&block)
+      def count(&block) = @tasks.count(&block)
+
+      def empty? = @tasks.empty?
+      def length = @tasks.length
+      def any?   = @tasks.any?
+
+      # Add a task to the collection
+      def add(task)
+        @tasks << task
+        self
+      end
+
+      # Remove a task (and its subtasks) by 1-based index.
+      # Returns the removed Task, or raises IndexError if out of range.
+      def remove_at(index)
+        if index < 1 || index > @tasks.length
+          raise IndexError, "Task index #{index} is out of range (1-#{@tasks.length})"
+        end
+
+        @tasks.delete_at(index - 1)
+      end
+
+      def self.parse(content)
+        tasks = []
+        current_task = nil
+
+        content.each_line do |line|
+          # Top-level task: starts with "- [" at beginning (no leading whitespace)
+          if (match = line.match(/^- \[([ x\/])\]\s*(.+)/))
+            tasks << current_task if current_task
+            status_char = match[1]
+            text = match[2]
+            status = case status_char
+                     when "x" then :complete
+                     when "/" then :in_progress
+                     else :todo
+                     end
+            current_task = Task.new(text: text, status: status, subtasks: [], original_line: line.chomp)
+            next
+          end
+
+          # Subtask: starts with whitespace followed by "- ["
+          if (match = line.match(/^\s+- \[([ x\/])\]\s*(.+)/)) && current_task
+            status_char = match[1]
+            text = match[2]
+            status = case status_char
+                     when "x" then :complete
+                     when "/" then :in_progress
+                     else :todo
+                     end
+            current_task.subtasks << Task.new(text: text, status: status, subtasks: [], original_line: line.chomp)
+          end
+        end
+
+        tasks << current_task if current_task
+        new(tasks)
+      end
+
+      # Display tasks with numbering for CLI
+      def display_with_indices
+        if empty?
+          puts "No tasks found."
+          return
+        end
+
+        puts "Current tasks:"
+        each_with_index do |task, i|
+          icon = status_icon(task.status)
+          puts "#{i + 1}. #{icon} #{task.text}"
+
+          task.subtasks.each do |subtask|
+            sub_icon = status_icon(subtask.status)
+            puts "   #{sub_icon} #{subtask.text}"
+          end
+        end
+      end
+
+      def current = find { |t| t.status == :in_progress }
+      def next = find { |t| t.status == :todo }
+
+      def all_complete?
+        !empty? && all? { |t| t.status == :complete }
+      end
+
+      def status_icon(status)
+        case status
+        when :complete    then "✅"
+        when :in_progress then "🔄"
+        else "⏸️"
+        end
+      end
+
+      def self.status_icon(status)
+        case status
+        when :complete    then "✅"
+        when :in_progress then "🔄"
+        else "⏸️"
+        end
+      end
+    end
+  end
+end

data/lib/ralph/threads/heartbeat.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ralph
+  module Threads
+    class Heartbeat
+      include ::Ralph::Helpers
+
+      def initialize(iteration_start, heartbeat_interval_ms, timing, mutex)
+        @iteration_start = iteration_start
+        @heartbeat_interval_ms = heartbeat_interval_ms
+        @timing = timing
+        @mutex = mutex
+
+        @thread = Thread.new { run_loop }
+      end
+
+      def stop
+        @thread&.kill
+      end
+
+      def join
+        @thread&.join
+      end
+
+      private
+
+      def run_loop
+        loop do
+          sleep(@heartbeat_interval_ms / 1000.0)
+          now_ms.then do |now|
+            if now - @mutex.synchronize { @timing[:last_printed_at] } >= @heartbeat_interval_ms
+              @mutex.synchronize do
+                puts "⏳ working... elapsed #{format_duration(now - @iteration_start)} · last activity #{format_duration(now - @timing[:last_activity_at])} ago"
+                @timing[:last_printed_at] = now_ms
+              end
+            end
+          end
+        end
+      rescue StandardError
+        # thread cleanup
+      end
+    end
+  end
+end

data/lib/ralph/threads/stream_reader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ralph
+  module Threads
+    class StreamReader
+      def initialize(io, text_buffer, mutex, tool_counts, on_line, is_error, tool_parser)
+        @io = io
+        @text_buffer = text_buffer
+        @mutex = mutex
+        @tool_counts = tool_counts
+        @on_line = on_line
+        @is_error = is_error
+        @tool_parser = tool_parser
+
+        @thread = Thread.new { run_loop }
+      end
+
+      def stop
+        @thread&.kill
+      end
+
+      def join
+        @thread&.join
+      end
+
+      private
+
+      def run_loop
+        buffer = +""
+        while (chunk = @io.read(4096))
+          @text_buffer << chunk
+          buffer << chunk
+          while (index = buffer.index("\n"))
+            line = buffer.slice!(0, index + 1).chomp
+            tool = @tool_parser.call(line)
+            @mutex.synchronize { @tool_counts[tool] += 1 } if tool
+            @on_line.call(line, @is_error, tool) if @on_line
+          end
+        end
+        unless buffer.empty?
+          tool = @tool_parser.call(buffer)
+          @mutex.synchronize { @tool_counts[tool] += 1 } if tool
+          @on_line.call(buffer, @is_error, tool) if @on_line
+        end
+      rescue IOError
+        # stream closed
+      end
+    end
+  end
+end

data/lib/ralph/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ralph
+  VERSION = "1.2.435535439"
+end

data/lib/ralph.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "optparse"
+require "open3"
+
+module Ralph
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠟⠛⠋⠉⠁⠀⡀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠛⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠋⢁⡠⠀⡀⠀⣠⡾⠟⣡⡶⢃⣴⡟⣰⣶⠀⣦⠰⣄⠠⣄⠀⠈⠙⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⠀⢀⡴⢋⣴⠟⢡⣾⠋⣠⡾⠋⣴⣿⠟⢠⣿⡏⢸⣿⡄⢻⣧⠘⣷⣄⠀⢀⠀⠈⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⠟⠋⠀⢀⡴⠋⣠⣿⠃⣴⡿⢃⣼⣿⠁⣼⣿⡏⠀⣿⣿⡇⣼⣿⣷⠀⣿⣷⡈⢻⣧⠘⣷⡀⢦⣄⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⠏⣤⠂⣠⠞⢁⣴⡿⠁⣼⡿⠁⣼⣿⡇⣼⣿⣿⣇⣴⣿⣿⣇⣿⣿⣿⡄⢹⣿⣇⠀⣿⣧⡈⣷⡈⢻⣦⠀⢌⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⡿⢁⡼⠃⣴⠏⢀⣾⡿⠀⣸⣿⡇⣸⣿⣿⣧⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⣷⣿⣷⣾⣿⣷⠈⢧⣌⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⡿⠁⡾⠁⣸⡟⢀⣿⣿⡇⢠⣿⣿⣇⣿⣿⣿⣿⣿⡿⠋⣁⣀⣀⣀⣉⠹⢿⣿⣿⣿⣿⣿⣿⠟⢋⣁⣀⣤⣈⡙⢿⡇⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣇⣤⡇⢠⣿⡇⣾⣿⣿⡁⣾⣿⣿⣿⣿⣿⣿⣿⠏⢠⣿⣿⣿⣿⣿⣿⣷⡄⢻⣿⣿⣿⣿⠋⣶⣿⣿⣿⣿⣿⣿⡌⢷⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⠀⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⠉⠈⣻⣿⣿⣿⡷⠘⣿⣿⣿⡷⠀⣿⣿⣿⡁⠀⣿⣿⡇⣸⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⠏⣀⣀⣀⣩⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠙⣿⣦⣶⣿⣿⣿⣿⠇⢸⣿⣿⣿⣿⣆⠈⢿⣿⣿⣿⣿⡿⢡⣿⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⡁⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡈⠛⠿⠿⠟⠛⢁⣠⣿⣿⣤⣭⣉⡉⠑⢤⣈⠉⢋⣉⣴⣿⣿⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣇⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣶⣶⣶⣾⣿⡿⠿⢿⣿⣿⣿⣿⣦⠀⣿⣿⣿⣿⣿⣿⣿⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣷⣌⠙⠛⠛⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠉⣀⣤⣄⠈⠻⣿⠟⠋⢀⣿⣿⣿⣿⣿⣿⣿⣿⣄⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣶⡈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⡿⠋⣠⣤⣤⣴⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣄⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⠀⣿⣿⠟⢠⣿⣿⣿⡟⠁⠈⣉⡉⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠛⢁⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⡈⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣀⣀⠀⣿⣿⣿⣿⣷⣶⣾⣿⡿⠂⠈⠻⠿⠟⠛⠛⠛⢉⣉⣠⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⡿⢀⣾⣿⣶⣄⡈⠙⠻⢿⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⣿⣿⣿⣿⣧⣤⣶⣶⣆⠀⣶⣶⠂⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⠃⠸⣿⣿⣿⣿⣿⣷⣦⣄⣀⡉⠛⠛⠛⠛⠛⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⢰⠟⠁⠘⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⡿⠛⠁⣀⠀⠉⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⡷⠀⣰⣶⣶⣦⣀⠉⠙⢿⣿⣿⣿⣿⠀⢀⣀⡀⢠⣾⡷⠀⠈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⡟⢀⣶⣿⣿⣿⣿⣦⡀⠙⢿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⣿⣿⣷⣦⡀⠈⢻⣿⣿⠀⢸⣿⣿⠀⠉⠀⠰⣶⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣷⣄⣀⡉⠻⠿⠁⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠻⠟⠀⣿⣿⠇⢀⣴⣷⣄⠈⠄⠀⠙⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢂⣀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⣦⡀⢁⣴⣿⣿⣿⣿⣆⠀⢸⣄⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⡿⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⠋⢠⣦⡀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⠃⣰⣿⣿⣧⡀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⢠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⠀⣿⣿⣿⣿⣿⣦⡈⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⢁⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣦⣄⠉⠛⠻⢿⣿⣿⣿⣿⣿⣿⠿⠟⠛⠉⢁⣠⣴⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⡄⠘⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⠇⠈⠻⢿⣿⣿⣿⣿⣿⣿⣿⣷⣦⣤⣀⣀⣀⣀⣀⣀⣀⣠⣤⣶⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢹⠀⠹⣿⣿⣿⣿⣿⣿
+  # ⡟⠀⣴⣤⣤⣀⡈⠉⠛⠛⠻⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠈⡆⠀⢹⣿⣿⣿⣿⣿
+  # ⣷⠀⠈⠻⢿⣿⣿⣷⣶⣤⣄⣀⠀⠀⠉⠉⠉⠛⠻⠿⠿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⠿⠿⠿⠿⠛⠛⠛⠛⠉⠉⠀⠀⢿⡄⠘⣿⣿⣿⣿⣿
+  # ⣿⡄⢠⣤⣀⡈⠉⠛⠻⠿⢿⣿⣿⣿⣶⣶⣶⣤⣤⣤⣄⣀⣀⣀⠀⠀⠉⠉⠉⠉⠉⠉⠉⠀⠀⠀⠀⠀⢠⣤⣤⣤⣶⣶⣶⡄⠀⣶⣶⣶⣿⠀⢸⣇⠀⣿⣿⣿⣿⣿
+  # ⣿⣷⠀⣿⣿⣿⣿⣶⣦⣤⣀⡀⠈⠉⠉⠙⠛⠿⠿⠿⠿⠿⠿⠿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⣸⣿⣿⣿⣿⣿⣿⠃⠀⠟⠋⠉⠉⠀⣸⣿⠀⣿⣿⣿⣿⣿
+  # ⣿⣿⡄⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣶⣶⣦⣤⣤⣄⣀⣀⣀⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠛⠛⠛⠋⣁⣠⣴⣶⣶⣾⡇⠀⠉⠁⠀⣿⣿⣿⣿⣿
+  # ⣿⣿⣧⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣿⣧⣀⠙⢿⣿⣿⣿
+  # ⣿⣿⣿⣧⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⣾⡿⣿⣿⣦⠈⣿⣿⣿
+  # ⣿⣿⣿⣿⣦⠈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⣴⣿⣄⠈⠉⢁⣴⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣷⡀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⡜⢹⣿⣿⠰⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⡇⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠀⢸⡇⠘⠿⠇⢀⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣧⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀⣀⣀⣴⣶⣶⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⠀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⢿⣿⣿⣿⣿⣿⣿⡿⠿⠛⠛⢛⣿⣿⣿⣿⣿⣿⣿⣿⡇⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⣈⡉⣉⣉⣉⠀⢀⣤⣤⣶⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⢸⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⡏⢰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⢸⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⠁⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠘⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠷⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⣧⡀⠹⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠇⠀⢹⣿⣿⣿⡿⠀⣀⠈⠛⠛⠛⠛⠿⠿⠿⠿⠟⠛⠛⠉⢀⣀⣀⡀⠉⠙⠛⠿⠿⣿⣿⣿⣿⣿
+  # ⣿⣿⣿⣿⣿⡟⠁⣤⣄⡀⠈⠉⠙⠛⠛⠛⠛⠛⠛⠛⠉⢉⣀⣀⣀⣀⣀⠉⠻⠿⠇⢸⣿⣿⣶⣶⣦⣤⣤⣤⣤⣶⣶⣶⣶⣿⣿⣿⣿⣿⣿⣿⣷⣶⣄⣈⠙⠻⣿⣿
+  # ⣿⣿⣿⣿⣿⠁⠸⣿⣿⣿⣿⣷⣶⣶⣶⣶⣶⣶⣶⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣄⡀⠈⠙⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠈⢻
+  # ⣿⣿⣿⣿⣿⣶⣤⣈⡉⠛⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⣤⠀⠈⠉⠉⠛⠛⠛⠛⠻⠿⠿⠿⠿⢿⣿⣿⣿⣿⣿⠿⠿⠿⠟⠋⢀⣸
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⣄⣈⠉⠛⠛⠿⠿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠘⣿⣿⣿⣿⣿⣶⣶⣦⣤⣤⣤⣤⣀⣀⣀⣤⣤⣤⣤⣴⣾⣿⣿
+  # ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣶⣤⣤⣄⣀⣀⣈⣉⠉⠉⠉⠉⠙⠛⠛⠛⠛⠛⠉⠉⣀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+end
+
+# Helpers must load first since other modules extend it at parse time
+require_relative "ralph/helpers"
+
+# Require everything else by globbing, because I'm too lazy to do anything else
+Dir[File.join(__dir__, "ralph", "**", "*.rb")].sort.each { |f| require f }

data/original/bin/ralph.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+const { spawnSync } = require("node:child_process");
+const { resolve } = require("node:path");
+
+const scriptPath = resolve(__dirname, "..", "ralph.ts");
+const result = spawnSync("bun", [scriptPath, ...process.argv.slice(2)], { stdio: "inherit" });
+
+if (result.error) {
+  console.error("Error: Bun is required to run ralph. Install Bun: https://bun.sh");
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);