wralph 0.1.2

data/lib/wralph/config.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'ostruct'
+require_relative 'interfaces/repo'
+require_relative 'interfaces/print'
+
+module Wralph
+  class Config
+    class << self
+      def load
+        @config ||= begin
+          config_file = Interfaces::Repo.config_file
+          unless File.exist?(config_file)
+            Interfaces::Print.warning "Config file #{config_file} not found, using default settings"
+            return default_config
+          end
+
+          begin
+            yaml_data = YAML.load_file(config_file)
+            yaml_data = {} if yaml_data.nil? || yaml_data == false
+            # Merge with defaults to ensure all keys exist
+            merged_data = default_hash.merge(yaml_data) do |_key, default_val, yaml_val|
+              if default_val.is_a?(Hash) && yaml_val.is_a?(Hash)
+                default_val.merge(yaml_val)
+              else
+                yaml_val
+              end
+            end
+            deep_struct(merged_data)
+          rescue Psych::SyntaxError => e
+            Interfaces::Print.warning "Failed to parse #{config_file}: #{e.message}"
+            default_config
+          end
+        end
+
+        @config
+      end
+
+      def reload
+        @config = nil
+        load
+      end
+
+      def reset
+        @config = nil
+      end
+
+      def method_missing(method_name, *args, &block)
+        if load.respond_to?(method_name)
+          load.public_send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        load.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      def default_hash
+        {
+          'objective_repository' => {
+            'source' => 'github_issues'
+          },
+          'ci' => {
+            'source' => 'circle_ci'
+          }
+        }
+      end
+
+      def default_config
+        deep_struct(default_hash)
+      end
+
+      def deep_struct(hash)
+        return hash unless hash.is_a?(Hash)
+
+        OpenStruct.new(
+          hash.transform_values do |value|
+            value.is_a?(Hash) ? deep_struct(value) : value
+          end
+        )
+      end
+    end
+  end
+end

data/lib/wralph/fixtures/config.yaml

@@ -0,0 +1,18 @@
+# WRALPH Configuration
+# Configure which adapters to use for different components
+
+# Where the objectives, PRDs, or other issue write-ups are stored.
+objective_repository:
+  # You can specify a "custom" source, just provide a class that implements
+  # the ObjectiveRepository interface and specify the class_name below. The
+  # file containing the class must be in the .wralph directory and track the
+  # class name in snake_case, e.g.: my_custom_objective_repository.rb
+  source: github_issues
+
+# CI/CD system adapter configuration
+ci:
+  # You can specify a "custom" source, just provide a class that implements
+  # the CI interface and specify the class_name below. The file containing
+  # the class must be in the .wralph directory and track the class name in
+  # snake_case, e.g.: my_custom_ci_adapter.rb
+  source: circle_ci

data/lib/wralph/fixtures/secrets.yaml

@@ -0,0 +1,5 @@
+# WRALPH Secrets Configuration
+# Add your CI API tokens and other secrets here
+# This file is git-ignored for security
+
+ci_api_token: # Add your CircleCI API token here

data/lib/wralph/interfaces/agent.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../adapters/agents'
+
+module Wralph
+  module Interfaces
+    module Agent
+      def self.run(instructions)
+        Adapters::Agents::ClaudeCode.run(instructions)
+      end
+    end
+  end
+end

