ocak 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17cdf9a84ce2be155679a0087de97b587ca6746cab5556eebfac6107b501651b
-  data.tar.gz: 972f1ea39c842e6b3719b8a8dfd2af1618f358105c5c9ec1c69e376b1c2ea2f1
+  metadata.gz: f4aa86d60189e50486edaba37ce3a2763d52a28b817818ac5b6466c952087cff
+  data.tar.gz: 4a1d662842ef9f7e88fe5b6deeb30c51f061a6a598f948e1e622bf60e05abc70
 SHA512:
-  metadata.gz: a20c0599a4a31c6eda56617a9cbb34c73b6dbbbcb41fdf712917659288474dc9a4eb795f90b848b9732022060aab79a395cce7673848d0dec112410b849b94f8
-  data.tar.gz: 96bf0277c41027c9335e62628fc4dca32a77c932cf861cfe5205981c74911278308181449793e9568e4f453a8f7d7630b1981b798e7492333a9d1b58fecf7d61
+  metadata.gz: 14787c35edcd0b30fd87b1aaf3e9537e091778a457ab43c33304b037dcbd79efa03d3f1dbdfa5d7d4256431cea8e7067d2c66ea9e5fcbaa43f86cfdef1802105
+  data.tar.gz: 8d0c0b8a7ad9a8ed47d9b2864d9238b6a6705df00d6580db7296d67fab284198001c41ed9cc024edb6288344183ef07059788f536392ba7b7b386baa52106e7e

data/lib/ocak/agent_generator.rb

@@ -150,7 +150,8 @@ module Ocak
     def claude_available?
       _, _, status = Open3.capture3('which', 'claude')
       status.success?
-    rescue Errno::ENOENT
+    rescue Errno::ENOENT => e
+      @logger&.warn("Claude CLI not found: #{e.message}")
       false
     end
 
@@ -164,7 +165,8 @@ module Ocak
         chdir: @project_dir
       )
       status.success? ? stdout : nil
-    rescue Errno::ENOENT
+    rescue Errno::ENOENT => e
+      @logger&.warn("Failed to run Claude prompt: #{e.message}")
       nil
     end
   end

data/lib/ocak/cli.rb

@@ -9,6 +9,7 @@ require_relative 'commands/debt'
 require_relative 'commands/status'
 require_relative 'commands/clean'
 require_relative 'commands/resume'
+require_relative 'commands/hiz'
 
 module Ocak
   module CLI
@@ -23,6 +24,7 @@ module Ocak
       register 'status', Ocak::Commands::Status
       register 'clean',  Ocak::Commands::Clean
       register 'resume', Ocak::Commands::Resume
+      register 'hiz',    Ocak::Commands::Hiz
     end
   end
 end

