rralph 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 879adb96bb31b3269ef4f60a200a8689cf4283f694f2aca5e0f9a95c24bef7ff
+  data.tar.gz: 909224ae6b25857bff64c7c789d66a16025c74601ef397d9f40c8d066707ba94
+SHA512:
+  metadata.gz: 6411d979dddce3cd5de21d510d5af092c4aa65f0d6af5371c96628320b3658d1b2f5a70495e861c15f77044fc1486fe1de29eb9fb0383a6a6637fe61c4cb11e8
+  data.tar.gz: '07018c95c8ec9029893b4548ede3e5ef1a1e601bc1243c665ba053c882fdca83ac7523c71df6005c179a85af3f775ef42f9d6a4b997ea6490dc4753918f0748b'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Hagege
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# rralph
+
+A self-improving task orchestrator for AI-assisted development. Based on Ralph Wiggum concept.
+
+## Overview
+
+`rralph` automates an iterative, AI-assisted development workflow. It reads your project's plan, learnings, and todo list, then orchestrates AI tool invocations to complete tasks one by one — learning, testing, and committing along the way.
+
+## Installation
+
+```
+gem install rralph
+```
+
+Ralph by default uses `qwen-code` as the AI agent. You can override this with the `--ai-command` flag.
+
+## Usage
+
+### Prerequisites
+
+Before running `rralph`, ensure you have:
+
+1. A Git repository initialized
+2. Three Markdown files in your working directory:
+   - `plan.md` — Your high-level project plan
+   - `learnings.md` — Accumulated insights (can start empty)
+   - `todo.md` — Task list with checkboxes (one task per line, can be empty first, rralph will generate the tasks)
+
+Example `plan.md`:
+
+```markdown
+Plan: Bash script that prints "IS EVEN" or "IS ODD" based on input.
+
+Input: One integer as command-line argument.  
+Output: "IS EVEN" if divisible by 2, "IS ODD" otherwise.  
+Error: If no argument or non-integer, print error and exit 1.
+
+Logic: Use % to check remainder. Validate input with regex: ^-?[0-9]+$.
+
+File: odd_even.sh  
+Requirements:
+
+- Need to be in bash
+- Validate input
+- Use conditional with (( ))
+- No external tools
+
+Test: 0→EVEN, 7→ODD, -4→EVEN, abc→error, no arg→error
+```
+
+### Basic Usage
+
+Run `rralph` with default settings:
+
+```bash
+rralph
+```
+
+Or with options:
+
+```bash
+rralph --max-failures 2 --watch
+```
+
+### Command-Line Options
+
+```
+rralph run [OPTIONS]
+
+Options:
+  -m, --max-failures N       Maximum allowed failures before stopping (default: 3)
+  -a, --ai-command "CMD"     AI command to invoke (default: "qwen-code -y -s")
+  -w, --watch                Run in continuous loop until completion or max failures
+  -p, --plan-path PATH       Path to plan.md file (default: "plan.md")
+  -l, --learnings-path PATH  Path to learnings.md file (default: "learnings.md")
+  -t, --todo-path PATH       Path to todo.md file (default: "todo.md")
+  -h, --help                 Show help message
+```
+
+### Examples
+
+Run a single cycle:
+
+```bash
+rralph
+```
+
+Run continuously until all tasks are done or max failures reached:
+
+```bash
+rralph --watch --max-failures 5
+```
+
+Use a custom AI command:
+
+```bash
+rralph --ai-command "claude --prompt"
+```
+
+View progress statistics:
+
+```bash
+$> rralph stats
+Tasks: 5/6 done
+Pending: 1
+Learnings: 6 lines
+```
+
+## How It Works
+
+1. **Read** — `rralph` reads `plan.md`, `learnings.md`, and `todo.md`
+2. **Prompt** — Builds a prompt with file contents and sends to LLM
+3. **Parse** — Analyzes AI response for:
+   - `FAILURE` keyword (case-insensitive, whole word)
+   - New learnings to extract
+4. **Update** — On success:
+   - Marks current task as complete in `todo.md`
+   - Appends new learnings to `learnings.md`
+   - Commits all changes to Git
+5. **Repeat** — In `--watch` mode, continues until done or max failures
+
+### Failure Handling
+
+- Each `FAILURE` response increments a counter
+- Non-failure responses reset the counter to 0
+- When max failures reached, `rralph` exits with error:
+- ```
+  Max failures reached (N). Stopping to avoid infinite loops. Review learnings.md and todo.md.
+  ```
+
+### Logging
+
+Human-readable logs are output to stderr:
+
+```
+✅ [Cycle 4] Task completed. 0 failures. Git commit: abc123
+❌ [Cycle 5] FAILURE detected. Failures: 2/3
+```
+
+In `--watch` mode, AI responses are saved to `logs/` for audit trail.
+
+## License
+
+Available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/rralph

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/rralph"
+
+Rralph::CLI.start(ARGV)

