ocak 0.4.0 → 0.6.0

data/lib/ocak/commands/init.rb

@@ -35,6 +35,7 @@ module Ocak
         )
 
         generate_files(generator, project_dir, options)
+        scaffold_user_config
         update_settings(project_dir, stack)
         update_gitignore(project_dir)
         create_labels(project_dir)
@@ -83,6 +84,36 @@ module Ocak
         puts ''
       end
 
+      def scaffold_user_config
+        path = Config.user_config_path
+        if File.exist?(path)
+          puts "  #{path} already exists — skipping"
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, user_config_template)
+        puts "  Created #{path}"
+      end
+
+      def user_config_template
+        <<~YAML
+          # ~/.config/ocak/config.yml
+          # Machine-specific Ocak settings (not committed to any repo)
+
+          # Map repo names to local paths (used with multi_repo: true in project ocak.yml)
+          # repos:
+          #   my-gem: ~/dev/my-gem
+          #   other-gem: ~/dev/other-gem
+
+          # Pipeline tuning for this machine
+          # pipeline:
+          #   max_parallel: 3      # default: 5
+          #   poll_interval: 60    # seconds between polls, default: 60
+          #   cost_budget: 10.00   # max $ per pipeline run
+        YAML
+      end
+
       def update_settings(project_dir, stack)
         settings_path = File.join(project_dir, '.claude', 'settings.json')
         existing = begin
@@ -183,6 +214,11 @@ module Ocak
 
       def create_labels(project_dir)
         config = Config.load(project_dir)
+        if config.local_issues?
+          puts '  Skipped label creation (local issue backend)'
+          return
+        end
+
         fetcher = IssueFetcher.new(config: config)
         fetcher.ensure_labels(config.all_labels)
         puts '  Created GitHub labels'
@@ -201,6 +237,7 @@ module Ocak
         end
         puts '  .claude/hooks/                     — lint + test hooks'
         puts '  .claude/settings.json              — permissions & hooks config'
+        puts "  #{Config.user_config_path}  — machine-specific settings (not committed)"
         puts ''
         puts 'Next steps:'
         puts '  1. Review ocak.yml and adjust settings'

data/lib/ocak/commands/issue/close.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class Close < Dry::CLI::Command
+        desc 'Close a local issue (sets completed label)'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          issue_number = issue.to_i
+
+          data = fetcher.view(issue_number)
+          unless data
+            warn "Issue ##{issue} not found."
+            exit 1
+          end
+
+          fetcher.remove_label(issue_number, config.label_ready)
+          fetcher.remove_label(issue_number, config.label_in_progress)
+          fetcher.add_label(issue_number, config.label_completed)
+
+          puts "Closed issue ##{issue_number}: #{data['title']}"
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/create.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class Create < Dry::CLI::Command
+        desc 'Create a local issue'
+
+        argument :title, type: :string, required: true, desc: 'Issue title'
+        option :body, type: :string, default: '', desc: 'Issue body (opens $EDITOR if omitted)'
+        option :label, type: :array, default: [], desc: 'Labels to add (repeatable)'
+        option :complexity, type: :string, default: 'full', desc: 'Issue complexity (full or simple)'
+
+        def call(title:, **options)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+
+          body = options[:body]
+          body = read_from_editor(title) if body.empty?
+
+          number = fetcher.create(
+            title: title,
+            body: body,
+            labels: options[:label],
+            complexity: options[:complexity]
+          )
+
+          path = File.join('.ocak', 'issues', format('%04d.md', number))
+          puts "Created issue ##{number} (#{path})"
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def read_from_editor(title)
+          editor = ENV.fetch('EDITOR', 'vi')
+          require 'tempfile'
+          file = Tempfile.new(['ocak-issue', '.md'])
+          file.write("#{title}\n\n")
+          file.close
+
+          system(editor, file.path)
+          content = File.read(file.path)
+          # Strip the title line if it's still there
+          lines = content.lines
+          lines.shift if lines.first&.strip == title
+          lines.join.strip
+        ensure
+          file&.unlink
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/edit.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+
+module Ocak
+  module Commands
+    module Issue
+      class Edit < Dry::CLI::Command
+        desc 'Edit a local issue in $EDITOR'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          path = File.join(config.project_dir, '.ocak', 'issues', format('%04d.md', issue.to_i))
+
+          unless File.exist?(path)
+            warn "Issue ##{issue} not found at #{path}"
+            exit 1
+          end
+
+          editor = ENV.fetch('EDITOR', 'vi')
+          system(editor, path)
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/list.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class List < Dry::CLI::Command
+        desc 'List local issues'
+
+        option :label, type: :string, desc: 'Filter by label'
+
+        def call(**options)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          issues = fetcher.all_issues
+
+          if options[:label]
+            issues = issues.select do |i|
+              i['labels']&.any? { |l| l['name'] == options[:label] }
+            end
+          end
+
+          if issues.empty?
+            puts 'No issues found.'
+            return
+          end
+
+          issues.sort_by { |i| i['number'] }.each do |issue|
+            labels = (issue['labels'] || []).map { |l| l['name'] }.join(', ')
+            label_str = labels.empty? ? '' : "  [#{labels}]"
+            puts format('#%-4<num>d %<title>s%<labels>s',
+                        num: issue['number'], title: issue['title'], labels: label_str)
+          end
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/view.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class View < Dry::CLI::Command
+        desc 'View a local issue'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          data = fetcher.view(issue.to_i)
+
+          unless data
+            warn "Issue ##{issue} not found."
+            exit 1
+          end
+
+          labels = (data['labels'] || []).map { |l| l['name'] }.join(', ')
+          puts "##{data['number']}  #{data['title']}"
+          puts "Labels: #{labels}" unless labels.empty?
+          puts "Complexity: #{data['complexity']}" if data['complexity'] && data['complexity'] != 'full'
+          puts ''
+          puts data['body'] unless data['body'].to_s.empty?
+
+          # Show pipeline comments from the raw file
+          path = File.join('.ocak', 'issues', format('%04d.md', issue.to_i))
+          show_pipeline_comments(path)
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def show_pipeline_comments(path)
+          return unless File.exist?(path)
+
+          content = File.read(path)
+          sentinel = LocalIssueFetcher::COMMENTS_SENTINEL
+          return unless content.include?(sentinel)
+
+          comments = content.split(sentinel, 2).last.to_s.strip
+          return if comments.empty?
+
+          puts ''
+          puts '--- Pipeline Activity ---'
+          puts comments
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/resume.rb

