ocak 0.2.0 → 0.4.0

data/lib/ocak/pipeline_runner.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
+require_relative 'failure_reporting'
+require_relative 'merge_orchestration'
 require_relative 'pipeline_executor'
+require_relative 'process_registry'
+require_relative 'git_utils'
+require_relative 'reready_processor'
 
 module Ocak
   class PipelineRunner
+    include FailureReporting
+    include MergeOrchestration
+
+    attr_reader :registry
+
     def initialize(config:, options: {})
       @config = config
       @options = options
       @watch_formatter = options[:watch] ? WatchFormatter.new : nil
       @shutting_down = false
+      @shutdown_count = 0
       @active_issues = []
+      @interrupted_issues = []
       @active_mutex = Mutex.new
-      @executor = PipelineExecutor.new(config: config)
+      @registry = ProcessRegistry.new
+      @executor = PipelineExecutor.new(config: config, shutdown_check: -> { @shutting_down })
     end
 
     def run
@@ -24,18 +37,26 @@ module Ocak
     end
 
     def shutdown!
-      @shutting_down = true
-      logger = build_logger
-      logger.info('Graceful shutdown initiated...')
+      count = @active_mutex.synchronize { @shutdown_count += 1 }
 
-      issues = IssueFetcher.new(config: @config, logger: logger)
-      @active_mutex.synchronize do
-        @active_issues.each do |issue_number|
-          logger.info("Returning issue ##{issue_number} to ready queue")
-          issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_ready)
-        rescue StandardError => e
-          logger.warn("Failed to reset issue ##{issue_number}: #{e.message}")
-        end
+      if count >= 2
+        force_shutdown!
+      else
+        graceful_shutdown!
+      end
+    end
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    def print_shutdown_summary
+      issues = @active_mutex.synchronize { @interrupted_issues.dup }
+      return if issues.empty?
+
+      warn "\nInterrupted issues:"
+      issues.each do |issue_number|
+        warn "  - Issue ##{issue_number}: ocak resume --issue #{issue_number}"
       end
     end
 
@@ -45,6 +66,8 @@ module Ocak
       logger = build_logger(issue_number: issue_number)
       claude = build_claude(logger)
       issues = IssueFetcher.new(config: @config)
+      ensure_labels(issues, logger)
+      @executor.issues = issues
       logger.info("Running single issue mode for ##{issue_number}")
 
       if @options[:dry_run]
@@ -53,17 +76,15 @@ module Ocak
       end
 
       issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
-      result = run_pipeline(issue_number, logger: logger, claude: claude)
+      complexity = @options[:fast] ? 'simple' : 'full'
+      result = run_pipeline(issue_number, logger: logger, claude: claude, complexity: complexity)
 
-      if result[:success]
-        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)
-        logger.info("Issue ##{issue_number} completed successfully")
+      if result[:interrupted]
+        handle_interrupted_issue(issue_number, nil, result[:phase], logger: logger, issues: issues)
+      elsif result[:success]
+        handle_single_success(issue_number, result, logger: logger, claude: claude, issues: issues)
       else
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-        issues.comment(issue_number,
-                       "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{result[:output][0..1000]}\n```")
+        report_pipeline_failure(issue_number, result, issues: issues, config: @config)
         logger.error("Issue ##{issue_number} failed at phase: #{result[:phase]}")
       end
     end
@@ -71,11 +92,15 @@ module Ocak
     def run_loop
       logger = build_logger
       issues = IssueFetcher.new(config: @config, logger: logger)
+      ensure_labels(issues, logger)
+      @executor.issues = issues
       cleanup_stale_worktrees(logger)
 
       loop do
         break if @shutting_down
 
+        process_reready_prs(logger: logger, issues: issues) if @config.manual_review
+
         logger.info("Checking for #{@config.label_ready} issues...")
         ready = issues.fetch_ready
 
