aidp 0.5.0 → 0.8.0

data/lib/aidp/providers/cursor.rb

@@ -1,213 +1,100 @@
 # frozen_string_literal: true
 
-require "open3"
 require "timeout"
 require_relative "base"
 require_relative "../util"
+require_relative "../debug_mixin"
 
 module Aidp
   module Providers
     class Cursor < Base
+      include Aidp::DebugMixin
+
       def self.available?
         !!Aidp::Util.which("cursor-agent")
       end
 
-      def name = "cursor"
+      def name
+        "cursor"
+      end
 
       def send(prompt:, session: nil)
         raise "cursor-agent not available" unless self.class.available?
 
-        # Always use non-interactive mode with -p flag
-        cmd = ["cursor-agent", "-p"]
-        puts "📝 Sending prompt to cursor-agent"
-
-        # Enable debug output if requested
-        if ENV["AIDP_DEBUG"]
-          puts "🔍 Debug mode enabled - showing cursor-agent output"
-        end
-
-        # Setup logging if log file is specified
-        log_file = ENV["AIDP_CURSOR_LOG"]
-
         # Smart timeout calculation
         timeout_seconds = calculate_timeout
 
-        puts "⏱️  Timeout set to #{timeout_seconds} seconds"
+        debug_provider("cursor", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to cursor-agent (length: #{prompt.length})", level: :info)
 
         # Set up activity monitoring
         setup_activity_monitoring("cursor-agent", method(:activity_callback))
         record_activity("Starting cursor-agent execution")
 
-        # Start activity display thread
+        # Start activity display thread with timeout
         activity_display_thread = Thread.new do
+          start_time = Time.now
           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|
-          # Send the prompt to stdin
-          stdin.puts prompt
-          stdin.close
+            sleep 0.5 # Update every 500ms to reduce spam
+            elapsed = Time.now - start_time
 
-          # Read stdout and stderr synchronously for better reliability
-          output = ""
-          error_output = ""
+            # Break if we've been running too long or state changed
+            break if elapsed > timeout_seconds || @activity_state == :completed || @activity_state == :failed
 
-          # 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
-
-          # 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
-
-          # Start activity monitoring thread
-          activity_thread = Thread.new do
-            loop do
-              sleep 10 # Check every 10 seconds
-
-              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
-
-              # Stop checking if the process is done
-              break if wait.value
-            rescue
-              break
-            end
+            print_activity_status(elapsed)
           end
+        end
 
-          # Wait for process to complete with timeout
+        begin
+          # Use debug_execute_command for better debugging
+          # Try agent command first (better for large prompts), fallback to -p mode
           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
-
-            # Wait for the process to complete
-            exit_status = wait.value
-
-            # Cancel the timeout thread since we completed successfully
-            timeout_thread.kill
+            result = debug_execute_command("cursor-agent", args: ["agent"], input: prompt, timeout: timeout_seconds)
           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
+            # Fallback to -p mode if agent command fails
+            debug_log("🔄 Falling back to -p mode: #{e.message}", level: :warn)
+            result = debug_execute_command("cursor-agent", args: ["-p"], input: prompt, timeout: timeout_seconds)
           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
+          # Log the results
+          debug_command("cursor-agent", args: ["-p"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
 
           # Stop activity display
-          activity_display_thread.join
-
+          activity_display_thread.kill if activity_display_thread.alive?
+          activity_display_thread.join(0.1) # Give it 100ms to finish
           clear_activity_status
-          if exit_status.success?
+
+          if result.exit_status == 0
             mark_completed
-            output
+            result.out
           else
-            mark_failed("cursor-agent failed with exit code #{exit_status.exitstatus}")
-            raise "cursor-agent failed with exit code #{exit_status.exitstatus}: #{error_output}"
+            mark_failed("cursor-agent failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("cursor-agent failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "cursor-agent failed with exit code #{result.exit_status}: #{result.err}"
           end
+        rescue => e
+          # Stop activity display
+          activity_display_thread.kill if activity_display_thread.alive?
+          activity_display_thread.join(0.1) # Give it 100ms to finish
+          clear_activity_status
+          mark_failed("cursor-agent execution failed: #{e.message}")
+          debug_error(e, {provider: "cursor", prompt_length: prompt.length})
+          raise
         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..."
+      def print_activity_status(elapsed)
+        # Print activity status during cursor execution with elapsed time
+        minutes = (elapsed / 60).to_i
+        seconds = (elapsed % 60).to_i
+
+        if minutes > 0
+          print "\r🔄 cursor-agent is running... (#{minutes}m #{seconds}s)"
+        else
+          print "\r🔄 cursor-agent is running... (#{seconds}s)"
+        end
         $stdout.flush
       end
 
@@ -246,25 +133,7 @@ module Aidp
       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
+        # Timeout recommendations based on step type patterns
         step_name = ENV["AIDP_CURRENT_STEP"] || ""
 
         case step_name

data/lib/aidp/providers/gemini.rb

@@ -1,113 +1,46 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../debug_mixin"
 
 module Aidp
   module Providers
     class Gemini < Base
+      include Aidp::DebugMixin
+
       def self.available?
         !!Aidp::Util.which("gemini")
       end
 
-      def name = "gemini"
+      def name
+        "gemini"
+      end
 
       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", "--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
+        debug_provider("gemini", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to gemini...", level: :info)
+
+        begin
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("gemini", args: ["--print"], input: prompt, timeout: timeout_seconds)
+
+          # Log the results
+          debug_command("gemini", args: ["--print"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
 
-          # 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
+          if result.exit_status == 0
+            result.out
+          else
+            debug_error(StandardError.new("gemini failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "gemini failed with exit code #{result.exit_status}: #{result.err}"
           end
+        rescue => e
+          debug_error(e, {provider: "gemini", prompt_length: prompt.length})
+          raise
         end
       end
 
@@ -142,25 +75,7 @@ module Aidp
       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
+        # Timeout recommendations based on step type patterns
         step_name = ENV["AIDP_CURRENT_STEP"] || ""
 
         case step_name

data/lib/aidp/providers/macos_ui.rb

@@ -1,23 +1,117 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../debug_mixin"
 
 module Aidp
   module Providers
     class MacOSUI < Base
+      include Aidp::DebugMixin
+
       def self.available?
         RUBY_PLATFORM.include?("darwin")
       end
 
-      def name = "macos"
+      def name
+        "macos"
+      end
 
       def send(prompt:, session: nil)
         raise "macOS UI not available on this platform" unless self.class.available?
 
-        # Use macOS UI for interactive mode
-        cmd = ["osascript", "-e", "display dialog \"#{prompt}\" with title \"Aidp\" buttons {\"OK\"} default button \"OK\""]
-        system(*cmd)
-        :ok
+        debug_provider("macos", "Starting Cursor interaction", {prompt_length: prompt.length})
+
+        # Try to use Cursor's chat interface via AppleScript
+        result = interact_with_cursor(prompt)
+
+        if result[:success]
+          debug_log("✅ Successfully sent prompt to Cursor", level: :info)
+          result[:response]
+        else
+          debug_log("❌ Failed to interact with Cursor: #{result[:error]}", level: :warn)
+          # Fallback to simple dialog
+          fallback_dialog(prompt)
+        end
+      end
+
+      private
+
+      def interact_with_cursor(prompt)
+        # Create a temporary script file for the prompt with proper encoding
+        temp_file = "/tmp/aidp_cursor_prompt.txt"
+        File.write(temp_file, prompt, encoding: "UTF-8")
+
+        # AppleScript to interact with Cursor - use properly escaped prompt to avoid injection
+        escaped_prompt = escape_for_applescript(prompt)
+        script = <<~APPLESCRIPT
+          tell application "Cursor"
+            activate
+          end tell
+
+          delay 1
+
+          tell application "System Events"
+            -- Open chat panel (Cmd+L)
+            keystroke "l" using command down
+            delay 2
+
+            -- Type the prompt (properly escaped)
+            keystroke "#{escaped_prompt}"
+            delay 1
+
+            -- Send the message (Enter)
+            keystroke (ASCII character 13)
+            delay 3
+
+            -- Try to get response (this is tricky without accessibility permissions)
+            -- For now, we'll just return success
+            return "Prompt sent to Cursor chat"
+          end tell
+        APPLESCRIPT
+
+        begin
+          # Use Open3 to safely execute AppleScript without shell injection
+          require "open3"
+
+          # Write AppleScript to temporary file to avoid command line issues
+          script_file = "/tmp/aidp_cursor_script.scpt"
+          File.write(script_file, script, encoding: "UTF-8")
+
+          stdout, stderr, status = Open3.capture3("osascript", script_file)
+
+          if status.success?
+            {success: true, response: stdout.strip}
+          else
+            {success: false, error: stderr.strip}
+          end
+        rescue => e
+          {success: false, error: e.message}
+        ensure
+          File.delete(temp_file) if File.exist?(temp_file)
+          File.delete(script_file) if File.exist?(script_file)
+        end
+      end
+
+      def escape_for_applescript(text)
+        # Escape special characters for AppleScript
+        # Must escape backslashes first to avoid double-escaping
+        text.gsub("\\", "\\\\").gsub('"', '\\"').gsub("'", "\\'").gsub("\n", "\\n")
+      end
+
+      def fallback_dialog(prompt)
+        # Fallback to simple dialog
+        truncated_prompt = (prompt.length > 200) ? prompt[0..200] + "..." : prompt
+
+        script = <<~APPLESCRIPT
+          display dialog "#{escape_for_applescript(truncated_prompt)}" with title "Aidp - Cursor Integration" buttons {"OK", "Open Cursor"} default button "Open Cursor"
+          set buttonPressed to button returned of result
+          if buttonPressed is "Open Cursor" then
+            tell application "Cursor" to activate
+          end if
+        APPLESCRIPT
+
+        system("osascript", "-e", script)
+        "Dialog shown - please use Cursor manually"
       end
     end
   end