ocak 0.1.0

data/lib/ocak/pipeline_runner.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'shellwords'
+require_relative 'pipeline_state'
+require_relative 'verification'
+require_relative 'planner'
+
+module Ocak
+  class PipelineRunner
+    include Verification
+    include Planner
+
+    StepContext = Struct.new(:issue_number, :idx, :role, :result, :state, :logger, :chdir)
+
+    def initialize(config:, options: {})
+      @config = config
+      @options = options
+      @watch_formatter = options[:watch] ? WatchFormatter.new : nil
+      @shutting_down = false
+      @active_issues = []
+      @active_mutex = Mutex.new
+    end
+
+    def run
+      if @options[:single]
+        run_single(@options[:single])
+      else
+        run_loop
+      end
+    end
+
+    def shutdown!
+      @shutting_down = true
+      logger = build_logger
+      logger.info('Graceful shutdown initiated...')
+
+      # Transition any in-progress issues back to ready
+      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
+      end
+    end
+
+    private
+
+    # --- Single Issue Mode ---
+
+    def run_single(issue_number)
+      logger = build_logger(issue_number: issue_number)
+      claude = build_claude(logger)
+      issues = IssueFetcher.new(config: @config)
+
+      logger.info("Running single issue mode for ##{issue_number}")
+
+      if @options[:dry_run]
+        logger.info("[DRY RUN] Would run pipeline for issue ##{issue_number}")
+        return
+      end
+
+      issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
+
+      result = run_pipeline(issue_number, logger: logger, claude: claude)
+
+      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")
+      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```")
+        logger.error("Issue ##{issue_number} failed at phase: #{result[:phase]}")
+      end
+    end
+
+    # --- Poll Loop ---
+
+    def run_loop
+      logger = build_logger
+      issues = IssueFetcher.new(config: @config, logger: logger)
+
+      # Clean up stale worktrees from previous runs
+      cleanup_stale_worktrees(logger)
+
+      loop do
+        break if @shutting_down
+
+        logger.info("Checking for #{@config.label_ready} issues...")
+        ready = issues.fetch_ready
+
+        if ready.empty?
+          logger.info('No ready issues found')
+        else
+          logger.info("Found #{ready.size} ready issue(s): #{ready.map { |i| "##{i['number']}" }.join(', ')}")
+          process_issues(ready, logger: logger, issues: issues)
+        end
+
+        break if @options[:once]
+
+        logger.info("Sleeping #{@config.poll_interval}s...")
+        sleep @config.poll_interval
+      end
+    end
+
+    # --- Batch Processing ---
+
+    def process_issues(ready_issues, logger:, issues:)
+      if ready_issues.size > @config.max_issues_per_run
+        logger.warn("Capping to #{@config.max_issues_per_run} issues (found #{ready_issues.size})")
+        ready_issues = ready_issues.first(@config.max_issues_per_run)
+      end
+
+      claude = build_claude(logger)
+      batches = plan_batches(ready_issues, logger: logger, claude: claude)
+
+      batches.each_with_index do |batch, idx|
+        batch_issues = batch['issues'][0...@config.max_parallel]
+        logger.info("Running batch #{idx + 1}/#{batches.size} (#{batch_issues.size} issues)")
+
+        if @options[:dry_run]
+          batch_issues.each { |i| logger.info("[DRY RUN] Would process issue ##{i['number']}: #{i['title']}") }
+          next
+        end
+
+        run_batch(batch_issues, logger: logger, issues: issues)
+      end
+    end
+
+    def run_batch(batch_issues, logger:, issues:)
+      worktrees = WorktreeManager.new(config: @config)
+
+      # Process issues in parallel
+      threads = batch_issues.map do |issue|
+        Thread.new { process_one_issue(issue, worktrees: worktrees, issues: issues) }
+      end
+
+      results = threads.map(&:value)
+
+      # Merge successful issues sequentially
+      results.select { |r| r[:success] }.each do |result|
+        merger = MergeManager.new(
+          config: @config, claude: build_claude(logger), logger: logger, 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")
+        end
+      end
+
+      # Clean up all worktrees
+      results.each do |result|
+        next unless result[:worktree]
+
+        worktrees.remove(result[:worktree])
+      rescue StandardError => e
+        logger.warn("Failed to clean worktree for ##{result[:issue_number]}: #{e.message}")
+      end
+    end
+
+    def process_one_issue(issue, worktrees:, issues:)
+      issue_number = issue['number']
+      logger = build_logger(issue_number: issue_number)
+      claude = build_claude(logger)
+      worktree = nil
+
+      @active_mutex.synchronize { @active_issues << issue_number }
+      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})")
+
+      result = run_pipeline(issue_number, logger: logger, claude: claude, chdir: worktree.path,
+                                          complexity: issue.fetch('complexity', 'full'))
+
+      build_issue_result(result, issue_number: issue_number, worktree: worktree, issues: issues)
+    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 }
+    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 }
+      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```")
+        { issue_number: issue_number, success: false, worktree: worktree }
+      end
+    end
+
+    # --- Pipeline Execution ---
+
+    def run_pipeline(issue_number, logger:, claude:, chdir: nil, skip_steps: [], complexity: 'full')
+      chdir ||= @config.project_dir
+      logger.info("=== Starting pipeline for issue ##{issue_number} (#{complexity}) ===")
+
+      state = { last_review_output: nil, had_fixes: false, completed_steps: [], total_cost: 0.0,
+                complexity: complexity }
+
+      failure = run_pipeline_steps(issue_number, state, logger: logger, claude: claude, chdir: chdir,
+                                                        skip_steps: skip_steps)
+      log_cost_summary(state[:total_cost], logger)
+      return failure if failure
+
+      failure = run_final_verification(logger: logger, claude: claude, chdir: chdir)
+      return failure if failure
+
+      # Clean up state file on success
+      pipeline_state.delete(issue_number)
+
+      logger.info("=== Pipeline complete for issue ##{issue_number} ===")
+      { success: true, output: 'Pipeline completed successfully' }
+    end
+
+    def run_pipeline_steps(issue_number, state, logger:, claude:, chdir:, skip_steps: [])
+      @config.steps.each_with_index do |step, idx|
+        step = symbolize(step)
+        role = step[:role].to_s
+
+        if skip_steps.include?(idx)
+          logger.info("Skipping #{role} (already completed)")
+          next
+        end
+
+        next if skip_step?(step, state, logger)
+
+        result = execute_step(step, issue_number, state[:last_review_output], logger: logger, claude: claude,
+                                                                              chdir: chdir)
+        ctx = StepContext.new(issue_number, idx, role, result, state, logger, chdir)
+        failure = record_step_result(ctx)
+        return failure if failure
+      end
+      nil
+    end
+
+    def record_step_result(ctx)
+      update_pipeline_state(ctx.role, ctx.result, ctx.state)
+      ctx.state[:completed_steps] << ctx.idx
+      ctx.state[:total_cost] += ctx.result.cost_usd.to_f
+      save_step_progress(ctx)
+
+      check_step_failure(ctx) || check_cost_budget(ctx.state, ctx.logger)
+    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))
+    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_step?(step, state, logger)
+      role = step[:role].to_s
+      condition = step[:condition]
+
+      if step[:complexity] == 'full' && state[:complexity] == 'simple'
+        logger.info("Skipping #{role} — fast-track issue")
+        return true
+      end
+      if condition == 'has_findings' && !state[:last_review_output]&.include?("\u{1F534}")
+        logger.info("Skipping #{role} — no blocking findings")
+        return true
+      end
+      if condition == 'had_fixes' && !state[:had_fixes]
+        logger.info("Skipping #{role} — no fixes were made")
+        return true
+      end
+      false
+    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}) ---")
+      prompt = build_step_prompt(role, issue_number, review_output)
+      claude.run_agent(agent.tr('_', '-'), prompt, chdir: chdir)
+    end
+
+    def update_pipeline_state(role, result, state)
+      case role
+      when 'review', 'verify', 'security', 'audit'
+        state[:last_review_output] = result.output
+      when 'fix'
+        state[:had_fixes] = true
+        state[:last_review_output] = nil
+      when 'implement'
+        state[:last_review_output] = nil
+      end
+    end
+
+    def run_final_verification(logger:, claude:, chdir:)
+      return nil unless @config.test_command || @config.lint_check_command
+
+      logger.info('--- Final verification ---')
+      result = run_final_checks(logger, chdir: chdir)
+      return nil if result[:success]
+
+      logger.warn('Final checks failed, attempting fix...')
+      claude.run_agent('implementer',
+                       "Fix these test/lint failures:\n\n#{result[:output]}",
+                       chdir: chdir)
+      result = run_final_checks(logger, chdir: chdir)
+      return nil if result[:success]
+
+      { success: false, phase: 'final-verify', output: result[:output] }
+    end
+
+    # --- Cost ---
+
+    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
+
+    # --- Cleanup ---
+
+    def cleanup_stale_worktrees(logger)
+      worktrees = WorktreeManager.new(config: @config)
+      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
+
+    # --- Helpers ---
+
+    def build_logger(issue_number: nil)
+      PipelineLogger.new(
+        log_dir: File.join(@config.project_dir, @config.log_dir),
+        issue_number: issue_number
+      )
+    end
+
+    def build_claude(logger)
+      ClaudeRunner.new(config: @config, logger: logger, watch: @watch_formatter)
+    end
+
+    def pipeline_state
+      @pipeline_state ||= PipelineState.new(log_dir: File.join(@config.project_dir, @config.log_dir))
+    end
+
+    def current_branch(chdir)
+      stdout, = Open3.capture3('git', 'rev-parse', '--abbrev-ref', 'HEAD', chdir: chdir)
+      stdout.strip
+    rescue StandardError
+      nil
+    end
+
+    def symbolize(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/ocak/pipeline_state.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Ocak
+  class PipelineState
+    def initialize(log_dir:)
+      @log_dir = log_dir
+    end
+
+    def save(issue_number, completed_steps:, worktree_path: nil, branch: nil)
+      FileUtils.mkdir_p(@log_dir)
+      File.write(state_path(issue_number), JSON.pretty_generate({
+                                                                  issue_number: issue_number,
+                                                                  completed_steps: completed_steps,
+                                                                  worktree_path: worktree_path,
+                                                                  branch: branch,
+                                                                  updated_at: Time.now.iso8601
+                                                                }))
+    end
+
+    def load(issue_number)
+      path = state_path(issue_number)
+      return nil unless File.exist?(path)
+
+      JSON.parse(File.read(path), symbolize_names: true)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def delete(issue_number)
+      path = state_path(issue_number)
+      FileUtils.rm_f(path)
+    end
+
+    def list
+      Dir.glob(File.join(@log_dir, 'issue-*-state.json')).filter_map do |path|
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    private
+
+    def state_path(issue_number)
+      File.join(@log_dir, "issue-#{issue_number}-state.json")
+    end
+  end
+end

data/lib/ocak/planner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ocak
+  # Batch planning logic extracted from PipelineRunner.
+  module Planner
+    STEP_PROMPTS = {
+      'implement' => 'Implement GitHub issue #%<issue>s',
+      'review' => 'Review the changes for GitHub issue #%<issue>s. Run: git diff main',
+      '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'
+    }.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}"
+      elsif STEP_PROMPTS.key?(role)
+        format(STEP_PROMPTS[role], issue: issue_number)
+      else
+        "Run #{role} for GitHub issue ##{issue_number}"
+      end
+    end
+
+    def plan_batches(issues, logger:, claude:)
+      return sequential_batches(issues) if issues.size <= 1
+
+      issue_json = JSON.generate(issues.map { |i| { number: i['number'], title: i['title'] } })
+      result = claude.run_agent(
+        'planner',
+        "Analyze these issues and output parallelization batches as JSON:\n\n#{issue_json}"
+      )
+
+      unless result.success?
+        logger.warn('Planner failed, falling back to sequential')
+        return sequential_batches(issues)
+      end
+
+      parse_planner_output(result.output, issues, logger)
+    end
+
+    def parse_planner_output(output, issues, logger)
+      json_match = output.match(/\{[\s\S]*"batches"[\s\S]*\}/)
+      if json_match
+        parsed = JSON.parse(json_match[0])
+        parsed['batches']
+      else
+        logger.warn('Could not parse planner output, falling back to sequential')
+        sequential_batches(issues)
+      end
+    rescue JSON::ParserError => e
+      logger.warn("JSON parse error from planner: #{e.message}")
+      sequential_batches(issues)
+    end
+
+    def sequential_batches(issues)
+      issues.map.with_index do |i, idx|
+        issue = i.dup
+        issue['complexity'] ||= 'full'
+        { 'batch' => idx + 1, 'issues' => [issue] }
+      end
+    end
+  end
+end

