claude-task-master 0.2.0

data/lib/claude_task_master/pr_comment.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module ClaudeTaskMaster
+  # Represents a GitHub PR review comment
+  # Detects CodeRabbit, Copilot, and other review bot comments
+  class PRComment
+    ACTIONABLE_SEVERITIES = %w[major critical warning].freeze
+
+    # Known bot authors
+    CODERABBIT_BOT = 'coderabbitai[bot]'
+    COPILOT_BOT = 'github-copilot[bot]'
+    KNOWN_BOTS = [CODERABBIT_BOT, COPILOT_BOT].freeze
+
+    attr_reader :id, :file_path, :line, :start_line, :body, :author,
+                :created_at, :updated_at, :html_url, :resolved
+
+    def initialize(attrs = {})
+      @id = attrs[:id] || attrs['id']
+      @file_path = attrs[:path] || attrs['path']
+      @line = attrs[:line] || attrs['line']
+      @start_line = attrs[:start_line] || attrs['start_line']
+      @body = attrs[:body] || attrs['body']
+      @author = extract_author(attrs[:user] || attrs['user'])
+      @created_at = attrs[:created_at] || attrs['created_at']
+      @updated_at = attrs[:updated_at] || attrs['updated_at']
+      @html_url = attrs[:html_url] || attrs['html_url']
+      @resolved = attrs[:resolved] || attrs['resolved']
+    end
+
+    # Create collection from API response
+    def self.from_api_response(data)
+      data = [data] unless data.is_a?(Array)
+      data.map { |item| new(item) }
+    end
+
+    # Line range as string (e.g., "40-42" or "42")
+    def line_range
+      @line_range ||= begin
+        start = start_line || line
+        start == line ? line.to_s : "#{start}-#{line}"
+      end
+    end
+
+    # Parse severity from CodeRabbit/Copilot comment body
+    def severity
+      @severity ||= parse_severity
+    end
+
+    # Extract summary from comment body
+    def summary
+      @summary ||= extract_summary
+    end
+
+    # Check if comment requires attention
+    def actionable?
+      ACTIONABLE_SEVERITIES.include?(severity)
+    end
+
+    # Bot detection
+    def from_coderabbit?
+      author == CODERABBIT_BOT
+    end
+
+    def from_copilot?
+      author == COPILOT_BOT
+    end
+
+    def from_bot?
+      KNOWN_BOTS.include?(author) || author&.end_with?('[bot]')
+    end
+
+    def from_human?
+      !from_bot?
+    end
+
+    # Resolved status
+    def resolved?
+      @resolved == true
+    end
+
+    def unresolved?
+      @resolved == false
+    end
+
+    # Check if comment has committable suggestion
+    def has_suggestion?
+      body&.include?('```suggestion') || false
+    end
+
+    # Extract suggestion code from body
+    def suggestion_code
+      @suggestion_code ||= begin
+        return nil unless body&.include?('```suggestion')
+
+        match = body.match(/```suggestion[^\n]*\n(.*?)\n```/m)
+        match ? match[1] : nil
+      end
+    end
+
+    # Serialize to hash
+    def to_h
+      {
+        id: id,
+        file_path: file_path,
+        line_range: line_range,
+        author: author,
+        severity: severity,
+        summary: summary,
+        actionable: actionable?,
+        from_bot: from_bot?,
+        resolved: resolved?,
+        has_suggestion: has_suggestion?,
+        html_url: html_url
+      }
+    end
+
+    private
+
+    def extract_author(user)
+      return user if user.is_a?(String)
+      return nil unless user
+
+      user[:login] || user['login']
+    end
+
+    def parse_severity
+      return 'info' unless body
+
+      case body
+      when /❌.*Critical/m, /\*\*Critical\*\*/i
+        'critical'
+      when /⚠️.*Warning/m, /\*\*Warning\*\*/i
+        'warning'
+      when /🟠 Major/m, /\*\*Major\*\*/i
+        'major'
+      when /🔵 Trivial/m, /\*\*Trivial\*\*/i
+        'trivial'
+      when /🛠️ Refactor/m, /refactor suggestion/i
+        'refactor'
+      when /🧹 Nitpick/m, /nitpick/i
+        'nitpick'
+      when /suggestion:/i, /consider:/i
+        'suggestion'
+      else
+        'info'
+      end
+    end
+
+    def extract_summary
+      return nil unless body
+
+      # Try to extract bolded summary line
+      match = body.match(/\*\*(.+?)\*\*/)
+      return match[1] if match
+
+      # Fallback to first non-empty line, skipping metadata
+      line = body.lines.reject { |l| l.strip.empty? || l.strip.start_with?('_', '<', '<!--') }.first
+      line&.strip&.truncate(100)
+    end
+  end
+end
+
+# Monkey-patch String for truncate
+class String
+  def truncate(max_length, omission: '...')
+    return self if length <= max_length
+
+    "#{self[0, max_length - omission.length]}#{omission}"
+  end
+end

