aidp 0.24.0 → 0.26.0

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

data/lib/aidp/auto_update/version_detector.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "update_check"
+require_relative "update_policy"
+require_relative "bundler_adapter"
+require_relative "rubygems_api_adapter"
+
+module Aidp
+  module AutoUpdate
+    # Service for detecting available gem versions and enforcing semver policy
+    class VersionDetector
+      def initialize(
+        policy:, current_version: Aidp::VERSION,
+        bundler_adapter: BundlerAdapter.new,
+        rubygems_adapter: RubyGemsAPIAdapter.new
+      )
+        @current_version = Gem::Version.new(current_version)
+        @policy = policy
+        @bundler_adapter = bundler_adapter
+        @rubygems_adapter = rubygems_adapter
+      end
+
+      # Check for updates according to policy
+      # @return [UpdateCheck] Result of update check
+      def check_for_update
+        Aidp.log_info("version_detector", "checking_for_updates",
+          current_version: @current_version.to_s,
+          policy: @policy.policy)
+
+        available_version = fetch_latest_version
+
+        unless available_version
+          Aidp.log_warn("version_detector", "no_version_available")
+          return UpdateCheck.unavailable(current_version: @current_version.to_s)
+        end
+
+        update_available = available_version > @current_version
+        # Check policy even if disabled - we still want to report update_available
+        update_allowed = @policy.disabled? ? false : update_allowed_by_policy?(available_version)
+        reason = policy_reason(available_version)
+
+        Aidp.log_info("version_detector", "update_check_complete",
+          current: @current_version.to_s,
+          available: available_version.to_s,
+          update_available: update_available,
+          update_allowed: update_allowed,
+          reason: reason)
+
+        UpdateCheck.new(
+          current_version: @current_version.to_s,
+          available_version: available_version.to_s,
+          update_available: update_available,
+          update_allowed: update_allowed,
+          policy_reason: reason
+        )
+      rescue => e
+        Aidp.log_error("version_detector", "check_failed", error: e.message)
+        UpdateCheck.failed(e.message, current_version: @current_version.to_s)
+      end
+
+      private
+
+      # Fetch latest version using bundler first, fallback to RubyGems API
+      # @return [Gem::Version, nil]
+      def fetch_latest_version
+        # Try bundler first
+        version = @bundler_adapter.latest_version_for("aidp")
+        return version if version
+
+        # Fallback to RubyGems API
+        Aidp.log_debug("version_detector", "falling_back_to_rubygems_api")
+        @rubygems_adapter.latest_version_for("aidp", allow_prerelease: @policy.allow_prerelease)
+      end
+
+      # Apply semver policy to determine if update is allowed
+      # @param available [Gem::Version] Available version
+      # @return [Boolean] Whether update is permitted
+      def update_allowed_by_policy?(available)
+        case @policy.policy
+        when "off"
+          false
+        when "exact"
+          # Only update if exact match (essentially disabled)
+          available == @current_version
+        when "patch"
+          # Allow patch updates within same major.minor
+          same_major_minor?(available) && available >= @current_version
+        when "minor"
+          # Allow minor + patch updates within same major
+          same_major?(available) && available >= @current_version
+        when "major"
+          # Allow any update (including major version bumps)
+          available >= @current_version
+        else
+          false
+        end
+      end
+
+      # Generate human-readable reason for policy decision
+      # @param available [Gem::Version] Available version
+      # @return [String] Explanation of policy decision
+      def policy_reason(available)
+        return "No update available" if available <= @current_version
+
+        case @policy.policy
+        when "off"
+          "Updates disabled by policy"
+        when "exact"
+          "Policy requires exact version match"
+        when "patch"
+          if same_major_minor?(available)
+            "Patch update allowed by policy"
+          else
+            "Minor or major version change blocked by patch policy"
+          end
+        when "minor"
+          if same_major?(available)
+            "Minor/patch update allowed by policy"
+          else
+            "Major version change blocked by minor policy"
+          end
+        when "major"
+          "Update allowed by major policy"
+        else
+          "Unknown policy: #{@policy.policy}"
+        end
+      end
+
+      # Check if version has same major version
+      # @param version [Gem::Version] Version to compare
+      # @return [Boolean]
+      def same_major?(version)
+        version.segments[0] == @current_version.segments[0]
+      end
+
+      # Check if version has same major.minor version
+      # @param version [Gem::Version] Version to compare
+      # @return [Boolean]
+      def same_major_minor?(version)
+        same_major?(version) && version.segments[1] == @current_version.segments[1]
+      end
+    end
+  end
+end

