aidp 0.7.0 → 0.8.1

data/lib/aidp/providers/agent_supervisor.rb

@@ -1,348 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-require "open3"
-
-module Aidp
-  module Providers
-    # Supervisor for managing agent execution with progressive warnings instead of hard timeouts
-    class AgentSupervisor
-      # Execution states
-      STATES = {
-        idle: "⏳",
-        starting: "🚀",
-        running: "🔄",
-        warning: "⚠️",
-        user_aborted: "🛑",
-        completed: "✅",
-        failed: "❌"
-      }.freeze
-
-      attr_reader :state, :start_time, :end_time, :duration, :output, :error_output, :exit_code
-
-      def initialize(command, timeout_seconds: 300, debug: false)
-        @command = command
-        @timeout_seconds = timeout_seconds
-        @debug = debug
-        @state = :idle
-        @start_time = nil
-        @end_time = nil
-        @duration = 0
-        @output = ""
-        @error_output = ""
-        @exit_code = nil
-        @process_pid = nil
-        @output_count = 0
-        @last_output_time = nil
-        @supervisor_thread = nil
-        @output_threads = []
-        @warning_shown = false
-        @user_aborted = false
-      end
-
-      # Execute the command with supervision
-      def execute(input = nil)
-        @state = :starting
-        @start_time = Time.now
-        @last_output_time = @start_time
-
-        puts "🚀 Starting agent execution (will warn at #{@timeout_seconds}s)"
-
-        begin
-          # Start the process
-          Open3.popen3(*@command) do |stdin, stdout, stderr, wait|
-            @process_pid = wait.pid
-            @state = :running
-
-            # Send input if provided
-            if input
-              stdin.puts input
-              stdin.close
-            end
-
-            # Start timeout thread that will warn but not kill
-            timeout_thread = Thread.new do
-              sleep @timeout_seconds
-              if @state == :running && !@warning_shown
-                show_timeout_warning
-              end
-            end
-
-            # Start supervisor thread
-            start_supervisor_thread(wait)
-
-            # Start output collection threads
-            start_output_threads(stdout, stderr)
-
-            # Wait for completion
-            result = wait_for_completion(wait)
-
-            # Kill timeout thread since we're done
-            timeout_thread.kill
-
-            # Clean up threads
-            cleanup_threads
-
-            @end_time = Time.now
-            @duration = @end_time - @start_time
-
-            return result
-          end
-        rescue => e
-          @state = :failed
-          @end_time = Time.now
-          @duration = @end_time - @start_time if @start_time
-          puts "❌ Agent execution failed: #{e.message}"
-          raise
-        end
-      end
-
-      # Get current execution status
-      def status
-        elapsed = @start_time ? Time.now - @start_time : 0
-        minutes = (elapsed / 60).to_i
-        seconds = (elapsed % 60).to_i
-        time_str = (minutes > 0) ? "#{minutes}m #{seconds}s" : "#{seconds}s"
-
-        case @state
-        when :idle
-          "⏳ Idle"
-        when :starting
-          "🚀 Starting..."
-        when :running
-          output_info = (@output_count > 0) ? " (#{@output_count} outputs)" : ""
-          "🔄 Running #{time_str}#{output_info}"
-        when :warning
-          "⚠️ Taking longer than expected #{time_str}"
-        when :user_aborted
-          "🛑 Aborted by user after #{time_str}"
-        when :completed
-          "✅ Completed in #{time_str}"
-        when :failed
-          "❌ Failed after #{time_str}"
-        end
-      end
-
-      # Check if execution is still active
-      def active?
-        [:starting, :running, :warning].include?(@state)
-      end
-
-      # Check if execution completed successfully
-      def success?
-        @state == :completed && @exit_code == 0
-      end
-
-      # Show timeout warning and give user control
-      def show_timeout_warning
-        return if @warning_shown
-        @warning_shown = true
-        @state = :warning
-
-        puts "\n⚠️  Agent has been running for #{@timeout_seconds} seconds"
-        puts "   This is longer than expected, but the agent may still be working."
-        puts "   You can:"
-        puts "   1. Continue waiting (press Enter)"
-        puts "   2. Abort execution (type 'abort' and press Enter)"
-        puts "   3. Wait 5 more minutes (type 'wait' and press Enter)"
-
-        begin
-          Timeout.timeout(30) do
-            response = gets&.chomp&.downcase
-            case response
-            when "abort"
-              puts "🛑 Aborting execution..."
-              @user_aborted = true
-              @state = :user_aborted
-              kill!
-            when "wait"
-              puts "⏰ Will warn again in 5 minutes..."
-              @warning_shown = false
-              @state = :running
-              # Start another warning thread for 5 more minutes
-              Thread.new do
-                sleep 300 # 5 minutes
-                if @state == :running && !@warning_shown
-                  show_timeout_warning
-                end
-              end
-            else
-              puts "🔄 Continuing to wait..."
-              @state = :running
-            end
-          end
-        rescue Timeout::Error
-          puts "⏰ No response received, continuing to wait..."
-          @state = :running
-        rescue Interrupt
-          puts "\n🛑 User interrupted, aborting..."
-          @user_aborted = true
-          @state = :user_aborted
-          kill!
-        end
-      end
-
-      # Force kill the process
-      def kill!
-        return unless @process_pid && active?
-
-        puts "💀 Force killing agent process (PID: #{@process_pid})"
-
-        begin
-          # Try graceful termination first
-          Process.kill("TERM", @process_pid)
-          sleep 1
-
-          # Force kill if still running
-          if process_running?(@process_pid)
-            Process.kill("KILL", @process_pid)
-            sleep 1
-          end
-
-          # Double-check and force kill again if needed
-          if process_running?(@process_pid)
-            puts "⚠️ Process still running, using SIGKILL..."
-            Process.kill("KILL", @process_pid)
-            sleep 1
-          end
-
-          @state = :user_aborted
-        rescue Errno::ESRCH
-          # Process already dead
-          @state = :user_aborted
-        rescue => e
-          puts "⚠️ Error killing process: #{e.message}"
-          # Try one more time with KILL
-          begin
-            Process.kill("KILL", @process_pid) if process_running?(@process_pid)
-          rescue Errno::ESRCH
-            # Process already terminated
-          end
-        end
-      end
-
-      private
-
-      def start_supervisor_thread(wait)
-        @supervisor_thread = Thread.new do
-          loop do
-            sleep 10 # Check every 10 seconds
-
-            # Check if process is done
-            if wait.value
-              break
-            end
-
-            # Check for stuck condition (no output for 3 minutes)
-            if @last_output_time && Time.now - @last_output_time > 180
-              puts "⚠️ Agent appears stuck (no output for 3+ minutes)"
-              # Don't kill, just warn
-            end
-          end
-        rescue => e
-          puts "⚠️ Supervisor thread error: #{e.message}" if @debug
-        end
-
-        @supervisor_thread
-      end
-
-      def start_output_threads(stdout, stderr)
-        # Stdout thread
-        @output_threads << Thread.new do
-          stdout.each_line do |line|
-            @output += line
-            @output_count += 1
-            @last_output_time = Time.now
-
-            if @debug
-              puts "📤 #{line.chomp}"
-            end
-          end
-        rescue IOError => e
-          puts "📤 stdout closed: #{e.message}" if @debug
-        rescue => e
-          puts "⚠️ stdout thread error: #{e.message}" if @debug
-        end
-
-        # Stderr thread
-        @output_threads << Thread.new do
-          stderr.each_line do |line|
-            @error_output += line
-            @output_count += 1
-            @last_output_time = Time.now
-
-            if @debug
-              puts "❌ #{line.chomp}"
-            end
-          end
-        rescue IOError => e
-          puts "❌ stderr closed: #{e.message}" if @debug
-        rescue => e
-          puts "⚠️ stderr thread error: #{e.message}" if @debug
-        end
-      end
-
-      def wait_for_completion(wait)
-        # Wait for process to complete
-        exit_status = wait.value
-        @exit_code = exit_status.exitstatus
-
-        # Update duration
-        @duration = Time.now - @start_time
-
-        if @user_aborted || @state == :user_aborted
-          # Process was killed by user
-          {
-            success: false,
-            state: @state,
-            output: @output,
-            error_output: @error_output,
-            exit_code: @exit_code,
-            duration: @duration,
-            reason: "user_aborted"
-          }
-        elsif exit_status.success?
-          @state = :completed
-          {
-            success: true,
-            state: @state,
-            output: @output,
-            error_output: @error_output,
-            exit_code: @exit_code,
-            duration: @duration
-          }
-        else
-          @state = :failed
-          {
-            success: false,
-            state: @state,
-            output: @output,
-            error_output: @error_output,
-            exit_code: @exit_code,
-            duration: @duration,
-            reason: "non_zero_exit"
-          }
-        end
-      end
-
-      def cleanup_threads
-        # Wait for output threads to finish (with timeout)
-        @output_threads.each do |thread|
-          thread.join(5) # Wait up to 5 seconds
-        rescue => e
-          puts "⚠️ Error joining thread: #{e.message}" if @debug
-        end
-
-        # Kill supervisor thread
-        @supervisor_thread&.kill
-      end
-
-      def process_running?(pid)
-        Process.kill(0, pid)
-        true
-      rescue Errno::ESRCH
-        false
-      end
-    end
-  end
-end

