claude_swarm 0.1.16 → 0.1.18

data/lib/claude_swarm/orchestrator.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require "English"
 require "shellwords"
 require "json"
 require "fileutils"
 require_relative "session_path"
 require_relative "process_tracker"
+require_relative "worktree_manager"
 
 module ClaudeSwarm
   class Orchestrator
+    RUN_DIR = File.expand_path("~/.claude-swarm/run")
+
     def initialize(configuration, mcp_generator, vibe: false, prompt: nil, stream_logs: false, debug: false,
-                   restore_session_path: nil)
+                   restore_session_path: nil, worktree: nil)
       @config = configuration
       @generator = mcp_generator
       @vibe = vibe
@@ -17,6 +21,16 @@ module ClaudeSwarm
       @stream_logs = stream_logs
       @debug = debug
       @restore_session_path = restore_session_path
+      @session_path = nil
+      # Store worktree option for later use
+      @worktree_option = worktree
+      @needs_worktree_manager = worktree.is_a?(String) || worktree == "" ||
+                                configuration.instances.values.any? { |inst| !inst[:worktree].nil? }
+      # Store modified instances after worktree setup
+      @modified_instances = nil
+
+      # Set environment variable for prompt mode to suppress output
+      ENV["CLAUDE_SWARM_PROMPT"] = "1" if @prompt
     end
 
     def start
@@ -29,9 +43,13 @@ module ClaudeSwarm
 
         # Use existing session path
         session_path = @restore_session_path
+        @session_path = session_path
         ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
         ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
 
+        # Create run symlink for restored session
+        create_run_symlink
+
         unless @prompt
           puts "📝 Using existing session: #{session_path}/"
           puts
@@ -43,6 +61,9 @@ module ClaudeSwarm
         # Set up signal handlers to clean up child processes
         setup_signal_handlers
 
+        # Check if the original session used worktrees
+        restore_worktrees_if_needed(session_path)
+
         # Regenerate MCP configurations with session IDs for restoration
         @generator.generate_all
         unless @prompt
@@ -59,10 +80,17 @@ module ClaudeSwarm
         # Generate and set session path for all instances
         session_path = SessionPath.generate(working_dir: Dir.pwd)
         SessionPath.ensure_directory(session_path)
+        @session_path = session_path
+
+        # Extract session ID from path (the timestamp part)
+        @session_id = File.basename(session_path)
 
         ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
         ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
 
+        # Create run symlink for new session
+        create_run_symlink
+
         unless @prompt
           puts "📝 Session files will be saved to: #{session_path}/"
           puts
@@ -74,6 +102,24 @@ module ClaudeSwarm
         # Set up signal handlers to clean up child processes
         setup_signal_handlers
 
+        # Create WorktreeManager if needed with session ID
+        if @needs_worktree_manager
+          cli_option = @worktree_option.is_a?(String) && !@worktree_option.empty? ? @worktree_option : nil
+          @worktree_manager = WorktreeManager.new(cli_option, session_id: @session_id)
+          puts "🌳 Setting up Git worktrees..." unless @prompt
+
+          # Get all instances for worktree setup
+          # Note: instances.values already includes the main instance
+          all_instances = @config.instances.values
+
+          @worktree_manager.setup_worktrees(all_instances)
+
+          unless @prompt
+            puts "✓ Worktrees created with branch: #{@worktree_manager.worktree_name}"
+            puts
+          end
+        end
+
         # Generate all MCP configuration files
         @generator.generate_all
         unless @prompt
@@ -85,12 +131,40 @@ module ClaudeSwarm
         save_swarm_config_path(session_path)
       end
 
-      # Launch the main instance
+      # Execute before commands if specified
+      before_commands = @config.before_commands
+      if before_commands.any? && !@restore_session_path
+        unless @prompt
+          puts "⚙️  Executing before commands..."
+          puts
+        end
+
+        success = execute_before_commands(before_commands)
+        unless success
+          puts "❌ Before commands failed. Aborting swarm launch." unless @prompt
+          cleanup_processes
+          cleanup_run_symlink
+          cleanup_worktrees
+          exit 1
+        end
+
+        unless @prompt
+          puts "✓ Before commands completed successfully"
+          puts
+        end
+      end
+
+      # Launch the main instance (fetch after worktree setup to get modified paths)
       main_instance = @config.main_instance_config
       unless @prompt
         puts "🚀 Launching main instance: #{@config.main_instance}"
         puts "   Model: #{main_instance[:model]}"
