aidp 0.31.0 → 0.33.0

data/lib/aidp/execute/work_loop_runner.rb

@@ -7,8 +7,10 @@ require_relative "guard_policy"
 require_relative "work_loop_unit_scheduler"
 require_relative "deterministic_unit"
 require_relative "agent_signal_parser"
+require_relative "steps"
 require_relative "../harness/test_runner"
 require_relative "../errors"
+require_relative "../style_guide/selector"
 
 module Aidp
   module Execute
@@ -53,6 +55,7 @@ module Aidp
         @checkpoint = Checkpoint.new(project_dir)
         @checkpoint_display = CheckpointDisplay.new(prompt: @prompt)
         @guard_policy = GuardPolicy.new(project_dir, config.guards_config)
+        @work_context = {}
         @persistent_tasklist = PersistentTasklist.new(project_dir)
         @iteration_count = 0
         @step_name = nil
@@ -67,6 +70,9 @@ module Aidp
         @thinking_depth_manager = options[:thinking_depth_manager] || Aidp::Harness::ThinkingDepthManager.new(config)
         @consecutive_failures = 0
         @last_tier = nil
+
+        # Initialize style guide selector for intelligent section selection
+        @style_guide_selector = options[:style_guide_selector] || Aidp::StyleGuide::Selector.new(project_dir: project_dir)
       end
 
       # Execute a step using fix-forward work loop pattern
@@ -74,6 +80,7 @@ module Aidp
       # Never rolls back - only moves forward through fixes
       def execute_step(step_name, step_spec, context = {})
         @step_name = step_name
+        @work_context = context
         @iteration_count = 0
         transition_to(:ready)
 
@@ -81,6 +88,7 @@ module Aidp
 
         display_message("🔄 Starting hybrid work loop for step: #{step_name}", type: :info)
         display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
+        display_work_context(step_name, context)
 
         display_guard_policy_status
         display_pending_tasks
@@ -159,9 +167,20 @@ module Aidp
 
           transition_to(:apply_patch)
 
+          # Preview provider/model selection and queued checks for this iteration
+          preview_provider, preview_model, _model_data = select_model_for_current_tier
+          prompt_length = @prompt_manager.read&.length || 0
+          checks_summary = planned_checks_summary
+          display_iteration_overview(preview_provider, preview_model, prompt_length, checks_summary)
+          log_iteration_status("running",
+            provider: preview_provider,
+            model: preview_model,
+            prompt_length: prompt_length,
+            checks: checks_summary)
+
           # Wrap agent call in exception handling for true fix-forward
           begin
-            agent_result = apply_patch
+            agent_result = apply_patch(preview_provider, preview_model)
           rescue Aidp::Errors::ConfigurationError
             # Configuration errors should crash immediately (crash-early principle)
             # Re-raise without catching
@@ -256,6 +275,12 @@ module Aidp
                 display_task_summary
                 display_message("✅ Step #{@step_name} completed after #{@iteration_count} iterations", type: :success)
                 display_state_summary
