aidp 0.25.0 → 0.26.0

data/lib/aidp/watch/plan_processor.rb

@@ -41,21 +41,46 @@ module Aidp
 
       def process(issue)
         number = issue[:number]
-        if @state_store.plan_processed?(number)
-          display_message("ℹ️  Plan for issue ##{number} already posted. Skipping.", type: :muted)
-          return
+        existing_plan = @state_store.plan_data(number)
+
+        if existing_plan
+          display_message("🔄 Re-planning for issue ##{number} (iteration #{@state_store.plan_iteration_count(number) + 1})", type: :info)
+        else
+          display_message("🧠 Generating plan for issue ##{number} (#{issue[:title]})", type: :info)
         end
 
-        display_message("🧠 Generating plan for issue ##{number} (#{issue[:title]})", type: :info)
         plan_data = @plan_generator.generate(issue)
 
         # Fetch the user who added the most recent label
         label_actor = @repository_client.most_recent_label_actor(number)
 
-        comment_body = build_comment(issue: issue, plan: plan_data, label_actor: label_actor)
-        @repository_client.post_comment(number, comment_body)
+        # If updating existing plan, archive the previous content
+        archived_content = existing_plan ? archive_previous_plan(number, existing_plan) : nil
+
+        comment_body = build_comment(issue: issue, plan: plan_data, label_actor: label_actor, archived_content: archived_content)
+
+        if existing_plan && existing_plan["comment_id"]
+          # Update existing comment
+          @repository_client.update_comment(existing_plan["comment_id"], comment_body)
+          display_message("📝 Updated plan comment for issue ##{number}", type: :success)
+        elsif existing_plan
+          # Try to find existing comment by header
+          existing_comment = @repository_client.find_comment(number, COMMENT_HEADER)
+          if existing_comment
+            @repository_client.update_comment(existing_comment[:id], comment_body)
+            display_message("📝 Updated plan comment for issue ##{number}", type: :success)
+            plan_data = plan_data.merge(comment_id: existing_comment[:id])
+          else
+            # Fallback to posting new comment if we can't find the old one
+            @repository_client.post_comment(number, comment_body)
+            display_message("💬 Posted new plan comment for issue ##{number}", type: :success)
+          end
+        else
+          # First time planning - post new comment
+          @repository_client.post_comment(number, comment_body)
+          display_message("💬 Posted plan comment for issue ##{number}", type: :success)
+        end
 
-        display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
 
         # Update labels: remove plan trigger, add appropriate status label
@@ -64,6 +89,31 @@ module Aidp
 
       private
 
+      def archive_previous_plan(number, existing_plan)
+        iteration = @state_store.plan_iteration_count(number)
+        timestamp = existing_plan["posted_at"] || "unknown"
+
+        archived_parts = []
+        archived_parts << "<!-- ARCHIVED_PLAN_START iteration=#{iteration} timestamp=#{timestamp} -->"
+        archived_parts << "<details>"
+        archived_parts << "<summary>📋 Previous Plan (Iteration #{iteration}) - #{timestamp}</summary>"
+        archived_parts << ""
+        archived_parts << "<!-- ARCHIVED_PLAN_SUMMARY_START -->"
+        archived_parts << "### Plan Summary"
+        archived_parts << existing_plan["summary"].to_s
+        archived_parts << "<!-- ARCHIVED_PLAN_SUMMARY_END -->"
+        archived_parts << ""
+        archived_parts << "<!-- ARCHIVED_PLAN_TASKS_START -->"
+        archived_parts << "### Proposed Tasks"
+        archived_parts << format_bullets(Array(existing_plan["tasks"]), placeholder: "_No tasks_")
+        archived_parts << "<!-- ARCHIVED_PLAN_TASKS_END -->"
+        archived_parts << ""
+        archived_parts << "</details>"
+        archived_parts << "<!-- ARCHIVED_PLAN_END -->"
+
+        archived_parts.join("\n")
+      end
+
       def update_labels_after_plan(number, plan_data)
         questions = Array(plan_data[:questions])
         has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
