aidp 0.3.0 → 0.5.0

data/lib/aidp/providers/cursor.rb

@@ -27,9 +27,24 @@ module Aidp
         end
 
         # Setup logging if log file is specified
-        log_file = ENV["AIDP_LOG_FILE"]
-        if log_file
-          puts "📝 Logging to: #{log_file}"
+        log_file = ENV["AIDP_CURSOR_LOG"]
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        puts "⏱️  Timeout set to #{timeout_seconds} seconds"
+
+        # Set up activity monitoring
+        setup_activity_monitoring("cursor-agent", method(:activity_callback))
+        record_activity("Starting cursor-agent execution")
+
+        # Start activity display thread
+        activity_display_thread = Thread.new do
+          loop do
+            sleep 0.1 # Update every 100ms for smooth animation
+            print_activity_status
+            break if @activity_state == :completed || @activity_state == :failed
+          end
         end
 
         Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
@@ -37,62 +52,251 @@ module Aidp
           stdin.puts prompt
           stdin.close
 
-          # Log the prompt if debugging
-          if ENV["AIDP_DEBUG"] || log_file
-            prompt_log = "📝 Sending prompt to cursor-agent:\n#{prompt}"
-            puts prompt_log if ENV["AIDP_DEBUG"]
-            File.write(log_file, "#{Time.now.iso8601} #{prompt_log}\n", mode: "a") if log_file
-          end
+          # Read stdout and stderr synchronously for better reliability
+          output = ""
+          error_output = ""
 
-          # Handle debug output and logging
-          if ENV["AIDP_DEBUG"] || log_file
-            # Start threads to capture and display output in real-time
-            stdout_thread = Thread.new do
-              stdout.each_line do |line|
-                output = "📤 cursor-agent: #{line.chomp}"
-                puts output if ENV["AIDP_DEBUG"]
-                File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+          # Read stdout
+          stdout_thread = Thread.new do
+            stdout&.each_line do |line|
+              output += line
+              if ENV["AIDP_DEBUG"]
+                clear_activity_status
+                puts "📤 cursor-agent: #{line.chomp}"
+                $stdout.flush # Force output to display immediately
               end
+              File.write(log_file, "#{Time.now.iso8601} #{line}\n", mode: "a") if log_file
+
+              # Record activity when we get output
+              record_activity("Received output: #{line.chomp[0..50]}...")
             end
+          rescue IOError => e
+            puts "📤 stdout stream closed: #{e.message}" if ENV["AIDP_DEBUG"]
+          end
 
-            stderr_thread = Thread.new do
-              stderr.each_line do |line|
-                output = "❌ cursor-agent error: #{line.chomp}"
-                puts output if ENV["AIDP_DEBUG"]
-                File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+          # Read stderr
+          stderr_thread = Thread.new do
+            stderr&.each_line do |line|
+              error_output += line
+              if ENV["AIDP_DEBUG"]
+                clear_activity_status
+                puts "❌ cursor-agent error: #{line.chomp}"
+                $stdout.flush # Force output to display immediately
               end
+              File.write(log_file, "#{Time.now.iso8601} #{line}\n", mode: "a") if log_file
+
+              # Record activity when we get error output
+              record_activity("Error output: #{line.chomp[0..50]}...")
             end
+          rescue IOError => e
+            puts "❌ stderr stream closed: #{e.message}" if ENV["AIDP_DEBUG"]
           end
 
-          # Wait for completion with a reasonable timeout
-          begin
-            Timeout.timeout(300) do # 5 minutes timeout
-              result = wait.value
+          # Start activity monitoring thread
+          activity_thread = Thread.new do
+            loop do
+              sleep 10 # Check every 10 seconds
 
-              # Stop debug threads
-              if ENV["AIDP_DEBUG"]
-                stdout_thread&.kill
-                stderr_thread&.kill
+              if stuck?
+                clear_activity_status
+                puts "⚠️  cursor-agent 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 "\n🛑 User requested abort"
+                  Process.kill("TERM", wait.pid)
+                  break
+                end
               end
 
-              return :ok if result.success?
-              raise "cursor-agent failed with exit code #{result.exitstatus}"
+              # Stop checking if the process is done
+              break if wait.value
+            rescue
+              break
             end
-          rescue Timeout::Error
-            # Stop debug threads
-            if ENV["AIDP_DEBUG"]
-              stdout_thread&.kill
-              stderr_thread&.kill
+          end
+
+          # Wait for process to complete with timeout
+          begin
+            # Start a timeout thread that will kill the process if it takes too long
+            timeout_thread = Thread.new do
+              sleep timeout_seconds
+              begin
+                Process.kill("TERM", wait.pid)
+                sleep 2
+                Process.kill("KILL", wait.pid) if wait.value.nil?
+              rescue
+                # Process already terminated
+              end
             end
 