@@ -89,7 +114,11 @@ module Ocak
         break if @options[:once]
 
         logger.info("Sleeping #{@config.poll_interval}s...")
-        sleep @config.poll_interval
+        @config.poll_interval.times do
+          break if @shutting_down
+
+          sleep 1
+        end
       end
     end
 
@@ -116,33 +145,33 @@ module Ocak
     end
 
     def run_batch(batch_issues, logger:, issues:)
-      worktrees = WorktreeManager.new(config: @config)
+      worktrees = WorktreeManager.new(config: @config, logger: logger)
 
       threads = batch_issues.map do |issue|
         Thread.new { process_one_issue(issue, worktrees: worktrees, issues: issues) }
       end
       results = threads.map(&:value)
 
-      results.select { |r| r[:success] }.each do |result|
+      unless @shutting_down
         merger = MergeManager.new(
-          config: @config, claude: build_claude(logger), logger: logger, watch: @watch_formatter
+          config: @config, claude: build_claude(logger), logger: logger, issues: issues, watch: @watch_formatter
         )
-        if merger.merge(result[:issue_number], result[:worktree])
-          issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_completed)
-          logger.info("Issue ##{result[:issue_number]} merged successfully")
-        else
-          issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
-          logger.error("Issue ##{result[:issue_number]} merge failed")
+        results.select { |r| r[:success] }.each do |result|
+          merge_completed_issue(result, merger: merger, issues: issues, logger: logger)
         end
       end
 
       results.each do |result|
         next unless result[:worktree]
+        next if result[:interrupted]
 
         worktrees.remove(result[:worktree])
       rescue StandardError => e
         logger.warn("Failed to clean worktree for ##{result[:issue_number]}: #{e.message}")
       end
+
+      programming_error = results.find { |r| r[:programming_error] }&.dig(:programming_error)
+      raise programming_error if programming_error
     end
 
     def process_one_issue(issue, worktrees:, issues:)
@@ -151,48 +180,116 @@ module Ocak
       claude = build_claude(logger)
       worktree = nil
 
-      @active_mutex.synchronize { @active_issues << issue_number }
+      @active_mutex.synchronize do
+        @active_issues << issue_number
+      end
       issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
       worktree = worktrees.create(issue_number, setup_command: @config.setup_command)
       logger.info("Created worktree at #{worktree.path} (branch: #{worktree.branch})")
 
+      complexity = @options[:fast] ? 'simple' : issue.fetch('complexity', 'full')
       result = run_pipeline(issue_number, logger: logger, claude: claude, chdir: worktree.path,
-                                          complexity: issue.fetch('complexity', 'full'))
+                                          complexity: complexity)
 
-      build_issue_result(result, issue_number: issue_number, worktree: worktree, issues: issues)
+      build_issue_result(result, issue_number: issue_number, worktree: worktree, issues: issues,
+                                 logger: logger)
     rescue StandardError => e
