aidp 0.34.1 → 0.39.3

data/lib/aidp/database/repositories/provider_info_cache_repository.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for provider info cache
+      # Replaces: .aidp/providers/{provider_name}_info.yml
+      #
+      # Stores detailed information about AI providers gathered from CLI introspection
+      class ProviderInfoCacheRepository < Repository
+        DEFAULT_TTL = 86400 # 24 hours in seconds
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "provider_info_cache")
+        end
+
+        # Store provider info in cache
+        #
+        # @param provider_name [String] Provider name (e.g., "claude", "cursor")
+        # @param info [Hash] Provider info hash
+        # @param ttl [Integer] Time to live in seconds
+        # @return [Boolean] Success status
+        def cache(provider_name, info, ttl: DEFAULT_TTL)
+          Aidp.log_debug("provider_info_cache_repo", "cache",
+            provider: provider_name, ttl: ttl)
+
+          expires_at = Time.now.utc + ttl
+
+          execute(<<~SQL, [project_dir, provider_name, serialize_json(info), current_timestamp, expires_at.strftime("%Y-%m-%d %H:%M:%S")])
+            INSERT INTO #{table_name} (project_dir, provider_name, info, cached_at, expires_at)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(project_dir, provider_name) DO UPDATE SET
+              info = excluded.info,
+              cached_at = excluded.cached_at,
+              expires_at = excluded.expires_at
+          SQL
+
+          true
+        rescue => e
+          Aidp.log_error("provider_info_cache_repo", "cache_failed",
+            provider: provider_name, error: e.message)
+          false
+        end
+
+        # Get cached provider info if not expired
+        #
+        # @param provider_name [String] Provider name
+        # @return [Hash, nil] Cached info or nil if expired/not found
+        def get(provider_name)
+          Aidp.log_debug("provider_info_cache_repo", "get", provider: provider_name)
+
+          row = query_one(<<~SQL, [project_dir, provider_name])
+            SELECT info, cached_at, expires_at
+            FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+          SQL
+
+          return nil unless row
+
+          # Check expiration
+          if row["expires_at"]
+            # Parse as UTC since timestamps are stored in UTC
+            expires_at = Time.parse(row["expires_at"] + " UTC")
+            if Time.now.utc > expires_at
+              Aidp.log_debug("provider_info_cache_repo", "cache_expired",
+                provider: provider_name, expires_at: expires_at)
+              return nil
+            end
+          end
+
+          deserialize_json(row["info"])
+        end
+
+        # Get cached info, ignoring expiration
+        #
+        # @param provider_name [String] Provider name
+        # @return [Hash, nil] Cached info or nil if not found
+        def get_stale(provider_name)
+          row = query_one(<<~SQL, [project_dir, provider_name])
+            SELECT info FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+          SQL
+
+          return nil unless row
+
+          deserialize_json(row["info"])
+        end
+
+        # Check if cache is stale for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @param max_age [Integer] Maximum age in seconds
+        # @return [Boolean] True if stale or not found
+        def stale?(provider_name, max_age: DEFAULT_TTL)
+          row = query_one(<<~SQL, [project_dir, provider_name])
+            SELECT cached_at FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+          SQL
+
+          return true unless row
+
+          # Parse as UTC since timestamps are stored in UTC
+          cached_at = Time.parse(row["cached_at"] + " UTC")
+          (Time.now.utc - cached_at) > max_age
+        end
+
+        # Invalidate cache for a specific provider
+        #
+        # @param provider_name [String] Provider name
+        def invalidate(provider_name)
+          Aidp.log_debug("provider_info_cache_repo", "invalidate",
+            provider: provider_name)
+
+          execute(<<~SQL, [project_dir, provider_name])
+            DELETE FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+          SQL
+        end
+
+        # Invalidate all cached providers for project
+        def invalidate_all
+          Aidp.log_debug("provider_info_cache_repo", "invalidate_all")
+          delete_by_project
+        end
+
+        # List all cached providers
+        #
+        # @param include_expired [Boolean] Include expired entries
+        # @return [Array<String>] Provider names
+        def cached_providers(include_expired: false)
+          sql = if include_expired
+            <<~SQL
+              SELECT provider_name FROM #{table_name}
+              WHERE project_dir = ?
+              ORDER BY provider_name
+            SQL
+          else
+            <<~SQL
+              SELECT provider_name FROM #{table_name}
+              WHERE project_dir = ?
+                AND (expires_at IS NULL OR datetime(expires_at) > datetime('now'))
+              ORDER BY provider_name
+            SQL
+          end
+
+          query(sql, [project_dir]).map { |row| row["provider_name"] }
+        end
+
+        # Get cache statistics
+        #
+        # @return [Hash] Statistics
+        def stats
+          total = query_value(<<~SQL, [project_dir])
+            SELECT COUNT(*) FROM #{table_name} WHERE project_dir = ?
+          SQL
+
+          valid = query_value(<<~SQL, [project_dir])
+            SELECT COUNT(*) FROM #{table_name}
+            WHERE project_dir = ?
+              AND (expires_at IS NULL OR datetime(expires_at) > datetime('now'))
+          SQL
+
+          expired = query_value(<<~SQL, [project_dir])
+            SELECT COUNT(*) FROM #{table_name}
+            WHERE project_dir = ?
+              AND expires_at IS NOT NULL
+              AND datetime(expires_at) <= datetime('now')
+          SQL
+
+          {
+            total_cached: total || 0,
+            valid_entries: valid || 0,
+            expired_entries: expired || 0,
+            providers: cached_providers(include_expired: true)
+          }
+        end
+
+        # Clean up expired entries
+        #
+        # @return [Integer] Number of entries deleted
+        def cleanup_expired
+          result = query_value(<<~SQL, [project_dir])
+            SELECT COUNT(*) FROM #{table_name}
+            WHERE project_dir = ?
+              AND expires_at IS NOT NULL
+              AND datetime(expires_at) <= datetime('now')
+          SQL
+
+          execute(<<~SQL, [project_dir])
+            DELETE FROM #{table_name}
+            WHERE project_dir = ?
+              AND expires_at IS NOT NULL
+              AND datetime(expires_at) <= datetime('now')
+          SQL
+
+          count = result || 0
+          if count > 0
+            Aidp.log_info("provider_info_cache_repo", "cleanup_expired",
+              deleted: count)
+          end
+          count
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/provider_metrics_repository.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for provider_metrics and provider_rate_limits tables
+      # Replaces provider_metrics.yml and provider_rate_limits.yml
+      class ProviderMetricsRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "provider_metrics")
+        end
+
+        # Save metrics for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @param metrics [Hash] Metrics data (success_count, error_count, avg_latency, etc.)
+        # @param model_name [String, nil] Optional model name
+        def save_metrics(provider_name, metrics, model_name: nil)
+          now = current_timestamp
+
+          # Convert Time values to ISO8601 strings
+          normalized = metrics.transform_values do |value|
+            value.is_a?(Time) ? value.iso8601 : value
+          end
+
+          execute(
+            insert_sql([:project_dir, :provider_name, :model_name, :metrics, :recorded_at]),
+            [project_dir, provider_name, model_name, serialize_json(normalized), now]
+          )
+
+          Aidp.log_debug("provider_metrics_repository", "saved_metrics",
+            provider: provider_name, metrics_count: metrics.size)
+        end
+
+        # Load metrics for all providers
+        #
+        # @return [Hash] Map of provider_name => metrics hash
+        def load_metrics
+          # Get the latest metrics for each provider
+          rows = query(
+            <<~SQL,
+              SELECT provider_name, model_name, metrics, recorded_at
+              FROM provider_metrics
+              WHERE project_dir = ?
+              AND id IN (
+                SELECT MAX(id) FROM provider_metrics
+                WHERE project_dir = ?
+                GROUP BY provider_name
+              )
+            SQL
+            [project_dir, project_dir]
+          )
+
+          result = {}
+          rows.each do |row|
+            provider = row["provider_name"]
+            metrics = deserialize_json(row["metrics"]) || {}
+            result[provider] = symbolize_keys(metrics)
+            result[provider][:recorded_at] = row["recorded_at"]
+          end
+
+          result
+        end
+
+        # Load metrics for a specific provider
+        #
+        # @param provider_name [String] Provider name
+        # @return [Hash] Metrics
+        def load_provider_metrics(provider_name)
+          row = query_one(
+            <<~SQL,
+              SELECT metrics, recorded_at
+              FROM provider_metrics
+              WHERE project_dir = ? AND provider_name = ?
+              ORDER BY recorded_at DESC
+              LIMIT 1
+            SQL
+            [project_dir, provider_name]
+          )
+
+          return {} unless row
+
+          metrics = deserialize_json(row["metrics"]) || {}
+          symbolize_keys(metrics)
+        end
+
+        # Save rate limit info for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @param rate_limits [Hash] Rate limit data
+        # @param model_name [String, nil] Optional model name
+        def save_rate_limits(provider_name, rate_limits, model_name: nil)
+          now = current_timestamp
+
+          # Convert Time values to ISO8601 strings
+          normalized = rate_limits.transform_values do |info|
+            next info unless info.is_a?(Hash)
+
+            info.transform_values do |value|
+              value.is_a?(Time) ? value.iso8601 : value
+            end
+          end
+
+          upsert_rate_limit(
+            provider_name: provider_name,
+            model_name: model_name,
+            rate_limit_info: serialize_json(normalized),
+            updated_at: now
+          )
+
+          Aidp.log_debug("provider_metrics_repository", "saved_rate_limits",
+            provider: provider_name)
+        end
+
+        # Load rate limits for all providers
+        #
+        # @return [Hash] Map of provider_name => rate limits hash
+        def load_rate_limits
+          rows = query(
+            "SELECT provider_name, model_name, rate_limit_info, updated_at FROM provider_rate_limits WHERE project_dir = ?",
+            [project_dir]
+          )
+
+          result = {}
+          rows.each do |row|
+            provider = row["provider_name"]
+            limits = deserialize_json(row["rate_limit_info"]) || {}
+            result[provider] = symbolize_keys_deep(limits)
+          end
+
+          result
+        end
+
+        # Load rate limits for a specific provider
+        #
+        # @param provider_name [String] Provider name
+        # @return [Hash] Rate limits
+        def load_provider_rate_limits(provider_name)
+          row = query_one(
+            "SELECT rate_limit_info, updated_at FROM provider_rate_limits WHERE project_dir = ? AND provider_name = ?",
+            [project_dir, provider_name]
+          )
+
+          return {} unless row
+
+          limits = deserialize_json(row["rate_limit_info"]) || {}
+          symbolize_keys_deep(limits)
+        end
+
+        # Clear all metrics and rate limits
+        def clear
+          transaction do
+            execute("DELETE FROM provider_metrics WHERE project_dir = ?", [project_dir])
+            execute("DELETE FROM provider_rate_limits WHERE project_dir = ?", [project_dir])
+          end
+          Aidp.log_debug("provider_metrics_repository", "cleared")
+        end
+
+        # Get metrics history for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @param metric_type [String, nil] Metric type to extract (optional)
+        # @param limit [Integer] Max records
+        # @return [Array<Hash>] Historical values
+        def metrics_history(provider_name, metric_type = nil, limit: 100)
+          rows = query(
+            <<~SQL,
+              SELECT metrics, recorded_at
+              FROM provider_metrics
+              WHERE project_dir = ? AND provider_name = ?
+              ORDER BY recorded_at DESC
+              LIMIT ?
+            SQL
+            [project_dir, provider_name, limit]
+          )
+
+          rows.map do |row|
+            metrics = deserialize_json(row["metrics"]) || {}
+            if metric_type
+              {value: metrics[metric_type.to_s] || metrics[metric_type.to_sym], recorded_at: row["recorded_at"]}
+            else
+              {metrics: symbolize_keys(metrics), recorded_at: row["recorded_at"]}
+            end
+          end
+        end
+
+        private
+
+        def upsert_rate_limit(provider_name:, model_name:, rate_limit_info:, updated_at:)
+          existing = query_one(
+            "SELECT id FROM provider_rate_limits WHERE project_dir = ? AND provider_name = ? AND (model_name = ? OR (model_name IS NULL AND ? IS NULL))",
+            [project_dir, provider_name, model_name, model_name]
+          )
+
+          if existing
+            execute(
+              <<~SQL,
+                UPDATE provider_rate_limits SET
+                  rate_limit_info = ?, updated_at = ?
+                WHERE id = ?
+              SQL
+              [rate_limit_info, updated_at, existing["id"]]
+            )
+          else
+            execute(
+              <<~SQL,
+                INSERT INTO provider_rate_limits
+                  (project_dir, provider_name, model_name, rate_limit_info, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+              SQL
+              [project_dir, provider_name, model_name, rate_limit_info, updated_at]
+            )
+          end
+        end
+
+        def symbolize_keys(hash)
+          return {} unless hash
+
+          hash.each_with_object({}) do |(key, value), memo|
+            memo[key.to_sym] = value
+          end
+        end
+
+        def symbolize_keys_deep(hash)
+          return {} unless hash
+
+          hash.each_with_object({}) do |(key, value), memo|
+            memo[key.to_sym] = value.is_a?(Hash) ? symbolize_keys_deep(value) : value
+          end
+        end
+
+        def parse_time(value)
+          return nil if value.nil?
+          return value if value.is_a?(Time)
+
+          Time.parse(value)
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/secrets_repository.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+require "securerandom"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for secrets_registry table
+      # Replaces security/secrets_registry.json
+      # Note: Only stores metadata about secrets, never actual values
+      class SecretsRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "secrets_registry")
+        end
+
+        # Register a secret
+        #
+        # @param name [String] Secret name
+        # @param env_var [String] Environment variable containing the secret
+        # @param description [String, nil] Description
+        # @param scopes [Array<String>] Allowed operation scopes
+        # @return [Hash] Registration details
+        def register(name:, env_var:, description: nil, scopes: [])
+          now = current_timestamp
+          secret_id = SecureRandom.hex(8)
+
+          # Warn if env var doesn't exist
+          unless ENV.key?(env_var)
+            Aidp.log_warn("secrets_repository", "env_var_not_found",
+              name: name, env_var: env_var)
+          end
+
+          execute(
+            insert_sql([
+              :project_dir, :secret_id, :secret_name, :env_var,
+              :description, :scopes, :registered_at
+            ]),
+            [
+              project_dir,
+              secret_id,
+              name,
+              env_var,
+              description,
+              serialize_json(scopes),
+              now
+            ]
+          )
+
+          Aidp.log_debug("secrets_repository", "registered",
+            name: name, env_var: env_var)
+
+          {
+            id: secret_id,
+            name: name,
+            env_var: env_var,
+            description: description,
+            scopes: scopes,
+            registered_at: now
+          }
+        end
+
+        # Unregister a secret
+        #
+        # @param name [String] Secret name
+        # @return [Boolean] true if removed
+        def unregister(name:)
+          existing = find(name)
+          return false unless existing
+
+          execute(
+            "DELETE FROM secrets_registry WHERE project_dir = ? AND secret_name = ?",
+            [project_dir, name]
+          )
+
+          Aidp.log_debug("secrets_repository", "unregistered", name: name)
+          true
+        end
+
+        # Check if secret is registered
+        #
+        # @param name [String] Secret name
+        # @return [Boolean]
+        def registered?(name)
+          count = query_value(
+            "SELECT COUNT(*) FROM secrets_registry WHERE project_dir = ? AND secret_name = ?",
+            [project_dir, name]
+          )
+          count.positive?
+        end
+
+        # Get registration details
+        #
+        # @param name [String] Secret name
+        # @return [Hash, nil] Registration or nil
+        def find(name)
+          row = query_one(
+            "SELECT * FROM secrets_registry WHERE project_dir = ? AND secret_name = ?",
+            [project_dir, name]
+          )
+          deserialize_secret(row)
+        end
+
+        # Alias for find
+        alias_method :get, :find
+
+        # Get env var for a secret
+        #
+        # @param name [String] Secret name
+        # @return [String, nil] Env var name or nil
+        def env_var_for(name)
+          row = query_one(
+            "SELECT env_var FROM secrets_registry WHERE project_dir = ? AND secret_name = ?",
+            [project_dir, name]
+          )
+          row&.dig("env_var")
+        end
+
+        # List all registered secrets
+        #
+        # @return [Array<Hash>]
+        def list
+          rows = query(
+            "SELECT * FROM secrets_registry WHERE project_dir = ? ORDER BY registered_at",
+            [project_dir]
+          )
+
+          rows.map do |row|
+            secret = deserialize_secret(row)
+            secret[:has_value] = ENV.key?(secret[:env_var]) if secret
+            secret
+          end.compact
+        end
+
+        # Get env vars that should be stripped
+        #
+        # @return [Array<String>]
+        def env_vars_to_strip
+          rows = query(
+            "SELECT DISTINCT env_var FROM secrets_registry WHERE project_dir = ?",
+            [project_dir]
+          )
+          rows.map { |r| r["env_var"] }.compact
+        end
+
+        # Check if an env var is registered
+        #
+        # @param env_var [String] Environment variable name
+        # @return [Boolean]
+        def env_var_registered?(env_var)
+          count = query_value(
+            "SELECT COUNT(*) FROM secrets_registry WHERE project_dir = ? AND env_var = ?",
+            [project_dir, env_var]
+          )
+          count.positive?
+        end
+
+        # Get secret name for an env var
+        #
+        # @param env_var [String] Environment variable name
+        # @return [String, nil] Secret name or nil
+        def name_for_env_var(env_var)
+          row = query_one(
+            "SELECT secret_name FROM secrets_registry WHERE project_dir = ? AND env_var = ?",
+            [project_dir, env_var]
+          )
+          row&.dig("secret_name")
+        end
+
+        private
+
+        def deserialize_secret(row)
+          return nil unless row
+
+          {
+            id: row["secret_id"],
+            name: row["secret_name"],
+            env_var: row["env_var"],
+            description: row["description"],
+            scopes: deserialize_json(row["scopes"]) || [],
+            registered_at: row["registered_at"]
+          }
+        end
+      end
+    end
+  end
+end