ocak 0.1.0

data/lib/ocak/config.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Ocak
+  class Config
+    CONFIG_FILE = 'ocak.yml'
+
+    attr_reader :project_dir
+
+    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)
+    end
+
+    def initialize(data, project_dir = Dir.pwd)
+      @data = data || {}
+      @project_dir = project_dir
+      @overrides = {}
+      validate!
+    end
+
+    def override(key, value)
+      @overrides[key] = value
+    end
+
+    # Stack
+    def language      = dig(:stack, :language) || 'unknown'
+    def framework     = dig(:stack, :framework)
+    def test_command   = dig(:stack, :test_command)
+    def lint_command   = dig(:stack, :lint_command)
+    def format_command = dig(:stack, :format_command)
+    def setup_command  = dig(:stack, :setup_command)
+
+    # Returns the lint command with auto-fix flags stripped, suitable for check-only verification.
+    def lint_check_command
+      cmd = lint_command
+      return nil unless cmd
+
+      cmd.gsub(/\s+(?:-A|--fix|--write|--allow-dirty)\b/, '').strip
+    end
+
+    def security_commands
+      dig(:stack, :security_commands) || []
+    end
+
+    # Pipeline
+    def max_parallel  = @overrides[:max_parallel] || dig(:pipeline, :max_parallel) || 3
+    def poll_interval = @overrides[:poll_interval] || dig(:pipeline, :poll_interval) || 60
+    def worktree_dir  = dig(:pipeline, :worktree_dir) || '.claude/worktrees'
+    def log_dir       = dig(:pipeline, :log_dir) || 'logs/pipeline'
+    def cost_budget   = dig(:pipeline, :cost_budget)
+
+    # Safety
+    def allowed_authors    = dig(:safety, :allowed_authors) || []
+    def require_comment    = dig(:safety, :require_comment)
+    def max_issues_per_run = dig(:safety, :max_issues_per_run) || 5
+
+    # Labels
+    def label_ready = dig(:labels, :ready) || 'auto-ready'
+    def label_in_progress = dig(:labels, :in_progress) || 'in-progress'
+    def label_completed  = dig(:labels, :completed) || 'completed'
+    def label_failed     = dig(:labels, :failed) || 'pipeline-failed'
+
+    # Steps
+    def steps
+      @data[:steps] || default_steps
+    end
+
+    # Agent paths
+    def agent_path(name)
+      custom = dig(:agents, name.to_sym)
+      return File.join(@project_dir, custom) if custom
+
+      File.join(@project_dir, '.claude', 'agents', "#{name.to_s.tr('_', '-')}.md")
+    end
+
+    private
+
+    def dig(*keys)
+      keys.reduce(@data) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+    end
+
+    def validate!
+      return if @data.is_a?(Hash)
+
+      raise ConfigError, 'ocak.yml must be a YAML hash'
+    end
+
+    def default_steps
+      [
+        { agent: 'implementer', role: 'implement' },
+        { agent: 'reviewer', role: 'review' },
+        { agent: 'implementer', role: 'fix', condition: 'has_findings' },
+        { agent: 'reviewer', role: 'verify', condition: 'had_fixes' },
+        { agent: 'security_reviewer', role: 'security' },
+        { agent: 'implementer', role: 'fix', condition: 'has_findings', complexity: 'full' },
+        { agent: 'documenter', role: 'document', complexity: 'full' },
+        { agent: 'auditor', role: 'audit', complexity: 'full' },
+        { agent: 'merger', role: 'merge' }
+      ]
+    end
+
+    class ConfigNotFound < StandardError; end
+    class ConfigError < StandardError; end
+  end
+end