data/lib/aidp/providers/supervised_base.rb

@@ -1,317 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "agent_supervisor"
-
-module Aidp
-  module Providers
-    # Base class for providers that use the agent supervisor
-    class SupervisedBase
-      # Timeout constants are now configurable via environment variables for flexibility
-      DEFAULT_TIMEOUT = Integer(ENV.fetch("AIDP_DEFAULT_TIMEOUT", "300"))             # 5 minutes for general operations
-      QUICK_MODE_TIMEOUT = Integer(ENV.fetch("AIDP_QUICK_MODE_TIMEOUT", "120"))       # 2 minutes for testing
-      REPOSITORY_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_REPOSITORY_ANALYSIS_TIMEOUT", "180")) # 3 minutes
-      ARCHITECTURE_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_ARCHITECTURE_ANALYSIS_TIMEOUT", "600"))  # 10 minutes
-      TEST_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_TEST_ANALYSIS_TIMEOUT", "300"))       # 5 minutes
-      FUNCTIONALITY_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_FUNCTIONALITY_ANALYSIS_TIMEOUT", "600"))  # 10 minutes
-      DOCUMENTATION_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_DOCUMENTATION_ANALYSIS_TIMEOUT", "300"))  # 5 minutes
-      STATIC_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_STATIC_ANALYSIS_TIMEOUT", "450"))     # 7.5 minutes
-      REFACTORING_RECOMMENDATIONS_TIMEOUT = Integer(ENV.fetch("AIDP_REFACTORING_RECOMMENDATIONS_TIMEOUT", "600"))  # 10 minutes
-      ADAPTIVE_TIMEOUT_BUFFER = Float(ENV.fetch("AIDP_ADAPTIVE_TIMEOUT_BUFFER", "1.2"))     # 20% buffer for adaptive timeouts
-      attr_reader :name, :last_execution_result, :metrics
-
-      def initialize
-        @last_execution_result = nil
-        @metrics = {
-          total_executions: 0,
-          successful_executions: 0,
-          timeout_count: 0,
-          failure_count: 0,
-          average_duration: 0.0,
-          total_duration: 0.0
-        }
-        @job_context = nil
-      end
-
-      # Abstract method - must be implemented by subclasses
-      def command
-        raise NotImplementedError, "#{self.class} must implement #command"
-      end
-
-      # Abstract method - must be implemented by subclasses
-      def provider_name
-        raise NotImplementedError, "#{self.class} must implement #provider_name"
-      end
-
-      # Set job context for background execution
-      def set_job_context(job_id:, execution_id:, job_manager:)
-        @job_context = {
-          job_id: job_id,
-          execution_id: execution_id,
-          job_manager: job_manager
-        }
-      end
-
-      # Execute with supervision and recovery
-      def send(prompt:, session: nil)
-        timeout_seconds = calculate_timeout
-        debug = ENV["AIDP_DEBUG"] == "1"
-
-        log_info("Executing with #{provider_name} provider (timeout: #{timeout_seconds}s)")
-
-        # Create supervisor
-        supervisor = AgentSupervisor.new(
-          command,
-          timeout_seconds: timeout_seconds,
-          debug: debug
-        )
-
-        begin
-          # Execute with supervision
-          result = supervisor.execute(prompt)
-
-          # Update metrics
-          update_metrics(supervisor, result)
-
-          # Store result for debugging
-          @last_execution_result = result
-
-          if result[:success]
-            log_info("#{provider_name} completed successfully in #{format_duration(result[:duration])}")
-            result[:output]
-          else
-            handle_execution_failure(result, supervisor)
-          end
-        rescue => e
-          log_error("#{provider_name} execution error: #{e.message}")
-
-          # Try to kill the process if it's still running
-          supervisor.kill! if supervisor.active?
-
-          raise
-        end
-      end
-
-      # Get execution statistics
-      def stats
-        @metrics.dup
-      end
-
-      # Reset statistics
-      def reset_stats!
-        @metrics = {
-          total_executions: 0,
-          successful_executions: 0,
-          timeout_count: 0,
-          failure_count: 0,
-          average_duration: 0.0,
-          total_duration: 0.0
-        }
-      end
-
-      # Check if provider supports activity monitoring
-      def supports_activity_monitoring?
-        true # Supervised providers always support activity monitoring
-      end
-
-      # Get activity summary for metrics (compatibility with old interface)
-      def activity_summary
-        return {} unless @last_execution_result
-
-        {
-          provider: provider_name,
-          step_name: ENV["AIDP_CURRENT_STEP"],
-          start_time: @last_execution_result[:start_time],
-          end_time: @last_execution_result[:end_time],
-          duration: @last_execution_result[:duration],
-          final_state: @last_execution_result[:state],
-          stuck_detected: false, # Supervisor handles this differently
-          output_count: @last_execution_result[:output_count] || 0
-        }
-      end
-
-      # Compatibility methods for old activity monitoring interface
-      def setup_activity_monitoring(step_name, callback = nil, timeout = nil)
-        # No-op for supervised providers - supervisor handles this
-      end
-
-      def record_activity(message = nil)
-        # No-op for supervised providers - supervisor handles this
-      end
-
-      def mark_completed
-        # No-op for supervised providers - supervisor handles this
-      end
-
-      def mark_failed(message = nil)
-        # No-op for supervised providers - supervisor handles this
-      end
-
-      private
-
-      def calculate_timeout
-        # Priority order for timeout calculation:
-        # 1. Quick mode (for testing)
-        # 2. Environment variable override
-        # 3. Adaptive timeout based on step type
-        # 4. Default timeout
-
-        if ENV["AIDP_QUICK_MODE"]
-          log_info("Quick mode enabled - #{QUICK_MODE_TIMEOUT / 60} minute timeout")
-          return QUICK_MODE_TIMEOUT
-        end
-
-        provider_timeout_var = "AIDP_#{provider_name.upcase}_TIMEOUT"
-        if ENV[provider_timeout_var]
-          return ENV[provider_timeout_var].to_i
-        end
-
-        # Adaptive timeout based on step type
-        step_timeout = get_adaptive_timeout
-        if step_timeout
-          log_info("Using adaptive timeout: #{step_timeout} seconds")
-          return step_timeout
-        end
-
-        # Default timeout for interactive use
-        log_info("Using default timeout: #{DEFAULT_TIMEOUT / 60} minutes")
-        DEFAULT_TIMEOUT
-      end
-
-      def get_adaptive_timeout
-        # Try to get timeout recommendations from metrics storage
-        begin
-          require_relative "../analyze/metrics_storage"
-          storage = Aidp::Analyze::MetricsStorage.new(Dir.pwd)
-          recommendations = storage.calculate_timeout_recommendations
-
-          # Get current step name from environment or context
-          step_name = ENV["AIDP_CURRENT_STEP"] || "unknown"
-
-          if recommendations[step_name]
-            recommended = recommendations[step_name][:recommended_timeout]
-            # Add buffer for safety
-            return (recommended * ADAPTIVE_TIMEOUT_BUFFER).ceil
-          end
-        rescue => e
-          log_warning("Could not get adaptive timeout: #{e.message}") if ENV["AIDP_DEBUG"]
-        end
-
-        # Fallback timeouts based on step type patterns
-        step_name = ENV["AIDP_CURRENT_STEP"] || ""
-
-        case step_name
-        when /REPOSITORY_ANALYSIS/
-          REPOSITORY_ANALYSIS_TIMEOUT
-        when /ARCHITECTURE_ANALYSIS/
-          ARCHITECTURE_ANALYSIS_TIMEOUT
-        when /TEST_ANALYSIS/
-          TEST_ANALYSIS_TIMEOUT
-        when /FUNCTIONALITY_ANALYSIS/
-          FUNCTIONALITY_ANALYSIS_TIMEOUT
-        when /DOCUMENTATION_ANALYSIS/
-          DOCUMENTATION_ANALYSIS_TIMEOUT
-        when /STATIC_ANALYSIS/
-          STATIC_ANALYSIS_TIMEOUT
-        when /REFACTORING_RECOMMENDATIONS/
-          REFACTORING_RECOMMENDATIONS_TIMEOUT
-        else
-          nil  # Use default
-        end
-      end
-
-      def update_metrics(supervisor, result)
-        @metrics[:total_executions] += 1
-        @metrics[:total_duration] += supervisor.duration
-        @metrics[:average_duration] = @metrics[:total_duration] / @metrics[:total_executions]
-
-        case result[:state]
-        when :completed
-          @metrics[:successful_executions] += 1
-        when :timeout
-          @metrics[:timeout_count] += 1
-        when :failed, :killed
-          @metrics[:failure_count] += 1
-        end
-
-        # Log metrics update if in job context
-        if @job_context
-          @job_context[:job_manager].log_message(
-            @job_context[:job_id],
-            @job_context[:execution_id],
-            "Updated execution metrics",
-            "debug",
-            @metrics
-          )
-        end
-      end
-
-      def handle_execution_failure(result, supervisor)
-        case result[:reason]
-        when "user_aborted"
-          message = "#{provider_name} was aborted by user after #{format_duration(result[:duration])}"
-          log_error(message)
-          raise Interrupt, message
-        when "non_zero_exit"
-          error_msg = result[:error_output].empty? ? "Unknown error" : result[:error_output].strip
-          message = "#{provider_name} failed with exit code #{result[:exit_code]}: #{error_msg}"
-          log_error(message)
-          raise message
-        else
-          message = "#{provider_name} failed: #{result[:reason] || "Unknown error"}"
-          log_error(message)
-          raise message
-        end
-      end
-
-      def format_duration(seconds)
-        minutes = (seconds / 60).to_i
-        secs = (seconds % 60).to_i
-
-        if minutes > 0
-          "#{minutes}m #{secs}s"
-        else
-          "#{secs}s"
-        end
-      end
-
-      def log_info(message)
-        if @job_context
-          @job_context[:job_manager].log_message(
-            @job_context[:job_id],
-            @job_context[:execution_id],
-            message,
-            "info"
-          )
-        else
-          puts message
-        end
-      end
-
-      def log_warning(message)
-        if @job_context
-          @job_context[:job_manager].log_message(
-            @job_context[:job_id],
-            @job_context[:execution_id],
-            message,
-            "warning"
-          )
-        else
-          puts "⚠️  #{message}"
-        end
-      end
-
-      def log_error(message)
-        if @job_context
-          @job_context[:job_manager].log_message(
-            @job_context[:job_id],
-            @job_context[:execution_id],
-            message,
-            "error"
-          )
-        else
-          puts "❌ #{message}"
-        end
-      end
-    end
-  end
-end

data/lib/aidp/providers/supervised_cursor.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "supervised_base"
-require_relative "../util"
-
-module Aidp
-  module Providers
-    class SupervisedCursor < SupervisedBase
-      def self.available?
-        !!Aidp::Util.which("cursor-agent")
-      end
-
-      def provider_name
-        "cursor"
-      end
-
-      def command
-        ["cursor-agent", "-p"]
-      end
-    end
-  end
-end

data/lib/aidp/sync.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Aidp
-  # Synchronization utilities
-  class Sync
-    def self.ensure_workspace_sync
-      # Placeholder for workspace synchronization logic
-      true
-    end
-  end
-end