aidp 0.3.0 → 0.5.0

data/lib/aidp/execute/runner.rb

@@ -1,135 +1,108 @@
 # frozen_string_literal: true
 
-require "erb"
-require "yaml"
-require "json"
-
 module Aidp
   module Execute
-    # Handles execution logic for execute mode steps
     class Runner
-      attr_reader :project_dir, :progress
-
       def initialize(project_dir)
         @project_dir = project_dir
-        @progress = Aidp::Execute::Progress.new(project_dir)
       end
 
-      def run_step(step_name, options = {})
-        raise "Step '#{step_name}' not found in execute mode steps" unless Aidp::Execute::Steps::SPEC.key?(step_name)
+      def progress
+        @progress ||= Aidp::Execute::Progress.new(@project_dir)
+      end
 
+      def run_step(step_name, options = {})
+        # Always validate step exists first, even in mock mode
         step_spec = Aidp::Execute::Steps::SPEC[step_name]
-        template_name = step_spec["templates"].first
-
-        # Load template
-        template = find_template(template_name)
-        raise "Template '#{template_name}' not found" unless template
+        raise "Step '#{step_name}' not found" unless step_spec
 
-        # Compose prompt
-        prompt = composed_prompt(template_name, options)
-
-        # Handle error simulation for tests
-        if options[:simulate_error]
-          return {
-            status: "error",
-            error: options[:simulate_error],
-            step: step_name
-          }
+        if should_use_mock_mode?(options)
+          return options[:simulate_error] ?
+            {status: "error", error: options[:simulate_error]} :
+            mock_execution_result
         end
 
-        # Execute step (mock for now)
-        result = {
-          status: "success",
-          step: step_name,
-          output_files: step_spec["outs"],
-          prompt: prompt
-        }
+        job = Aidp::Jobs::ProviderExecutionJob.enqueue(
+          provider_type: "cursor",
+          prompt: composed_prompt(step_name, options),
+          metadata: {
+            step_name: step_name,
+            project_dir: @project_dir
+          }
+        )
 
-        # Mark step as completed
-        @progress.mark_step_completed(step_name)
+        wait_for_job_completion(job)
+      end
 
-        # Generate output files
-        generate_output_files(step_name, step_spec["outs"], result)
+      private
 
-        # Generate database export
-        generate_database_export
+      def should_use_mock_mode?(options)
+        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",
+          output: "Mock execution result"
+        }
       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"} if job && job["finished_at"] && job["error_count"] == 0
+          return {status: "failed", error: job["last_error_message"]} if job && job["error_count"] && job["error_count"] > 0
+
+          if job && job["finished_at"].nil?
+            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
 
       def template_search_paths
         [
-          File.join(@project_dir, "templates"),
-          File.join(@project_dir, "templates", "COMMON"),
-          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "EXECUTE"),
-          File.join(File.dirname(__FILE__), "..", "..", "..", "templates", "COMMON")
+          File.join(@project_dir, "templates", "EXECUTE"),
+          File.join(@project_dir, "templates", "COMMON")
         ]
       end
 
-      def composed_prompt(template_name, options = {})
-        template = find_template(template_name)
-        return template unless template
+      def composed_prompt(step_name, options = {})
+        step_spec = Aidp::Execute::Steps::SPEC[step_name]
+        raise "Step '#{step_name}' not found" unless step_spec
+
+        template_name = step_spec["templates"].first
+        template_path = find_template(template_name)
+        raise "Template not found for step #{step_name}" unless template_path
 
-        # Load agent base template if available
-        agent_base = find_template("AGENT_BASE.md")
-        template = "#{agent_base}\n\n#{template}" if agent_base
+        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
 
         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
-      end
-
-      def generate_output_content(step_name, output_file, result)
-        case output_file
-        when /\.md$/
-          "# #{step_name} Output\n\nGenerated on #{Time.now}\n\n## Result\n\n#{result[:status]}"
-        when /\.json$/
-          result.to_json
-        else
-          "Output for #{step_name}: #{result[:status]}"
-        end
-      end
-
-      def generate_database_export
-        database_file = File.join(@project_dir, ".aidp.db")
-        require "sqlite3"
-
-        begin
-          db = SQLite3::Database.new(database_file)
-          db.execute("CREATE TABLE IF NOT EXISTS execute_results (step TEXT, status TEXT, completed_at TEXT)")
-
-          Aidp::Execute::Steps::SPEC.keys.each do |step|
-            if @progress.step_completed?(step)
-              db.execute("INSERT INTO execute_results (step, status, completed_at) VALUES (?, ?, ?)",
-                [step, "success", Time.now.iso8601])
-            end
-          end
-        rescue => e
-          # Log the error but don't fail the execution
-          puts "Warning: Database export failed: #{e.message}"
-        end
-      end
     end
   end
 end

data/lib/aidp/execute/steps.rb

@@ -2,110 +2,109 @@
 
 module Aidp
   module Execute