data/lib/rralph/cli.rb

@@ -0,0 +1,104 @@
+require "thor"
+require_relative "runner"
+
+module Rralph
+  class CLI < Thor
+    desc "start", "Run the rralph orchestrator"
+    method_option :max_failures,
+                  type: :numeric,
+                  default: 3,
+                  aliases: "-m",
+                  desc: "Maximum allowed failures before stopping"
+    method_option :ai_command,
+                  type: :string,
+                  default: "qwen-code -y -s",
+                  aliases: "-a",
+                  desc: "AI command to invoke"
+    method_option :watch,
+                  type: :boolean,
+                  default: false,
+                  aliases: "-w",
+                  desc: "Run in continuous loop until completion or max failures"
+    method_option :plan_path,
+                  type: :string,
+                  default: "plan.md",
+                  aliases: "-p",
+                  desc: "Path to plan.md file"
+    method_option :learnings_path,
+                  type: :string,
+                  default: "learnings.md",
+                  aliases: "-l",
+                  desc: "Path to learnings.md file"
+    method_option :todo_path,
+                  type: :string,
+                  default: "todo.md",
+                  aliases: "-t",
+                  desc: "Path to todo.md file"
+
+    def start
+      runner = Runner.new(
+        max_failures: options[:max_failures],
+        ai_command: options[:ai_command],
+        watch: options[:watch],
+        plan_path: options[:plan_path],
+        learnings_path: options[:learnings_path],
+        todo_path: options[:todo_path]
+      )
+
+      runner.run
+    rescue Rralph::FileNotFound => e
+      $stderr.puts "Error: #{e.message}"
+      $stderr.puts "Please ensure plan.md, learnings.md, and todo.md exist in the current directory."
+      exit 1
+    rescue Rralph::GitError => e
+      $stderr.puts "Git Error: #{e.message}"
+      exit 1
+    rescue => e
+      $stderr.puts "Unexpected error: #{e.message}"
+      $stderr.puts e.backtrace.first(5)
+      exit 1
+    end
+
+    desc "version", "Show rralph version"
+    def version
+      puts "rralph v#{Rralph::VERSION}"
+    end
+
+    desc "stats", "Show progress statistics"
+    method_option :plan_path,
+                  type: :string,
+                  default: "plan.md",
+                  aliases: "-p"
+    method_option :learnings_path,
+                  type: :string,
+                  default: "learnings.md",
+                  aliases: "-l"
+    method_option :todo_path,
+                  type: :string,
+                  default: "todo.md",
+                  aliases: "-t"
+
+    def stats
+      parser = Parser.new(
+        plan_path: options[:plan_path],
+        learnings_path: options[:learnings_path],
+        todo_path: options[:todo_path]
+      )
+
+      parser.load_files
+
+      all_tasks = parser.all_tasks
+      completed = parser.completed_tasks
+      pending = parser.pending_tasks
+
+      puts "Tasks: #{completed.size}/#{all_tasks.size} done"
+      puts "Pending: #{pending.size}"
+      puts "Learnings: #{parser.learnings_content.lines.size} lines"
+    rescue Rralph::FileNotFound => e
+      $stderr.puts "Error: #{e.message}"
+      exit 1
+    end
+
+    default_task :start
+  end
+end

