aidp 0.17.0 → 0.17.1

data/lib/aidp/harness/state_manager.rb

@@ -11,19 +11,20 @@ module Aidp
   module Harness
     # Manages harness-specific state and persistence, extending existing progress tracking
     class StateManager
-      def initialize(project_dir, mode)
+      def initialize(project_dir, mode, skip_persistence: false)
         @project_dir = project_dir
         @mode = mode
         @state_dir = File.join(project_dir, ".aidp", "harness")
         @state_file = File.join(@state_dir, "#{mode}_state.json")
         @lock_file = File.join(@state_dir, "#{mode}_state.lock")
+        @skip_persistence = skip_persistence
+        @memory_state = {} if @skip_persistence  # In-memory state for tests
 
-        # Initialize the appropriate progress tracker
         case mode
         when :analyze
-          @progress_tracker = Aidp::Analyze::Progress.new(project_dir)
+          @progress_tracker = Aidp::Analyze::Progress.new(project_dir, skip_persistence: @skip_persistence)
         when :execute
-          @progress_tracker = Aidp::Execute::Progress.new(project_dir)
+          @progress_tracker = Aidp::Execute::Progress.new(project_dir, skip_persistence: @skip_persistence)
         else
           raise ArgumentError, "Unsupported mode: #{mode}"
         end
@@ -33,21 +34,14 @@ module Aidp
 
       # Check if state exists
       def has_state?
-        # In test mode, always return false to avoid file operations
-        return false if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-
+        return false if @skip_persistence
         File.exist?(@state_file)
       end
 
       # Load existing state
       def load_state
-        # In test mode, return empty state to avoid file locking issues
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          return {}
-        end
-
+        return @memory_state if @skip_persistence
         return {} unless has_state?
-
         with_lock do
           content = File.read(@state_file)
           JSON.parse(content, symbolize_names: true)
@@ -59,20 +53,16 @@ module Aidp
 
       # Save current state
       def save_state(state_data)
-        # In test mode, skip file operations to avoid file locking issues
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
+        if @skip_persistence
+          @memory_state = state_data
           return
         end
-
         with_lock do
-          # Add metadata
           state_with_metadata = state_data.merge(
             mode: @mode,
             project_dir: @project_dir,
             saved_at: Time.now.iso8601
           )
-
-          # Write to temporary file first, then rename (atomic operation)
           temp_file = "#{@state_file}.tmp"
           File.write(temp_file, JSON.pretty_generate(state_with_metadata))
           File.rename(temp_file, @state_file)
@@ -81,9 +71,10 @@ module Aidp
 
       # Clear state (for fresh start)
       def clear_state
-        # In test mode, skip file operations to avoid hanging
-        return if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-
+        if @skip_persistence
+          @memory_state = {}
+          return
+        end
         with_lock do
           File.delete(@state_file) if File.exist?(@state_file)
         end
@@ -91,11 +82,7 @@ module Aidp
 
       # Get state metadata
       def state_metadata
-        # In test mode, return empty metadata to avoid file operations
-        return {} if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-
         return {} unless has_state?
