ocak 0.4.0 → 0.5.0

data/lib/ocak/git_utils.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require 'open3'
+require_relative 'command_runner'
 
 module Ocak
   module GitUtils
+    extend CommandRunner
+
     # Validates that a branch name is safe to pass to git commands.
     # Rejects names that could be interpreted as flags (starting with -)
     # or cause unexpected git behavior (containing ..).
@@ -17,22 +20,22 @@ module Ocak
     # Returns true if changes were committed, false if no changes or on failure.
     # Logs warnings via logger on failure rather than raising.
     def self.commit_changes(chdir:, message:, logger: nil)
-      stdout, _, status = Open3.capture3('git', 'status', '--porcelain', chdir: chdir)
-      unless status.success?
+      result = run_git('status', '--porcelain', chdir: chdir)
+      unless result.success?
         logger&.warn('git status --porcelain failed')
         return false
       end
-      return false if stdout.strip.empty?
+      return false if result.output.empty?
 
-      _, stderr, add_status = Open3.capture3('git', 'add', '-A', chdir: chdir)
-      unless add_status.success?
-        logger&.warn("git add failed: #{stderr[0..200]}")
+      add_result = run_git('add', '-A', chdir: chdir)
+      unless add_result.success?
+        logger&.warn("git add failed: #{add_result.error}")
         return false
       end
 
-      _, stderr, commit_status = Open3.capture3('git', 'commit', '-m', message, chdir: chdir)
-      unless commit_status.success?
-        logger&.warn("git commit failed: #{stderr[0..200]}")
+      commit_result = run_git('commit', '-m', message, chdir: chdir)
+      unless commit_result.success?
+        logger&.warn("git commit failed: #{commit_result.error}")
         return false
       end
 
@@ -42,8 +45,12 @@ module Ocak
     # Checks out the main branch. Intended for cleanup/ensure blocks.
     # Rescues all errors so it never crashes the caller.
     def self.checkout_main(chdir:, logger: nil)
-      _, stderr, status = Open3.capture3('git', 'checkout', 'main', chdir: chdir)
-      logger&.warn("Cleanup checkout to main failed: #{stderr}") unless status.success?
+      result = run_git('checkout', 'main', chdir: chdir)
+      unless result.success?
+        # Use "error" prefix when command not found (status is nil), otherwise "failed"
+        prefix = result.status.nil? ? 'Cleanup checkout to main error:' : 'Cleanup checkout to main failed:'
+        logger&.warn("#{prefix} #{result.error}")
+      end
     rescue StandardError => e
       logger&.warn("Cleanup checkout to main error: #{e.message}")
     end

data/lib/ocak/instance_builders.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Ocak
+  # Factory methods for building logger, claude, merge manager instances, plus setup helpers.
+  # Extracted from PipelineRunner to reduce file size.
+  module InstanceBuilders
+    private
+
+    def build_logger(issue_number: nil)
+      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, registry: @registry)
+    end
+
+    def build_merge_manager(logger:, issues:)
+      if issues.is_a?(LocalIssueFetcher) && !gh_available?
+        LocalMergeManager.new(config: @config, logger: logger, issues: issues)
+      else
+        MergeManager.new(config: @config, claude: build_claude(logger), logger: logger,
+                         issues: issues, watch: @watch_formatter)
+      end
+    end
+
+    def gh_available?
+      _, _, status = Open3.capture3('gh', 'repo', 'view', '--json', 'name', chdir: @config.project_dir)
+      status.success?
+    rescue Errno::ENOENT
+      false
+    end
+
+    def cleanup_stale_worktrees(logger)
+      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
+  end
+end

data/lib/ocak/issue_backend.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'issue_fetcher'
+require_relative 'local_issue_fetcher'
+
+module Ocak
+  module IssueBackend
+    def self.build(config:, logger: nil)
+      case config.issue_backend
+      when 'local'
+        LocalIssueFetcher.new(config: config, logger: logger)
+      when 'github'
+        IssueFetcher.new(config: config, logger: logger)
+      else
+        auto_detect(config: config, logger: logger)
+      end
+    end
+
+    def self.auto_detect(config:, logger: nil)
+      store_dir = File.join(config.project_dir, '.ocak', 'issues')
+      has_local = Dir.exist?(store_dir) && Dir.glob(File.join(store_dir, '*.md')).any?
+
+      if has_local
+        logger&.info('Auto-detected local issue store in .ocak/issues/')
+        LocalIssueFetcher.new(config: config, logger: logger)
+      else
+        IssueFetcher.new(config: config, logger: logger)
+      end
+    end
+  end
+end

