aidp 0.32.0 → 0.33.0

data/lib/aidp/tooling_detector.rb

@@ -3,23 +3,108 @@
 module Aidp
   # Detect basic project tooling to seed work loop test & lint commands.
   # Lightweight heuristic pass – prefers safety over guessing incorrectly.
+  # Provides framework-aware command suggestions with optimal flags for output filtering.
   class ToolingDetector
     DETECTORS = [
       :ruby_bundle,
       :rspec,
+      :minitest,
       :ruby_standardrb,
       :node_jest,
       :node_mocha,
       :node_eslint,
-      :python_pytest
+      :python_pytest,
+      :python_ruff
     ].freeze
 
-    Result = Struct.new(:test_commands, :lint_commands, keyword_init: true)
+    # Framework identifiers for output filtering
+    FRAMEWORKS = {
+      rspec: :rspec,
+      minitest: :minitest,
+      jest: :jest,
+      mocha: :jest, # Mocha uses similar output format
+      pytest: :pytest
+    }.freeze
+
+    # Enhanced result with framework information
+    Result = Struct.new(:test_commands, :lint_commands, :formatter_commands,
+      :frameworks, keyword_init: true) do
+      # Get test commands with their detected framework
+      def test_command_frameworks
+        @test_command_frameworks ||= {}
+      end
+
+      # Get the framework for a specific command
+      def framework_for_command(command)
+        test_command_frameworks[command] || :unknown
+      end
+    end
+
+    # Information about a detected command
+    CommandInfo = Struct.new(:command, :framework, :flags, keyword_init: true)
 
     def self.detect(root = Dir.pwd)
       new(root).detect
     end
 
+    # Detect framework from a command string
+    # @param command [String] Command to analyze
+    # @return [Symbol] Framework identifier (:rspec, :minitest, :jest, :pytest, :unknown)
+    def self.framework_from_command(command)
+      return :unknown unless command.is_a?(String)
+
+      case command.downcase
+      when /\brspec\b/
+        :rspec
+      when /\bminitest\b/, /\bruby.*test/, /\brake test\b/
+        :minitest
+      when /\bjest\b/, /\bmocha\b/
+        :jest
+      when /\bpytest\b/
+        :pytest
+      else
+        :unknown
+      end
+    end
+
+    # Get recommended command flags for better output filtering
+    # @param framework [Symbol] Framework identifier
+    # @return [Hash] Recommended flags for different verbosity modes
+    def self.recommended_flags(framework)
+      case framework
+      when :rspec
+        {
+          standard: "--format progress",
+          verbose: "--format documentation",
+          failures_only: "--format failures --format progress"
+        }
+      when :minitest
+        {
+          standard: "",
+          verbose: "-v",
+          failures_only: ""
+        }
+      when :jest
+        {
+          standard: "",
+          verbose: "--verbose",
+          failures_only: "--reporters=default --silent=false"
+        }
+      when :pytest
+        {
+          standard: "-q",
+          verbose: "-v",
+          failures_only: "-q --tb=short"
+        }
+      else
+        {
+          standard: "",
+          verbose: "",
+          failures_only: ""
+        }
+      end
+    end
+
     def initialize(root = Dir.pwd)
       @root = root
     end
@@ -27,34 +112,143 @@ module Aidp
     def detect
       tests = []
       linters = []
+      formatters = []
+      frameworks = {}
+
+      detect_ruby_tools(tests, linters, formatters, frameworks)
+      detect_node_tools(tests, linters, formatters, frameworks)
+      detect_python_tools(tests, linters, formatters, frameworks)
+
+      result = Result.new(
+        test_commands: tests.uniq,
+        lint_commands: linters.uniq,
+        formatter_commands: formatters.uniq,
+        frameworks: frameworks
+      )
+
+      # Store framework mappings in the result
+      frameworks.each do |cmd, framework|
+        result.test_command_frameworks[cmd] = framework
+      end
+
+      result
+    end
+
+    # Get detailed command information including framework and suggested flags
+    # @return [Array<CommandInfo>] Detailed information about detected commands
+    def detect_with_details
+      commands = []
 
       if ruby_project?
-        tests << bundle_prefix("rspec") if rspec?
-        linters << bundle_prefix("standardrb") if standard_rb?
+        if rspec?
+          commands << CommandInfo.new(
+            command: bundle_prefix("rspec"),
+            framework: :rspec,
+            flags: self.class.recommended_flags(:rspec)
+          )
+        end
+
+        if minitest?
+          commands << CommandInfo.new(
+            command: bundle_prefix("ruby -Itest test"),
+            framework: :minitest,
+            flags: self.class.recommended_flags(:minitest)
+          )
+        end
       end
 
       if node_project?
