ralph.rb 1.2.4355354345 → 2.0.0

data/lib/ralph/prompt_template.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-module Ralph
-  class PromptTemplate
-    class Error < StandardError; end
-
-    attr_reader :user_prompt, :context, :tasks
-
-    def initialize(user_prompt, context: nil, tasks: nil)
-      @user_prompt = user_prompt
-      @context = context
-      @tasks = tasks
-    end
-
-    def to_s = @user_prompt
-    def empty? = @user_prompt.strip.empty?
-
-    def context_section
-      @_context_section ||=
-        if @context.present?
-          "
-            ## Additional Context (added by user mid-loop)
-
-            #{@context.content}
-
-            ---
-          "
-        else
-          ""
-        end
-    end
-
-    def task_mode_prompt(state)
-      tasks_section = build_tasks_section(state)
-      <<~PROMPT.strip
-        # Ralph Wiggum Loop - Iteration #{state.iteration}
-
-        You are in an iterative development loop working through a task list.
-        #{context_section}#{tasks_section}
-        ## Your Main Goal
-
-        #{@user_prompt}
-
-        ## Critical Rules
-
-        - Work on ONE task at a time from .ralph/ralph-tasks.md
-        - ONLY output <promise>#{state.task_promise}</promise> when the current task is complete and marked in ralph-tasks.md
-        - ONLY output <promise>#{state.completion_promise}</promise> when ALL tasks are truly done
-        - Do NOT lie or output false promises to exit the loop
-        - If stuck, try a different approach
-        - Check your work before claiming completion
-
-        ## Current Iteration: #{state.iteration}#{state.max_iterations > 0 ? " / #{state.max_iterations}" : " (unlimited)"} (min: #{state.min_iterations || 1})
-
-        Tasks Mode: ENABLED - Work on one task at a time from ralph-tasks.md
-
-        Now, work on the current task. Good luck!
-      PROMPT
-    end
-
-    def non_task_mode_prompt(state)
-      <<~PROMPT.strip
-        # Ralph Wiggum Loop - Iteration #{state.iteration}
-
-        You are in an iterative development loop. Work on the task below until you can genuinely complete it.
-        #{context_section}
-        ## Your Task
-
-        #{@user_prompt}
-
-        ## Instructions
-
-        1. Read the current state of files to understand what's been done
-        2. Track your progress and plan remaining work
-        3. Make progress on the task
-        4. Run tests/verification if applicable
-        5. When the task is GENUINELY COMPLETE, output:
-           <promise>#{state.completion_promise}</promise>
-
-        ## Critical Rules
-
-        - ONLY output <promise>#{state.completion_promise}</promise> when the task is truly done
-        - Do NOT lie or output false promises to exit the loop
-        - If stuck, try a different approach
-        - Check your work before claiming completion
-        - The loop will continue until you succeed
-
-        ## Current Iteration: #{state.iteration}#{state.max_iterations > 0 ? " / #{state.max_iterations}" : " (unlimited)"} (min: #{state.min_iterations || 1})
-
-        Now, work on the task. Good luck!
-      PROMPT
-    end
-
-    # Build the full iteration prompt sent to the LLM.
-    # +state+ is a Storage::State with iteration metadata.
-    # +_agent+ is the agent config (reserved for future use).
-    def build_iteration(state, _agent)
-      if state.tasks_mode
-        task_mode_prompt(state)
-      else
-        non_task_mode_prompt(state)
-      end
-    end
-
-    private
-
-      def build_tasks_section(state)
-        tasks_path = @tasks.path
-        unless File.exist?(tasks_path)
-          return <<~SECTION
-
-            ## TASKS MODE: Enabled (no tasks file found)
-
-            Create .ralph/ralph-tasks.md with your task list, or use `ralph --add-task "description"` to add tasks.
-          SECTION
-        end
-
-        begin
-           tasks_content = File.read(tasks_path)
-           tasks = Tasks.parse(tasks_content)
-           current_task = tasks.current
-           next_task = tasks.next
-
-           task_instructions =
-             if current_task
-               <<~INST
-                🔄 CURRENT TASK: "#{current_task.text}"
-                   Focus on completing this specific task.
-                   When done: Mark as [x] in .ralph/ralph-tasks.md and output <promise>#{state.task_promise}</promise>
-              INST
-             elsif next_task
-               <<~INST
-                📍 NEXT TASK: "#{next_task.text}"
-                   Mark as [/] in .ralph/ralph-tasks.md before starting.
-                   When done: Mark as [x] and output <promise>#{state.task_promise}</promise>
-              INST
-             elsif tasks.all_complete?
-               <<~INST
-                ✅ ALL TASKS COMPLETE!
-                   Output <promise>#{state.completion_promise}</promise> to finish.
-              INST
-             else
-               <<~INST
-                📋 No tasks found. Add tasks to .ralph/ralph-tasks.md or use `ralph --add-task`
-              INST
-             end
-
-           <<~SECTION
-
-            ## TASKS MODE: Working through task list
-
-            Current tasks from .ralph/ralph-tasks.md:
-            ```markdown
-            #{tasks_content.strip}
-            ```
-            #{task_instructions}
-            ### Task Workflow
-            1. Find any task marked [/] (in progress). If none, pick the first [ ] task.
-            2. Mark the task as [/] in ralph-tasks.md before starting.
-            3. Complete the task.
-            4. Mark as [x] when verified complete.
-            5. Output <promise>#{state.task_promise}</promise> to move to the next task.
-            6. Only output <promise>#{state.completion_promise}</promise> when ALL tasks are [x].
-
-            ---
-          SECTION
-         rescue StandardError
-           <<~SECTION
-
-            ## TASKS MODE: Error reading tasks file
-
-            Unable to read .ralph/ralph-tasks.md
-          SECTION
-        end
-      end
-
-      class << self
-        def inject(user_prompt, context:, tasks:)
-          new(user_prompt, context: context, tasks: tasks)
-        end
-      end
-  end
-end

