aidp 0.1.0 → 0.5.0

data/lib/aidp/cli.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Aidp
+  # CLI interface for both execute and analyze modes
+  class CLI < Thor
+    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
+        all_options = options.merge(custom_options)
+        runner.run_step(step_name, all_options)
+      else
+        puts "Available execute steps:"
+        Aidp::Execute::Steps::SPEC.keys.each { |step| puts "  - #{step}" }
+        progress = Aidp::Execute::Progress.new(project_dir)
+        next_step = progress.next_step
+        {status: "success", message: "Available steps listed", next_step: next_step}
+      end
+    end
+
+    desc "analyze [STEP]", "Run analyze mode step(s)"
+    long_desc <<~DESC
+      Run analyze mode steps. STEP can be:
+      - A full step name (e.g., 01_REPOSITORY_ANALYSIS)
+      - A step number (e.g., 01, 02, 03)
+      - 'next' to run the next unfinished step
+      - 'current' to run the current step
+      - Empty to list available steps
+    DESC
+    option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
+    option :rerun, type: :boolean, desc: "Re-run a completed step"
+    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
+        # Resolve the step name
+        resolved_step = resolve_analyze_step(step_name, progress)
+
+        if resolved_step
+          runner = Aidp::Analyze::Runner.new(project_dir)
+          # Merge Thor options with custom options
+          all_options = options.merge(custom_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:"
+          Aidp::Analyze::Steps::SPEC.keys.each_with_index do |step, index|
+            status = progress.step_completed?(step) ? "✅" : "⏳"
+            puts "  #{status} #{sprintf("%02d", index + 1)}: #{step}"
+          end
+          {status: "error", message: "Step not found"}
+        end
+      else
+        puts "Available analyze steps:"
+        Aidp::Analyze::Steps::SPEC.keys.each_with_index do |step, index|
+          status = progress.step_completed?(step) ? "✅" : "⏳"
+          puts "  #{status} #{sprintf("%02d", index + 1)}: #{step}"
+        end
+
+        next_step = progress.next_step
+        if next_step
+          puts "\n💡 Run 'aidp analyze next' or 'aidp analyze #{next_step.match(/^(\d+)/)[1]}' to run the next step"
+        end
+
+        {status: "success", message: "Available steps listed", next_step: next_step,
+         completed_steps: progress.completed_steps}
+      end
+    end
+
+    desc "status", "Show current progress for both modes"
+    def status
+      puts "\n📊 AI Dev Pipeline Status"
+      puts "=" * 50
+
+      # Execute mode status
+      execute_progress = Aidp::Execute::Progress.new(Dir.pwd)
+      puts "\n🔧 Execute Mode:"
+      Aidp::Execute::Steps::SPEC.keys.each do |step|
+        status = execute_progress.step_completed?(step) ? "✅" : "⏳"
+        puts "  #{status} #{step}"
+      end
+
+      # Analyze mode status
+      analyze_progress = Aidp::Analyze::Progress.new(Dir.pwd)
+      puts "\n🔍 Analyze Mode:"
+      Aidp::Analyze::Steps::SPEC.keys.each do |step|
+        status = analyze_progress.step_completed?(step) ? "✅" : "⏳"
+        puts "  #{status} #{step}"
+      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}"
+    end
+
+    private
+
+    def resolve_analyze_step(step_input, progress)
+      step_input = step_input.to_s.downcase.strip
+
+      case step_input
+      when "next"
+        progress.next_step
+      when "current"
+        progress.current_step || progress.next_step
+      else
+        # Check if it's a step number (e.g., "01", "02", "1", "2")
+        if step_input.match?(/^\d{1,2}$/)
+          step_number = sprintf("%02d", step_input.to_i)
+          # Find step that starts with this number
+          Aidp::Analyze::Steps::SPEC.keys.find { |step| step.start_with?(step_number) }
+        else
+          # Check if it's a full step name (case insensitive)
+          Aidp::Analyze::Steps::SPEC.keys.find { |step| step.downcase == step_input }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Aidp
+  # Configuration management for both execute and analyze modes
+  class Config
+    def self.load(project_dir = Dir.pwd)
+      config_file = File.join(project_dir, ".aidp.yml")
+      if File.exist?(config_file)
+        YAML.load_file(config_file) || {}
+      else
+        {}
+      end
+    end
+
+    def self.templates_root
+      File.join(Dir.pwd, "templates")
+    end
+
+    def self.analyze_templates_root
+      File.join(Dir.pwd, "templates", "ANALYZE")
+    end
+
+    def self.execute_templates_root
+      File.join(Dir.pwd, "templates", "EXECUTE")
+    end
+
+    def self.common_templates_root
+      File.join(Dir.pwd, "templates", "COMMON")
+    end
+  end
+end

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