@@ -85,7 +135,7 @@ module Aidp
         end
       end
 
-      def build_comment(issue:, plan:, label_actor: nil)
+      def build_comment(issue:, plan:, label_actor: nil, archived_content: nil)
         summary = plan[:summary].to_s.strip
         tasks = Array(plan[:tasks])
         questions = Array(plan[:questions])
@@ -104,14 +154,27 @@ module Aidp
         parts << "**Issue**: [##{issue[:number]}](#{issue[:url]})"
         parts << "**Title**: #{issue[:title]}"
         parts << ""
+
+        # Add archived content if this is a plan update
+        if archived_content
+          parts << archived_content
+          parts << ""
+        end
+
+        parts << "<!-- PLAN_SUMMARY_START -->"
         parts << "### Plan Summary"
         parts << (summary.empty? ? "_No summary generated_" : summary)
+        parts << "<!-- PLAN_SUMMARY_END -->"
         parts << ""
+        parts << "<!-- PLAN_TASKS_START -->"
         parts << "### Proposed Tasks"
         parts << format_bullets(tasks, placeholder: "_Pending task breakdown_")
+        parts << "<!-- PLAN_TASKS_END -->"
         parts << ""
+        parts << "<!-- CLARIFYING_QUESTIONS_START -->"
         parts << "### Clarifying Questions"
         parts << format_numbered(questions, placeholder: "_No questions identified_")
+        parts << "<!-- CLARIFYING_QUESTIONS_END -->"
         parts << ""
 
         # Add instructions based on whether there are questions

data/lib/aidp/watch/repository_client.rb

@@ -61,6 +61,14 @@ module Aidp
         gh_available? ? post_comment_via_gh(number, body) : post_comment_via_api(number, body)
       end
 
+      def find_comment(number, header_text)
+        gh_available? ? find_comment_via_gh(number, header_text) : find_comment_via_api(number, header_text)
+      end
+
+      def update_comment(comment_id, body)
+        gh_available? ? update_comment_via_gh(comment_id, body) : update_comment_via_api(comment_id, body)
+      end
+
       def create_pull_request(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
         gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number, draft: draft, assignee: assignee) : raise("GitHub CLI not available - cannot create PR")
       end
@@ -108,6 +116,10 @@ module Aidp
         gh_available? ? list_pull_requests_via_gh(labels: labels, state: state) : list_pull_requests_via_api(labels: labels, state: state)
       end
 
+      def fetch_pr_comments(number)
+        gh_available? ? fetch_pr_comments_via_gh(number) : fetch_pr_comments_via_api(number)
+      end
+
       private
 
       def list_issues_via_gh(labels:, state:)
@@ -162,27 +174,11 @@ module Aidp
         raise "GitHub API error (#{response.code})" unless response.code == "200"
 
         data = JSON.parse(response.body)
-        comments = fetch_comments_via_api(number)
+        comments = fetch_pr_comments_via_api(number)
         data["comments"] = comments
         normalize_issue_detail_api(data)
       end
 
-      def fetch_comments_via_api(number)
-        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
-        response = Net::HTTP.get_response(uri)
-        return [] unless response.code == "200"
-
-        JSON.parse(response.body).map do |raw|
-          {
-            "body" => raw["body"],
-            "author" => raw.dig("user", "login"),
-            "createdAt" => raw["created_at"]
-          }
-        end
-      rescue
-        []
-      end
-
       def post_comment_via_gh(number, body)
         cmd = ["gh", "issue", "comment", number.to_s, "--repo", full_repo, "--body", body]
         stdout, stderr, status = Open3.capture3(*cmd)
@@ -205,6 +201,44 @@ module Aidp
         response.body
       end
 
