aidp 0.5.0 → 0.8.0

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/database_migration.rb

@@ -1,158 +0,0 @@
-# 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/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,47 +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)
-        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

@@ -1,96 +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
-
-        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