+                log_iteration_status("completed",
+                  provider: preview_provider,
+                  model: preview_model,
+                  prompt_length: prompt_length,
+                  checks: checks_summary,
+                  task_status: "complete")
                 archive_and_cleanup
 
                 return build_agentic_payload(
@@ -270,6 +295,12 @@ module Aidp
                 display_message("  All checks passed but tasks not complete", type: :warning)
                 display_message("  #{task_completion_result[:message]}", type: :warning)
                 display_task_summary
+                log_iteration_status("checks_passed_tasks_incomplete",
+                  provider: preview_provider,
+                  model: preview_model,
+                  prompt_length: prompt_length,
+                  checks: checks_summary,
+                  task_status: "incomplete")
                 transition_to(:next_patch)
 
                 # Append task completion requirement to PROMPT.md
@@ -277,6 +308,11 @@ module Aidp
               end
             else
               display_message("  All checks passed but work not marked complete", type: :info)
+              log_iteration_status("checks_passed_waiting_agent_completion",
+                provider: preview_provider,
+                model: preview_model,
+                prompt_length: prompt_length,
+                checks: checks_summary)
               transition_to(:next_patch)
             end
           else
@@ -287,6 +323,12 @@ module Aidp
             diagnostic = diagnose_failures(all_results)
 
             transition_to(:next_patch)
+            log_iteration_status("checks_failed",
+              provider: preview_provider,
+              model: preview_model,
+              prompt_length: prompt_length,
+              checks: checks_summary,
+              failures: failure_summary_for_log(all_results))
             prepare_next_iteration(all_results, diagnostic)
           end
         end
@@ -497,8 +539,8 @@ module Aidp
       end
 
       # Apply patch - send PROMPT.md to agent
-      def apply_patch
-        send_to_agent
+      def apply_patch(selected_provider = nil, selected_model = nil)
+        send_to_agent(selected_provider: selected_provider, selected_model: selected_model)
       end
 
       # Check if agent marked work complete
@@ -547,7 +589,9 @@ module Aidp
         # Traditional prompt building (fallback or when optimization disabled)
         template_content = load_template(step_spec["templates"]&.first)
         prd_content = load_prd
-        style_guide = load_style_guide
+        # Use provider-aware style guide loading - skips for Claude/Copilot,
+        # selects relevant STYLE_GUIDE sections for other providers
+        style_guide = load_style_guide_for_provider(context)
         user_input = format_user_input(context[:user_input])
         deterministic_outputs = Array(context[:deterministic_outputs])
         previous_summary = context[:previous_agent_summary]
@@ -727,7 +771,7 @@ module Aidp
         parts.join("\n")
       end
 
-      def send_to_agent
+      def send_to_agent(selected_provider: nil, selected_model: nil)
         prompt_content = @prompt_manager.read
         return {status: "error", message: "PROMPT.md not found"} unless prompt_content
 
@@ -735,9 +779,11 @@ module Aidp
         full_prompt = build_work_loop_header(@step_name, @iteration_count) + "\n\n" + prompt_content
 
         # Select model based on thinking depth tier
-        provider_name, model_name, _model_data = select_model_for_current_tier
+        provider_name = selected_provider
+        model_name = selected_model
+        provider_name, model_name, _model_data = select_model_for_current_tier if provider_name.nil? || model_name.nil?
 
-        if provider_name.nil? || model_name.nil?
+        if provider_name.nil?
           Aidp.logger.error("work_loop", "Failed to select model for tier",
             tier: @thinking_depth_manager.current_tier,
             step: @step_name,
@@ -748,7 +794,8 @@ module Aidp
         # Log model selection
         tier = @thinking_depth_manager.current_tier
         if @last_tier != tier
-          display_message("  💡 Using tier: #{tier} (#{provider_name}/#{model_name})", type: :info)
+          model_label = model_name || "auto"
+          display_message("  💡 Using tier: #{tier} (#{provider_name}/#{model_label})", type: :info)
           @last_tier = tier
         end
 
@@ -770,6 +817,164 @@ module Aidp
         end
       end
 
+      def display_iteration_overview(provider_name, model_name, prompt_length, checks_summary = nil)
+        tier = @thinking_depth_manager.current_tier
+        checks = checks_summary
+        checks ||= summarize_checks(@test_runner.planned_commands) if @test_runner.respond_to?(:planned_commands)
+        model_label = model_name || "auto"
+        context_labels = iteration_context_labels
+
+        display_message("    • Step: #{@step_name} | Tier: #{tier} | Model: #{provider_name}/#{model_label}", type: :info)
+        display_message("    • Prompt size: #{prompt_length} chars | State: #{STATES[@current_state]}", type: :info)
+        display_message("    • Upcoming checks: #{checks}", type: :info) if checks && !checks.empty?
+        display_message("    • Context: #{context_labels.join(" | ")}", type: :info) if context_labels.any?
+
+        # Display output filtering configuration if enabled
+        filtering_info = summarize_output_filtering
+        display_message("    • Output filtering: #{filtering_info}", type: :info) if filtering_info
+      end
+
+      # Summarize output filtering configuration
+      def summarize_output_filtering
+        return nil unless @config.respond_to?(:output_filtering_enabled?) && @config.output_filtering_enabled?
+
+        iteration = @test_runner.respond_to?(:iteration_count) ? @test_runner.iteration_count : 0
+
+        test_mode = if @config.respond_to?(:test_output_mode)
+          @config.test_output_mode
+        elsif iteration > 1
+          :failures_only
+        else
+          :full
+        end
+
+        lint_mode = if @config.respond_to?(:lint_output_mode)
+          @config.lint_output_mode
+        elsif iteration > 1
+          :failures_only
+        else
+          :full
+        end
+
+        if test_mode == :full && lint_mode == :full
+          nil # Don't show message when no filtering is active
+        else
+          "test=#{test_mode}, lint=#{lint_mode}"
+        end
+      rescue
+        nil
+      end
+
+      # Display output filtering statistics after test/lint runs
+      def display_filtering_stats
+        return unless @test_runner.respond_to?(:filter_stats)
+
+        stats = @test_runner.filter_stats
+        return if stats[:total_input_bytes].zero?
+
+        reduction = ((stats[:total_input_bytes] - stats[:total_output_bytes]).to_f / stats[:total_input_bytes] * 100).round(1)
+        return if reduction <= 0
+
+        display_message("    📉 Token optimization: #{reduction}% reduction " \
+                       "(#{format_bytes(stats[:total_input_bytes])} → #{format_bytes(stats[:total_output_bytes])})", type: :info)
+      rescue
+        # Silently ignore errors in stats display
+      end
+
+      def format_bytes(bytes)
+        if bytes >= 1024 * 1024
+          "#{(bytes / 1024.0 / 1024.0).round(1)}MB"
+        elsif bytes >= 1024
+          "#{(bytes / 1024.0).round(1)}KB"
+        else
+          "#{bytes}B"
+        end
+      end
+
+      def summarize_checks(planned)
+        labels = {
+          tests: "tests",
+          lints: "linters",
+          formatters: "formatters",
+          builds: "builds",
+          docs: "docs"
+        }
+
+        summaries = planned.map do |category, commands|
+          count = Array(commands).size
+          next if count.zero?
+
+          label = labels[category] || category.to_s
+          cmd_names = Array(commands).map do |cmd|
+            cmd.is_a?(Hash) ? cmd[:command] : cmd
+          end
+
+          if cmd_names.size <= 2
+            "#{label} (#{cmd_names.join(", ")})"
+          else
+            "#{label} (#{cmd_names.first(2).join(", ")} +#{cmd_names.size - 2} more)"
+          end
+        end.compact
+
+        summaries.join(" | ")
+      rescue => e
+        Aidp.log_warn("work_loop", "summarize_checks_failed", error: e.message)
+        nil
+      end
+
+      def planned_checks_summary
+        return nil unless @test_runner.respond_to?(:planned_commands)
+
+        summarize_checks(@test_runner.planned_commands)
+      end
+
+      def failure_summary_for_log(all_results)
+        Array(all_results).each_with_object([]) do |(category, results), summary|
+          next if results[:success]
+
+          failures = results[:required_failures] || results[:failures] || []
+          count = failures.size
+          commands = Array(failures).map { |f| f[:command] }.compact
+
+          summary << if commands.any?
+            "#{category}: #{count} (#{commands.first(2).join(", ")})"
+          else
+            "#{category}: #{count}"
+          end
+        end
+      rescue => e
+        Aidp.log_warn("work_loop", "failure_summary_for_log_failed", error: e.message)
+        []
+      end
+
+      def log_iteration_status(status, provider:, model:, prompt_length:, checks: nil, failures: nil, task_status: nil)
+        context_labels = iteration_context_labels
+        metadata = {
+          step: @step_name,
+          iteration: @iteration_count,
+          state: STATES[@current_state],
+          tier: @thinking_depth_manager.current_tier,
+          provider: provider,
+          model: model,
+          prompt_length: prompt_length,
+          checks: checks,
+          failures: failures,
+          task_status: task_status
+        }
+
+        metadata.merge!(iteration_context_metadata)
+        metadata.delete_if { |_, value| value.nil? || (value.respond_to?(:empty?) && value.empty?) }
+
+        message = "Iteration #{@iteration_count} for #{@step_name}: #{status}"
+        message += " | #{context_labels.join(" | ")}" if context_labels.any?
+
+        Aidp.log_info("work_loop_iteration",
+          message,
+          **metadata)
+      rescue => e
+        Aidp.log_warn("work_loop", "failed_to_log_iteration_status", error: e.message)
+      end
+
       def build_work_loop_header(step_name, iteration)
         parts = []
         parts << "# Work Loop: #{step_name} (Iteration #{iteration})"
@@ -830,6 +1035,24 @@ module Aidp
         parts.join("\n")
       end
 
+      def iteration_context_metadata
+        ctx = (@options || {}).merge(@work_context || {})
+        {
+          issue: issue_context_label(ctx),
+          pr: pr_context_label(ctx),
+          step_position: step_position_label(@step_name, ctx)
+        }.compact
+      end
+
+      def iteration_context_labels
+        meta = iteration_context_metadata
+        labels = []
+        labels << meta[:issue] if meta[:issue]
+        labels << meta[:pr] if meta[:pr]
+        labels << meta[:step_position] if meta[:step_position]
+        labels
+      end
+
       def prompt_marked_complete?
         prompt_content = @prompt_manager.read
         return false unless prompt_content
@@ -936,30 +1159,50 @@ module Aidp
 
       # Check if we should reinject the style guide at this iteration
       def should_reinject_style_guide?
+        # Skip reinjection for providers with instruction files (Claude, GitHub Copilot)
+        current_provider = @provider_manager&.current_provider
+        return false unless @style_guide_selector.provider_needs_style_guide?(current_provider)
+
         # Reinject on intervals (5, 10, 15, etc.) but not on iteration 1
         @iteration_count > 1 && (@iteration_count % STYLE_GUIDE_REMINDER_INTERVAL == 0)
       end
 
       # Create style guide reminder text
       def reinject_style_guide_reminder
-        style_guide = load_style_guide
+        current_provider = @provider_manager&.current_provider
+
+        # Skip for providers with instruction files
+        unless @style_guide_selector.provider_needs_style_guide?(current_provider)
+          Aidp.log_debug("work_loop", "skipping_style_guide_reminder",
+            provider: current_provider,
+            reason: "provider has instruction file")
+          return ""
+        end
+
         template_content = load_current_template
 
+        # Use provider-aware style guide loading with context-based section selection
+        style_guide = load_style_guide_for_provider(@work_context)
+
         reminder = []
         reminder << "### 🔄 Style Guide & Template Reminder (Iteration #{@iteration_count})"
         reminder << ""
         reminder << "**IMPORTANT**: To prevent drift from project conventions, please review:"
         reminder << ""
 
-        if style_guide
-          reminder << "#### LLM Style Guide"
-          reminder << "```"
-          # Include first 1000 chars of style guide to keep context manageable
-          style_guide_preview = (style_guide.length > 1000) ? style_guide[0...1000] + "\n...(truncated)" : style_guide
+        if style_guide && !style_guide.empty?
+          reminder << "#### Relevant Style Guide Sections"
+          reminder << "```markdown"
+          # Include selected sections (already limited by selector)
+          style_guide_preview = if style_guide.length > 2000
+            style_guide[0...2000] + "\n...(truncated)"
+          else
+            style_guide
+          end
           reminder << style_guide_preview
           reminder << "```"
           reminder << ""
-          display_message("  [STYLE_GUIDE] Re-injecting LLM_STYLE_GUIDE at iteration #{@iteration_count}", type: :info)
+          display_message("  [STYLE_GUIDE] Re-injecting selected STYLE_GUIDE sections at iteration #{@iteration_count}", type: :info)
         end
 
         if template_content
@@ -1049,6 +1292,74 @@ module Aidp
         File.exist?(style_guide_path) ? File.read(style_guide_path) : nil
       end
 
+      # Load style guide content appropriate for the current provider and context
+      # Returns nil for providers with instruction files (Claude, GitHub Copilot)
+      # Returns selected STYLE_GUIDE sections for other providers
+      #
+      # @param context [Hash] Task context for keyword extraction
+      # @return [String, nil] Style guide content or nil if not needed
+      def load_style_guide_for_provider(context = {})
+        current_provider = @provider_manager&.current_provider
+
+        # Skip style guide for providers with their own instruction files
+        unless @style_guide_selector.provider_needs_style_guide?(current_provider)
+          Aidp.log_debug("work_loop", "skipping_style_guide",
+            provider: current_provider,
+            reason: "provider has instruction file")
+          return nil
+        end
+
+        # Extract keywords from context for intelligent section selection
+        keywords = extract_style_guide_keywords(context)
+
+        # Select relevant sections from STYLE_GUIDE.md
+        content = @style_guide_selector.select_sections(
+          keywords: keywords,
+          include_core: true,
+          max_lines: 500 # Limit to keep prompt size manageable
+        )
+
+        return nil if content.nil? || content.empty?
+
+        Aidp.log_debug("work_loop", "style_guide_selected",
+          provider: current_provider,
+          keywords: keywords,
+          content_lines: content.lines.count)
+
+        content
+      end
+
+      # Extract keywords from task context for style guide section selection
+      #
+      # @param context [Hash] Task context
+      # @return [Array<String>] Keywords for section selection
+      def extract_style_guide_keywords(context)
+        keywords = []
+
+        # Extract from step name
+        step_lower = @step_name.to_s.downcase
+        keywords << "testing" if step_lower.include?("test")
+        keywords << "implementation" if step_lower.include?("implement")
+        keywords << "refactor" if step_lower.include?("refactor")
+
+        # Extract from user input
+        user_input = context[:user_input]
+        if user_input.is_a?(Hash)
+          keywords.concat(@style_guide_selector.extract_keywords(user_input.values.join(" ")))
+        elsif user_input.is_a?(String)
+          keywords.concat(@style_guide_selector.extract_keywords(user_input))
+        end
+
+        # Extract from affected files
+        affected_files = context[:affected_files] || []
+        affected_files.each do |file|
+          keywords << "testing" if file.include?("spec") || file.include?("test")
+          keywords << "tty" if file.include?("cli") || file.include?("tui")
+        end
+
+        keywords.uniq
+      end
+
       def format_user_input(user_input)
         return nil if user_input.nil? || user_input.empty?
 
@@ -1286,6 +1597,74 @@ module Aidp
         display_message("")
       end
 
+      # Show watch-mode context (issue/PR, step position) to improve situational awareness
+      def display_work_context(step_name, context)
+        parts = work_context_parts(step_name, context)
+        return if parts.empty?
+
+        Aidp.log_debug("work_loop", "work_context", step: step_name, parts: parts)
+        display_message("  📡 Context: #{parts.join(" | ")}", type: :info)
+      end
+
+      def work_context_parts(step_name, context)
+        ctx = (@options || {}).merge(context || {})
+        parts = []
+
+        if (step_label = step_position_label(step_name, ctx))
+          parts << step_label
+        end
+
+        if (issue_label = issue_context_label(ctx))
+          parts << issue_label
+        end
+
+        if (pr_label = pr_context_label(ctx))
+          parts << pr_label
+        end
+
+        parts << "Watch mode" if ctx[:workflow_type].to_s == "watch_mode"
+
+        parts.compact
+      end
+
+      def step_position_label(step_name, context)
+        steps = Array(context[:selected_steps]).map(&:to_s)
+        steps = Aidp::Execute::Steps::SPEC.keys if steps.empty?
+        steps = [step_name] if steps.empty?
+        steps << step_name unless steps.include?(step_name)
+
+        index = steps.index(step_name)
+        return nil unless index
+
+        "Step #{index + 1}/#{steps.size} (#{step_name})"
+      end
+
+      def issue_context_label(context)
+        issue_number = context[:issue_number] ||
+          context.dig(:issue, :number) ||
+          extract_number_from_url(context[:issue_url] || context.dig(:issue, :url) || context.dig(:user_input, "Issue URL"), /issues\/(\d+)/)
+
+        return nil unless issue_number
+
+        "Issue ##{issue_number}"
+      end
+
+      def pr_context_label(context)
+        pr_number = context[:pr_number] ||
+          context.dig(:pull_request, :number) ||
+          extract_number_from_url(context[:pr_url] || context.dig(:pull_request, :url) || context.dig(:user_input, "PR URL") || context.dig(:user_input, "Pull Request URL"), /pull\/(\d+)/)
+
+        return nil unless pr_number
+
+        "PR ##{pr_number}"
+      end
+
+      def extract_number_from_url(url, pattern)
+        return nil unless url
+        match = url.to_s.match(pattern)
+        match && match[1]
+      end
+
       # Append task completion requirement to PROMPT.md
       def append_task_requirement_to_prompt(message)
         task_requirement = []