data/lib/ocak/issue_fetcher.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module Ocak
+  class IssueFetcher
+    def initialize(config:, logger: nil)
+      @config = config
+      @logger = logger
+    end
+
+    def fetch_ready
+      stdout, _, status = Open3.capture3(
+        'gh', 'issue', 'list',
+        '--label', @config.label_ready,
+        '--state', 'open',
+        '--json', 'number,title,body,labels,author',
+        '--limit', '50',
+        chdir: @config.project_dir
+      )
+      return [] unless status.success?
+
+      issues = JSON.parse(stdout)
+      issues.reject! { |i| in_progress?(i) }
+      issues.select! { |i| authorized_issue?(i) }
+      issues
+    rescue JSON::ParserError
+      []
+    end
+
+    def add_label(issue_number, label)
+      run_gh('issue', 'edit', issue_number.to_s, '--add-label', label)
+    end
+
+    def remove_label(issue_number, label)
+      run_gh('issue', 'edit', issue_number.to_s, '--remove-label', label)
+    end
+
+    def transition(issue_number, from:, to:)
+      remove_label(issue_number, from) if from
+      add_label(issue_number, to)
+    end
+
+    def comment(issue_number, body)
+      run_gh('issue', 'comment', issue_number.to_s, '--body', body)
+    end
+
+    def view(issue_number, fields: 'number,title,body,labels')
+      stdout, _, status = Open3.capture3(
+        'gh', 'issue', 'view', issue_number.to_s,
+        '--json', fields,
+        chdir: @config.project_dir
+      )
+      return nil unless status.success?
+
+      JSON.parse(stdout)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private
+
+    def in_progress?(issue)
+      issue['labels']&.any? { |l| l['name'] == @config.label_in_progress }
+    end
+
+    def authorized_issue?(issue)
+      authors = allowed_authors
+      author_login = issue.dig('author', 'login')
+
+      return true if authors.empty? && @config.allowed_authors.any?
+
+      if authors.any? && authors.include?(author_login)
+        check_comment_requirement(issue)
+      elsif authors.empty?
+        # Default: current user only
+        if author_login == current_user
+          check_comment_requirement(issue)
+        else
+          @logger&.warn("Skipping issue ##{issue['number']}: author '#{author_login}' not in allowed list")
+          false
+        end
+      else
+        @logger&.warn("Skipping issue ##{issue['number']}: author '#{author_login}' not in allowed list")
+        false
+      end
+    end
+
+    def check_comment_requirement(issue)
+      phrase = @config.require_comment
+      return true unless phrase
+
+      # Check if an allowed author commented the required phrase
+      comments = fetch_comments(issue['number'])
+      authors = allowed_authors.empty? ? [current_user] : allowed_authors
+
+      has_approval = comments.any? do |c|
+        authors.include?(c.dig('author', 'login')) && c['body']&.strip == phrase
+      end
+
+      unless has_approval
+        @logger&.warn("Skipping issue ##{issue['number']}: missing required '#{phrase}' comment from allowed author")
+      end
+
+      has_approval
+    end
+
+    def fetch_comments(issue_number)
+      stdout, _, status = Open3.capture3(
+        'gh', 'issue', 'view', issue_number.to_s,
+        '--json', 'comments',
+        chdir: @config.project_dir
+      )
+      return [] unless status.success?
+
+      JSON.parse(stdout).fetch('comments', [])
+    rescue JSON::ParserError
+      []
+    end
+
+    def allowed_authors
+      @config.allowed_authors
+    end
+
+    def current_user
+      @current_user ||= begin
+        stdout, _, status = Open3.capture3('gh', 'api', 'user', '--jq', '.login')
+        status.success? ? stdout.strip : nil
+      end
+    end
+
+    def run_gh(*)
+      Open3.capture3('gh', *, chdir: @config.project_dir)
+    end
+  end
+end