-      logger.error("Unexpected error: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
-      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-      { issue_number: issue_number, success: false, worktree: worktree, error: e.message }
+      handle_process_error(e, issue_number: issue_number, logger: logger, issues: issues)
+      result = { issue_number: issue_number, success: false, worktree: worktree, error: e.message }
+      # NameError includes NoMethodError
+      result[:programming_error] = e if e.is_a?(NameError) || e.is_a?(TypeError)
+      result
     ensure
       @active_mutex.synchronize { @active_issues.delete(issue_number) }
     end
 
-    def build_issue_result(result, issue_number:, worktree:, issues:)
-      if result[:success]
-        { issue_number: issue_number, success: true, worktree: worktree }
+    def build_issue_result(result, issue_number:, worktree:, issues:, logger: nil)
+      if result[:interrupted]
+        handle_interrupted_issue(issue_number, worktree&.path, result[:phase],
+                                 logger: logger || build_logger(issue_number: issue_number), issues: issues)
+        { issue_number: issue_number, success: false, worktree: worktree, interrupted: true }
+      elsif result[:success]
+        { issue_number: issue_number, success: true, worktree: worktree,
+          audit_blocked: result[:audit_blocked], audit_output: result[:audit_output] }
       else
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-        issues.comment(issue_number,
-                       "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{result[:output][0..1000]}\n```")
+        report_pipeline_failure(issue_number, result, issues: issues, config: @config)
         { issue_number: issue_number, success: false, worktree: worktree }
       end
     end
 
+    def process_reready_prs(logger:, issues:)
+      reready = issues.fetch_reready_prs
+      return if reready.empty?
+
+      logger.info("Found #{reready.size} reready PR(s)")
+      processor = RereadyProcessor.new(config: @config, logger: logger,
+                                       claude: build_claude(logger), issues: issues,
+                                       watch: @watch_formatter)
+      reready.each do |pr|
+        break if @shutting_down
+
+        processor.process(pr)
+      end
+    end
+
     def cleanup_stale_worktrees(logger)
-      worktrees = WorktreeManager.new(config: @config)
+      worktrees = WorktreeManager.new(config: @config, logger: logger)
       removed = worktrees.clean_stale
       removed.each { |path| logger.info("Cleaned stale worktree: #{path}") }
     rescue StandardError => e
       logger.warn("Stale worktree cleanup failed: #{e.message}")
     end
 
+    def ensure_labels(issues, logger)
+      issues.ensure_labels(@config.all_labels)
+    rescue StandardError => e
+      logger.warn("Failed to ensure labels: #{e.message}")
+    end
+
     def build_logger(issue_number: nil)
-      PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir), issue_number: issue_number)
+      PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir),
+                         issue_number: issue_number, log_level: @options.fetch(:log_level, :normal))
     end
 
     def build_claude(logger)
-      ClaudeRunner.new(config: @config, logger: logger, watch: @watch_formatter)
+      ClaudeRunner.new(config: @config, logger: logger, watch: @watch_formatter, registry: @registry)
+    end
+
+    def graceful_shutdown!
+      @shutting_down = true
+      warn "\nGraceful shutdown initiated — finishing current agent step(s)..."
+    end
+
+    def force_shutdown!
+      @shutting_down = true
+      warn "\nForce shutdown — killing active processes..."
+      @registry.kill_all
+    end
+
+    def handle_process_error(error, issue_number:, logger:, issues:)
+      logger.error("Unexpected #{error.class}: #{error.message}\n#{error.backtrace&.first(5)&.join("\n")}")
+      logger.debug("Full backtrace:\n#{error.backtrace&.join("\n")}")
+      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
+      begin
+        issues.comment(issue_number, "Unexpected #{error.class}: #{error.message}")
+      rescue StandardError
+        nil
+      end
+    end
+
+    def handle_interrupted_issue(issue_number, worktree_path, step_name, logger:, issues:)
+      if worktree_path
+        GitUtils.commit_changes(chdir: worktree_path,
+                                message: "wip: pipeline interrupted after step #{step_name} for issue ##{issue_number}",
+                                logger: logger)
+      end
+      issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_ready)
+      issues&.comment(issue_number,
+                      "\u{26A0}\u{FE0F} Pipeline interrupted after #{step_name}. " \
+                      "Resume with `ocak resume --issue #{issue_number}`.")
+      @active_mutex.synchronize { @interrupted_issues << issue_number }
+    rescue StandardError => e
+      logger.warn("Failed to handle interrupted issue ##{issue_number}: #{e.message}")
     end
   end
 end

data/lib/ocak/pipeline_state.rb

@@ -5,8 +5,9 @@ require 'fileutils'
 
 module Ocak
   class PipelineState
-    def initialize(log_dir:)
+    def initialize(log_dir:, logger: nil)
       @log_dir = log_dir
+      @logger = logger
     end
 
     def save(issue_number, completed_steps:, worktree_path: nil, branch: nil)
