aidp 0.27.0 → 0.28.0

data/lib/aidp/watch/runner.rb

@@ -6,6 +6,7 @@ require_relative "../message_display"
 require_relative "repository_client"
 require_relative "repository_safety_checker"
 require_relative "state_store"
+require_relative "github_state_extractor"
 require_relative "plan_generator"
 require_relative "plan_processor"
 require_relative "build_processor"
@@ -40,10 +41,21 @@ module Aidp
           config: safety_config
         )
         @state_store = StateStore.new(project_dir: project_dir, repository: "#{owner}/#{repo}")
+        @state_extractor = GitHubStateExtractor.new(repository_client: @repository_client)
 
         # Extract label configuration from safety_config (it's actually the full watch config)
         label_config = safety_config[:labels] || safety_config["labels"] || {}
 
+        # Extract detection comment configuration (issue #280)
+        # Enabled by default, can be disabled in config
+        @post_detection_comments = if safety_config.key?(:post_detection_comments)
+          safety_config[:post_detection_comments]
+        elsif safety_config.key?("post_detection_comments")
+          safety_config["post_detection_comments"]
+        else
+          true # Enabled by default
+        end
+
         @plan_processor = PlanProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
@@ -138,7 +150,12 @@ module Aidp
 
       def process_plan_triggers
         plan_label = @plan_processor.plan_label
-        issues = @repository_client.list_issues(labels: [plan_label], state: "open")
+        begin
+          issues = @repository_client.list_issues(labels: [plan_label], state: "open")
+        rescue => e
+          Aidp.log_error("watch_runner", "plan_poll_failed", label: plan_label, error: e.message)
+          return # Skip this cycle, continue watch loop
+        end
         Aidp.log_debug("watch_runner", "plan_poll", label: plan_label, total: issues.size)
         issues.each do |issue|
           unless issue_has_label?(issue, plan_label)
@@ -146,7 +163,18 @@ module Aidp
             next
           end
 
-          detailed = @repository_client.fetch_issue(issue[:number])
+          begin
+            detailed = @repository_client.fetch_issue(issue[:number])
+          rescue => e
+            Aidp.log_error("watch_runner", "fetch_issue_failed", issue: issue[:number], error: e.message)
+            next # Skip this issue, continue with others
+          end
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "plan_skip_in_progress", issue: detailed[:number])
+            next
+          end
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
@@ -154,6 +182,11 @@ module Aidp
             next
           end
 
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, plan_label)
+            post_detection_comment(item_type: :issue, number: detailed[:number], label: plan_label)
+          end
+
           Aidp.log_debug("watch_runner", "plan_process", issue: detailed[:number])
           @plan_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
@@ -163,38 +196,82 @@ module Aidp
 
       def process_build_triggers
         build_label = @build_processor.build_label
-        issues = @repository_client.list_issues(labels: [build_label], state: "open")
+        begin
+          issues = @repository_client.list_issues(labels: [build_label], state: "open")
+        rescue => e
+          Aidp.log_error("watch_runner", "build_poll_failed", label: build_label, error: e.message)
+          return # Skip this cycle, continue watch loop
+        end
         Aidp.log_debug("watch_runner", "build_poll", label: build_label, total: issues.size)
         issues.each do |issue|