data/lib/ocak/commands/hiz.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'securerandom'
+require_relative '../config'
+require_relative '../claude_runner'
+require_relative '../issue_fetcher'
+require_relative '../verification'
+require_relative '../logger'
+
+module Ocak
+  module Commands
+    class Hiz < Dry::CLI::Command
+      include Verification
+
+      desc 'Fast-mode: implement an issue with Sonnet, create a PR (no merge)'
+
+      argument :issue, type: :integer, required: true, desc: 'Issue number to process'
+      option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
+
+      MODEL = 'sonnet'
+
+      STEPS = [
+        { agent: 'implementer', role: 'implement' },
+        { agent: 'reviewer',    role: 'review' },
+        { agent: 'security-reviewer', role: 'security' }
+      ].freeze
+
+      def call(issue:, **options)
+        @config = Config.load
+        issue_number = issue.to_i
+        logger = build_logger(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)
+
+        logger.info("=== Hiz (fast mode) for issue ##{issue_number} ===")
+
+        run_fast_pipeline(issue_number, claude: claude, logger: logger, issues: issues)
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def run_fast_pipeline(issue_number, claude:, logger:, issues:)
+        chdir = @config.project_dir
+        branch = create_branch(issue_number, chdir)
+
+        failure = run_agents(issue_number, claude: claude, logger: logger, chdir: chdir)
+        if failure
+          handle_failure(issue_number, failure[:phase], failure[:output], issues: issues, logger: logger)
+          return
+        end
+
+        verification_failure = run_final_verification_step(claude: claude, logger: logger, chdir: chdir)
+        if verification_failure
+          handle_failure(issue_number, 'final-verify', verification_failure[:output],
+                         issues: issues, logger: logger)
+          return
+        end
+
+        push_and_create_pr(issue_number, branch, logger: logger, issues: issues, chdir: chdir)
+      end
+
+      def run_agents(issue_number, claude:, logger:, chdir:)
+        STEPS.each do |step|
+          result = run_step(step, issue_number, claude: claude, logger: logger, chdir: chdir)
+          next if result.success?
+
+          if step[:role] == 'implement'
+            logger.error("Implementation failed for issue ##{issue_number}")
+            return { phase: 'implement', output: result.output }
+          end
+
+          logger.warn("#{step[:role]} reported issues but continuing")
+        end
+        nil
+      end
+
+      def create_branch(issue_number, chdir)
+        branch = "hiz/issue-#{issue_number}-#{SecureRandom.hex(4)}"
+        _, stderr, status = Open3.capture3('git', 'checkout', '-b', branch, chdir: chdir)
+        raise "Failed to create branch #{branch}: #{stderr}" unless status.success?
+
+        branch
+      end
+
+      def run_step(step, issue_number, claude:, logger:, chdir:)
+        agent = step[:agent]
+        role = step[:role]
+        logger.info("--- Phase: #{role} (#{agent}) [sonnet] ---")
+        prompt = build_prompt(role, issue_number)
+        claude.run_agent(agent, prompt, chdir: chdir, model: MODEL)
+      end
+
+      def build_prompt(role, issue_number)
+        case role
+        when 'implement' then "Implement GitHub issue ##{issue_number}"
+        when 'review'    then "Review the changes for GitHub issue ##{issue_number}. Run: git diff main"
+        when 'security'  then "Security review changes for GitHub issue ##{issue_number}. Run: git diff main"
+        else "Run #{role} for GitHub issue ##{issue_number}"
+        end
+      end
+
+      def run_final_verification_step(claude:, logger:, 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, model: MODEL)
+
+        result = run_final_checks(logger, chdir: chdir)
+        return nil if result[:success]
+
+        { success: false, phase: 'final-verify', output: result[:output] }
+      end
+
+      def push_and_create_pr(issue_number, branch, logger:, issues:, chdir:)
+        commit_changes(issue_number, chdir)
+
+        _, stderr, status = Open3.capture3('git', 'push', '-u', 'origin', branch, chdir: chdir)
+        unless status.success?
+          logger.error("Push failed: #{stderr}")
+          handle_failure(issue_number, 'push', stderr, issues: issues, logger: logger)
+          return
+        end
+
+        issue_data = issues.view(issue_number)
+        issue_title = issue_data&.dig('title')
+        pr_title = issue_title ? "Fix ##{issue_number}: #{issue_title}" : "Fix ##{issue_number}"
+        pr_body = "Automated PR for issue ##{issue_number} (hiz fast mode)\n\nCloses ##{issue_number}"
+
+        stdout, stderr, status = Open3.capture3(
+          'gh', 'pr', 'create',
+          '--title', pr_title,
+          '--body', pr_body,
+          '--head', branch,
+          chdir: chdir
+        )
+
+        if status.success?
+          pr_url = stdout.strip
+          logger.info("PR created: #{pr_url}")
+          puts "PR created: #{pr_url}"
+        else
+          logger.error("PR creation failed: #{stderr}")
+          handle_failure(issue_number, 'pr-create', stderr, issues: issues, logger: logger)
+        end
+      end
+
+      def commit_changes(issue_number, chdir)
+        stdout, = Open3.capture3('git', 'status', '--porcelain', chdir: chdir)
+        return if stdout.strip.empty?
+
+        Open3.capture3('git', 'add', '-A', chdir: chdir)
+        Open3.capture3('git', 'commit', '-m', "feat: implement issue ##{issue_number} [hiz]",
+                       chdir: chdir)
+      end
+
+      def handle_failure(issue_number, phase, output, issues:, logger:)
+        logger.error("Issue ##{issue_number} failed at phase: #{phase}")
+        issues.comment(issue_number,
+                       "Hiz (fast mode) failed at phase: #{phase}\n\n```\n#{output.to_s[0..1000]}\n```")
+        warn "Issue ##{issue_number} failed at phase: #{phase}"
+        Open3.capture3('git', 'checkout', 'main', chdir: @config.project_dir)
+      end
+
+      def build_logger(issue_number)
+        PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir), issue_number: issue_number)
+      end
+    end
+  end
+end

data/lib/ocak/commands/resume.rb

@@ -61,9 +61,9 @@ module Ocak
         issues.transition(issue_number, from: config.label_failed, to: config.label_in_progress)
 
         runner = PipelineRunner.new(config: config, options: { watch: options[:watch] })
-        result = runner.send(:run_pipeline, issue_number,
-                             logger: logger, claude: claude, chdir: chdir,
-                             skip_steps: saved[:completed_steps])
+        result = runner.run_pipeline(issue_number,
+                                     logger: logger, claude: claude, chdir: chdir,
+                                     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 }

data/lib/ocak/issue_fetcher.rb

@@ -25,7 +25,8 @@ module Ocak
       issues.reject! { |i| in_progress?(i) }
       issues.select! { |i| authorized_issue?(i) }
       issues