-        tests << npm_or_yarn("test") if package_script?("test")
-        %w[lint eslint].each do |script|
-          if package_script?(script)
-            linters << npm_or_yarn(script)
-            break
-          end
+        if jest?
+          commands << CommandInfo.new(
+            command: npm_or_yarn("test"),
+            framework: :jest,
+            flags: self.class.recommended_flags(:jest)
+          )
         end
       end
 
       if python_pytest?
-        tests << "pytest -q"
+        commands << CommandInfo.new(
+          command: "pytest",
+          framework: :pytest,
+          flags: self.class.recommended_flags(:pytest)
+        )
       end
 
-      Result.new(
-        test_commands: tests.uniq,
-        lint_commands: linters.uniq
-      )
+      commands
     end
 
     private
 
+    def detect_ruby_tools(tests, linters, formatters, frameworks)
+      return unless ruby_project?
+
+      if rspec?
+        cmd = bundle_prefix("rspec")
+        tests << cmd
+        frameworks[cmd] = :rspec
+      end
+
+      if minitest?
+        cmd = bundle_prefix("ruby -Itest test")
+        tests << cmd
+        frameworks[cmd] = :minitest
+      end
+
+      if standard_rb?
+        linters << bundle_prefix("standardrb")
+        formatters << bundle_prefix("standardrb --fix")
+      end
+
+      if rubocop?
+        linters << bundle_prefix("rubocop") unless standard_rb?
+        formatters << bundle_prefix("rubocop -A") unless standard_rb?
+      end
+    end
+
+    def detect_node_tools(tests, linters, formatters, frameworks)
+      return unless node_project?
+
+      if jest?
+        cmd = npm_or_yarn("test")
+        tests << cmd
+        frameworks[cmd] = :jest
+      elsif package_script?("test")
+        tests << npm_or_yarn("test")
+      end
+
+      %w[lint eslint].each do |script|
+        if package_script?(script)
+          linters << npm_or_yarn(script)
+          break
+        end
+      end
+
+      %w[format prettier].each do |script|
+        if package_script?(script)
+          formatters << npm_or_yarn(script)
+          break
+        end
+      end
+    end
+
+    def detect_python_tools(tests, linters, formatters, frameworks)
+      if python_pytest?
+        cmd = "pytest -q"
+        tests << cmd
+        frameworks[cmd] = :pytest
+      end
+
+      if python_ruff?
+        linters << "ruff check ."
+        formatters << "ruff format ."
+      elsif python_flake8?
+        linters << "flake8"
+      end
+
+      formatters << "black ." if python_black?
+    end
+
     def bundle_prefix(cmd)
       File.exist?(File.join(@root, "Gemfile")) ? "bundle exec #{cmd}" : cmd
     end
@@ -72,6 +266,24 @@ module Aidp
         end
     end
 
+    def minitest?
+      test_dir = File.join(@root, "test")
+      return false unless File.exist?(test_dir)
+
+      # Check for minitest in Gemfile or test files
+      gemfile_has_minitest = begin
+        File.readlines(File.join(@root, "Gemfile")).grep(/minitest/).any?
+      rescue
+        false
+      end
+
+      return true if gemfile_has_minitest
+
+      # Check for test files that use minitest
+      test_files = Dir.glob(File.join(test_dir, "**", "*_test.rb"))
+      test_files.any?
+    end
+
     def standard_rb?
       File.exist?(File.join(@root, "Gemfile")) &&
         begin
@@ -81,6 +293,16 @@ module Aidp
         end
     end
 
+    def rubocop?
+      File.exist?(File.join(@root, ".rubocop.yml")) ||
+        (File.exist?(File.join(@root, "Gemfile")) &&
+         begin
+           File.readlines(File.join(@root, "Gemfile")).grep(/rubocop/).any?
+         rescue
+           false
+         end)
+    end
+
     def package_json
       @package_json ||= begin
         path = File.join(@root, "package.json")
@@ -107,9 +329,54 @@ module Aidp
       end
     end
 
+    def jest?
+      return false unless node_project?
+
+      # Check for jest in dependencies or devDependencies
+      deps = package_json&.dig("dependencies") || {}
+      dev_deps = package_json&.dig("devDependencies") || {}
+
+      deps.key?("jest") || dev_deps.key?("jest") ||
+        package_json&.dig("scripts", "test")&.include?("jest")
+    end
+
     def python_pytest?
       Dir.glob(File.join(@root, "**", "pytest.ini")).any? ||
