aidp 0.32.0 → 0.34.0

data/lib/aidp/watch/review_processor.rb

@@ -10,6 +10,7 @@ require_relative "implementation_verifier"
 require_relative "reviewers/senior_dev_reviewer"
 require_relative "reviewers/security_reviewer"
 require_relative "reviewers/performance_reviewer"
+require_relative "feedback_collector"
 
 module Aidp
   module Watch
@@ -81,13 +82,16 @@ module Aidp
           review_results: review_results,
           verification_result: verification_result
         )
-        @repository_client.post_comment(number, comment_body)
+        comment_body_with_feedback = FeedbackCollector.append_feedback_prompt(comment_body)
+        result = @repository_client.post_comment(number, comment_body_with_feedback)
+        comment_id = result[:id] if result.is_a?(Hash)
 
         display_message("💬 Posted review comment for PR ##{number}", type: :success)
         @state_store.record_review(number, {
           timestamp: Time.now.utc.iso8601,
           reviewers: review_results.map { |r| r[:persona] },
-          total_findings: review_results.sum { |r| r[:findings].length }
+          total_findings: review_results.sum { |r| r[:findings].length },
+          comment_id: comment_id
         })
 
         # Remove review label after processing
@@ -200,12 +204,35 @@ module Aidp
           else
             parts << "### ⚠️ Implementation Incomplete"
             parts << ""
-            parts << "**This PR appears to be incomplete based on the linked issue requirements:**"
+            parts << "**This PR appears to be incomplete based on the linked issue requirements.**"
             parts << ""
-            verification_result[:reasons]&.each do |reason|
-              parts << "- #{reason}"
+
+            # Show the verification reasoning
+            if verification_result[:reason]
+              parts << "**Summary:** #{verification_result[:reason]}"
+              parts << ""
             end
-            parts << ""
+
+            # Show missing requirements for implementers to address
+            if verification_result[:missing_items]&.any?
+              parts << "**Missing Requirements:**"
+              parts << ""
+              verification_result[:missing_items].each do |item|
+                parts << "- #{item}"
+              end
+              parts << ""
+            end
+
+            # Show additional work needed for implementers
+            if verification_result[:additional_work]&.any?
+              parts << "**Additional Work Needed:**"
+              parts << ""
+              verification_result[:additional_work].each do |work|
+                parts << "- #{work}"
+              end
+              parts << ""
+            end
+
             parts << "**Suggested Action:** Add the `aidp-request-changes` label if you'd like AIDP to help complete the implementation."
           end
           parts << ""

data/lib/aidp/watch/runner.rb

@@ -1,21 +1,8 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
-
-require_relative "../message_display"
-require_relative "repository_client"
-require_relative "repository_safety_checker"
-require_relative "state_store"
+require_relative "feedback_collector"
 require_relative "github_state_extractor"
-require_relative "plan_generator"
-require_relative "plan_processor"
-require_relative "build_processor"
-require_relative "../auto_update"
-require_relative "review_processor"
-require_relative "ci_fix_processor"
-require_relative "change_request_processor"
-require_relative "auto_processor"
-require_relative "auto_pr_processor"
 
 module Aidp
   module Watch
@@ -26,13 +13,18 @@ module Aidp
 
       DEFAULT_INTERVAL = 30
 
-      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false, verbose: false)
+      # Expose for testability
+      attr_reader :post_detection_comments
+      attr_writer :last_update_check
+
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false, verbose: false, quiet: false)
         @prompt = prompt
         @interval = interval
         @once = once
         @project_dir = project_dir
         @force = force
         @verbose = verbose
+        @quiet = quiet
         @provider_name = provider_name
         @safety_config = safety_config
 
@@ -117,6 +109,12 @@ module Aidp
           safety_config: safety_config[:safety] || safety_config["safety"] || {},
           verbose: verbose
         )
+
+        @feedback_collector = FeedbackCollector.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          project_dir: project_dir
+        )
       end
 
       def start
@@ -144,6 +142,7 @@ module Aidp
           process_cycle
           Aidp.log_debug("watch_runner", "poll_cycle.complete", once: @once, next_poll_in: @once ? nil : @interval)
           break if @once
+
           Aidp.log_debug("watch_runner", "poll_cycle.sleep", seconds: @interval)
           sleep @interval
         end
@@ -165,6 +164,7 @@ module Aidp
         process_ci_fix_triggers
         process_auto_pr_triggers
         process_change_request_triggers
+        collect_feedback
       end
 
       def process_plan_triggers
