aidp 0.24.0 → 0.25.0

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

data/lib/aidp/auto_update/update_logger.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "socket"
+require_relative "../safe_directory"
+
+module Aidp
+  module AutoUpdate
+    # Service for logging update events in JSON Lines format
+    class UpdateLogger
+      include Aidp::SafeDirectory
+
+      attr_reader :log_file
+
+      def initialize(project_dir: Dir.pwd)
+        @project_dir = project_dir
+        log_dir = File.join(project_dir, ".aidp", "logs")
+        actual_dir = safe_mkdir_p(log_dir, component_name: "UpdateLogger")
+        @log_file = File.join(actual_dir, "updates.log")
+      end
+
+      # Log an update check
+      # @param update_check [UpdateCheck] Update check result
+      def log_check(update_check)
+        write_log_entry(
+          event: "check",
+          current_version: update_check.current_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,
+          error: update_check.error
+        )
+      end
+
+      # Log update initiation
+      # @param checkpoint [Checkpoint] Checkpoint created for update
+      # @param target_version [String] Version updating to
+      def log_update_initiated(checkpoint, target_version: nil)
+        write_log_entry(
+          event: "update_initiated",
+          checkpoint_id: checkpoint.checkpoint_id,
+          from_version: checkpoint.aidp_version,
+          to_version: target_version,
+          mode: checkpoint.mode
+        )
+      end
+
+      # Log successful checkpoint restoration
+      # @param checkpoint [Checkpoint] Checkpoint that was restored
+      def log_restore(checkpoint)
+        write_log_entry(
+          event: "restore",
+          checkpoint_id: checkpoint.checkpoint_id,
+          from_version: checkpoint.aidp_version,
+          restored_version: Aidp::VERSION,
+          mode: checkpoint.mode
+        )
+      end
+
+      # Log update failure
+      # @param reason [String] Failure reason
+      # @param checkpoint_id [String, nil] Associated checkpoint ID
+      def log_failure(reason, checkpoint_id: nil)
+        write_log_entry(
+          event: "failure",
+          reason: reason,
+          checkpoint_id: checkpoint_id,
+          version: Aidp::VERSION
+        )
+      end
+
+      # Log successful update completion
+      # @param from_version [String] Version updated from
+      # @param to_version [String] Version updated to
+      def log_success(from_version:, to_version:)
+        write_log_entry(
+          event: "success",
+          from_version: from_version,
+          to_version: to_version
+        )
+      end
+
+      # Log restart loop detection
+      # @param failure_count [Integer] Number of consecutive failures
+      def log_restart_loop(failure_count)
+        write_log_entry(
+          event: "restart_loop_detected",
+          failure_count: failure_count,
+          version: Aidp::VERSION
+        )
+      end
+
+      # Read recent update log entries
+      # @param limit [Integer] Maximum number of entries to return
+      # @return [Array<Hash>] Recent log entries
+      def recent_entries(limit: 10)
+        return [] unless File.exist?(@log_file)
+
+        entries = []
+        File.readlines(@log_file).reverse_each do |line|
+          break if entries.size >= limit
+          begin
+            entries << JSON.parse(line, symbolize_names: true)
+          rescue JSON::ParserError
+            # Skip malformed lines
+          end
+        end
+
+        entries
+      rescue => e
+        Aidp.log_error("update_logger", "read_entries_failed",
+          error: e.message)
+        []
+      end
+
+      private
+
+      def write_log_entry(data)
+        entry = data.merge(
+          timestamp: Time.now.utc.iso8601,
+          hostname: Socket.gethostname
+        )
+
+        # Remove nil values
+        entry = entry.compact
+
+        File.open(@log_file, "a") do |f|
+          f.puts(JSON.generate(entry))
+        end
+
+        Aidp.log_debug("update_logger", "log_entry_written",
+          event: data[:event])
+      rescue => e
+        # Log to main logger but don't fail
+        Aidp.log_error("update_logger", "write_failed",
+          event: data[:event],
+          error: e.message)
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/update_policy.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Aidp
+  module AutoUpdate
+    # Value object representing auto-update configuration policy
+    class UpdatePolicy
+      attr_reader :enabled, :policy, :allow_prerelease, :check_interval_seconds,
+        :supervisor, :max_consecutive_failures
+
+      VALID_POLICIES = %w[off exact patch minor major].freeze
+      VALID_SUPERVISORS = %w[none supervisord s6 runit].freeze
+
+      def initialize(
+        enabled: false,
+        policy: "off",
+        allow_prerelease: false,
+        check_interval_seconds: 3600,
+        supervisor: "none",
+        max_consecutive_failures: 3
+      )
+        @enabled = enabled
+        @policy = validate_policy(policy)
+        @allow_prerelease = allow_prerelease
+        @check_interval_seconds = validate_interval(check_interval_seconds)
+        @supervisor = validate_supervisor(supervisor)
+        @max_consecutive_failures = validate_max_failures(max_consecutive_failures)
+      end
+
+      # Create from configuration hash
+      # @param config [Hash] Configuration hash from aidp.yml
+      # @return [UpdatePolicy]
+      def self.from_config(config)
+        return disabled unless config
+
+        new(
+          enabled: config[:enabled] || config["enabled"] || false,
+          policy: config[:policy] || config["policy"] || "off",
+          allow_prerelease: config[:allow_prerelease] || config["allow_prerelease"] || false,
+          check_interval_seconds: config[:check_interval_seconds] || config["check_interval_seconds"] || 3600,
+          supervisor: config[:supervisor] || config["supervisor"] || "none",
+          max_consecutive_failures: config[:max_consecutive_failures] || config["max_consecutive_failures"] || 3
+        )
+      end
+
+      # Create a disabled policy
+      # @return [UpdatePolicy]
+      def self.disabled
+        new(enabled: false, policy: "off")
+      end
+
+      # Check if updates are completely disabled
+      # @return [Boolean]
+      def disabled?
+        !@enabled || @policy == "off"
+      end
+
+      # Check if a supervisor is configured
+      # @return [Boolean]
+      def supervised?
+        @supervisor != "none"
+      end
+
+      # Convert to hash for serialization
+      # @return [Hash]
+      def to_h
+        {
+          enabled: @enabled,
+          policy: @policy,
+          allow_prerelease: @allow_prerelease,
+          check_interval_seconds: @check_interval_seconds,
+          supervisor: @supervisor,
+          max_consecutive_failures: @max_consecutive_failures
+        }
+      end
+
+      private
+
+      def validate_policy(policy)
+        unless VALID_POLICIES.include?(policy.to_s)
+          raise ArgumentError, "Invalid policy: #{policy}. Must be one of: #{VALID_POLICIES.join(", ")}"
+        end
+        policy.to_s
+      end
+
+      def validate_supervisor(supervisor)
+        unless VALID_SUPERVISORS.include?(supervisor.to_s)
+          raise ArgumentError, "Invalid supervisor: #{supervisor}. Must be one of: #{VALID_SUPERVISORS.join(", ")}"
+        end
+        supervisor.to_s
+      end
+
+      def validate_interval(interval)
+        interval = interval.to_i
+        if interval < 300 || interval > 86400
+          raise ArgumentError, "Invalid check_interval_seconds: #{interval}. Must be between 300 and 86400"
+        end
+        interval
+      end
+
+      def validate_max_failures(max_failures)
+        max_failures = max_failures.to_i
+        if max_failures < 1 || max_failures > 10
+          raise ArgumentError, "Invalid max_consecutive_failures: #{max_failures}. Must be between 1 and 10"
+        end
+        max_failures
+      end
+    end
+  end
+end