data/lib/aidp/auto_update.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "auto_update/errors"
+require_relative "auto_update/update_policy"
+require_relative "auto_update/update_check"
+require_relative "auto_update/checkpoint"
+require_relative "auto_update/bundler_adapter"
+require_relative "auto_update/rubygems_api_adapter"
+require_relative "auto_update/version_detector"
+require_relative "auto_update/checkpoint_store"
+require_relative "auto_update/update_logger"
+require_relative "auto_update/failure_tracker"
+require_relative "auto_update/coordinator"
+
+module Aidp
+  # Auto-update functionality for Aidp in devcontainers
+  module AutoUpdate
+    # Exit code used to signal supervisor to perform update
+    UPDATE_EXIT_CODE = 75
+
+    # Create coordinator from project configuration
+    # @param project_dir [String] Project root directory
+    # @return [Coordinator]
+    def self.coordinator(project_dir: Dir.pwd)
+      config = Aidp::Config.load_harness_config(project_dir)
+      auto_update_config = config[:auto_update] || config["auto_update"] || {}
+
+      Coordinator.from_config(auto_update_config, project_dir: project_dir)
+    end
+
+    # Check if auto-update is enabled in configuration
+    # @param project_dir [String] Project root directory
+    # @return [Boolean]
+    def self.enabled?(project_dir: Dir.pwd)
+      config = Aidp::Config.load_harness_config(project_dir)
+      auto_update_config = config[:auto_update] || config["auto_update"] || {}
+
+      policy = UpdatePolicy.from_config(auto_update_config)
+      !policy.disabled?
+    end
+
+    # Get auto-update policy from configuration
+    # @param project_dir [String] Project root directory
+    # @return [UpdatePolicy]
+    def self.policy(project_dir: Dir.pwd)
+      config = Aidp::Config.load_harness_config(project_dir)
+      auto_update_config = config[:auto_update] || config["auto_update"] || {}
+
+      UpdatePolicy.from_config(auto_update_config)
+    end
+  end
+end

data/lib/aidp/cli.rb

@@ -323,6 +323,11 @@ module Aidp
           opts.separator "    show <id>                - Show detailed skill information"
           opts.separator "    search <query>           - Search skills by keyword"
           opts.separator "    validate [path]          - Validate skill file format"
+          opts.separator "  settings                 Manage runtime settings"
+          opts.separator "    auto-update status       - Show auto-update configuration"
+          opts.separator "    auto-update on|off       - Enable/disable auto-updates"
+          opts.separator "    auto-update policy <pol> - Set update policy (off/exact/patch/minor/major)"
+          opts.separator "    auto-update prerelease   - Toggle prerelease updates"
           opts.separator "  harness                  Manage harness state"
           opts.separator "  config                   Manage configuration"
           opts.separator "    status                   - Show harness status"
@@ -376,7 +381,7 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness providers checkpoint mcp issue config init watch ws work skill].include?(args.first)
+        %w[status jobs kb harness providers checkpoint mcp issue config init watch ws work skill settings].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -397,6 +402,7 @@ module Aidp
         when "ws" then run_ws_command(args)
         when "work" then run_work_command(args)
         when "skill" then run_skill_command(args)
+        when "settings" then run_settings_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -1854,6 +1860,164 @@ module Aidp
         display_message("Usage: aidp config --interactive [--dry-run]", type: :info)
       end
 
