aidp 0.26.0 → 0.28.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,251 @@ 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
+        has_existing_tiers = all_providers.any? do |provider|
+          existing_tiers = get([:providers, provider.to_sym, :thinking_tiers])
+          existing_tiers && !existing_tiers.empty?
+        end
+
+        if has_existing_tiers
+          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 (now provider-specific)
+        tier_configs = generate_provider_tier_configurations(discovered_models)
+
+        # Show preview
+        prompt.say("\n📋 Proposed tier configuration:")
+        display_provider_tier_preview(tier_configs)
+
+        # Confirm and save
+        if prompt.yes?("\nSave this tier configuration?", default: true)
+          # Write to provider-specific paths
+          tier_configs.each do |provider, provider_tiers|
+            set([:providers, provider.to_sym, :thinking_tiers], provider_tiers)
+          end
+          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_provider_tier_configurations(discovered_models)
+        provider_configs = {}
+
+        # Organize by provider first, then by tier
+        discovered_models.each do |provider, models|
+          provider_tiers = {}
+
+          # Configure the three most common tiers: mini, standard, and pro
+          DEFAULT_AUTOCONFIG_TIERS.each do |tier|
+            tier_models = find_models_for_tier(models, tier)
+
+            # Add to config if we found any models for this tier
+            if tier_models.any?
+              provider_tiers[tier.to_sym] = {
+                models: tier_models.map { |m| m[:name] }
+              }
+            end
+          end
+
+          # Only add provider if it has at least one tier configured
+          provider_configs[provider] = provider_tiers if provider_tiers.any?
+        end
+
+        provider_configs
+      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_provider_tier_preview(provider_configs)
+        return if provider_configs.empty?
+
+        provider_configs.each do |provider, provider_tiers|
+          prompt.say("  #{provider}:")
+          provider_tiers.each do |tier, tier_config|
+            models = tier_config[:models] || []
+            prompt.say("    #{tier}:")
+            models.each do |model_name|
+              prompt.say("      - #{model_name}")
+            end
+          end
+          prompt.say("") # Blank line between providers
+        end
+      end
+
       # -------------------------------------------
       # Work loop configuration
       # -------------------------------------------
@@ -670,8 +926,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])
@@ -802,6 +1068,7 @@ module Aidp
 
         configure_watch_safety
         configure_watch_labels
+        configure_watch_label_creation
       end
 
       def configure_watch_safety
@@ -835,7 +1102,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,14 +1125,239 @@ 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
 