data/lib/ralph/storage/context.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Ralph
-  module Storage
-    # Represents the persistent AI context file for conversational continuity.
-    #
-    # Always instantiate with Context.new — it represents the file on disk.
-    # Content is read lazily; the file is created on first write/append.
-    class Context
-      attr_reader :path
-
-      def initialize
-        FileUtils.mkdir_p(dir)
-      end
-
-      def self.dir
-        @dir ||= File.join(Dir.pwd, ".ralph")
-      end
-
-      def dir = self.class.dir
-
-      def path
-        @path ||= File.join(dir, "ralph-context.md")
-      end
-
-      def content
-        if File.exist?(path)
-          text = File.read(path).strip
-          text.empty? ? nil : text
-        end
-      rescue StandardError
-        nil
-      end
-
-      def present? = !content.nil?
-
-      def append(text)
-        if File.exist?(path)
-          write(File.read(path) + text)
-        else
-          write("# Ralph Loop Context\n#{text}")
-        end
-      end
-
-      def write(text)
-        File.write(path, text)
-      end
-
-      def clear
-        if File.exist?(path)
-          File.delete(path) 
-        end
-      end
-    end
-  end
-end

data/lib/ralph/storage/history.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fileutils"
-
-module Ralph
-  module Storage
-    # Manages iteration history and performance tracking.
-    #
-    # Stores everything as plain hashes. No structs, no ceremony.
-    # Each iteration is a hash appended to an array, persisted as JSON.
-    class History
-      include ::Ralph::Helpers
-
-      EMPTY_HISTORY = {
-        "iterations" => [],
-        "total_duration_ms" => 0,
-        "struggle_indicators" => {
-          "repeated_errors" => {},
-          "no_progress_iterations" => 0,
-          "short_iterations" => 0
-        }
-      }.freeze
-
-      attr_reader :history
-
-      def initialize
-        @history = self.class.empty_history
-        self.class.save_history(@history)
-      end
-
-      # Record a completed iteration.
-      def record(state_iteration:, iteration_start:, result:, struggle_indicators:)
-        entry = {
-          "iteration" => state_iteration,
-          "started_at" => Time.at(iteration_start / 1000.0).utc.iso8601,
-          "ended_at" => Time.now.utc.iso8601,
-          "duration_ms" => result.duration_ms,
-          "tools_used" => result.tool_counts,
-          "files_modified" => result.files_modified,
-          "exit_code" => result.exit_code,
-          "completion_detected" => result.completion_detected,
-          "errors" => result.errors
-        }
-
-        append(entry, result.duration_ms, struggle_indicators)
-      end
-
-      # Record an iteration that raised an exception before producing a result.
-      def record_error(state_iteration:, iteration_start:, error:)
-        iteration_duration = now_ms - iteration_start
-
-        entry = {
-          "iteration" => state_iteration,
-          "started_at" => Time.at(iteration_start / 1000.0).utc.iso8601,
-          "ended_at" => Time.now.utc.iso8601,
-          "duration_ms" => iteration_duration,
-          "tools_used" => {},
-          "files_modified" => [],
-          "exit_code" => -1,
-          "completion_detected" => false,
-          "errors" => [error.to_s[0, 200]]
-        }
-
-        append(entry, iteration_duration, nil)
-      end
-
-      def total_duration_ms
-        @history["total_duration_ms"]
-      end
-
-      # --- Class API (raw persistence) ---
-
-      class << self
-        def state_dir
-          File.join(Dir.pwd, ".ralph")
-        end
-
-        def history_path
-          File.join(state_dir, "ralph-history.json")
-        end
-
-        def empty_history
-          JSON.parse(JSON.generate(EMPTY_HISTORY))
-        end
-
-        def save_history(history)
-          FileUtils.mkdir_p(state_dir)
-          File.write(history_path, JSON.pretty_generate(history))
-        end
-
-        def load_history
-          return empty_history unless File.exist?(history_path)
-
-          JSON.parse(File.read(history_path))
-        rescue StandardError
-          empty_history
-        end
-
-        def clear_history
-          File.delete(history_path) if File.exist?(history_path)
-        rescue StandardError
-          # ignore
-        end
-      end
-
-      private
-
-      def append(entry, duration_ms, struggle_indicators)
-        @history["iterations"] << entry
-        @history["total_duration_ms"] += duration_ms
-        @history["struggle_indicators"] = struggle_indicators if struggle_indicators
-        self.class.save_history(@history)
-      end
-    end
-  end
-end

data/lib/ralph/storage/state.rb

@@ -1,178 +0,0 @@
-# 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