-        puts "   Directory: #{main_instance[:directory]}"
+        if main_instance[:directories].size == 1
+          puts "   Directory: #{main_instance[:directory]}"
+        else
+          puts "   Directories:"
+          main_instance[:directories].each { |dir| puts "     - #{dir}" }
+        end
         puts "   Allowed tools: #{main_instance[:allowed_tools].join(", ")}" if main_instance[:allowed_tools].any?
         puts "   Disallowed tools: #{main_instance[:disallowed_tools].join(", ")}" if main_instance[:disallowed_tools]&.any?
         puts "   Connections: #{main_instance[:connections].join(", ")}" if main_instance[:connections].any?
@@ -119,12 +193,69 @@ module ClaudeSwarm
         log_thread.join
       end
 
-      # Clean up child processes
+      # Clean up child processes and run symlink
       cleanup_processes
+      cleanup_run_symlink
+      cleanup_worktrees
     end
 
     private
 
+    def execute_before_commands(commands)
+      log_file = File.join(@session_path, "session.log") if @session_path
+
+      commands.each_with_index do |command, index|
+        # Log the command execution to session log
+        if @session_path
+          File.open(log_file, "a") do |f|
+            f.puts "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}] Executing before command #{index + 1}/#{commands.size}: #{command}"
+          end
+        end
+
+        # Execute the command and capture output
+        begin
+          puts "Debug: Executing command #{index + 1}/#{commands.size}: #{command}" if @debug && !@prompt
+
+          # Use system with output capture
+          output = `#{command} 2>&1`
+          success = $CHILD_STATUS.success?
+
+          # Log the output
+          if @session_path
+            File.open(log_file, "a") do |f|
+              f.puts "Command output:"
+              f.puts output
+              f.puts "Exit status: #{$CHILD_STATUS.exitstatus}"
+              f.puts "-" * 80
+            end
+          end
+
+          # Show output if in debug mode or if command failed
+          if (@debug || !success) && !@prompt
+            puts "Command #{index + 1} output:"
+            puts output
+            puts "Exit status: #{$CHILD_STATUS.exitstatus}"
+          end
+
+          unless success
+            puts "❌ Before command #{index + 1} failed: #{command}" unless @prompt
+            return false
+          end
+        rescue StandardError => e
+          puts "Error executing before command #{index + 1}: #{e.message}" unless @prompt
+          if @session_path
+            File.open(log_file, "a") do |f|
+              f.puts "Error: #{e.message}"
+              f.puts "-" * 80
+            end
+          end
+          return false
+        end
+      end
+
+      true
+    end
+
     def save_swarm_config_path(session_path)
       # Copy the YAML config file to the session directory
       config_copy_path = File.join(session_path, "config.yml")
@@ -133,6 +264,20 @@ module ClaudeSwarm
       # Save the original working directory
       start_dir_file = File.join(session_path, "start_directory")
       File.write(start_dir_file, Dir.pwd)
+
+      # Save session metadata
+      metadata = {
+        "start_directory" => Dir.pwd,
+        "timestamp" => Time.now.utc.iso8601,
+        "swarm_name" => @config.swarm_name,
+        "claude_swarm_version" => VERSION
+      }
+
+      # Add worktree info if applicable
+      metadata["worktree"] = @worktree_manager.session_metadata if @worktree_manager
+
+      metadata_file = File.join(session_path, "session_metadata.json")
+      File.write(metadata_file, JSON.pretty_generate(metadata))
     end
 
     def setup_signal_handlers
@@ -140,6 +285,8 @@ module ClaudeSwarm
         Signal.trap(signal) do
           puts "\n🛑 Received #{signal} signal, cleaning up..."
           cleanup_processes
+          cleanup_run_symlink
+          cleanup_worktrees
           exit
         end
       end