data/lib/ocak/local_issue_fetcher.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require 'time'
+require_relative 'issue_fetcher'
+
+module Ocak
+  class LocalIssueFetcher < IssueFetcher
+    COMMENTS_SENTINEL = '<!-- pipeline-comments -->'
+
+    def initialize(config:, logger: nil)
+      super
+      @store_dir = File.join(config.project_dir, '.ocak', 'issues')
+    end
+
+    # --- Issue operations (overrides) ---
+
+    def fetch_ready
+      all_issues.select do |issue|
+        labels = label_names(issue)
+        labels.include?(@config.label_ready) && !labels.include?(@config.label_in_progress)
+      end
+    rescue StandardError => e
+      @logger&.warn("LocalIssueFetcher#fetch_ready failed: #{e.message}")
+      []
+    end
+
+    def view(issue_number, fields: 'number,title,body,labels') # rubocop:disable Lint/UnusedMethodArgument
+      read_issue(issue_number.to_i)
+    rescue StandardError => e
+      @logger&.warn("LocalIssueFetcher#view failed for ##{issue_number}: #{e.message}")
+      nil
+    end
+
+    def add_label(issue_number, label)
+      update_frontmatter(issue_number.to_i) do |fm|
+        fm['labels'] = ((fm['labels'] || []) | [label])
+      end
+    end
+
+    def remove_label(issue_number, label)
+      update_frontmatter(issue_number.to_i) do |fm|
+        fm['labels'] = (fm['labels'] || []) - [label]
+      end
+    end
+
+    def comment(issue_number, body)
+      path = issue_path(issue_number.to_i)
+      return unless path && File.exist?(path)
+
+      content = File.read(path)
+      timestamp = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+      unless content.include?(COMMENTS_SENTINEL)
+        File.write(path, "#{content.chomp}\n\n#{COMMENTS_SENTINEL}\n#{timestamp} — #{body}\n")
+        return
+      end
+
+      File.open(path, 'a') { |f| f.write("#{timestamp} — #{body}\n") }
+    rescue StandardError => e
+      @logger&.warn("LocalIssueFetcher#comment failed for ##{issue_number}: #{e.message}")
+      nil
+    end
+
+    def ensure_label(_label) = nil
+    def ensure_labels(_labels) = nil
+
+    # --- Issue creation (CLI only) ---
+
+    def create(title:, body: '', labels: [], complexity: 'full')
+      FileUtils.mkdir_p(@store_dir)
+      number = next_issue_number
+      fm = {
+        'number' => number,
+        'title' => title,
+        'labels' => labels,
+        'complexity' => complexity,
+        'created_at' => Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+      }
+      File.write(issue_path(number), build_file(fm, body))
+      number
+    end
+
+    # --- Queries ---
+
+    def all_issues
+      return [] unless Dir.exist?(@store_dir)
+
+      Dir.glob(File.join(@store_dir, '*.md'))
+         .filter_map { |f| parse_issue_file(f) }
+    end
+
+    private
+
+    def read_issue(issue_number)
+      path = issue_path(issue_number)
+      return nil unless File.exist?(path)
+
+      parse_issue_file(path)
+    end
+
+    def parse_issue_file(path)
+      content = File.read(path)
+      parts = content.split(/^---\s*$/, 3)
+      return nil unless parts.size >= 3
+
+      fm = YAML.safe_load(parts[1]) || {}
+      raw_body = parts[2]
+      body = raw_body.split(COMMENTS_SENTINEL, 2).first.to_s.strip
+
+      {
+        'number' => fm['number'],
+        'title' => fm['title'],
+        'body' => body,
+        'labels' => (fm['labels'] || []).map { |l| { 'name' => l } },
+        'author' => { 'login' => 'local' },
+        'complexity' => fm['complexity'] || 'full'
+      }
+    rescue StandardError => e
+      @logger&.warn("Failed to parse issue file #{path}: #{e.message}")
+      nil
+    end
+
+    def update_frontmatter(issue_number)
+      path = issue_path(issue_number)
+      return unless File.exist?(path)
+
+      content = File.read(path)
+      parts = content.split(/^---\s*$/, 3)
+      return unless parts.size >= 3
+
+      fm = YAML.safe_load(parts[1]) || {}
+      yield fm
+
+      File.write(path, "---\n#{dump_frontmatter(fm)}---\n#{parts[2]}")
+    rescue StandardError => e
+      @logger&.warn("LocalIssueFetcher#update_frontmatter failed for ##{issue_number}: #{e.message}")
+      nil
+    end
+
+    def issue_path(number)
+      File.join(@store_dir, format('%04d.md', number))
+    end
+
+    def next_issue_number
+      existing = Dir.glob(File.join(@store_dir, '*.md'))
+                    .filter_map { |f| File.basename(f, '.md').to_i }
+      existing.empty? ? 1 : existing.max + 1
+    end
+
+    def label_names(issue)
+      (issue['labels'] || []).map { |l| l['name'] }
+    end
+
+    def dump_frontmatter(hash)
+      # YAML.dump prepends "---\n"; we manage our own delimiters
+      YAML.dump(hash).delete_prefix("---\n")
+    end
+
+    def build_file(frontmatter, body)
+      "---\n#{dump_frontmatter(frontmatter)}---\n\n#{body}\n"
+    end
+  end
+end

