aidp 0.22.0 → 0.24.0

data/lib/aidp/providers/error_taxonomy.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Providers
+    # ErrorTaxonomy defines the five standardized error categories that all providers
+    # use for consistent error handling, retry logic, and escalation.
+    #
+    # Categories:
+    # - rate_limited: Provider is rate-limiting requests (switch provider immediately)
+    # - auth_expired: Authentication credentials are invalid or expired (escalate or switch)
+    # - quota_exceeded: Usage quota has been exceeded (switch provider)
+    # - transient: Temporary error that may resolve on retry (retry with backoff)
+    # - permanent: Permanent error that won't resolve with retry (escalate or abort)
+    #
+    # @see https://github.com/viamin/aidp/issues/243
+    module ErrorTaxonomy
+      # Error category constants
+      RATE_LIMITED = :rate_limited
+      AUTH_EXPIRED = :auth_expired
+      QUOTA_EXCEEDED = :quota_exceeded
+      TRANSIENT = :transient
+      PERMANENT = :permanent
+
+      # All valid error categories
+      CATEGORIES = [
+        RATE_LIMITED,
+        AUTH_EXPIRED,
+        QUOTA_EXCEEDED,
+        TRANSIENT,
+        PERMANENT
+      ].freeze
+
+      # Default error patterns for common error messages
+      # Providers can override these with provider-specific patterns
+      DEFAULT_PATTERNS = {
+        rate_limited: [
+          /rate.?limit/i,
+          /too.?many.?requests/i,
+          /429/,
+          /throttl(ed|ing)/i,
+          /request.?limit/i,
+          /requests.?per.?minute/i,
+          /rpm.?exceeded/i
+        ],
+        auth_expired: [
+          /auth(entication|orization).?(fail(ed|ure)|error)/i,
+          /invalid.?(api.?key|token|credential)/i,
+          /expired.?(api.?key|token|credential)/i,
+          /unauthorized/i,
+          /401/,
+          /403/,
+          /permission.?denied/i,
+          /access.?denied/i
+        ],
+        quota_exceeded: [
+          /quota.?(exceed(ed)?|limit|exhausted)/i,
+          /usage.?limit/i,
+          /billing.?limit/i,
+          /credit.?limit/i,
+          /insufficient.?quota/i,
+          /usage.?cap/i
+        ],
+        transient: [
+          /timeout/i,
+          /timed?.?out/i,
+          /connection.?(reset|refused|lost|closed)/i,
+          /temporary.?error/i,
+          /try.?again/i,
+          /service.?unavailable/i,
+          /503/,
+          /502/,
+          /504/,
+          /gateway.?timeout/i,
+          /network.?error/i,
+          /socket.?error/i,
+          /connection.?error/i,
+          /broken.?pipe/i,
+          /host.?unreachable/i
+        ],
+        permanent: [
+          /invalid.?(model|parameter|request|input)/i,
+          /unsupported.?(operation|feature|model)/i,
+          /not.?found/i,
+          /404/,
+          /bad.?request/i,
+          /400/,
+          /malformed/i,
+          /syntax.?error/i,
+          /validation.?error/i,
+          /model.?not.?available/i,
+          /model.?deprecated/i
+        ]
+      }.freeze
+
+      # Retry policy for each category
+      RETRY_POLICIES = {
+        rate_limited: {
+          retry: false,
+          switch_provider: true,
+          escalate: false,
+          backoff_strategy: :none
+        },
+        auth_expired: {
+          retry: false,
+          switch_provider: true,
+          escalate: true,
+          backoff_strategy: :none
+        },
+        quota_exceeded: {
+          retry: false,
+          switch_provider: true,
+          escalate: false,
+          backoff_strategy: :none
+        },
+        transient: {
+          retry: true,
+          switch_provider: false,
+          escalate: false,
+          backoff_strategy: :exponential
+        },
+        permanent: {
+          retry: false,
+          switch_provider: false,
+          escalate: true,
+          backoff_strategy: :none
+        }
+      }.freeze
+
+      # Check if a category is valid
+      # @param category [Symbol] category to check
+      # @return [Boolean] true if valid
+      def self.valid_category?(category)
+        CATEGORIES.include?(category)
+      end
+
+      # Get retry policy for a category
+      # @param category [Symbol] error category
+      # @return [Hash] retry policy configuration
+      def self.retry_policy(category)
+        RETRY_POLICIES[category] || RETRY_POLICIES[:transient]
+      end
+
+      # Classify an error message using default patterns
+      # @param message [String] error message
+      # @return [Symbol] error category
+      def self.classify_message(message)
+        return :transient if message.nil? || message.empty?
+
+        message_lower = message.downcase
+
+        # Check each category's patterns
+        DEFAULT_PATTERNS.each do |category, patterns|
+          patterns.each do |pattern|
+            return category if message_lower.match?(pattern)
+          end
+        end
+
+        # Default to transient for unknown errors
+        :transient
+      end
+
+      # Check if an error category is retryable
+      # @param category [Symbol] error category
+      # @return [Boolean] true if should retry
+      def self.retryable?(category)
+        policy = retry_policy(category)
+        policy[:retry] == true
+      end
+
+      # Check if an error category should trigger provider switch
+      # @param category [Symbol] error category
+      # @return [Boolean] true if should switch provider
+      def self.should_switch_provider?(category)
+        policy = retry_policy(category)
+        policy[:switch_provider] == true
+      end
+
+      # Check if an error category should be escalated
+      # @param category [Symbol] error category
+      # @return [Boolean] true if should escalate
+      def self.should_escalate?(category)
+        policy = retry_policy(category)
+        policy[:escalate] == true
+      end
+
+      # Get backoff strategy for a category
+      # @param category [Symbol] error category
+      # @return [Symbol] backoff strategy (:none, :linear, :exponential)
+      def self.backoff_strategy(category)
+        policy = retry_policy(category)
+        policy[:backoff_strategy] || :none
+      end
+    end
+  end
+end

