aidp 0.3.0 → 0.5.0

data/lib/aidp/analyze/runner.rb

@@ -1,98 +1,125 @@
 # frozen_string_literal: true
 
-require "erb"
-require "yaml"
-require "json"
+require "timeout"
+require "que"
+require "sequel"
 
 module Aidp
   module Analyze
-    # Handles execution logic for analyze mode steps
     class Runner
-      attr_reader :project_dir, :progress
-
       def initialize(project_dir)
         @project_dir = project_dir
-        @progress = Aidp::Analyze::Progress.new(project_dir)
       end
 
-      def run_step(step_name, options = {})
-        raise "Step '#{step_name}' not found in analyze mode steps" unless Aidp::Analyze::Steps::SPEC.key?(step_name)
+      def progress
+        @progress ||= Aidp::Analyze::Progress.new(@project_dir)
+      end
 
+      def run_step(step_name, options = {})
+        # Always validate step exists first, even in mock mode
         step_spec = Aidp::Analyze::Steps::SPEC[step_name]
-        template_name = step_spec["templates"].first
+        raise "Step '#{step_name}' not found" unless step_spec
 
-        # Load template
-        template = find_template(template_name)
-        raise "Template '#{template_name}' not found" unless template
+        if should_use_mock_mode?(options)
+          result = options[:simulate_error] ?
+            {status: "error", error: options[:simulate_error]} :
+            mock_execution_result
 
-        # Compose prompt with agent persona
-        prompt = composed_prompt(template_name, step_spec["agent"], options)
+          # Add focus areas and export formats to mock result if provided
+          result[:focus_areas] = options[:focus]&.split(",") if options[:focus]
+          result[:export_formats] = options[:format]&.split(",") if options[:format]
 
-        # Handle error simulation for tests
-        if options[:simulate_error]
-          return {
-            status: "error",
-            error: options[:simulate_error],
-            step: step_name
-          }
+          return result
         end
 
-        # Execute step (mock for now)
-        result = {
-          status: "success",
-          step: step_name,
-          output_files: step_spec["outs"],
-          prompt: prompt,
-          agent: step_spec["agent"]
-        }
-
-        # Add test-specific fields based on options
-        result[:force_used] = true if options[:force]
-
-        result[:rerun_used] = true if options[:rerun]
+        # Set up database connection for background jobs
+        setup_database_connection
 
-        result[:focus_areas] = options[:focus].split(",") if options[:focus]
-
-        result[:export_formats] = options[:format].split(",") if options[:format]
+        puts "🚀 Enqueuing background job for step: #{step_name}"
+        job = Aidp::Jobs::ProviderExecutionJob.enqueue(
+          provider_type: "cursor",
+          prompt: composed_prompt(step_name, options),
+          metadata: {
+            step_name: step_name,
+            project_dir: @project_dir
+          }
+        )
+        puts "✅ Job enqueued with ID: #{job}"
 
-        # Simulate chunking for large repositories
-        result[:chunking_used] = true if Dir.glob(File.join(@project_dir, "**", "*")).count > 50
+        wait_for_job_completion(job)
+      end
 
-        # Simulate warnings for network errors
-        result[:warnings] = ["Network timeout"] if options[:simulate_network_error]
+      private
 
-        # Simulate tools used for configuration tests
-        if step_name == "06_STATIC_ANALYSIS"
-          result[:tools_used] = %w[rubocop reek]
-          # Check for user config
-          user_config_file = File.expand_path("~/.aidp-tools.yml")
-          result[:tools_used] << "eslint" if File.exist?(user_config_file)
+      def setup_database_connection
+        # Skip database setup in test mode if we're mocking
+        return if ENV["RACK_ENV"] == "test" && ENV["MOCK_DATABASE"] == "true"
+
+        dbname = (ENV["RACK_ENV"] == "test") ? "aidp_test" : (ENV["AIDP_DB_NAME"] || "aidp")
+
+        # Use Sequel for connection pooling with timeout
+        Timeout.timeout(10) do
+          Que.connection = Sequel.connect(
+            adapter: "postgres",
+            host: ENV["AIDP_DB_HOST"] || "localhost",
+            port: ENV["AIDP_DB_PORT"] || 5432,
+            database: dbname,
+            user: ENV["AIDP_DB_USER"] || ENV["USER"],
+            password: ENV["AIDP_DB_PASSWORD"],
+            max_connections: 10,
+            pool_timeout: 30
+          )
+
+          Que.migrate!(version: Que::Migrations::CURRENT_VERSION)
         end