@@ -197,7 +197,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "plan_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "plan_skip_unauthorized_author", issue: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -253,7 +254,8 @@ module Aidp
 
             # Check author authorization before processing
             unless @safety_checker.should_process_issue?(detailed, enforce: false)
-              Aidp.log_debug("watch_runner", "build_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+              Aidp.log_debug("watch_runner", "build_skip_unauthorized_author", issue: detailed[:number],
+                author: detailed[:author])
               next
             end
 
@@ -276,7 +278,8 @@ module Aidp
               begin
                 @repository_client.remove_labels(detailed[:number], GitHubStateExtractor::IN_PROGRESS_LABEL)
               rescue => e
-                Aidp.log_warn("watch_runner", "failed_to_remove_in_progress_label", issue: detailed[:number], error: e.message)
+                Aidp.log_warn("watch_runner", "failed_to_remove_in_progress_label", issue: detailed[:number],
+                  error: e.message)
               end
             end
           end
@@ -296,7 +299,8 @@ module Aidp
 
         issues.each do |issue|
           unless issue_has_label?(issue, auto_label)
-            Aidp.log_debug("watch_runner", "auto_issue_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+            Aidp.log_debug("watch_runner", "auto_issue_skip_label_mismatch", issue: issue[:number],
+              labels: issue[:labels])
             next
           end
 
@@ -315,7 +319,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "auto_issue_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "auto_issue_skip_unauthorized_author", issue: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -361,7 +366,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "review_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "review_skip_unauthorized_author", pr: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -398,7 +404,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "auto_pr_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "auto_pr_skip_unauthorized_author", pr: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -434,7 +441,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "ci_fix_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "ci_fix_skip_unauthorized_author", pr: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -470,7 +478,8 @@ module Aidp
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
-            Aidp.log_debug("watch_runner", "change_request_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            Aidp.log_debug("watch_runner", "change_request_skip_unauthorized_author", pr: detailed[:number],
+              author: detailed[:author])
             next
           end
 
@@ -522,14 +531,22 @@ module Aidp
         return unless @auto_update_coordinator.policy.enabled
         return unless time_for_update_check?
 
+        @last_update_check = Time.now
         update_check = @auto_update_coordinator.check_for_update
 
         if update_check.should_update?
-          display_message("🔄 Update available: #{update_check.current_version} → #{update_check.available_version}", type: :highlight)
-          display_message("   Saving checkpoint and initiating update...", type: :muted)
-
-          initiate_update(update_check)
-          # Never returns - exits with code 75
+          display_message("🔄 Update available: #{update_check.current_version} → #{update_check.available_version}",
+            type: :highlight)
+
+          # Prefer hot reloading if available (Zeitwerk enabled with reloading)
+          if @auto_update_coordinator.hot_reload_available?
+            perform_hot_reload(update_check)
+          else
+            # Fall back to checkpoint + exit approach
+            display_message("   Saving checkpoint and initiating update...", type: :muted)
+            initiate_update(update_check)
+            # Never returns - exits with code 75
+          end
         end
       rescue Aidp::AutoUpdate::UpdateLoopError => e
         # Restart loop detected - disable auto-update
@@ -540,6 +557,25 @@ module Aidp
         Aidp.log_error("watch_runner", "update_check_failed", error: e.message)
       end
 
+      # Perform hot code reload without restarting
+      # @param update_check [Aidp::AutoUpdate::UpdateCheck] Update check result
+      def perform_hot_reload(update_check)
+        display_message("   Performing hot code reload (no restart needed)...", type: :muted)
+
+        if @auto_update_coordinator.hot_reload_update(update_check)
+          display_message("✨ Hot reload complete! Now running #{Aidp::VERSION}", type: :success)
+          Aidp.log_info("watch_runner", "hot_reload_success",
+            version: Aidp::VERSION)
+        else
+          display_message("⚠️  Hot reload skipped (no update needed)", type: :muted)
+        end
+      rescue Aidp::AutoUpdate::UpdateError => e
+        display_message("⚠️  Hot reload failed: #{e.message}", type: :warning)
+        display_message("   Falling back to checkpoint + restart...", type: :muted)
+        # Fall back to cold restart
+        initiate_update(update_check)
+      end
+
       # Determine if it's time to check for updates
       # @return [Boolean]
       def time_for_update_check?
@@ -633,6 +669,21 @@ module Aidp
           name.casecmp(label).zero?
         end
       end
