aidp 0.14.1 → 0.15.0

data/lib/aidp/execute/work_loop_unit_scheduler.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "deterministic_unit"
+require_relative "../logger"
+
+module Aidp
+  module Execute
+    class WorkLoopUnitScheduler
+      Unit = Struct.new(:type, :name, :definition, keyword_init: true) do
+        def agentic?
+          type == :agentic
+        end
+
+        def deterministic?
+          type == :deterministic
+        end
+      end
+
+      attr_reader :last_agentic_summary
+
+      def initialize(units_config, clock: Time)
+        @clock = clock
+        @deterministic_definitions = build_deterministic_definitions(units_config[:deterministic])
+        @defaults = default_options.merge(units_config[:defaults] || {})
+        @pending_units = []
+        @deterministic_history = []
+        @deterministic_state = Hash.new { |h, key| h[key] = default_deterministic_state }
+        @agentic_runs = []
+        @last_agentic_summary = nil
+        @consecutive_deciders = 0
+        @completed = false
+        @started = false
+      end
+
+      def next_unit
+        return nil if @completed
+
+        unless @started
+          @started = true
+          queue_requested_unit(@defaults[:initial_unit] || :agentic)
+        end
+
+        unit = @pending_units.shift
+        return unit if unit
+
+        queue_requested_unit(@defaults[:on_no_next_step] || :agentic)
+
+        @pending_units.shift
+      end
+
+      def record_agentic_result(result, requested_next: nil, summary: nil, completed: false)
+        @last_agentic_summary = summarize(summary)
+        @agentic_runs << {timestamp: @clock.now, result: result}
+
+        queue_requested_unit(requested_next) if requested_next
+
+        mark_completed if completed && !requested_next
+      end
+
+      def record_deterministic_result(definition, result)
+        state = @deterministic_state[definition.name]
+        state[:last_run_at] = result.finished_at
+
+        state[:current_backoff] = if result.success? || result.status == :event
+          definition.min_interval_seconds
+        else
+          [
+            state[:current_backoff] * definition.backoff_multiplier,
+            definition.max_backoff_seconds
+          ].min
+        end
+
+        @deterministic_history << {
+          name: definition.name,
+          status: result.status,
+          output_path: result.output_path,
+          finished_at: result.finished_at,
+          data: result.data
+        }
+
+        requested = definition.next_for(result.status)
+        queue_requested_unit(requested) if requested
+      end
+
+      def deterministic_context(limit: 5)
+        @deterministic_history.last(limit)
+      end
+
+      def completed?
+        @completed
+      end
+
+      private
+
+      def summarize(summary)
+        return nil unless summary
+        content = summary.to_s.strip
+        return nil if content.empty?
+        (content.length > 500) ? "#{content[0...500]}…" : content
+      end
+
+      def mark_completed
+        @completed = true
+        @pending_units.clear
+      end
+
+      def queue_requested_unit(identifier)
+        return if identifier.nil?
+
+        case identifier.to_sym
+        when :agentic
+          enqueue_agentic(:primary)
+        when :decide_whats_next
+          enqueue_agentic(:decide_whats_next)
+        else
+          enqueue_deterministic(identifier.to_s)
+        end
+      rescue NoMethodError
+        enqueue_agentic(:primary)
+      end
+
+      def enqueue_agentic(name)
+        if name == :decide_whats_next
+          if @consecutive_deciders >= @defaults[:max_consecutive_deciders]
+            enqueue_agentic(:primary)
+            return
+          end
+          @consecutive_deciders += 1
+        else
+          @consecutive_deciders = 0
+        end
+
+        @pending_units << Unit.new(type: :agentic, name: name)
+      end
+
+      def enqueue_deterministic(name)
+        definition = @deterministic_definitions[name]
+        unless definition
+          enqueue_agentic((@defaults[:fallback_agentic] || :agentic).to_sym)
+          return
+        end
+        return unless definition.enabled
+
+        state = @deterministic_state[definition.name]
+        state[:current_backoff] ||= definition.min_interval_seconds
+
+        if cooldown_remaining(definition).positive?
+          enqueue_agentic((@defaults[:fallback_agentic] || :agentic).to_sym)
+          return
+        end
+
+        @pending_units << Unit.new(type: :deterministic, name: definition.name, definition: definition)
+      end
+
+      def cooldown_remaining(definition)
+        state = @deterministic_state[definition.name]
+        state[:current_backoff] ||= definition.min_interval_seconds
+
+        return 0 unless state[:last_run_at]
+
+        next_allowed_at = state[:last_run_at] + state[:current_backoff]
+        remaining = next_allowed_at - @clock.now
+        remaining.positive? ? remaining : 0
+      end
+
+      def build_deterministic_definitions(config_list)
+        Array(config_list).each_with_object({}) do |config, mapping|
+          definition = DeterministicUnits::Definition.new(config.transform_keys(&:to_sym))
+          mapping[definition.name] = definition
+        rescue KeyError, ArgumentError => e
+          Aidp.logger.warn("work_loop", "Skipping invalid deterministic unit configuration",
+            name: config[:name], error: e.message)
+        end
+      end
+
+      def default_deterministic_state
+        {last_run_at: nil, current_backoff: nil}
+      end
+
+      def default_options
+        {
+          initial_unit: :agentic,
+          on_no_next_step: :agentic,
+          fallback_agentic: :decide_whats_next,
+          max_consecutive_deciders: 1
+        }
+      end
+    end
+  end
+end