@@ -152,6 +299,43 @@ module ClaudeSwarm
       puts "⚠️  Error during cleanup: #{e.message}"
     end
 
+    def cleanup_worktrees
+      return unless @worktree_manager
+
+      @worktree_manager.cleanup_worktrees
+    rescue StandardError => e
+      puts "⚠️  Error during worktree cleanup: #{e.message}"
+    end
+
+    def create_run_symlink
+      return unless @session_path
+
+      FileUtils.mkdir_p(RUN_DIR)
+
+      # Session ID is the last part of the session path
+      session_id = File.basename(@session_path)
+      symlink_path = File.join(RUN_DIR, session_id)
+
+      # Remove stale symlink if exists
+      File.unlink(symlink_path) if File.symlink?(symlink_path)
+
+      # Create new symlink
+      File.symlink(@session_path, symlink_path)
+    rescue StandardError => e
+      # Don't fail the process if symlink creation fails
+      puts "⚠️  Warning: Could not create run symlink: #{e.message}" unless @prompt
+    end
+
+    def cleanup_run_symlink
+      return unless @session_path
+
+      session_id = File.basename(@session_path)
+      symlink_path = File.join(RUN_DIR, session_id)
+      File.unlink(symlink_path) if File.symlink?(symlink_path)
+    rescue StandardError
+      # Ignore errors during cleanup
+    end
+
     def start_log_streaming
       Thread.new do
         session_log_path = File.join(ENV.fetch("CLAUDE_SWARM_SESSION_PATH", nil), "session.log")
@@ -238,6 +422,14 @@ module ClaudeSwarm
 
       parts << "--debug" if @debug
 
+      # Add additional directories with --add-dir
+      if instance[:directories].size > 1
+        instance[:directories][1..].each do |additional_dir|
+          parts << "--add-dir"
+          parts << additional_dir
+        end
+      end
+
       mcp_config_path = @generator.mcp_config_path(@config.main_instance)
       parts << "--mcp-config"
       parts << mcp_config_path
@@ -249,5 +441,31 @@ module ClaudeSwarm
         parts << "#{instance[:prompt]}\n\nNow just say 'I am ready to start'"
       end
     end
+
+    def restore_worktrees_if_needed(session_path)
+      metadata_file = File.join(session_path, "session_metadata.json")
+      return unless File.exist?(metadata_file)
+
+      metadata = JSON.parse(File.read(metadata_file))
+      worktree_data = metadata["worktree"]
+      return unless worktree_data && worktree_data["enabled"]
+
+      unless @prompt
+        puts "🌳 Restoring Git worktrees..."
+        puts
+      end
+
+      # Restore worktrees using the saved configuration
+      @worktree_manager = WorktreeManager.new(worktree_data["shared_name"])
+
+      # Get all instances and restore their worktree paths
+      all_instances = @config.instances.values
+      @worktree_manager.setup_worktrees(all_instances)
+
+      return if @prompt
+
+      puts "✓ Worktrees restored with branch: #{@worktree_manager.worktree_name}"
+      puts
+    end
   end
 end

data/lib/claude_swarm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeSwarm
-  VERSION = "0.1.16"
+  VERSION = "0.1.18"
 end

