aidp 0.19.1 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25ff9a05d33bc6dc88dfac85b9fc37ff5023af5f756c1d7b2533b1d2f473b103
-  data.tar.gz: 11f7a0c6ca6d1c8b2f9f13475fe7d8a2ba9851f2ba09037264e6808171291d62
+  metadata.gz: d4fbf6c86d50426f952b62da4b353cce6560aa5321c33d641a972a3af5989456
+  data.tar.gz: da684c72ccdc0d4770d3029a0977f592a9f9baf8e1ce4c14df47ccfbda559b38
 SHA512:
-  metadata.gz: e05fe743a66e0370dff5a60194c824a71e1d99e8ffcbea03786ab9f8b98e7983ff9a01ce48bf6d2ac8f294781d9808715181f9d92f292dc6bfa4ca568a3a4175
-  data.tar.gz: 59774b09928fbc2e1b6e1023247aa5b2b1208531a965c2fe8c05f9012b2cb03a94a9ccf7dc6029a77086ed6f425a9570c3860b241a50094a6dd71c4053f782b6
+  metadata.gz: bf57b96f9393e533508624fabe2ca3bdc8e49a241a68f6404c144d124ab0c19c4f3cea415e8e8e2f4a7d3145e06e23f86f2207e61414b8397ea929304ae29f96
+  data.tar.gz: f15ca608bda7e5ed3358c9b633b7d415ce943e99d9a10a74f114de3e31373daec0d4ae52d01000bbb42c6950b252e50ad13daa176c4d32932a6f98b2153a678b

data/lib/aidp/cli/issue_importer.rb

@@ -4,20 +4,30 @@ require "json"
 require "net/http"
 require "uri"
 require "open3"
+require "timeout"
 
 module Aidp
   # Handles importing GitHub issues into AIDP work loops
   class IssueImporter
     include Aidp::MessageDisplay
 
+    COMPONENT = "issue_importer"
+
     # Initialize the importer
     #
     # @param gh_available [Boolean, nil] (test-only) forcibly sets whether gh CLI is considered
     #   available. When nil (default) we auto-detect. This enables deterministic specs without
     #   depending on developer environment.
     def initialize(gh_available: nil, enable_bootstrap: true)
-      @gh_available = gh_available.nil? ? gh_cli_available? : gh_available
+      disabled_via_env = ENV["AIDP_DISABLE_GH_CLI"] == "1"
+      @gh_available = if disabled_via_env
+        false
+      else
+        gh_available.nil? ? gh_cli_available? : gh_available
+      end
       @enable_bootstrap = enable_bootstrap
+      Aidp.log_debug(COMPONENT, "Initialized importer", gh_available: @gh_available, enable_bootstrap: @enable_bootstrap, disabled_via_env: disabled_via_env)
+      Aidp.log_debug(COMPONENT, "GitHub CLI disabled via env flag") if disabled_via_env
     end
 
     def import_issue(identifier)
@@ -81,16 +91,28 @@ module Aidp
       return nil unless match
 
       owner, repo, number = match[1], match[2], match[3]
+      Aidp.log_debug(COMPONENT, "Fetching issue data", owner: owner, repo: repo, number: number, via: (@gh_available ? "gh_cli" : "api"))
 
       # First try GitHub CLI if available (works for private repos)
       if @gh_available
         display_message("🔍 Fetching issue via GitHub CLI...", type: :info)
+        Aidp.log_debug(COMPONENT, "Attempting GitHub CLI fetch", owner: owner, repo: repo, number: number)
         issue_data = fetch_via_gh_cli(owner, repo, number)
-        return issue_data if issue_data
+        if issue_data
+          Aidp.log_debug(COMPONENT, "GitHub CLI fetch succeeded", owner: owner, repo: repo, number: number)
+          return issue_data
+        end
+        Aidp.log_debug(COMPONENT, "GitHub CLI fetch failed, falling back to API", owner: owner, repo: repo, number: number)
       end
 
       # Fallback to public API
       display_message("🔍 Fetching issue via GitHub API...", type: :info)
