aidp 0.3.0 → 0.7.0

data/lib/aidp/providers/agent_supervisor.rb

@@ -0,0 +1,348 @@
+# 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/anthropic.rb

@@ -14,10 +14,167 @@ module Aidp
       def send(prompt:, session: nil)
         raise "claude CLI not available" unless self.class.available?
 
+        require "open3"
+
         # Use Claude CLI for non-interactive mode
-        cmd = ["claude", "compose", "--prompt", prompt]
-        system(*cmd)
-        :ok
+        cmd = ["claude", "--print"]
+
+        puts "📝 Sending prompt to claude..."
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
+          # Send the prompt to stdin
+          stdin.puts prompt
+          stdin.close
+
+          # Start stuck detection thread
+          stuck_detection_thread = Thread.new do
+            loop do
+              sleep 10 # Check every 10 seconds
+
+              if stuck?
+                puts "⚠️  claude appears stuck (no activity for #{stuck_timeout} seconds)"
+                puts "   You can:"
+                puts "   1. Wait longer (press Enter)"
+                puts "   2. Abort (Ctrl+C)"
+
+                # Give user a chance to respond
+                begin
+                  Timeout.timeout(30) do
+                    gets
+                    puts "🔄 Continuing to wait..."
+                  end
+                rescue Timeout::Error
+                  puts "⏰ No response received, continuing to wait..."
+                rescue Interrupt
+                  puts "🛑 Aborting claude..."
+                  Process.kill("TERM", wait.pid)
+                  raise Interrupt, "User aborted claude execution"
+                end
+              end
+
+              # Stop checking if the process is done
+              break if wait.value
+            end
+          end
+
+          # Wait for completion with timeout
+          begin
+            Timeout.timeout(timeout_seconds) do
+              result = wait.value
+
+              # Stop stuck detection thread
+              stuck_detection_thread&.kill
+
+              if result.success?
+                output = stdout.read
+                puts "✅ Claude analysis completed"
+                mark_completed
+                return output.empty? ? :ok : output
+              else
+                error_output = stderr.read
+                mark_failed("claude failed with exit code #{result.exitstatus}: #{error_output}")
+                raise "claude failed with exit code #{result.exitstatus}: #{error_output}"
+              end
+            end
+          rescue Timeout::Error
+            # Stop stuck detection thread
+            stuck_detection_thread&.kill
+
+            # Kill the process if it's taking too long
+            begin
+              Process.kill("TERM", wait.pid)
+            rescue Errno::ESRCH
+              # Process already terminated
+            end
+
+            mark_failed("claude timed out after #{timeout_seconds} seconds")
+            raise Timeout::Error, "claude timed out after #{timeout_seconds} seconds"
+          rescue Interrupt
+            # Stop stuck detection thread
+            stuck_detection_thread&.kill
+
+            # Kill the process
+            begin
+              Process.kill("TERM", wait.pid)
+            rescue Errno::ESRCH
+              # Process already terminated
+            end
+
+            mark_failed("claude execution was interrupted")
+            raise
+          end
+        end
+      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"]
+          puts "⚡ Quick mode enabled - 2 minute timeout"
+          return 120
+        end
+
+        if ENV["AIDP_ANTHROPIC_TIMEOUT"]
+          return ENV["AIDP_ANTHROPIC_TIMEOUT"].to_i
+        end
+
+        # Adaptive timeout based on step type
+        step_timeout = get_adaptive_timeout
+        if step_timeout
+          puts "🧠 Using adaptive timeout: #{step_timeout} seconds"
+          return step_timeout
+        end
+
+        # Default timeout (5 minutes for interactive use)
+        puts "📋 Using default timeout: 5 minutes"
+        300
+      end
+
+      def get_adaptive_timeout
+        # Try to get timeout recommendations from metrics storage
+        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 20% buffer for safety
+          return (recommended * 1.2).ceil
+        end
+
+        # Fallback timeouts based on step type patterns
+        step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+        case step_name
+        when /REPOSITORY_ANALYSIS/
+          180  # 3 minutes - repository analysis can be quick
+        when /ARCHITECTURE_ANALYSIS/
+          600  # 10 minutes - architecture analysis needs more time
+        when /TEST_ANALYSIS/
+          300  # 5 minutes - test analysis is moderate
+        when /FUNCTIONALITY_ANALYSIS/
+          600  # 10 minutes - functionality analysis is complex
+        when /DOCUMENTATION_ANALYSIS/
+          300  # 5 minutes - documentation analysis is moderate
+        when /STATIC_ANALYSIS/
+          450  # 7.5 minutes - static analysis can be intensive
+        when /REFACTORING_RECOMMENDATIONS/
+          600  # 10 minutes - refactoring recommendations are complex
+        else
+          nil  # Use default
+        end
       end
     end
   end