data/lib/ocak/logger.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'fileutils'
+
+module Ocak
+  class PipelineLogger
+    COLORS = {
+      reset: "\e[0m",
+      bold: "\e[1m",
+      dim: "\e[2m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      magenta: "\e[35m",
+      cyan: "\e[36m",
+      white: "\e[37m"
+    }.freeze
+
+    AGENT_COLORS = {
+      'implementer' => :cyan,
+      'reviewer' => :magenta,
+      'security-reviewer' => :red,
+      'auditor' => :yellow,
+      'documenter' => :blue,
+      'merger' => :green,
+      'planner' => :white,
+      'pipeline' => :cyan
+    }.freeze
+
+    def initialize(log_dir: nil, issue_number: nil, color: $stderr.tty?)
+      @color = color
+      @mutex = Mutex.new
+      @file_logger = setup_file_logger(log_dir, issue_number) if log_dir
+    end
+
+    def info(msg, agent: nil)
+      log(:info, msg, agent: agent)
+    end
+
+    def warn(msg, agent: nil)
+      log(:warn, msg, agent: agent, color: :yellow)
+    end
+
+    def error(msg, agent: nil)
+      log(:error, msg, agent: agent, color: :red)
+    end
+
+    def debug(msg, agent: nil) # rubocop:disable Lint/UnusedMethodArgument
+      @file_logger&.debug(msg)
+    end
+
+    attr_reader :log_file_path
+
+    private
+
+    def log(level, msg, agent: nil, color: nil)
+      ts = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+      plain = "[#{ts}] #{level.to_s.upcase}: #{msg}"
+
+      @file_logger&.send(level, msg)
+
+      @mutex.synchronize do
+        output = @color ? colorize(ts, level, msg, agent: agent, color: color) : plain
+        $stderr.write("#{output}\n")
+      end
+    end
+
+    def colorize(timestamp, level, msg, agent: nil, color: nil)
+      parts = [c(:dim), timestamp, c(:reset), ' ']
+
+      if agent
+        agent_color = AGENT_COLORS.fetch(agent, :white)
+        parts.push c(agent_color), c(:bold), "[#{agent}]", c(:reset), ' '
+      end
+
+      msg_color = color || level_color(level)
+      parts.push c(msg_color), msg, c(:reset)
+      parts.join
+    end
+
+    def level_color(level)
+      case level
+      when :error then :red
+      when :warn  then :yellow
+      when :info  then :white
+      else :dim
+      end
+    end
+
+    def c(name)
+      @color ? COLORS.fetch(name, '') : ''
+    end
+
+    def setup_file_logger(log_dir, issue_number)
+      FileUtils.mkdir_p(log_dir)
+      timestamp = Time.now.strftime('%Y%m%d-%H%M%S')
+      suffix = issue_number ? "issue-#{issue_number}" : 'pipeline'
+      @log_file_path = File.join(log_dir, "#{timestamp}-#{suffix}.log")
+
+      logger = ::Logger.new(@log_file_path)
+      logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+      end
+      logger
+    end
+  end
+
+  # Colorized real-time terminal output for --watch mode.
+  class WatchFormatter
+    def initialize(io = $stderr)
+      @io = io
+      @tty = io.respond_to?(:tty?) && io.tty?
+      @mutex = Mutex.new
+    end
+
+    def emit(agent_name, event)
+      return unless event
+
+      line = format_event(agent_name, event)
+      return unless line
+
+      @mutex.synchronize { @io.puts line }
+    end
+
+    private
+
+    def format_event(agent_name, event)
+      ts = Time.now.strftime('%H:%M:%S')
+      agent_color = PipelineLogger::AGENT_COLORS.fetch(agent_name, :white)
+      prefix = "#{c(:dim)}#{ts}#{c(:reset)} #{c(agent_color)}#{c(:bold)}[#{agent_name}]#{c(:reset)}"
+
+      case event[:category]
+      when :init       then "#{prefix} #{c(:dim)}Session started (model: #{event[:model]})#{c(:reset)}"
+      when :tool_call  then format_tool_call(prefix, event)
+      when :tool_result then format_tool_result(prefix, event)
+      when :text       then format_text(prefix, event)
+      when :result     then format_result(prefix, event)
+      end
+    end
+
+    def format_tool_call(prefix, event)
+      case event[:tool]
+      when 'Edit', 'Write'
+        "#{prefix} #{c(:yellow)}[EDIT]#{c(:reset)} #{event[:detail]}"
+      when 'Bash'
+        "#{prefix} #{c(:blue)}[BASH]#{c(:reset)} #{c(:dim)}#{event[:detail]}#{c(:reset)}"
+      when 'Read'
+        "#{prefix} #{c(:dim)}[READ] #{event[:detail]}#{c(:reset)}"
+      when 'Glob', 'Grep'
+        "#{prefix} #{c(:dim)}[#{event[:tool].upcase}] #{event[:detail]}#{c(:reset)}"
+      else
+        "#{prefix} #{c(:dim)}[#{event[:tool]}]#{c(:reset)}"
+      end
+    end
+
+    def format_tool_result(prefix, event)
+      return nil unless event[:is_test_result]
+
+      color = event[:passed] ? :green : :red
+      status = event[:passed] ? 'PASS' : 'FAIL'
+      "#{prefix} #{c(color)}#{c(:bold)}[TEST #{status}]#{c(:reset)} #{c(:dim)}#{event[:command]}#{c(:reset)}"
+    end
+
+    def format_text(prefix, event)
+      return nil unless event[:has_findings]
+
+      if event[:has_red]
+        "#{prefix} #{c(:red)}#{c(:bold)}[REVIEW] BLOCKING#{c(:reset)}"
+      elsif event[:has_yellow]
+        "#{prefix} #{c(:yellow)}[REVIEW] WARNING#{c(:reset)}"
+      else
+        "#{prefix} #{c(:green)}[REVIEW] PASS#{c(:reset)}"
+      end
+    end
+
+    def format_result(prefix, event)
+      cost = event[:cost_usd] ? format('$%.4f', event[:cost_usd]) : 'n/a'
+      dur = event[:duration_ms] ? "#{(event[:duration_ms] / 1000.0).round(1)}s" : 'n/a'
+      turns = event[:num_turns] ? "#{event[:num_turns]} turns" : ''
+      color = event[:subtype] == 'success' ? :green : :red
+      done = "#{c(color)}#{c(:bold)}[DONE]#{c(:reset)}"
+      detail = "#{c(:dim)}#{event[:subtype]} #{cost} #{dur} #{turns}#{c(:reset)}"
+      "#{prefix} #{done} #{detail}"
+    end
+
+    def c(name)
+      @tty ? PipelineLogger::COLORS.fetch(name, '') : ''
+    end
+  end
+end

data/lib/ocak/merge_manager.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+module Ocak
+  class MergeManager
+    def initialize(config:, claude:, logger:, watch: nil)
+      @config = config
+      @claude = claude
+      @logger = logger
+      @watch = watch
+    end
+
+    # Rebase, test, push, then let the merger agent create PR + merge + close issue.
+    def merge(issue_number, worktree)
+      @logger.info("Starting 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 push_branch(worktree)
+        @logger.error("Push failed for issue ##{issue_number}")
+        return false
+      end
+
+      result = @claude.run_agent(
+        'merger',
+        "Create a PR, merge it, and close issue ##{issue_number}. Branch: #{worktree.branch}",
+        chdir: worktree.path
+      )
+
+      if result.success?
+        @logger.info("Issue ##{issue_number} merged successfully")
+        true
+      else
+        @logger.error("Merger agent failed for issue ##{issue_number}")
+        false
+      end
+    end
+
+    private
+
+    def commit_uncommitted_changes(issue_number, worktree)
+      stdout, = git('status', '--porcelain', chdir: worktree.path)
+      return if stdout.strip.empty?
+
+      @logger.info('Found uncommitted changes, committing before merge...')
+      git('add', '-A', chdir: worktree.path)
+      _, stderr, status = git('commit', '-m', "chore: uncommitted pipeline changes for issue ##{issue_number}",
+                              chdir: worktree.path)
+
+      if status.success?
+        @logger.info('Committed uncommitted changes')
+      else
+        @logger.warn("Commit of uncommitted changes failed: #{stderr[0..200]}")
+      end
+    end
+
+    def rebase_onto_main(worktree)
+      git('fetch', 'origin', 'main', chdir: worktree.path)
+      _, stderr, status = git('rebase', 'origin/main', chdir: worktree.path)
+
+      return true if status.success?
+
+      @logger.warn("Rebase conflict, aborting rebase: #{stderr}")
+      git('rebase', '--abort', chdir: worktree.path)
+
+      # Fall back to merge strategy
+      @logger.info('Attempting merge strategy instead...')
+      _, merge_stderr, merge_status = git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
+
+      return true if merge_status.success?
+
+      # Merge also has conflicts — try to resolve via agent
+      @logger.warn("Merge conflict, attempting agent resolution: #{merge_stderr}")
+      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?)
+
+      if conflicting.empty?
+        @logger.warn('No conflicting files found, aborting merge')
+        git('merge', '--abort', chdir: worktree.path)
+        return false
+      end
+
+      result = @claude.run_agent(
+        'implementer',
+        "Resolve these merge conflicts. Conflicting files:\n#{conflicting.join("\n")}\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, = git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
+        if remaining.strip.empty?
+          git('commit', '--no-edit', chdir: worktree.path)
+          @logger.info('Merge conflicts resolved by agent')
+          return true
+        end
+      end
+
+      @logger.error('Agent could not resolve merge conflicts')
+      git('merge', '--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 = shell(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 push_branch(worktree)
+      _, stderr, status = git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
+
+      unless status.success?
+        @logger.error("Push failed: #{stderr}")
+        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
+  end
+end