+      Aidp.log_debug(COMPONENT, "Fetching issue via GitHub API", owner: owner, repo: repo, number: number)
+      fixture = test_fixture(owner, repo, number)
+      if fixture
+        Aidp.log_debug(COMPONENT, "Using test fixture for issue fetch", owner: owner, repo: repo, number: number, status: fixture["status"])
+        return handle_test_fixture(fixture, owner, repo, number)
+      end
       fetch_via_api(owner, repo, number)
     end
 
@@ -101,9 +123,12 @@ module Aidp
         "--json", "title,body,labels,milestone,comments,state,assignees,number,url"
       ]
 
-      stdout, stderr, status = Open3.capture3(*cmd)
+      Aidp.log_debug(COMPONENT, "Running gh cli", owner: owner, repo: repo, number: number, command: cmd.join(" "))
+      stdout, stderr, status = capture3_with_timeout(*cmd, timeout: gh_cli_timeout)
+      Aidp.log_debug(COMPONENT, "Completed gh cli", owner: owner, repo: repo, number: number, exitstatus: status.exitstatus)
 
       unless status.success?
+        Aidp.log_warn(COMPONENT, "GitHub CLI fetch failed", owner: owner, repo: repo, number: number, exitstatus: status.exitstatus, error: stderr.strip)
         display_message("⚠️ GitHub CLI failed: #{stderr.strip}", type: :warn)
         return nil
       end
@@ -112,9 +137,14 @@ module Aidp
         data = JSON.parse(stdout)
         normalize_gh_cli_data(data)
       rescue JSON::ParserError => e
+        Aidp.log_warn(COMPONENT, "GitHub CLI response parse failed", owner: owner, repo: repo, number: number, error: e.message)
         display_message("❌ Failed to parse GitHub CLI response: #{e.message}", type: :error)
         nil
       end
+    rescue Timeout::Error
+      Aidp.log_warn(COMPONENT, "GitHub CLI timed out", owner: owner, repo: repo, number: number, timeout: gh_cli_timeout)
+      display_message("⚠️ GitHub CLI timed out after #{gh_cli_timeout}s, falling back to API", type: :warn)
+      nil
     end
 
     def fetch_via_api(owner, repo, number)
@@ -281,6 +311,103 @@ module Aidp
       false
     end
 
+    def capture3_with_timeout(*cmd, timeout:)
+      stdout_str = +""
+      stderr_str = +""
+      status = nil
+      wait_thr = nil
+
+      Timeout.timeout(timeout) do
+        Open3.popen3(*cmd) do |stdin, stdout_io, stderr_io, thread|
+          wait_thr = thread
+          stdin.close
+          stdout_str = stdout_io.read
+          stderr_str = stderr_io.read
+          status = thread.value
+        end
+      end
+
+      [stdout_str, stderr_str, status]
+    rescue Timeout::Error
+      terminate_process(wait_thr)
+      raise
+    end
+
+    def terminate_process(wait_thr)
+      return unless wait_thr&.alive?
+
+      begin
+        Process.kill("TERM", wait_thr.pid)
+      rescue Errno::ESRCH
+        return
+      end
+
+      begin
+        wait_thr.join(1)
+      rescue
+        nil
+      end
+
+      return unless wait_thr.alive?
+
+      begin
+        Process.kill("KILL", wait_thr.pid)
+      rescue Errno::ESRCH
+        return
+      end
+
+      begin
+        wait_thr.join(1)
+      rescue
+        nil
+      end
+    end
+
+    def gh_cli_timeout
+      Integer(ENV.fetch("AIDP_GH_CLI_TIMEOUT", 5))
+    rescue ArgumentError, TypeError
+      5
+    end
+
+    def test_fixture(owner, repo, number)
+      fixtures_raw = ENV["AIDP_TEST_ISSUE_FIXTURES"]
+      return nil unless fixtures_raw
+
+      fixtures = JSON.parse(fixtures_raw)
+      fixtures["#{owner}/#{repo}##{number}"]
+    rescue JSON::ParserError => e
+      Aidp.log_warn(COMPONENT, "Invalid issue fixtures JSON", error: e.message)
+      nil
+    end
+
+    def handle_test_fixture(fixture, owner, repo, number)
+      status = fixture["status"].to_i
+      case status
+      when 200
+        data = fixture.fetch("data", {})
+        Aidp.log_debug(COMPONENT, "Returning fixture issue data", owner: owner, repo: repo, number: number)
+        normalize_api_data(stringify_keys(data))
+      when 404
+        Aidp.log_warn(COMPONENT, "Fixture indicates issue not found", owner: owner, repo: repo, number: number)
+        display_message("❌ Issue not found (may be private)", type: :error)
+        nil
+      when 403
+        Aidp.log_warn(COMPONENT, "Fixture indicates API rate limit", owner: owner, repo: repo, number: number)
+        display_message("❌ API rate limit exceeded", type: :error)
+        nil
+      else
+        Aidp.log_warn(COMPONENT, "Fixture indicates API error", owner: owner, repo: repo, number: number, status: status)
+        display_message("❌ GitHub API error: #{status}", type: :error)
+        nil
+      end
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) do |(k, v), result|
+        result[k.to_s] = v
+      end
+    end
+
     def perform_bootstrap(issue_data)
       return if ENV["AIDP_DISABLE_BOOTSTRAP"] == "1"
       return unless @enable_bootstrap

