claude-task-master 0.2.0

data/lib/claude_task_master/github.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require 'octokit'
+
+module ClaudeTaskMaster
+  # GitHub operations via gh CLI and Octokit
+  # Handles PR creation, CI status, comments, and merging
+  class GitHub
+    class << self
+      # Check if gh CLI is available and authenticated
+      def available?
+        _, status = Open3.capture2('gh auth status')
+        status.success?
+      end
+
+      # Get Octokit client using gh token
+      def client
+        @client ||= begin
+          token = gh_token
+          raise ConfigError, 'GitHub token not found. Run: gh auth login' unless token
+
+          Octokit::Client.new(access_token: token, auto_paginate: true)
+        end
+      end
+
+      # Reset client (useful for testing)
+      def reset_client!
+        @client = nil
+      end
+
+      # Get current repository (owner/repo format)
+      def current_repo
+        @current_repo ||= begin
+          stdout, status = Open3.capture2('gh repo view --json nameWithOwner -q .nameWithOwner')
+          return nil unless status.success?
+
+          stdout.strip
+        end
+      end
+
+      # Create a PR
+      # Returns [success, pr_number_or_error]
+      def create_pr(title:, body:, base: 'main', head: nil)
+        head ||= current_branch
+        repo = current_repo
+        return [false, 'Not in a git repository'] unless repo
+
+        pr = client.create_pull_request(repo, base, head, title, body)
+        [true, pr.number]
+      rescue Octokit::Error => e
+        [false, e.message]
+      end
+
+      # Get PR status (CI checks)
+      # Returns hash with :status (:pending, :passing, :failing) and :checks array
+      def pr_status(pr_number)
+        repo = current_repo
+        return { status: :unknown, checks: [] } unless repo
+
+        # Get check runs for the PR's head SHA
+        pr = client.pull_request(repo, pr_number)
+        checks = client.check_runs_for_ref(repo, pr.head.sha)
+
+        check_results = checks.check_runs.map do |run|
+          {
+            name: run.name,
+            status: run.status,
+            conclusion: run.conclusion
+          }
+        end
+
+        overall = determine_ci_status(check_results)
+        { status: overall, checks: check_results }
+      rescue Octokit::Error
+        # Fallback to gh CLI
+        gh_pr_status(pr_number)
+      end
+
+      # Get all PR review comments
+      def pr_comments(pr_number)
+        repo = current_repo
+        return [] unless repo
+
+        comments = client.pull_request_comments(repo, pr_number)
+        PRComment.from_api_response(comments.map(&:to_h))
+      rescue Octokit::Error => e
+        warn "Failed to fetch comments: #{e.message}"
+        []
+      end
+
+      # Get unresolved review threads via GraphQL
+      def unresolved_threads(pr_number)
+        repo = current_repo
+        return [] unless repo
+
+        owner, name = repo.split('/')
+
+        query = <<~GRAPHQL
+          query {
+            repository(owner: "#{owner}", name: "#{name}") {
+              pullRequest(number: #{pr_number}) {
+                reviewThreads(first: 100) {
+                  nodes {
+                    id
+                    isResolved
+                    comments(first: 10) {
+                      nodes {
+                        body
+                        author { login }
+                        path
+                        line
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        response = client.post('/graphql', { query: query }.to_json)
+        threads = response.dig(:data, :repository, :pullRequest, :reviewThreads, :nodes) || []
+
+        threads.reject { |t| t[:isResolved] }.map do |thread|
+          first_comment = thread.dig(:comments, :nodes)&.first
+          {
+            id: thread[:id],
+            author: first_comment&.dig(:author, :login),
+            body: first_comment&.dig(:body),
+            file_path: first_comment&.dig(:path),
+            line: first_comment&.dig(:line)
+          }
+        end
+      rescue Octokit::Error, StandardError => e
+        # Fallback to gh CLI
+        gh_unresolved_threads(pr_number)
+      end
+
+      # Get actionable comments (unresolved + actionable severity)
+      def actionable_comments(pr_number)
+        comments = pr_comments(pr_number)
+        unresolved_ids = unresolved_threads(pr_number).map { |t| t[:id] }
+
+        comments.select do |comment|
+          comment.actionable? || unresolved_ids.include?(comment.id)
+        end
+      end
+
+      # Resolve a review thread
+      def resolve_thread(thread_id)
+        mutation = <<~GRAPHQL
+          mutation {
+            resolveReviewThread(input: {threadId: "#{thread_id}"}) {
+              thread {
+                id
+                isResolved
+              }
+            }
+          }
+        GRAPHQL
+
+        response = client.post('/graphql', { query: mutation }.to_json)
+        errors = response[:errors]
+
+        return true unless errors
+
+        raise GitHubError, errors.map { |e| e[:message] }.join(', ')
+      end
+
+      # Reply to a PR comment
+      def reply_to_comment(pr_number, comment_id, body)
+        repo = current_repo
+        return false unless repo
+
+        client.create_pull_request_comment_reply(repo, pr_number, body, comment_id)
+        true
+      rescue Octokit::Error => e
+        warn "Failed to reply: #{e.message}"
+        false
+      end
+
+      # Wait for CI to complete (blocking)
+      def wait_for_ci(pr_number, timeout: 600)
+        cmd = ['gh', 'pr', 'checks', pr_number.to_s, '--watch', '--fail-fast']
+
+        Timeout.timeout(timeout) do
+          _, status = Open3.capture2(*cmd)
+          status.success? ? :passing : :failing
+        end
+      rescue Timeout::Error
+        :timeout
+      end
+
+      # Merge PR
+      def merge_pr(pr_number, method: :squash, delete_branch: true)
+        repo = current_repo
+        return false unless repo
+
+        client.merge_pull_request(repo, pr_number, '', merge_method: method)
+        client.delete_branch(repo, pr_branch_name(pr_number)) if delete_branch
+        true
+      rescue Octokit::Error => e
+        warn "Failed to merge: #{e.message}"
+        false
+      end
+
+      # Get PR info
+      def pr_info(pr_number)
+        repo = current_repo
+        return nil unless repo
+
+        pr = client.pull_request(repo, pr_number)
+        {
+          number: pr.number,
+          title: pr.title,
+          state: pr.state,
+          url: pr.html_url,
+          head_ref: pr.head.ref,
+          base_ref: pr.base.ref,
+          mergeable: pr.mergeable,
+          merged: pr.merged
+        }
+      rescue Octokit::Error
+        nil
+      end
+
+      # List open PRs
+      def open_prs
+        repo = current_repo
+        return [] unless repo
+
+        client.pull_requests(repo, state: 'open').map do |pr|
+          {
+            number: pr.number,
+            title: pr.title,
+            head_ref: pr.head.ref
+          }
+        end
+      rescue Octokit::Error
+        []
+      end
+
+      private
+
+      # Get GitHub token from gh CLI
+      def gh_token
+        stdout, status = Open3.capture2('gh auth token')
+        return nil unless status.success?
+
+        stdout.strip
+      end
+
+      # Get current git branch
+      def current_branch
+        stdout, status = Open3.capture2('git rev-parse --abbrev-ref HEAD')
+        return nil unless status.success?
+
+        stdout.strip
+      end
+
+      # Get PR branch name
+      def pr_branch_name(pr_number)
+        pr = client.pull_request(current_repo, pr_number)
+        pr.head.ref
+      rescue Octokit::Error
+        nil
+      end
+
+      # Determine overall CI status from check results
+      def determine_ci_status(checks)
+        return :unknown if checks.empty?
+
+        if checks.any? { |c| c[:conclusion] == 'failure' }
+          :failing
+        elsif checks.any? { |c| c[:status] != 'completed' }
+          :pending
+        else
+          :passing
+        end
+      end
+
+      # Fallback: Get PR status via gh CLI
+      def gh_pr_status(pr_number)
+        cmd = ['gh', 'pr', 'checks', pr_number.to_s, '--json', 'name,state,bucket']
+        stdout, status = Open3.capture2(*cmd)
+
+        return { status: :unknown, checks: [] } unless status.success?
+
+        checks = JSON.parse(stdout, symbolize_names: true)
+
+        overall = if checks.any? { |c| c[:bucket] == 'fail' }
+                    :failing
+                  elsif checks.any? { |c| c[:bucket] == 'pending' }
+                    :pending
+                  else
+                    :passing
+                  end
+
+        { status: overall, checks: checks }
+      end
+
+      # Fallback: Get unresolved threads via gh CLI
+      def gh_unresolved_threads(pr_number)
+        repo = current_repo
+        return [] unless repo
+
+        owner, name = repo.split('/')
+
+        query = <<~GRAPHQL
+          query {
+            repository(owner: "#{owner}", name: "#{name}") {
+              pullRequest(number: #{pr_number}) {
+                reviewThreads(first: 100) {
+                  nodes {
+                    id
+                    isResolved
+                    comments(first: 10) {
+                      nodes {
+                        body
+                        author { login }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        stdout, status = Open3.capture2('gh', 'api', 'graphql', '-f', "query=#{query}")
+        return [] unless status.success?
+
+        response = JSON.parse(stdout, symbolize_names: true)
+        threads = response.dig(:data, :repository, :pullRequest, :reviewThreads, :nodes) || []
+
+        threads.reject { |t| t[:isResolved] }
+      end
+    end
+  end
+
+  # Custom error class
+  class GitHubError < StandardError; end
+end

data/lib/claude_task_master/loop.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module ClaudeTaskMaster
+  # The main work loop
+  # Keeps calling Claude until success criteria met
+  class Loop
+    attr_reader :state, :claude, :pastel, :options
+
+    # Options:
+    #   no_merge: Don't auto-merge PRs, require manual merge
+    #   max_sessions: Stop after N sessions
+    #   pause_on_pr: Pause after creating each PR for review
+    #   verbose: Show verbose output
+    def initialize(state:, model: 'sonnet', **opts)
+      @state = state
+      @claude = Claude.new(model:)
+      @pastel = Pastel.new
+      @options = {
+        no_merge: opts[:no_merge] || false,
+        max_sessions: opts[:max_sessions],
+        pause_on_pr: opts[:pause_on_pr] || false,
+        verbose: opts[:verbose] || false
+      }
+      @session_count = 0
+    end
+
+    # Run the full loop from start
+    def run(goal:, criteria:)
+      puts pastel.cyan("Starting claude-task-master...")
+      puts pastel.dim("Goal: #{goal[0..100]}#{'...' if goal.length > 100}")
+      show_options
+      puts
+
+      # Initialize state
+      state.init(goal:, criteria:)
+
+      # Phase 1: Planning
+      plan_phase
+
+      # Phase 2: Work loop
+      work_loop
+    end
+
+    # Resume from existing state
+    def resume
+      unless state.exists?
+        raise ConfigError, 'No existing state found. Start fresh with a goal.'
+      end
+
+      current_state = state.load_state
+      puts pastel.cyan("Resuming claude-task-master...")
+      puts pastel.dim("Goal: #{state.goal[0..100]}#{'...' if state.goal.length > 100}")
+      puts pastel.dim("Status: #{current_state[:status]}")
+      puts pastel.dim("Session: #{current_state[:session_count]}")
+      show_options
+      puts
+
+      if current_state[:status] == 'planning'
+        plan_phase
+      end
+
+      work_loop
+    end
+
+    private
+
+    # Display active options
+    def show_options
+      active = []
+      active << 'no-merge' if options[:no_merge]
+      active << "max-sessions=#{options[:max_sessions]}" if options[:max_sessions]
+      active << 'pause-on-pr' if options[:pause_on_pr]
+      active << 'verbose' if options[:verbose]
+      return if active.empty?
+
+      puts pastel.dim("Options: #{active.join(', ')}")
+    end
+
+    # Phase 1: Generate plan
+    def plan_phase
+      puts pastel.yellow("Phase 1: Planning...")
+
+      # Check for existing CLAUDE.md
+      claude_md_path = File.join(Dir.pwd, 'CLAUDE.md')
+      existing_claude_md = File.exist?(claude_md_path) ? File.read(claude_md_path) : nil
+
+      prompt = Claude.planning_prompt(state.goal, existing_claude_md:, no_merge: options[:no_merge])
+
+      session_num = state.next_session_number
+      state.update_state(session_count: session_num)
+
+      success, output, _exit_code = claude.invoke(prompt)
+
+      # Log the session
+      state.log_session(session_num, "# Planning Session\n\n#{output}")
+
+      unless success
+        state.update_state(status: 'blocked')
+        state.append_progress("\n## Blocked in Planning\n\n#{output[-500..]}")
+        raise ClaudeError, 'Planning failed. Check logs.'
+      end
+
+      current = state.load_state
+      if current[:status] != 'ready'
+        # Claude didn't update state, do it ourselves
+        state.update_state(status: 'ready')
+      end
+
+      puts pastel.green("Plan created. Check .claude-task-master/plan.md")
+      puts
+    end
+
+    # Show current PR status (CI, comments)
+    def show_pr_status(pr_number)
+      ci_status = GitHub.pr_status(pr_number)
+      unresolved = GitHub.unresolved_threads(pr_number)
+
+      status_icon = case ci_status[:status]
+                    when :passing then pastel.green('CI passing')
+                    when :failing then pastel.red('CI failing')
+                    when :pending then pastel.yellow('CI pending')
+                    else pastel.dim('CI unknown')
+                    end
+
+      comments_text = if unresolved.empty?
+                        pastel.green('0 unresolved')
+                      else
+                        pastel.yellow("#{unresolved.size} unresolved comments")
+                      end
+
+      puts pastel.dim("  PR ##{pr_number}: #{status_icon} | #{comments_text}")
+    rescue StandardError => e
+      # Don't fail if we can't get PR status
+      puts pastel.dim("  PR ##{pr_number}: (couldn't fetch status)")
+    end
+
+    # Phase 2: Work until done
+    def work_loop
+      puts pastel.yellow("Phase 2: Working...")
+      puts pastel.dim("Press Ctrl+C to pause (can resume later)")
+      puts
+
+      loop do
+        # Check if done
+        if state.success?
+          puts
+          puts pastel.green.bold("SUCCESS!")
+          puts pastel.green("All tasks completed. Check .claude-task-master/progress.md")
+          break
+        end
+
+        if state.blocked?
+          puts
+          puts pastel.red.bold("BLOCKED")
+          puts pastel.red("Claude got stuck. Check .claude-task-master/progress.md for details.")
+          break
+        end
+
+        # Check max sessions limit
+        if options[:max_sessions] && @session_count >= options[:max_sessions]
+          puts
+          puts pastel.yellow.bold("MAX SESSIONS REACHED")
+          puts pastel.yellow("Stopped after #{@session_count} sessions. Run 'claude-task-master resume' to continue.")
+          state.append_progress("\n_Stopped at max sessions (#{@session_count}) at #{Time.now.iso8601}_\n")
+          break
+        end
+
+        # Run one work iteration
+        pr_before = state.load_state[:pr_number]
+        work_iteration
+        @session_count += 1
+
+        # Check if new PR was created
+        pr_after = state.load_state[:pr_number]
+        if pr_after && pr_after != pr_before && options[:pause_on_pr]
+          puts
+          puts pastel.yellow.bold("NEW PR CREATED")
+          puts pastel.yellow("Paused for review. PR ##{pr_after}")
+          puts pastel.dim("Run 'claude-task-master resume' to continue after review.")
+          state.append_progress("\n_Paused for PR review (##{pr_after}) at #{Time.now.iso8601}_\n")
+          break
+        end
+
+        # Brief pause between iterations
+        sleep 2
+      end
+    rescue Interrupt
+      puts
+      puts pastel.yellow("Paused. Run 'claude-task-master' to resume.")
+      state.append_progress("\n_Paused at #{Time.now.iso8601}_\n")
+    end
+
+    # Single work iteration
+    def work_iteration
+      current_state = state.load_state
+      session_num = state.next_session_number
+
+      # Show PR/CI status if we have a PR
+      if current_state[:pr_number]
+        show_pr_status(current_state[:pr_number])
+      end
+
+      puts pastel.cyan("[Session #{session_num}] Working on: #{current_state[:current_task] || 'next task'}")
+
+      # Build context and prompt
+      context = state.build_context
+      prompt = Claude.work_prompt(context, no_merge: options[:no_merge])
+
+      # Update session count
+      state.update_state(session_count: session_num)
+
+      # Invoke Claude
+      start_time = Time.now
+      success, output, _exit_code = claude.invoke(prompt)
+      duration = (Time.now - start_time).round(1)
+
+      # Log the session
+      log_content = <<~LOG
+        # Work Session #{session_num}
+
+        _Duration: #{duration}s_
+        _Started: #{start_time.iso8601}_
+
+        ## Output
+
+        #{output}
+      LOG
+      state.log_session(session_num, log_content)
+
+      # Report
+      if success
+        puts pastel.green("  Completed in #{duration}s")
+      else
+        puts pastel.red("  Session ended with error (#{duration}s)")
+        state.append_progress("\n## Session #{session_num} Error\n\n#{output[-500..]}")
+      end
+
+      # Check new state
+      new_state = state.load_state
+      if new_state[:current_task] != current_state[:current_task]
+        puts pastel.dim("  Task changed: #{new_state[:current_task]}")
+      end
+      if new_state[:pr_number] && new_state[:pr_number] != current_state[:pr_number]
+        puts pastel.dim("  PR created: ##{new_state[:pr_number]}")
+      end
+    end
+  end
+end