aidp 0.34.1 → 0.39.3

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for checkpoint and checkpoint_history tables
+      # Replaces checkpoint.yml and checkpoint_history.jsonl
+      class CheckpointRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "checkpoints")
+        end
+
+        # Save or update current checkpoint
+        #
+        # @param step_name [String]
+        # @param iteration [Integer]
+        # @param status [String]
+        # @param run_loop_started_at [String, nil]
+        # @param metrics [Hash]
+        # @return [Integer] Checkpoint ID
+        def save_checkpoint(step_name:, iteration: nil, status: nil, run_loop_started_at: nil, metrics: {})
+          data = {
+            step_name: step_name,
+            iteration: iteration,
+            status: status,
+            run_loop_started_at: run_loop_started_at,
+            metrics: metrics
+          }
+          existing = current_checkpoint
+          now = current_timestamp
+
+          if existing
+            existing_id = existing[:id]
+            execute(
+              <<~SQL,
+                UPDATE checkpoints SET
+                  step_name = ?,
+                  step_index = ?,
+                  status = ?,
+                  run_loop_started_at = ?,
+                  metadata = ?,
+                  updated_at = ?
+                WHERE id = ?
+              SQL
+              [
+                data[:step_name],
+                data[:iteration],
+                data[:status],
+                data[:run_loop_started_at],
+                serialize_json(data[:metrics]),
+                now,
+                existing_id
+              ]
+            )
+            Aidp.log_debug("checkpoint_repository", "updated", id: existing_id)
+            existing_id
+          else
+            execute(
+              insert_sql([
+                :project_dir, :step_name, :step_index, :status,
+                :run_loop_started_at, :metadata, :created_at, :updated_at
+              ]),
+              [
+                project_dir,
+                data[:step_name],
+                data[:iteration],
+                data[:status],
+                data[:run_loop_started_at],
+                serialize_json(data[:metrics]),
+                now,
+                now
+              ]
+            )
+            id = last_insert_row_id
+            Aidp.log_debug("checkpoint_repository", "created", id: id)
+            id
+          end
+        end
+
+        # Get current checkpoint for project
+        #
+        # @return [Hash, nil] Current checkpoint or nil
+        def current_checkpoint
+          row = query_one(
+            "SELECT * FROM checkpoints WHERE project_dir = ? ORDER BY updated_at DESC LIMIT 1",
+            [project_dir]
+          )
+          return nil unless row
+
+          deserialize_checkpoint(row)
+        end
+
+        # Append checkpoint to history
+        #
+        # @param step_name [String]
+        # @param iteration [Integer]
+        # @param status [String]
+        # @param timestamp [String, nil]
+        # @param metrics [Hash]
+        def append_history(step_name:, iteration: nil, status: nil, timestamp: nil, metrics: {})
+          execute(
+            <<~SQL,
+              INSERT INTO checkpoint_history (project_dir, step_name, step_index, status, timestamp, metadata)
+              VALUES (?, ?, ?, ?, ?, ?)
+            SQL
+            [
+              project_dir,
+              step_name,
+              iteration,
+              status,
+              timestamp || current_timestamp,
+              serialize_json(metrics)
+            ]
+          )
+          Aidp.log_debug("checkpoint_repository", "history_appended", step: step_name)
+        end
+
+        # Get checkpoint history
+        #
+        # @param limit [Integer] Maximum entries to return
+        # @return [Array<Hash>] Checkpoint history entries
+        def history(limit: 100)
+          rows = query(
+            <<~SQL,
+              SELECT * FROM checkpoint_history
+              WHERE project_dir = ?
+              ORDER BY timestamp DESC, id DESC
+              LIMIT ?
+            SQL
+            [project_dir, limit]
+          )
+
+          rows.map { |row| deserialize_history_entry(row) }.reverse
+        end
+
+        # Clear all checkpoint data for project
+        def clear
+          transaction do
+            execute("DELETE FROM checkpoints WHERE project_dir = ?", [project_dir])
+            execute("DELETE FROM checkpoint_history WHERE project_dir = ?", [project_dir])
+          end
+          Aidp.log_debug("checkpoint_repository", "cleared", project_dir: project_dir)
+        end
+
+        private
+
+        def deserialize_checkpoint(row)
+          {
+            id: row["id"],
+            step_name: row["step_name"],
+            iteration: row["step_index"],
+            status: row["status"],
+            run_loop_started_at: row["run_loop_started_at"],
+            metrics: deserialize_json(row["metadata"]) || {},
+            created_at: row["created_at"],
+            updated_at: row["updated_at"]
+          }
+        end
+
+        def deserialize_history_entry(row)
+          {
+            step_name: row["step_name"],
+            iteration: row["step_index"],
+            status: row["status"],
+            timestamp: row["timestamp"],
+            metrics: deserialize_json(row["metadata"]) || {}
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for deprecated models cache
+      # Replaces: .aidp/deprecated_models.json
+      #
+      # Tracks models that have been deprecated by providers at runtime
+      class DeprecatedModelsRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "deprecated_models")
+        end
+
+        # Add a deprecated model to the cache
+        #
+        # @param provider_name [String] Provider name (e.g., "anthropic")
+        # @param model_name [String] Deprecated model ID
+        # @param replacement [String, nil] Replacement model ID
+        # @param reason [String, nil] Deprecation reason
+        # @return [Boolean] Success status
+        def add(provider_name:, model_name:, replacement: nil, reason: nil)
+          Aidp.log_debug("deprecated_models_repo", "add",
+            provider: provider_name, model: model_name, replacement: replacement)
+
+          execute(<<~SQL, [project_dir, provider_name, model_name, replacement, reason, current_timestamp])
+            INSERT INTO #{table_name}
+              (project_dir, provider_name, model_name, replacement, reason, detected_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(project_dir, provider_name, model_name) DO UPDATE SET
+              replacement = excluded.replacement,
+              reason = excluded.reason,
+              detected_at = excluded.detected_at
+          SQL
+
+          Aidp.log_info("deprecated_models_repo", "added_deprecated_model",
+            provider: provider_name, model: model_name, replacement: replacement)
+          true
+        rescue => e
+          Aidp.log_error("deprecated_models_repo", "add_failed",
+            provider: provider_name, model: model_name, error: e.message)
+          false
+        end
+
+        # Check if a model is deprecated
+        #
+        # @param provider_name [String] Provider name
+        # @param model_name [String] Model ID to check
+        # @return [Boolean]
+        def deprecated?(provider_name:, model_name:)
+          result = query_value(<<~SQL, [project_dir, provider_name, model_name])
+            SELECT 1 FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ? AND model_name = ?
+          SQL
+
+          !result.nil?
+        end
+
+        # Get replacement model for a deprecated model
+        #
+        # @param provider_name [String] Provider name
+        # @param model_name [String] Deprecated model ID
+        # @return [String, nil] Replacement model ID or nil
+        def replacement_for(provider_name:, model_name:)
+          query_value(<<~SQL, [project_dir, provider_name, model_name])
+            SELECT replacement FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ? AND model_name = ?
+          SQL
+        end
+
+        # Get all deprecated models for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @return [Array<String>] List of deprecated model IDs
+        def deprecated_models(provider_name:)
+          rows = query(<<~SQL, [project_dir, provider_name])
+            SELECT model_name FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+            ORDER BY model_name
+          SQL
+
+          rows.map { |row| row["model_name"] }
+        end
+
+        # Get full deprecation info for a model
+        #
+        # @param provider_name [String] Provider name
+        # @param model_name [String] Model ID
+        # @return [Hash, nil] Deprecation metadata or nil
+        def info(provider_name:, model_name:)
+          row = query_one(<<~SQL, [project_dir, provider_name, model_name])
+            SELECT replacement, reason, detected_at
+            FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ? AND model_name = ?
+          SQL
+
+          return nil unless row
+
+          {
+            replacement: row["replacement"],
+            reason: row["reason"],
+            detected_at: row["detected_at"]
+          }
+        end
+
+        # Remove a model from the deprecated cache
+        #
+        # @param provider_name [String] Provider name
+        # @param model_name [String] Model ID to remove
+        def remove(provider_name:, model_name:)
+          Aidp.log_debug("deprecated_models_repo", "remove",
+            provider: provider_name, model: model_name)
+
+          execute(<<~SQL, [project_dir, provider_name, model_name])
+            DELETE FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ? AND model_name = ?
+          SQL
+
+          Aidp.log_info("deprecated_models_repo", "removed_deprecated_model",
+            provider: provider_name, model: model_name)
+        end
+
+        # Clear all deprecations for project
+        def clear!
+          Aidp.log_debug("deprecated_models_repo", "clear")
+          delete_by_project
+          Aidp.log_info("deprecated_models_repo", "cleared_all")
+        end
+
+        # Get cache statistics
+        #
+        # @return [Hash] Statistics
+        def stats
+          providers_rows = query(<<~SQL, [project_dir])
+            SELECT DISTINCT provider_name FROM #{table_name}
+            WHERE project_dir = ?
+            ORDER BY provider_name
+          SQL
+
+          providers = providers_rows.map { |row| row["provider_name"] }
+
+          by_provider = {}
+          providers.each do |provider|
+            count = query_value(<<~SQL, [project_dir, provider])
+              SELECT COUNT(*) FROM #{table_name}
+              WHERE project_dir = ? AND provider_name = ?
+            SQL
+            by_provider[provider] = count || 0
+          end
+
+          total = by_provider.values.sum
+
+          {
+            providers: providers,
+            total_deprecated: total,
+            by_provider: by_provider
+          }
+        end
+
+        # List all deprecated models with full info
+        #
+        # @return [Array<Hash>] All deprecated models
+        def list_all
+          rows = query(<<~SQL, [project_dir])
+            SELECT provider_name, model_name, replacement, reason, detected_at
+            FROM #{table_name}
+            WHERE project_dir = ?
+            ORDER BY provider_name, model_name
+          SQL
+
+          rows.map do |row|
+            {
+              provider: row["provider_name"],
+              model: row["model_name"],
+              replacement: row["replacement"],
+              reason: row["reason"],
+              detected_at: row["detected_at"]
+            }
+          end
+        end
+
+        # Find deprecated models with replacements
+        #
+        # @return [Array<Hash>] Models with replacement info
+        def with_replacements
+          rows = query(<<~SQL, [project_dir])
+            SELECT provider_name, model_name, replacement
+            FROM #{table_name}
+            WHERE project_dir = ? AND replacement IS NOT NULL
+            ORDER BY provider_name, model_name
+          SQL
+
+          rows.map do |row|
+            {
+              provider: row["provider_name"],
+              model: row["model_name"],
+              replacement: row["replacement"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for evaluations table
+      # Replaces evaluations/*.json and index.json
+      class EvaluationRepository < Repository
+        VALID_RATINGS = %w[good neutral bad].freeze
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "evaluations")
+        end
+
+        # Store a new evaluation
+        #
+        # @param record [Hash] Evaluation data with keys:
+        #   - id [String] Evaluation ID
+        #   - rating [String] good/neutral/bad
+        #   - target_type [String] Type of item being evaluated
+        #   - target_id [String] ID of item being evaluated
+        #   - feedback [String, nil] User feedback text
+        #   - context [Hash, nil] Additional context
+        # @return [Hash] Result with :success and :id
+        def store(record)
+          execute(
+            insert_sql([
+              :id, :project_dir, :rating, :target_type, :target_id,
+              :comment, :context
+            ]),
+            [
+              record[:id],
+              project_dir,
+              record[:rating],
+              record[:target_type],
+              record[:target_id],
+              record[:feedback],
+              serialize_json(record[:context] || {})
+            ]
+          )
+
+          Aidp.log_debug("evaluation_repository", "stored",
+            id: record[:id], rating: record[:rating])
+
+          {success: true, id: record[:id]}
+        rescue => e
+          Aidp.log_debug("evaluation_repository", "store_failed",
+            id: record[:id], error: e.message)
+          {success: false, error: e.message, id: record[:id]}
+        end
+
+        # Load an evaluation by ID
+        #
+        # @param id [String] Evaluation ID
+        # @return [Hash, nil] Evaluation or nil
+        def load(id)
+          row = query_one(
+            "SELECT * FROM evaluations WHERE id = ? AND project_dir = ?",
+            [id, project_dir]
+          )
+          deserialize_evaluation(row)
+        end
+
+        # List evaluations with optional filtering
+        #
+        # @param limit [Integer] Maximum records
+        # @param rating [String, nil] Filter by rating
+        # @param target_type [String, nil] Filter by target type
+        # @return [Array<Hash>] Evaluations
+        def list(limit: 50, rating: nil, target_type: nil)
+          conditions = ["project_dir = ?"]
+          params = [project_dir]
+
+          if rating
+            conditions << "rating = ?"
+            params << rating
+          end
+
+          if target_type
+            conditions << "target_type = ?"
+            params << target_type
+          end
+
+          params << limit
+
+          rows = query(
+            <<~SQL,
+              SELECT * FROM evaluations
+              WHERE #{conditions.join(" AND ")}
+              ORDER BY created_at DESC
+              LIMIT ?
+            SQL
+            params
+          )
+
+          rows.map { |row| deserialize_evaluation(row) }
+        end
+
+        # Get statistics
+        #
+        # @return [Hash] Statistics
+        def stats
+          total = query_value(
+            "SELECT COUNT(*) FROM evaluations WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+
+          by_rating = {}
+          %w[good neutral bad].each do |r|
+            by_rating[r.to_sym] = query_value(
+              "SELECT COUNT(*) FROM evaluations WHERE project_dir = ? AND rating = ?",
+              [project_dir, r]
+            ) || 0
+          end
+
+          by_type_rows = query(
+            <<~SQL,
+              SELECT target_type, COUNT(*) as count
+              FROM evaluations
+              WHERE project_dir = ?
+              GROUP BY target_type
+            SQL
+            [project_dir]
+          )
+          by_target_type = by_type_rows.each_with_object({}) do |row, h|
+            h[row["target_type"]] = row["count"]
+          end
+
+          first_row = query_one(
+            "SELECT created_at FROM evaluations WHERE project_dir = ? ORDER BY created_at ASC LIMIT 1",
+            [project_dir]
+          )
+          last_row = query_one(
+            "SELECT created_at FROM evaluations WHERE project_dir = ? ORDER BY created_at DESC LIMIT 1",
+            [project_dir]
+          )
+
+          {
+            total: total,
+            by_rating: by_rating,
+            by_target_type: by_target_type,
+            first_evaluation: first_row&.dig("created_at"),
+            last_evaluation: last_row&.dig("created_at")
+          }
+        end
+
+        # Delete an evaluation
+        #
+        # @param id [String] Evaluation ID
+        # @return [Hash] Result
+        def delete(id)
+          execute(
+            "DELETE FROM evaluations WHERE id = ? AND project_dir = ?",
+            [id, project_dir]
+          )
+          Aidp.log_debug("evaluation_repository", "deleted", id: id)
+          {success: true, id: id}
+        end
+
+        # Clear all evaluations
+        #
+        # @return [Hash] Result with count
+        def clear
+          count = query_value(
+            "SELECT COUNT(*) FROM evaluations WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+
+          execute("DELETE FROM evaluations WHERE project_dir = ?", [project_dir])
+
+          Aidp.log_debug("evaluation_repository", "cleared", count: count)
+          {success: true, count: count}
+        end
+
+        # Check if any evaluations exist
+        #
+        # @return [Boolean]
+        def any?
+          count = query_value(
+            "SELECT COUNT(*) FROM evaluations WHERE project_dir = ?",
+            [project_dir]
+          ) || 0
+          count.positive?
+        end
+
+        private
+
+        def deserialize_evaluation(row)
+          return nil unless row
+
+          context = deserialize_json(row["context"]) || {}
+
+          {
+            id: row["id"],
+            rating: row["rating"],
+            target_type: row["target_type"],
+            target_id: row["target_id"],
+            feedback: row["comment"],
+            context: context,
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end