+      def run_settings_command(args)
+        require_relative "auto_update"
+        require "yaml"
+        require "tty-table"
+
+        subcommand = args.shift
+
+        case subcommand
+        when "auto-update"
+          action = args.shift
+
+          case action
+          when "status", nil
+            # Show current auto-update status
+            coordinator = Aidp::AutoUpdate.coordinator(project_dir: Dir.pwd)
+            status = coordinator.status
+
+            display_message("Auto-Update Configuration", type: :highlight)
+            display_message("=" * 60, type: :muted)
+            display_message("Enabled: #{status[:enabled] ? "Yes" : "No"}", type: status[:enabled] ? :success : :muted)
+            display_message("Policy: #{status[:policy]}", type: :info)
+            display_message("Supervisor: #{status[:supervisor]}", type: :info)
+            display_message("Allow Prerelease: #{coordinator.policy.allow_prerelease}", type: :info)
+            display_message("Check Interval: #{coordinator.policy.check_interval_seconds}s", type: :info)
+            display_message("Max Consecutive Failures: #{coordinator.policy.max_consecutive_failures}", type: :info)
+            display_message("", type: :info)
+            display_message("Current Version: #{status[:current_version]}", type: :info)
+            display_message("Latest Available: #{status[:available_version] || "checking..."}", type: :info)
+
+            if status[:update_available]
+              if status[:update_allowed]
+                display_message("Update Available: Yes (allowed by policy)", type: :success)
+              else
+                display_message("Update Available: Yes (blocked by policy: #{status[:policy_reason]})", type: :warning)
+              end
+            else
+              display_message("Update Available: No", type: :muted)
+            end
+
+            display_message("", type: :info)
+            display_message("Failure Tracker:", type: :highlight)
+            failure_status = status[:failure_tracker]
+            display_message("Consecutive Failures: #{failure_status[:failures]}/#{failure_status[:max_failures]}", type: :info)
+            display_message("Last Success: #{failure_status[:last_success] || "never"}", type: :muted)
+
+            if status[:recent_updates]&.any?
+              display_message("", type: :info)
+              display_message("Recent Updates:", type: :highlight)
+              status[:recent_updates].each do |entry|
+                timestamp = entry["timestamp"] || entry[:timestamp]
+                event = entry["event"] || entry[:event]
+                display_message("  #{timestamp} - #{event}", type: :muted)
+              end
+            end
+
+          when "on"
+            # Enable auto-update
+            update_config_value(:auto_update, :enabled, true)
+            display_message("✓ Auto-update enabled", type: :success)
+            display_message("", type: :info)
+            display_message("Make sure to configure a supervisor for watch mode.", type: :muted)
+            display_message("See: docs/SELF_UPDATE.md", type: :muted)
+
+          when "off"
+            # Disable auto-update
+            update_config_value(:auto_update, :enabled, false)
+            display_message("✓ Auto-update disabled", type: :success)
+
+          when "policy"
+            # Set update policy
+            policy = args.shift
+            unless %w[off exact patch minor major].include?(policy)
+              display_message("❌ Invalid policy. Must be: off, exact, patch, minor, major", type: :error)
+              return
+            end
+
+            update_config_value(:auto_update, :policy, policy)
+            display_message("✓ Auto-update policy set to: #{policy}", type: :success)
+            display_message("", type: :info)
+            case policy
+            when "off"
+              display_message("No automatic updates will be performed", type: :muted)
+            when "exact"
+              display_message("Only exact version matches allowed", type: :muted)
+            when "patch"
+              display_message("Patch updates allowed (e.g., 1.2.3 → 1.2.4)", type: :muted)
+            when "minor"
+              display_message("Minor + patch updates allowed (e.g., 1.2.3 → 1.3.0)", type: :muted)
+            when "major"
+              display_message("All updates allowed (e.g., 1.2.3 → 2.0.0)", type: :muted)
+            end
+
+          when "prerelease"
+            # Toggle prerelease
+            current = load_auto_update_config[:allow_prerelease]
+            new_value = !current
+            update_config_value(:auto_update, :allow_prerelease, new_value)
+            display_message("✓ Prerelease updates: #{new_value ? "enabled" : "disabled"}", type: :success)
+
+          else
+            display_message("Usage: aidp settings auto-update <command>", type: :info)
+            display_message("", type: :info)
+            display_message("Commands:", type: :info)
+            display_message("  status                Show current configuration", type: :info)
+            display_message("  on                    Enable auto-updates", type: :info)
+            display_message("  off                   Disable auto-updates", type: :info)
+            display_message("  policy <policy>       Set update policy", type: :info)
+            display_message("    Policies: off, exact, patch, minor, major", type: :muted)
+            display_message("  prerelease            Toggle prerelease updates", type: :info)
+            display_message("", type: :info)
+            display_message("Examples:", type: :info)
+            display_message("  aidp settings auto-update status", type: :info)
+            display_message("  aidp settings auto-update on", type: :info)
+            display_message("  aidp settings auto-update policy minor", type: :info)
+            display_message("  aidp settings auto-update prerelease", type: :info)
+          end
+
+        else
+          display_message("Usage: aidp settings <category> <command>", type: :info)
+          display_message("", type: :info)
+          display_message("Categories:", type: :info)
+          display_message("  auto-update           Auto-update configuration", type: :info)
+          display_message("", type: :info)
+          display_message("Examples:", type: :info)
+          display_message("  aidp settings auto-update status", type: :info)
+        end
+      end
+
+      # Load current auto_update config
+      def load_auto_update_config
+        config_path = File.join(Dir.pwd, ".aidp", "aidp.yml")
+        return {} unless File.exist?(config_path)
+
+        full_config = YAML.safe_load_file(config_path, permitted_classes: [Date, Time, Symbol], aliases: true)
+        full_config["auto_update"] || full_config[:auto_update] || {}
+      end
+
+      # Update a specific configuration value
+      def update_config_value(section, key, value)
+        config_path = File.join(Dir.pwd, ".aidp", "aidp.yml")
+
+        # Load existing config
+        config = if File.exist?(config_path)
+          YAML.safe_load_file(config_path, permitted_classes: [Date, Time, Symbol], aliases: true) || {}
+        else
+          {}
+        end
+
+        # Ensure section exists
+        config[section.to_s] ||= {}
+
+        # Update value
+        config[section.to_s][key.to_s] = value
+
+        # Write back
+        File.write(config_path, YAML.dump(config))
+      end
+
       def run_skill_command(args)
         require_relative "skills"
         require "tty-table"