aidp 0.14.1 → 0.14.2

data/lib/aidp/harness/provider_manager.rb

@@ -2,12 +2,14 @@
 
 require "tty-prompt"
 require_relative "provider_factory"
+require_relative "../rescue_logging"
 
 module Aidp
   module Harness
     # Manages provider switching and fallback logic
     class ProviderManager
       include Aidp::MessageDisplay
+      include Aidp::RescueLogging
 
       def initialize(configuration, prompt: TTY::Prompt.new)
         @configuration = configuration
@@ -69,6 +71,8 @@ module Aidp
 
       # Switch to next available provider with sophisticated fallback logic
       def switch_provider(reason = "manual_switch", context = {})
+        Aidp.logger.info("provider_manager", "Attempting provider switch", reason: reason, current: current_provider, **context)
+
         # Get fallback chain for current provider
         provider_fallback_chain = fallback_chain(current_provider)
 
@@ -79,7 +83,10 @@ module Aidp
           success = set_current_provider(next_provider, reason, context)
           if success
             log_provider_switch(current_provider, next_provider, reason, context)
+            Aidp.logger.info("provider_manager", "Provider switched successfully", from: current_provider, to: next_provider, reason: reason)
             return next_provider
+          else
+            Aidp.logger.warn("provider_manager", "Failed to switch to provider", provider: next_provider, reason: reason)
           end
         end
 
@@ -107,14 +114,21 @@ module Aidp
 
         # No providers available
         log_no_providers_available(reason, context)
+        Aidp.logger.error("provider_manager", "No providers available for fallback", reason: reason, **context)
         nil
       end
 
       # Switch provider for specific error type
       def switch_provider_for_error(error_type, error_details = {})
+        Aidp.logger.warn("provider_manager", "Error triggered provider switch", error_type: error_type, **error_details)
+
         case error_type
         when "rate_limit"
           switch_provider("rate_limit", error_details)
+        when "resource_exhausted", "quota_exceeded"
+          # Treat capacity/resource exhaustion like rate limit for fallback purposes
+          Aidp.logger.warn("provider_manager", "Resource/quota exhaustion detected", classified_from: error_type)
+          switch_provider("rate_limit", error_details.merge(classified_from: error_type))
         when "authentication"
           switch_provider("authentication_error", error_details)
         when "network"
@@ -269,9 +283,27 @@ module Aidp
 
       # Set current provider with enhanced validation
       def set_current_provider(provider_name, reason = "manual_switch", context = {})
-        return false unless @configuration.provider_configured?(provider_name)
-        return false unless is_provider_healthy?(provider_name)
-        return false if is_provider_circuit_breaker_open?(provider_name)
+        # Use provider_config for ConfigManager, provider_configured? for legacy Configuration
+        config_exists = if @configuration.respond_to?(:provider_config)
+          @configuration.provider_config(provider_name)
+        else
+          @configuration.provider_configured?(provider_name)
+        end
+
+        unless config_exists
+          Aidp.logger.warn("provider_manager", "Provider not configured", provider: provider_name)
+          return false
+        end
+
+        unless is_provider_healthy?(provider_name)
+          Aidp.logger.warn("provider_manager", "Provider not healthy", provider: provider_name)
+          return false
+        end
+
+        if is_provider_circuit_breaker_open?(provider_name)
+          Aidp.logger.warn("provider_manager", "Provider circuit breaker open", provider: provider_name)
+          return false
+        end
 
         # Update provider health
         update_provider_health(provider_name, "switched_to")
@@ -292,6 +324,7 @@ module Aidp
         @current_model = default_model(provider_name)
 
         @current_provider = provider_name
+        Aidp.logger.info("provider_manager", "Provider activated", provider: provider_name, reason: reason)
         true
       end
 
@@ -468,11 +501,24 @@ module Aidp
       # Build default fallback chain
       def build_default_fallback_chain(provider_name)
         all_providers = configured_providers