data/lib/aidp/cli.rb

@@ -146,6 +146,16 @@ module Aidp
 
     class << self
       extend Aidp::MessageDisplay::ClassMethods
+      extend Aidp::RescueLogging
+
+      # Explicit singleton delegator (defensive: ensure availability even if extend fails to attach)
+      def log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+        Aidp::RescueLogging.log_rescue(error, component: component, action: action, fallback: fallback, level: level, **context)
+      end
+
+      # Store last parsed options for access by UI components (e.g., verbose flag)
+      @last_options = nil
+      attr_accessor :last_options
 
       def create_prompt
         ::TTY::Prompt.new
@@ -156,6 +166,7 @@ module Aidp
         return run_subcommand(args) if subcommand?(args)
 
         options = parse_options(args)
+        self.last_options = options
 
         if options[:help]
           display_message(options[:parser].to_s, type: :info)
@@ -324,6 +335,7 @@ module Aidp
           opts.on("-h", "--help", "Show this help message") { options[:help] = true }
           opts.on("-v", "--version", "Show version information") { options[:version] = true }
           opts.on("--setup-config", "Setup or reconfigure config file") { options[:setup_config] = true }
+          opts.on("--verbose", "Show detailed prompts and raw provider responses during guided workflow") { options[:verbose] = true }
 
           opts.separator ""
           opts.separator "Examples:"

data/lib/aidp/harness/config_schema.rb

@@ -1110,6 +1110,9 @@ module Aidp
 
       # Apply defaults to configuration
       def self.apply_defaults(config)
+        # Guard against non-hash config (e.g., when YAML parsing fails)
+        return config unless config.is_a?(Hash)
+
         result = deep_dup(config)
 
         # Apply harness defaults

data/lib/aidp/harness/config_validator.rb

@@ -279,6 +279,7 @@ module Aidp
 
       def fix_validation_issues
         return unless @config
+        return unless @config.is_a?(Hash)
 
         # Fix common issues that can be automatically corrected
 

data/lib/aidp/harness/provider_manager.rb

@@ -108,10 +108,16 @@ module Aidp
         # Last resort: try any available provider
         next_provider = find_any_available_provider
         if next_provider
-          success = set_current_provider(next_provider, reason, context)
-          if success
-            log_provider_switch(old_provider, next_provider, reason, context)
-            return next_provider
+          # Only attempt switch if it's actually a different provider
+          if next_provider != old_provider
+            success = set_current_provider(next_provider, reason, context)
+            if success
+              log_provider_switch(old_provider, next_provider, reason, context)
+              return next_provider
+            end
+          else
+            # Same provider - no switch possible
+            Aidp.logger.debug("provider_manager", "Only provider available is current provider", provider: next_provider)
           end
         end
 