data/lib/wralph/interfaces/ci.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative '../adapters/cis'
+require_relative '../config'
+require_relative 'repo'
+
+module Wralph
+  module Interfaces
+    module Ci
+      def self.build_status(pr_number, repo_owner, repo_name, api_token, verbose: true)
+        adapter.build_status(pr_number, repo_owner, repo_name, api_token, verbose: verbose)
+      end
+
+      def self.wait_for_build(pr_number, repo_owner, repo_name, api_token)
+        adapter.wait_for_build(pr_number, repo_owner, repo_name, api_token)
+      end
+
+      def self.build_failures(pr_number, repo_owner, repo_name, api_token)
+        adapter.build_failures(pr_number, repo_owner, repo_name, api_token)
+      end
+
+      def self.api_token
+        secrets = load_secrets
+        token = secrets['ci_api_token']
+        return nil unless token
+
+        token = token.strip
+        token.empty? ? nil : token
+      end
+
+      def self.reset_adapter
+        @adapter = nil
+      end
+
+      def self.adapter
+        @adapter ||= load_adapter
+      end
+
+      def self.load_adapter
+        config = Config.load
+        source = config.ci.source
+
+        case source
+        when 'circle_ci'
+          Adapters::Cis::CircleCi
+        when 'custom'
+          load_custom_adapter(config.ci.class_name)
+        else
+          raise "Unknown CI source: #{source}"
+        end
+      end
+
+      def self.load_custom_adapter(class_name)
+        raise "class_name is required when source is 'custom'" if class_name.nil? || class_name.empty?
+
+        # Convert class name to snake_case file path
+        file_name = class_name_to_snake_case(class_name)
+        adapter_file = File.join(Repo.wralph_dir, "#{file_name}.rb")
+
+        raise "Custom adapter file not found: #{adapter_file}" unless File.exist?(adapter_file)
+
+        # Load the file
+        load adapter_file
+
+        # Get the class constant
+        begin
+          klass = Object.const_get(class_name)
+          validate_adapter_interface(klass)
+          klass
+        rescue NameError => e
+          raise "Failed to load custom adapter class '#{class_name}': #{e.message}"
+        end
+      end
+
+      def self.class_name_to_snake_case(class_name)
+        # Convert CamelCase to snake_case
+        # Insert underscore before capital letters (except the first one)
+        # Then downcase everything
+        class_name
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+      end
+
+      def self.validate_adapter_interface(klass)
+        required_methods = %i[build_status wait_for_build build_failures]
+        missing_methods = required_methods.reject { |method| klass.respond_to?(method) }
+
+        return if missing_methods.empty?
+
+        raise "Custom adapter class must implement: #{missing_methods.join(', ')}"
+      end
+
+      def self.load_secrets
+        secrets_file = Repo.secrets_file
+        return {} unless File.exist?(secrets_file)
+
+        begin
+          YAML.load_file(secrets_file) || {}
+        rescue Psych::SyntaxError => e
+          Print.warning "Failed to parse #{secrets_file}: #{e.message}"
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/wralph/interfaces/objective_repository.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../adapters/objective_repositories'
+require_relative '../config'
+
+module Wralph
+  module Interfaces
+    module ObjectiveRepository
+      def self.download!(identifier)
+        adapter.download!(identifier)
+      end
+
+      def self.local_file_path(identifier)
+        adapter.local_file_path(identifier)
+      end
+
+      def self.reset_adapter
+        @adapter = nil
+      end
+
+      def self.adapter
+        @adapter ||= load_adapter
+      end
+
+      def self.load_adapter
+        config = Config.load
+        source = config.objective_repository.source
+
+        case source
+        when 'github_issues'
+          Adapters::ObjectiveRepositories::GithubIssues
+        when 'custom'
+          load_custom_adapter(config.objective_repository.class_name)
+        else
+          raise "Unknown objective_repository source: #{source}"
+        end
+      end
+
+      def self.load_custom_adapter(class_name)
+        raise "class_name is required when source is 'custom'" if class_name.nil? || class_name.empty?
+
+        # Convert class name to snake_case file path
+        file_name = class_name_to_snake_case(class_name)
+        adapter_file = File.join(Repo.wralph_dir, "#{file_name}.rb")
+
+        raise "Custom adapter file not found: #{adapter_file}" unless File.exist?(adapter_file)
+
+        # Load the file
+        load adapter_file
+
+        # Get the class constant
+        begin
+          klass = Object.const_get(class_name)
+          validate_adapter_interface(klass)
+          klass
+        rescue NameError => e
+          raise "Failed to load custom adapter class '#{class_name}': #{e.message}"
+        end
+      end
+
+      def self.class_name_to_snake_case(class_name)
+        # Convert CamelCase to snake_case
+        # Insert underscore before capital letters (except the first one)
+        # Then downcase everything
+        class_name
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+      end
+
+      def self.validate_adapter_interface(klass)
+        required_methods = %i[download! local_file_path]
+        missing_methods = required_methods.reject { |method| klass.respond_to?(method) }
+
+        return if missing_methods.empty?
+
+        raise "Custom adapter class must implement: #{missing_methods.join(', ')}"
+      end
+    end
+  end
+end