+      rescue Timeout::Error
+        puts "Database connection timed out"
+        raise
+      rescue => e
+        puts "Error connecting to database: #{e.message}"
+        raise
+      end
 
-        # Mark step as completed
-        @progress.mark_step_completed(step_name)
-
-        # Generate output files
-        generate_output_files(step_name, step_spec["outs"], result)
-
-        # Generate database export for any step
-        generate_database_export
-
-        # Generate tool configuration file for static analysis step
-        generate_tool_configuration if step_name == "06_STATIC_ANALYSIS"
-
-        # Generate summary report if this is the last step
-        generate_summary_report if step_name == "07_REFACTORING_RECOMMENDATIONS"
+      def should_use_mock_mode?(options)
+        return false if options[:background] # Force background jobs if requested
+        # Only use mock mode when explicitly requested or in tests
+        options[:mock_mode] || ENV["AIDP_MOCK_MODE"] == "1" || ENV["RAILS_ENV"] == "test"
+      end
 
-        result
+      def mock_execution_result
+        {
+          status: "completed",
+          provider: "mock",
+          message: "Mock execution"
+        }
       end
 
-      private
+      def wait_for_job_completion(job_id)
+        loop do
+          job = Que.execute("SELECT * FROM que_jobs WHERE id = $1", [job_id]).first
+          return {status: "completed", provider: "test_provider", message: "Analysis completed successfully"} if job && job["finished_at"] && job["error_count"] == 0
+          return {status: "error", error: job["last_error_message"]} if job && job["error_count"] && job["error_count"] > 0
+
+          if job && job["finished_at"].nil? && job["run_at"]
+            duration = Time.now - job["run_at"]
+            minutes = (duration / 60).to_i
+            seconds = (duration % 60).to_i
+            duration_str = (minutes > 0) ? "#{minutes}m #{seconds}s" : "#{seconds}s"
+            print "\r🔄 Job #{job_id} is running (#{duration_str})...".ljust(80)
+          else
+            print "\r⏳ Job #{job_id} is pending...".ljust(80)
+          end
+          $stdout.flush
+          sleep 1
+        end
+      ensure
+        print "\r" + " " * 80 + "\r"
+      end
 
       def find_template(template_name)
         template_search_paths.each do |path|
-          template_file = File.join(path, template_name)
-          return File.read(template_file) if File.exist?(template_file)
+          template_path = File.join(path, template_name)
+          return template_path if File.exist?(template_path)
         end
         nil
       end
@@ -100,26 +127,21 @@ module Aidp
       def template_search_paths
         [
           File.join(@project_dir, "templates", "ANALYZE"),
-          File.join(@project_dir, "templates", "COMMON"),
-          File.join(@project_dir, "templates"),
-          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "ANALYZE"),
-          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "COMMON")
+          File.join(@project_dir, "templates", "COMMON")
         ]
       end
 
-      def composed_prompt(template_name, agent_persona, options = {})
-        template = find_template(template_name)
-        return template unless template
+      def composed_prompt(step_name, options = {})
+        step_spec = Aidp::Analyze::Steps::SPEC[step_name]
+        raise "Step '#{step_name}' not found" unless step_spec
 
-        # Load agent base template if available
-        agent_base = find_template("AGENT_BASE.md")
-        template = "#{agent_base}\n\n#{template}" if agent_base
+        template_name = step_spec["templates"].first
+        template_path = find_template(template_name)
+        raise "Template not found for step #{step_name}" unless template_path
 
-        # Add agent persona context
-        persona = Aidp::Analyze::AgentPersonas.get_persona(agent_persona)
-        template = "# Agent Persona: #{persona["name"]}\n#{persona["description"]}\n\n#{template}" if persona
+        template = File.read(template_path)
 
-        # Replace placeholders
+        # Replace template variables in the format {{key}} with option values
         options.each do |key, value|
           template = template.gsub("{{#{key}}}", value.to_s)
         end
