ocak 0.4.0 → 0.6.0

data/lib/ocak/merge_orchestration.rb

@@ -14,50 +14,59 @@ module Ocak
       elsif @config.manual_review
         handle_batch_manual_review(result, merger: merger, issues: issues, logger: logger)
       elsif merger.merge(result[:issue_number], result[:worktree])
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_completed)
+        @state_machine.mark_completed(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} merged successfully")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} merge failed")
       end
     end
 
     def handle_single_success(issue_number, result, logger:, claude:, issues:)
+      target_dir = result[:target_repo]&.dig(:path) || @config.project_dir
+
       if result[:audit_blocked]
-        handle_single_audit_blocked(issue_number, result, logger: logger, claude: claude, issues: issues)
+        handle_single_audit_blocked(issue_number, result, logger: logger, claude: claude, issues: issues,
+                                                          chdir: target_dir)
       elsif @config.manual_review
-        handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues)
+        handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues, chdir: target_dir)
       else
-        claude.run_agent('merger', "Create a PR, merge it, and close issue ##{issue_number}",
-                         chdir: @config.project_dir)
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_completed)
+        unless pipeline_has_merge_step?
+          prompt = if result[:target_repo]
+                     "Create a PR and merge it for issue ##{issue_number}. " \
+                       'Do NOT close any issues (the issue lives in a different repository).'
+                   else
+                     "Create a PR, merge it, and close issue ##{issue_number}"
+                   end
+          claude.run_agent('merger', prompt, chdir: target_dir)
+        end
+        @state_machine.mark_completed(issue_number)
         logger.info("Issue ##{issue_number} completed successfully")
       end
     end
 
-    def handle_single_manual_review(issue_number, logger:, claude:, issues:)
+    def handle_single_manual_review(issue_number, logger:, claude:, issues: nil, chdir: @config.project_dir) # rubocop:disable Lint/UnusedMethodArgument
       claude.run_agent('merger',
                        "Create a PR for issue ##{issue_number} but do NOT merge it and do NOT close the issue",
-                       chdir: @config.project_dir)
-      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_awaiting_review)
+                       chdir: chdir)
+      @state_machine.mark_for_review(issue_number)
       logger.info("Issue ##{issue_number} PR created (manual review mode)")
     end
 
-    def handle_batch_manual_review(result, merger:, issues:, logger:)
+    def handle_batch_manual_review(result, merger:, logger:, issues: nil) # rubocop:disable Lint/UnusedMethodArgument
       pr_number = merger.create_pr_only(result[:issue_number], result[:worktree])
       if pr_number
-        issues.transition(result[:issue_number], from: @config.label_in_progress,
-                                                 to: @config.label_awaiting_review)
+        @state_machine.mark_for_review(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} PR ##{pr_number} created (manual review mode)")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} PR creation failed")
       end
     end
 
-    def handle_single_audit_blocked(issue_number, result, logger:, claude:, issues:)
-      handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues)
-      post_audit_comment_single(result[:audit_output], logger: logger, issues: issues)
+    def handle_single_audit_blocked(issue_number, result, logger:, claude:, issues:, chdir: @config.project_dir)
+      handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues, chdir: chdir)
+      post_audit_comment_single(result[:audit_output], logger: logger, issues: issues, chdir: chdir)
     end
 
     def handle_batch_audit(result, merger:, issues:, logger:)
@@ -68,17 +77,16 @@ module Ocak
       pr_number = merger.create_pr_only(result[:issue_number], result[:worktree])
       if pr_number
         issues.pr_comment(pr_number, "## Audit Report\n\n#{audit_output}")
-        issues.transition(result[:issue_number], from: @config.label_in_progress,
-                                                 to: @config.label_awaiting_review)
+        @state_machine.mark_for_review(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} PR ##{pr_number} created (audit findings)")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} PR creation failed")
       end
     end
 
-    def post_audit_comment_single(audit_output, logger:, issues:)
-      pr_number = find_pr_for_branch(logger: logger)
+    def post_audit_comment_single(audit_output, logger:, issues:, chdir: @config.project_dir)
+      pr_number = find_pr_for_branch(logger: logger, chdir: chdir)
       unless pr_number
         logger.warn("Could not find PR to post audit comment — findings were: #{audit_output.to_s[0..200]}")
         return
