aidp 0.25.0 → 0.27.0

data/lib/aidp/setup/wizard.rb

@@ -9,6 +9,7 @@ require "json"
 
 require_relative "../util"
 require_relative "../config/paths"
+require_relative "../harness/capability_registry"
 require_relative "provider_registry"
 require_relative "devcontainer/parser"
 require_relative "devcontainer/generator"
@@ -24,6 +25,11 @@ module Aidp
       SCHEMA_VERSION = 1
       DEVCONTAINER_COMPONENT = "setup_wizard.devcontainer"
 
+      DEFAULT_AUTOCONFIG_TIERS = %w[mini standard pro].freeze
+      LEGACY_TIER_ALIASES = {
+        advanced: :pro
+      }.freeze
+
       attr_reader :project_dir, :prompt, :dry_run
 
       def initialize(project_dir = Dir.pwd, prompt: nil, dry_run: false)
@@ -38,11 +44,13 @@ module Aidp
 
       def run
         display_welcome
-        # Normalize any legacy or label-based model_family entries before prompting
+        # Normalize any legacy tier/model_family entries before prompting
         normalize_existing_model_families!
+        normalize_existing_thinking_tiers!
         return @saved if skip_wizard?
 
         configure_providers
+        configure_thinking_tiers
         configure_work_loop
         configure_branching
         configure_artifacts
@@ -51,6 +59,9 @@ module Aidp
         configure_modes
         configure_devcontainer
 
+        # Finalize any background model discovery
+        finalize_background_discovery
+
         yaml_content = generate_yaml
         display_preview(yaml_content)
         display_diff(yaml_content) if @existing_config.any?
@@ -279,6 +290,249 @@ module Aidp
 
       # Removed MCP configuration step (MCP now expected to be provider-specific if used)
 