data/lib/aidp/providers/gemini.rb

@@ -36,11 +36,12 @@ module Aidp
         end
 
         begin
+          command_args = ["--prompt", prompt]
           # Use debug_execute_command with streaming support
-          result = debug_execute_command("gemini", args: ["--print"], input: prompt, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("gemini", args: command_args, timeout: timeout_seconds, streaming: streaming_enabled)
 
           # Log the results
-          debug_command("gemini", args: ["--print"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+          debug_command("gemini", args: command_args, input: nil, output: result.out, error: result.err, exit_code: result.exit_status)
 
           if result.exit_status == 0
             result.out

data/lib/aidp/setup/devcontainer/backup_manager.rb

@@ -10,9 +10,10 @@ module Aidp
       class BackupManager
         class BackupError < StandardError; end
 
-        def initialize(project_dir)
+        def initialize(project_dir, clock: Time)
           @project_dir = project_dir
           @backup_dir = File.join(project_dir, ".aidp", "backups", "devcontainer")
+          @clock = clock
         end
 
         # Create a backup of the devcontainer file
@@ -26,7 +27,7 @@ module Aidp
 
           ensure_backup_directory_exists
 
-          timestamp = Time.now.utc.strftime("%Y%m%d_%H%M%S")
+          timestamp = current_time.utc.strftime("%Y%m%d_%H%M%S")
           backup_filename = "devcontainer-#{timestamp}.json"
           backup_path = File.join(@backup_dir, backup_filename)
 
@@ -163,11 +164,17 @@ module Aidp
         end
 
         def parse_timestamp(timestamp_str)
-          return Time.now if timestamp_str.nil?
+          return current_time if timestamp_str.nil?
 
           Time.strptime(timestamp_str, "%Y%m%d_%H%M%S")
         rescue ArgumentError
-          Time.now
+          current_time
+        end
+
+        attr_reader :clock
+
+        def current_time
+          clock.respond_to?(:call) ? clock.call : clock.now
         end
       end
     end

data/lib/aidp/setup/provider_registry.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Setup
+    # Centralized registry for provider metadata including billing types and model families.
+    # This module provides a single source of truth for provider configuration options.
+    module ProviderRegistry
+      # Billing type options for providers
+      BILLING_TYPES = [
+        {
+          label: "Subscription / flat-rate",
+          value: "subscription",
+          description: "Monthly or annual subscription with unlimited usage"
+        },
+        {
+          label: "Usage-based / metered (API)",
+          value: "usage_based",
+          description: "Pay per API call or token usage"
+        },
+        {
+          label: "Passthrough / local (no billing)",
+          value: "passthrough",
+          description: "Local execution or proxy without direct billing"
+        }
+      ].freeze
+
+      # Model family options for providers
+      MODEL_FAMILIES = [
+        {
+          label: "Auto (let provider decide)",
+          value: "auto",
+          description: "Use provider's default model selection"
+        },
+        {
+          label: "OpenAI o-series (reasoning models)",
+          value: "openai_o",
+          description: "Advanced reasoning capabilities, slower but more thorough"
+        },
+        {
+          label: "Anthropic Claude (balanced)",
+          value: "claude",
+          description: "Balanced performance for general-purpose tasks"
+        },
+        {
+          label: "Mistral (European/open)",
+          value: "mistral",
+          description: "European provider with open-source focus"
+        },
+        {
+          label: "Local LLM (self-hosted)",
+          value: "local",
+          description: "Self-hosted or local model execution"
+        }
+      ].freeze
+
+      # Returns array of [label, value] pairs for billing types
+      def self.billing_type_choices
+        BILLING_TYPES.map { |bt| [bt[:label], bt[:value]] }
+      end
+
+      # Returns array of [label, value] pairs for model families
+      def self.model_family_choices
+        MODEL_FAMILIES.map { |mf| [mf[:label], mf[:value]] }
+      end
+
+      # Finds label for a given billing type value
+      def self.billing_type_label(value)
+        BILLING_TYPES.find { |bt| bt[:value] == value }&.dig(:label) || value
+      end
+
+      # Finds label for a given model family value
+      def self.model_family_label(value)
+        MODEL_FAMILIES.find { |mf| mf[:value] == value }&.dig(:label) || value
+      end
+
+      # Finds description for a given billing type value
+      def self.billing_type_description(value)
+        BILLING_TYPES.find { |bt| bt[:value] == value }&.dig(:description)
+      end
+
+      # Finds description for a given model family value
+      def self.model_family_description(value)
+        MODEL_FAMILIES.find { |mf| mf[:value] == value }&.dig(:description)
+      end
+
+      # Validates if a billing type value is valid
+      def self.valid_billing_type?(value)
+        BILLING_TYPES.any? { |bt| bt[:value] == value }
+      end
+
+      # Validates if a model family value is valid
+      def self.valid_model_family?(value)
+        MODEL_FAMILIES.any? { |mf| mf[:value] == value }
+      end
+
+      # Returns all valid billing type values
+      def self.billing_type_values
+        BILLING_TYPES.map { |bt| bt[:value] }
+      end
+
+      # Returns all valid model family values
+      def self.model_family_values
+        MODEL_FAMILIES.map { |mf| mf[:value] }
+      end
+    end
+  end
+end

data/lib/aidp/setup/wizard.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
+require "tty-table"
 require "yaml"
 require "time"
 require "fileutils"
@@ -8,6 +9,7 @@ require "json"
 
 require_relative "../util"
 require_relative "../config/paths"
+require_relative "provider_registry"
 require_relative "devcontainer/parser"
 require_relative "devcontainer/generator"
 require_relative "devcontainer/port_manager"
@@ -260,7 +262,10 @@ module Aidp
                 editable = ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
               end
             else
-              edit_provider_configuration(to_edit)
+              # Edit the selected provider or offer to remove it
+              edit_or_remove_provider(to_edit, provider_choice, cleaned_fallbacks)
+              # Refresh editable list after potential removal
+              editable = ([provider_choice] + cleaned_fallbacks).uniq.reject { |p| p == "custom" }
             end
           end
         end
@@ -786,6 +791,79 @@ module Aidp
           watch_enabled: watch,
           quick_mode_default: quick_mode
         })
+
+        # Configure watch mode settings if enabled
+        configure_watch_mode if watch
+      end
+
+      def configure_watch_mode
+        prompt.say("\n👀 Watch Mode Configuration")
+        prompt.say("-" * 40)
+
+        configure_watch_safety
+        configure_watch_labels
+      end
+
+      def configure_watch_safety
+        prompt.say("\n🔒 Watch mode safety settings")
+        existing = get([:watch, :safety]) || {}
+
+        allow_public_repos = prompt.yes?(
+          "Allow watch mode on public repositories?",
+          default: existing.fetch(:allow_public_repos, false)
+        )
+
+        prompt.say("\n📝 Author allowlist (GitHub usernames allowed to trigger watch mode)")
+        prompt.say("  Leave empty to allow all authors (not recommended for public repos)")
+        author_allowlist = ask_list(
+          "Author allowlist (comma-separated GitHub usernames)",
+          existing[:author_allowlist] || [],
+          allow_empty: true
+        )
+
+        require_container = prompt.yes?(
+          "Require watch mode to run in a container?",
+          default: existing.fetch(:require_container, true)
+        )
+
+        set([:watch, :safety], {
+          allow_public_repos: allow_public_repos,
+          author_allowlist: author_allowlist,
+          require_container: require_container
+        })
+      end
+
+      def configure_watch_labels
+        prompt.say("\n🏷️  Watch mode label configuration")
+        prompt.say("  Configure GitHub issue labels that trigger watch mode actions")
+        existing = get([:watch, :labels]) || {}
+
+        plan_trigger = ask_with_default(
+          "Label to trigger plan generation",
+          existing[:plan_trigger] || "aidp-plan"
+        )
+
+        needs_input = ask_with_default(
+          "Label for plans needing user input",
+          existing[:needs_input] || "aidp-needs-input"
+        )
+
+        ready_to_build = ask_with_default(
+          "Label for plans ready to build",
+          existing[:ready_to_build] || "aidp-ready"
+        )
+
+        build_trigger = ask_with_default(
+          "Label to trigger implementation",
+          existing[:build_trigger] || "aidp-build"
+        )
+
+        set([:watch, :labels], {
+          plan_trigger: plan_trigger,
+          needs_input: needs_input,
+          ready_to_build: ready_to_build,
+          build_trigger: build_trigger
+        })
       end
 
       # -------------------------------------------
@@ -816,6 +894,7 @@ module Aidp
           .sub(/^nfrs:/, "# Non-functional requirements to reference during planning\nnfrs:")
           .sub(/^logging:/, "# Logging configuration\nlogging:")
           .sub(/^modes:/, "# Defaults for background/watch/quick modes\nmodes:")
+          .sub(/^watch:/, "# Watch mode safety and label configuration\nwatch:")
       end
 
       def display_preview(yaml_content)
@@ -1041,22 +1120,81 @@ module Aidp
       end
 
       def show_provider_summary(primary, fallbacks)
+        Aidp.log_debug("wizard.provider_summary", "displaying provider configuration table", primary: primary, fallback_count: fallbacks&.size || 0)
         prompt.say("\n📋 Provider Configuration Summary:")
         providers_config = get([:providers]) || {}
 
-        # Show primary
+        rows = []
+
+        # Add primary provider to table
         if primary && primary != "custom"
           primary_cfg = providers_config[primary.to_sym] || {}
-          prompt.say("  ✓ Primary: #{primary} (#{primary_cfg[:type] || "not configured"}, #{primary_cfg[:model_family] || "auto"})")
+          rows << [
+            "Primary",
+            primary,
+            primary_cfg[:type] || "not configured",
+            primary_cfg[:model_family] || "auto"
+          ]
         end
 
-        # Show fallbacks
+        # Add fallback providers to table
         if fallbacks && !fallbacks.empty?
-          fallbacks.each do |fallback|
+          fallbacks.each_with_index do |fallback, index|
             fallback_cfg = providers_config[fallback.to_sym] || {}
-            prompt.say("  ✓ Fallback: #{fallback} (#{fallback_cfg[:type] || "not configured"}, #{fallback_cfg[:model_family] || "auto"})")
+            rows << [
+              "Fallback #{index + 1}",
+              fallback,
+              fallback_cfg[:type] || "not configured",
+              fallback_cfg[:model_family] || "auto"
+            ]
           end
         end
+
+        # Detect duplicate providers with identical characteristics
+        duplicates = detect_duplicate_providers(rows)
+        if duplicates.any?
+          Aidp.log_warn("wizard.provider_summary", "duplicate provider configurations detected", duplicates: duplicates)
+        end
+
+        if rows.any?
+          table = TTY::Table.new(
+            header: ["Role", "Provider", "Billing Type", "Model Family"],
+            rows: rows
+          )
+          prompt.say(table.render(:unicode, padding: [0, 1]))
+
+          # Show warning for duplicates
+          if duplicates.any?
+            prompt.say("")
+            prompt.warn("⚠️  Duplicate configurations detected:")
+            duplicates.each do |dup|
+              prompt.say("   • #{dup[:providers].join(" and ")} have identical billing type (#{dup[:type]}) and model family (#{dup[:family]})")
+            end
+            prompt.say("   Consider using different providers or model families for better redundancy.")
+          end
+        else
+          prompt.say("  (No providers configured)")
+        end
+      end
+
+      def detect_duplicate_providers(rows)
+        # Group providers by their billing type and model family
+        # Returns array of duplicate groups with identical characteristics
+        duplicates = []
+        config_groups = rows.group_by { |row| [row[2], row[3]] }
+
+        config_groups.each do |(type, family), group|
+          next if group.size < 2
+          next if type == "not configured" # Skip unconfigured providers
+
+          duplicates << {
+            providers: group.map { |row| row[1] },
+            type: type,
+            family: family
+          }
+        end
+
+        duplicates
       end
 
       # Ensure a minimal billing configuration exists for a selected provider (no secrets)
@@ -1089,6 +1227,42 @@ module Aidp
         prompt.say("  • #{action_word.capitalize} provider '#{display_name}' (#{provider_name}) with billing type '#{provider_type}' and model family '#{model_family}'")
       end
 
+      def edit_or_remove_provider(provider_name, primary_provider, fallbacks)
+        is_primary = (provider_name == primary_provider)
+        display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
+
+        action = prompt.select("What would you like to do with '#{display_name}'?") do |menu|
+          menu.choice "Edit configuration", :edit
+          unless is_primary
+            menu.choice "Remove from configuration", :remove
+          end
+          menu.choice "Cancel", :cancel
+        end
+
+        case action
+        when :edit
+          edit_provider_configuration(provider_name)
+        when :remove
+          if is_primary
+            prompt.warn("Cannot remove primary provider. Change primary provider first.")
+          else
+            remove_fallback_provider(provider_name, fallbacks)
+          end
+        when :cancel
+          Aidp.log_debug("wizard.edit_provider", "user cancelled edit operation", provider: provider_name)
+        end
+      end
+
+      def remove_fallback_provider(provider_name, fallbacks)
+        display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
+        if prompt.yes?("Remove '#{display_name}' from fallback providers?", default: false)
+          fallbacks.delete(provider_name)
+          set([:harness, :fallback_providers], fallbacks)
+          Aidp.log_info("wizard.remove_provider", "removed fallback provider", provider: provider_name)
+          prompt.ok("Removed '#{display_name}' from fallback providers")
+        end
+      end
+
       def edit_provider_configuration(provider_name)
         existing = get([:providers, provider_name.to_sym]) || {}
         prompt.say("\n🔧 Editing provider '#{provider_name}' (current: type=#{existing[:type] || "unset"}, model_family=#{existing[:model_family] || "unset"})")
@@ -1104,54 +1278,38 @@ module Aidp
         ask_provider_billing_type_with_default(provider_name, nil)
       end
 
-      BILLING_TYPE_CHOICES = [
-        ["Subscription / flat-rate", "subscription"],
-        ["Usage-based / metered (API)", "usage_based"],
-        ["Passthrough / local (no billing)", "passthrough"]
-      ].freeze
-
       def ask_provider_billing_type_with_default(provider_name, default_value)
-        default_label = BILLING_TYPE_CHOICES.find { |label, value| value == default_value }&.first
+        choices = ProviderRegistry.billing_type_choices
+        default_label = choices.find { |label, value| value == default_value }&.first
         suffix = default_value ? " (current: #{default_value})" : ""
         prompt.select("Billing model for #{provider_name}:#{suffix}", default: default_label) do |menu|
-          BILLING_TYPE_CHOICES.each do |label, value|
+          choices.each do |label, value|
             menu.choice(label, value)
           end
         end
       end
 
-      MODEL_FAMILY_CHOICES = [
-        ["Auto (let provider decide)", "auto"],
-        ["OpenAI o-series (reasoning models)", "openai_o"],
-        ["Anthropic Claude (balanced)", "claude"],
-        ["Mistral (European/open)", "mistral"],
-        ["Local LLM (self-hosted)", "local"]
-      ].freeze
-
       def ask_model_family(provider_name, default = "auto")
         # TTY::Prompt validates defaults against the displayed choice labels, not values.
         # Map the value default (e.g. "auto") to its corresponding label.
-        default_label = MODEL_FAMILY_CHOICES.find { |label, value| value == default }&.first
+        choices = ProviderRegistry.model_family_choices
+        default_label = choices.find { |label, value| value == default }&.first
 
         prompt.select("Preferred model family for #{provider_name}:", default: default_label) do |menu|
-          MODEL_FAMILY_CHOICES.each do |label, value|
+          choices.each do |label, value|
             menu.choice(label, value)
           end
         end
       end
 
       # Canonicalization helpers ------------------------------------------------
-      MODEL_FAMILY_LABEL_TO_VALUE = MODEL_FAMILY_CHOICES.each_with_object({}) do |(label, value), h|
-        h[label] = value
-      end.freeze
-      MODEL_FAMILY_VALUES = MODEL_FAMILY_CHOICES.map { |(_, value)| value }.freeze
-
       def normalize_model_family(value)
         return "auto" if value.nil? || value.to_s.strip.empty?
         # Already a canonical value
-        return value if MODEL_FAMILY_VALUES.include?(value)
+        return value if ProviderRegistry.valid_model_family?(value)
         # Try label -> value
-        mapped = MODEL_FAMILY_LABEL_TO_VALUE[value]
+        choices = ProviderRegistry.model_family_choices
+        mapped = choices.find { |label, _| label == value }&.last
         return mapped if mapped
         # Unknown legacy entry -> fallback to auto
         "auto"

data/lib/aidp/version.rb

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