-        fallback_chain = all_providers.dup
-        fallback_chain.delete(provider_name)
-        fallback_chain.unshift(provider_name) # Put current provider first
-        @fallback_chains[provider_name] = fallback_chain
-        fallback_chain
+
+        # Harness-defined explicit ordering has priority
+        harness_fallbacks = if @configuration.respond_to?(:fallback_providers)
+          Array(@configuration.fallback_providers).map(&:to_s)
+        else
+          []
+        end
+
+        # Construct ordered chain:
+        # 1. current provider first
+        # 2. harness fallback providers (excluding current and de-duplicated)
+        # 3. any remaining configured providers not already listed
+        ordered = [provider_name]
+        ordered += harness_fallbacks.reject { |p| p == provider_name || ordered.include?(p) }
+        ordered += all_providers.reject { |p| ordered.include?(p) }
+
+        @fallback_chains[provider_name] = ordered
+        ordered
       end
 
       # Find next healthy provider in fallback chain
@@ -1008,7 +1054,8 @@ module Aidp
             require_relative "../providers/cursor"
             installed = Aidp::Providers::Cursor.available?
           end
-        rescue LoadError
+        rescue LoadError => e
+          log_rescue(e, component: "provider_manager", action: "check_provider_availability", fallback: false, provider: provider_name)
           installed = false
         end
         @unavailable_cache[provider_name] = installed
@@ -1048,7 +1095,8 @@ module Aidp
         end
         path = begin
           Aidp::Util.which(binary)
-        rescue
+        rescue => e
+          log_rescue(e, component: "provider_manager", action: "locate_binary", fallback: nil, binary: binary)
           nil
         end
         unless path
@@ -1074,13 +1122,15 @@ module Aidp
             # Timeout -> kill
             begin
               Process.kill("TERM", pid)
-            rescue
+            rescue => e
+              log_rescue(e, component: "provider_manager", action: "kill_timeout_process_term", fallback: nil, binary: binary, pid: pid)
               nil
             end
             sleep 0.1
             begin
               Process.kill("KILL", pid)
-            rescue
+            rescue => e
+              log_rescue(e, component: "provider_manager", action: "kill_timeout_process_kill", fallback: nil, binary: binary, pid: pid)
               nil
             end
             ok = false
@@ -1093,6 +1143,7 @@ module Aidp
             ok = true
           end
         rescue => e
+          log_rescue(e, component: "provider_manager", action: "verify_binary_health", fallback: "binary_error", binary: binary)
           ok = false
           reason = e.class.name.downcase.include?("enoent") ? "binary_missing" : "binary_error"
         end
@@ -1340,6 +1391,7 @@ module Aidp
           }
         }
       rescue => e
