aidp 0.3.0 → 0.5.0

data/lib/aidp/cli.rb

@@ -8,7 +8,26 @@ module Aidp
     desc "execute [STEP]", "Run execute mode step(s)"
     option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
     option :rerun, type: :boolean, desc: "Re-run a completed step"
+    option :approve, type: :string, desc: "Approve a completed execute gate step"
+    option :reset, type: :boolean, desc: "Reset execute mode progress"
     def execute(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+      # Handle reset flag
+      if options[:reset] || options["reset"]
+        progress = Aidp::Execute::Progress.new(project_dir)
+        progress.reset
+        puts "🔄 Reset execute mode progress"
+        return {status: "success", message: "Progress reset"}
+      end
+
+      # Handle approve flag
+      if options[:approve] || options["approve"]
+        step_name = options[:approve] || options["approve"]
+        progress = Aidp::Execute::Progress.new(project_dir)
+        progress.mark_step_completed(step_name)
+        puts "✅ Approved execute step: #{step_name}"
+        return {status: "success", step: step_name}
+      end
+
       if step_name
         runner = Aidp::Execute::Runner.new(project_dir)
         # Merge Thor options with custom options
@@ -34,7 +53,71 @@ module Aidp
     DESC
     option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
     option :rerun, type: :boolean, desc: "Re-run a completed step"
-    def analyze(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+    option :background, type: :boolean, desc: "Run analysis in background jobs (requires database setup)"
+    option :approve, type: :string, desc: "Approve a completed analyze gate step"
+    option :reset, type: :boolean, desc: "Reset analyze mode progress"
+    def analyze(*args)
+      # Handle reset flag
+      if options[:reset] || options["reset"]
+        project_dir = Dir.pwd
+        progress = Aidp::Analyze::Progress.new(project_dir)
+        progress.reset
+        puts "🔄 Reset analyze mode progress"
+        return {status: "success", message: "Progress reset"}
+      end
+
+      # Handle approve flag
+      if options[:approve] || options["approve"]
+        project_dir = Dir.pwd
+        step_name = options[:approve] || options["approve"]
+        progress = Aidp::Analyze::Progress.new(project_dir)
+        progress.mark_step_completed(step_name)
+        puts "✅ Approved analyze step: #{step_name}"
+        return {status: "success", step: step_name}
+      end
+
+      # Handle both old and new calling patterns for backwards compatibility
+      case args.length
+      when 0
+        # analyze() - list steps
+        project_dir = Dir.pwd
+        step_name = nil
+        custom_options = {}
+      when 1
+        # analyze(step_name) - new CLI pattern
+        if args[0].is_a?(String) && Dir.exist?(args[0])
+          # analyze(project_dir) - old test pattern
+          project_dir = args[0]
+          step_name = nil
+        else
+          # analyze(step_name) - new CLI pattern
+          project_dir = Dir.pwd
+          step_name = args[0]
+        end
+        custom_options = {}
+      when 2
+        # analyze(project_dir, step_name) - old test pattern
+        # or analyze(step_name, options) - new CLI pattern
+        if Dir.exist?(args[0])
+          # analyze(project_dir, step_name)
+          project_dir = args[0]
+          step_name = args[1]
+          custom_options = {}
+        else
+          # analyze(step_name, options)
+          project_dir = Dir.pwd
+          step_name = args[0]
+          custom_options = args[1] || {}
+        end
+      when 3
+        # analyze(project_dir, step_name, options) - old test pattern
+        project_dir = args[0]
+        step_name = args[1]
+        custom_options = args[2] || {}
+      else
+        raise ArgumentError, "Wrong number of arguments (given #{args.length}, expected 0..3)"
+      end
+
       progress = Aidp::Analyze::Progress.new(project_dir)
 
       if step_name
@@ -45,7 +128,19 @@ module Aidp
           runner = Aidp::Analyze::Runner.new(project_dir)
           # Merge Thor options with custom options
           all_options = options.merge(custom_options)
-          runner.run_step(resolved_step, all_options)
+          result = runner.run_step(resolved_step, all_options)
+
+          # Display the result
+          if result[:status] == "completed"
+            puts "✅ Step '#{resolved_step}' completed successfully"
+            puts "   Provider: #{result[:provider]}"
+            puts "   Message: #{result[:message]}" if result[:message]
+          elsif result[:status] == "error"
+            puts "❌ Step '#{resolved_step}' failed"
+            puts "   Error: #{result[:error]}" if result[:error]
+          end
+
+          result
         else
           puts "❌ Step '#{step_name}' not found or not available"
           puts "\nAvailable steps:"
@@ -72,49 +167,6 @@ module Aidp
       end
     end
 
-    desc "analyze-approve STEP", "Approve a completed analyze gate step"
-    def analyze_approve(project_dir = Dir.pwd, step_name = nil)
-      progress = Aidp::Analyze::Progress.new(project_dir)
-      progress.mark_step_completed(step_name)
-      puts "✅ Approved analyze step: #{step_name}"
-      {status: "success", step: step_name}
-    end
-
-    desc "analyze-reset", "Reset analyze mode progress"
-    def analyze_reset(project_dir = Dir.pwd)
-      progress = Aidp::Analyze::Progress.new(project_dir)
-      progress.reset
-      puts "🔄 Reset analyze mode progress"
-      {status: "success", message: "Progress reset"}
-    end
-
-    desc "execute-approve STEP", "Approve a completed execute gate step"
-    def execute_approve(project_dir = Dir.pwd, step_name = nil)
-      progress = Aidp::Execute::Progress.new(project_dir)
-      progress.mark_step_completed(step_name)
-      puts "✅ Approved execute step: #{step_name}"
-      {status: "success", step: step_name}
-    end
-
-    desc "execute-reset", "Reset execute mode progress"
-    def execute_reset(project_dir = Dir.pwd)
-      progress = Aidp::Execute::Progress.new(project_dir)
-      progress.reset
-      puts "🔄 Reset execute mode progress"
-      {status: "success", message: "Progress reset"}
-    end
-
-    # Backward compatibility aliases
-    desc "approve STEP", "Approve a completed execute gate step (alias for execute-approve)"
-    def approve(project_dir = Dir.pwd, step_name = nil)
-      execute_approve(project_dir, step_name)
-    end
-
-    desc "reset", "Reset execute mode progress (alias for execute-reset)"
-    def reset(project_dir = Dir.pwd)
-      execute_reset(project_dir)
-    end
-
     desc "status", "Show current progress for both modes"
     def status
       puts "\n📊 AI Dev Pipeline Status"
@@ -137,6 +189,13 @@ module Aidp
       end
     end
 
+    desc "jobs", "Show and manage background jobs"
+    def jobs
+      require_relative "cli/jobs_command"
+      command = Aidp::CLI::JobsCommand.new
+      command.run
+    end
+
     desc "version", "Show version information"
     def version
       puts "Aidp version #{Aidp::VERSION}"

data/lib/aidp/core_ext/class_attribute.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aidp
+  module CoreExt
+    module ClassAttribute
+      def class_attribute(*attrs)
+        attrs.each do |name|
+          # Define class instance variable
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            @#{name} = nil
+
+            def self.#{name}
+              return @#{name} if defined?(@#{name})
+              return superclass.#{name} if superclass.respond_to?(:#{name})
+              nil
+            end
+
+            def self.#{name}=(val)
+              @#{name} = val
+            end
+
+            def #{name}
+              self.class.#{name}
+            end
+
+            def #{name}=(val)
+              raise "#{name} is a class attribute, cannot be set on instance"
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+Class.include Aidp::CoreExt::ClassAttribute

data/lib/aidp/database/pg_adapter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Database
+    class PgAdapter
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def execute(sql, params = [])
+        result = @connection.exec_params(sql, params)
+        result.to_a.map { |row| row.transform_keys(&:to_sym) }
+      end
+
+      def in_transaction?
+        @connection.transaction_status != PG::PQTRANS_IDLE
+      end
+
+      def checkout
+        yield self
+      end
+
+      def after_commit
+        yield
+      end
+
+      def server_version
+        @connection.server_version
+      end
+
+      def transaction_status
+        @connection.transaction_status
+      end
+
+      def transaction
+        @connection.transaction do
+          yield
+        end
+      end
+
+      def quote_table_name(name)
+        "\"#{name}\""
+      end
+
+      def quote_identifier(name)
+        "\"#{name}\""
+      end
+
+      def quote_string(string)
+        "'#{string.gsub("'", "''")}'"
+      end
+
+      def quote_date(date)
+        date.strftime("%Y-%m-%d")
+      end
+
+      def quote_time(time)
+        time.strftime("%Y-%m-%d %H:%M:%S.%6N %z")
+      end
+
+      # Additional methods required by Que
+      def async_connection
+        self
+      end
+
+      def wait_for_notify(timeout = nil)
+        @connection.wait_for_notify(timeout)
+      end
+
+      def listen(channel)
+        @connection.exec("LISTEN #{quote_identifier(channel)}")
+      end
+
+      def unlisten(channel)
+        @connection.exec("UNLISTEN #{quote_identifier(channel)}")
+      end
+
+      def unlisten_all
+        @connection.exec("UNLISTEN *")
+      end
+
+      def notifications
+        @connection.notifications
+      end
+
+      def reset
+        @connection.reset
+      end
+
+      def type_map_for_queries
+        @connection.type_map_for_queries
+      end
+
+      def type_map_for_results
+        @connection.type_map_for_results
+      end
+
+      # Additional methods for Que compatibility
+      def adapter_name
+        "pg"
+      end
+
+      def active?
+        @connection.status == PG::CONNECTION_OK
+      end
+
+      def disconnect!
+        @connection.close
+      end
+
+      def reconnect!
+        @connection.reset
+      end
+
+      def raw_connection
+        @connection
+      end
+
+      def schema_search_path
+        execute("SHOW search_path")[0][:search_path]
+      end
+
+      def schema_search_path=(path)
+        execute("SET search_path TO #{path}")
+      end
+
+      def table_exists?(name)
+        execute(<<~SQL, [name]).any?
+          SELECT 1
+          FROM pg_tables
+          WHERE tablename = $1
+        SQL
+      end
+
+      def advisory_lock(id)
+        execute("SELECT pg_advisory_lock($1)", [id])
+      end
+
+      def advisory_unlock(id)
+        execute("SELECT pg_advisory_unlock($1)", [id])
+      end
+
+      def advisory_unlock_all
+        execute("SELECT pg_advisory_unlock_all()")
+      end
+    end
+  end
+end

data/lib/aidp/database_config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Aidp
+  class DatabaseConfig
+    DEFAULT_CONFIG = {
+      "database" => {
+        "adapter" => "postgresql",
+        "host" => "localhost",
+        "port" => 5432,
+        "database" => "aidp",
+        "username" => ENV["USER"],
+        "password" => nil,
+        "pool" => 5,
+        "timeout" => 5000
+      }
+    }.freeze
+
+    def self.load(project_dir = Dir.pwd)
+      new(project_dir).load
+    end
+
+    def initialize(project_dir)
+      @project_dir = project_dir
+      @config_file = File.join(project_dir, ".aidp-config.yml")
+    end
+
+    def load
+      ensure_config_exists
+      config = YAML.load_file(@config_file)
+      validate_config(config)
+      config["database"]
+    end
+
+    private
+
+    def ensure_config_exists
+      return if File.exist?(@config_file)
+
+      # Create config directory if it doesn't exist
+      FileUtils.mkdir_p(File.dirname(@config_file))
+
+      # Write default config
+      File.write(@config_file, YAML.dump(DEFAULT_CONFIG))
+
+      puts "Created default database configuration at #{@config_file}"
+      puts "Please update the configuration with your database settings"
+    end
+
+    def validate_config(config)
+      unless config.is_a?(Hash) && config["database"].is_a?(Hash)
+        raise "Invalid configuration format in #{@config_file}"
+      end
+
+      required_keys = %w[adapter host port database username]
+      missing_keys = required_keys - config["database"].keys
+
+      unless missing_keys.empty?
+        raise "Missing required configuration keys: #{missing_keys.join(", ")}"
+      end
+
+      unless config["database"]["adapter"] == "postgresql"
+        raise "Only PostgreSQL is supported as a database adapter"
+      end
+    end
+  end
+end

data/lib/aidp/database_connection.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "pg"
+require "que"
+require "sequel"
+
+module Aidp
+  class DatabaseConnection
+    class << self
+      def initialize_mutex
+        @mutex ||= Mutex.new
+      end
+
+      def establish_connection
+        initialize_mutex
+        @mutex.synchronize do
+          # Return existing connection if already established
+          return @connection if @connection && !@connection.finished?
+          @connection = PG.connect(connection_params)
+          @sequel_db = Sequel.connect(
+            adapter: "postgres",
+            host: ENV["AIDP_DB_HOST"] || "localhost",
+            port: (ENV["AIDP_DB_PORT"] || 5432).to_i,
+            database: ENV["AIDP_DB_NAME"] || "aidp",
+            user: ENV["AIDP_DB_USER"] || ENV["USER"],
+            password: ENV["AIDP_DB_PASSWORD"]
+          )
+          Que.connection = @sequel_db
+          Que.migrate!(version: Que::Migrations::CURRENT_VERSION)
+          @connection
+        end
+      end
+
+      def connection
+        return @connection if @connection && !@connection.finished?
+        establish_connection
+      end
+
+      def disconnect
+        initialize_mutex
+        @mutex.synchronize do
+          return unless @connection
+
+          # Safely disconnect in reverse order
+          begin
+            Que.connection = nil
+          rescue => e
+            # Log but don't fail on Que disconnection issues
+            puts "Warning: Error setting Que.connection to nil: #{e.message}" if ENV["AIDP_DEBUG"]
+          end
+
+          @sequel_db&.disconnect
+          @connection&.close
+          @connection = nil
+          @sequel_db = nil
+        end
+      end
+
+      private
+
+      def connection_params
+        {
+          host: ENV["AIDP_DB_HOST"] || "localhost",
+          port: (ENV["AIDP_DB_PORT"] || 5432).to_i,
+          dbname: ENV["AIDP_DB_NAME"] || "aidp",
+          user: ENV["AIDP_DB_USER"] || ENV["USER"],
+          password: ENV["AIDP_DB_PASSWORD"]
+        }
+      end
+    end
+  end
+end

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