-    # Defines the steps, templates, outputs, and associated AI agents for execute mode
-    class Steps
+    module Steps
       SPEC = {
         "00_PRD" => {
-          "templates" => ["00_PRD.md"],
-          "outs" => ["00_PRD.md"],
-          "gate" => false,
-          "agent" => "Product Manager"
+          "templates" => ["prd.md"],
+          "description" => "Generate Product Requirements Document",
+          "outs" => ["docs/prd.md"],
+          "gate" => true
         },
         "01_NFRS" => {
-          "templates" => ["01_NFRS.md"],
-          "outs" => ["01_NFRS.md"],
-          "gate" => false,
-          "agent" => "Architect"
+          "templates" => ["nfrs.md"],
+          "description" => "Define Non-Functional Requirements",
+          "outs" => ["docs/nfrs.md"],
+          "gate" => true
         },
         "02_ARCHITECTURE" => {
-          "templates" => ["02_ARCHITECTURE.md"],
-          "outs" => ["02_ARCHITECTURE.md"],
-          "gate" => false,
-          "agent" => "Architect"
+          "templates" => ["architecture.md"],
+          "description" => "Design System Architecture",
+          "outs" => ["docs/architecture.md"],
+          "gate" => true
         },
         "02A_ARCH_GATE_QUESTIONS" => {
-          "templates" => ["02A_ARCH_GATE_QUESTIONS.md"],
-          "outs" => ["02A_ARCH_GATE_QUESTIONS.md"],
-          "gate" => true,
-          "agent" => "Architect"
+          "templates" => ["arch_gate_questions.md"],
+          "description" => "Architecture Gate Questions",
+          "outs" => ["docs/arch_gate_questions.md"],
+          "gate" => true
         },
         "03_ADR_FACTORY" => {
-          "templates" => ["03_ADR_FACTORY.md"],
-          "outs" => ["03_ADR_FACTORY.md"],
-          "gate" => false,
-          "agent" => "Architect"
+          "templates" => ["adr_factory.md"],
+          "description" => "Generate Architecture Decision Records",
+          "outs" => ["docs/adr/*.md"],
+          "gate" => false
         },
         "04_DOMAIN_DECOMPOSITION" => {
-          "templates" => ["04_DOMAIN_DECOMPOSITION.md"],
-          "outs" => ["04_DOMAIN_DECOMPOSITION.md"],
-          "gate" => false,
-          "agent" => "Architect"
-        },
-        "05_CONTRACTS" => {
-          "templates" => ["05_CONTRACTS.md"],
-          "outs" => ["05_CONTRACTS.md"],
-          "gate" => false,
-          "agent" => "Architect"
-        },
-        "06_THREAT_MODEL" => {
-          "templates" => ["06_THREAT_MODEL.md"],
-          "outs" => ["06_THREAT_MODEL.md"],
-          "gate" => false,
-          "agent" => "Security Expert"
-        },
-        "07_TEST_PLAN" => {
-          "templates" => ["07_TEST_PLAN.md"],
-          "outs" => ["07_TEST_PLAN.md"],
-          "gate" => false,
-          "agent" => "Test Engineer"
-        },
-        "08_TASKS" => {
-          "templates" => ["08_TASKS.md"],
-          "outs" => ["08_TASKS.md"],
-          "gate" => false,
-          "agent" => "Project Manager"
-        },
-        "09_SCAFFOLDING_DEVEX" => {
-          "templates" => ["09_SCAFFOLDING_DEVEX.md"],
-          "outs" => ["09_SCAFFOLDING_DEVEX.md"],
-          "gate" => false,
-          "agent" => "DevOps Engineer"
-        },
-        "10_IMPLEMENTATION_AGENT" => {
-          "templates" => ["10_IMPLEMENTATION_AGENT.md"],
-          "outs" => ["10_IMPLEMENTATION_AGENT.md"],
-          "gate" => false,
-          "agent" => "Implementation Specialist"
+          "templates" => ["domain_decomposition.md"],
+          "description" => "Decompose Domain into Components",
+          "outs" => ["docs/domain_decomposition.md"],
+          "gate" => true
+        },
+        "05_API_DESIGN" => {
+          "templates" => ["api_design.md"],
+          "description" => "Design APIs and Interfaces",
+          "outs" => ["docs/api_design.md"],
+          "gate" => true
+        },
+        "06_DATA_MODEL" => {
+          "templates" => ["data_model.md"],
+          "description" => "Design Data Model",
+          "outs" => ["docs/data_model.md"],
+          "gate" => true
+        },
+        "07_SECURITY_REVIEW" => {
+          "templates" => ["security_review.md"],
+          "description" => "Security Review and Threat Model",
+          "outs" => ["docs/security_review.md"],
+          "gate" => true
+        },
+        "08_PERFORMANCE_REVIEW" => {
+          "templates" => ["performance_review.md"],
+          "description" => "Performance Review and Optimization",
+          "outs" => ["docs/performance_review.md"],
+          "gate" => true
+        },
+        "09_RELIABILITY_REVIEW" => {
+          "templates" => ["reliability_review.md"],
+          "description" => "Reliability Review and SLOs",
+          "outs" => ["docs/reliability_review.md"],
+          "gate" => true
+        },
+        "10_TESTING_STRATEGY" => {
+          "templates" => ["testing_strategy.md"],
+          "description" => "Define Testing Strategy",
+          "outs" => ["docs/testing_strategy.md"],
+          "gate" => true
         },
         "11_STATIC_ANALYSIS" => {
-          "templates" => ["11_STATIC_ANALYSIS.md"],
-          "outs" => ["11_STATIC_ANALYSIS.md"],
-          "gate" => false,
-          "agent" => "Code Quality Expert"
+          "templates" => ["static_analysis.md"],
+          "description" => "Static Code Analysis",
+          "outs" => ["docs/static_analysis.md"],
+          "gate" => false
         },
         "12_OBSERVABILITY_SLOS" => {
-          "templates" => ["12_OBSERVABILITY_SLOS.md"],
-          "outs" => ["12_OBSERVABILITY_SLOS.md"],
-          "gate" => false,
-          "agent" => "SRE Engineer"
+          "templates" => ["observability_slos.md"],
+          "description" => "Define Observability and SLOs",
+          "outs" => ["docs/observability_slos.md"],
+          "gate" => true
         },
         "13_DELIVERY_ROLLOUT" => {
-          "templates" => ["13_DELIVERY_ROLLOUT.md"],
-          "outs" => ["13_DELIVERY_ROLLOUT.md"],
-          "gate" => false,
-          "agent" => "DevOps Engineer"
+          "templates" => ["delivery_rollout.md"],
+          "description" => "Plan Delivery and Rollout",
+          "outs" => ["docs/delivery_rollout.md"],
+          "gate" => true
         },
         "14_DOCS_PORTAL" => {
-          "templates" => ["14_DOCS_PORTAL.md"],
-          "outs" => ["14_DOCS_PORTAL.md"],
-          "gate" => false,
-          "agent" => "Technical Writer"
+          "templates" => ["docs_portal.md"],
+          "description" => "Documentation Portal",
+          "outs" => ["docs/docs_portal.md"],
+          "gate" => false
         },
         "15_POST_RELEASE" => {
-          "templates" => ["15_POST_RELEASE.md"],
-          "outs" => ["15_POST_RELEASE.md"],
-          "gate" => false,
-          "agent" => "Project Manager"
+          "templates" => ["post_release.md"],
+          "description" => "Post-Release Review",
+          "outs" => ["docs/post_release.md"],
+          "gate" => true
         }
       }.freeze
     end