@@ -18,6 +19,10 @@ module Ocak
                                                                   branch: branch,
                                                                   updated_at: Time.now.iso8601
                                                                 }))
+    rescue StandardError => e
+      @logger&.warn("Pipeline state save failed for issue ##{issue_number}: #{e.message}") ||
+        warn("Pipeline state save failed for issue ##{issue_number}: #{e.message}")
+      nil
     end
 
     def load(issue_number)
@@ -25,7 +30,7 @@ module Ocak
       return nil unless File.exist?(path)
 
       JSON.parse(File.read(path), symbolize_names: true)
-    rescue JSON::ParserError => e
+    rescue ArgumentError, JSON::ParserError => e
       warn("Failed to parse pipeline state for issue ##{issue_number}: #{e.message}")
       nil
     end
@@ -33,6 +38,8 @@ module Ocak
     def delete(issue_number)
       path = state_path(issue_number)
       FileUtils.rm_f(path)
+    rescue ArgumentError
+      nil
     end
 
     def list
@@ -47,6 +54,8 @@ module Ocak
     private
 
     def state_path(issue_number)
+      raise ArgumentError, "Invalid issue number: #{issue_number}" unless issue_number.to_s.match?(/\A\d+\z/)
+
       File.join(@log_dir, "issue-#{issue_number}-state.json")
     end
   end

data/lib/ocak/planner.rb

@@ -11,14 +11,12 @@ module Ocak
       'verify' => 'Review the changes for GitHub issue #%<issue>s. Run: git diff main',
       'security' => 'Security review changes for GitHub issue #%<issue>s. Run: git diff main',
       'document' => 'Add documentation for changes in GitHub issue #%<issue>s',
-      'audit' => 'Audit the changed files for issue #%<issue>s. Run: git diff main --name-only',
-      'merge' => 'Create a PR, merge it, and close issue #%<issue>s',
-      'create_pr' => 'Create a PR, merge it, and close issue #%<issue>s'
+      'merge' => 'Create a PR, merge it, and close issue #%<issue>s'
     }.freeze
 
     def build_step_prompt(role, issue_number, review_output)
       if role == 'fix'
-        "Fix these review findings for issue ##{issue_number}:\n\n#{review_output}"
+        "Fix these review findings for issue ##{issue_number}:\n\n<review_output>\n#{review_output}\n</review_output>"
       elsif STEP_PROMPTS.key?(role)
         format(STEP_PROMPTS[role], issue: issue_number)
       else
@@ -47,7 +45,10 @@ module Ocak
       json_match = output.match(/\{[\s\S]*"batches"[\s\S]*\}/)
       if json_match
         parsed = JSON.parse(json_match[0])
-        parsed['batches']
+        batches = parsed['batches']
+        return sequential_batches(issues) unless batches.is_a?(Array)
+
+        batches
       else
         logger.warn('Could not parse planner output, falling back to sequential')
         sequential_batches(issues)