-          unless issue_has_label?(issue, build_label)
-            Aidp.log_debug("watch_runner", "build_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
-            next
+          detailed = nil
+          in_progress_added = false
+
+          begin
+            unless issue_has_label?(issue, build_label)
+              Aidp.log_debug("watch_runner", "build_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+              next
+            end
+
+            begin
+              detailed = @repository_client.fetch_issue(issue[:number])
+            rescue => e
+              Aidp.log_error("watch_runner", "fetch_issue_failed", issue: issue[:number], error: e.message)
+              next # Skip this issue, continue with others
+            end
+
+            # Check if already completed (via GitHub comments)
+            if @state_extractor.build_completed?(detailed)
+              Aidp.log_debug("watch_runner", "build_skip_completed", issue: detailed[:number])
+              next
+            end
+
+            # Check if already in progress by another instance
+            if @state_extractor.in_progress?(detailed)
+              Aidp.log_debug("watch_runner", "build_skip_in_progress", issue: detailed[:number])
+              next
+            end
+
+            # 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])
+              next
+            end
+
+            # Check if detection comment already posted (deduplication)
+            unless @state_extractor.detection_comment_posted?(detailed, build_label)
+              post_detection_comment(item_type: :issue, number: detailed[:number], label: build_label)
+            end
+
+            # Add in-progress label before processing
+            @repository_client.add_labels(detailed[:number], GitHubStateExtractor::IN_PROGRESS_LABEL)
+            in_progress_added = true
+
+            Aidp.log_debug("watch_runner", "build_process", issue: detailed[:number])
+            @build_processor.process(detailed)
+          rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+            Aidp.log_warn("watch_runner", "unauthorized issue author", issue: issue[:number], error: e.message)
+          ensure
+            # Remove in-progress label when done (only if we added it)
+            if in_progress_added && detailed
+              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)
+              end
+            end
           end
-
-          status = @state_store.build_status(issue[:number])
-          if status["status"] == "completed"
-            Aidp.log_debug("watch_runner", "build_skip_completed", issue: issue[:number])
-            next
-          end
-
-          detailed = @repository_client.fetch_issue(issue[:number])
-
-          # 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])
-            next
-          end
-
-          Aidp.log_debug("watch_runner", "build_process", issue: detailed[:number])
-          @build_processor.process(detailed)
-        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
-          Aidp.log_warn("watch_runner", "unauthorized issue author", issue: issue[:number], error: e.message)
         end
       end
 
       def process_review_triggers
         review_label = @review_processor.review_label
-        prs = @repository_client.list_pull_requests(labels: [review_label], state: "open")
+        begin
+          prs = @repository_client.list_pull_requests(labels: [review_label], state: "open")
+        rescue => e
+          Aidp.log_error("watch_runner", "review_poll_failed", label: review_label, error: e.message)
+          return # Skip this cycle, continue watch loop
+        end
         Aidp.log_debug("watch_runner", "review_poll", label: review_label, total: prs.size)
         prs.each do |pr|
           unless pr_has_label?(pr, review_label)
@@ -202,7 +279,18 @@ module Aidp
             next
           end
 
-          detailed = @repository_client.fetch_pull_request(pr[:number])
+          begin
+            detailed = @repository_client.fetch_pull_request(pr[:number])
+          rescue => e
+            Aidp.log_error("watch_runner", "fetch_pr_failed", pr: pr[:number], error: e.message)
+            next # Skip this PR, continue with others
+          end
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "review_skip_in_progress", pr: detailed[:number])
+            next
+          end
 
           # Check author authorization before processing
           unless @safety_checker.should_process_issue?(detailed, enforce: false)
@@ -210,6 +298,11 @@ module Aidp
             next
           end
 
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, review_label)
+            post_detection_comment(item_type: :pr, number: detailed[:number], label: review_label)
+          end
+
           Aidp.log_debug("watch_runner", "review_process", pr: detailed[:number])
           @review_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
@@ -229,12 +322,23 @@ module Aidp
 
           detailed = @repository_client.fetch_pull_request(pr[:number])
 
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "ci_fix_skip_in_progress", pr: detailed[:number])
+            next
+          end
+
           # 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])
             next
           end
 
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, ci_fix_label)
+            post_detection_comment(item_type: :pr, number: detailed[:number], label: ci_fix_label)
+          end
+
           Aidp.log_debug("watch_runner", "ci_fix_process", pr: detailed[:number])
           @ci_fix_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
@@ -254,12 +358,23 @@ module Aidp
 
           detailed = @repository_client.fetch_pull_request(pr[:number])
 
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "change_request_skip_in_progress", pr: detailed[:number])
+            next
+          end
+
           # 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
 
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, change_request_label)
+            post_detection_comment(item_type: :pr, number: detailed[:number], label: change_request_label)
+          end
+
           Aidp.log_debug("watch_runner", "change_request_process", pr: detailed[:number])
           @change_request_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