data/lib/ocak/local_merge_manager.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require_relative 'git_utils'
+
+module Ocak
+  class LocalMergeManager
+    def initialize(config:, logger:, issues:, **_opts)
+      @config = config
+      @logger = logger
+      @issues = issues
+    end
+
+    def merge(issue_number, worktree)
+      @logger.info("Starting local merge for issue ##{issue_number}")
+
+      commit_uncommitted_changes(issue_number, worktree)
+
+      unless rebase_onto_main(worktree)
+        @logger.error("Rebase failed for issue ##{issue_number}")
+        return false
+      end
+
+      unless verify_tests(worktree)
+        @logger.error("Tests failed after rebase for issue ##{issue_number}")
+        return false
+      end
+
+      unless merge_to_main(worktree)
+        @logger.error("Merge to main failed for issue ##{issue_number}")
+        return false
+      end
+
+      delete_branch(worktree.branch)
+      @logger.info("Issue ##{issue_number} merged to main (local)")
+      true
+    end
+
+    def create_pr_only(issue_number, _worktree)
+      @logger.warn("manual_review is not supported in fully local mode for issue ##{issue_number}")
+      nil
+    end
+
+    private
+
+    def commit_uncommitted_changes(issue_number, worktree)
+      GitUtils.commit_changes(
+        chdir: worktree.path,
+        message: "chore: uncommitted pipeline changes for issue ##{issue_number}",
+        logger: @logger
+      )
+    end
+
+    def rebase_onto_main(worktree)
+      _, stderr, status = git('rebase', 'main', chdir: worktree.path)
+      return true if status.success?
+
+      @logger.warn("Rebase failed: #{stderr[0..200]}")
+      git('rebase', '--abort', chdir: worktree.path)
+      false
+    end
+
+    def verify_tests(worktree)
+      test_cmd = @config.test_command
+      return true unless test_cmd
+
+      @logger.info('Running tests after rebase...')
+      _, _, status = Open3.capture3(*Shellwords.shellsplit(test_cmd), chdir: worktree.path)
+
+      if status.success?
+        @logger.info('Tests passed after rebase')
+        true
+      else
+        @logger.warn('Tests failed after rebase')
+        false
+      end
+    end
+
+    def merge_to_main(worktree)
+      _, stderr, status = git('checkout', 'main', chdir: @config.project_dir)
+      unless status.success?
+        @logger.error("Checkout main failed: #{stderr}")
+        return false
+      end
+
+      _, stderr, status = git('merge', worktree.branch, '--ff-only', chdir: @config.project_dir)
+      return true if status.success?
+
+      @logger.warn("Fast-forward merge failed: #{stderr[0..200]}")
+      false
+    end
+
+    def delete_branch(branch)
+      git('branch', '-d', branch, chdir: @config.project_dir)
+    rescue StandardError => e
+      @logger.warn("Failed to delete branch #{branch}: #{e.message}")
+    end
+
+    def git(*, chdir:)
+      Open3.capture3('git', *, chdir: chdir)
+    end
+  end
+end

data/lib/ocak/merge_manager.rb

@@ -3,9 +3,12 @@
 require 'open3'
 require 'shellwords'
 require_relative 'git_utils'
+require_relative 'command_runner'
 
 module Ocak
   class MergeManager
+    include CommandRunner
+
     def initialize(config:, claude:, logger:, issues:, watch: nil)
       @config = config
       @claude = claude
@@ -77,20 +80,20 @@ module Ocak
                 '_This PR was created in manual review mode. ' \
                 'Review and label `auto-reready` to trigger automated fixes based on your feedback._'
 