@@ -127,118 +149,12 @@ module Aidp
         template
       end
 
-      def generate_output_files(step_name, output_files, result)
-        output_files.each do |output_file|
-          file_path = File.join(@project_dir, output_file)
-          content = generate_output_content(step_name, output_file, result)
-          File.write(file_path, content)
-        end
-
-        # Handle additional export formats if specified
-        return unless result[:export_formats]
-
-        result[:export_formats].each do |format|
-          case format
-          when "json"
-            json_file = File.join(@project_dir, "#{step_name}.json")
-            File.write(json_file, result.to_json)
-          when "csv"
-            csv_file = File.join(@project_dir, "#{step_name}.csv")
-            csv_content = "step,status,agent\n#{step_name},#{result[:status]},#{result[:agent]}"
-            File.write(csv_file, csv_content)
-          end
-        end
-      end
-
-      def generate_output_content(step_name, output_file, result)
-        case output_file
-        when /\.md$/
-          # Use the actual template content if available
-          template_name = Aidp::Analyze::Steps::SPEC[step_name]["templates"].first
-          template = find_template(template_name)
-          if template
-            "# #{step_name} Analysis\n\nGenerated on #{Time.now}\n\n## Result\n\n#{result[:status]}\n\n## Agent\n\n#{result[:agent]}\n\n## Template Content\n\n#{template}"
-          else
-            "# #{step_name} Analysis\n\nGenerated on #{Time.now}\n\n## Result\n\n#{result[:status]}\n\n## Agent\n\n#{result[:agent]}"
-          end
-        when /\.json$/
-          result.to_json
-        else
-          "Analysis output for #{step_name}: #{result[:status]}"
-        end
-      end
-
-      def generate_tool_configuration
-        tools_file = File.join(@project_dir, ".aidp-analyze-tools.yml")
-        tools_config = {
-          "preferred_tools" => {
-            "ruby" => %w[rubocop reek],
-            "javascript" => ["eslint"]
-          },
-          "execution_settings" => {
-            "parallel_execution" => true
-          }
-        }
-        File.write(tools_file, tools_config.to_yaml)
-      end
-
-      def generate_summary_report
-        summary_file = File.join(@project_dir, "ANALYSIS_SUMMARY.md")
-        content = "# Analysis Summary\n\n"
-        content += "Generated on #{Time.now}\n\n"
-
-        step_names = {
-          "01_REPOSITORY_ANALYSIS" => "Repository Analysis",
-          "02_ARCHITECTURE_ANALYSIS" => "Architecture Analysis",
-          "03_TEST_ANALYSIS" => "Test Coverage Analysis",
-          "04_FUNCTIONALITY_ANALYSIS" => "Functionality Analysis",
-          "05_DOCUMENTATION_ANALYSIS" => "Documentation Analysis",
-          "06_STATIC_ANALYSIS" => "Static Analysis",
-          "07_REFACTORING_RECOMMENDATIONS" => "Refactoring Recommendations"
-        }
-
-        Aidp::Analyze::Steps::SPEC.keys.each do |step|
-          readable_name = step_names[step] || step
-          content += if @progress.step_completed?(step)
-            "## #{readable_name}\n✅ Completed\n\n"
-          else
-            "## #{readable_name}\n⏳ Pending\n\n"
-          end
-        end
-
-        File.write(summary_file, content)
-      end
-
-      def generate_database_export
-        database_file = File.join(@project_dir, ".aidp-analysis.db")
-        require "sqlite3"
-
-        begin
-          db = SQLite3::Database.new(database_file)
-          db.execute("CREATE TABLE IF NOT EXISTS analysis_results (step TEXT, status TEXT, agent TEXT, completed_at TEXT)")
+      private
 