data/lib/aidp/harness/config_schema.rb

@@ -374,7 +374,8 @@ module Aidp
                 enabled: true,
                 max_iterations: 50,
                 test_commands: [],
-                lint_commands: []
+                lint_commands: [],
+                units: {}
               },
               properties: {
                 enabled: {
@@ -405,6 +406,95 @@ module Aidp
                     type: :string
                   }
                 },
+                units: {
+                  type: :hash,
+                  required: false,
+                  default: {},
+                  properties: {
+                    deterministic: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :hash,
+                        properties: {
+                          name: {
+                            type: :string,
+                            required: true
+                          },
+                          command: {
+                            type: :string,
+                            required: false
+                          },
+                          type: {
+                            type: :string,
+                            required: false,
+                            enum: ["command", "wait"]
+                          },
+                          output_file: {
+                            type: :string,
+                            required: false
+                          },
+                          enabled: {
+                            type: :boolean,
+                            required: false,
+                            default: true
+                          },
+                          min_interval_seconds: {
+                            type: :integer,
+                            required: false,
+                            min: 1
+                          },
+                          max_backoff_seconds: {
+                            type: :integer,
+                            required: false,
+                            min: 1
+                          },
+                          backoff_multiplier: {
+                            type: :number,
+                            required: false,
+                            min: 1.0
+                          },
+                          metadata: {
+                            type: :hash,
+                            required: false,
+                            default: {}
+                          },
+                          next: {
+                            type: :hash,
+                            required: false,
+                            default: {}
+                          }
+                        }
+                      }
+                    },
+                    defaults: {
+                      type: :hash,
+                      required: false,
+                      default: {},
+                      properties: {
+                        initial_unit: {
+                          type: :string,
+                          required: false
+                        },
+                        on_no_next_step: {
+                          type: :string,
+                          required: false
+                        },
+                        fallback_agentic: {
+                          type: :string,
+                          required: false
+                        },
+                        max_consecutive_deciders: {
+                          type: :integer,
+                          required: false,
+                          min: 1,
+                          max: 10
+                        }
+                      }
+                    }
+                  }
+                },
                 guards: {
                   type: :hash,
                   required: false,

data/lib/aidp/harness/configuration.rb

@@ -150,6 +150,10 @@ module Aidp
         harness_config[:work_loop] || default_work_loop_config
       end
 
+      def work_loop_units_config
+        work_loop_config[:units] || default_units_config
+      end
+
       # Check if work loops are enabled
       def work_loop_enabled?
         work_loop_config[:enabled]
@@ -483,7 +487,62 @@ module Aidp
           max_iterations: 50,
           test_commands: [],
           lint_commands: [],
-          guards: default_guards_config
+          guards: default_guards_config,
+          units: default_units_config
+        }
+      end
+
+      def default_units_config
+        {
+          deterministic: [
+            {
+              name: "run_full_tests",
+              command: "bundle exec rake spec",
+              output_file: ".aidp/out/run_full_tests.yml",
+              enabled: false,
+              min_interval_seconds: 300,
+              max_backoff_seconds: 1800,
+              next: {
+                success: :agentic,
+                failure: :decide_whats_next,
+                else: :decide_whats_next
+              }
+            },
+            {
+              name: "run_lint",
+              command: "bundle exec standardrb",
+              output_file: ".aidp/out/run_lint.yml",
+              enabled: false,
+              min_interval_seconds: 300,
+              max_backoff_seconds: 1800,
+              next: {
+                success: :agentic,
+                failure: :decide_whats_next,
+                else: :decide_whats_next
+              }
+            },
+            {
+              name: "wait_for_github",
+              type: :wait,
+              output_file: ".aidp/out/wait_for_github.yml",
+              metadata: {
+                interval_seconds: 60,
+                backoff_seconds: 60
+              },
+              min_interval_seconds: 60,
+              max_backoff_seconds: 900,
+              next: {
+                event: :agentic,
+                else: :wait_for_github
+              }
+            }
+          ],
+          defaults: {
+            initial_unit: :agentic,
+            on_no_next_step: :wait_for_github,
+            fallback_agentic: :decide_whats_next,
+            max_consecutive_deciders: 1
+          }
         }
       end
 