-      stdout, stderr, status = Open3.capture3(
-        'gh', 'pr', 'create',
+      result = run_gh(
+        'pr', 'create',
         '--title', pr_title,
         '--body', pr_body,
         '--head', worktree.branch,
         chdir: worktree.path
       )
 
-      unless status.success?
-        @logger.error("PR creation failed: #{stderr}")
+      unless result.success?
+        @logger.error("PR creation failed: #{result.error}")
         return nil
       end
 
-      extract_pr_number(stdout)
+      extract_pr_number(result.stdout)
     end
 
     def fetch_issue_title(issue_number)
@@ -112,39 +115,39 @@ module Ocak
     end
 
     def rebase_onto_main(worktree)
-      _, fetch_stderr, fetch_status = git('fetch', 'origin', 'main', chdir: worktree.path)
-      unless fetch_status.success?
-        @logger.error("git fetch origin main failed: #{fetch_stderr[0..200]}")
+      fetch_result = run_git('fetch', 'origin', 'main', chdir: worktree.path)
+      unless fetch_result.success?
+        @logger.error("git fetch origin main failed: #{fetch_result.error}")
         return false
       end
 
-      _, stderr, status = git('rebase', 'origin/main', chdir: worktree.path)
+      rebase_result = run_git('rebase', 'origin/main', chdir: worktree.path)
 
-      return true if status.success?
+      return true if rebase_result.success?
 
-      @logger.warn("Rebase conflict, aborting rebase: #{stderr}")
-      _, abort_stderr, abort_status = git('rebase', '--abort', chdir: worktree.path)
-      @logger.warn("git rebase --abort failed: #{abort_stderr}") unless abort_status.success?
+      @logger.warn("Rebase conflict, aborting rebase: #{rebase_result.error}")
+      abort_result = run_git('rebase', '--abort', chdir: worktree.path)
+      @logger.warn("git rebase --abort failed: #{abort_result.error}") unless abort_result.success?
 
       # Fall back to merge strategy
       @logger.info('Attempting merge strategy instead...')
-      _, merge_stderr, merge_status = git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
+      merge_result = run_git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
 
-      return true if merge_status.success?
+      return true if merge_result.success?
 
       # Merge also has conflicts — try to resolve via agent
-      @logger.warn("Merge conflict, attempting agent resolution: #{merge_stderr}")
+      @logger.warn("Merge conflict, attempting agent resolution: #{merge_result.error}")
       resolve_conflicts_via_agent(worktree)
     end
 
     def resolve_conflicts_via_agent(worktree)
       # Get list of conflicting files
-      stdout, = git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
-      conflicting = stdout.lines.map(&:strip).reject(&:empty?)
+      diff_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
+      conflicting = diff_result.stdout.lines.map(&:strip).reject(&:empty?)
 
       if conflicting.empty?
         @logger.warn('No conflicting files found, aborting merge')
-        git('merge', '--abort', chdir: worktree.path)
+        run_git('merge', '--abort', chdir: worktree.path)
         return false
       end
 
@@ -158,11 +161,11 @@ module Ocak
 
       if result.success?
         # Check if all conflicts resolved
-        remaining, = git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
-        if remaining.strip.empty?
-          _, commit_stderr, commit_status = git('commit', '--no-edit', chdir: worktree.path)
-          unless commit_status.success?
-            @logger.error("Commit after conflict resolution failed: #{commit_stderr}")
+        remaining_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
+        if remaining_result.output.empty?
+          commit_result = run_git('commit', '--no-edit', chdir: worktree.path)
+          unless commit_result.success?
+            @logger.error("Commit after conflict resolution failed: #{commit_result.error}")
             return false
           end
           @logger.info('Merge conflicts resolved by agent')
@@ -171,7 +174,7 @@ module Ocak
       end
 
       @logger.error('Agent could not resolve merge conflicts')
-      git('merge', '--abort', chdir: worktree.path)
+      run_git('merge', '--abort', chdir: worktree.path)
       false
     end
 
@@ -193,20 +196,16 @@ module Ocak
     end
 
     def push_branch(worktree)
-      _, stderr, status = git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
+      result = run_git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
 
-      unless status.success?
-        @logger.error("Push failed: #{stderr}")
+      unless result.success?
+        @logger.error("Push failed: #{result.error}")
         return false
       end
 
       true
     end
 
-    def git(*, chdir:)
-      Open3.capture3('git', *, chdir: chdir)
-    end
-
     def shell(cmd, chdir:)
       Open3.capture3(*Shellwords.shellsplit(cmd), chdir: chdir)
     end

data/lib/ocak/merge_orchestration.rb

@@ -28,8 +28,10 @@ module Ocak
       elsif @config.manual_review
         handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues)
       else
-        claude.run_agent('merger', "Create a PR, merge it, and close issue ##{issue_number}",
-                         chdir: @config.project_dir)
+        unless pipeline_has_merge_step?
+          claude.run_agent('merger', "Create a PR, merge it, and close issue ##{issue_number}",
+                           chdir: @config.project_dir)
+        end
         issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_completed)
         logger.info("Issue ##{issue_number} completed successfully")
       end
@@ -88,6 +90,10 @@ module Ocak
       logger.info("Posted audit comment on PR ##{pr_number}")
     end
 
+    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:)
       stdout, _, status = Open3.capture3('gh', 'pr', 'view', '--json', 'number', chdir: @config.project_dir)
       return nil unless status.success?

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