@@ -269,7 +384,7 @@ module Aidp
 
       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
+          name = (issue_label.is_a?(Hash) ? issue_label["name"] : issue_label.to_s)
           name.casecmp(label).zero?
         end
       end
@@ -371,9 +486,46 @@ module Aidp
         {}
       end
 
+      # Post detection comment to GitHub when aidp picks up a labeled item (issue #280)
+      # @param item_type [Symbol] Type of item (:issue or :pr)
+      # @param number [Integer] Issue or PR number
+      # @param label [String] Label that triggered detection
+      def post_detection_comment(item_type:, number:, label:)
+        return unless @post_detection_comments
+
+        # Check if we've already posted a detection comment for this item/label combination
+        detection_key = "#{item_type}_#{number}_#{label}"
+        return if @state_store.detection_comment_posted?(detection_key)
+
+        timestamp = Time.now.utc.iso8601
+        item_name = (item_type == :pr) ? "PR" : "issue"
+
+        comment_body = "aidp detected `#{label}` at #{timestamp} and is working on it"
+
+        begin
+          @repository_client.post_comment(number, comment_body)
+          @state_store.record_detection_comment(detection_key, timestamp: timestamp)
+
+          Aidp.log_info("watch_runner", "detection_comment_posted",
+            item_type: item_type,
+            number: number,
+            label: label,
+            timestamp: timestamp)
+
+          display_message("💬 Posted detection comment for #{item_name} ##{number}", type: :info) if @verbose
+        rescue => e
+          # Don't fail processing if comment posting fails - just log it
+          Aidp.log_warn("watch_runner", "detection_comment_failed",
+            item_type: item_type,
+            number: number,
+            label: label,
+            error: e.message)
+        end
+      end
+
       def pr_has_label?(pr, label)
         Array(pr[:labels]).any? do |pr_label|
-          name = pr_label.is_a?(Hash) ? pr_label["name"] : pr_label.to_s
+          name = (pr_label.is_a?(Hash) ? pr_label["name"] : pr_label.to_s)
           name.casecmp(label).zero?
         end
       end

data/lib/aidp/watch/state_store.rb

@@ -124,7 +124,10 @@ module Aidp
           "changes_applied" => data[:changes_applied],
           "commits" => data[:commits],
           "reason" => data[:reason],
-          "clarification_count" => data[:clarification_count]
+          "clarification_count" => data[:clarification_count],
+          "verification_reasons" => data[:verification_reasons],
+          "missing_items" => data[:missing_items],
+          "additional_work" => data[:additional_work]
         }.compact
 
         change_requests[pr_number.to_s] = payload
@@ -136,6 +139,19 @@ module Aidp
         save!
       end
 
+      # Detection comment tracking methods (issue #280)
+      def detection_comment_posted?(detection_key)
+        detection_comments.key?(detection_key.to_s)
+      end
+
+      def record_detection_comment(detection_key, timestamp:)
+        detection_comments[detection_key.to_s] = {
+          "timestamp" => timestamp,
+          "posted_at" => Time.now.utc.iso8601
+        }
+        save!
+      end
+
       private
 
       def ensure_directory
@@ -167,6 +183,7 @@ module Aidp
           base["reviews"] ||= {}
           base["ci_fixes"] ||= {}
           base["change_requests"] ||= {}
+          base["detection_comments"] ||= {}
           base
         end
       end
@@ -191,6 +208,10 @@ module Aidp
         state["change_requests"]
       end
 
+      def detection_comments
+        state["detection_comments"]
+      end
+
       def stringify_keys(hash)
         return {} unless hash
 

data/lib/aidp/workflows/definitions.rb

@@ -165,6 +165,26 @@ module Aidp
           ]
         },
 
