aidp 0.33.0 → 0.34.0

data/lib/aidp/watch/hierarchical_pr_strategy.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+
+module Aidp
+  module Watch
+    # Handles hierarchical PR creation strategy for parent and sub-issues.
+    # Parent issues get draft PRs targeting main. Sub-issues get PRs targeting
+    # the parent's branch.
+    class HierarchicalPrStrategy
+      include Aidp::MessageDisplay
+
+      # Labels for hierarchical PR identification
+      PARENT_PR_LABEL = "aidp-parent-pr"
+      SUB_PR_LABEL = "aidp-sub-pr"
+
+      attr_reader :repository_client, :state_store
+
+      def initialize(repository_client:, state_store:)
+        @repository_client = repository_client
+        @state_store = state_store
+      end
+
+      # Determine if an issue is a parent issue (has sub-issues)
+      # @param issue_number [Integer] The issue number
+      # @return [Boolean] True if this is a parent issue
+      def parent_issue?(issue_number)
+        sub_issues = @state_store.sub_issues(issue_number)
+        sub_issues.any?
+      end
+
+      # Determine if an issue is a sub-issue (has a parent)
+      # @param issue_number [Integer] The issue number
+      # @return [Boolean] True if this is a sub-issue
+      def sub_issue?(issue_number)
+        parent = @state_store.parent_issue(issue_number)
+        !parent.nil?
+      end
+
+      # Get PR creation options for an issue based on its hierarchy position
+      # @param issue [Hash] The issue data
+      # @param default_base_branch [String] The default base branch (e.g., "main")
+      # @return [Hash] PR options including :base_branch, :draft, :labels
+      def pr_options_for_issue(issue, default_base_branch:)
+        issue_number = issue[:number]
+        Aidp.log_debug("hierarchical_pr_strategy", "determining_pr_options",
+          issue_number: issue_number, default_base: default_base_branch)
+
+        if parent_issue?(issue_number)
+          parent_pr_options(issue, default_base_branch)
+        elsif sub_issue?(issue_number)
+          sub_issue_pr_options(issue, default_base_branch)
+        else
+          # Regular issue - use default behavior
+          regular_pr_options(issue, default_base_branch)
+        end
+      end
+
+      # Generate branch name for hierarchical issues
+      # @param issue [Hash] The issue data
+      # @return [String] The branch name
+      def branch_name_for(issue)
+        issue_number = issue[:number]
+        slug = issue_slug(issue)
+
+        if parent_issue?(issue_number)
+          # Parent branch: aidp/parent-{number}-{slug}
+          "aidp/parent-#{issue_number}-#{slug}"
+        elsif sub_issue?(issue_number)
+          parent_number = @state_store.parent_issue(issue_number)
+          # Sub-issue branch: aidp/sub-{parent}-{number}-{slug}
+          "aidp/sub-#{parent_number}-#{issue_number}-#{slug}"
+        else
+          # Regular branch: aidp/issue-{number}-{slug}
+          "aidp/issue-#{issue_number}-#{slug}"
+        end
+      end
+
+      # Build PR description with hierarchy context
+      # @param issue [Hash] The issue data
+      # @param plan_summary [String] The plan summary
+      # @return [String] The PR description
+      def pr_description_for(issue, plan_summary:)
+        issue_number = issue[:number]
+
+        if parent_issue?(issue_number)
+          build_parent_pr_description(issue, plan_summary)
+        elsif sub_issue?(issue_number)
+          build_sub_issue_pr_description(issue, plan_summary)
+        else
+          build_regular_pr_description(issue, plan_summary)
+        end
+      end
+
+      # Get the base branch for a sub-issue PR (the parent's branch)
+      # @param issue_number [Integer] The sub-issue number
+      # @return [String, nil] The parent's branch name, or nil if not found
+      def parent_branch_for_sub_issue(issue_number)
+        parent_number = @state_store.parent_issue(issue_number)
+        return nil unless parent_number
+
+        parent_build = @state_store.workstream_for_issue(parent_number)
+        return nil unless parent_build
+
+        parent_build[:branch]
+      end
+
+      private
+
+      def issue_slug(issue)
+        issue[:title].to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")[0, 32]
+      end
+
+      def parent_pr_options(issue, default_base_branch)
+        Aidp.log_debug("hierarchical_pr_strategy", "parent_pr_options",
+          issue_number: issue[:number])
+
+        {
+          base_branch: default_base_branch,
+          draft: true, # Parent PRs always start as draft
+          labels: [PARENT_PR_LABEL],
+          additional_context: build_parent_context(issue)
+        }
+      end
+
+      def sub_issue_pr_options(issue, default_base_branch)
+        issue_number = issue[:number]
+        parent_branch = parent_branch_for_sub_issue(issue_number)
+
+        Aidp.log_debug("hierarchical_pr_strategy", "sub_issue_pr_options",
+          issue_number: issue_number, parent_branch: parent_branch)
+
+        # If parent branch exists, target it; otherwise fall back to default
+        base = parent_branch || default_base_branch
+
+        {
+          base_branch: base,
+          draft: false, # Sub-PRs can be non-draft (will be auto-merged)
+          labels: [SUB_PR_LABEL],
+          additional_context: build_sub_issue_context(issue)
+        }
+      end
+
+      def regular_pr_options(issue, default_base_branch)
+        {
+          base_branch: default_base_branch,
+          draft: true,
+          labels: [],
+          additional_context: nil
+        }
+      end
+
+      def build_parent_context(issue)
+        issue_number = issue[:number]
+        sub_issues = @state_store.sub_issues(issue_number)
+
+        return nil if sub_issues.empty?
+
+        lines = []
+        lines << "### Sub-Issues"
+        lines << ""
+        lines << "This parent PR aggregates the following sub-issues:"
+        lines << ""
+
+        sub_issues.each do |sub_number|
+          sub_build = @state_store.workstream_for_issue(sub_number)
+          pr_link = sub_build&.dig(:pr_url) ? sub_build[:pr_url] : "_(PR pending)_"
+          lines << "- ##{sub_number}: #{pr_link}"
+        end
+
+        lines << ""
+        lines << "**Note:** This PR will be ready for review once all sub-issue PRs are merged."
+        lines.join("\n")
+      end
+
+      def build_sub_issue_context(issue)
+        issue_number = issue[:number]
+        parent_number = @state_store.parent_issue(issue_number)
+
+        return nil unless parent_number
+
+        parent_build = @state_store.workstream_for_issue(parent_number)
+
+        lines = []
+        lines << "### Parent Issue"
+        lines << ""
+        lines << "This PR implements a sub-issue of ##{parent_number}."
+        lines << ""
+
+        pr_link = parent_build&.dig(:pr_url) || "_(pending)_"
+        lines << "**Parent PR:** #{pr_link}"
+
+        lines << ""
+        lines << "This sub-issue PR will be automatically merged when CI passes."
+        lines.join("\n")
+      end
+
+      def build_parent_pr_description(issue, plan_summary)
+        issue_number = issue[:number]
+        sub_context = build_parent_context(issue)
+
+        parts = []
+        parts << "Implements ##{issue_number}"
+        parts << ""
+        parts << "## Summary"
+        parts << plan_summary
+        parts << ""
+
+        if sub_context
+          parts << sub_context
+          parts << ""
+        end
+
+        parts << "---"
+        parts << "_This is a parent PR that aggregates changes from sub-issue PRs._"
+        parts << "_It requires human review before merging to the main branch._"
+
+        parts.join("\n")
+      end
+
+      def build_sub_issue_pr_description(issue, plan_summary)
+        issue_number = issue[:number]
+        sub_context = build_sub_issue_context(issue)
+
+        parts = []
+        parts << "Fixes ##{issue_number}"
+        parts << ""
+        parts << "## Summary"
+        parts << plan_summary
+        parts << ""
+
+        if sub_context
+          parts << sub_context
+          parts << ""
+        end
+
+        parts << "---"
+        parts << "_This is a sub-issue PR that will be auto-merged when CI passes._"
+
+        parts.join("\n")
+      end
+
+      def build_regular_pr_description(issue, plan_summary)
+        <<~DESCRIPTION
+          Fixes ##{issue[:number]}
+
+          ## Summary
+          #{plan_summary}
+
+          ---
+          _Automated implementation by AIDP._
+        DESCRIPTION
+      end
+    end
+  end
+end

