aidp 0.1.0 → 0.5.0

data/lib/aidp/database_migration.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "fileutils"
+
+module Aidp
+  # Handles database migrations for AIDP
+  class DatabaseMigration
+    def initialize(project_dir = Dir.pwd)
+      @project_dir = project_dir
+      @old_db_path = File.join(project_dir, ".aidp-analysis.db")
+      @new_db_path = File.join(project_dir, ".aidp.db")
+    end
+
+    # Migrate database from old to new format
+    def migrate
+      # If neither database exists, create new one directly
+      if !File.exist?(@old_db_path) && !File.exist?(@new_db_path)
+        create_new_database
+        return true
+      end
+
+      # If new database already exists, skip migration
+      if File.exist?(@new_db_path)
+        puts "Database .aidp.db already exists, skipping migration"
+        return false
+      end
+
+      # Rename old database to new name
+      FileUtils.mv(@old_db_path, @new_db_path)
+
+      # Open database connection
+      db = SQLite3::Database.new(@new_db_path)
+
+      # Create new tables for job management
+      create_job_tables(db)
+
+      # Close connection
+      db.close
+
+      true
+    rescue => e
+      puts "Error during database migration: #{e.message}"
+      # Try to restore old database if something went wrong
+      if File.exist?(@new_db_path) && !File.exist?(@old_db_path)
+        FileUtils.mv(@new_db_path, @old_db_path)
+      end
+      false
+    end
+
+    private
+
+    def create_new_database
+      db = SQLite3::Database.new(@new_db_path)
+
+      # Create original tables
+      create_original_tables(db)
+
+      # Create new job tables
+      create_job_tables(db)
+
+      db.close
+    end
+
+    def create_original_tables(db)
+      # Create analysis_results table
+      db.execute(<<~SQL)
+        CREATE TABLE analysis_results (
+          step_name TEXT PRIMARY KEY,
+          data TEXT NOT NULL,
+          metadata TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      SQL
+
+      # Create analysis_metrics table
+      db.execute(<<~SQL)
+        CREATE TABLE analysis_metrics (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          step_name TEXT NOT NULL,
+          metric_name TEXT NOT NULL,
+          value TEXT NOT NULL,
+          recorded_at TEXT NOT NULL,
+          UNIQUE(step_name, metric_name, recorded_at)
+        )
+      SQL
+
+      # Create embeddings table
+      db.execute(<<~SQL)
+        CREATE TABLE embeddings (
+          step_name TEXT PRIMARY KEY,
+          embeddings_data TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        )
+      SQL
+
+      # Create indexes
+      db.execute("CREATE INDEX idx_analysis_metrics_step_name ON analysis_metrics(step_name)")
+      db.execute("CREATE INDEX idx_analysis_metrics_recorded_at ON analysis_metrics(recorded_at)")
+      db.execute("CREATE INDEX idx_analysis_results_updated_at ON analysis_results(updated_at)")
+    end
+
+    def create_job_tables(db)
+      # Create jobs table
+      db.execute(<<~SQL)
+        CREATE TABLE jobs (
+          id INTEGER PRIMARY KEY,
+          job_type TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          status TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          started_at INTEGER,
+          completed_at INTEGER,
+          error TEXT,
+          metadata TEXT
+        )
+      SQL
+
+      # Create job_executions table
+      db.execute(<<~SQL)
+        CREATE TABLE job_executions (
+          id INTEGER PRIMARY KEY,
+          job_id INTEGER NOT NULL,
+          attempt INTEGER NOT NULL,
+          status TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          completed_at INTEGER,
+          error TEXT,
+          FOREIGN KEY (job_id) REFERENCES jobs(id)
+        )
+      SQL
+
+      # Create job_logs table
+      db.execute(<<~SQL)
+        CREATE TABLE job_logs (
+          id INTEGER PRIMARY KEY,
+          job_id INTEGER NOT NULL,
+          execution_id INTEGER NOT NULL,
+          timestamp INTEGER NOT NULL,
+          message TEXT NOT NULL,
+          level TEXT NOT NULL,
+          metadata TEXT,
+          FOREIGN KEY (job_id) REFERENCES jobs(id),
+          FOREIGN KEY (execution_id) REFERENCES job_executions(id)
+        )
+      SQL
+
+      # Create indexes for job tables
+      db.execute("CREATE INDEX idx_jobs_status ON jobs(status)")
+      db.execute("CREATE INDEX idx_jobs_provider ON jobs(provider)")
+      db.execute("CREATE INDEX idx_job_executions_job_id ON job_executions(job_id)")
+      db.execute("CREATE INDEX idx_job_logs_job_id ON job_logs(job_id)")
+      db.execute("CREATE INDEX idx_job_logs_execution_id ON job_logs(execution_id)")
+      db.execute("CREATE INDEX idx_job_logs_timestamp ON job_logs(timestamp)")
+    end
+  end
+end

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