+      # -------------------------------------------
+      # Thinking tier configuration (automated model discovery)
+      # -------------------------------------------
+      def configure_thinking_tiers
+        prompt.say("\n🧠 Thinking Tier Configuration")
+        prompt.say("-" * 40)
+
+        # Get configured providers
+        primary_provider = get([:harness, :default_provider])
+        fallback_providers = Array(get([:harness, :fallback_providers]))
+        all_providers = ([primary_provider] + fallback_providers).compact.uniq
+
+        if all_providers.empty?
+          prompt.warn("⚠️  No providers configured. Skipping tier configuration.")
+          return
+        end
+
+        # Check if user wants to use automated discovery
+        existing_tiers = get([:thinking, :tiers])
+        if existing_tiers && !existing_tiers.empty?
+          prompt.say("📝 Found existing tier configuration")
+          unless prompt.yes?("Would you like to update it with discovered models?", default: false)
+            return
+          end
+        elsif !prompt.yes?("Auto-configure thinking tiers with discovered models?", default: true)
+          prompt.say("💡 You can run 'aidp models discover' later to see available models")
+          return
+        end
+
+        # Run model discovery
+        prompt.say("\n🔍 Discovering available models...")
+        discovered_models = discover_models_for_providers(all_providers)
+
+        if discovered_models.empty?
+          prompt.warn("⚠️  No models discovered. Ensure provider CLIs are installed.")
+          prompt.say("💡 You can configure tiers manually or run 'aidp models discover' later")
+          return
+        end
+
+        # Display discovered models
+        display_discovered_models(discovered_models)
+
+        # Generate tier configuration
+        tier_config = generate_tier_configuration(discovered_models, primary_provider)
+
+        # Show preview
+        prompt.say("\n📋 Proposed tier configuration:")
+        display_tier_preview(tier_config)
+
+        # Confirm and save
+        if prompt.yes?("\nSave this tier configuration?", default: true)
+          set([:thinking, :tiers], tier_config)
+          prompt.ok("✅ Thinking tiers configured successfully")
+        else
+          prompt.say("💡 Skipped tier configuration. You can run 'aidp models discover' later")
+        end
+      end
+
+      # Trigger background model discovery for a provider
+      # Runs asynchronously and caches results without blocking the wizard
+      def trigger_background_discovery(provider_name)
+        return unless provider_available_for_discovery?(provider_name)
+
+        # Store reference to display notification later
+        @discovery_threads ||= []
+
+        thread = Thread.new do
+          discover_and_cache_models(provider_name)
+        rescue => e
+          Aidp.log_debug("setup_wizard", "background discovery failed",
+            provider: provider_name, error: e.message)
+        end
+
+        @discovery_threads << {thread: thread, provider: provider_name}
+      end
+
+      # Check if provider CLI is available for discovery
+      def provider_available_for_discovery?(provider_name)
+        provider_class = get_provider_class(provider_name)
+        return false unless provider_class
+
+        provider_class.respond_to?(:available?) && provider_class.available?
+      rescue => e
+        Aidp.log_debug("setup_wizard", "provider availability check failed",
+          provider: provider_name, error: e.message)
+        false
+      end
+
+      # Perform model discovery and cache results
+      def discover_and_cache_models(provider_name)
+        require_relative "../harness/model_discovery_service"
+
+        service = Aidp::Harness::ModelDiscoveryService.new
+        models = service.discover_models(provider_name, use_cache: false)
+
+        if models.any?
+          Aidp.log_info("setup_wizard", "discovered models in background",
+            provider: provider_name, count: models.size)
+        end
+
+        models
+      rescue => e
+        Aidp.log_debug("setup_wizard", "background discovery failed",
+          provider: provider_name, error: e.message)
+        []
+      end
+
+      # Get provider class for discovery
+      def get_provider_class(provider_name)
+        class_name = "Aidp::Providers::#{provider_name.capitalize}"
+        Object.const_get(class_name)
+      rescue NameError
+        nil
+      end
+
+      # Wait for background discovery to complete and show notifications
+      #
+      # @param timeout [Numeric] Maximum seconds to wait per thread (default: 5)
+      def finalize_background_discovery(timeout: 5)
+        return unless @discovery_threads&.any?
+
+        @discovery_threads.each do |entry|
+          thread = entry[:thread]
+          provider = entry[:provider]
+
+          # Wait up to timeout seconds for discovery to complete
+          thread.join(timeout)
+
+          if thread.alive?
+            Aidp.log_debug("setup_wizard", "discovery timeout, killing thread",
+              provider: provider)
+            # Kill thread to prevent hanging
+            thread.kill
+            thread.join(0.1) # Brief wait for cleanup
+          else
+            # Discovery completed - show notification
+            begin
+              require_relative "../harness/model_cache"
+              cache = Aidp::Harness::ModelCache.new
+              cached_models = cache.get_cached_models(provider)
+
+              if cached_models&.any?
+                prompt.say("  💾 Discovered #{cached_models.size} model#{"s" unless cached_models.size == 1} for #{provider}")
+              end
+            rescue => e
+              Aidp.log_debug("setup_wizard", "failed to check cached models",
+                provider: provider, error: e.message)
+            end
+          end
+        end
+
+        @discovery_threads = []
+      end
+
+      def discover_models_for_providers(providers)
+        require_relative "../harness/model_discovery_service"
+
+        service = Aidp::Harness::ModelDiscoveryService.new
+        all_models = {}
+
+        providers.each do |provider|
+          models = service.discover_models(provider, use_cache: true)
+          all_models[provider] = models if models.any?
+        rescue => e
+          Aidp.log_debug("setup_wizard", "discovery failed", provider: provider, error: e.message)
+          # Continue with other providers
+        end
+
+        all_models
+      end
+
+      def display_discovered_models(discovered_models)
+        discovered_models.each do |provider, models|
+          prompt.say("\n✓ Found #{models.size} models for #{provider}:")
+          by_tier = models.group_by { |m| m[:tier] }
+          valid_thinking_tiers.each do |tier|
+            tier_models = by_tier[tier] || []
+            next if tier_models.empty?
+
+            prompt.say("  #{tier.capitalize} tier: #{tier_models.size} model#{"s" unless tier_models.size == 1}")
+          end
+        end
+      end
+
+      def generate_tier_configuration(discovered_models, primary_provider)
+        tier_config = {}
+
+        # Configure the three most common tiers: mini, standard, and pro
+        DEFAULT_AUTOCONFIG_TIERS.each do |tier|
+          tier_models = []
+
+          # Collect primary provider models first (if available)
+          primary_models = find_models_for_tier(discovered_models[primary_provider], tier)
+          tier_models.concat(primary_models) if primary_models&.any?
+
+          # Add models from other providers
+          discovered_models.each do |provider, models|
+            next if provider == primary_provider
+            provider_models = find_models_for_tier(models, tier)
+            tier_models.concat(provider_models) if provider_models&.any?
+          end
+
+          # Add to config if we found any models for this tier
+          if tier_models.any?
+            tier_config[tier.to_sym] = {
+              models: tier_models.map { |m|
+                {
+                  provider: m[:provider],
+                  model: m[:name]
+                }
+              }
+            }
+          end
+        end
+
+        tier_config
+      end
+
+      def find_model_for_tier(models, target_tier)
+        return nil unless models
+
+        models.find { |m| m[:tier] == target_tier }
+      end
+
+      def find_models_for_tier(models, target_tier)
+        return [] unless models
+
+        models.select { |m| m[:tier] == target_tier }
+      end
+
+      def display_tier_preview(tier_config)
+        return if tier_config.empty?
+
+        tier_config.each do |tier, config|
+          models = config[:models] || []
+          prompt.say("  #{tier}:")
+          models.each do |model_entry|
+            prompt.say("    - provider: #{model_entry[:provider]}")
+            prompt.say("      model: #{model_entry[:model]}")
+          end
+        end
+      end
+
       # -------------------------------------------
       # Work loop configuration
       # -------------------------------------------
