aidp 0.7.0 → 0.8.1

data/lib/aidp/database/pg_adapter.rb

@@ -1,148 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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/job_manager.rb

@@ -1,41 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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)
-        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

@@ -1,83 +0,0 @@
-# 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
-
-        # 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
-        )
-      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/project_detector.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "yaml"
-
-module Aidp
-  # Detects project type, language, framework, and other characteristics
-  class ProjectDetector
-    attr_reader :project_dir
-
-    def initialize(project_dir = Dir.pwd)
-      @project_dir = project_dir
-    end
-
-    def detect
-      {
-        language: detect_language,
-        framework: detect_framework,
-        build_system: detect_build_system,
-        package_manager: detect_package_manager,
-        static_analysis_tools: detect_static_analysis_tools,
-        test_framework: detect_test_framework,
-        database: detect_database,
-        deployment: detect_deployment
-      }
-    end
-
-    private
-
-    def detect_language
-      return "ruby" if File.exist?(File.join(@project_dir, "Gemfile"))
-      return "javascript" if File.exist?(File.join(@project_dir, "package.json"))
-      return "python" if File.exist?(File.join(@project_dir, "requirements.txt")) || File.exist?(File.join(@project_dir, "pyproject.toml"))
-      return "java" if File.exist?(File.join(@project_dir, "pom.xml")) || File.exist?(File.join(@project_dir, "build.gradle"))
-      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
-      return "rust" if File.exist?(File.join(@project_dir, "Cargo.toml"))
-      return "csharp" if File.exist?(File.join(@project_dir, "*.csproj"))
-      "unknown"
-    end
-
-    def detect_framework
-      case detect_language
-      when "ruby"
-        return "rails" if File.exist?(File.join(@project_dir, "config", "application.rb"))
-        return "sinatra" if File.exist?(File.join(@project_dir, "app.rb")) && File.read(File.join(@project_dir, "app.rb")).include?("Sinatra")
-      when "javascript"
-        return "react" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("react")
-        return "vue" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("vue")
-        return "angular" if File.exist?(File.join(@project_dir, "angular.json"))
-        return "express" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("express")
-      when "python"
-        return "django" if File.exist?(File.join(@project_dir, "manage.py"))
-        return "flask" if File.exist?(File.join(@project_dir, "app.py")) && File.read(File.join(@project_dir, "app.py")).include?("Flask")
-      when "java"
-        return "spring" if File.exist?(File.join(@project_dir, "pom.xml")) && File.read(File.join(@project_dir, "pom.xml")).include?("spring-boot")
-      end
-      "unknown"
-    end
-
-    def detect_build_system
-      return "maven" if File.exist?(File.join(@project_dir, "pom.xml"))
-      return "gradle" if File.exist?(File.join(@project_dir, "build.gradle"))
-      return "npm" if File.exist?(File.join(@project_dir, "package.json"))
-      return "bundler" if File.exist?(File.join(@project_dir, "Gemfile"))
-      return "pip" if File.exist?(File.join(@project_dir, "requirements.txt"))
-      return "cargo" if File.exist?(File.join(@project_dir, "Cargo.toml"))
-      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
-      "unknown"
-    end
-
-    def detect_package_manager
-      detect_build_system
-    end
-
-    def detect_static_analysis_tools
-      tools = []
-      tools << "rubocop" if File.exist?(File.join(@project_dir, ".rubocop.yml"))
-      tools << "eslint" if File.exist?(File.join(@project_dir, ".eslintrc"))
-      tools << "flake8" if File.exist?(File.join(@project_dir, ".flake8"))
-      tools << "checkstyle" if File.exist?(File.join(@project_dir, "checkstyle.xml"))
-      tools << "clippy" if File.exist?(File.join(@project_dir, "Cargo.toml"))
-      tools
-    end
-
-    def detect_test_framework
-      case detect_language
-      when "ruby"
-        return "rspec" if File.exist?(File.join(@project_dir, "spec"))
-        return "minitest" if File.exist?(File.join(@project_dir, "test"))
-      when "javascript"
-        return "jest" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("jest")
-        return "mocha" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("mocha")
-      when "python"
-        return "pytest" if File.exist?(File.join(@project_dir, "pytest.ini"))
-        return "unittest" if Dir.exist?(File.join(@project_dir, "tests"))
-      when "java"
-        return "junit" if File.exist?(File.join(@project_dir, "src", "test"))
-      end
-      "unknown"
-    end
-
-    def detect_database
-      return "postgresql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("postgresql")
-      return "mysql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("mysql")
-      return "sqlite" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("sqlite")
-      "unknown"
-    end
-
-    def detect_deployment
-      return "docker" if File.exist?(File.join(@project_dir, "Dockerfile"))
-      return "kubernetes" if File.exist?(File.join(@project_dir, "k8s")) || File.exist?(File.join(@project_dir, "kubernetes"))
-      return "heroku" if File.exist?(File.join(@project_dir, "Procfile"))
-      return "aws" if File.exist?(File.join(@project_dir, "serverless.yml")) || File.exist?(File.join(@project_dir, "template.yaml"))
-      "unknown"
-    end
-  end
-end