@@ -88,8 +96,12 @@ module Ocak
       logger.info("Posted audit comment on PR ##{pr_number}")
     end
 
-    def find_pr_for_branch(logger:)
-      stdout, _, status = Open3.capture3('gh', 'pr', 'view', '--json', 'number', chdir: @config.project_dir)
+    def pipeline_has_merge_step?
+      @config.steps.any? { |s| s[:role].to_s == 'merge' || s['role'].to_s == 'merge' }
+    end
+
+    def find_pr_for_branch(logger:, chdir: @config.project_dir)
+      stdout, _, status = Open3.capture3('gh', 'pr', 'view', '--json', 'number', chdir: chdir)
       return nil unless status.success?
 
       data = JSON.parse(stdout)

data/lib/ocak/merge_verification.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+module Ocak
+  # Test verification and git push logic — verify_tests, push_branch.
+  # Extracted from MergeManager to reduce file size.
+  module MergeVerification
+    private
+
+    def verify_tests(worktree)
+      test_cmd = @config.test_command
+      return true unless test_cmd
+
+      @logger.info('Running tests after rebase...')
+      stdout, stderr, status = shell(test_cmd, chdir: worktree.path)
+
+      if status.success?
+        @logger.info('Tests passed after rebase')
+        true
+      else
+        @logger.warn('Tests failed after rebase')
+        @logger.debug("Test output:\n#{stdout[0..2000]}\n#{stderr[0..500]}")
+        false
+      end
+    end
+
+    def push_branch(worktree)
+      result = run_git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
+
+      unless result.success?
+        @logger.error("Push failed: #{result.error}")
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/ocak/parallel_execution.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ocak
+  # Parallel group execution logic extracted from PipelineExecutor.
+  # Includers must provide run_single_step method and symbolize helper.
+  module ParallelExecution
+    def collect_parallel_group(steps, start_idx)
+      group = []
+      idx = start_idx
+      while idx < steps.size
+        step = symbolize(steps[idx])
+        break unless step[:parallel]
+
+        group << [step, idx]
+        idx += 1
+      end
+      group
+    end
+
+    def run_parallel_group(group, issue_number, state, logger:, claude:, chdir:)
+      mutex = Mutex.new
+      threads = group.map do |step, idx|
+        Thread.new do
+          run_single_step(step, idx, issue_number, state, logger: logger, claude: claude,
+                                                          chdir: chdir, mutex: mutex)
+        rescue StandardError => e
+          logger.error("#{step[:role]} thread failed: #{e.message}")
+          { success: false, phase: step[:role].to_s, output: "Thread error: #{e.message}" }
+        end
+      end
+
+      results = threads.map(&:value)
+      results.compact.find { |r| r.is_a?(Hash) && !r[:success] }
+    end
+  end
+end

data/lib/ocak/pipeline_executor.rb

@@ -2,19 +2,25 @@
 
 require 'open3'
 require 'fileutils'
+require_relative 'command_runner'
 require_relative 'pipeline_state'
 require_relative 'run_report'
 require_relative 'verification'
 require_relative 'planner'
 require_relative 'step_comments'
+require_relative 'state_management'
+require_relative 'step_execution'
+require_relative 'parallel_execution'
 
 module Ocak
   class PipelineExecutor
+    include CommandRunner
     include Verification
     include Planner
     include StepComments
-
-    StepContext = Struct.new(:issue_number, :idx, :role, :result, :state, :logger, :chdir)
+    include StateManagement
+    include StepExecution
+    include ParallelExecution
 
     attr_writer :issues
 
@@ -26,11 +32,13 @@ module Ocak
 
     def run_pipeline(issue_number, logger:, claude:, chdir: nil, skip_steps: [], complexity: 'full', # rubocop:disable Metrics/ParameterLists
                      steps: nil, verification_model: nil,
-                     post_start_comment: true, post_summary_comment: true)
+                     post_start_comment: true, post_summary_comment: true,
+                     skip_merge: false)
       @logger = logger
       @custom_steps = steps
       @verification_model = verification_model
       @post_summary_comment = post_summary_comment
+      @skip_merge = skip_merge
       chdir ||= @config.project_dir
       logger.info("=== Starting pipeline for issue ##{issue_number} (#{complexity}) ===")
 