data/lib/aidp/job_manager.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aidp
+  class JobManager
+    def initialize(project_dir)
+      @project_dir = project_dir
+    end
+
+    def create_job(job_class, args = {})
+      # Create a new job and return job ID
+      # This is a placeholder implementation
+      job_id = rand(1000..9999)
+
+      # Store job metadata for testing
+      @jobs ||= {}
+      @jobs[job_id] = {
+        id: job_id,
+        job_class: job_class,
+        args: args,
+        status: "queued",
+        created_at: Time.now
+      }
+
+      job_id
+    end
+
+    def get_job(job_id)
+      @jobs ||= {}
+      @jobs[job_id]
+    end
+
+    def update_job_status(job_id, status, error: nil)
+      @jobs ||= {}
+      return unless @jobs[job_id]
+
+      @jobs[job_id][:status] = status
+      @jobs[job_id][:error] = error if error
+      @jobs[job_id][:updated_at] = Time.now
+    end
+  end
+end

data/lib/aidp/jobs/base_job.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "que"
+
+module Aidp
+  module Jobs
+    class BaseJob < Que::Job
+      # Default settings
+      self.retry_interval = 30.0 # 30 seconds between retries
+      self.maximum_retry_count = 3
+
+      # Error tracking
+      class_attribute :error_handlers
+      self.error_handlers = []
+
+      def self.on_error(&block)
+        error_handlers << block
+      end
+
+      protected
+
+      def log_info(message)
+        Que.logger.info "[#{self.class.name}] #{message}"
+      end
+
+      def log_error(message)
+        Que.logger.error "[#{self.class.name}] #{message}"
+      end
+
+      def handle_error(error)
+        self.class.error_handlers.each do |handler|
+          handler.call(error, self)
+        rescue => e
+          log_error "Error handler failed: #{e.message}"
+        end
+      end
+
+      # Override run to add error handling
+      def run(*args)
+        raise NotImplementedError, "#{self.class} must implement #run"
+      rescue => error
+        handle_error(error)
+        raise # Re-raise to trigger Que's retry mechanism
+      end
+    end
+  end
+end

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/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