+        tdd_feature_development: {
+          name: "TDD Feature Development",
+          description: "Test-driven development with tests written first",
+          icon: "🧪",
+          details: [
+            "Product requirements",
+            "Architecture design",
+            "TDD test specifications (write tests FIRST)",
+            "RED: Tests fail initially",
+            "GREEN: Implement to pass tests",
+            "REFACTOR: Improve with confidence"
+          ],
+          steps: [
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "17_TDD_SPECIFICATION",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
         production_ready: {
           name: "Production-Ready",
           description: "Enterprise-grade with NFRs and compliance",
@@ -227,6 +247,133 @@ module Aidp
           ]
         },
 
+        waterfall_standard: {
+          name: "Waterfall Planning",
+          description: "Structured project planning with WBS and Gantt charts",
+          icon: "📊",
+          details: [
+            "Documentation ingestion or generation",
+            "Work breakdown structure (WBS)",
+            "Gantt chart with critical path",
+            "Task dependencies and milestones",
+            "Persona/agent assignment",
+            "Complete project plan"
+          ],
+          steps: [
+            "22_PLANNING_MODE_INIT",
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "18_WBS",
+            "19_GANTT_CHART",
+            "20_PERSONA_ASSIGNMENT",
+            "21_PROJECT_PLAN_ASSEMBLY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        waterfall_minimal: {
+          name: "Waterfall Planning (Minimal)",
+          description: "Quick waterfall planning without full enterprise features",
+          icon: "📋",
+          details: [
+            "Essential documentation",
+            "Basic work breakdown",
+            "Simple Gantt chart",
+            "Task list with dependencies"
+          ],
+          steps: [
+            "22_PLANNING_MODE_INIT",
+            "00_PRD",
+            "18_WBS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        waterfall_tdd: {
+          name: "Waterfall Planning with TDD",
+          description: "Waterfall planning with test-driven development",
+          icon: "📊🧪",
+          details: [
+            "Complete waterfall planning",
+            "Work breakdown structure",
+            "Gantt chart with critical path",
+            "TDD test specifications (write tests first)",
+            "Test-driven implementation",
+            "Persona assignments"
+          ],
+          steps: [
+            "22_PLANNING_MODE_INIT",
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "18_WBS",
+            "19_GANTT_CHART",
+            "17_TDD_SPECIFICATION",
+            "20_PERSONA_ASSIGNMENT",
+            "21_PROJECT_PLAN_ASSEMBLY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        agile_mvp: {
+          name: "Agile MVP Planning",
+          description: "Plan MVP with user testing and marketing",
+          icon: "🚀",
+          details: [
+            "MVP scope definition (must-have vs nice-to-have)",
+            "User testing plan with surveys and interviews",
+            "Marketing materials and messaging",
+            "Timeline with Gantt chart",
+            "Persona assignments"
+          ],
+          steps: [
+            "00_PRD",
+            "23_MVP_SCOPE",
+            "24_USER_TEST_PLAN",
+            "25_MARKETING_REPORT",
+            "19_GANTT_CHART",
+            "20_PERSONA_ASSIGNMENT",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        agile_iteration: {
+          name: "Agile Iteration Planning",
+          description: "Plan next iteration based on user feedback",
+          icon: "🔄",
+          details: [
+            "Ingest user feedback data (CSV/JSON/markdown)",
+            "AI-powered feedback analysis",
+            "Next iteration plan with tasks",
+            "Timeline with Gantt chart",
+            "Persona assignments"
+          ],
+          steps: [
+            "26_INGEST_FEEDBACK",
+            "27_ANALYZE_FEEDBACK",
+            "28_ITERATION_PLAN",
+            "19_GANTT_CHART",
+            "20_PERSONA_ASSIGNMENT",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        agile_legacy_research: {
+          name: "Legacy Product Research",
+          description: "Plan user research for existing codebase",
+          icon: "🔍",
+          details: [
+            "Codebase analysis to identify features",
+            "User research plan generation",
+            "User testing plan with priorities",
+            "Improvement recommendations"
+          ],
+          steps: [
+            "29_LEGACY_RESEARCH_PLAN",
+            "24_USER_TEST_PLAN",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
         custom: {
           name: "Custom Workflow",
           description: "Choose specific planning and implementation steps",