data/lib/ocak/process_registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ocak
+  class ProcessRegistry
+    KILL_WAIT = 2
+
+    def initialize
+      @pids = Set.new
+      @mutex = Mutex.new
+    end
+
+    def register(pid)
+      @mutex.synchronize { @pids.add(pid) }
+    end
+
+    def unregister(pid)
+      @mutex.synchronize { @pids.delete(pid) }
+    end
+
+    def pids
+      @mutex.synchronize { @pids.dup }
+    end
+
+    def kill_all(signal: :TERM, wait: KILL_WAIT)
+      snapshot = pids
+      return if snapshot.empty?
+
+      snapshot.each do |pid|
+        Process.kill(signal, pid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+
+      sleep wait
+
+      # SIGKILL any survivors; ESRCH means already exited, which is fine
+      snapshot.each do |pid|
+        Process.kill(:KILL, pid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+    end
+  end
+end

data/lib/ocak/process_runner.rb

@@ -5,15 +5,22 @@ require 'open3'
 module Ocak
   # Runs a subprocess with streaming line output and timeout support.
   module ProcessRunner
+    KILL_GRACE_PERIOD = 2
+
+    FailedStatus = Struct.new(:success?) do
+      def self.instance = new(false)
+    end
+
     module_function
 
-    def run(cmd, chdir:, timeout: nil, on_line: nil)
+    def run(cmd, chdir:, timeout: nil, on_line: nil, registry: nil)
       stdout = +''
       stderr = +''
       line_buf = +''
 
       Open3.popen3(*cmd, chdir: chdir) do |stdin, out, err, wait_thr|
         stdin.close
+        registry&.register(wait_thr.pid)
         ctx = {
           stdout: +'', stderr: +'', line_buf: +'',
           deadline: timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil,
@@ -23,9 +30,11 @@ module Ocak
         stdout, stderr, line_buf = read_streams(out, err, ctx)
         on_line&.call(line_buf.chomp) unless line_buf.empty?
         [stdout, stderr, wait_thr.value]
+      ensure
+        registry&.unregister(wait_thr.pid)
       end
     rescue Errno::ENOENT => e
-      ['', e.message, ClaudeRunner::FailedStatus.instance]
+      ['', e.message, FailedStatus.instance]
     end
 
     def read_streams(out, err, ctx)
@@ -47,9 +56,9 @@ module Ocak
 
     def kill_process(pid)
       Process.kill('TERM', pid)
-      sleep 2
+      sleep KILL_GRACE_PERIOD
       Process.kill('KILL', pid)
-    rescue Errno::ESRCH => e
+    rescue Errno::ESRCH, Errno::EPERM => e
       warn("Process already exited during kill: #{e.message}")
       nil
     end
@@ -66,8 +75,7 @@ module Ocak
         else
           ctx[:stderr] << chunk
         end
-      rescue EOFError => e
-        warn("Stream EOF for subprocess IO: #{e.message}")
+      rescue EOFError
         readers.delete(io)
       end
     end

data/lib/ocak/reready_processor.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require_relative 'git_utils'
+
+module Ocak
+  class RereadyProcessor
+    def initialize(config:, logger:, claude:, issues:, watch: nil)
+      @config = config
+      @logger = logger
+      @claude = claude
+      @issues = issues
+      @watch = watch
+    end
+
+    # Main entry point. Returns true on success.
+    def process(pull_request)
+      pr_number = pull_request['number']
+      issue_number = @issues.extract_issue_number_from_pr(pull_request)
+      unless issue_number
+        @logger.warn("PR ##{pr_number}: could not extract issue number from body")
+        return false
+      end
+
+      feedback = gather_feedback(pr_number, issue_number)
+      return false unless feedback
+
+      branch_name = pull_request['headRefName']
+      unless GitUtils.safe_branch_name?(branch_name)
+        @logger.error("PR ##{pr_number}: unsafe branch name '#{branch_name}'")
+        return false
+      end
+
+      unless checkout_pr_branch(branch_name)
+        @logger.error("PR ##{pr_number}: failed to checkout branch #{branch_name}")
+        cleanup
+        return false
+      end
+
+      success = run_feedback_loop(feedback)
+      handle_result(pr_number, success)
+    ensure
+      cleanup
+    end
+
+    private
+
+    def gather_feedback(pr_number, issue_number)
+      comments_data = @issues.fetch_pr_comments(pr_number)
+      issue_data = fetch_issue(issue_number)
+      return nil unless issue_data
+
+      { pr_number: pr_number, issue_number: issue_number,
+        comments: comments_data[:comments], reviews: comments_data[:reviews],
+        issue_title: issue_data['title'], issue_body: issue_data['body'] }
+    end
+
+    def fetch_issue(issue_number)
+      @issues.view(issue_number, fields: 'title,body')
+    end
+
+    def checkout_pr_branch(branch_name)
+      _, _, fetch_status = Open3.capture3('git', 'fetch', 'origin', branch_name,
+                                          chdir: @config.project_dir)
+      return false unless fetch_status.success?
+
+      _, _, checkout_status = Open3.capture3('git', 'checkout', branch_name,
+                                             chdir: @config.project_dir)
+      return false unless checkout_status.success?
+
+      _, _, pull_status = Open3.capture3('git', 'pull', '--rebase', 'origin', branch_name,
+                                         chdir: @config.project_dir)
+      pull_status.success?
+    end
+
+    def run_feedback_loop(feedback)
+      prompt = build_feedback_prompt(feedback)
+      result = @claude.run_agent('implementer', prompt, chdir: @config.project_dir)
+      return false unless result.success?
+
+      verified = run_verification
+      return true if verified
+
+      # One retry
+      retry_result = @claude.run_agent('implementer', "Fix the failing tests and lint errors.\n#{prompt}",
+                                       chdir: @config.project_dir)
+      return false unless retry_result.success?
+
+      run_verification
+    end
+
+    def run_verification
+      test_ok = run_optional_cmd(@config.test_command)
+      lint_ok = run_optional_cmd(@config.lint_check_command)
+      test_ok && lint_ok
+    end
+
+    def run_optional_cmd(cmd)
+      return true if cmd.nil? || cmd.empty?
+
+      _, _, status = Open3.capture3(*Shellwords.shellsplit(cmd), chdir: @config.project_dir)
+      status.success?
+    rescue ArgumentError => e
+      @logger&.warn("Invalid shell command in config: #{cmd.inspect} (#{e.message})")
+      false
+    end
+
+    def handle_result(pr_number, success)
+      if success
+        push_ok = push_updates
+        @issues.pr_transition(pr_number, remove_label: @config.label_reready)
+        if push_ok
+          @issues.pr_comment(pr_number, 'Feedback addressed. Please re-review.')
+        else
+          @issues.pr_comment(pr_number, 'Failed to push feedback changes. Please check logs.')
+        end
+        push_ok
+      else
+        @issues.pr_transition(pr_number, remove_label: @config.label_reready)
+        @issues.pr_comment(pr_number, 'Failed to address feedback automatically. Please check logs.')
+        false
+      end
+    end
+
+    def push_updates
+      committed = GitUtils.commit_changes(
+        chdir: @config.project_dir,
+        message: 'fix: address review feedback',
+        logger: @logger
+      )
+      @logger.warn('Proceeding to push without new commit') unless committed
+
+      _, _, push_status = Open3.capture3('git', 'push', '--force-with-lease', chdir: @config.project_dir)
+      push_status.success?
+    end
+
+    def cleanup
+      GitUtils.checkout_main(chdir: @config.project_dir, logger: @logger)
+    end
+
+    def build_feedback_prompt(feedback)
+      reviews_text = Array(feedback[:reviews]).map do |r|
+        "- #{r.dig('author', 'login')} [#{r['state']}]: #{r['body']}"
+      end.join("\n")
+
+      comments_text = Array(feedback[:comments]).map do |c|
+        "- #{c.dig('author', 'login')}: #{c['body']}"
+      end.join("\n")
+
+      <<~PROMPT
+        Address the review feedback on PR ##{feedback[:pr_number]} for issue ##{feedback[:issue_number]}.
+
+        ## Original Issue: #{feedback[:issue_title]}
+        <issue_body>
+        #{feedback[:issue_body]}
+        </issue_body>
+
+        ## Review Comments
+        <review_comments>
+        #{reviews_text.empty? ? '(none)' : reviews_text}
+        </review_comments>
+
+        ## PR Comments
+        <pr_comments>
+        #{comments_text.empty? ? '(none)' : comments_text}
+        </pr_comments>
+
+        ## Instructions
+        Read the PR diff with `git diff main` to understand current changes.
+        Address each piece of feedback. Do NOT revert changes unless explicitly requested.
+        Run tests and lint after making changes.
+      PROMPT
+    end
+  end
+end