-        Dir.glob(File.join(@root, "**", "conftest.py")).any?
+        Dir.glob(File.join(@root, "**", "conftest.py")).any? ||
+        (File.exist?(File.join(@root, "pyproject.toml")) &&
+         begin
+           File.read(File.join(@root, "pyproject.toml")).include?("pytest")
+         rescue
+           false
+         end)
+    end
+
+    def python_ruff?
+      File.exist?(File.join(@root, "pyproject.toml")) &&
+        begin
+          File.read(File.join(@root, "pyproject.toml")).include?("[tool.ruff]")
+        rescue
+          false
+        end
+    end
+
+    def python_flake8?
+      File.exist?(File.join(@root, ".flake8")) ||
+        File.exist?(File.join(@root, "setup.cfg")) &&
+          begin
+            File.read(File.join(@root, "setup.cfg")).include?("[flake8]")
+          rescue
+            false
+          end
+    end
+
+    def python_black?
+      File.exist?(File.join(@root, "pyproject.toml")) &&
+        begin
+          File.read(File.join(@root, "pyproject.toml")).include?("[tool.black]")
+        rescue
+          false
+        end
     end
   end
 end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.32.0"
+  VERSION = "0.33.0"
 end

data/lib/aidp/watch/change_request_processor.rb

@@ -40,6 +40,12 @@ module Aidp
         @project_dir = project_dir
         @verbose = verbose
 