-    rescue JSON::ParserError
+    rescue JSON::ParserError => e
+      @logger&.warn("Failed to parse issue list JSON: #{e.message}")
       []
     end
 
@@ -55,7 +56,8 @@ module Ocak
       return nil unless status.success?
 
       JSON.parse(stdout)
-    rescue JSON::ParserError
+    rescue JSON::ParserError => e
+      @logger&.warn("Failed to parse issue view JSON: #{e.message}")
       nil
     end
 
@@ -115,7 +117,8 @@ module Ocak
       return [] unless status.success?
 
       JSON.parse(stdout).fetch('comments', [])
-    rescue JSON::ParserError
+    rescue JSON::ParserError => e
+      @logger&.warn("Failed to parse issue comments JSON: #{e.message}")
       []
     end
 

data/lib/ocak/monorepo_detector.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ocak
+  module MonorepoDetector
+    private
+
+    def detect_monorepo
+      packages = []
+      packages.concat(detect_npm_workspaces)
+      packages.concat(detect_pnpm_workspaces)
+      packages.concat(detect_cargo_workspaces)
+      packages.concat(detect_go_workspaces)
+      packages.concat(detect_lerna_packages)
+      packages.concat(detect_convention_packages) if packages.empty?
+      packages.uniq!
+      { detected: packages.any?, packages: packages }
+    end
+
+    def detect_npm_workspaces
+      return [] unless exists?('package.json')
+
+      pkg = begin
+        JSON.parse(read_file('package.json'))
+      rescue JSON::ParserError => e
+        warn("Failed to parse package.json: #{e.message}")
+        {}
+      end
+      workspaces = pkg['workspaces']
+      workspaces = workspaces['packages'] if workspaces.is_a?(Hash)
+      return [] unless workspaces.is_a?(Array) && workspaces.any?
+
+      expand_workspace_globs(workspaces)
+    end
+
+    def detect_pnpm_workspaces
+      return [] unless exists?('pnpm-workspace.yaml')
+
+      content = read_file('pnpm-workspace.yaml')
+      globs = content.scan(/^\s*-\s*['"]?([^'"#\n]+)/).flatten.map(&:strip)
+      expand_workspace_globs(globs)
+    end
+
+    def detect_cargo_workspaces
+      return [] unless exists?('Cargo.toml') && read_file('Cargo.toml').include?('[workspace]')
+
+      read_file('Cargo.toml').scan(/members\s*=\s*\[(.*?)\]/m).flatten.flat_map do |members|
+        globs = members.scan(/"([^"]+)"/).flatten
+        expand_workspace_globs(globs)
+      end
+    end
+
+    def detect_go_workspaces
+      return [] unless exists?('go.work')
+
+      read_file('go.work').scan(/use\s+(\S+)/).flatten.select do |pkg|
+        Dir.exist?(File.join(@dir, pkg))
+      end
+    end
+
+    def detect_lerna_packages
+      return [] unless exists?('lerna.json')
+
+      lerna = begin
+        JSON.parse(read_file('lerna.json'))
+      rescue JSON::ParserError => e
+        warn("Failed to parse lerna.json: #{e.message}")
+        {}
+      end
+      expand_workspace_globs(lerna['packages'] || ['packages/*'])
+    end
+
+    def detect_convention_packages
+      packages = []
+      %w[packages apps services modules libs].each do |candidate|
+        path = File.join(@dir, candidate)
+        next unless Dir.exist?(path)
+
+        subdirs = Dir.entries(path).reject { |e| e.start_with?('.') }.select do |e|
+          File.directory?(File.join(path, e))
+        end
+        packages.concat(subdirs.map { |s| "#{candidate}/#{s}" }) if subdirs.size > 1
+      end
+      packages
+    end
+
+    def expand_workspace_globs(globs)
+      globs.flat_map do |glob|
+        pattern = File.join(@dir, glob)
+        Dir.glob(pattern).select { |p| File.directory?(p) }.map do |p|
+          p.sub("#{@dir}/", '')
+        end
+      end
+    end
+  end
+end

data/lib/ocak/pipeline_executor.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'pipeline_state'
+require_relative 'verification'
+require_relative 'planner'
+
+module Ocak
+  class PipelineExecutor
+    include Verification
+    include Planner
+
+    StepContext = Struct.new(:issue_number, :idx, :role, :result, :state, :logger, :chdir)
+
+    def initialize(config:)
+      @config = config
+    end
+
+    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
+
+      pipeline_state.delete(issue_number)
+
+      logger.info("=== Pipeline complete for issue ##{issue_number} ===")
+      { success: true, output: 'Pipeline completed successfully' }
+    end
+
+    private
+
+    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 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 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 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
+
+    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
+
+    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