data/lib/claude_swarm/worktree_manager.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "json"
+require "pathname"
+require "securerandom"
+
+module ClaudeSwarm
+  class WorktreeManager
+    attr_reader :shared_worktree_name, :created_worktrees
+
+    def initialize(cli_worktree_option = nil, session_id: nil)
+      @cli_worktree_option = cli_worktree_option
+      @session_id = session_id
+      # Generate a name based on session ID if no option given, empty string, or default "worktree" from Thor
+      @shared_worktree_name = if cli_worktree_option.nil? || cli_worktree_option.empty? || cli_worktree_option == "worktree"
+                                generate_worktree_name
+                              else
+                                cli_worktree_option
+                              end
+      @created_worktrees = {} # Maps "repo_root:worktree_name" to worktree_path
+      @instance_worktree_configs = {} # Stores per-instance worktree settings
+    end
+
+    def setup_worktrees(instances)
+      # First pass: determine worktree configuration for each instance
+      instances.each do |instance|
+        worktree_config = determine_worktree_config(instance)
+        @instance_worktree_configs[instance[:name]] = worktree_config
+      end
+
+      # Second pass: create necessary worktrees
+      worktrees_to_create = collect_worktrees_to_create(instances)
+      worktrees_to_create.each do |repo_root, worktree_name|
+        create_worktree(repo_root, worktree_name)
+      end
+
+      # Third pass: map instance directories to worktree paths
+      instances.each do |instance|
+        worktree_config = @instance_worktree_configs[instance[:name]]
+
+        if ENV["CLAUDE_SWARM_DEBUG"]
+          puts "Debug [WorktreeManager]: Processing instance #{instance[:name]}"
+          puts "Debug [WorktreeManager]: Worktree config: #{worktree_config.inspect}"
+        end
+
+        next if worktree_config[:skip]
+
+        worktree_name = worktree_config[:name]
+        original_dirs = instance[:directories] || [instance[:directory]]
+        mapped_dirs = original_dirs.map { |dir| map_to_worktree_path(dir, worktree_name) }
+
+        if ENV["CLAUDE_SWARM_DEBUG"]
+          puts "Debug [WorktreeManager]: Original dirs: #{original_dirs.inspect}"
+          puts "Debug [WorktreeManager]: Mapped dirs: #{mapped_dirs.inspect}"
+        end
+
+        if instance[:directories]
+          instance[:directories] = mapped_dirs
+          # Also update the single directory field for backward compatibility
+          instance[:directory] = mapped_dirs.first
+        else
+          instance[:directory] = mapped_dirs.first
+        end
+
+        puts "Debug [WorktreeManager]: Updated instance[:directory] to: #{instance[:directory]}" if ENV["CLAUDE_SWARM_DEBUG"]
+      end
+    end
+
+    def map_to_worktree_path(original_path, worktree_name)
+      return original_path unless original_path
+
+      expanded_path = File.expand_path(original_path)
+      repo_root = find_git_root(expanded_path)
+
+      if ENV["CLAUDE_SWARM_DEBUG"]
+        puts "Debug [map_to_worktree_path]: Original path: #{original_path}"
+        puts "Debug [map_to_worktree_path]: Expanded path: #{expanded_path}"
+        puts "Debug [map_to_worktree_path]: Repo root: #{repo_root}"
+      end
+
+      return original_path unless repo_root
+
+      # Check if we have a worktree for this repo and name
+      worktree_key = "#{repo_root}:#{worktree_name}"
+      worktree_path = @created_worktrees[worktree_key]
+
+      if ENV["CLAUDE_SWARM_DEBUG"]
+        puts "Debug [map_to_worktree_path]: Worktree key: #{worktree_key}"
+        puts "Debug [map_to_worktree_path]: Worktree path: #{worktree_path}"
+        puts "Debug [map_to_worktree_path]: Created worktrees: #{@created_worktrees.inspect}"
+      end
+
+      return original_path unless worktree_path
+
+      # Calculate relative path from repo root
+      relative_path = Pathname.new(expanded_path).relative_path_from(Pathname.new(repo_root)).to_s
+
+      # Return the equivalent path in the worktree
+      result = if relative_path == "."
+                 worktree_path
+               else
+                 File.join(worktree_path, relative_path)
+               end
+
+      puts "Debug [map_to_worktree_path]: Result: #{result}" if ENV["CLAUDE_SWARM_DEBUG"]
+
+      result
+    end
+
+    def cleanup_worktrees
+      @created_worktrees.each do |worktree_key, worktree_path|
+        repo_root = worktree_key.split(":", 2).first
+        next unless File.exist?(worktree_path)
+
+        # Check for uncommitted changes
+        if has_uncommitted_changes?(worktree_path)
+          puts "⚠️  Warning: Worktree has uncommitted changes, skipping cleanup: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
+          next
+        end
+
+        # Check for unpushed commits
+        if has_unpushed_commits?(worktree_path)
+          puts "⚠️  Warning: Worktree has unpushed commits, skipping cleanup: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
+          next
+        end
+
+        puts "Removing worktree: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
+
+        # Remove the worktree
+        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "remove", worktree_path)
+        next if status.success?
+
+        puts "Warning: Failed to remove worktree: #{output}"
+        # Try force remove
+        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "remove", "--force", worktree_path)
+        puts "Force remove result: #{output}" unless status.success?
+      end
+    rescue StandardError => e
+      puts "Error during worktree cleanup: #{e.message}"
+    end
+
+    def session_metadata
+      {
+        enabled: true,
+        shared_name: @shared_worktree_name,
+        created_paths: @created_worktrees.dup,
+        instance_configs: @instance_worktree_configs.dup
+      }
+    end
+
+    # Deprecated method for backward compatibility
+    def worktree_name
+      @shared_worktree_name
+    end
+
+    private
+
+    def generate_worktree_name
+      # Use session ID if available, otherwise generate a random suffix
+      if @session_id
+        "worktree-#{@session_id}"
+      else
+        # Fallback to random suffix for tests or when session ID is not available
+        random_suffix = SecureRandom.alphanumeric(5).downcase
+        "worktree-#{random_suffix}"
+      end
+    end
+
+    def determine_worktree_config(instance)
+      # Check instance-level worktree setting
+      instance_worktree = instance[:worktree]
+
+      if instance_worktree.nil?
+        # No instance-level setting, follow CLI behavior
+        if @cli_worktree_option.nil?
+          { skip: true }
+        else
+          { skip: false, name: @shared_worktree_name }
+        end
+      elsif instance_worktree == false
+        # Explicitly disabled for this instance
+        { skip: true }
+      elsif instance_worktree == true
+        # Use shared worktree (either from CLI or auto-generated)
+        { skip: false, name: @shared_worktree_name }
+      elsif instance_worktree.is_a?(String)
+        # Use custom worktree name
+        { skip: false, name: instance_worktree }
+      else
+        raise Error, "Invalid worktree configuration for instance '#{instance[:name]}': #{instance_worktree.inspect}"
+      end
+    end
+
+    def collect_worktrees_to_create(instances)
+      worktrees_needed = {}
+
+      instances.each do |instance|
+        worktree_config = @instance_worktree_configs[instance[:name]]
+        next if worktree_config[:skip]
+
+        worktree_name = worktree_config[:name]
+        directories = instance[:directories] || [instance[:directory]]
+
+        directories.each do |dir|
+          next unless dir
+
+          expanded_dir = File.expand_path(dir)
+          repo_root = find_git_root(expanded_dir)
+          next unless repo_root
+
+          # Track unique repo_root:worktree_name combinations
+          worktrees_needed[repo_root] ||= Set.new
+          worktrees_needed[repo_root].add(worktree_name)
+        end
+      end
+
+      # Convert to array of [repo_root, worktree_name] pairs
+      result = []
+      worktrees_needed.each do |repo_root, worktree_names|
+        worktree_names.each do |worktree_name|
+          result << [repo_root, worktree_name]
+        end
+      end
+      result
+    end
+
+    def find_git_root(path)
+      current = File.expand_path(path)
+
+      while current != "/"
+        return current if File.exist?(File.join(current, ".git"))
+
+        current = File.dirname(current)
+      end
+
+      nil
+    end
+
+    def create_worktree(repo_root, worktree_name)
+      worktree_key = "#{repo_root}:#{worktree_name}"
+      # Create worktrees inside the repository in a .worktrees directory
+      worktree_base_dir = File.join(repo_root, ".worktrees")
+      worktree_path = File.join(worktree_base_dir, worktree_name)
+
+      # Check if worktree already exists
+      if File.exist?(worktree_path)
+        puts "Using existing worktree: #{worktree_path}" unless ENV["CLAUDE_SWARM_PROMPT"]
+        @created_worktrees[worktree_key] = worktree_path
+        return
+      end
+
+      # Ensure .worktrees directory exists
+      FileUtils.mkdir_p(worktree_base_dir)
+
+      # Create .gitignore inside .worktrees to ignore all contents
+      gitignore_path = File.join(worktree_base_dir, ".gitignore")
+      File.write(gitignore_path, "# Ignore all worktree contents\n*\n") unless File.exist?(gitignore_path)
+
+      # Get current branch
+      output, status = Open3.capture2e("git", "-C", repo_root, "rev-parse", "--abbrev-ref", "HEAD")
+      raise Error, "Failed to get current branch in #{repo_root}: #{output}" unless status.success?
+
+      current_branch = output.strip
+
+      # Create worktree with a new branch based on current branch
+      branch_name = worktree_name
+      puts "Creating worktree: #{worktree_path} with branch: #{branch_name}" unless ENV["CLAUDE_SWARM_PROMPT"]
+
+      # Create worktree with a new branch
+      output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "add", "-b", branch_name, worktree_path, current_branch)
+
+      # If branch already exists, try without -b flag
+      if !status.success? && output.include?("already exists")
+        puts "Branch #{branch_name} already exists, using existing branch" unless ENV["CLAUDE_SWARM_PROMPT"]
+        output, status = Open3.capture2e("git", "-C", repo_root, "worktree", "add", worktree_path, branch_name)
+      end
+
+      raise Error, "Failed to create worktree: #{output}" unless status.success?
+
+      @created_worktrees[worktree_key] = worktree_path
+    end
+
+    def has_uncommitted_changes?(worktree_path)
+      # Check if there are any uncommitted changes (staged or unstaged)
+      output, status = Open3.capture2e("git", "-C", worktree_path, "status", "--porcelain")
+      return false unless status.success?
+
+      # If output is not empty, there are changes
+      !output.strip.empty?
+    end
+
+    def has_unpushed_commits?(worktree_path)
+      # Get the current branch
+      branch_output, branch_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--abbrev-ref", "HEAD")
+      return false unless branch_status.success?
+
+      current_branch = branch_output.strip
+
+      # Check if the branch has an upstream
+      _, upstream_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--abbrev-ref", "#{current_branch}@{upstream}")
+
+      # If no upstream, check if there are any commits on this branch
+      unless upstream_status.success?
+        # Get the base branch (usually main or master)
+        base_branch = find_base_branch(worktree_path)
+
+        # If we can't find a base branch or this IS the base branch, check if there are any commits at all
+        if base_branch.nil? || current_branch == base_branch
+          # Check if this branch has any commits
+          commits_output, commits_status = Open3.capture2e("git", "-C", worktree_path, "rev-list", "--count", "HEAD")
+          return false unless commits_status.success?
+
+          # If there's more than 0 commits and no upstream, they're unpushed
+          return commits_output.strip.to_i.positive?
+        end
+
+        # Check if this branch has any commits not on the base branch
+        commits_output, commits_status = Open3.capture2e("git", "-C", worktree_path, "rev-list", "HEAD", "^#{base_branch}")
+        return false unless commits_status.success?
+
+        # If there are commits, they're unpushed (no upstream set)
+        return !commits_output.strip.empty?
+      end
+
+      # Check for unpushed commits
+      unpushed_output, unpushed_status = Open3.capture2e("git", "-C", worktree_path, "rev-list", "HEAD", "^#{current_branch}@{upstream}")
+      return false unless unpushed_status.success?
+
+      # If output is not empty, there are unpushed commits
+      !unpushed_output.strip.empty?
+    end
+
+    def find_base_branch(repo_path)
+      # Try to find the base branch - check for main, master, or the default branch
+      %w[main master].each do |branch|
+        _, status = Open3.capture2e("git", "-C", repo_path, "rev-parse", "--verify", "refs/heads/#{branch}")
+        return branch if status.success?
+      end
+
+      # Try to get the default branch from HEAD
+      output, status = Open3.capture2e("git", "-C", repo_path, "symbolic-ref", "refs/remotes/origin/HEAD")
+      if status.success?
+        # Extract branch name from refs/remotes/origin/main
+        branch_match = output.strip.match(%r{refs/remotes/origin/(.+)$})
+        return branch_match[1] if branch_match
+      end
+
+      nil
+    end
+  end
+end