-
         state = load_state
         {
           mode: state[:mode],
@@ -216,21 +203,6 @@ module Aidp
 
       # Export state for debugging
       def export_state
-        # In test mode, include test variables
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          test_state = {
-            current_workstream: @test_workstream,
-            workstream_path: @test_workstream_path,
-            workstream_branch: @test_workstream_branch
-          }
-          return {
-            state_file: @state_file,
-            has_state: false,
-            metadata: {},
-            state: test_state
-          }
-        end
-
         {
           state_file: @state_file,
           has_state: has_state?,
@@ -309,11 +281,7 @@ module Aidp
         @progress_tracker.reset
         clear_state
         # Also clear test workstream variables
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          @test_workstream = nil
-          @test_workstream_path = nil
-          @test_workstream_branch = nil
-        end
+        # Test-only instance vars removed; rely on persistence skip flag for isolation
       end
 
       # Get progress summary
@@ -472,11 +440,6 @@ module Aidp
 
       # Get current workstream slug
       def current_workstream
-        # In test mode, use instance variable
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          return @test_workstream
-        end
-
         state = load_state
         state[:current_workstream]
       end
@@ -498,14 +461,6 @@ module Aidp
         ws = Aidp::Worktree.info(slug: slug, project_dir: @project_dir)
         return false unless ws
 
-        # In test mode, use instance variables
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          @test_workstream = slug
-          @test_workstream_path = ws[:path]
-          @test_workstream_branch = ws[:branch]
-          return true
-        end
-
         update_state(
           current_workstream: slug,
           workstream_path: ws[:path],
@@ -516,14 +471,6 @@ module Aidp
 
       # Clear current workstream (switch back to main project)
       def clear_workstream
-        # In test mode, use instance variables
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          @test_workstream = nil
-          @test_workstream_path = nil
-          @test_workstream_branch = nil
-          return
-        end
-
         update_state(
           current_workstream: nil,
           workstream_path: nil,
@@ -533,15 +480,6 @@ module Aidp
 
       # Get workstream metadata
       def workstream_metadata
-        # In test mode, use instance variables
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          return {
-            slug: @test_workstream,
-            path: @test_workstream_path,
-            branch: @test_workstream_branch
-          }
-        end
-
         state = load_state
         {
           slug: state[:current_workstream],
@@ -642,34 +580,31 @@ module Aidp
       end
 
       def with_lock(&_block)
-        # In test mode, skip file locking to avoid concurrency issues
-        if ENV["RACK_ENV"] == "test" || defined?(RSpec)
+        # Skip locking entirely when persistence disabled
+        if @skip_persistence
           yield
           return
         end
 
-        # Improved file-based locking with Async for better concurrency
+        # Improved file-based locking using exponential backoff
+        require_relative "../concurrency"
         lock_acquired = false
-        timeout = 30 # 30 seconds in production
-
-        start_time = Time.now
-        while (Time.now - start_time) < timeout
-          begin
-            # Try to acquire lock
-            File.open(@lock_file, File::CREAT | File::EXCL | File::WRONLY) do |_lock|
-              lock_acquired = true
-              yield
-              break
-            end
-          rescue Errno::EEXIST
-            # Lock file exists, wait briefly and retry
-            sleep(0.1)
-          end
-        end
 
-        unless lock_acquired
-          raise "Could not acquire state lock within #{timeout} seconds"
+        Aidp::Concurrency::Backoff.retry(
+          max_attempts: 300,  # 300 attempts * ~0.1s = ~30s max
+          base: 0.1,
+          max_delay: 1.0,
+          strategy: :exponential,
+          on: [Errno::EEXIST]
+        ) do
+          # Try to acquire lock
+          File.open(@lock_file, File::CREAT | File::EXCL | File::WRONLY) do |_lock|
+            lock_acquired = true
+            yield
+          end
         end
+      rescue Aidp::Concurrency::MaxAttemptsExceededError
+        raise "Could not acquire state lock within timeout"
       ensure
         # Clean up lock file
         File.delete(@lock_file) if lock_acquired && File.exist?(@lock_file)
@@ -677,6 +612,7 @@ module Aidp
 
       # Clean up stale lock files (older than 30 seconds)
       def cleanup_stale_lock
+        return if @skip_persistence
         return unless File.exist?(@lock_file)
 
         begin

data/lib/aidp/harness/status_display.rb

@@ -46,7 +46,7 @@ module Aidp
       end
 
       # Start real-time status updates
-      def start_status_updates(display_mode = :compact)
+      def start_status_updates(display_mode = :compact, async_updates: true)
         return if @running
 
         @running = true
@@ -54,20 +54,30 @@ module Aidp
         @display_mode = display_mode
         @last_update = Time.now
 
-        unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          require "concurrent"
-          @status_future = Concurrent::Future.execute do
-            while @running
-              begin
-                collect_status_data
-                display_status
-                check_alerts
-                sleep(@update_interval)
-              rescue => e
-                handle_display_error(e)
+        if async_updates
+          begin
+            require "concurrent"
+            @status_future = Concurrent::Future.execute do
+              while @running
+                begin
+                  collect_status_data
+                  display_status
+                  check_alerts
+                  sleep(@update_interval)
+                rescue => e
+                  handle_display_error(e)
+                end
               end
             end
+          rescue LoadError
+            # Fallback: perform single synchronous update if concurrent not available
+            collect_status_data
+            display_status
           end
+        else
+          # Synchronous single update mode (useful for tests)
+          collect_status_data
+          display_status
         end
       end
 

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

@@ -20,16 +20,15 @@ module Aidp
 
         class DisplayError < TUIError; end
 
-        def initialize(prompt: TTY::Prompt.new)
+        def initialize(prompt: TTY::Prompt.new, tty: $stdin)
           @cursor = TTY::Cursor
           @screen = TTY::Screen
           @pastel = Pastel.new
           @prompt = prompt
 
           # Headless (non-interactive) detection for test/CI environments:
-          # - RSpec defined or RSPEC_RUNNING env set
-          # - STDIN not a TTY (captured by PTY/tmux harness)
-          @headless = !!(defined?(RSpec) || ENV["RSPEC_RUNNING"] || $stdin.nil? || !$stdin.tty?)
+          # - STDIN not a TTY (captured by PTY/tmux harness or test environment)
+          @headless = !!(tty.nil? || !tty.tty?)
 
           @current_mode = nil
           @workflow_active = false

data/lib/aidp/harness/user_interface.rb

@@ -2052,17 +2052,22 @@ module Aidp
       # ============================================================================
 
       # Start the control interface
-      def start_control_interface
+      def start_control_interface(async_control: true)
         return unless @control_interface_enabled
 
         @control_mutex.synchronize do
           return if @control_future&.pending?
 
-          # Start control interface using concurrent-ruby (skip in test mode)
-          # Using Concurrent::Future for background execution with proper thread pool management
-          unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            require "concurrent"
-            @control_future = Concurrent::Future.execute { control_interface_loop }
+          if async_control
+            begin
+              require "concurrent"
+              @control_future = Concurrent::Future.execute { control_interface_loop }
+            rescue LoadError
+              # Fallback: run a single synchronous loop iteration if concurrent not available
+              control_interface_loop_iteration
+            end
+          else
+            control_interface_loop_iteration
           end
         end
 

data/lib/aidp/jobs/background_runner.rb

@@ -17,12 +17,18 @@ module Aidp
 
       attr_reader :project_dir, :jobs_dir
 
-      def initialize(project_dir = Dir.pwd)
+      def initialize(project_dir = Dir.pwd, suppress_display: false)
         @project_dir = project_dir
         @jobs_dir = File.join(project_dir, ".aidp", "jobs")
+        @suppress_display = suppress_display
         ensure_jobs_directory
       end
 
+      def display_message(msg, type: :info)
+        return if @suppress_display
+        super
+      end
+
       # Start a background job
       # Returns job_id
       def start(mode, options = {})

data/lib/aidp/logger.rb

@@ -114,7 +114,7 @@ module Aidp
       logger
     rescue => e
       # Fall back to STDERR if file logging fails
-      warn "[AIDP Logger] Failed to create log file at #{path}: #{e.message}. Falling back to STDERR."
+      Kernel.warn "[AIDP Logger] Failed to create log file at #{path}: #{e.message}. Falling back to STDERR."
       logger = ::Logger.new($stderr)
       logger.level = ::Logger::DEBUG
       logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }

data/lib/aidp/message_display.rb

@@ -39,9 +39,16 @@ module Aidp
     end
 
     module ClassMethods
-      # Class-level display helper (stateless)
+      # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
-        TTY::Prompt.new.say(message, color: COLOR_MAP.fetch(type, :white))
+        class_message_display_prompt.say(message, color: COLOR_MAP.fetch(type, :white))
+      end
+
+      private
+
+      # Don't memoize - create fresh prompt each time to respect $stdout redirection in tests
+      def class_message_display_prompt
+        TTY::Prompt.new
       end
     end
   end

data/lib/aidp/providers/anthropic.rb

@@ -44,7 +44,7 @@ module Aidp
         self.class.available?
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "claude CLI not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/base.rb

@@ -71,8 +71,8 @@ module Aidp
         name
       end
 
-      def send(prompt:, session: nil)
-        raise NotImplementedError, "#{self.class} must implement #send"
+      def send_message(prompt:, session: nil)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
       end
 
       # Fetch MCP servers configured for this provider
@@ -279,8 +279,8 @@ module Aidp
         error_message = nil
 
         begin
-          # Call the original send method
-          result = send(prompt: prompt, session: session)
+          # Call the original send_message method
+          result = send_message(prompt: prompt, session: session)
           success = true
 
           # Extract token usage and cost if available

data/lib/aidp/providers/codex.rb

@@ -34,7 +34,7 @@ module Aidp
         end
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "codex CLI not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/cursor.rb

@@ -31,7 +31,7 @@ module Aidp
         fetch_mcp_servers_cli || fetch_mcp_servers_config
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "cursor-agent not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/gemini.rb

@@ -20,7 +20,7 @@ module Aidp
         "Google Gemini"
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "gemini CLI not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/github_copilot.rb

@@ -34,7 +34,7 @@ module Aidp
         end
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "copilot CLI not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/macos_ui.rb

@@ -16,7 +16,7 @@ module Aidp
         "macos"
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "macOS UI not available on this platform" unless self.class.available?
 
         debug_provider("macos", "Starting Cursor interaction", {prompt_length: prompt.length})

data/lib/aidp/providers/opencode.rb

@@ -22,7 +22,7 @@ module Aidp
         "OpenCode"
       end
 
-      def send(prompt:, session: nil)
+      def send_message(prompt:, session: nil)
         raise "opencode not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/skills/wizard/prompter.rb

@@ -15,8 +15,8 @@ module Aidp
       class Prompter
         attr_reader :prompt
 
-        def initialize
-          @prompt = TTY::Prompt.new
+        def initialize(prompt: TTY::Prompt.new)
+          @prompt = prompt
         end
 
         # Gather all responses for creating a skill

data/lib/aidp/version.rb

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

data/lib/aidp/watch/plan_generator.rb

@@ -67,7 +67,7 @@ module Aidp
 
       def generate_with_provider(provider, issue)
         payload = build_prompt(issue)
-        response = provider.send(prompt: payload)
+        response = provider.send_message(prompt: payload)
         parsed = parse_structured_response(response)
 
         return parsed if parsed

data/lib/aidp/watch/repository_client.rb

@@ -11,6 +11,16 @@ module Aidp
     # (works for private repositories) and falls back to public REST endpoints
     # when the CLI is unavailable.
     class RepositoryClient
+      # Binary availability checker for testing
+      class BinaryChecker
+        def gh_cli_available?
+          _stdout, _stderr, status = Open3.capture3("gh", "--version")
+          status.success?
+        rescue Errno::ENOENT
+          false
+        end
+      end
+
       attr_reader :owner, :repo
 
       def self.parse_issues_url(issues_url)
@@ -24,10 +34,11 @@ module Aidp
         end
       end
 
-      def initialize(owner:, repo:, gh_available: nil)
+      def initialize(owner:, repo:, gh_available: nil, binary_checker: BinaryChecker.new)
         @owner = owner
         @repo = repo
-        @gh_available = gh_available.nil? ? gh_cli_available? : gh_available
+        @binary_checker = binary_checker
+        @gh_available = gh_available.nil? ? @binary_checker.gh_cli_available? : gh_available
       end
 
       def gh_available?
@@ -56,13 +67,6 @@ module Aidp
 
       private
 
-      def gh_cli_available?
-        _stdout, _stderr, status = Open3.capture3("gh", "--version")
-        status.success?
-      rescue Errno::ENOENT
-        false
-      end
-
       def list_issues_via_gh(labels:, state:)
         json_fields = %w[number title labels updatedAt state url assignees]
         cmd = ["gh", "issue", "list", "--repo", full_repo, "--state", state, "--json", json_fields.join(",")]