data/lib/aidp/providers/base.rb

@@ -3,13 +3,160 @@
 module Aidp
   module Providers
     class Base
-      def name = raise(NotImplementedError)
+      # Activity indicator states
+      ACTIVITY_STATES = {
+        idle: "⏳",
+        working: "🔄",
+        stuck: "⚠️",
+        completed: "✅",
+        failed: "❌"
+      }.freeze
 
-      # Send a composed prompt string to the provider.
-      # Return :ok when command completed successfully,
-      # Return :interactive when starting an interactive session (for gate steps),
-      # or return a string if we captured output and the caller should write to a file.
-      def send(prompt:, session: nil) = raise(NotImplementedError)
+      # Default timeout for stuck detection (2 minutes)
+      DEFAULT_STUCK_TIMEOUT = 120
+
+      attr_reader :activity_state, :last_activity_time, :start_time, :step_name
+
+      def initialize
+        @activity_state = :idle
+        @last_activity_time = Time.now
+        @start_time = nil
+        @step_name = nil
+        @activity_callback = nil
+        @stuck_timeout = DEFAULT_STUCK_TIMEOUT
+        @output_count = 0
+        @last_output_time = Time.now
+        @job_context = nil
+      end
+
+      def name
+        raise NotImplementedError, "#{self.class} must implement #name"
+      end
+
+      def send(prompt:, session: nil)
+        raise NotImplementedError, "#{self.class} must implement #send"
+      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
+
+      # Set up activity monitoring for a step
+      def setup_activity_monitoring(step_name, activity_callback = nil, stuck_timeout = nil)
+        @step_name = step_name
+        @activity_callback = activity_callback
+        @stuck_timeout = stuck_timeout || DEFAULT_STUCK_TIMEOUT
+        @start_time = Time.now
+        @last_activity_time = @start_time
+        @output_count = 0
+        @last_output_time = @start_time
+        update_activity_state(:working)
+      end
+
+      # Update activity state and notify callback
+      def update_activity_state(state, message = nil)
+        @activity_state = state
+        @last_activity_time = Time.now if state == :working
+
+        # Log state change to job if in background mode
+        if @job_context
+          level = case state
+          when :completed then "info"
+          when :failed then "error"
+          else "debug"
+          end
+
+          log_to_job(message || "Provider state changed to #{state}", level)
+        end
+
+        @activity_callback&.call(state, message, self)
+      end
+
+      # Check if provider appears to be stuck
+      def stuck?
+        return false unless @activity_state == :working
+
+        time_since_activity = Time.now - @last_activity_time
+        time_since_activity > @stuck_timeout
+      end
+
+      # Get current execution time
+      def execution_time
+        return 0 unless @start_time
+        Time.now - @start_time
+      end
+
+      # Get time since last activity
+      def time_since_last_activity
+        Time.now - @last_activity_time
+      end
+
+      # Record activity (called when provider produces output)
+      def record_activity(message = nil)
+        @output_count += 1
+        @last_output_time = Time.now
+        update_activity_state(:working, message)
+      end
+
+      # Mark as completed
+      def mark_completed
+        update_activity_state(:completed)
+      end
+
+      # Mark as failed
+      def mark_failed(error_message = nil)
+        update_activity_state(:failed, error_message)
+      end
+
+      # Get activity summary for metrics
+      def activity_summary
+        {
+          provider: name,
+          step_name: @step_name,
+          start_time: @start_time&.iso8601,
+          end_time: Time.now.iso8601,
+          duration: execution_time,
+          final_state: @activity_state,
+          stuck_detected: stuck?,
+          output_count: @output_count
+        }
+      end
+
+      # Check if provider supports activity monitoring
+      def supports_activity_monitoring?
+        true # Default to true, override in subclasses if needed
+      end
+
+      # Get stuck timeout for this provider
+      attr_reader :stuck_timeout
+
+      protected
+
+      # Log message to job if in background mode
+      def log_to_job(message, level = "info", metadata = {})
+        return unless @job_context && @job_context[:job_manager]
+
+        metadata = metadata.merge(
+          provider: name,
+          step_name: @step_name,
+          activity_state: @activity_state,
+          execution_time: execution_time,
+          output_count: @output_count
+        )
+
+        @job_context[:job_manager].log_message(
+          @job_context[:job_id],
+          @job_context[:execution_id],
+          message,
+          level,
+          metadata
+        )
+      end
     end
   end
 end