@@ -3,10 +3,11 @@
 require_relative '../config'
 require_relative '../failure_reporting'
 require_relative '../git_utils'
+require_relative '../issue_state_machine'
 require_relative '../pipeline_runner'
 require_relative '../pipeline_state'
 require_relative '../claude_runner'
-require_relative '../issue_fetcher'
+require_relative '../issue_backend'
 require_relative '../worktree_manager'
 require_relative '../merge_manager'
 require_relative '../logger'
@@ -78,9 +79,10 @@ module Ocak
         logger = PipelineLogger.new(log_dir: log_dir, issue_number: issue_number)
         watch_formatter = options[:watch] ? WatchFormatter.new : nil
         claude = ClaudeRunner.new(config: config, logger: logger, watch: watch_formatter)
-        issues = IssueFetcher.new(config: config, logger: logger)
+        issues = IssueBackend.build(config: config, logger: logger)
+        state_machine = IssueStateMachine.new(config: config, issues: issues)
 
-        issues.transition(issue_number, from: config.label_failed, to: config.label_in_progress)
+        state_machine.mark_resuming(issue_number)
 
         runner = PipelineRunner.new(config: config, options: { watch: options[:watch] })
         result = runner.run_pipeline(issue_number,
@@ -88,7 +90,8 @@ module Ocak
                                      skip_steps: saved[:completed_steps])
 
         ctx = { config: config, issue_number: issue_number, saved: saved, chdir: chdir,
-                issues: issues, claude: claude, logger: logger, watch: watch_formatter }
+                issues: issues, state_machine: state_machine, claude: claude, logger: logger,
+                watch: watch_formatter }
         handle_result(result, ctx)
       end
 
@@ -96,7 +99,8 @@ module Ocak
         if result[:success]
           attempt_merge(ctx)
         else
-          report_pipeline_failure(ctx[:issue_number], result, issues: ctx[:issues], config: ctx[:config])
+          report_pipeline_failure(ctx[:issue_number], result, issues: ctx[:issues], config: ctx[:config],
+                                                              logger: ctx[:logger])
           warn "Issue ##{ctx[:issue_number]} failed again at phase: #{result[:phase]}"
         end
       end
@@ -109,12 +113,10 @@ module Ocak
         )
 
         if merger.merge(ctx[:issue_number], worktree)