data/lib/rralph/file_updater.rb

@@ -0,0 +1,48 @@
+module Rralph
+  class FileUpdater
+    def initialize(todo_path: "todo.md", learnings_path: "learnings.md")
+      @todo_path = todo_path
+      @learnings_path = learnings_path
+    end
+
+    def mark_task_completed(task_index)
+      content = File.read(@todo_path)
+      lines = content.lines
+
+      line = lines[task_index]
+      if line
+        updated_line = line.gsub(/^([-*]) \[ \]/, '\1 [x]')
+        lines[task_index] = updated_line
+        File.write(@todo_path, lines.join)
+      end
+    end
+
+    def append_learnings(new_learnings)
+      return if new_learnings.empty?
+
+      existing_content = File.exist?(@learnings_path) ? File.read(@learnings_path) : ""
+      existing_learnings = existing_content.lines.map(&:strip).reject(&:empty?)
+
+      unique_learnings = new_learnings.reject do |learning|
+        existing_learnings.any? { |existing| existing.include?(learning) || learning.include?(existing) }
+      end
+
+      return if unique_learnings.empty?
+
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      new_section = "\n\n## Learnings - #{timestamp}\n\n"
+      unique_learnings.each do |learning|
+        new_section += "- #{learning}\n"
+      end
+
+      File.write(@learnings_path, existing_content.rstrip + new_section + "\n")
+    end
+
+    def todo_empty?
+      return true unless File.exist?(@todo_path)
+
+      content = File.read(@todo_path)
+      content.lines.none? { |line| line.match?(/^[-*] \[ \]/i) }
+    end
+  end
+end

data/lib/rralph/git.rb

@@ -0,0 +1,37 @@
+require "shellwords"
+
+module Rralph
+  class Git
+    def initialize
+    end
+
+    def in_git_repo?
+      result = `git rev-parse --git-dir 2>/dev/null`
+      $?.success?
+    end
+
+    def commit_changes(message)
+      add_result = `git add . 2>&1`
+      unless $?.success?
+        raise GitError, "Failed to stage files: #{add_result}"
+      end
+
+      commit_result = `git commit -m #{message.shellescape} 2>&1`
+      unless $?.success?
+        raise GitError, "Failed to commit: #{commit_result}"
+      end
+
+      sha = `git rev-parse --short HEAD 2>/dev/null`.strip
+      sha
+    end
+
+    def status
+      `git status --short 2>/dev/null`
+    end
+
+    def has_changes?
+      status = `git status --porcelain 2>/dev/null`
+      !status.empty?
+    end
+  end
+end

data/lib/rralph/parser.rb