@@ -132,6 +138,14 @@ module Aidp
           # 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 "empty_response"
+          # Empty response indicates provider failure, try next provider
+          Aidp.logger.warn("provider_manager", "Empty response from provider", classified_from: error_type)
+          switch_provider("provider_failure", error_details.merge(classified_from: error_type))
+        when "provider_error"
+          # Generic provider error, try next provider
+          Aidp.logger.warn("provider_manager", "Provider error detected", classified_from: error_type)
+          switch_provider("provider_failure", error_details.merge(classified_from: error_type))
         when "authentication"
           switch_provider("authentication_error", error_details)
         when "network"
@@ -1504,7 +1518,13 @@ module Aidp
 
       # Log provider switch
       def log_provider_switch(from_provider, to_provider, reason, context)
-        display_message("🔄 Provider switch: #{from_provider} → #{to_provider} (#{reason})", type: :info)
+        if from_provider == to_provider
+          # Same provider - this indicates no fallback was possible
+          display_message("⚠️  Provider switch failed: #{from_provider} → #{to_provider} (#{reason})", type: :warning)
+          display_message("   No alternative providers available", type: :warning)
+        else
+          display_message("🔄 Provider switch: #{from_provider} → #{to_provider} (#{reason})", type: :info)
+        end
         if context.any?
           display_message("   Context: #{context.inspect}", type: :muted)
         end
@@ -1513,7 +1533,31 @@ module Aidp
       # Log no providers available
       def log_no_providers_available(reason, context)
         display_message("❌ No providers available for switching (#{reason})", type: :error)
-        display_message("   All providers are rate limited, unhealthy, or circuit breaker open", type: :warning)
+
+        # Check if we have any fallback providers configured
+        harness_fallbacks = if @configuration.respond_to?(:fallback_providers)
+          Array(@configuration.fallback_providers).compact
+        else
+          []
+        end
+
+        all_providers = configured_providers
+
+        if harness_fallbacks.empty? && all_providers.size <= 1
+          display_message("   No fallback providers configured in aidp.yml", type: :warning)
+          display_message("   💡 Add fallback providers to enable automatic failover:", type: :info)
+          display_message("      harness:", type: :muted)
+          display_message("        fallback_providers:", type: :muted)
+          display_message("          - anthropic", type: :muted)
+          display_message("          - gemini", type: :muted)
+          display_message("   Run 'aidp config --interactive' to configure providers", type: :info)
+        else
+          display_message("   All providers are rate limited, unhealthy, or circuit breaker open", type: :warning)
+          if harness_fallbacks.any?
+            display_message("   Configured fallbacks: #{harness_fallbacks.join(", ")}", type: :muted)
+          end
+        end
+
         if context.any?
           display_message("   Context: #{context.inspect}", type: :muted)
         end

data/lib/aidp/harness/state/persistence.rb

@@ -18,21 +18,27 @@ module Aidp
           # Callers should set skip_persistence: true for test/dry-run scenarios
           @skip_persistence = skip_persistence
           ensure_state_directory
+          Aidp.log_debug("state_persistence", "initialized", mode: @mode, skip: @skip_persistence, dir: @state_dir)
         end
 
         def has_state?
           return false if @skip_persistence
-          File.exist?(@state_file)
+          exists = File.exist?(@state_file)
+          Aidp.log_debug("state_persistence", "has_state?", exists: exists, file: @state_file) if exists
+          exists
         end
 
         def load_state
           return {} if @skip_persistence || !has_state?
 
           with_lock do
+            Aidp.log_debug("state_persistence", "load_state.start", file: @state_file)
             content = File.read(@state_file)