data/lib/aidp/watch/implementation_verifier.rb

@@ -19,6 +19,9 @@ module Aidp
 
       # Verify implementation against issue requirements
       # Returns: { verified: true/false, reason: String, missing_items: Array }
+      #
+      # FIX for issue #391: Enhanced verification to require substantive code changes
+      # Rejects implementations that only contain documentation changes
       def verify(issue:, working_dir:)
         Aidp.log_debug("implementation_verifier", "starting_verification", issue: issue[:number], working_dir: working_dir)
 
@@ -28,6 +31,24 @@ module Aidp
         issue_requirements = extract_issue_requirements(issue)
         implementation_changes = extract_implementation_changes(working_dir)
 
+        # FIX for issue #391: Check for substantive changes before ZFC verification
+        substantive_check = verify_substantive_changes(implementation_changes, working_dir)
+        unless substantive_check[:has_substantive_changes]
+          Aidp.log_warn(
+            "implementation_verifier",
+            "no_substantive_changes",
+            issue: issue[:number],
+            reason: substantive_check[:reason]
+          )
+
+          return {
+            verified: false,
+            reason: substantive_check[:reason],
+            missing_items: ["Substantive code changes required - only documentation/config changes detected"],
+            additional_work: ["Implement the actual code changes described in the issue"]
+          }
+        end
+
         # Use ZFC to verify completeness
         result = perform_zfc_verification(
           issue_number: issue[:number],
@@ -78,7 +99,10 @@ module Aidp
 
           unless status.success?
             Aidp.log_warn("implementation_verifier", "git_diff_failed", working_dir: working_dir)
-            return "Unable to extract changes: git diff failed"
+            return {
+              diff: "",
+              files_changed: "Unable to extract changes: git diff failed"
+            }
           end
 
           # Get list of changed files with stats
@@ -119,6 +143,123 @@ module Aidp
         end || "main"
       end
 
+      # FIX for issue #391: Verify that implementation includes substantive code changes
+      # Rejects changes that only include documentation, config, or non-code files
+      # Note: If no files changed, we defer to ZFC verification (which handles empty implementations)
+      def verify_substantive_changes(implementation_changes, working_dir)
+        files_changed = implementation_changes[:files_changed] || ""
+        diff = implementation_changes[:diff] || ""
+
+        # Extract file names from the files changed summary
+        changed_files = extract_changed_file_names(files_changed)
+
+        Aidp.log_debug("implementation_verifier", "checking_substantive_changes",
+          total_files: changed_files.size,
+          files: changed_files.take(10))
+
+        # No changes at all - defer to ZFC verification for proper handling
+        # ZFC will determine if an empty implementation is valid for the issue
+        if changed_files.empty?
+          Aidp.log_debug("implementation_verifier", "no_files_changed_deferring_to_zfc")
+          return {
+            has_substantive_changes: true,  # Allow ZFC to make the determination
+            reason: "No files changed - deferring to ZFC verification"
+          }
+        end
+
+        # Categorize files
+        code_files = []
+        test_files = []
+        doc_files = []
+        config_files = []
+        other_files = []
+
+        changed_files.each do |file|
+          case file
+          when /\.(rb|py|js|ts|jsx|tsx|go|rs|java|kt|swift|c|cpp|h|hpp|cs)$/i
+            if /(_spec|_test|\.spec|\.test|\/spec\/|\/test\/)/i.match?(file)
+              test_files << file
+            else
+              code_files << file
+            end
+          # Only clearly documentation files - not .txt which could be anything
+          when /\.(md|rst|adoc|rdoc)$/i, /^README/i, /^CHANGELOG/i, /^LICENSE/i
+            doc_files << file
+          when /\.(yml|yaml|json|toml|ini|env|config)$/i, /\.gitignore$/, /Gemfile/, /package\.json/
+            config_files << file
+          else
+            other_files << file
+          end
+        end
+
+        Aidp.log_debug("implementation_verifier", "file_categorization",
+          code_files: code_files.size,
+          test_files: test_files.size,
+          doc_files: doc_files.size,
+          config_files: config_files.size,
+          other_files: other_files.size)
+
+        # Check if there are substantive code changes
+        # Substantive means: actual code files changed, not just docs/config
+        # Note: "other" files (unknown extensions) are allowed through to ZFC for proper evaluation
+        if code_files.empty? && test_files.empty? && other_files.empty?
+          if doc_files.any? && config_files.empty?
+            return {
+              has_substantive_changes: false,
+              reason: "Only documentation files were changed (#{doc_files.join(", ")}). " \
+                     "Implementation requires code changes."
+            }
+          elsif config_files.any? && doc_files.empty?
+            return {
+              has_substantive_changes: false,
+              reason: "Only configuration files were changed (#{config_files.join(", ")}). " \
+                     "Implementation requires code changes."
+            }
+          elsif doc_files.any? || config_files.any?
+            return {
+              has_substantive_changes: false,
+              reason: "Only documentation and configuration files were changed. " \
+                     "Implementation requires code changes."
+            }
+          end
+        end
+
+        # If only test files changed, that's potentially valid for test-related issues
+        # but we should flag it for issues that require implementation
+        if code_files.empty? && test_files.any?
+          # This is acceptable but worth noting
+          Aidp.log_debug("implementation_verifier", "only_test_files_changed",
+            test_files: test_files)
+        end
+
+        # Check diff size - very small diffs might be insignificant
+        if diff.bytesize < 100 && code_files.any?
+          return {
+            has_substantive_changes: false,
+            reason: "Code changes are too minimal (#{diff.bytesize} bytes). " \
+                   "Please implement the required functionality fully."
+          }
+        end
+
+        {
+          has_substantive_changes: true,
+          reason: "Found #{code_files.size} code files and #{test_files.size} test files changed"
+        }
+      end
+
+      def extract_changed_file_names(files_changed_summary)
+        return [] if files_changed_summary.nil? || files_changed_summary.empty?
+
+        # Parse git diff --stat output format:
+        # lib/aidp/foo.rb | 10 +++++-----
+        # docs/README.md  |  3 +++
+        files_changed_summary.lines.map do |line|
+          # Extract filename from diff --stat format
+          match = line.match(/^\s*([^\s|]+)\s*\|/)
+          match ? match[1].strip : nil
+        end.compact.reject(&:empty?)
+      end
+
       def perform_zfc_verification(issue_number:, issue_requirements:, implementation_changes:)
         # Check if AI decision engine is available
         unless @ai_decision_engine

data/lib/aidp/watch/plan_generator.rb

@@ -26,13 +26,50 @@ module Aidp
         Focus on concrete engineering tasks. Ensure questions are actionable.
       PROMPT
 
-      def initialize(provider_name: nil, verbose: false)
+      HIERARCHICAL_PROVIDER_PROMPT = <<~PROMPT
+        You are AIDP's planning specialist for large projects. Read the GitHub issue and existing comments.
+        This is a LARGE project that should be broken down into independent sub-issues.
+
+        Analyze the requirements and break them into logical sub-tasks that can be worked on independently.
+        For each sub-task, identify:
+        1. What should be built (clear, focused scope)
+        2. What skills are required (e.g., "GraphQL API", "React Components", "Database Schema")
+        3. What personas should work on it (e.g., "Backend Engineer", "Frontend Developer")
+        4. What dependencies exist (which other sub-tasks must complete first)
+
+        Respond in JSON with the following shape (no extra text, no code fences):
+        {
+          "plan_summary": "one paragraph summary of the overall project",
+          "should_create_sub_issues": true,
+          "sub_issues": [
+            {
+              "title": "Brief title for the sub-issue",
+              "description": "Detailed description of what needs to be built",
+              "tasks": ["Specific task 1", "Specific task 2"],
+              "skills": ["Skill 1", "Skill 2"],
+              "personas": ["Persona 1"],
+              "dependencies": ["Reference to other sub-issue by title if needed"]
+            }
+          ],
+          "clarifying_questions": ["question 1", "question 2"]
+        }
+
+        Guidelines:
+        - Each sub-issue should be independently testable and deliverable
+        - Sub-issues should be sized for 1-3 days of work
+        - Include 3-8 sub-issues for a large project
+        - Be specific about skills needed (avoid generic terms)
+        - Only create sub-issues if the project truly warrants it (complexity, multiple components, etc.)
+      PROMPT
+
+      def initialize(provider_name: nil, verbose: false, hierarchical: false)
         @provider_name = provider_name
         @verbose = verbose
+        @hierarchical = hierarchical
         @providers_attempted = []
       end
 
-      def generate(issue)
+      def generate(issue, hierarchical: @hierarchical)
         Aidp.log_debug("plan_generator", "generate.start", provider: @provider_name, issue: issue[:number])
 
         # Try providers in fallback chain order
@@ -52,8 +89,8 @@ module Aidp
           end
 
           begin
-            Aidp.log_info("plan_generator", "generate_with_provider", provider: provider_name, issue: issue[:number])
-            result = generate_with_provider(provider, issue, provider_name)
+            Aidp.log_info("plan_generator", "generate_with_provider", provider: provider_name, issue: issue[:number], hierarchical: hierarchical)
+            result = generate_with_provider(provider, issue, provider_name, hierarchical: hierarchical)
             if result
               Aidp.log_info("plan_generator", "generation_success", provider: provider_name, issue: issue[:number])
               return result
@@ -137,10 +174,10 @@ module Aidp
         "cursor"
       end
 
-      def generate_with_provider(provider, issue, provider_name = "unknown")
-        payload = build_prompt(issue)
+      def generate_with_provider(provider, issue, provider_name = "unknown", hierarchical: false)
+        payload = build_prompt(issue, hierarchical: hierarchical)
 
-        Aidp.log_debug("plan_generator", "sending_to_provider", provider: provider_name, prompt_length: payload.length)
+        Aidp.log_debug("plan_generator", "sending_to_provider", provider: provider_name, prompt_length: payload.length, hierarchical: hierarchical)
 
         if @verbose
           display_message("\n--- Plan Generation Prompt ---", type: :muted)
@@ -158,10 +195,10 @@ module Aidp
           display_message("--- End Response ---\n", type: :muted)
         end
 
-        parsed = parse_structured_response(response)
+        parsed = parse_structured_response(response, hierarchical: hierarchical)
 
         if parsed
-          Aidp.log_debug("plan_generator", "response_parsed", provider: provider_name, has_summary: !parsed[:summary].to_s.empty?, tasks_count: parsed[:tasks]&.size || 0)
+          Aidp.log_debug("plan_generator", "response_parsed", provider: provider_name, has_summary: !parsed[:summary].to_s.empty?, tasks_count: parsed[:tasks]&.size || 0, sub_issues_count: parsed[:sub_issues]&.size || 0)
           return parsed
         end
 
@@ -170,7 +207,7 @@ module Aidp
         nil
       end
 
-      def build_prompt(issue)
+      def build_prompt(issue, hierarchical: false)
         comments_text = issue[:comments]
           .sort_by { |comment| comment["createdAt"].to_s }
           .map do |comment|
@@ -180,8 +217,10 @@ module Aidp
           end
           .join("\n\n")
 
+        prompt_template = hierarchical ? HIERARCHICAL_PROVIDER_PROMPT : PROVIDER_PROMPT
+
         <<~PROMPT
-          #{PROVIDER_PROMPT}
+          #{prompt_template}
 
           Issue Title: #{issue[:title]}
           Issue URL: #{issue[:url]}
@@ -194,17 +233,35 @@ module Aidp
         PROMPT
       end
 
-      def parse_structured_response(response)
+      def parse_structured_response(response, hierarchical: false)
         text = response.to_s.strip
         candidate = extract_json_payload(text)
         return nil unless candidate
 
         data = JSON.parse(candidate)
-        {
+
+        result = {
           summary: data["plan_summary"].to_s.strip,
           tasks: Array(data["plan_tasks"]).map(&:to_s),
           questions: Array(data["clarifying_questions"]).map(&:to_s)
         }
+
+        # Add hierarchical planning data if present
+        if hierarchical || data["should_create_sub_issues"]
+          result[:should_create_sub_issues] = data["should_create_sub_issues"] || false
+          result[:sub_issues] = Array(data["sub_issues"]).map do |sub|
+            {
+              title: sub["title"].to_s,
+              description: sub["description"].to_s,
+              tasks: Array(sub["tasks"]).map(&:to_s),
+              skills: Array(sub["skills"]).map(&:to_s),
+              personas: Array(sub["personas"]).map(&:to_s),
+              dependencies: Array(sub["dependencies"]).map(&:to_s)
+            }
+          end
+        end
+
+        result
       rescue JSON::ParserError
         nil
       end

data/lib/aidp/watch/plan_processor.rb

@@ -3,6 +3,7 @@
 require_relative "../message_display"
 require_relative "plan_generator"
 require_relative "state_store"
+require_relative "feedback_collector"
 
 module Aidp
   module Watch
@@ -59,29 +60,35 @@ module Aidp
         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)
+        comment_body_with_feedback = FeedbackCollector.append_feedback_prompt(comment_body)
+        comment_id = nil
 
         if existing_plan && existing_plan["comment_id"]
           # Update existing comment
-          @repository_client.update_comment(existing_plan["comment_id"], comment_body)
+          @repository_client.update_comment(existing_plan["comment_id"], comment_body_with_feedback)
+          comment_id = existing_plan["comment_id"]
           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)
+            @repository_client.update_comment(existing_comment[:id], comment_body_with_feedback)
+            comment_id = existing_comment[:id]
             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)
+            result = @repository_client.post_comment(number, comment_body_with_feedback)
+            comment_id = result[:id] if result.is_a?(Hash)
             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)
+          result = @repository_client.post_comment(number, comment_body_with_feedback)
+          comment_id = result[:id] if result.is_a?(Hash)
           display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         end
 
+        plan_data = plan_data.merge(comment_id: comment_id) if comment_id
         @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