-            # Kill the process if it's taking too long
-            begin
-              Process.kill("TERM", wait.pid)
-            rescue
-              nil
+            # Wait for the process to complete
+            exit_status = wait.value
+
+            # Cancel the timeout thread since we completed successfully
+            timeout_thread.kill
+          rescue => e
+            # Kill the timeout thread
+            timeout_thread&.kill
+
+            # Check if this was a timeout
+            if e.is_a?(Timeout::Error) || execution_time >= timeout_seconds
+              # Kill the process if it times out
+              begin
+                Process.kill("TERM", wait.pid)
+                sleep 1
+                Process.kill("KILL", wait.pid) if wait.value.nil?
+              rescue
+                # Process already terminated
+              end
+
+              # Wait for output threads to finish (with timeout)
+              [stdout_thread, stderr_thread, activity_thread].each do |thread|
+                thread.join(5) # Wait up to 5 seconds for each thread
+              end
+
+              # Stop activity display
+              activity_display_thread.join
+
+              clear_activity_status
+              mark_failed("cursor-agent timed out after #{timeout_seconds} seconds")
+              raise Timeout::Error, "cursor-agent timed out after #{timeout_seconds} seconds"
+            else
+              raise e
             end
-            raise Timeout::Error, "cursor-agent timed out after 5 minutes"
           end
+
+          # Wait for output threads to finish (with timeout)
+          [stdout_thread, stderr_thread, activity_thread].each do |thread|
+            thread.join(5) # Wait up to 5 seconds for each thread
+          end
+
+          # Stop activity display
+          activity_display_thread.join
+
+          clear_activity_status
+          if exit_status.success?
+            mark_completed
+            output
+          else
+            mark_failed("cursor-agent failed with exit code #{exit_status.exitstatus}")
+            raise "cursor-agent failed with exit code #{exit_status.exitstatus}: #{error_output}"
+          end
+        end
+      rescue Timeout::Error
+        clear_activity_status
+        mark_failed("cursor-agent timed out after #{timeout_seconds} seconds")
+        raise Timeout::Error, "cursor-agent timed out after #{timeout_seconds} seconds"
+      rescue => e
+        clear_activity_status
+        mark_failed("cursor-agent execution was interrupted: #{e.message}")
+        raise
+      end
+
+      private
+
+      def print_activity_status
+        # Print activity status during cursor execution
+        print "🔄 cursor-agent is running..."
+        $stdout.flush
+      end
+
+      def clear_activity_status
+        # Clear the activity status line
+        print "\r" + " " * 50 + "\r"
+        $stdout.flush
+      end
+
+      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_CURSOR_TIMEOUT"]
+          return ENV["AIDP_CURSOR_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
+        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 20% buffer for safety
+            return (recommended * 1.2).ceil
+          end
+        rescue => e
+          puts "⚠️  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/
+          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
+
+      def activity_callback(state, message, provider)
+        # This is now handled by the animated display thread
+        # Only print static messages for state changes
+        case state
+        when :stuck
+          puts "\n⚠️  cursor appears stuck: #{message}"
+        when :completed
+          puts "\n✅ cursor completed: #{message}"
+        when :failed
+          puts "\n❌ cursor failed: #{message}"
         end
       end
     end

data/lib/aidp/providers/gemini.rb

@@ -14,10 +14,173 @@ module Aidp
       def send(prompt:, session: nil)
         raise "gemini CLI not available" unless self.class.available?
 
+        require "open3"
+
         # Use Gemini CLI for non-interactive mode
-        cmd = ["gemini", "chat", "--prompt", prompt]
-        system(*cmd)
-        :ok
+        cmd = ["gemini", "--print"]
+
+        puts "📝 Sending prompt to gemini..."
+
+        # 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 "⚠️  gemini 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 gemini..."
+                  Process.kill("TERM", wait.pid)
+                  raise Interrupt, "User aborted gemini execution"
+                end
+              end
+
+              # Stop checking if the process is done
+              break if wait.value
+            rescue
+              break
+            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 "✅ Gemini analysis completed"
+                mark_completed
+                return output.empty? ? :ok : output
+              else
+                error_output = stderr.read
+                mark_failed("gemini failed with exit code #{result.exitstatus}: #{error_output}")
+                raise "gemini 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
+              nil
+            end
+
+            mark_failed("gemini timed out after #{timeout_seconds} seconds")
+            raise Timeout::Error, "gemini 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
+              nil
+            end
+
+            mark_failed("gemini 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_GEMINI_TIMEOUT"]
+          return ENV["AIDP_GEMINI_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
+        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 20% buffer for safety
+            return (recommended * 1.2).ceil
+          end
+        rescue => e
+          puts "⚠️  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/
+          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