aidp 0.24.0 → 0.26.0

data/lib/aidp/auto_update/coordinator.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "version_detector"
+require_relative "checkpoint_store"
+require_relative "update_logger"
+require_relative "failure_tracker"
+require_relative "update_policy"
+require_relative "errors"
+
+module Aidp
+  module AutoUpdate
+    # Facade for orchestrating the complete auto-update workflow
+    class Coordinator
+      attr_reader :policy, :version_detector, :checkpoint_store, :update_logger, :failure_tracker
+
+      def initialize(
+        policy:,
+        version_detector: nil,
+        checkpoint_store: nil,
+        update_logger: nil,
+        failure_tracker: nil,
+        project_dir: Dir.pwd
+      )
+        @policy = policy
+        @project_dir = project_dir
+
+        # Use provided instances or create defaults
+        @version_detector = version_detector || VersionDetector.new(policy: policy)
+        @checkpoint_store = checkpoint_store || CheckpointStore.new(project_dir: project_dir)
+        @update_logger = update_logger || UpdateLogger.new(project_dir: project_dir)
+        @failure_tracker = failure_tracker || FailureTracker.new(
+          project_dir: project_dir,
+          max_failures: policy.max_consecutive_failures
+        )
+      end
+
+      # Create coordinator from configuration
+      # @param config [Hash] Auto-update configuration from aidp.yml
+      # @param project_dir [String] Project root directory
+      # @return [Coordinator]
+      def self.from_config(config, project_dir: Dir.pwd)
+        policy = UpdatePolicy.from_config(config)
+        new(policy: policy, project_dir: project_dir)
+      end
+
+      # Check if update is available and allowed
+      # @return [UpdateCheck] Update check result
+      def check_for_update
+        return UpdateCheck.unavailable unless @policy.enabled
+
+        update_check = @version_detector.check_for_update
+        @update_logger.log_check(update_check)
+        update_check
+      rescue => e
+        Aidp.log_error("auto_update_coordinator", "check_failed",
+          error: e.message)
+        UpdateCheck.failed(e.message)
+      end
+
+      # Initiate update process (checkpoint + exit with code 75)
+      # @param current_state [Hash] Current application state (from Watch::Runner)
+      # @return [void] (exits process with code 75)
+      # @raise [UpdateError] If updates are disabled or preconditions not met
+      # @raise [UpdateLoopError] If too many consecutive failures
+      def initiate_update(current_state)
+        raise UpdateError, "Updates disabled by configuration" unless @policy.enabled
+
+        # Check for restart loops
+        if @failure_tracker.too_many_failures?
+          @update_logger.log_restart_loop(@failure_tracker.failure_count)
+          raise UpdateLoopError, "Too many consecutive update failures (#{@failure_tracker.failure_count}/#{@policy.max_consecutive_failures})"
+        end
+
+        # Verify supervisor is configured
+        unless @policy.supervised?
+          raise UpdateError, "No supervisor configured. Set auto_update.supervisor in aidp.yml"
+        end
+
+        # Get latest version to record in checkpoint
+        update_check = check_for_update
+
+        unless update_check.should_update?
+          Aidp.log_info("auto_update_coordinator", "no_update_needed",
+            reason: update_check.policy_reason)
+          return
+        end
+
+        # Create checkpoint from current state
+        checkpoint = build_checkpoint(current_state, update_check.available_version)
+
+        # Save checkpoint
+        unless @checkpoint_store.save_checkpoint(checkpoint)
+          raise UpdateError, "Failed to save checkpoint"
+        end
+
+        # Log update initiation
+        @update_logger.log_update_initiated(checkpoint, target_version: update_check.available_version)
+
+        Aidp.log_info("auto_update_coordinator", "exiting_for_update",
+          from_version: update_check.current_version,
+          to_version: update_check.available_version,
+          checkpoint_id: checkpoint.checkpoint_id)
+
+        # Exit with special code 75 to signal supervisor to update
+        exit(75)
+      rescue UpdateError, UpdateLoopError
+        # Re-raise domain errors
+        raise
+      rescue => e
+        @failure_tracker.record_failure
+        @update_logger.log_failure(e.message)
+        Aidp.log_error("auto_update_coordinator", "initiate_failed",
+          error: e.message)
+        raise UpdateError, "Update initiation failed: #{e.message}"
+      end
+
+      # Restore from checkpoint after update
+      # @return [Checkpoint, nil] Restored checkpoint or nil
+      def restore_from_checkpoint
+        checkpoint = @checkpoint_store.latest_checkpoint
+        return nil unless checkpoint
+
+        Aidp.log_info("auto_update_coordinator", "restoring_checkpoint",
+          id: checkpoint.checkpoint_id,
+          created_at: checkpoint.created_at.iso8601)
+
+        # Validate checkpoint
+        unless checkpoint.valid?
+          Aidp.log_error("auto_update_coordinator", "invalid_checkpoint",
+            id: checkpoint.checkpoint_id,
+            reason: "Checksum validation failed")
+          @failure_tracker.record_failure
+          @update_logger.log_failure("Invalid checkpoint checksum", checkpoint_id: checkpoint.checkpoint_id)
+          return nil
+        end
+
+        # Check version compatibility
+        unless checkpoint.compatible_version?
+          Aidp.log_warn("auto_update_coordinator", "incompatible_version",
+            checkpoint_version: checkpoint.aidp_version,
+            current_version: Aidp::VERSION)
+          @failure_tracker.record_failure
+          @update_logger.log_failure(
+            "Incompatible version: checkpoint from #{checkpoint.aidp_version}, current #{Aidp::VERSION}",
+            checkpoint_id: checkpoint.checkpoint_id
+          )
+          return nil
+        end
+
+        # Log successful restoration
+        @update_logger.log_restore(checkpoint)
+        @update_logger.log_success(
+          from_version: checkpoint.aidp_version,
+          to_version: Aidp::VERSION
+        )
+
+        # Reset failure tracker on success
+        @failure_tracker.reset_on_success
+
+        # Delete checkpoint after successful restore
+        @checkpoint_store.delete_checkpoint(checkpoint.checkpoint_id)
+
+        checkpoint
+      rescue => e
+        @failure_tracker.record_failure
+        @update_logger.log_failure("Checkpoint restore failed: #{e.message}")
+        Aidp.log_error("auto_update_coordinator", "restore_failed",
+          error: e.message)
+        nil
+      end
+
+      # Get status summary for CLI display
+      # @return [Hash] Status information
+      def status
+        update_check = check_for_update
+
+        {
+          enabled: @policy.enabled,
+          policy: @policy.policy,
+          supervisor: @policy.supervisor,
+          current_version: Aidp::VERSION,
+          available_version: update_check.available_version,
+          update_available: update_check.update_available,
+          update_allowed: update_check.update_allowed,
+          policy_reason: update_check.policy_reason,
+          failure_tracker: @failure_tracker.status,
+          recent_updates: @update_logger.recent_entries(limit: 5)
+        }
+      end
+
+      private
+
+      def build_checkpoint(current_state, target_version)
+        Checkpoint.new(
+          mode: current_state[:mode] || "watch",
+          watch_state: current_state[:watch_state]
+        ).tap do |cp|
+          # Store target version in metadata for logging
+          cp.instance_variable_set(:@target_version, target_version)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aidp
+  module AutoUpdate
+    # Base error for all auto-update errors
+    class UpdateError < StandardError; end
+
+    # Error raised when too many consecutive update failures detected
+    class UpdateLoopError < UpdateError; end
+
+    # Error raised when checkpoint is invalid or corrupted
+    class CheckpointError < UpdateError; end
+
+    # Error raised when version policy prevents update
+    class VersionPolicyError < UpdateError; end
+  end
+end

