aidp 0.1.0 → 0.5.0

data/lib/aidp/providers/gemini.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Providers
+    class Gemini < Base
+      def self.available?
+        !!Aidp::Util.which("gemini")
+      end
+
+      def name = "gemini"
+
+      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
+
+          # 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
+end

data/lib/aidp/providers/macos_ui.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Providers
+    class MacOSUI < Base
+      def self.available?
+        RUBY_PLATFORM.include?("darwin")
+      end
+
+      def name = "macos"
+
+      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
+      end
+    end
+  end
+end

data/lib/aidp/providers/supervised_base.rb

@@ -0,0 +1,317 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,13 @@
+# 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

data/lib/aidp/util.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  # Utility functions shared between execute and analyze modes
+  class Util
+    def self.which(cmd)
+      exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+      ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+
+    def self.ensure_dirs(output_files, project_dir)
+      output_files.each do |file|
+        dir = File.dirname(File.join(project_dir, file))
+        FileUtils.mkdir_p(dir) unless dir == "."
+      end
+    end
+
+    def self.safe_file_write(path, content)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, content)
+    end
+
+    def self.project_root?(dir = Dir.pwd)
+      File.exist?(File.join(dir, ".git")) ||
+        File.exist?(File.join(dir, "package.json")) ||
+        File.exist?(File.join(dir, "Gemfile")) ||
+        File.exist?(File.join(dir, "pom.xml")) ||
+        File.exist?(File.join(dir, "build.gradle"))
+    end
+  end
+end

data/lib/aidp/{shared/version.rb → version.rb}

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  module Shared
-    VERSION = "0.1.0"
-  end
+  VERSION = "0.5.0"
 end

data/lib/aidp/workspace.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+
+module Aidp
+  # Workspace management utilities
+  class Workspace
+    def self.current
+      Dir.pwd
+    end
+
+    def self.ensure_project_root
+      unless Aidp::Util.project_root?
+        raise "Not in a project root directory. Please run from a directory with .git, package.json, Gemfile, etc."
+      end
+    end
+  end
+end