data/lib/claude_task_master/state.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module ClaudeTaskMaster
+  # Manages state persistence in .claude-task-master/
+  # All state is file-based for easy inspection and resumption
+  class State
+    GOAL_FILE = 'goal.txt'
+    CRITERIA_FILE = 'criteria.txt'
+    PLAN_FILE = 'plan.md'
+    STATE_FILE = 'state.json'
+    PROGRESS_FILE = 'progress.md'
+    CONTEXT_FILE = 'context.md'
+    LOGS_DIR = 'logs'
+
+    attr_reader :dir
+
+    def initialize(project_dir = Dir.pwd)
+      @dir = File.join(project_dir, STATE_DIR)
+    end
+
+    # Initialize state directory for new project
+    def init(goal:, criteria:)
+      FileUtils.mkdir_p(@dir)
+      FileUtils.mkdir_p(logs_dir)
+
+      write_file(GOAL_FILE, goal)
+      write_file(CRITERIA_FILE, criteria)
+      write_file(PROGRESS_FILE, "# Progress\n\n_Started: #{Time.now.iso8601}_\n\n")
+      write_file(CONTEXT_FILE, "# Context\n\n_Learnings accumulated across sessions._\n\n")
+
+      save_state(
+        status: 'planning',
+        current_task: nil,
+        session_count: 0,
+        pr_number: nil,
+        started_at: Time.now.iso8601,
+        updated_at: Time.now.iso8601
+      )
+    end
+
+    # Check if state directory exists (for resume)
+    def exists?
+      File.directory?(@dir) && File.exist?(state_path)
+    end
+
+    # Load machine state
+    def load_state
+      return nil unless File.exist?(state_path)
+
+      JSON.parse(File.read(state_path), symbolize_names: true)
+    end
+
+    # Save machine state
+    def save_state(data)
+      data[:updated_at] = Time.now.iso8601
+      File.write(state_path, JSON.pretty_generate(data))
+    end
+
+    # Update specific state fields
+    def update_state(**fields)
+      current = load_state || {}
+      save_state(current.merge(fields))
+    end
+
+    # Read goal
+    def goal
+      read_file(GOAL_FILE)
+    end
+
+    # Read success criteria
+    def criteria
+      read_file(CRITERIA_FILE)
+    end
+
+    # Read plan
+    def plan
+      read_file(PLAN_FILE)
+    end
+
+    # Write plan
+    def save_plan(content)
+      write_file(PLAN_FILE, content)
+    end
+
+    # Read progress notes
+    def progress
+      read_file(PROGRESS_FILE)
+    end
+
+    # Append to progress
+    def append_progress(content)
+      current = progress || ''
+      write_file(PROGRESS_FILE, "#{current}\n#{content}")
+    end
+
+    # Read accumulated context
+    def context
+      read_file(CONTEXT_FILE)
+    end
+
+    # Append to context
+    def append_context(content)
+      current = context || ''
+      write_file(CONTEXT_FILE, "#{current}\n#{content}")
+    end
+
+    # Log a session
+    def log_session(session_num, content)
+      filename = format('session-%03d.md', session_num)
+      File.write(File.join(logs_dir, filename), content)
+    end
+
+    # Get next session number
+    def next_session_number
+      existing = Dir.glob(File.join(logs_dir, 'session-*.md'))
+      existing.empty? ? 1 : existing.size + 1
+    end
+
+    # Check if success criteria met (Claude writes SUCCESS to state)
+    def success?
+      state = load_state
+      state && state[:status] == 'success'
+    end
+
+    # Check if blocked
+    def blocked?
+      state = load_state
+      state && state[:status] == 'blocked'
+    end
+
+    # Build context string for Claude
+    def build_context
+      state = load_state || {}
+
+      <<~CONTEXT
+        # Current State
+
+        ## Goal
+        #{goal}
+
+        ## Success Criteria
+        #{criteria}
+
+        ## Status
+        - Phase: #{state[:status] || 'unknown'}
+        - Current task: #{state[:current_task] || 'none'}
+        - PR: #{state[:pr_number] ? "##{state[:pr_number]}" : 'none'}
+        - Session: #{state[:session_count] || 0}
+
+        ## Plan
+        #{plan || '_No plan yet. Generate one first._'}
+
+        ## Context from Previous Sessions
+        #{context || '_No context yet._'}
+
+        ## Recent Progress
+        #{progress || '_No progress yet._'}
+      CONTEXT
+    end
+
+    private
+
+    def state_path
+      File.join(@dir, STATE_FILE)
+    end
+
+    def logs_dir
+      File.join(@dir, LOGS_DIR)
+    end
+
+    def read_file(filename)
+      path = File.join(@dir, filename)
+      File.exist?(path) ? File.read(path) : nil
+    end
+
+    def write_file(filename, content)
+      File.write(File.join(@dir, filename), content)
+    end
+  end
+end

data/lib/claude_task_master/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ClaudeTaskMaster
+  VERSION = '0.2.0'
+end

data/lib/claude_task_master.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ClaudeTaskMaster
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class ClaudeError < Error; end
+
+  STATE_DIR = '.claude-task-master'
+end
+
+require_relative 'claude_task_master/version'
+require_relative 'claude_task_master/state'
+require_relative 'claude_task_master/claude'
+require_relative 'claude_task_master/pr_comment'
+require_relative 'claude_task_master/github'
+require_relative 'claude_task_master/loop'
+require_relative 'claude_task_master/cli'

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: claude-task-master
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- developerz.ai
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+description: |
+  A lightweight harness that keeps Claude Code working autonomously until
+  success criteria are met. Supports any code review system (CodeRabbit,
+  GitHub Copilot, etc.) and any CI provider.
+
+  The loop: plan -> work -> check -> work -> check -> done
+email:
+- hello@developerz.ai
+executables:
+- claude-task-master
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- README.md
+- bin/claude-task-master
+- lib/claude_task_master.rb
+- lib/claude_task_master/claude.rb
+- lib/claude_task_master/cli.rb
+- lib/claude_task_master/github.rb
+- lib/claude_task_master/loop.rb
+- lib/claude_task_master/pr_comment.rb
+- lib/claude_task_master/state.rb
+- lib/claude_task_master/version.rb
+homepage: https://github.com/developerz-ai/claude-task-master
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Autonomous task loop for Claude Code
+test_files: []