data/lib/aidp/auto_update/failure_tracker.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "../safe_directory"
+
+module Aidp
+  module AutoUpdate
+    # Service for tracking update failures to prevent restart loops
+    class FailureTracker
+      include Aidp::SafeDirectory
+
+      attr_reader :state_file, :max_failures
+
+      def initialize(project_dir: Dir.pwd, max_failures: 3)
+        @project_dir = project_dir
+        state_dir = File.join(project_dir, ".aidp")
+        actual_dir = safe_mkdir_p(state_dir, component_name: "FailureTracker")
+        @state_file = File.join(actual_dir, "auto_update_failures.json")
+        @max_failures = max_failures
+        @state = load_state
+      end
+
+      # Record a failure
+      def record_failure
+        @state[:failures] << {
+          timestamp: Time.now.utc.iso8601,
+          version: Aidp::VERSION
+        }
+
+        # Keep only recent failures (last hour)
+        @state[:failures].select! { |f|
+          Time.parse(f[:timestamp]) > Time.now - 3600
+        }
+
+        save_state
+
+        Aidp.log_warn("failure_tracker", "failure_recorded",
+          total_failures: @state[:failures].size,
+          max_failures: @max_failures)
+      rescue => e
+        Aidp.log_error("failure_tracker", "record_failure_failed",
+          error: e.message)
+      end
+
+      # Check if too many consecutive failures have occurred
+      # @return [Boolean]
+      def too_many_failures?
+        failure_count = @state[:failures].size
+        is_looping = failure_count >= @max_failures
+
+        if is_looping
+          Aidp.log_error("failure_tracker", "restart_loop_detected",
+            failure_count: failure_count,
+            max_failures: @max_failures)
+        end
+
+        is_looping
+      end
+
+      # Reset failure count after successful operation
+      def reset_on_success
+        previous_failures = @state[:failures].size
+
+        @state[:failures] = []
+        @state[:last_success] = Time.now.utc.iso8601
+        @state[:last_success_version] = Aidp::VERSION
+
+        save_state
+
+        Aidp.log_info("failure_tracker", "reset_on_success",
+          previous_failures: previous_failures,
+          version: Aidp::VERSION)
+      rescue => e
+        Aidp.log_error("failure_tracker", "reset_failed",
+          error: e.message)
+      end
+
+      # Get current failure count
+      # @return [Integer]
+      def failure_count
+        @state[:failures].size
+      end
+
+      # Get time since last success
+      # @return [Integer, nil] Seconds since last success, or nil if never successful
+      def time_since_last_success
+        return nil unless @state[:last_success]
+
+        Time.now - Time.parse(@state[:last_success])
+      rescue => e
+        Aidp.log_error("failure_tracker", "time_calculation_failed",
+          error: e.message)
+        nil
+      end
+
+      # Get all failure timestamps
+      # @return [Array<Time>]
+      def failure_timestamps
+        @state[:failures].map { |f| Time.parse(f[:timestamp]) }
+      rescue => e
+        Aidp.log_error("failure_tracker", "timestamp_parsing_failed",
+          error: e.message)
+        []
+      end
+
+      # Manually reset failures (for CLI command or recovery)
+      def force_reset
+        Aidp.log_warn("failure_tracker", "manual_reset_triggered",
+          previous_failures: @state[:failures].size)
+
+        @state[:failures] = []
+        save_state
+      end
+
+      # Get state summary for status display
+      # @return [Hash]
+      def status
+        {
+          failure_count: failure_count,
+          max_failures: @max_failures,
+          too_many_failures: too_many_failures?,
+          last_success: @state[:last_success],
+          last_success_version: @state[:last_success_version],
+          recent_failures: @state[:failures]
+        }
+      end
+
+      private
+
+      def load_state
+        return default_state unless File.exist?(@state_file)
+
+        JSON.parse(File.read(@state_file), symbolize_names: true)
+      rescue JSON::ParserError => e
+        Aidp.log_warn("failure_tracker", "state_file_corrupted",
+          error: e.message)
+        default_state
+      rescue => e
+        Aidp.log_warn("failure_tracker", "load_state_failed",
+          error: e.message)
+        default_state
+      end
+
+      def save_state
+        File.write(@state_file, JSON.pretty_generate(@state))
+      rescue => e
+        Aidp.log_error("failure_tracker", "save_state_failed",
+          error: e.message)
+      end
+
+      def default_state
+        {
+          failures: [],
+          last_success: nil,
+          last_success_version: nil
+        }
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/rubygems_api_adapter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Aidp
+  module AutoUpdate
+    # Adapter for querying gem versions via RubyGems API (fallback)
+    class RubyGemsAPIAdapter
+      RUBYGEMS_API_BASE = "https://rubygems.org/api/v1"
+      TIMEOUT_SECONDS = 5
+
+      # Get the latest version of a gem from RubyGems API
+      # @param gem_name [String] Name of the gem
+      # @param allow_prerelease [Boolean] Whether to allow prerelease versions
+      # @return [Gem::Version, nil] Latest version or nil if unavailable
+      def latest_version_for(gem_name, allow_prerelease: false)
+        Aidp.log_debug("rubygems_api", "checking_gem_version",
+          gem: gem_name,
+          allow_prerelease: allow_prerelease)
+
+        uri = URI.parse("#{RUBYGEMS_API_BASE}/gems/#{gem_name}.json")
+        response = fetch_with_timeout(uri)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body)
+        version_string = data["version"]
+
+        if version_string
+          version = Gem::Version.new(version_string)
+
+          # Filter out prerelease if not allowed
+          if !allow_prerelease && version.prerelease?
+            Aidp.log_debug("rubygems_api", "skipping_prerelease",
+              gem: gem_name,
+              version: version_string)
+            return nil
+          end
+
+          Aidp.log_debug("rubygems_api", "found_version",
+            gem: gem_name,
+            version: version_string)
+          version
+        else
+          Aidp.log_debug("rubygems_api", "no_version_in_response",
+            gem: gem_name)
+          nil
+        end
+      rescue JSON::ParserError => e
+        Aidp.log_error("rubygems_api", "json_parse_failed",
+          gem: gem_name,
+          error: e.message)
+        nil
+      rescue ArgumentError => e
+        Aidp.log_error("rubygems_api", "invalid_version",
+          gem: gem_name,
+          error: e.message)
+        nil
+      rescue => e
+        Aidp.log_error("rubygems_api", "api_request_failed",
+          gem: gem_name,
+          error: e.message)
+        nil
+      end
+
+      private
+
+      def fetch_with_timeout(uri)
+        Net::HTTP.start(
+          uri.host,
+          uri.port,
+          use_ssl: uri.scheme == "https",
+          open_timeout: TIMEOUT_SECONDS,
+          read_timeout: TIMEOUT_SECONDS
+        ) do |http|
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = "Aidp/#{Aidp::VERSION}"
+          http.request(request)
+        end
+      rescue Timeout::Error, Errno::ETIMEDOUT
+        Aidp.log_warn("rubygems_api", "request_timeout",
+          uri: uri.to_s,
+          timeout: TIMEOUT_SECONDS)
+        nil
+      rescue SocketError, Errno::ECONNREFUSED => e
+        Aidp.log_warn("rubygems_api", "connection_failed",
+          uri: uri.to_s,
+          error: e.message)
+        nil
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/update_check.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Aidp
+  module AutoUpdate
+    # Value object representing the result of an update check
+    class UpdateCheck
+      attr_reader :current_version, :available_version, :update_available,
+        :update_allowed, :policy_reason, :checked_at, :error
+
+      def initialize(
+        current_version:,
+        available_version:,
+        update_available:,
+        update_allowed:,
+        policy_reason: nil,
+        checked_at: Time.now,
+        error: nil
+      )
+        @current_version = current_version
+        @available_version = available_version
+        @update_available = update_available
+        @update_allowed = update_allowed
+        @policy_reason = policy_reason
+        @checked_at = checked_at
+        @error = error
+      end
+
+      # Create a failed update check
+      # @param error_message [String] Error message
+      # @param current_version [String] Current version
+      # @return [UpdateCheck]
+      def self.failed(error_message, current_version: Aidp::VERSION)
+        new(
+          current_version: current_version,
+          available_version: current_version,
+          update_available: false,
+          update_allowed: false,
+          policy_reason: "Update check failed",
+          error: error_message
+        )
+      end
+
+      # Create an unavailable update check (service temporarily unavailable)
+      # @param current_version [String] Current version
+      # @return [UpdateCheck]
+      def self.unavailable(current_version: Aidp::VERSION)
+        new(
+          current_version: current_version,
+          available_version: current_version,
+          update_available: false,
+          update_allowed: false,
+          policy_reason: "Update service temporarily unavailable"
+        )
+      end
+
+      # Check if update check was successful
+      # @return [Boolean]
+      def success?
+        @error.nil?
+      end
+
+      # Check if update check failed
+      # @return [Boolean]
+      def failed?
+        !success?
+      end
+
+      # Check if update should be performed
+      # @return [Boolean]
+      def should_update?
+        success? && @update_available && @update_allowed
+      end
+
+      # Convert to hash for serialization
+      # @return [Hash]
+      def to_h
+        {
+          current_version: @current_version,
+          available_version: @available_version,
+          update_available: @update_available,
+          update_allowed: @update_allowed,
+          policy_reason: @policy_reason,
+          checked_at: @checked_at.utc.iso8601,
+          error: @error
+        }
+      end
+
+      # Create from hash
+      # @param hash [Hash] Serialized update check
+      # @return [UpdateCheck]
+      def self.from_h(hash)
+        new(
+          current_version: hash[:current_version] || hash["current_version"],
+          available_version: hash[:available_version] || hash["available_version"],
+          update_available: hash[:update_available] || hash["update_available"],
+          update_allowed: hash[:update_allowed] || hash["update_allowed"],
+          policy_reason: hash[:policy_reason] || hash["policy_reason"],
+          checked_at: Time.parse(hash[:checked_at] || hash["checked_at"]),
+          error: hash[:error] || hash["error"]
+        )
+      end
+    end
+  end
+end