aidp 0.26.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/version.rb

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

data/lib/aidp/watch/plan_generator.rb

@@ -29,32 +29,103 @@ module Aidp
       def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
         @verbose = verbose
+        @providers_attempted = []
       end
 
       def generate(issue)
-        provider = resolve_provider
-        if provider
-          generate_with_provider(provider, issue)
-        else
-          display_message("⚠️  No active provider available. Falling back to heuristic plan.", type: :warn)
-          heuristic_plan(issue)
+        Aidp.log_debug("plan_generator", "generate.start", provider: @provider_name, issue: issue[:number])
+
+        # Try providers in fallback chain order
+        providers_to_try = build_provider_fallback_chain
+        Aidp.log_debug("plan_generator", "fallback_chain", providers: providers_to_try, count: providers_to_try.size)
+
+        providers_to_try.each do |provider_name|
+          next if @providers_attempted.include?(provider_name)
+
+          Aidp.log_debug("plan_generator", "trying_provider", provider: provider_name, attempted: @providers_attempted)
+
+          provider = resolve_provider(provider_name)
+          unless provider
+            Aidp.log_debug("plan_generator", "provider_unavailable", provider: provider_name, reason: "not resolved")
+            @providers_attempted << provider_name
+            next
+          end
+
+          begin
+            Aidp.log_info("plan_generator", "generate_with_provider", provider: provider_name, issue: issue[:number])
+            result = generate_with_provider(provider, issue, provider_name)
+            if result
+              Aidp.log_info("plan_generator", "generation_success", provider: provider_name, issue: issue[:number])
+              return result
+            end
+
+            # Provider returned nil - try next provider
+            Aidp.log_warn("plan_generator", "provider_returned_nil", provider: provider_name)
+            @providers_attempted << provider_name
+          rescue => e
+            # Log error and try next provider in chain
+            Aidp.log_warn("plan_generator", "provider_failed", provider: provider_name, error: e.message, error_class: e.class.name)
+            @providers_attempted << provider_name
+          end
         end
+
+        # All providers exhausted, fall back to heuristic
+        Aidp.log_warn("plan_generator", "all_providers_exhausted", attempted: @providers_attempted, falling_back: "heuristic")
+        display_message("⚠️  All providers unavailable or failed. Falling back to heuristic plan.", type: :warn)
+        heuristic_plan(issue)
       rescue => e
-        display_message("⚠️  Plan generation failed (#{e.message}). Using heuristic.", type: :warn)
+        Aidp.log_error("plan_generator", "generation_failed_unexpectedly", error: e.message, backtrace: e.backtrace&.first(3))
+        display_message("⚠️  Plan generation failed unexpectedly (#{e.message}). Using heuristic.", type: :warn)
         heuristic_plan(issue)
       end
 
       private
 
-      def resolve_provider
-        provider_name = @provider_name || detect_default_provider
+      def build_provider_fallback_chain
+        # Start with specified provider or default
+        primary_provider = @provider_name || detect_default_provider
+        providers = []
+
+        # Add primary provider first
+        providers << primary_provider if primary_provider
+
+        # Try to get fallback chain from config
+        begin
+          config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+          fallback_providers = config_manager.fallback_providers || []
+
+          # Add fallback providers that aren't already in the list
+          fallback_providers.each do |fallback|
+            providers << fallback unless providers.include?(fallback)
+          end
+        rescue => e
+          Aidp.log_debug("plan_generator", "config_fallback_unavailable", error: e.message)
+        end
+
+        # If we still have no providers, add cursor as last resort
+        providers << "cursor" if providers.empty?
+
+        # Remove duplicates while preserving order
+        providers.uniq
+      end
+
+      def resolve_provider(provider_name = nil)
+        provider_name ||= @provider_name || detect_default_provider
         return nil unless provider_name
 
+        Aidp.log_debug("plan_generator", "resolve_provider", provider: provider_name)
+
         provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
-        return provider if provider&.available?
 