-          ctx[:issues].transition(ctx[:issue_number], from: ctx[:config].label_in_progress,
-                                                      to: ctx[:config].label_completed)
+          ctx[:state_machine].mark_completed(ctx[:issue_number])
           puts "Issue ##{ctx[:issue_number]} resumed and merged successfully!"
         else
-          ctx[:issues].transition(ctx[:issue_number], from: ctx[:config].label_in_progress,
-                                                      to: ctx[:config].label_failed)
+          ctx[:state_machine].mark_failed(ctx[:issue_number])
           warn "Issue ##{ctx[:issue_number]} merge failed after resume"
         end
       end

data/lib/ocak/commands/status.rb

@@ -3,12 +3,16 @@
 require 'open3'
 require 'json'
 require_relative '../config'
+require_relative '../command_runner'
+require_relative '../issue_backend'
 require_relative '../run_report'
 require_relative '../worktree_manager'
 
 module Ocak
   module Commands
     class Status < Dry::CLI::Command
+      include CommandRunner
+
       desc 'Show pipeline status'
 
       option :report, type: :boolean, default: false, desc: 'Show run reports'
@@ -42,7 +46,26 @@ module Ocak
 
       def show_issues(config)
         puts 'Issues:'
+        fetcher = IssueBackend.build(config: config)
 
+        if fetcher.is_a?(LocalIssueFetcher)
+          show_local_issues(fetcher, config)
+        else
+          show_github_issues(config)
+        end
+      end
+
+      def show_local_issues(fetcher, config)
+        all = fetcher.all_issues
+        %w[ready in_progress completed failed].each do |state|
+          label = config.send(:"label_#{state}")
+          count = all.count { |i| i['labels']&.any? { |l| l['name'] == label } }
+          icon = { 'ready' => '  ', 'in_progress' => '  ', 'completed' => '  ', 'failed' => '  ' }[state]
+          puts "  #{icon} #{state.tr('_', ' ')}: #{count} (label: #{label})"
+        end
+      end
+
+      def show_github_issues(config)
         %w[ready in_progress completed failed].each do |state|
           label = config.send(:"label_#{state}")
           count = fetch_issue_count(label, config)
@@ -187,18 +210,12 @@ module Ocak
       end
 
       def fetch_issue_count(label, config)
-        stdout, _, status = Open3.capture3(
-          'gh', 'issue', 'list',
-          '--label', label,
-          '--state', 'open',
-          '--json', 'number',
-          '--limit', '100',
-          chdir: config.project_dir
-        )
-        return 0 unless status.success?
-
-        JSON.parse(stdout).size
-      rescue JSON::ParserError, Errno::ENOENT
+        result = run_gh('issue', 'list', '--label', label, '--state', 'open',
+                        '--json', 'number', '--limit', '100', chdir: config.project_dir)
+        return 0 unless result.success?
+
+        JSON.parse(result.stdout).size
+      rescue JSON::ParserError
         0
       end
 

data/lib/ocak/config.rb

@@ -5,14 +5,28 @@ require 'yaml'
 module Ocak
   class Config
     CONFIG_FILE = 'ocak.yml'
+    USER_CONFIG_DIR = 'ocak'
+    USER_CONFIG_FILE = 'config.yml'
 
     attr_reader :project_dir
 
+    def self.user_config_path
+      base = ENV.fetch('XDG_CONFIG_HOME', File.expand_path('~/.config'))
+      File.join(base, USER_CONFIG_DIR, USER_CONFIG_FILE)
+    end
+
     def self.load(dir = Dir.pwd)
       path = File.join(dir, CONFIG_FILE)
       raise ConfigNotFound, "No ocak.yml found in #{dir}. Run `ocak init` first." unless File.exist?(path)
 
-      new(YAML.safe_load_file(path, symbolize_names: true), dir)
+      project_data = YAML.safe_load_file(path, symbolize_names: true) || {}
+      user_data = load_user_config
+
+      merged = deep_merge(user_data, project_data)
+      # repos: is user-only — always take from user config, never project
+      merged[:repos] = user_data[:repos] if user_data[:repos]
+
+      new(merged, dir)
     end
 
     def initialize(data, project_dir = Dir.pwd)
@@ -51,6 +65,10 @@ module Ocak
       dig(:stack, :security_commands) || []
     end
 