-          Aidp::Analyze::Steps::SPEC.keys.each do |step|
-            if @progress.step_completed?(step)
-              db.execute("INSERT INTO analysis_results (step, status, agent, completed_at) VALUES (?, ?, ?, ?)",
-                [step, "success", Aidp::Analyze::Steps::SPEC[step]["agent"], Time.now.iso8601])
-            end
-          end
-        rescue SQLite3::BusyException
-          # Retry once after a short delay
-          sleep(0.1)
-          db = SQLite3::Database.new(database_file)
-          db.execute("CREATE TABLE IF NOT EXISTS analysis_results (step TEXT, status TEXT, agent TEXT, completed_at TEXT)")
-
-          Aidp::Analyze::Steps::SPEC.keys.each do |step|
-            if @progress.step_completed?(step)
-              db.execute("INSERT INTO analysis_results (step, status, agent, completed_at) VALUES (?, ?, ?, ?)",
-                [step, "success", Aidp::Analyze::Steps::SPEC[step]["agent"], Time.now.iso8601])
-            end
-          end
-        rescue => e
-          # Log the error but don't fail the analysis
-          puts "Warning: Database export failed: #{e.message}"
-        end
+      def store_execution_metrics(step_name, result, duration)
+        # Store execution metrics in the database for analysis
+        # This is a placeholder implementation
+        # In a real implementation, this would connect to a database and store metrics
       end
     end
   end

data/lib/aidp/analyze/steps.rb

@@ -2,50 +2,49 @@
 
 module Aidp
   module Analyze
-    # Defines the steps, templates, outputs, and associated AI agents for analyze mode
-    class Steps
+    module Steps
       SPEC = {
         "01_REPOSITORY_ANALYSIS" => {
-          "templates" => ["01_REPOSITORY_ANALYSIS.md"],
-          "outs" => ["01_REPOSITORY_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Repository Analyst"
+          "templates" => ["01_repository_analysis.md"],
+          "description" => "Initial code-maat based repository mining",
+          "outs" => ["docs/analysis/repository_analysis.md"],
+          "gate" => false
         },
         "02_ARCHITECTURE_ANALYSIS" => {
-          "templates" => ["02_ARCHITECTURE_ANALYSIS.md"],
-          "outs" => ["02_ARCHITECTURE_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Architecture Analyst"
+          "templates" => ["02_architecture_analysis.md"],
+          "description" => "Identify architectural patterns, dependencies, and violations",
+          "outs" => ["docs/analysis/architecture_analysis.md"],
+          "gate" => true
         },
         "03_TEST_ANALYSIS" => {
-          "templates" => ["03_TEST_ANALYSIS.md"],
-          "outs" => ["03_TEST_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Test Analyst"
+          "templates" => ["03_test_analysis.md"],
+          "description" => "Analyze existing test coverage and identify gaps",
+          "outs" => ["docs/analysis/test_analysis.md"],
+          "gate" => false
         },
         "04_FUNCTIONALITY_ANALYSIS" => {
-          "templates" => ["04_FUNCTIONALITY_ANALYSIS.md"],
-          "outs" => ["04_FUNCTIONALITY_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Functionality Analyst"
+          "templates" => ["04_functionality_analysis.md"],
+          "description" => "Map features, identify dead code, analyze complexity",
+          "outs" => ["docs/analysis/functionality_analysis.md"],
+          "gate" => false
         },
         "05_DOCUMENTATION_ANALYSIS" => {
-          "templates" => ["05_DOCUMENTATION_ANALYSIS.md"],
-          "outs" => ["05_DOCUMENTATION_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Documentation Analyst"
+          "templates" => ["05_documentation_analysis.md"],
+          "description" => "Identify missing documentation and generate what's needed",
+          "outs" => ["docs/analysis/documentation_analysis.md"],
+          "gate" => false
         },
         "06_STATIC_ANALYSIS" => {
-          "templates" => ["06_STATIC_ANALYSIS.md"],
-          "outs" => ["06_STATIC_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Static Analysis Expert"
+          "templates" => ["06_static_analysis.md"],
+          "description" => "Check for existing tools and recommend improvements",
+          "outs" => ["docs/analysis/static_analysis.md"],
+          "gate" => false
         },
         "07_REFACTORING_RECOMMENDATIONS" => {
-          "templates" => ["07_REFACTORING_RECOMMENDATIONS.md"],
-          "outs" => ["07_REFACTORING_RECOMMENDATIONS.md"],
-          "gate" => false,
-          "agent" => "Refactoring Specialist"
+          "templates" => ["07_refactoring_recommendations.md"],
+          "description" => "Provide actionable refactoring guidance",
+          "outs" => ["docs/analysis/refactoring_recommendations.md"],
+          "gate" => true
         }
       }.freeze
     end