+
+      # Collect feedback from reactions on tracked comments
+      def collect_feedback
+        new_evaluations = @feedback_collector.collect_feedback
+        return if new_evaluations.empty?
+
+        Aidp.log_info("watch_runner", "feedback_collected",
+          count: new_evaluations.size,
+          evaluations: new_evaluations.map { |e| {id: e[:id], rating: e[:rating]} })
+
+        display_message("📊 Collected #{new_evaluations.size} new feedback evaluation(s)", type: :info) if @verbose
+      rescue => e
+        Aidp.log_error("watch_runner", "feedback_collection_failed", error: e.message)
+        display_message("⚠️  Feedback collection failed: #{e.message}", type: :warn) if @verbose
+      end
     end
   end
 end

data/lib/aidp/watch/state_store.rb

@@ -189,6 +189,214 @@ module Aidp
         save!
       end
 
+      # Feedback tracking methods - track comments for reaction-based evaluations
+
+      # Get all tracked comments with their metadata for feedback collection
+      # @return [Array<Hash>] List of comment info hashes
+      def tracked_comments
+        comments = []
+
+        # Collect from plans
+        plans.each do |issue_number, data|
+          next unless data["comment_id"]
+          comments << {
+            comment_id: data["comment_id"],
+            processor_type: "plan",
+            number: issue_number.to_i,
+            posted_at: data["posted_at"]
+          }
+        end
+
+        # Collect from reviews (if they store comment_id)
+        reviews.each do |pr_number, data|
+          next unless data["comment_id"]
+          comments << {
+            comment_id: data["comment_id"],
+            processor_type: "review",
+            number: pr_number.to_i,
+            posted_at: data["timestamp"]
+          }
+        end
+
+        # Collect from builds (if they store comment_id)
+        builds.each do |issue_number, data|
+          next unless data["comment_id"]
+          comments << {
+            comment_id: data["comment_id"],
+            processor_type: "build",
+            number: issue_number.to_i,
+            posted_at: data["updated_at"]
+          }
+        end
+
+        # Collect from feedback_comments (explicitly tracked)
+        feedback_comments.each do |key, data|
+          comments << {
+            comment_id: data["comment_id"],
+            processor_type: data["processor_type"],
+            number: data["number"].to_i,
+            posted_at: data["posted_at"]
+          }
+        end
+
+        comments
+      end
+
+      # Track a comment for feedback collection
+      # @param comment_id [Integer, String] GitHub comment ID
+      # @param processor_type [String] Type of processor (plan, review, build, etc.)
+      # @param number [Integer] Issue or PR number
+      def track_comment_for_feedback(comment_id:, processor_type:, number:)
+        key = "#{processor_type}_#{number}"
+        feedback_comments[key] = {
+          "comment_id" => comment_id.to_s,
+          "processor_type" => processor_type,
+          "number" => number,
+          "posted_at" => Time.now.utc.iso8601
+        }
+        save!
+      end
+
+      # Get IDs of reactions already processed for a comment
+      # @param comment_id [Integer, String] GitHub comment ID
+      # @return [Array<Integer>] List of processed reaction IDs
+      def processed_reaction_ids(comment_id)
+        data = processed_reactions[comment_id.to_s]
+        return [] unless data
+        data["reaction_ids"] || []
+      end
+
+      # Mark a reaction as processed
+      # @param comment_id [Integer, String] GitHub comment ID
+      # @param reaction_id [Integer] GitHub reaction ID
+      def mark_reaction_processed(comment_id, reaction_id)
+        key = comment_id.to_s
+        processed_reactions[key] ||= {"reaction_ids" => [], "last_checked" => nil}
+        processed_reactions[key]["reaction_ids"] << reaction_id unless processed_reactions[key]["reaction_ids"].include?(reaction_id)
+        processed_reactions[key]["last_checked"] = Time.now.utc.iso8601
+        save!
+      end
+
+      # Auto PR tracking methods - for aidp-auto label on PRs
+      # Tracks iteration counts to enforce iteration cap
+
+      # Get the current iteration count for an auto PR
+      # @param pr_number [Integer] PR number
+      # @return [Integer] Current iteration count (0 if not tracked)
+      def auto_pr_iteration_count(pr_number)
+        data = auto_prs[pr_number.to_s]
+        return 0 unless data
+        data["iteration"] || 0
+      end
+
+      # Get full auto PR data
+      # @param pr_number [Integer] PR number
+      # @return [Hash, nil] Auto PR tracking data
+      def auto_pr_data(pr_number)
+        auto_prs[pr_number.to_s]
+      end
+
+      # Record an auto PR iteration
+      # @param pr_number [Integer] PR number
+      # @param data [Hash] Additional data to store
+      # @return [Integer] New iteration count
+      def record_auto_pr_iteration(pr_number, data = {})
+        key = pr_number.to_s
+        existing = auto_prs[key] || {}
+        iteration = (existing["iteration"] || 0) + 1
+
+        auto_prs[key] = {
+          "iteration" => iteration,
+          "last_processed_at" => Time.now.utc.iso8601,
+          "status" => data[:status] || "in_progress",
+          "metadata" => stringify_keys(data[:metadata] || {})
+        }.merge(stringify_keys(data.except(:status, :metadata)))
+
+        save!
+        iteration
+      end
+
+      # Mark an auto PR as completed (ready for human review)
+      # @param pr_number [Integer] PR number
+      # @param data [Hash] Additional completion data
+      def complete_auto_pr(pr_number, data = {})
+        key = pr_number.to_s
+        existing = auto_prs[key] || {}
+
+        auto_prs[key] = existing.merge({
+          "status" => "completed",
+          "completed_at" => Time.now.utc.iso8601
+        }).merge(stringify_keys(data))
+
+        save!
+      end
+
+      # Check if an auto PR has reached the iteration cap
+      # @param pr_number [Integer] PR number
+      # @param cap [Integer] Maximum iterations allowed
+      # @return [Boolean] True if cap reached
+      def auto_pr_cap_reached?(pr_number, cap:)
+        auto_pr_iteration_count(pr_number) >= cap
+      end
+
+      # Project tracking methods
+      def project_item_id(issue_number)
+        projects[issue_number.to_s]&.dig("item_id")
+      end
+
+      def record_project_item_id(issue_number, item_id)
+        projects[issue_number.to_s] ||= {}
+        projects[issue_number.to_s]["item_id"] = item_id
+        projects[issue_number.to_s]["synced_at"] = Time.now.utc.iso8601
+        save!
+      end
+
+      def project_sync_data(issue_number)
+        projects[issue_number.to_s] || {}
+      end
+
+      def record_project_sync(issue_number, data)
+        projects[issue_number.to_s] ||= {}
+        projects[issue_number.to_s].merge!(stringify_keys(data))
+        projects[issue_number.to_s]["synced_at"] = Time.now.utc.iso8601
+        save!
+      end
+
+      # Sub-issue tracking methods
+      def sub_issues(parent_number)
+        hierarchies[parent_number.to_s]&.dig("sub_issues") || []
+      end
+
+      def parent_issue(sub_issue_number)
+        hierarchies[sub_issue_number.to_s]&.dig("parent")
+      end
+
+      def record_sub_issues(parent_number, sub_issue_numbers)
+        hierarchies[parent_number.to_s] ||= {}
+        hierarchies[parent_number.to_s]["sub_issues"] = Array(sub_issue_numbers)
+        hierarchies[parent_number.to_s]["created_at"] = Time.now.utc.iso8601
+
+        # Also record reverse mapping
+        sub_issue_numbers.each do |sub_number|
+          hierarchies[sub_number.to_s] ||= {}
+          hierarchies[sub_number.to_s]["parent"] = parent_number
+        end
+
+        save!
+      end
+
+      def blocking_status(issue_number)
+        # Check if this issue is blocked by any open sub-issues
+        sub_issue_numbers = sub_issues(issue_number)
+        return {blocked: false, blockers: []} if sub_issue_numbers.empty?
+
+        {
+          blocked: true,
+          blockers: sub_issue_numbers,
+          blocker_count: sub_issue_numbers.size
+        }
+      end
+
       private
 
       def ensure_directory
@@ -221,6 +429,11 @@ module Aidp
           base["ci_fixes"] ||= {}
           base["change_requests"] ||= {}
           base["detection_comments"] ||= {}
+          base["feedback_comments"] ||= {}
+          base["processed_reactions"] ||= {}
+          base["auto_prs"] ||= {}
+          base["projects"] ||= {}
+          base["hierarchies"] ||= {}
           base
         end
       end
@@ -249,6 +462,26 @@ module Aidp
         state["detection_comments"]
       end
 
+      def feedback_comments
+        state["feedback_comments"]
+      end
+
+      def processed_reactions
+        state["processed_reactions"]
+      end
+
+      def auto_prs
+        state["auto_prs"]
+      end
+
+      def projects
+        state["projects"]
+      end
+
+      def hierarchies
+        state["hierarchies"]
+      end
+
       def stringify_keys(hash)
         return {} unless hash