+      def configure_watch_label_creation
+        prompt.say("\n🏷️  GitHub Label Auto-Creation")
+        prompt.say("  Automatically create GitHub labels for watch mode if they don't exist")
+
+        Aidp.log_debug("setup_wizard.label_creation", "start")
+
+        # Ask if user wants to auto-create labels
+        unless prompt.yes?("Auto-create GitHub labels if missing?", default: true)
+          Aidp.log_debug("setup_wizard.label_creation", "user_declined")
+          return
+        end
+
+        # Check if gh CLI is available
+        unless gh_cli_available?
+          prompt.warn("⚠️  GitHub CLI (gh) not found. Install it to enable label auto-creation.")
+          prompt.say("   Visit: https://cli.github.com/")
+          Aidp.log_debug("setup_wizard.label_creation", "gh_not_available")
+          return
+        end
+
+        # Extract repository info
+        repo_info = extract_repo_info
+        unless repo_info
+          prompt.warn("⚠️  Could not determine GitHub repository from git remote.")
+          prompt.say("   Ensure you're in a git repository with a GitHub remote configured.")
+          Aidp.log_debug("setup_wizard.label_creation", "repo_info_failed")
+          return
+        end
+
+        owner, repo = repo_info
+        Aidp.log_debug("setup_wizard.label_creation", "repo_detected", owner: owner, repo: repo)
+        prompt.say("📦 Repository: #{owner}/#{repo}")
+
+        # Fetch existing labels
+        existing_labels = fetch_existing_labels(owner, repo)
+        unless existing_labels
+          prompt.warn("⚠️  Failed to fetch existing labels. Check your GitHub authentication.")
+          Aidp.log_debug("setup_wizard.label_creation", "fetch_labels_failed")
+          return
+        end
+
+        Aidp.log_debug("setup_wizard.label_creation", "existing_labels_fetched", count: existing_labels.size)
+
+        # Get configured label names
+        labels_config = get([:watch, :labels]) || {}
+        required_labels = collect_required_labels(labels_config)
+
+        # Determine which labels need to be created
+        labels_to_create = required_labels.reject { |label| existing_labels.include?(label[:name]) }
+
+        if labels_to_create.empty?
+          prompt.ok("✅ All required labels already exist!")
+          Aidp.log_debug("setup_wizard.label_creation", "all_labels_exist")
+          return
+        end
+
+        # Show labels to be created
+        prompt.say("\n📝 Labels to create:")
+        labels_to_create.each do |label|
+          prompt.say("  • #{label[:name]} (#{label[:color]})")
+        end
+
+        # Confirm creation
+        unless prompt.yes?("Create these labels?", default: true)
+          Aidp.log_debug("setup_wizard.label_creation", "creation_declined")
+          return
+        end
+
+        # Create labels
+        create_labels(owner, repo, labels_to_create)
+      end
+
+      # Check if gh CLI is available
+      def gh_cli_available?
+        require "open3"
+        _stdout, _stderr, status = Open3.capture3("gh", "--version")
+        Aidp.log_debug("setup_wizard.gh_check", "version_check", success: status.success?)
+        status.success?
+      rescue Errno::ENOENT
+        Aidp.log_debug("setup_wizard.gh_check", "not_found")
+        false
+      end
+
+      # Extract repository owner and name from git remote
+      def extract_repo_info
+        require "open3"
+        stdout, stderr, status = Open3.capture3("git", "remote", "get-url", "origin")
+
+        unless status.success?
+          Aidp.log_debug("setup_wizard.repo_extraction", "git_remote_failed", error: stderr)
+          return nil
+        end
+
+        remote_url = stdout.strip
+        Aidp.log_debug("setup_wizard.repo_extraction", "remote_url_found", url: remote_url)
+
+        # Parse GitHub URL (supports both HTTPS and SSH formats)
+        # HTTPS: https://github.com/owner/repo.git
+        # SSH: git@github.com:owner/repo.git
+        if remote_url =~ %r{github\.com[:/]([^/]+)/(.+?)(?:\.git)?$}
+          owner = Regexp.last_match(1)
+          repo = Regexp.last_match(2)
+          Aidp.log_debug("setup_wizard.repo_extraction", "parsed", owner: owner, repo: repo)
+          [owner, repo]
+        else
+          Aidp.log_debug("setup_wizard.repo_extraction", "parse_failed", url: remote_url)
+          nil
+        end
+      rescue => e
+        Aidp.log_error("setup_wizard.repo_extraction", "exception", error: e.message)
+        nil
+      end
+
+      # Fetch existing labels from GitHub
+      def fetch_existing_labels(owner, repo)
+        require "open3"
+        stdout, stderr, status = Open3.capture3("gh", "label", "list", "-R", "#{owner}/#{repo}", "--json", "name", "--jq", ".[].name")
+
+        unless status.success?
+          Aidp.log_error("setup_wizard.fetch_labels", "gh_failed", error: stderr)
+          return nil
+        end
+
+        labels = stdout.strip.split("\n").map(&:strip).reject(&:empty?)
+        Aidp.log_debug("setup_wizard.fetch_labels", "fetched", count: labels.size)
+        labels
+      rescue => e
+        Aidp.log_error("setup_wizard.fetch_labels", "exception", error: e.message)
+        nil
+      end
+
+      # Collect required labels with their default colors
+      def collect_required_labels(labels_config)
+        default_colors = {
+          plan_trigger: "0E8A16",        # Green
+          needs_input: "D93F0B",         # Red
+          ready_to_build: "0075CA",      # Blue
+          build_trigger: "5319E7",       # Purple
+          review_trigger: "FBCA04",      # Yellow
+          ci_fix_trigger: "D93F0B",      # Red
+          change_request_trigger: "F9D0C4",  # Light pink
+          in_progress: "1D76DB"          # Dark blue (internal coordination)
+        }
+
+        required = []
+        labels_config.each do |key, name|
+          next if name.nil? || name.to_s.strip.empty?
+
+          color = default_colors[key] || "EDEDED"  # Gray fallback
+          required << {name: name, color: color, key: key}
+        end
+
+        # Always include the internal in-progress label for coordination
+        required << {
+          name: "aidp-in-progress",
+          color: default_colors[:in_progress],
+          key: :in_progress,
+          internal: true
+        }
+
+        Aidp.log_debug("setup_wizard.collect_labels", "collected", count: required.size)
+        required
+      end
+
+      # Create labels on GitHub
+      def create_labels(owner, repo, labels)
+        require "open3"
+
+        created = 0
+        failed = 0
+
+        labels.each do |label|
+          Aidp.log_debug("setup_wizard.create_label", "creating", name: label[:name], color: label[:color])
+
+          _stdout, stderr, status = Open3.capture3(
+            "gh", "label", "create", label[:name],
+            "--color", label[:color],
+            "-R", "#{owner}/#{repo}"
+          )
+
+          if status.success?
+            prompt.ok("  ✅ Created: #{label[:name]}")
+            Aidp.log_info("setup_wizard.create_label", "success", name: label[:name])
+            created += 1
+          else
+            prompt.warn("  ⚠️  Failed to create: #{label[:name]} - #{stderr.strip}")
+            Aidp.log_error("setup_wizard.create_label", "failed", name: label[:name], error: stderr.strip)
+            failed += 1
+          end
+        rescue => e
+          prompt.warn("  ⚠️  Error creating #{label[:name]}: #{e.message}")
+          Aidp.log_error("setup_wizard.create_label", "exception", name: label[:name], error: e.message)
+          failed += 1
+        end
+
+        # Summary
+        prompt.say("")
+        if created > 0
+          prompt.ok("✅ Successfully created #{created} label#{"s" unless created == 1}")
+        end
+        if failed > 0
+          prompt.warn("⚠️  Failed to create #{failed} label#{"s" unless failed == 1}")
+        end
+
+        Aidp.log_info("setup_wizard.create_labels", "complete", created: created, failed: failed)
+      end
+
       # -------------------------------------------
       # Preview & persistence
       # -------------------------------------------
@@ -953,9 +1445,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 +1717,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 +1830,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 +2001,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 +2021,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.28.0"
 end