aidp 0.34.1 → 0.39.3

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for harness_state table
+      # Replaces harness/*_state.json files
+      class HarnessStateRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "harness_state")
+        end
+
+        # Check if state exists for mode
+        #
+        # @param mode [String, Symbol] Mode (execute, analyze, etc.)
+        # @return [Boolean]
+        def has_state?(mode)
+          mode_str = mode.to_s
+          count = query_value(
+            "SELECT COUNT(*) FROM harness_state WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+          count.positive?
+        end
+
+        # Load state for mode
+        #
+        # @param mode [String, Symbol] Mode
+        # @return [Hash] State data (empty hash if no state)
+        def load_state(mode)
+          mode_str = mode.to_s
+          row = query_one(
+            "SELECT * FROM harness_state WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+
+          return {} unless row
+
+          state = deserialize_json(row["state"]) || {}
+          Aidp.log_debug("harness_state_repository", "loaded",
+            mode: mode_str, keys: state.keys.size)
+          state
+        end
+
+        # Save state for mode
+        #
+        # @param mode [String, Symbol] Mode
+        # @param state_data [Hash] State to save
+        def save_state(mode, state_data)
+          mode_str = mode.to_s
+          now = current_timestamp
+
+          # Add metadata
+          state_with_metadata = state_data.merge(
+            mode: mode_str,
+            project_dir: project_dir,
+            saved_at: now
+          )
+
+          existing = query_one(
+            "SELECT id, version FROM harness_state WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+
+          if existing
+            new_version = (existing["version"] || 1) + 1
+            execute(
+              <<~SQL,
+                UPDATE harness_state SET
+                  state = ?,
+                  version = ?,
+                  updated_at = ?
+                WHERE project_dir = ? AND mode = ?
+              SQL
+              [
+                serialize_json(state_with_metadata),
+                new_version,
+                now,
+                project_dir,
+                mode_str
+              ]
+            )
+            Aidp.log_debug("harness_state_repository", "updated",
+              mode: mode_str, version: new_version)
+          else
+            execute(
+              insert_sql([:project_dir, :mode, :state, :version, :created_at, :updated_at]),
+              [
+                project_dir,
+                mode_str,
+                serialize_json(state_with_metadata),
+                1,
+                now,
+                now
+              ]
+            )
+            Aidp.log_debug("harness_state_repository", "created", mode: mode_str)
+          end
+        end
+
+        # Clear state for mode
+        #
+        # @param mode [String, Symbol] Mode
+        def clear_state(mode)
+          mode_str = mode.to_s
+          execute(
+            "DELETE FROM harness_state WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          )
+          Aidp.log_debug("harness_state_repository", "cleared", mode: mode_str)
+        end
+
+        # Get all modes with state
+        #
+        # @return [Array<String>] Mode names
+        def modes_with_state
+          rows = query(
+            "SELECT DISTINCT mode FROM harness_state WHERE project_dir = ?",
+            [project_dir]
+          )
+          rows.map { |r| r["mode"] }
+        end
+
+        # Get state version for mode
+        #
+        # @param mode [String, Symbol] Mode
+        # @return [Integer] Version number (0 if no state)
+        def version(mode)
+          mode_str = mode.to_s
+          query_value(
+            "SELECT version FROM harness_state WHERE project_dir = ? AND mode = ?",
+            [project_dir, mode_str]
+          ) || 0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+require "securerandom"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for background_jobs table
+      # Replaces jobs/* directory (metadata, logs, PID tracking)
+      class JobRepository < Repository
+        VALID_STATUSES = %w[pending running completed failed stopped].freeze
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "background_jobs")
+        end
+
+        # Create a new job
+        #
+        # @param job_type [String] Type of job (e.g., "execute", "analyze")
+        # @param input [Hash] Job input/options
+        # @return [String] Job ID
+        def create(job_type:, input: {})
+          job_id = generate_job_id
+          now = current_timestamp
+
+          execute(
+            insert_sql([
+              :id, :project_dir, :job_type, :status, :options, :created_at
+            ]),
+            [
+              job_id,
+              project_dir,
+              job_type,
+              "pending",
+              serialize_json(input),
+              now
+            ]
+          )
+
+          Aidp.log_debug("job_repository", "created",
+            job_id: job_id, type: job_type)
+
+          job_id
+        end
+
+        # Start a job
+        #
+        # @param job_id [String] Job ID
+        # @param pid [Integer, nil] Process ID
+        def start(job_id, pid: nil)
+          now = current_timestamp
+
+          execute(
+            <<~SQL,
+              UPDATE background_jobs SET
+                status = 'running',
+                pid = ?,
+                started_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [pid, now, job_id, project_dir]
+          )
+
+          Aidp.log_debug("job_repository", "started", job_id: job_id, pid: pid)
+        end
+
+        # Complete a job
+        #
+        # @param job_id [String] Job ID
+        # @param output [Hash] Job output/result
+        def complete(job_id, output: {})
+          now = current_timestamp
+
+          execute(
+            <<~SQL,
+              UPDATE background_jobs SET
+                status = 'completed',
+                result = ?,
+                completed_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [serialize_json(output), now, job_id, project_dir]
+          )
+
+          Aidp.log_debug("job_repository", "completed", job_id: job_id)
+        end
+
+        # Fail a job
+        #
+        # @param job_id [String] Job ID
+        # @param error [String] Error message
+        def fail(job_id, error:)
+          now = current_timestamp
+
+          execute(
+            <<~SQL,
+              UPDATE background_jobs SET
+                status = 'failed',
+                error = ?,
+                completed_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [error, now, job_id, project_dir]
+          )
+
+          Aidp.log_debug("job_repository", "failed", job_id: job_id, error: error)
+        end
+
+        # Stop a job
+        #
+        # @param job_id [String] Job ID
+        def stop(job_id)
+          now = current_timestamp
+
+          execute(
+            <<~SQL,
+              UPDATE background_jobs SET
+                status = 'stopped',
+                completed_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [now, job_id, project_dir]
+          )
+
+          Aidp.log_debug("job_repository", "stopped", job_id: job_id)
+        end
+
+        # Find job by ID
+        #
+        # @param job_id [String] Job ID
+        # @return [Hash, nil] Job or nil
+        def find(job_id)
+          row = query_one(
+            "SELECT * FROM background_jobs WHERE id = ? AND project_dir = ?",
+            [job_id, project_dir]
+          )
+          deserialize_job(row)
+        end
+
+        # List all jobs
+        #
+        # @param status [String, nil] Filter by status
+        # @param limit [Integer] Maximum jobs
+        # @return [Array<Hash>] Jobs
+        def list(status: nil, limit: 50)
+          rows = if status
+            query(
+              <<~SQL,
+                SELECT * FROM background_jobs
+                WHERE project_dir = ? AND status = ?
+                ORDER BY created_at DESC
+                LIMIT ?
+              SQL
+              [project_dir, status, limit]
+            )
+          else
+            query(
+              <<~SQL,
+                SELECT * FROM background_jobs
+                WHERE project_dir = ?
+                ORDER BY created_at DESC
+                LIMIT ?
+              SQL
+              [project_dir, limit]
+            )
+          end
+
+          rows.map { |row| deserialize_job(row) }
+        end
+
+        # List running jobs
+        #
+        # @return [Array<Hash>]
+        def running
+          list(status: "running")
+        end
+
+        # Get job status
+        #
+        # @param job_id [String] Job ID
+        # @return [Hash, nil] Status info or nil
+        def status(job_id)
+          job = find(job_id)
+          return nil unless job
+
+          pid = job[:pid]
+
+          {
+            job_id: job_id,
+            mode: job[:job_type],
+            status: job[:status],
+            pid: pid,
+            running: pid && process_running?(pid),
+            started_at: job[:started_at],
+            completed_at: job[:completed_at],
+            error: job[:error]
+          }
+        end
+
+        # Delete a job
+        #
+        # @param job_id [String] Job ID
+        def delete(job_id)
+          execute(
+            "DELETE FROM background_jobs WHERE id = ? AND project_dir = ?",
+            [job_id, project_dir]
+          )
+          Aidp.log_debug("job_repository", "deleted", job_id: job_id)
+        end
+
+        # Cleanup old completed jobs
+        #
+        # @param days_to_keep [Integer] Days to retain
+        # @return [Integer] Deleted count
+        def cleanup(days_to_keep: 7)
+          threshold = (Time.now - (days_to_keep * 24 * 60 * 60)).strftime("%Y-%m-%d %H:%M:%S")
+
+          count = query_value(
+            <<~SQL,
+              SELECT COUNT(*) FROM background_jobs
+              WHERE project_dir = ? AND status IN ('completed', 'failed', 'stopped')
+              AND completed_at < ?
+            SQL
+            [project_dir, threshold]
+          ) || 0
+
+          execute(
+            <<~SQL,
+              DELETE FROM background_jobs
+              WHERE project_dir = ? AND status IN ('completed', 'failed', 'stopped')
+              AND completed_at < ?
+            SQL
+            [project_dir, threshold]
+          )
+
+          Aidp.log_debug("job_repository", "cleanup",
+            deleted: count, threshold: threshold)
+
+          count
+        end
+
+        private
+
+        def generate_job_id
+          timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+          "job_#{timestamp}_#{SecureRandom.hex(4)}"
+        end
+
+        def process_running?(pid)
+          return false unless pid
+
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH, Errno::EPERM
+          false
+        end
+
+        def deserialize_job(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            job_type: row["job_type"],
+            status: row["status"],
+            options: deserialize_json(row["options"]) || {},
+            result: deserialize_json(row["result"]) || {},
+            pid: row["pid"],
+            error: row["error"],
+            started_at: row["started_at"],
+            completed_at: row["completed_at"],
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      # Repository for model cache
+      # Replaces: ~/.aidp/cache/models.json
+      #
+      # Caches discovered models from AI providers with TTL support
+      class ModelCacheRepository < Repository
+        DEFAULT_TTL = 86400 # 24 hours in seconds
+
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "model_cache")
+        end
+
+        # Cache models for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @param models [Array<Hash>] Models array
+        # @param ttl [Integer] Time to live in seconds
+        # @return [Boolean] Success status
+        def cache_models(provider_name, models, ttl: DEFAULT_TTL)
+          Aidp.log_debug("model_cache_repo", "cache_models",
+            provider: provider_name, count: models.size, ttl: ttl)
+
+          expires_at = Time.now.utc + ttl
+
+          execute(<<~SQL, [project_dir, provider_name, serialize_json(models), current_timestamp, expires_at.strftime("%Y-%m-%d %H:%M:%S")])
+            INSERT INTO #{table_name} (project_dir, provider_name, models, cached_at, expires_at)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(project_dir, provider_name) DO UPDATE SET
+              models = excluded.models,
+              cached_at = excluded.cached_at,
+              expires_at = excluded.expires_at
+          SQL
+
+          Aidp.log_info("model_cache_repo", "cached_models",
+            provider: provider_name, count: models.size)
+          true
+        rescue => e
+          Aidp.log_error("model_cache_repo", "cache_models_failed",
+            provider: provider_name, error: e.message)
+          false
+        end
+
+        # Get cached models for a provider if not expired
+        #
+        # @param provider_name [String] Provider name
+        # @return [Array<Hash>, nil] Cached models or nil if expired/not found
+        def get_cached_models(provider_name)
+          Aidp.log_debug("model_cache_repo", "get_cached_models",
+            provider: provider_name)
+
+          row = query_one(<<~SQL, [project_dir, provider_name])
+            SELECT models, 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("model_cache_repo", "cache_expired",
+                provider: provider_name, expires_at: expires_at)
+              return nil
+            end
+          end
+
+          models = deserialize_json(row["models"])
+          Aidp.log_debug("model_cache_repo", "cache_hit",
+            provider: provider_name, count: models&.size || 0)
+          models
+        end
+
+        # Invalidate cache for a specific provider
+        #
+        # @param provider_name [String] Provider name
+        # @return [Boolean] Success status
+        def invalidate(provider_name)
+          Aidp.log_debug("model_cache_repo", "invalidate",
+            provider: provider_name)
+
+          execute(<<~SQL, [project_dir, provider_name])
+            DELETE FROM #{table_name}
+            WHERE project_dir = ? AND provider_name = ?
+          SQL
+
+          Aidp.log_info("model_cache_repo", "invalidated",
+            provider: provider_name)
+          true
+        rescue => e
+          Aidp.log_error("model_cache_repo", "invalidate_failed",
+            provider: provider_name, error: e.message)
+          false
+        end
+
+        # Invalidate all cached models
+        #
+        # @return [Boolean] Success status
+        def invalidate_all
+          Aidp.log_debug("model_cache_repo", "invalidate_all")
+          delete_by_project
+          Aidp.log_info("model_cache_repo", "invalidated_all")
+          true
+        rescue => e
+          Aidp.log_error("model_cache_repo", "invalidate_all_failed",
+            error: e.message)
+          false
+        end
+
+        # Get list of providers with valid cached models
+        #
+        # @return [Array<String>] Provider names with valid caches
+        def cached_providers
+          rows = query(<<~SQL, [project_dir])
+            SELECT provider_name, expires_at
+            FROM #{table_name}
+            WHERE project_dir = ?
+          SQL
+
+          providers = []
+          rows.each do |row|
+            next unless row["expires_at"]
+
+            # Parse as UTC since timestamps are stored in UTC
+            expires_at = Time.parse(row["expires_at"] + " UTC")
+            providers << row["provider_name"] if Time.now.utc <= expires_at
+          end
+
+          providers
+        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_providers = cached_providers
+
+          {
+            total_providers: total || 0,
+            cached_providers: valid_providers,
+            valid_count: valid_providers.size
+          }
+        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("model_cache_repo", "cleanup_expired",
+              deleted: count)
+          end
+          count
+        end
+
+        # Get model count for a provider
+        #
+        # @param provider_name [String] Provider name
+        # @return [Integer] Number of cached models
+        def model_count(provider_name)
+          models = get_cached_models(provider_name)
+          models&.size || 0
+        end
+      end
+    end
+  end
+end