@@ -120,55 +128,6 @@ module Ocak
       nil
     end
 
-    def collect_parallel_group(steps, start_idx)
-      group = []
-      idx = start_idx
-      while idx < steps.size
-        step = symbolize(steps[idx])
-        break unless step[:parallel]
-
-        group << [step, idx]
-        idx += 1
-      end
-      group
-    end
-
-    def run_parallel_group(group, issue_number, state, logger:, claude:, chdir:)
-      mutex = Mutex.new
-      threads = group.map do |step, idx|
-        Thread.new do
-          run_single_step(step, idx, issue_number, state, logger: logger, claude: claude,
-                                                          chdir: chdir, mutex: mutex)
-        rescue StandardError => e
-          logger.error("#{step[:role]} thread failed: #{e.message}")
-          nil
-        end
-      end
-
-      results = threads.map(&:value)
-      results.compact.find { |r| r.is_a?(Hash) && !r[:success] }
-    end
-
-    def run_single_step(step, idx, issue_number, state, logger:, claude:, chdir:, mutex: nil) # rubocop:disable Metrics/ParameterLists
-      role = step[:role].to_s
-      agent = step[:agent].to_s
-
-      return nil if handle_already_completed(idx, role, @skip_steps, logger)
-
-      reason = skip_reason(step, state)
-      if reason
-        logger.info("Skipping #{role} \u2014 #{reason}")
-        record_skipped_step(issue_number, state, idx, agent, role, reason)
-        return nil
-      end
-
-      result = execute_step(step, issue_number, state[:last_review_output], logger: logger, claude: claude,
-                                                                            chdir: chdir)
-      state[:report].record_step(index: idx, agent: agent, role: role, status: 'completed', result: result)
-      ctx = StepContext.new(issue_number, idx, role, result, state, logger, chdir)
-      record_step_result(ctx, mutex: mutex)
-    end
-
     def check_shutdown(state, logger)
       return false unless @shutdown_check&.call
 
@@ -176,121 +135,6 @@ module Ocak
       state[:interrupted] = true
     end
 