+        log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, prompt_length: prompt.length)
         # Return error result
         {
           status: "error",

data/lib/aidp/jobs/background_runner.rb

@@ -3,6 +3,7 @@
 require "securerandom"
 require "yaml"
 require "fileutils"
+require_relative "../rescue_logging"
 
 module Aidp
   module Jobs
@@ -10,6 +11,7 @@ module Aidp
     # Runs harness in daemon process and tracks job metadata
     class BackgroundRunner
       include Aidp::MessageDisplay
+      include Aidp::RescueLogging
 
       attr_reader :project_dir, :jobs_dir
 
@@ -55,6 +57,7 @@ module Aidp
             puts "[#{Time.now}] Job completed with status: #{result[:status]}"
             mark_job_completed(job_id, result)
           rescue => e
+            log_rescue(e, component: "background_runner", action: "execute_job", fallback: "mark_failed", job_id: job_id, mode: mode)
             puts "[#{Time.now}] Job failed with error: #{e.message}"
             puts e.backtrace.join("\n")
             mark_job_failed(job_id, e)
@@ -136,11 +139,13 @@ module Aidp
 
           mark_job_stopped(job_id)
           {success: true, message: "Job stopped successfully"}
-        rescue Errno::ESRCH
+        rescue Errno::ESRCH => e
+          log_rescue(e, component: "background_runner", action: "stop_job", fallback: "mark_stopped", job_id: job_id, pid: pid, level: :info)
           # Process already dead
           mark_job_stopped(job_id)
           {success: true, message: "Job was already stopped"}
         rescue => e
+          log_rescue(e, component: "background_runner", action: "stop_job", fallback: "error_result", job_id: job_id, pid: pid)
           {success: false, message: "Failed to stop job: #{e.message}"}
         end
       end
@@ -244,7 +249,8 @@ module Aidp
 
         Process.kill(0, pid)
         true
-      rescue Errno::ESRCH, Errno::EPERM
+      rescue Errno::ESRCH, Errno::EPERM => e
+        log_rescue(e, component: "background_runner", action: "check_process_running", fallback: false, pid: pid, level: :debug)
         false
       end
 
@@ -252,7 +258,8 @@ module Aidp
         # Try to load checkpoint from project directory
         checkpoint = Aidp::Execute::Checkpoint.new(@project_dir)
         checkpoint.latest_checkpoint
-      rescue
+      rescue => e
+        log_rescue(e, component: "background_runner", action: "get_job_checkpoint", fallback: nil, job_id: job_id)
         nil
       end
 

data/lib/aidp/logger.rb

@@ -16,7 +16,7 @@ module Aidp
   # Usage:
   #   Aidp.setup_logger(project_dir, config)
   #   Aidp.logger.info("component", "message", key: "value")
-  class AidpLogger
+  class Logger
     LEVELS = {
       debug: ::Logger::DEBUG,
       info: ::Logger::INFO,
@@ -26,7 +26,6 @@ module Aidp
 
     LOG_DIR = ".aidp/logs"
     INFO_LOG = "#{LOG_DIR}/aidp.log"
-    DEBUG_LOG = "#{LOG_DIR}/aidp_debug.log"
 
     DEFAULT_MAX_SIZE = 10 * 1024 * 1024 # 10MB
     DEFAULT_MAX_FILES = 5
@@ -42,8 +41,7 @@ module Aidp
       @max_files = config[:max_backups] || DEFAULT_MAX_FILES
 
       ensure_log_directory
-      migrate_old_logs if should_migrate?
-      setup_loggers
+      setup_logger
     end
 
     # Log info level message
@@ -74,23 +72,12 @@ module Aidp
       safe_message = redact(message)
       safe_metadata = redact_hash(metadata)
 
-      # Log to appropriate file(s)
-      if level == :debug
-        write_to_debug(level, component, safe_message, safe_metadata)
-      else
-        write_to_info(level, component, safe_message, safe_metadata)
-      end
-
-      # Always log errors to both files
-      if level == :error
-        write_to_debug(level, component, safe_message, safe_metadata)
-      end
+      write_entry(level, component, safe_message, safe_metadata)
     end
 
     # Close all loggers
     def close
-      @info_logger&.close
-      @debug_logger&.close
+      @logger&.close
     end
 
     private
@@ -111,12 +98,9 @@ module Aidp
       FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
     end
 
-    def setup_loggers
+    def setup_logger
       info_path = File.join(@project_dir, INFO_LOG)
-      debug_path = File.join(@project_dir, DEBUG_LOG)
-
-      @info_logger = create_logger(info_path)
-      @debug_logger = create_logger(debug_path)
+      @logger = create_logger(info_path)
     end
 
     def create_logger(path)
@@ -126,14 +110,9 @@ module Aidp
       logger
     end
 
-    def write_to_info(level, component, message, metadata)
+    def write_entry(level, component, message, metadata)
       entry = format_entry(level, component, message, metadata)
-      @info_logger.send(logger_method(level), entry)
-    end
-
-    def write_to_debug(level, component, message, metadata)
-      entry = format_entry(level, component, message, metadata)
-      @debug_logger.send(logger_method(level), entry)
+      @logger.send(logger_method(level), entry)
     end
 
     def logger_method(level)
@@ -205,58 +184,18 @@ module Aidp
     def redact_hash(hash)
       hash.transform_values { |v| v.is_a?(String) ? redact(v) : v }
     end
-
-    # Migration from old debug_logs location
-    OLD_DEBUG_DIR = ".aidp/debug_logs"
-    OLD_DEBUG_LOG = "#{OLD_DEBUG_DIR}/aidp_debug.log"
-
-    def should_migrate?
-      old_path = File.join(@project_dir, OLD_DEBUG_LOG)
-      new_path = File.join(@project_dir, DEBUG_LOG)
-
-      # Migrate if old exists and new doesn't
-      File.exist?(old_path) && !File.exist?(new_path)
-    end
-
-    def migrate_old_logs
-      old_path = File.join(@project_dir, OLD_DEBUG_LOG)
-      new_path = File.join(@project_dir, DEBUG_LOG)
-
-      begin
-        FileUtils.mv(old_path, new_path)
-        log_migration_notice
-      rescue => e
-        # If migration fails, just continue (new logs will be created)
-        warn "Failed to migrate old logs: #{e.message}"
-      end
-    end
-
-    def log_migration_notice
-      notice = format_text(
-        :info,
-        "migration",
-        "Logs migrated from .aidp/debug_logs/ to .aidp/logs/",
-        timestamp: Time.now.utc.iso8601
-      )
-
-      # Write directly to avoid recursion
-      info_path = File.join(@project_dir, INFO_LOG)
-      File.open(info_path, "a") do |f|
-        f.puts notice
-      end
-    end
   end
 
   # Module-level logger accessor
   class << self
     # Set up global logger instance
     def setup_logger(project_dir = Dir.pwd, config = {})
-      @logger = AidpLogger.new(project_dir, config)
+      @logger = Logger.new(project_dir, config)
     end
 
     # Get current logger instance (creates default if not set up)
     def logger
-      @logger ||= AidpLogger.new
+      @logger ||= Logger.new
     end
 
     # Convenience logging methods

data/lib/aidp/providers/base.rb

@@ -5,6 +5,8 @@ require "tty-spinner"
 
 module Aidp
   module Providers
+    class ProviderUnavailableError < StandardError; end
+
     class Base
       include Aidp::MessageDisplay
 

data/lib/aidp/providers/github_copilot.rb

@@ -86,6 +86,16 @@ module Aidp
           # Log the results
           debug_command("copilot", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
 
+          # Detect authorization/access errors
+          auth_error = result.err.to_s =~ /not authorized|requires an enterprise|access denied|permission denied|not enabled/i
+          if auth_error
+            spinner.error("✗")
+            mark_failed("copilot authorization error: #{result.err}")
+            @unavailable = true
+            debug_error(StandardError.new("copilot authorization error"), {exit_code: result.exit_status, stderr: result.err})
+            raise Aidp::Providers::ProviderUnavailableError.new("copilot authorization error: #{result.err}")
+          end
+
           if result.exit_status == 0
             spinner.success("✓")
             mark_completed
@@ -96,6 +106,8 @@ module Aidp
             debug_error(StandardError.new("copilot failed"), {exit_code: result.exit_status, stderr: result.err})
             raise "copilot failed with exit code #{result.exit_status}: #{result.err}"
           end
+        rescue Aidp::Providers::ProviderUnavailableError
+          raise
         rescue => e
           spinner&.error("✗")
           mark_failed("copilot execution failed: #{e.message}")

data/lib/aidp/rescue_logging.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+module Aidp
+  # Mixin providing a unified helper for logging rescued exceptions.
+  # Usage:
+  #   include Aidp::RescueLogging
+  #   rescue => e
+  #     log_rescue(e, component: "storage", action: "store file", fallback: {success: false})
+  #
+  # Defaults:
+  #   - level: :warn (so filtering WARN surfaces rescue sites)
+  #   - includes error class, message
+  #   - optional fallback and extra context hash merged in
+  module RescueLogging
+    def log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+      data = {
+        error_class: error.class.name,
+        error_message: error.message,
+        action: action
+      }
+      data[:fallback] = fallback if fallback
+      data.merge!(context) unless context.empty?
+
+      # Prefer debug_mixin if present; otherwise use Aidp.logger directly
+      if respond_to?(:debug_log)
+        debug_log("⚠️ Rescue in #{component}: #{action}", level: level, data: data)
+      else
+        Aidp.logger.send(level, component, "Rescued exception during #{action}", **data)
+      end
+    rescue => logging_error
+      # Last resort: avoid raising from logging path - fall back to STDERR
+      warn "[AIDP Rescue Logging Error] Failed to log rescue for #{component}:#{action} - #{error.class}: #{error.message} (logging error: #{logging_error.message})"
+    end
+  end
+end

data/lib/aidp/setup/wizard.rb

@@ -143,46 +143,35 @@ module Aidp
         # Save primary provider
         set([:harness, :default_provider], provider_choice) unless provider_choice == "custom"
 
-        # Prompt for fallback providers (excluding the primary)
+        ensure_provider_billing_config(provider_choice) unless provider_choice == "custom"
+
+        # Prompt for fallback providers (excluding the primary), pre-select existing
+        existing_fallbacks = Array(get([:harness, :fallback_providers])).map(&:to_s) - [provider_choice]
         fallback_choices = available_providers.reject { |_, name| name == provider_choice }
-        fallback_selected = prompt.multi_select("Select fallback providers (used if primary fails):") do |menu|
+        fallback_selected = prompt.multi_select("Select fallback providers (used if primary fails):", default: existing_fallbacks) do |menu|
           fallback_choices.each do |display_name, provider_name|
             menu.choice display_name, provider_name
           end
         end
 
-        # Remove any accidental duplication of primary provider & save
+        # If user selected none but we had existing fallbacks, confirm removal
+        if fallback_selected.empty? && existing_fallbacks.any?
+          keep = prompt.no?("No fallbacks selected. Remove existing fallbacks (#{existing_fallbacks.join(", ")})?", default: false)
+          fallback_selected = existing_fallbacks if keep
+        end
+
+        # Remove any accidental duplication of primary provider & save (preserve order)
         cleaned_fallbacks = fallback_selected.reject { |name| name == provider_choice }
         set([:harness, :fallback_providers], cleaned_fallbacks)
 
-        # No LLM settings needed; provider agent handles LLM config
+        # Auto-create minimal provider configs for fallbacks if missing
+        cleaned_fallbacks.each { |fp| ensure_provider_billing_config(fp) }
 
-        configure_mcp
-        show_provider_secrets_help(provider_choice)
+        # Provide informational note (no secret handling stored)
+        show_provider_info_note(provider_choice) unless provider_choice == "custom"
       end
 
-      def configure_mcp
-        existing = get([:providers, :mcp]) || {}
-        enabled = prompt.yes?("Enable MCP (Model Context Protocol) tools?", default: existing.fetch(:enabled, true))
-        return delete_path([:providers, :mcp]) unless enabled
-
-        # TODO: Add default back once TTY-Prompt default validation issue is resolved
-        tools = prompt.multi_select("Select MCP tools:") do |menu|
-          menu.choice "Git", "git"
-          menu.choice "Shell", "shell"
-          menu.choice "Filesystem", "fs"
-          menu.choice "Browser", "browser"
-          menu.choice "GitHub", "github"
-        end
-
-        custom = ask_list("Custom MCP servers (comma-separated)", existing.fetch(:custom_servers, []))
-
-        set([:providers, :mcp], {
-          enabled: true,
-          tools: tools,
-          custom_servers: custom
-        }.compact)
-      end
+      # Removed MCP configuration step (MCP now expected to be provider-specific if used)
 
       # -------------------------------------------
       # Work loop configuration
@@ -621,27 +610,34 @@ module Aidp
         :other
       end
 
-      def default_model(provider)
-        case provider
-        when "anthropic" then "claude-3-5-sonnet-20241022"
-        when "openai" then "gpt-4.1"
-        when "google" then "gemini-1.5-pro"
-        when "azure" then "gpt-4"
-        else "claude-3-5-sonnet-20241022"
+      def show_provider_info_note(provider)
+        prompt.say("\n💡 Provider integration:")
+        prompt.say("AIDP does not store API keys or model lists. Configure the agent (#{provider}) externally.")
+        prompt.say("Only the billing model (subscription vs usage_based) is recorded for fallback decisions.")
+      end
+
+      # Ensure a minimal billing configuration exists for a selected provider (no secrets)
+      def ensure_provider_billing_config(provider_name)
+        return if provider_name.nil? || provider_name == "custom"
+        providers_section = get([:providers]) || {}
+        existing = providers_section[provider_name.to_sym]
+
+        if existing && existing[:type]
+          prompt.say("  • Provider '#{provider_name}' already configured (type: #{existing[:type]})")
+          return
         end
+
+        provider_type = ask_provider_billing_type(provider_name)
+        set([:providers, provider_name.to_sym], {type: provider_type})
+        prompt.say("  • Added provider '#{provider_name}' with billing type '#{provider_type}' (no secrets stored)")
       end
 
-      def show_provider_secrets_help(provider)
-        prompt.say("\n💡 Provider setup:")
-        case provider
-        when "anthropic"
-          prompt.say("Export API key: export ANTHROPIC_API_KEY=sk-ant-...")
-        when "openai", "azure"
-          prompt.say("Export API key: export OPENAI_API_KEY=sk-...")
-        when "google"
-          prompt.say("Export API key: export GOOGLE_API_KEY=...")
-        else
-          prompt.say("Configure API credentials via environment variables.")
+      def ask_provider_billing_type(provider_name)
+        prompt.select("Billing model for #{provider_name}:") do |menu|
+          menu.choice "Subscription / flat-rate", "subscription"
+          # e.g. tools that expose an integrated model under a subscription cost
+          menu.choice "Usage-based / metered (API)", "usage_based"
+          menu.choice "Passthrough / local (no billing)", "passthrough"
         end
       end
 

data/lib/aidp/storage/csv_storage.rb

@@ -2,11 +2,14 @@
 
 require "csv"
 require "fileutils"
+require "aidp/rescue_logging"
 
 module Aidp
   module Storage
     # Simple CSV file storage for tabular data
     class CsvStorage
+      include Aidp::RescueLogging
+
       def initialize(base_dir = ".aidp")
         @base_dir = base_dir
         ensure_directory_exists
@@ -42,11 +45,13 @@ module Aidp
           success: true
         }
       rescue => error
-        {
+        log_rescue(error,
+          component: "csv_storage",
+          action: "append",
+          fallback: {success: false},
           filename: filename,
-          error: error.message,
-          success: false
-        }
+          path: file_path)
+        {filename: filename, error: error.message, success: false}
       end
 
       # Read all rows from CSV file
@@ -60,7 +65,12 @@ module Aidp
         end
         rows
       rescue => error
-        puts "Error reading #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        log_rescue(error,
+          component: "csv_storage",
+          action: "read_all",
+          fallback: [],
+          filename: filename,
+          path: (defined?(file_path) ? file_path : nil))
         []
       end
 
@@ -83,7 +93,12 @@ module Aidp
         CSV.foreach(file_path) { count += 1 }
         count - 1 # Subtract 1 for header row
       rescue => error
-        puts "Error counting rows in #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        log_rescue(error,
+          component: "csv_storage",
+          action: "count_rows",
+          fallback: 0,
+          filename: filename,
+          path: (defined?(file_path) ? file_path : nil))
         0
       end
 
@@ -127,7 +142,12 @@ module Aidp
 
         summary_data
       rescue => error
-        puts "Error generating summary for #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        log_rescue(error,
+          component: "csv_storage",
+          action: "summary",
+          fallback: nil,
+          filename: filename,
+          path: (defined?(file_path) ? file_path : nil))
         nil
       end
 
@@ -144,6 +164,12 @@ module Aidp
         File.delete(file_path)
         {success: true, message: "File deleted"}
       rescue => error
+        log_rescue(error,
+          component: "csv_storage",
+          action: "delete",
+          fallback: {success: false},
+          filename: filename,
+          path: file_path)
         {success: false, error: error.message}
       end