data/lib/wralph/interfaces/print.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wralph
+  module Interfaces
+    module Print
+      # Colors for output
+      module Colors
+        RED = "\033[0;31m"
+        GREEN = "\033[0;32m"
+        YELLOW = "\033[1;33m"
+        BLUE = "\033[0;34m"
+        NC = "\033[0m" # No Color
+      end
+
+      def self.info(msg)
+        puts "#{Colors::BLUE}ℹ#{Colors::NC} #{msg}"
+      end
+
+      def self.success(msg)
+        puts "#{Colors::GREEN}✓#{Colors::NC} #{msg}"
+      end
+
+      def self.warning(msg)
+        puts "#{Colors::YELLOW}⚠#{Colors::NC} #{msg}"
+      end
+
+      def self.error(msg)
+        puts "#{Colors::RED}✗#{Colors::NC} #{msg}"
+      end
+    end
+  end
+end

data/lib/wralph/interfaces/repo.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Wralph
+  module Interfaces
+    module Repo
+      def self.install_dir
+        @install_dir ||= begin
+          # If we're running from source (lib/wralph/interfaces/repo.rb exists relative to bin/)
+          script_path = File.realpath($0) if $0
+          if script_path && File.exist?(script_path)
+            # Go up from bin/wralph to repo root
+            File.expand_path(File.join(File.dirname(script_path), '..'))
+          else
+            # Fallback: use __dir__ from this file, go up to repo root
+            File.expand_path(File.join(__dir__, '..', '..', '..'))
+          end
+        end
+      end
+
+      def self.repo_root
+        # Find git repository root from current working directory
+        dir = Dir.pwd
+        loop do
+          return dir if File.directory?(File.join(dir, '.git'))
+
+          parent = File.dirname(dir)
+          break if parent == dir
+
+          dir = parent
+        end
+        Dir.pwd # Fallback to current directory
+      end
+
+      def self.wralph_dir
+        File.join(repo_root, '.wralph')
+      end
+
+      def self.plans_dir
+        File.join(wralph_dir, 'plans')
+      end
+
+      def self.tmp_dir
+        File.join(repo_root, 'tmp')
+      end
+
+      def self.plan_file(issue_number)
+        File.join(plans_dir, "plan_#{issue_number}.md")
+      end
+
+      def self.env_file
+        File.join(repo_root, '.env')
+      end
+
+      def self.secrets_file
+        File.join(wralph_dir, 'secrets.yaml')
+      end
+
+      def self.config_file
+        File.join(wralph_dir, 'config.yaml')
+      end
+
+      def self.failure_details_file(branch_name, retry_count)
+        File.join(tmp_dir, "#{branch_name}_failure_details_#{retry_count}_#{retry_count}.txt")
+      end
+
+      def self.fixtures_dir
+        File.join(__dir__, '..', 'fixtures')
+      end
+
+      def self.fixture_file(filename)
+        File.join(fixtures_dir, filename)
+      end
+    end
+  end
+end

data/lib/wralph/interfaces/shell.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require_relative 'print'
+
+module Wralph
+  module Interfaces
+    module Shell
+      # Check if a command exists
+      def self.command_exists?(cmd)
+        system("which #{cmd} > /dev/null 2>&1")
+      end
+
+      # Run a command and return stdout, stderr, and status
+      def self.run_command(cmd, raise_on_error: false)
+        stdout, stderr, status = Open3.capture3(cmd)
+        raise "Command failed: #{cmd}\n#{stderr}" if raise_on_error && !status.success?
+
+        [stdout.chomp, stderr.chomp, status.success?]
+      end
+
+      def self.get_worktrees
+        json_output, = run_command("wt list --format=json")
+        JSON.parse(json_output.force_encoding('UTF-8'))
+      end
+
+      def self.switch_into_worktree(branch_name, create_if_not_exists: true)
+        # Check if any entry matches the branch name
+        worktree = get_worktrees.find { |wt| wt['branch'] == branch_name }
+        if worktree
+          success = system("wt switch #{worktree['branch']}")
+          unless success
+            Print.error "Failed to switch to branch #{branch_name}"
+            exit 1
+          end
+        elsif create_if_not_exists
+          success = system("wt switch --create #{branch_name}")
+          unless success
+            Print.error "Failed to switch to branch #{branch_name}"
+            exit 1
+          end
+          worktree = get_worktrees.find { |wt| wt['branch'] == branch_name }
+        else
+          Print.error "Worktree for branch #{branch_name} not found. Use --create to create it."
+          exit 1
+        end
+
+        # Change the directory of the CURRENT Ruby process to the new worktree
+        Dir.chdir(worktree['path'])
+      end
+
+      def self.ask_user_to_continue(message = 'Continue? (y/N) ')
+        print message
+        response = $stdin.gets.chomp
+        exit 1 unless response =~ /^[Yy]$/
+      end
+    end
+  end
+end