@@ -670,8 +924,18 @@ module Aidp
         prompt.say("\n📋 Non-functional requirements & preferred libraries")
         prompt.say("-" * 40)
 
-        return delete_path([:nfrs]) unless prompt.yes?("Configure NFRs?", default: true)
+        # Check existing configuration for previous choice
+        existing_configure = @config.dig(:nfrs, :configure)
+        default_configure = existing_configure.nil? || existing_configure
+
+        configure = prompt.yes?("Configure NFRs?", default: default_configure)
+
+        unless configure
+          Aidp.log_debug("setup_wizard.nfrs", "opt_out")
+          return set([:nfrs, :configure], false)
+        end
 
+        set([:nfrs, :configure], true)
         categories = %i[performance security reliability accessibility internationalization]
         categories.each do |category|
           existing = get([:nfrs, category])
@@ -835,7 +1099,7 @@ module Aidp
 
       def configure_watch_labels
         prompt.say("\n🏷️  Watch mode label configuration")
-        prompt.say("  Configure GitHub issue labels that trigger watch mode actions")
+        prompt.say("  Configure GitHub issue and PR labels that trigger watch mode actions")
         existing = get([:watch, :labels]) || {}
 
         plan_trigger = ask_with_default(
@@ -858,11 +1122,29 @@ module Aidp
           existing[:build_trigger] || "aidp-build"
         )
 
+        review_trigger = ask_with_default(
+          "Label to trigger code review",
+          existing[:review_trigger] || "aidp-review"
+        )
+
+        ci_fix_trigger = ask_with_default(
+          "Label to trigger CI remediation",
+          existing[:ci_fix_trigger] || "aidp-fix-ci"
+        )
+
+        change_request_trigger = ask_with_default(
+          "Label to trigger PR change implementation",
+          existing[:change_request_trigger] || "aidp-request-changes"
+        )
+
         set([:watch, :labels], {
           plan_trigger: plan_trigger,
           needs_input: needs_input,
           ready_to_build: ready_to_build,
-          build_trigger: build_trigger
+          build_trigger: build_trigger,
+          review_trigger: review_trigger,
+          ci_fix_trigger: ci_fix_trigger,
+          change_request_trigger: change_request_trigger
         })
       end
 
@@ -953,9 +1235,9 @@ module Aidp
       def show_next_steps
         prompt.say("\n🎉 Setup complete!")
         prompt.say("\nNext steps:")
-        prompt.say("  1. Export provider API keys as environment variables.")
-        prompt.say("  2. Run 'aidp init' to analyze the project.")
-        prompt.say("  3. Run 'aidp execute' to start a work loop.")
+        prompt.say("  1. Configure provider tools (set required API keys or connections).")
+        prompt.say("  2. Run 'aidp' to start a work loop.")
+        prompt.say("  3. Run 'aidp watch <owner/repo>' to enable watch mode automation.")
         prompt.say("")
       end
 
@@ -1225,6 +1507,9 @@ module Aidp
         # Enhance messaging with display name when available
         display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
         prompt.say("  • #{action_word.capitalize} provider '#{display_name}' (#{provider_name}) with billing type '#{provider_type}' and model family '#{model_family}'")
+
+        # Trigger background model discovery for newly added/updated provider
+        trigger_background_discovery(provider_name) unless @dry_run
       end
 
       def edit_or_remove_provider(provider_name, primary_provider, fallbacks)
@@ -1335,6 +1620,44 @@ module Aidp
         end
       end
 
+      def normalize_existing_thinking_tiers!
+        tiers_cfg = @config.dig(:thinking, :tiers)
+        return unless tiers_cfg.is_a?(Hash)
+
+        LEGACY_TIER_ALIASES.each do |legacy, canonical|
+          next unless tiers_cfg.key?(legacy)
+
+          legacy_cfg = tiers_cfg.delete(legacy) || {}
+          canonical_cfg = tiers_cfg[canonical] || {}
+          merged_models = merge_tier_models(canonical_cfg[:models], legacy_cfg[:models])
+          tiers_cfg[canonical] = canonical_cfg.merge(models: merged_models)
+          @warnings << "Normalized thinking tier '#{legacy}' to '#{canonical}'"
+        end
+
+        valid = valid_thinking_tiers
+        tiers_cfg.keys.each do |tier|
+          next if valid.include?(tier.to_s)
+
+          tiers_cfg.delete(tier)
+          @warnings << "Removed unsupported thinking tier '#{tier}' from configuration"
+        end
+      end
+
+      def merge_tier_models(existing_models, new_models)
+        combined = []
+        (Array(existing_models) + Array(new_models)).each do |entry|
+          next unless entry.is_a?(Hash)
+          provider = entry[:provider]
+          model = entry[:model]
+          next unless provider && model
+
+          unless combined.any? { |m| m[:provider] == provider && m[:model] == model }
+            combined << entry
+          end
+        end
+        combined
+      end
+
       def load_existing_config
         return {} unless File.exist?(config_path)
         YAML.safe_load_file(config_path, permitted_classes: [Time]) || {}