data/lib/ocak/process_runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Ocak
+  # Runs a subprocess with streaming line output and timeout support.
+  module ProcessRunner
+    module_function
+
+    def run(cmd, chdir:, timeout: nil, on_line: nil)
+      stdout = +''
+      stderr = +''
+      line_buf = +''
+
+      Open3.popen3(*cmd, chdir: chdir) do |stdin, out, err, wait_thr|
+        stdin.close
+        ctx = {
+          stdout: +'', stderr: +'', line_buf: +'',
+          deadline: timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil,
+          timeout: timeout, wait_thr: wait_thr, on_line: on_line
+        }
+
+        stdout, stderr, line_buf = read_streams(out, err, ctx)
+        on_line&.call(line_buf.chomp) unless line_buf.empty?
+        [stdout, stderr, wait_thr.value]
+      end
+    rescue Errno::ENOENT => e
+      ['', e.message, ClaudeRunner::FailedStatus.instance]
+    end
+
+    def read_streams(out, err, ctx)
+      readers = [out, err]
+
+      until readers.empty?
+        remaining = ctx[:deadline] ? ctx[:deadline] - Process.clock_gettime(Process::CLOCK_MONOTONIC) : 5
+
+        if ctx[:deadline] && remaining <= 0
+          kill_process(ctx[:wait_thr].pid)
+          return ['', "Timed out after #{ctx[:timeout]}s", +'']
+        end
+
+        read_available(readers, remaining, ctx)
+      end
+
+      [ctx[:stdout], ctx[:stderr], ctx[:line_buf]]
+    end
+
+    def kill_process(pid)
+      Process.kill('TERM', pid)
+      sleep 2
+      Process.kill('KILL', pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def read_available(readers, remaining, ctx)
+      ready = IO.select(readers, nil, nil, [remaining, 1].min)
+      return unless ready
+
+      ready[0].each do |io|
+        chunk = io.read_nonblock(8192)
+        if io == readers[0]
+          ctx[:stdout] << chunk
+          process_lines(ctx[:line_buf], chunk, ctx[:on_line])
+        else
+          ctx[:stderr] << chunk
+        end
+      rescue EOFError
+        readers.delete(io)
+      end
+    end
+
+    def process_lines(line_buf, chunk, on_line)
+      return unless on_line
+
+      line_buf << chunk
+      while (idx = line_buf.index("\n"))
+        on_line.call(line_buf.slice!(0, idx + 1).chomp)
+      end
+    end
+  end
+end