data/lib/wralph/run/execute_plan.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/repo'
+require_relative '../interfaces/print'
+require_relative '../interfaces/shell'
+require_relative '../interfaces/agent'
+require_relative '../interfaces/objective_repository'
+require_relative 'iterate_ci'
+
+module Wralph
+  module Run
+    module ExecutePlan
+      def self.run(issue_number)
+        plan_file = Interfaces::Repo.plan_file(issue_number)
+        plan_exists = File.exist?(plan_file)
+
+        branch_name = "issue-#{issue_number}".freeze
+        stdout, = Interfaces::Shell.run_command('git branch --show-current')
+        current_branch = stdout.strip
+
+        # Check if worktree already exists, if not, create it and copy .wralph directory
+        worktrees = Interfaces::Shell.get_worktrees
+        worktree_exists = worktrees.any? { |wt| wt['branch'] == branch_name }
+
+        if !worktree_exists
+          # Get the main repo root before creating worktree (in case we're already in a worktree)
+          # Use git rev-parse to reliably get the main repo root even from within a worktree
+          stdout, _, success = Interfaces::Shell.run_command('git rev-parse --show-toplevel')
+          main_repo_root = success && !stdout.empty? ? stdout.strip : Interfaces::Repo.repo_root
+          main_wralph_dir = File.join(main_repo_root, '.wralph')
+
+          # Create the worktree
+          Interfaces::Shell.switch_into_worktree(branch_name)
+
+          # Copy entire .wralph directory from main repo to the new worktree
+          if Dir.exist?(main_wralph_dir)
+            require 'fileutils'
+            worktree_wralph_dir = Interfaces::Repo.wralph_dir
+
+            # Only copy if source and destination are different (should always be true in real usage)
+            main_wralph_expanded = File.expand_path(main_wralph_dir)
+            worktree_wralph_expanded = File.expand_path(worktree_wralph_dir)
+
+            if main_wralph_expanded != worktree_wralph_expanded
+              FileUtils.mkdir_p(worktree_wralph_dir)
+              # Copy all contents from main .wralph to worktree .wralph
+              Dir.glob(File.join(main_wralph_dir, '*'), File::FNM_DOTMATCH).each do |item|
+                next if ['.', '..'].include?(File.basename(item))
+
+                dest_item = File.join(worktree_wralph_dir, File.basename(item))
+                # Skip if source and destination are the same (can happen in tests)
+                item_expanded = File.expand_path(item)
+                dest_item_expanded = File.expand_path(dest_item)
+                next if item_expanded == dest_item_expanded
+                # Skip if destination is inside source (would cause recursive copy error)
+                next if dest_item_expanded.start_with?(item_expanded + File::SEPARATOR)
+
+                begin
+                  FileUtils.cp_r(item, dest_item)
+                rescue ArgumentError => e
+                  # Handle edge case where source and dest are the same (can happen in tests)
+                  next if e.message.include?('cannot copy') && e.message.include?('to itself')
+
+                  raise
+                end
+              end
+            end
+          end
+        else
+          Interfaces::Shell.switch_into_worktree(branch_name)
+        end
+
+        # Build execution instructions based on whether plan exists
+        if plan_exists
+          execution_instructions = <<~EXECUTION_INSTRUCTIONS
+            You previously created a plan to solve GitHub issue ##{issue_number}. You can find the plan in the file: `#{plan_file}`. You have been placed in a git worktree for the branch `#{branch_name}`.
+
+            Do as follows:
+
+            1. Execute your plan:
+               - Make the necessary changes to solve the issue
+               - Commit your changes (including the plan) with a descriptive message that references the issue
+               - Push the branch to GitHub
+               - Create a pull request, referencing the issue in the body like "Fixes ##{issue_number}"
+
+            2. After creating the PR, output the PR number and its URL so I can track it.
+
+            Please proceed with these steps.
+          EXECUTION_INSTRUCTIONS
+          Interfaces::Print.info "Running Claude Code to execute the plan #{plan_file}..."
+        else
+          # Fetch GitHub issue content
+          Interfaces::Print.info "No plan found. Fetching GitHub issue ##{issue_number}..."
+          begin
+            objective_file = Interfaces::ObjectiveRepository.download!(issue_number)
+            File.read(objective_file)
+          rescue StandardError => e
+            Interfaces::Print.error "Failed to fetch objective ##{issue_number}: #{e.message}"
+            exit 1
+          end
+
+          execution_instructions = <<~EXECUTION_INSTRUCTIONS
+            I need you to solve the objective "#{issue_number}" in the file: `#{objective_file}`. You have been placed in a git worktree for the branch `#{branch_name}`.
+
+            Do as follows:
+
+            1. Solve the objective:
+               - Read and understand the objective's requirements
+               - Make the necessary code changes to solve the objective
+               - Write tests to verify the solution
+               - Commit your changes with a descriptive message that references the issue (e.g., "Fixes ##{issue_number}")
+               - Push the branch to GitHub
+               - Create a pull request, referencing the issue in the body like "Fixes ##{issue_number}"
+
+            2. After creating the PR, output the PR number and its URL so I can track it.
+
+            Please proceed with these steps.
+          EXECUTION_INSTRUCTIONS
+          Interfaces::Print.info "Running Claude Code to solve GitHub issue ##{issue_number}..."
+        end
+
+        # Run claude code with instructions
+        claude_output = Interfaces::Agent.run(execution_instructions)
+        puts "CLAUDE_OUTPUT: #{claude_output}"
+
+        # Extract PR number from output (look for patterns like "PR #123", "**PR #123**", or "Pull Request #123")
+        # Try multiple patterns in order of specificity to avoid false matches
+
+        # Pattern 1: Look for PR in URL format (most reliable and unambiguous)
+        # Matches: https://github.com/owner/repo/pull/774
+        Interfaces::Print.info 'Extracting PR number from output by looking for the PR URL pattern...'
+        pr_number = claude_output.match(%r{github\.com/[^/\s]+/[^/\s]+/pull/(\d+)}i)&.[](1)
+
+        # Pattern 2: Look for "PR Number:" followed by optional markdown formatting and the number
+        # This handles formats like "PR Number: **#774**" or "PR Number: #774"
+        if pr_number.nil?
+          # Match "PR Number:" followed by optional whitespace, optional markdown bold, optional #, then digits
+          Interfaces::Print.warning 'Extracting PR number from output by looking for the PR Number pattern...'
+          pr_number = claude_output.match(/PR\s+Number\s*:\s*(?:\*\*)?#?(\d+)/i)&.[](1)
+        end
+
+        # Pattern 3: Look for "PR #" or "Pull Request #" at start of line or after heading markers
+        if pr_number.nil?
+          Interfaces::Print.warning 'Extracting PR number from output by looking for the PR # pattern...'
+          pr_number = claude_output.match(/(?:^|\n|###\s+)[^\n]*(?:PR|Pull Request)[:\s]+(?:\*\*)?#?(\d+)/i)&.[](1)
+        end
+
+        # Pattern 4: Fallback to simple pattern but exclude "Found PR" patterns
+        if pr_number.nil?
+          # Match PR but not if preceded by "Found" or similar words
+          Interfaces::Print.warning 'Extracting PR number from output by looking for the PR pattern...'
+          pr_number = claude_output.match(/(?<!Found\s)(?:PR|Pull Request)[:\s]+(?:\*\*)?#?(\d+)/i)&.[](1)
+        end
+
+        # Pattern 5: Last resort - any PR pattern (but this might match false positives)
+        if pr_number.nil?
+          Interfaces::Print.warning 'Extracting PR number from output by looking for the any PR pattern...'
+          pr_number = claude_output.match(/(?:PR|Pull Request|pull request)[^0-9]*#?(\d+)/i)&.[](1)
+        end
+
+        if pr_number.nil?
+          # Try to find PR by branch name
+          Interfaces::Print.warning 'PR number not found in output, searching by branch name...'
+          stdout, = Interfaces::Shell.run_command("gh pr list --head #{branch_name} --json number -q '.[0].number'")
+          pr_number = stdout.strip
+          pr_number = nil if pr_number.empty? || pr_number == 'null'
+        end
+
+        if pr_number.nil?
+          Interfaces::Print.error 'Could not determine PR number. Please check the Claude Code output manually.'
+          Interfaces::Print.error "Output: #{claude_output}"
+          exit 1
+        end
+
+        Interfaces::Print.success "Found PR ##{pr_number}"
+        Interfaces::Print.info 'Proceeding to monitor CircleCI build status...'
+
+        # Step 2: Monitor CircleCI build and fix if needed
+        IterateCI.run(issue_number, pr_number)
+
+        Interfaces::Shell.switch_into_worktree(current_branch)
+      end
+    end
+  end
+end