@@ -1468,6 +1791,12 @@ module Aidp
         File.exist?(File.join(project_dir, relative_path))
       end
 
+      def valid_thinking_tiers
+        Aidp::Harness::CapabilityRegistry::VALID_TIERS
+      rescue NameError
+        %w[mini standard thinking pro max]
+      end
+
       def configure_devcontainer
         prompt.say("\n🐳 Devcontainer Configuration")
         Aidp.log_debug(DEVCONTAINER_COMPONENT, "configure.start")
@@ -1482,10 +1811,18 @@ module Aidp
             path: parser.detect)
         end
 
+        # Check existing configuration for previous choice
+        existing_manage = @config.dig(:devcontainer, :manage)
+        default_manage = if existing_manage.nil?
+          existing_devcontainer ? true : false
+        else
+          existing_manage
+        end
+
         # Ask if user wants AIDP to manage devcontainer
         manage = prompt.yes?(
           "Would you like AIDP to manage your devcontainer configuration?",
-          default: (@config.dig(:devcontainer, :manage) || existing_devcontainer) ? true : false
+          default: default_manage
         )
 
         unless manage

data/lib/aidp/storage/csv_storage.rb

@@ -205,12 +205,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage.")
           end
         end
       end
@@ -225,11 +225,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/file_manager.rb

@@ -16,7 +16,7 @@ module Aidp
         csv_dir = @csv_storage.instance_variable_get(:@base_dir)
         if json_dir != @base_dir || csv_dir != @base_dir
           @base_dir = json_dir # Prefer JSON storage directory
-          Kernel.warn "[AIDP Storage] Base directory normalized to #{@base_dir} after fallback."
+          warn_storage("[AIDP Storage] Base directory normalized to #{@base_dir} after fallback.")
         end
       end
 
@@ -229,11 +229,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/json_storage.rb

@@ -171,12 +171,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage.")
           end
         end
       end
@@ -192,11 +192,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -228,12 +228,51 @@ module Aidp
         relevant.map do |comment|
           author = comment["author"] || "unknown"
           created = comment["createdAt"] ? Time.parse(comment["createdAt"]).utc.iso8601 : "unknown"
-          "### #{author} (#{created})\n#{comment["body"]}"
+          body = strip_archived_plans(comment["body"])
+          "### #{author} (#{created})\n#{body}"
         end.join("\n\n")
       rescue
         "_Unable to parse comment thread._"
       end
 
+      def strip_archived_plans(content)
+        return content unless content
+
+        # Remove all archived plan sections (wrapped in HTML comments)
+        result = content.dup
+
+        # Remove archived plan blocks
+        # Safe string-based approach to avoid ReDoS vulnerabilities
+        start_prefix = "<!-- ARCHIVED_PLAN_START"
+        end_marker = "<!-- ARCHIVED_PLAN_END -->"
+
+        loop do
+          # Find the start of an archived plan block (may have attributes after ARCHIVED_PLAN_START)
+          start_idx = result.index(start_prefix)
+          break unless start_idx
+
+          # Find the closing --> of the start marker
+          start_marker_end = result.index("-->", start_idx)
+          break unless start_marker_end
+
+          # Find the corresponding end marker
+          end_idx = result.index(end_marker, start_marker_end)
+          break unless end_idx
+
+          # Remove the entire block including markers
+          result = result[0...start_idx] + result[(end_idx + end_marker.length)..]
+        end
+
+        # Remove HTML-commented sections from active plan
+        # Keep the content between START and END markers, but strip the markers themselves
+        # This preserves the current plan while removing archived content
+        result = result.gsub(/<!-- (PLAN_SUMMARY_START|PLAN_TASKS_START|CLARIFYING_QUESTIONS_START) -->/, "")
+        result = result.gsub(/<!-- (PLAN_SUMMARY_END|PLAN_TASKS_END|CLARIFYING_QUESTIONS_END) -->/, "")
+
+        # Clean up any extra blank lines
+        result.gsub(/\n{3,}/, "\n\n").strip
+      end
+
       def write_prompt(content, working_dir: @project_dir)
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content, step_name: IMPLEMENTATION_STEP)