-    def handle_already_completed(idx, role, skip_steps, logger)
-      return false unless skip_steps.include?(idx)
-
-      logger.info("Skipping #{role} (already completed)")
-      true
-    end
-
-    def record_skipped_step(issue_number, state, idx, agent, role, reason)
-      post_step_comment(issue_number, "\u{23ED}\u{FE0F} **Skipping #{role}** \u2014 #{reason}")
-      state[:report].record_step(index: idx, agent: agent, role: role, status: 'skipped', skip_reason: reason)
-      state[:steps_skipped] += 1
-    end
-
-    def execute_step(step, issue_number, review_output, logger:, claude:, chdir:)
-      agent = step[:agent].to_s
-      role = step[:role].to_s
-      logger.info("--- Phase: #{role} (#{agent}) ---")
-      post_step_comment(issue_number, "\u{1F504} **Phase: #{role}** (#{agent})")
-      prompt = build_step_prompt(role, issue_number, review_output)
-      opts = { chdir: chdir }
-      opts[:model] = step[:model].to_s if step[:model]
-      claude.run_agent(agent.tr('_', '-'), prompt, **opts)
-    end
-
-    def record_step_result(ctx, mutex: nil)
-      sync(mutex) { accumulate_state(ctx) }
-      save_step_progress(ctx)
-      write_step_output(ctx.issue_number, ctx.idx, ctx.role, ctx.result.output)
-      post_step_completion_comment(ctx.issue_number, ctx.role, ctx.result)
-
-      check_step_failure(ctx) || check_cost_budget(ctx.state, ctx.logger)
-    end
-
-    def accumulate_state(ctx)
-      update_pipeline_state(ctx.role, ctx.result, ctx.state)
-      ctx.state[:completed_steps] << ctx.idx
-      ctx.state[:steps_run] += 1
-      ctx.state[:total_cost] += ctx.result.cost_usd.to_f
-      ctx.state[:step_results][ctx.role] = ctx.result
-    end
-
-    def sync(mutex, &)
-      if mutex
-        mutex.synchronize(&)
-      else
-        yield
-      end
-    end
-
-    def save_step_progress(ctx)
-      pipeline_state.save(ctx.issue_number,
-                          completed_steps: ctx.state[:completed_steps],
-                          worktree_path: ctx.chdir,
-                          branch: current_branch(ctx.chdir, logger: ctx.logger))
-    end
-
-    def write_step_output(issue_number, idx, agent, output)
-      return if output.to_s.empty?
-      return unless issue_number.to_s.match?(/\A\d+\z/)
-
-      safe_agent = agent.to_s.gsub(/[^a-zA-Z0-9_-]/, '')
-      dir = File.join(@config.project_dir, '.ocak', 'logs', "issue-#{issue_number}")
-      FileUtils.mkdir_p(dir)
-      File.write(File.join(dir, "step-#{idx}-#{safe_agent}.md"), output)
-    rescue StandardError => e
-      @logger&.debug("Step output write failed: #{e.message}")
-      nil
-    end
-
-    def check_step_failure(ctx)
-      return nil if ctx.result.success? || !%w[implement merge].include?(ctx.role)
-
-      ctx.logger.error("#{ctx.role} failed")
-      { success: false, phase: ctx.role, output: ctx.result.output }
-    end
-
-    def check_cost_budget(state, logger)
-      return nil unless @config.cost_budget && state[:total_cost] > @config.cost_budget
-
-      cost = format('%.2f', state[:total_cost])
-      budget = format('%.2f', @config.cost_budget)
-      logger.error("Cost budget exceeded ($#{cost}/$#{budget})")
-      { success: false, phase: 'budget', output: "Cost budget exceeded: $#{cost}" }
-    end
-
-    def skip_reason(step, state)
-      condition = step[:condition]
-
-      return 'audit found blocking issues' if step[:role].to_s == 'merge' && @config.audit_mode && state[:audit_blocked]
-      return 'manual review mode' if step[:role].to_s == 'merge' && @config.manual_review
-      return 'fast-track issue (simple complexity)' if step[:complexity] == 'full' && state[:complexity] == 'simple'
-      if condition == 'has_findings' && !state[:last_review_output]&.include?("\u{1F534}")
-        return 'no blocking findings from review'
-      end
-      return 'no fixes were made' if condition == 'had_fixes' && !state[:had_fixes]
-
-      nil
-    end
-
-    def update_pipeline_state(role, result, state)
-      case role
-      when 'review', 'verify', 'security', 'audit'
-        state[:last_review_output] = result.output
-        if role == 'audit'
-          state[:audit_output] = result.output
-          state[:audit_blocked] = !result.success? || result.output.to_s.match?(/BLOCK|🔴/)
-        end
-      when 'fix'
-        state[:had_fixes] = true
-        state[:last_review_output] = nil
-      when 'implement'
-        state[:last_review_output] = nil
-      end
-    end
-
     def run_final_verification(issue_number, logger:, claude:, chdir:)
       run_verification_with_retry(logger: logger, claude: claude, chdir: chdir,
                                   model: @verification_model) do |body|
@@ -298,29 +142,17 @@ module Ocak
       end
     end
 
-    def log_cost_summary(total_cost, logger)
-      return if total_cost.zero?
-
-      budget = @config.cost_budget
-      budget_str = budget ? " / $#{format('%.2f', budget)} budget" : ''
-      logger.info("Pipeline cost: $#{format('%.4f', total_cost)}#{budget_str}")
-    end
-
-    def save_report(report, issue_number, success:, failed_phase: nil)
-      report.finish(success: success, failed_phase: failed_phase)
-      report.save(issue_number, project_dir: @config.project_dir)
-    rescue StandardError => e
-      @logger&.debug("Report save failed: #{e.message}")
-      nil
-    end
-
     def pipeline_state
       @pipeline_state ||= PipelineState.new(log_dir: File.join(@config.project_dir, @config.log_dir))
     end
 
     def current_branch(chdir, logger: nil)
-      stdout, = Open3.capture3('git', 'rev-parse', '--abbrev-ref', 'HEAD', chdir: chdir)
-      stdout.strip
+      result = run_git('rev-parse', '--abbrev-ref', 'HEAD', chdir: chdir)
+      if result.status.nil?
+        logger&.debug("Could not determine current branch: #{result.error}")
+        return nil
+      end
+      result.output
     rescue StandardError => e
       logger&.debug("Could not determine current branch: #{e.message}")
       nil