aidp 0.1.0 → 0.5.0

data/lib/aidp/jobs/provider_execution_job.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Jobs
+    class ProviderExecutionJob < BaseJob
+      def self.enqueue(provider_type:, prompt:, session: nil, metadata: {})
+        job = super
+        # Extract job ID explicitly for better readability and debugging
+        job_id = job.que_attrs[:job_id]
+        raise "Failed to enqueue job: no job ID returned" unless job_id
+        job_id
+      end
+
+      def run(provider_type:, prompt:, session: nil, metadata: {})
+        start_time = Time.now
+
+        # Get provider instance
+        provider = Aidp::ProviderManager.get_provider(provider_type)
+        raise "Provider #{provider_type} not available" unless provider
+
+        begin
+          # Execute provider
+          result = provider.send(prompt: prompt, session: session)
+
+          # Store result
+          store_result(result, metadata)
+
+          # Record metrics
+          record_metrics(
+            provider_type: provider_type,
+            duration: Time.now - start_time,
+            success: true,
+            error: nil
+          )
+        rescue => error
+          # Record metrics
+          record_metrics(
+            provider_type: provider_type,
+            duration: Time.now - start_time,
+            success: false,
+            error: error.message
+          )
+
+          # Re-raise error to trigger Que's retry mechanism
+          raise
+        end
+      end
+
+      private
+
+      def store_result(result, metadata)
+        return unless metadata[:step_name]
+
+        Aidp::DatabaseConnection.connection.exec_params(
+          <<~SQL,
+            INSERT INTO analysis_results (step_name, data, metadata, created_at, updated_at)
+            VALUES ($1, $2, $3, $4, $5)
+            ON CONFLICT (step_name)
+            DO UPDATE SET
+              data = EXCLUDED.data,
+              metadata = EXCLUDED.metadata,
+              updated_at = EXCLUDED.updated_at
+          SQL
+          [
+            metadata[:step_name],
+            result.to_json,
+            metadata.to_json,
+            Time.now,
+            Time.now
+          ]
+        )
+      end
+
+      def record_metrics(provider_type:, duration:, success:, error: nil)
+        Aidp::DatabaseConnection.connection.exec_params(
+          <<~SQL,
+            INSERT INTO provider_metrics (
+              provider_type, duration, success, error,
+              job_id, attempt, created_at
+            )
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+          SQL
+          [
+            provider_type,
+            duration,
+            success,
+            error,
+            que_attrs[:job_id],
+            que_attrs[:error_count] + 1,
+            Time.now
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/aidp/project_detector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Aidp
+  # Detects project type, language, framework, and other characteristics
+  class ProjectDetector
+    attr_reader :project_dir
+
+    def initialize(project_dir = Dir.pwd)
+      @project_dir = project_dir
+    end
+
+    def detect
+      {
+        language: detect_language,
+        framework: detect_framework,
+        build_system: detect_build_system,
+        package_manager: detect_package_manager,
+        static_analysis_tools: detect_static_analysis_tools,
+        test_framework: detect_test_framework,
+        database: detect_database,
+        deployment: detect_deployment
+      }
+    end
+
+    private
+
+    def detect_language
+      return "ruby" if File.exist?(File.join(@project_dir, "Gemfile"))
+      return "javascript" if File.exist?(File.join(@project_dir, "package.json"))
+      return "python" if File.exist?(File.join(@project_dir, "requirements.txt")) || File.exist?(File.join(@project_dir, "pyproject.toml"))
+      return "java" if File.exist?(File.join(@project_dir, "pom.xml")) || File.exist?(File.join(@project_dir, "build.gradle"))
+      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+      return "rust" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      return "csharp" if File.exist?(File.join(@project_dir, "*.csproj"))
+      "unknown"
+    end
+
+    def detect_framework
+      case detect_language
+      when "ruby"
+        return "rails" if File.exist?(File.join(@project_dir, "config", "application.rb"))
+        return "sinatra" if File.exist?(File.join(@project_dir, "app.rb")) && File.read(File.join(@project_dir, "app.rb")).include?("Sinatra")
+      when "javascript"
+        return "react" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("react")
+        return "vue" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("vue")
+        return "angular" if File.exist?(File.join(@project_dir, "angular.json"))
+        return "express" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("express")
+      when "python"
+        return "django" if File.exist?(File.join(@project_dir, "manage.py"))
+        return "flask" if File.exist?(File.join(@project_dir, "app.py")) && File.read(File.join(@project_dir, "app.py")).include?("Flask")
+      when "java"
+        return "spring" if File.exist?(File.join(@project_dir, "pom.xml")) && File.read(File.join(@project_dir, "pom.xml")).include?("spring-boot")
+      end
+      "unknown"
+    end
+
+    def detect_build_system
+      return "maven" if File.exist?(File.join(@project_dir, "pom.xml"))
+      return "gradle" if File.exist?(File.join(@project_dir, "build.gradle"))
+      return "npm" if File.exist?(File.join(@project_dir, "package.json"))
+      return "bundler" if File.exist?(File.join(@project_dir, "Gemfile"))
+      return "pip" if File.exist?(File.join(@project_dir, "requirements.txt"))
+      return "cargo" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+      "unknown"
+    end
+
+    def detect_package_manager
+      detect_build_system
+    end
+
+    def detect_static_analysis_tools
+      tools = []
+      tools << "rubocop" if File.exist?(File.join(@project_dir, ".rubocop.yml"))
+      tools << "eslint" if File.exist?(File.join(@project_dir, ".eslintrc"))
+      tools << "flake8" if File.exist?(File.join(@project_dir, ".flake8"))
+      tools << "checkstyle" if File.exist?(File.join(@project_dir, "checkstyle.xml"))
+      tools << "clippy" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      tools
+    end
+
+    def detect_test_framework
+      case detect_language
+      when "ruby"
+        return "rspec" if File.exist?(File.join(@project_dir, "spec"))
+        return "minitest" if File.exist?(File.join(@project_dir, "test"))
+      when "javascript"
+        return "jest" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("jest")
+        return "mocha" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("mocha")
+      when "python"
+        return "pytest" if File.exist?(File.join(@project_dir, "pytest.ini"))
+        return "unittest" if Dir.exist?(File.join(@project_dir, "tests"))
+      when "java"
+        return "junit" if File.exist?(File.join(@project_dir, "src", "test"))
+      end
+      "unknown"
+    end
+
+    def detect_database
+      return "postgresql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("postgresql")
+      return "mysql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("mysql")
+      return "sqlite" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("sqlite")
+      "unknown"
+    end
+
+    def detect_deployment
+      return "docker" if File.exist?(File.join(@project_dir, "Dockerfile"))
+      return "kubernetes" if File.exist?(File.join(@project_dir, "k8s")) || File.exist?(File.join(@project_dir, "kubernetes"))
+      return "heroku" if File.exist?(File.join(@project_dir, "Procfile"))
+      return "aws" if File.exist?(File.join(@project_dir, "serverless.yml")) || File.exist?(File.join(@project_dir, "template.yaml"))
+      "unknown"
+    end
+  end
+end

data/lib/aidp/provider_manager.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Aidp
+  class ProviderManager
+    class << self
+      def get_provider(provider_type)
+        case provider_type
+        when "cursor"
+          Aidp::Providers::Cursor.new
+        when "anthropic"
+          Aidp::Providers::Anthropic.new
+        when "gemini"
+          Aidp::Providers::Gemini.new
+        when "macos_ui"
+          Aidp::Providers::MacosUI.new
+        end
+      end
+
+      def load_from_config(config = {})
+        provider_type = config["provider"] || "cursor"
+        get_provider(provider_type)
+      end
+    end
+  end
+end

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
+            # Give up
+          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