data/lib/aidp/harness/enhanced_runner.rb

@@ -81,6 +81,8 @@ module Aidp
         @state = STATES[:running]
         @start_time = Time.now
 
+        Aidp.logger.info("harness_runner", "Starting harness execution", mode: @mode, workflow_type: @workflow_type, steps_count: @selected_steps.size)
+
         @tui.show_message("🚀 Starting #{@mode.to_s.capitalize} Mode", :info)
 
         begin

data/lib/aidp/harness/provider_info.rb

@@ -3,11 +3,14 @@
 require "json"
 require "yaml"
 require "fileutils"
+require_relative "../rescue_logging"
 
 module Aidp
   module Harness
     # Stores detailed information about AI providers gathered from their CLI tools
     class ProviderInfo
+      include Aidp::RescueLogging
+
       attr_reader :provider_name, :info_file_path
 
       def initialize(provider_name, root_dir = nil)
@@ -56,6 +59,7 @@ module Aidp
 
         YAML.safe_load_file(@info_file_path, permitted_classes: [Time, Symbol])
       rescue => e
+        log_rescue(e, component: "provider_info", action: "load_yaml", fallback: nil, provider: @provider_name, path: @info_file_path)
         warn "Failed to load provider info for #{@provider_name}: #{e.message}"
         nil
       end
@@ -133,7 +137,8 @@ module Aidp
 
         last_checked = Time.parse(info[:last_checked].to_s)
         (Time.now - last_checked) > max_age
-      rescue
+      rescue => e
+        log_rescue(e, component: "provider_info", action: "parse_last_checked_time", fallback: true, provider: @provider_name, timestamp: info[:last_checked])
         true
       end
 
@@ -147,6 +152,7 @@ module Aidp
 
         provider_instance.fetch_mcp_servers
       rescue => e
+        log_rescue(e, component: "provider_info", action: "fetch_mcp_servers", fallback: [], provider: @provider_name)
         warn "Failed to fetch MCP servers for #{@provider_name}: #{e.message}" if ENV["AIDP_DEBUG"]
         []
       end
@@ -157,7 +163,8 @@ module Aidp
         # Try to find the binary
         path = begin
           Aidp::Util.which(binary_name)
-        rescue
+        rescue => e
+          log_rescue(e, component: "provider_info", action: "locate_provider_binary", fallback: nil, provider: @provider_name, binary: binary_name)
           nil
         end
         return nil unless path
@@ -183,7 +190,8 @@ module Aidp
               Process.kill("TERM", pid)
               sleep 0.1
               Process.kill("KILL", pid)
-            rescue
+            rescue => e
+              log_rescue(e, component: "provider_info", action: "kill_timeout_provider_command", fallback: nil, provider: @provider_name, binary: binary_name, pid: pid)
               nil
             end
             return nil
@@ -192,7 +200,8 @@ module Aidp
           output = r.read
           r.close
           output
-        rescue
+        rescue => e
+          log_rescue(e, component: "provider_info", action: "execute_provider_command", fallback: nil, provider: @provider_name, binary: binary_name, args: args)
           nil
         end
       end
@@ -355,6 +364,7 @@ module Aidp
         # Create provider instance
         @provider_instance = provider_class.new
       rescue => e
+        log_rescue(e, component: "provider_info", action: "create_provider_instance", fallback: nil, provider: @provider_name)
         warn "Failed to create provider instance for #{@provider_name}: #{e.message}" if ENV["AIDP_DEBUG"]
         nil
       end

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