+        if provider&.available?
+          Aidp.log_debug("plan_generator", "provider_resolved", provider: provider_name, available: true)
+          return provider
+        end
+
+        Aidp.log_debug("plan_generator", "provider_not_available", provider: provider_name, available: provider&.available?)
         nil
       rescue => e
+        Aidp.log_warn("plan_generator", "resolve_provider_failed", provider: provider_name, error: e.message)
         display_message("⚠️  Failed to resolve provider #{provider_name}: #{e.message}", type: :warn)
         nil
       end
@@ -66,9 +137,11 @@ module Aidp
         "cursor"
       end
 
-      def generate_with_provider(provider, issue)
+      def generate_with_provider(provider, issue, provider_name = "unknown")
         payload = build_prompt(issue)
 
+        Aidp.log_debug("plan_generator", "sending_to_provider", provider: provider_name, prompt_length: payload.length)
+
         if @verbose
           display_message("\n--- Plan Generation Prompt ---", type: :muted)
           display_message(payload.strip, type: :muted)
@@ -77,6 +150,8 @@ module Aidp
 
         response = provider.send_message(prompt: payload)
 
+        Aidp.log_debug("plan_generator", "provider_response_received", provider: provider_name, response_length: response&.length || 0)
+
         if @verbose
           display_message("\n--- Provider Response ---", type: :muted)
           display_message(response.strip, type: :muted)
@@ -85,10 +160,14 @@ module Aidp
 
         parsed = parse_structured_response(response)
 
-        return parsed if parsed
+        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)
+          return parsed
+        end
 
-        display_message("⚠️  Unable to parse provider response. Using heuristic plan.", type: :warn)
-        heuristic_plan(issue)
+        Aidp.log_warn("plan_generator", "parse_failed", provider: provider_name)
+        display_message("⚠️  Unable to parse #{provider_name} response. Trying next provider.", type: :warn)
+        nil
       end
 
       def build_prompt(issue)

data/lib/aidp/watch/review_processor.rb

@@ -23,7 +23,7 @@ module Aidp
 
       attr_reader :review_label
 
-      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false)
+      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false, reviewers: nil)
         @repository_client = repository_client
         @state_store = state_store
         @provider_name = provider_name
@@ -33,8 +33,8 @@ module Aidp
         # Load label configuration
         @review_label = label_config[:review_trigger] || label_config["review_trigger"] || DEFAULT_REVIEW_LABEL
 
-        # Initialize reviewers
-        @reviewers = [
+        # Initialize reviewers (allow dependency injection for testing)
+        @reviewers = reviewers || [
           Reviewers::SeniorDevReviewer.new(provider_name: provider_name),
           Reviewers::SecurityReviewer.new(provider_name: provider_name),
           Reviewers::PerformanceReviewer.new(provider_name: provider_name)

data/lib/aidp/workflows/guided_agent.rb

@@ -19,7 +19,7 @@ module Aidp
 
       class ConversationError < StandardError; end
 
-      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false)
+      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false, config_manager: nil, provider_manager: nil)
         @project_dir = project_dir
 
         # Use EnhancedInput with Reline for full readline-style key bindings
@@ -29,8 +29,8 @@ module Aidp
           prompt || TTY::Prompt.new
         end
 
-        @config_manager = Aidp::Harness::ConfigManager.new(project_dir)
-        @provider_manager = Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
+        @config_manager = config_manager || Aidp::Harness::ConfigManager.new(project_dir)
+        @provider_manager = provider_manager || Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
         @conversation_history = []
         @user_input = {}
         @verbose = verbose

data/templates/aidp-development.yml.example

@@ -137,7 +137,7 @@ providers:
       file_upload: true
       code_generation: true
       analysis: true
-      streaming: true
+      supports_json_mode: true
 
     # Monitoring configuration (enhanced for development)
     monitoring:
@@ -243,7 +243,7 @@ providers:
       code_generation: true
       analysis: true
       vision: true
-      streaming: true
+      supports_json_mode: true
       function_calling: true
       tool_use: true