aidp 0.16.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 = {})
@@ -213,7 +219,7 @@ module Aidp
         return nil unless File.exist?(metadata_file)
 
         # Return raw metadata with times as ISO8601 strings to avoid unsafe class loading
-        YAML.load_file(metadata_file)
+        YAML.safe_load_file(metadata_file, permitted_classes: [Date, Time, Symbol], aliases: true)
       rescue
         nil
       end

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/registry.rb

@@ -8,10 +8,10 @@ module Aidp
     # lookup, filtering, and management capabilities.
     #
     # Skills are loaded from:
-    # 1. Built-in skills directory (project_root/skills/)
-    # 2. Custom skills directory (.aidp/skills/)
+    # 1. Template skills directory (gem templates/skills/) - built-in templates
+    # 2. Project skills directory (.aidp/skills/) - project-specific skills
     #
-    # Custom skills with matching IDs override built-in skills.
+    # Project skills with matching IDs override template skills.
     #
     # @example Basic usage
     #   registry = Registry.new(project_dir: "/path/to/project")
@@ -39,8 +39,8 @@ module Aidp
       # Load skills from all search paths
       #
       # Skills are loaded in order:
-      # 1. Built-in skills (project_root/skills/)
-      # 2. Custom skills (.aidp/skills/) - override built-in
+      # 1. Template skills (gem templates/skills/) - built-in templates
+      # 2. Project skills (.aidp/skills/) - override templates
       #
       # @return [Integer] Number of skills loaded
       def load_skills
@@ -48,13 +48,13 @@ module Aidp
 
         @skills = {}
 
-        # Load built-in skills first
-        builtin_skills = load_from_path(builtin_skills_path)
-        builtin_skills.each { |skill| register_skill(skill, source: :builtin) }
+        # Load template skills first
+        template_skills = load_from_path(template_skills_path)
+        template_skills.each { |skill| register_skill(skill, source: :template) }
 
-        # Load custom skills (override built-in if IDs match)
-        custom_skills = load_from_path(custom_skills_path)
-        custom_skills.each { |skill| register_skill(skill, source: :custom) }
+        # Load project skills (override templates if IDs match)
+        project_skills = load_from_path(project_skills_path)
+        project_skills.each { |skill| register_skill(skill, source: :project) }
 
         @loaded = true
 
@@ -139,13 +139,13 @@ module Aidp
 
       # Get skill IDs grouped by source
       #
-      # @return [Hash] Hash with :builtin and :custom arrays
+      # @return [Hash] Hash with :template and :project arrays
       def by_source
         load_skills unless loaded?
 
         {
-          builtin: @skills.values.select { |s| builtin_skill?(s) }.map(&:id),
-          custom: @skills.values.select { |s| custom_skill?(s) }.map(&:id)
+          template: @skills.values.select { |s| template_skill?(s) }.map(&:id),
+          project: @skills.values.select { |s| project_skill?(s) }.map(&:id)
         }
       end
 
@@ -186,34 +186,36 @@ module Aidp
         Loader.load_from_directory(path, provider: provider)
       end
 
-      # Get built-in skills path
+      # Get template skills path (from gem)
       #
-      # @return [String] Path to built-in skills directory
-      def builtin_skills_path
-        File.join(project_dir, "skills")
+      # @return [String] Path to template skills directory
+      def template_skills_path
+        # Get the gem root directory (go up from lib/aidp/skills/registry.rb)
+        gem_root = File.expand_path("../../../..", __dir__)
+        File.join(gem_root, "templates", "skills")
       end
 
-      # Get custom skills path
+      # Get project skills path
       #
-      # @return [String] Path to custom skills directory
-      def custom_skills_path
+      # @return [String] Path to project-specific skills directory
+      def project_skills_path
         File.join(project_dir, ".aidp", "skills")
       end
 
-      # Check if skill is from built-in directory
+      # Check if skill is from template directory
       #
       # @param skill [Skill] Skill to check
-      # @return [Boolean] True if built-in
-      def builtin_skill?(skill)
-        skill.source_path.start_with?(builtin_skills_path)
+      # @return [Boolean] True if template
+      def template_skill?(skill)
+        skill.source_path.start_with?(template_skills_path)
       end
 
-      # Check if skill is from custom directory
+      # Check if skill is from project directory
       #
       # @param skill [Skill] Skill to check
-      # @return [Boolean] True if custom
-      def custom_skill?(skill)
-        skill.source_path.start_with?(custom_skills_path)
+      # @return [Boolean] True if project
+      def project_skill?(skill)
+        skill.source_path.start_with?(project_skills_path)
       end
     end
   end