-            JSON.parse(content, symbolize_names: true)
+            parsed = JSON.parse(content, symbolize_names: true)
+            Aidp.log_debug("state_persistence", "load_state.success", keys: parsed.keys.size, file: @state_file)
+            parsed
           rescue JSON::ParserError => e
-            warn "Failed to parse state file: #{e.message}"
+            Aidp.log_warn("state_persistence", "parse_error", error: e.message, file: @state_file)
             {}
           end
         end
@@ -41,8 +47,10 @@ module Aidp
           return if @skip_persistence
 
           with_lock do
+            Aidp.log_debug("state_persistence", "save_state.start", keys: state_data.keys.size)
             state_with_metadata = add_metadata(state_data)
             write_atomically(state_with_metadata)
+            Aidp.log_debug("state_persistence", "save_state.written", file: @state_file, size: state_with_metadata.keys.size)
           end
         end
 
@@ -50,7 +58,9 @@ module Aidp
           return if @skip_persistence
 
           with_lock do
+            Aidp.log_debug("state_persistence", "clear_state.start", file: @state_file)
             File.delete(@state_file) if File.exist?(@state_file)
+            Aidp.log_debug("state_persistence", "clear_state.done", file: @state_file)
           end
         end
 
@@ -66,8 +76,10 @@ module Aidp
 
         def write_atomically(state_with_metadata)
           temp_file = "#{@state_file}.tmp"
+          Aidp.log_debug("state_persistence", "write_atomically.start", temp: temp_file)
           File.write(temp_file, JSON.pretty_generate(state_with_metadata))
           File.rename(temp_file, @state_file)
+          Aidp.log_debug("state_persistence", "write_atomically.rename", file: @state_file)
         end
 
         def ensure_state_directory
@@ -76,45 +88,50 @@ module Aidp
 
         def with_lock(&block)
           return yield if @skip_persistence
-
-          acquire_lock_with_timeout(&block)
+          result = acquire_lock_with_timeout(&block)
+          result
         ensure
           cleanup_lock_file
         end
 
         def acquire_lock_with_timeout(&block)
-          lock_acquired = false
-          timeout = 30
+          timeout = ENV["AIDP_STATE_LOCK_TIMEOUT"]&.to_f || ((ENV["RSPEC_RUNNING"] == "true") ? 1.0 : 30.0)
           start_time = Time.now
-
+          attempt_result = nil
           while (Time.now - start_time) < timeout
-            lock_acquired = try_acquire_lock(&block)
-            break if lock_acquired
+            acquired, attempt_result = try_acquire_lock(&block)
+            return attempt_result if acquired
             sleep_briefly
           end
-
-          raise_lock_timeout_error unless lock_acquired
+          raise_lock_timeout_error(timeout)
         end
 
         def try_acquire_lock(&block)
           File.open(@lock_file, File::CREAT | File::EXCL | File::WRONLY) do |_lock|
-            yield
-            true
+            Aidp.log_debug("state_persistence", "lock.acquired", file: @lock_file)
+            [true, yield]
           end
         rescue Errno::EEXIST
-          false
+          Aidp.log_debug("state_persistence", "lock.busy", file: @lock_file)
+          [false, nil]
         end
 
         def sleep_briefly
-          sleep(0.1)
+          sleep(ENV["AIDP_STATE_LOCK_SLEEP"]&.to_f || 0.05)
         end
 
-        def raise_lock_timeout_error
-          raise "Could not acquire state lock within 30 seconds"
+        def raise_lock_timeout_error(timeout)
+          # Prefer explicit error class; fall back if not defined yet
+          error_class = defined?(Aidp::Errors::StateError) ? Aidp::Errors::StateError : RuntimeError
+          Aidp.log_error("state_persistence", "lock.timeout", file: @lock_file, waited: timeout)
+          raise error_class, "Could not acquire state lock within #{timeout} seconds"
         end
 
         def cleanup_lock_file
-          File.delete(@lock_file) if File.exist?(@lock_file)
+          if File.exist?(@lock_file)
+            File.delete(@lock_file)
+            Aidp.log_debug("state_persistence", "lock.cleaned", file: @lock_file)
+          end
         end
       end
     end