+    def custom_commands?
+      !!(test_command || lint_command || format_command || setup_command || security_commands.any?)
+    end
+
     # Pipeline
     def max_parallel  = @overrides[:max_parallel] || dig(:pipeline, :max_parallel) || 5
     def poll_interval = @overrides[:poll_interval] || dig(:pipeline, :poll_interval) || 60
@@ -72,6 +90,37 @@ module Ocak
     def require_comment    = dig(:safety, :require_comment)
     def max_issues_per_run = dig(:safety, :max_issues_per_run) || 5
 
+    # Multi-repo
+    def repos
+      @data[:repos]
+    end
+
+    def multi_repo?
+      r = repos
+      r.is_a?(Hash) && !r.empty?
+    end
+
+    def target_field
+      dig(:target_field) || 'target_repo'
+    end
+
+    def resolve_repo(name)
+      raise ConfigError, 'No repos configured in ocak.yml' unless multi_repo?
+
+      key = name.to_sym
+      path_value = repos[key]
+      raise ConfigError, "Unknown repo '#{name}'. Known repos: #{repos.keys.join(', ')}" unless path_value
+
+      expanded = File.expand_path(path_value.to_s)
+      raise ConfigError, "Repo path does not exist: #{expanded}" unless Dir.exist?(expanded)
+
+      { name: name.to_s, path: expanded }
+    end
+
+    # Issues
+    def issue_backend = dig(:issues, :backend)
+    def local_issues? = issue_backend == 'local'
+
     # Labels
     def label_ready = dig(:labels, :ready) || 'auto-ready'
     def label_in_progress = dig(:labels, :in_progress) || 'auto-doing'
@@ -132,5 +181,27 @@ module Ocak
 
     class ConfigNotFound < StandardError; end
     class ConfigError < StandardError; end
+
+    private_class_method def self.load_user_config
+      path = user_config_path
+      return {} unless File.exist?(path)
+
+      data = YAML.safe_load_file(path, symbolize_names: true)
+      raise ConfigError, "#{path} must be a YAML hash" unless data.is_a?(Hash) || data.nil?
+
+      data || {}
+    rescue Psych::SyntaxError => e
+      raise ConfigError, "Invalid YAML in #{path}: #{e.message}"
+    end
+
+    private_class_method def self.deep_merge(base, override)
+      base.merge(override) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
   end
 end

data/lib/ocak/conflict_resolution.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ocak
+  # Rebase and conflict resolution logic — rebase_onto_main, resolve_conflicts_via_agent.
+  # Extracted from MergeManager to reduce file size.
+  module ConflictResolution
+    private
+
+    def rebase_onto_main(worktree)
+      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
+
+      rebase_result = run_git('rebase', 'origin/main', chdir: worktree.path)
+
+      return true if rebase_result.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_result = run_git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
+
+      return true if merge_result.success?
+
+      # Merge also has conflicts — try to resolve via agent
+      @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
+      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')
+        run_git('merge', '--abort', chdir: worktree.path)
+        return false
+      end
+
+      result = @claude.run_agent(
+        'implementer',
+        "Resolve these merge conflicts.\n\n<conflicting_files>\n#{conflicting.join("\n")}\n</conflicting_files>\n\n" \
+        'Open each file, find conflict markers (<<<<<<< ======= >>>>>>>), and resolve them. ' \
+        'Then run `git add` on each resolved file.',
+        chdir: worktree.path
+      )
+
+      if result.success?
+        # Check if all conflicts resolved
+        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')
+          return true
+        end
+      end
+
+      @logger.error('Agent could not resolve merge conflicts')
+      run_git('merge', '--abort', chdir: worktree.path)
+      false
+    end
+  end
+end

data/lib/ocak/failure_reporting.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
+require_relative 'issue_state_machine'
+
 module Ocak
   # Shared pipeline failure reporting — label transition + comment posting.
   # Included by PipelineRunner and Commands::Resume.
   module FailureReporting
-    def report_pipeline_failure(issue_number, result, issues:, config:)
-      issues.transition(issue_number, from: config.label_in_progress, to: config.label_failed)
+    def report_pipeline_failure(issue_number, result, issues:, config:, logger: nil)
+      IssueStateMachine.new(config: config, issues: issues).mark_failed(issue_number)
       sanitized = result[:output][0..1000].to_s.gsub('```', "'''")
       issues.comment(issue_number,
                      "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{sanitized}\n```")
-    rescue StandardError
+    rescue StandardError => e
+      logger&.debug("Failure report failed: #{e.message}")
       nil
     end
   end