@@ -0,0 +1,126 @@
+module Rralph
+  class Parser
+    attr_reader :plan_content, :learnings_content, :todo_content
+
+    def initialize(plan_path: "plan.md", learnings_path: "learnings.md", todo_path: "todo.md")
+      @plan_path = plan_path
+      @learnings_path = learnings_path
+      @todo_path = todo_path
+    end
+
+    def load_files
+      raise FileNotFound, "plan.md not found" unless File.exist?(@plan_path)
+
+      @plan_content = File.read(@plan_path)
+      @learnings_content = File.exist?(@learnings_path) ? File.read(@learnings_path) : ""
+      @todo_content = File.exist?(@todo_path) ? File.read(@todo_path) : ""
+    end
+
+    def pending_tasks
+      return [] unless @todo_content
+
+      @todo_content.lines.map.with_index do |line, index|
+        stripped = line.strip
+        next unless stripped.start_with?("- [ ]") || stripped.start_with?("* [ ]")
+
+        task_text = stripped.sub(/^[-*] \[ \] /, "").strip
+        { index: index, line: line, text: task_text, raw: stripped }
+      end.compact
+    end
+
+    def completed_tasks
+      return [] unless @todo_content
+
+      @todo_content.lines.map.with_index do |line, index|
+        stripped = line.strip
+        next unless stripped.start_with?("- [x]") || stripped.start_with?("* [x]")
+
+        task_text = stripped.sub(/^[-*] \[x\] /i, "").strip
+        { index: index, line: line, text: task_text, raw: stripped }
+      end.compact
+    end
+
+    def all_tasks
+      return [] unless @todo_content
+
+      @todo_content.lines.map.with_index do |line, index|
+        stripped = line.strip
+        next unless stripped.match?(/^[-*] \[[ x]\]/i)
+
+        completed = stripped.match?(/^[-*] \[x\]/i)
+        task_text = stripped.sub(/^[-*] \[[ x]\] /i, "").strip
+        { index: index, line: line, text: task_text, raw: stripped, completed: completed }
+      end.compact
+    end
+
+    def has_pending_tasks?
+      pending_tasks.any?
+    end
+
+    def failure_detected?(response)
+      response.match?(/\bFAILURE\b/i)
+    end
+
+    def extract_learnings(response)
+      learnings = []
+
+      # Match various learning patterns like:
+      # "Learning: xyz", "**Learning to add:** xyz", "- Learning: xyz", etc.
+      response.lines.each do |line|
+        if match = line.match(/(?:^|\s)(?:\*\*)?(?:Learning|Insight|Note|Tip|Discovered|Found|Realized)[\s*]*[:\s]*(?:to add)?[:\s]*(.+?)(?:\*\*)?(?:\s*$)/i)
+          learning = match[1].strip
+          learning = learning.gsub(/^\*\*|\*\*$/, "").strip
+          learnings << learning unless learning.empty?
+        end
+      end
+
+      # Also extract from ## Learnings sections
+      if response.match?(/##?\s+Learnings/i)
+        section = response.split(/##?\s+Learnings/i)[1]
+        section = section.split(/##?\s+/)[0] if section.match?(/##?\s+/)
+        section.lines.each do |line|
+          stripped = line.strip
+          next if stripped.empty?
+          stripped = stripped.sub(/^[-*]\s*/, "")
+          learnings << stripped unless stripped.empty?
+        end
+      end
+
+      learnings.uniq
+    end
+
+    def build_prompt(current_task: nil)
+      <<~PROMPT
+        You are in an iterative development loop. There is a todo list with tasks.
+        
+        YOUR CURRENT TASK (the first unchecked item in todo.md):
+        > #{current_task}
+        
+        INSTRUCTIONS - Follow these steps in order:
+        1. Implement ONLY the task shown above
+        2. Write a unit test for it
+        3. Run the test
+        4. Respond with exactly one of:
+           - "DONE" if the task is complete and test passes
+           - "FAILURE" if the test fails after your best effort
+        5. Optionally add learnings as: "Learning: <insight>"
+        
+        IMPORTANT RULES:
+        - Work on ONE task only - the one shown above
+        - Do NOT implement other tasks from the todo list
+        - Do NOT mark tasks as done yourself
+        - After you respond "DONE", the system will mark this task complete
+        - Then you will receive the next task
+        
+        --- plan.md (context) ---
+        #{@plan_content}
+
+        --- learnings.md (prior knowledge) ---
+        #{@learnings_content}
+
+        --- todo.md (full list - work on first unchecked only) ---
+        #{@todo_content}
+      PROMPT
+    end
+  end
+end

data/lib/rralph/runner.rb

@@ -0,0 +1,250 @@
+module Rralph
+  class Runner
+    attr_reader :cycle_count, :failure_count, :max_failures
+
+    def initialize(
+      max_failures: 3,
+      ai_command: "qwen-code -y -s",
+      watch: false,
+      plan_path: "plan.md",
+      learnings_path: "learnings.md",
+      todo_path: "todo.md"
+    )
+      @max_failures = max_failures
+      @ai_command = ai_command
+      @watch = watch
+      @plan_path = plan_path
+      @learnings_path = learnings_path
+      @todo_path = todo_path
+
+      @cycle_count = 0
+      @failure_count = 0
+
+      @parser = Parser.new(
+        plan_path: @plan_path,
+        learnings_path: @learnings_path,
+        todo_path: @todo_path
+      )
+      @file_updater = FileUpdater.new(
+        todo_path: @todo_path,
+        learnings_path: @learnings_path
+      )
+      @git = Git.new
+    end
+
+    def run
+      log("Starting rralph with max_failures=#{@max_failures}, ai_command='#{@ai_command}'")
+
+      unless @git.in_git_repo?
+        raise GitError, "Not in a git repository. Please initialize git first."
+      end
+
+      @parser.load_files
+
+      if todo_empty_or_missing?
+        log("todo.md is empty or missing. Generating todo list from plan...")
+        generate_todo_from_plan
+        return true
+      end
+
+      unless @parser.has_pending_tasks?
+        log("All tasks completed! Well done!")
+        return true
+      end
+
+      if @watch
+        run_watch_loop
+      else
+        run_single_cycle
+      end
+    end
+
+    private
+
+    def run_watch_loop
+      loop do
+        success = run_single_cycle
+        break unless success
+        break unless @parser.has_pending_tasks?
+        break if @failure_count >= @max_failures
+
+        sleep 1
+      end
+
+      check_final_state
+    end
+
+    def run_single_cycle
+      @cycle_count += 1
+
+      @parser.load_files
+
+      unless @parser.has_pending_tasks?
+        log("All tasks completed! Well done!")
+        return false
+      end
+
+      pending = @parser.pending_tasks
+      current_task = pending.first
+
+      log("Cycle #{@cycle_count}: Processing task: #{current_task[:text]}")
+
+      prompt = @parser.build_prompt(current_task: current_task[:text])
+      response = execute_ai_command(prompt)
+
+      # Always save AI request/response to logs for debugging
+      save_ai_log(prompt, response)
+
+      if response.nil?
+        @failure_count += 1
+        log("❌ [Cycle #{@cycle_count}] AI command failed. Failures: #{@failure_count}/#{@max_failures}")
+        return handle_failure
+      end
+
+      if @parser.failure_detected?(response)
+        @failure_count += 1
+        log("❌ [Cycle #{@cycle_count}] FAILURE detected. Failures: #{@failure_count}/#{@max_failures}")
+        return handle_failure
+      end
+
+      @failure_count = 0
+      log("✅ [Cycle #{@cycle_count}] Task completed. #{@failure_count} failures.")
+
+      @file_updater.mark_task_completed(current_task[:index])
+
+      new_learnings = @parser.extract_learnings(response)
+      @file_updater.append_learnings(new_learnings) if new_learnings.any?
+
+      commit_message = "rralph: completed task and updated artifacts [cycle #{@cycle_count}]"
+      sha = @git.commit_changes(commit_message)
+
+      if sha
+        log("   Git commit: #{sha}")
+      end
+
+      true
+    end
+
+    def handle_failure
+      if @failure_count >= @max_failures
+        log("Max failures reached (#{@failure_count}). Stopping to avoid infinite loops. Review learnings.md and todo.md.")
+        exit 1
+      end
+      true
+    end
+
+    def check_final_state
+      if @failure_count >= @max_failures
+        exit 1
+      elsif !@parser.has_pending_tasks?
+        log("All tasks completed! Well done!")
+        exit 0
+      end
+    end
+
+    def execute_ai_command(prompt)
+      require "tempfile"
+
+      # Write prompt to a temporary file
+      prompt_file = Tempfile.new(["rralph_prompt", ".txt"])
+      prompt_file.write(prompt)
+      prompt_file.close
+
+      # Read response from a temporary file  
+      response_file = Tempfile.new(["rralph_response", ".txt"])
+      response_file.close
+
+      begin
+        # Use bash -c with proper stdin redirection
+        cmd = "bash -c #{@ai_command.shellescape} < #{prompt_file.path} > #{response_file.path} 2>&1"
+        log("   Executing: #{@ai_command}")
+        system(cmd)
+
+        log("   Command exit status: #{$?.exitstatus}")
+        
+        response = File.read(response_file.path)
+        response.strip.empty? ? nil : response
+      ensure
+        prompt_file.unlink
+        response_file.unlink
+      end
+    rescue Errno::ENOENT => e
+      log("Error: AI command '#{@ai_command}' not found: #{e.message}")
+      nil
+    rescue => e
+      log("Error executing AI command: #{e.message}")
+      nil
+    end
+
+    def save_ai_log(prompt, response)
+      logs_dir = "logs"
+      Dir.mkdir(logs_dir) unless Dir.exist?(logs_dir)
+
+      timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+      filename = "#{logs_dir}/cycle_#{@cycle_count}_#{timestamp}.md"
+      
+      # Extract just the current task for the header
+      task_match = prompt.match(/YOUR CURRENT TASK.*?>\s*(.+?)\n/)
+      task_text = task_match ? task_match[1].strip : "Unknown"
+
+      content = <<~LOG
+        # Cycle #{@cycle_count} - #{timestamp}
+
+        ## Current Task
+        #{task_text}
+
+        ## AI Response
+
+        #{response || "(no response)"}
+      LOG
+
+      File.write(filename, content)
+      log("   Log saved: #{filename}")
+    end
+
+    def log(message)
+      $stderr.puts(message)
+    end
+
+    def todo_empty_or_missing?
+      return true unless File.exist?(@todo_path)
+
+      content = File.read(@todo_path)
+      content.strip.empty? || !content.match?(/^- \[ \]/m)
+    end
+
+    def generate_todo_from_plan
+      prompt = <<~PROMPT
+        Based on the following plan, generate a todo list with actionable tasks.
+        Format each task as a markdown checkbox like: - [ ] Task description
+        Keep tasks specific and actionable.
+
+        --- plan.md ---
+        #{@parser.plan_content}
+      PROMPT
+
+      response = execute_ai_command(prompt)
+
+      if response
+        todo_items = response.scan(/^- \[ \] .+$/).uniq
+
+        if todo_items.any?
+          todo_content = "# Todo List\n\n" + todo_items.join("\n") + "\n"
+
+          File.write(@todo_path, todo_content)
+
+          commit_message = "rralph: generated todo from plan.md"
+          sha = @git.commit_changes(commit_message)
+
+          if sha
+            log("✅ Generated #{todo_items.size} tasks. Git commit: #{sha}")
+          end
+        else
+          log("❌ Could not parse tasks from AI response")
+        end
+      else
+        log("❌ AI command failed when generating todo")
+      end
+    end
+  end
+end

data/lib/rralph.rb

@@ -0,0 +1,14 @@
+module Rralph
+  VERSION = "0.1.0"
+
+  class Error < StandardError; end
+  class FileNotFound < Error; end
+  class GitError < Error; end
+  class AICommandError < Error; end
+end
+
+require_relative "rralph/parser"
+require_relative "rralph/file_updater"
+require_relative "rralph/git"
+require_relative "rralph/runner"
+require_relative "rralph/cli"

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: rralph
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- rralph
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.58'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.58'
+description: rralph automates an iterative, AI-assisted development workflow by reading
+  plan.md, learnings.md, and todo.md, then orchestrating AI tool invocations to complete
+  tasks.
+email:
+- david@joynetiks.com
+executables:
+- rralph
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/rralph
+- lib/rralph.rb
+- lib/rralph/cli.rb
+- lib/rralph/file_updater.rb
+- lib/rralph/git.rb
+- lib/rralph/parser.rb
+- lib/rralph/runner.rb
+homepage: https://github.com/pcboy/rralph
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: A self-improving task orchestrator for AI-assisted development
+test_files: []