+        # Log initialization details
+        Aidp.log_debug("change_request_processor", "initializing",
+          provider_name: provider_name,
+          project_dir: project_dir,
+          verbose: verbose)
+
         # Initialize verifier
         @verifier = ImplementationVerifier.new(
           repository_client: repository_client,
@@ -50,6 +56,11 @@ module Aidp
         @change_request_label = label_config[:change_request_trigger] || label_config["change_request_trigger"] || DEFAULT_CHANGE_REQUEST_LABEL
         @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
 
+        # Log label details
+        Aidp.log_debug("change_request_processor", "label_configuration",
+          change_request_label: @change_request_label,
+          needs_input_label: @needs_input_label)
+
         # Load change request configuration
         @config = {
           enabled: true,
@@ -61,9 +72,18 @@ module Aidp
           allow_large_pr_worktree_bypass: true # Default to always using worktree for large PRs
         }.merge(symbolize_keys(change_request_config))
 
+        # Log configuration details
+        Aidp.log_debug("change_request_processor", "change_request_config",
+          config: @config.transform_values { |v| v.is_a?(Proc) ? "Proc" : v })
+
         # Load safety configuration
         @safety_config = safety_config
         @author_allowlist = Array(@safety_config[:author_allowlist] || @safety_config["author_allowlist"])
+
+        # Log safety configuration
+        Aidp.log_debug("change_request_processor", "safety_configuration",
+          author_allowlist: @author_allowlist,
+          allowlist_count: @author_allowlist.length)
       end
 
       def process(pr)
@@ -142,15 +162,29 @@ module Aidp
       def filter_authorized_comments(comments, pr_data)
         # If allowlist is empty (for private repos), consider PR author and all commenters
         # For public repos, enforce allowlist
+        Aidp.log_debug("change_request_processor", "filtering_authorized_comments",
+          total_comments: comments.length,
+          allowlist_count: @author_allowlist.length,
+          is_private_repo: @author_allowlist.empty?)
+
         if @author_allowlist.empty?
           # Private repo: trust all comments from PR participants
+          Aidp.log_debug("change_request_processor", "private_repo_comments_allowed",
+            comments_allowed: comments.length)
           comments
         else
           # Public repo: only allow comments from allowlisted users
-          comments.select do |comment|
+          authorized_comments = comments.select do |comment|
             author = comment[:author]
             @author_allowlist.include?(author)
           end
+
+          Aidp.log_debug("change_request_processor", "public_repo_comment_filtering",
+            total_comments: comments.length,
+            authorized_comments: authorized_comments.length,
+            allowed_authors: authorized_comments.map { |c| c[:author] })
+
+          authorized_comments
         end
       end
 
@@ -395,14 +429,83 @@ module Aidp
       def create_worktree_for_pr(pr_data)
         head_ref = pr_data[:head_ref]
         pr_number = pr_data[:number]
-        slug = "pr-#{pr_number}-change-requests"
 
-        display_message("🌿 Creating worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+        # Configure slug and worktree strategy
+        slug = pr_data.fetch(:worktree_slug, "pr-#{pr_number}-change-requests")
+        strategy = @config.fetch(:worktree_strategy, "auto")
+
+        display_message("🌿 Preparing worktree for PR ##{pr_number}: #{head_ref} (Strategy: #{strategy})", type: :info)
 
+        # Pre-create setup: fetch latest refs
         Dir.chdir(@project_dir) do
           run_git(%w[fetch origin], allow_failure: true)
         end
 
+        # Worktree creation strategy
+        worktree_path =
+          case strategy
+          when "always_create"
+            create_fresh_worktree(pr_data, slug)
+          when "reuse_only"
+            find_existing_worktree(pr_data, slug)
+          else # 'auto' or default
+            find_existing_worktree(pr_data, slug) || create_fresh_worktree(pr_data, slug)
+          end
+
+        Aidp.log_debug(
+          "change_request_processor",
+          "worktree_resolved",
+          pr_number: pr_number,
+          branch: head_ref,
+          path: worktree_path,
+          strategy: strategy
+        )
+
+        display_message("✅ Worktree available at #{worktree_path}", type: :success)
+        worktree_path
+      rescue => e
+        Aidp.log_error(
+          "change_request_processor",
+          "worktree_creation_failed",
+          pr_number: pr_number,
+          error: e.message,
+          backtrace: e.backtrace&.first(5)
+        )
+        display_message("❌ Failed to create worktree: #{e.message}", type: :error)
+        raise
+      end
+
+      private
+
+      def find_existing_worktree(pr_data, slug)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
+        # First check for existing worktree by branch
+        existing = Aidp::Worktree.find_by_branch(branch: head_ref, project_dir: @project_dir)
+        return existing[:path] if existing && existing[:active]
+
+        # If no branch-specific worktree, look for PR-specific worktree
+        pr_worktrees = Aidp::Worktree.list(project_dir: @project_dir)
+        pr_specific_worktree = pr_worktrees.find do |w|
+          w[:slug]&.include?("pr-#{pr_number}")
+        end
+
+        pr_specific_worktree ? pr_specific_worktree[:path] : nil
+      end
+
+      def create_fresh_worktree(pr_data, slug)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
+        Aidp.log_debug(
+          "change_request_processor",
+          "creating_new_worktree",
+          pr_number: pr_number,
+          branch: head_ref,
+          slug: slug
+        )
+
         result = Aidp::Worktree.create(
           slug: slug,
           project_dir: @project_dir,
@@ -410,11 +513,7 @@ module Aidp
           base_branch: pr_data[:base_ref]
         )
 
-        worktree_path = result[:path]
-        Aidp.log_debug("change_request_processor", "worktree_created", pr_number: pr_number, branch: head_ref, path: worktree_path)
-        display_message("✅ Worktree created at #{worktree_path}", type: :success)
-
-        worktree_path
+        result[:path]
       end
 
       def apply_changes(changes)
@@ -571,22 +670,42 @@ module Aidp
       end
 
       def handle_incomplete_implementation(pr:, analysis:, verification_result:)
+        Aidp.log_debug("change_request_processor", "start_incomplete_implementation_handling",
+          pr_number: pr[:number],
+          verification_result: {
+            missing_items_count: verification_result[:missing_items]&.length || 0,
+            additional_work_count: verification_result[:additional_work]&.length || 0
+          })
+
         display_message("⚠️  Implementation incomplete; creating follow-up tasks.", type: :warn)
 
         # Create tasks for missing requirements
         if verification_result[:additional_work] && !verification_result[:additional_work].empty?
+          Aidp.log_debug("change_request_processor", "preparing_follow_up_tasks",
+            pr_number: pr[:number],
+            additional_work_tasks_count: verification_result[:additional_work].length)
           create_follow_up_tasks(@project_dir, verification_result[:additional_work])
         end
 
         # Record state but do not post a separate comment
         # (verification details will be included in the next summary comment)
-        @state_store.record_change_request(pr[:number], {
+        state_record = {
           status: "incomplete_implementation",
           timestamp: Time.now.utc.iso8601,
           verification_reasons: verification_result[:reasons],
           missing_items: verification_result[:missing_items],
           additional_work: verification_result[:additional_work]
-        })
+        }
+
+        # Log the details of the state record before storing
+        Aidp.log_debug("change_request_processor", "recording_incomplete_implementation_state",
+          pr_number: pr[:number],
+          status: state_record[:status],
+          verification_reasons_count: state_record[:verification_reasons]&.length || 0,
+          missing_items_count: state_record[:missing_items]&.length || 0,
+          additional_work_count: state_record[:additional_work]&.length || 0)
+
+        @state_store.record_change_request(pr[:number], state_record)
 
         display_message("📝 Recorded incomplete implementation status for PR ##{pr[:number]}", type: :info)
 
@@ -603,36 +722,55 @@ module Aidp
       def create_follow_up_tasks(working_dir, additional_work)
         return if additional_work.nil? || additional_work.empty?
 
+        Aidp.log_debug("change_request_processor", "start_creating_follow_up_tasks",
+          working_dir: working_dir,
+          additional_work_tasks_count: additional_work.length)
+
         tasklist_file = File.join(working_dir, ".aidp", "tasklist.jsonl")
         FileUtils.mkdir_p(File.dirname(tasklist_file))
 
         require_relative "../execute/persistent_tasklist"
         tasklist = Aidp::Execute::PersistentTasklist.new(working_dir)
 
+        tasks_created = []
         additional_work.each do |task_description|
-          tasklist.create(
+          task = tasklist.create(
             description: task_description,
             priority: :high,
             source: "verification"
           )
+          tasks_created << task
         end
 
         display_message("📝 Created #{additional_work.length} follow-up task(s) for continued work", type: :info)
 
+        Aidp.log_debug("change_request_processor", "follow_up_tasks_details",
+          task_count: tasks_created.length,
+          working_dir: working_dir,
+          task_descriptions: tasks_created.map(&:description))
+
         Aidp.log_info(
           "change_request_processor",
           "created_follow_up_tasks",
-          task_count: additional_work.length,
+          task_count: tasks_created.length,
           working_dir: working_dir
         )
+
+        tasks_created
       rescue => e
-        display_message("⚠️  Failed to create follow-up tasks: #{e.message}", type: :warn)
         Aidp.log_error(
           "change_request_processor",
           "failed_to_create_follow_up_tasks",
           error: e.message,
-          backtrace: e.backtrace&.first(5)
+          error_class: e.class.name,
+          backtrace: e.backtrace&.first(5),
+          working_dir: working_dir
         )
+
+        display_message("⚠️  Failed to create follow-up tasks: #{e.message}", type: :warn)
+
+        # Return an empty array to indicate failure
+        []
       end
 
       def handle_clarification_needed(pr:, analysis:)

data/lib/aidp/watch/repository_client.rb

@@ -120,6 +120,47 @@ module Aidp
         gh_available? ? fetch_pr_comments_via_gh(number) : fetch_pr_comments_via_api(number)
       end
 
+      # Create or update a categorized comment (e.g., under a header) on an issue.
+      # If a comment with the category header exists, either append to it or
+      # replace it while archiving the previous content inline.
+      def consolidate_category_comment(issue_number, category_header, content, append: false)
+        existing_comment = find_comment(issue_number, category_header)
+
+        if existing_comment.nil?
+          Aidp.log_debug("repository_client", "creating_category_comment",
+            issue: issue_number,
+            header: category_header)
+          return post_comment(issue_number, "#{category_header}\n\n#{content}")
+        end
+
+        existing_body = existing_comment[:body] || existing_comment["body"] || ""
+        content_without_header = existing_body.sub(/\A#{Regexp.escape(category_header)}\s*/, "").strip
+
+        new_body =
+          if append
+            Aidp.log_debug("repository_client", "appending_category_comment",
+              issue: issue_number,
+              header: category_header)
+            segments = [category_header, content_without_header, content].reject(&:empty?)
+            segments.join("\n\n")
+          else
+            Aidp.log_debug("repository_client", "replacing_category_comment",
+              issue: issue_number,
+              header: category_header)
+            timestamp = Time.now.utc.iso8601
+            archive_marker = "<!-- ARCHIVED_PLAN_START #{timestamp} ARCHIVED_PLAN_END -->"
+            [category_header, content, archive_marker, content_without_header].join("\n\n")
+          end
+
+        update_comment(existing_comment[:id] || existing_comment["id"], new_body)
+      rescue => e
+        Aidp.log_error("repository_client", "consolidate_category_comment_failed",
+          issue: issue_number,
+          header: category_header,
+          error: e.message)
+        raise "GitHub error: #{e.message}"
+      end
+
       private
 
       # Retry a GitHub CLI operation with exponential backoff