data/lib/aidp/harness/ui/enhanced_workflow_selector.rb

@@ -251,7 +251,10 @@ module Aidp
         def select_guided_workflow
           # Use the guided agent to help user select workflow
           # Don't pass prompt so it uses EnhancedInput with full readline support
-          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir)
+          verbose_flag = (defined?(Aidp::CLI) && Aidp::CLI.respond_to?(:last_options) && Aidp::CLI.last_options) ? Aidp::CLI.last_options[:verbose] : false
+          # Fallback: store verbose in an env for easier access if options not available
+          verbose = verbose_flag || ENV["AIDP_VERBOSE"] == "1"
+          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir, verbose: verbose)
           result = guided_agent.select_workflow
 
           # Store user input for later use

data/lib/aidp/init/doc_generator.rb

@@ -112,6 +112,12 @@ module Aidp
 
           ---
           Generated from template `planning/generate_llm_style_guide.md` with repository-aware adjustments.
+
+          **Note**: For comprehensive AIDP projects, consider creating both:
+          1. `STYLE_GUIDE.md` - Detailed explanations with examples and rationale
+          2. `LLM_STYLE_GUIDE.md` - Quick reference with `STYLE_GUIDE:line-range` cross-references
+
+          See `planning/generate_llm_style_guide.md` for the two-guide approach.
         GUIDE
 
         File.write(File.join(@project_dir, STYLE_GUIDE_PATH), content)

data/lib/aidp/logger.rb

@@ -33,7 +33,7 @@ module Aidp
     attr_reader :level, :json_format
 
     def initialize(project_dir = Dir.pwd, config = {})
-      @project_dir = project_dir
+      @project_dir = sanitize_project_dir(project_dir)
       @config = config
       @level = determine_log_level
       @json_format = config[:json] || false
@@ -195,6 +195,18 @@ module Aidp
     def redact_hash(hash)
       hash.transform_values { |v| v.is_a?(String) ? redact(v) : v }
     end
+
+    # Guard against accidentally passing stream sentinel strings or invalid characters
+    # that would create odd top-level directories like "<STDERR>".
+    def sanitize_project_dir(dir)
+      return Dir.pwd if dir.nil?
+      str = dir.to_s
+      if str.empty? || str.match?(/[<>|]/) || str.match?(/[\x00-\x1F]/)
+        Kernel.warn "[AIDP Logger] Invalid project_dir '#{str}' - falling back to #{Dir.pwd}"
+        return Dir.pwd
+      end
+      str
+    end
   end
 
   # Module-level logger accessor

data/lib/aidp/rescue_logging.rb

@@ -13,24 +13,35 @@ module Aidp
   #   - includes error class, message
   #   - optional fallback and extra context hash merged in
   module RescueLogging
+    # Instance-level helper (made public so extend works for singleton contexts)
     def log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+      Aidp::RescueLogging.__log_rescue_impl(self, error, component: component, action: action, fallback: fallback, level: level, **context)
+    end
+
+    # Module-level access (Aidp::RescueLogging.log_rescue) for direct calls if desired
+    def self.log_rescue(error, component:, action:, fallback: nil, level: :warn, **context)
+      Aidp::RescueLogging.__log_rescue_impl(self, error, component: component, action: action, fallback: fallback, level: level, **context)
+    end
+
+    # Internal implementation shared by instance & module forms
+    def self.__log_rescue_impl(context_object, error, component:, action:, fallback:, level:, **extra)
       data = {
         error_class: error.class.name,
         error_message: error.message,
         action: action
       }
       data[:fallback] = fallback if fallback
-      data.merge!(context) unless context.empty?
+      data.merge!(extra) unless extra.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)
+      begin
+        if context_object.respond_to?(:debug_log)
+          context_object.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
+        warn "[AIDP Rescue Logging Error] Failed to log rescue for #{component}:#{action} - #{error.class}: #{error.message} (logging error: #{logging_error.message})"
       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