+      def find_comment_via_gh(number, header_text)
+        comments = fetch_pr_comments_via_gh(number)
+        comments.find { |comment| comment[:body]&.include?(header_text) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to find comment", error: e.message)
+        nil
+      end
+
+      def find_comment_via_api(number, header_text)
+        comments = fetch_pr_comments_via_api(number)
+        comments.find { |comment| comment[:body]&.include?(header_text) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to find comment", error: e.message)
+        nil
+      end
+
+      def update_comment_via_gh(comment_id, body)
+        cmd = ["gh", "api", "repos/#{full_repo}/issues/comments/#{comment_id}", "-X", "PATCH", "-f", "body=#{body}"]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to update comment via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def update_comment_via_api(comment_id, body)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/comments/#{comment_id}")
+        request = Net::HTTP::Patch.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({body: body})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "GitHub API update comment failed (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
       def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
         cmd = [
           "gh", "pr", "create",
@@ -535,6 +569,27 @@ module Aidp
         response.body
       end
 
+      def fetch_pr_comments_via_gh(number)
+        cmd = ["gh", "api", "repos/#{full_repo}/issues/#{number}/comments", "--jq", "."]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to fetch PR comments via gh: #{stderr.strip}" unless status.success?
+
+        JSON.parse(stdout).map { |raw| normalize_pr_comment(raw) }
+      rescue JSON::ParserError => e
+        raise "Failed to parse PR comments response: #{e.message}"
+      end
+
+      def fetch_pr_comments_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == "200"
+
+        JSON.parse(response.body).map { |raw| normalize_pr_comment(raw) }
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch PR comments", error: e.message)
+        []
+      end
+
       # Normalization methods for PRs
       def normalize_pull_request(raw)
         {
@@ -691,14 +746,24 @@ module Aidp
       def normalize_comment(comment)
         if comment.is_a?(Hash)
           {
-            "body" => comment["body"],
-            "author" => comment["author"] || comment.dig("user", "login"),
-            "createdAt" => comment["createdAt"] || comment["created_at"]
+            "body" => comment["body"] || comment[:body],
+            "author" => comment["author"] || comment[:author] || comment.dig("user", "login"),
+            "createdAt" => comment["createdAt"] || comment[:created_at] || comment["created_at"]
           }
         else
           {"body" => comment.to_s}
         end
       end
+
+      def normalize_pr_comment(raw)
+        {
+          id: raw["id"],
+          body: raw["body"],
+          author: raw.dig("user", "login"),
+          created_at: raw["created_at"],
+          updated_at: raw["updated_at"]
+        }
+      end
     end
   end
 end

data/lib/aidp/watch/runner.rb

@@ -12,6 +12,7 @@ require_relative "build_processor"
 require_relative "../auto_update"
 require_relative "review_processor"
 require_relative "ci_fix_processor"
+require_relative "change_request_processor"
 
 module Aidp
   module Watch
@@ -77,6 +78,16 @@ module Aidp
           label_config: label_config,
           verbose: verbose
         )
+        @change_request_processor = ChangeRequestProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          provider_name: provider_name,
+          project_dir: project_dir,
+          label_config: label_config,
+          change_request_config: safety_config[:pr_change_requests] || safety_config["pr_change_requests"] || {},
+          safety_config: safety_config[:safety] || safety_config["safety"] || {},
+          verbose: verbose
+        )
       end
 
       def start
@@ -122,6 +133,7 @@ module Aidp
         check_for_updates_if_due
         process_review_triggers
         process_ci_fix_triggers
+        process_change_request_triggers
       end
 
       def process_plan_triggers
@@ -230,6 +242,31 @@ module Aidp
         end
       end
 
+      def process_change_request_triggers
+        change_request_label = @change_request_processor.change_request_label
+        prs = @repository_client.list_pull_requests(labels: [change_request_label], state: "open")
+        Aidp.log_debug("watch_runner", "change_request_poll", label: change_request_label, total: prs.size)
+        prs.each do |pr|
+          unless pr_has_label?(pr, change_request_label)
+            Aidp.log_debug("watch_runner", "change_request_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # 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])
+            next
+          end
+
+          Aidp.log_debug("watch_runner", "change_request_process", pr: detailed[:number])
+          @change_request_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized PR author", pr: pr[:number], error: e.message)
+        end
+      end
+
       def issue_has_label?(issue, label)
         Array(issue[:labels]).any? do |issue_label|
           name = issue_label.is_a?(Hash) ? issue_label["name"] : issue_label.to_s

data/lib/aidp/watch/state_store.rb

@@ -27,14 +27,26 @@ module Aidp
         plans[issue_number.to_s]
       end
 
+      def plan_iteration_count(issue_number)
+        plan = plans[issue_number.to_s]
+        return 0 unless plan
+        plan["iteration"] || 1
+      end
+
       def record_plan(issue_number, data)
+        existing_plan = plans[issue_number.to_s]
+        iteration = existing_plan ? (existing_plan["iteration"] || 1) + 1 : 1
+
         payload = {
           "summary" => data[:summary],
           "tasks" => data[:tasks],
           "questions" => data[:questions],
           "comment_body" => data[:comment_body],
           "comment_hint" => data[:comment_hint],
-          "posted_at" => data[:posted_at] || Time.now.utc.iso8601
+          "comment_id" => data[:comment_id],
+          "posted_at" => data[:posted_at] || Time.now.utc.iso8601,
+          "iteration" => iteration,
+          "previous_iteration_at" => existing_plan ? existing_plan["posted_at"] : nil
         }.compact
 
         plans[issue_number.to_s] = payload
@@ -96,6 +108,34 @@ module Aidp
         save!
       end
 
+      # Change request tracking methods
+      def change_request_processed?(pr_number)
+        change_requests.key?(pr_number.to_s)
+      end
+
+      def change_request_data(pr_number)
+        change_requests[pr_number.to_s]
+      end
+
+      def record_change_request(pr_number, data)
+        payload = {
+          "status" => data[:status],
+          "timestamp" => data[:timestamp] || Time.now.utc.iso8601,
+          "changes_applied" => data[:changes_applied],
+          "commits" => data[:commits],
+          "reason" => data[:reason],
+          "clarification_count" => data[:clarification_count]
+        }.compact
+
+        change_requests[pr_number.to_s] = payload
+        save!
+      end
+
+      def reset_change_request_state(pr_number)
+        change_requests.delete(pr_number.to_s)
+        save!
+      end
+
       private
 
       def ensure_directory
@@ -126,6 +166,7 @@ module Aidp
           base["builds"] ||= {}
           base["reviews"] ||= {}
           base["ci_fixes"] ||= {}
+          base["change_requests"] ||= {}
           base
         end
       end
@@ -146,6 +187,10 @@ module Aidp
         state["ci_fixes"]
       end
 
+      def change_requests
+        state["change_requests"]
+      end
+
       def stringify_keys(hash)
         return {} unless hash
 

data/lib/aidp/workstream_executor.rb

@@ -156,8 +156,11 @@ module Aidp
         )
 
         # Log error and exit
-        warn("Error in workstream #{slug}: #{e.message}")
-        warn(e.backtrace.first(5).join("\n"))
+        # Suppress backtrace noise during tests while keeping it for production debugging
+        unless ENV["RSPEC_RUNNING"] == "true"
+          warn("Error in workstream #{slug}: #{e.message}")
+          warn(e.backtrace.first(5).join("\n"))
+        end
         exit(1)
       end
 

data/lib/aidp.rb

@@ -93,6 +93,10 @@ require_relative "aidp/harness/state_manager"
 require_relative "aidp/harness/error_handler"
 require_relative "aidp/harness/status_display"
 require_relative "aidp/harness/runner"
+require_relative "aidp/harness/filter_strategy"
+require_relative "aidp/harness/generic_filter_strategy"
+require_relative "aidp/harness/rspec_filter_strategy"
+require_relative "aidp/harness/output_filter"
 
 # UI components
 require_relative "aidp/harness/ui/spinner_helper"

data/templates/aidp.yml.example

@@ -708,6 +708,56 @@ devcontainer:
       # - "api.example.com"
       # - "registry.example.com"
 
+# Watch mode configuration
+# Configures automated monitoring and processing of GitHub issues/PRs
+watch:
+  # Label configuration for different triggers
+  labels:
+    plan_trigger: "aidp-plan"                    # Trigger plan generation
+    needs_input: "aidp-needs-input"              # Request clarification
+    ready_to_build: "aidp-ready"                 # Ready for implementation
+    build_trigger: "aidp-build"                  # Trigger implementation
+    review_trigger: "aidp-review"                # Trigger code review
+    ci_fix_trigger: "aidp-fix-ci"                # Trigger CI fix
+    change_request_trigger: "aidp-request-changes"  # Trigger PR change requests
+
+  # Safety configuration
+  safety:
+    # Allow watch mode on public repositories (default: false for safety)
+    allow_public_repos: false
+
+    # List of GitHub usernames allowed to trigger automated actions
+    # Empty list means all authenticated users (for private repos)
+    author_allowlist: []
+      # - "user1"
+      # - "user2"
+
+    # Require running in a container environment (additional safety)
+    require_container: false
+
+  # PR change request configuration
+  pr_change_requests:
+    # Enable/disable PR change request feature
+    enabled: true
+
+    # Allow changes across multiple files in a single request
+    allow_multi_file_edits: true
+
+    # Run tests and linters before pushing changes
+    # If tests fail, changes are committed locally but not pushed
+    run_tests_before_push: true
+
+    # Prefix for commit messages created by change request processor
+    commit_message_prefix: "aidp: pr-change"
+
+    # Require at least one comment before processing change request
+    # This ensures there's context for what changes are requested
+    require_comment_reference: true
+
+    # Maximum PR diff size (in lines) to process
+    # Large PRs are skipped to avoid overwhelming the AI analysis
+    max_diff_size: 2000
+
 # Configuration tips:
 # - Set max_tokens based on your API plan limits
 # - Use default_flags to customize provider behavior
@@ -724,3 +774,6 @@ devcontainer:
 # - Use time-based configs for different usage patterns
 # - Use step-specific configs for different workflow steps
 # - Use user-specific configs for personalized experiences
+# - Configure watch mode safety settings before using on public repositories
+# - Set author_allowlist to restrict who can trigger automated actions
+# - Adjust max_diff_size based on your typical PR sizes and AI capabilities

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -305,12 +305,16 @@ files:
 - lib/aidp/harness/configuration.rb
 - lib/aidp/harness/enhanced_runner.rb
 - lib/aidp/harness/error_handler.rb
+- lib/aidp/harness/filter_strategy.rb
+- lib/aidp/harness/generic_filter_strategy.rb
+- lib/aidp/harness/output_filter.rb
 - lib/aidp/harness/provider_config.rb
 - lib/aidp/harness/provider_factory.rb
 - lib/aidp/harness/provider_info.rb
 - lib/aidp/harness/provider_manager.rb
 - lib/aidp/harness/provider_metrics.rb
 - lib/aidp/harness/provider_type_checker.rb
+- lib/aidp/harness/rspec_filter_strategy.rb
 - lib/aidp/harness/runner.rb
 - lib/aidp/harness/simple_user_interface.rb
 - lib/aidp/harness/state/errors.rb
@@ -400,6 +404,7 @@ files:
 - lib/aidp/version.rb
 - lib/aidp/watch.rb
 - lib/aidp/watch/build_processor.rb
+- lib/aidp/watch/change_request_processor.rb
 - lib/aidp/watch/ci_fix_processor.rb
 - lib/aidp/watch/plan_generator.rb
 - lib/aidp/watch/plan_processor.rb