aidp 0.24.0 → 0.25.0

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"

data/lib/aidp/harness/config_schema.rb

@@ -1083,6 +1083,56 @@ module Aidp
               max: 365
             }
           }
+        },
+        auto_update: {
+          type: :hash,
+          required: false,
+          default: {
+            enabled: false,
+            policy: "off",
+            allow_prerelease: false,
+            check_interval_seconds: 3600,
+            supervisor: "none",
+            max_consecutive_failures: 3
+          },
+          properties: {
+            enabled: {
+              type: :boolean,
+              required: false,
+              default: false
+            },
+            policy: {
+              type: :string,
+              required: false,
+              default: "off",
+              enum: ["off", "exact", "patch", "minor", "major"]
+            },
+            allow_prerelease: {
+              type: :boolean,
+              required: false,
+              default: false
+            },
+            check_interval_seconds: {
+              type: :integer,
+              required: false,
+              default: 3600,
+              min: 300,
+              max: 86400
+            },
+            supervisor: {
+              type: :string,
+              required: false,
+              default: "none",
+              enum: ["none", "supervisord", "s6", "runit"]
+            },
+            max_consecutive_failures: {
+              type: :integer,
+              required: false,
+              default: 3,
+              min: 1,
+              max: 10
+            }
+          }
         }
       }.freeze
 

data/lib/aidp/harness/provider_factory.rb

@@ -6,6 +6,7 @@ require_relative "../providers/cursor"
 require_relative "../providers/anthropic"
 require_relative "../providers/gemini"
 require_relative "../providers/opencode"
+require_relative "../providers/kilocode"
 require_relative "../providers/github_copilot"
 require_relative "../providers/codex"
 
@@ -19,6 +20,7 @@ module Aidp
         "claude" => Aidp::Providers::Anthropic,
         "gemini" => Aidp::Providers::Gemini,
         "opencode" => Aidp::Providers::Opencode,
+        "kilocode" => Aidp::Providers::Kilocode,
         "github_copilot" => Aidp::Providers::GithubCopilot,
         "codex" => Aidp::Providers::Codex
       }.freeze

data/lib/aidp/message_display.rb

@@ -25,8 +25,12 @@ module Aidp
 
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
+      # Ensure message is UTF-8 encoded to handle emoji and special characters
+      message_str = message.to_s
+      message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
+      message_str = message_str.encode("UTF-8", invalid: :replace, undef: :replace)
       prompt = message_display_prompt
-      prompt.say(message, color: COLOR_MAP.fetch(type, :white))
+      prompt.say(message_str, color: COLOR_MAP.fetch(type, :white))
     end
 
     # Provide a memoized prompt per including instance (if it defines @prompt)
@@ -41,7 +45,11 @@ module Aidp
     module ClassMethods
       # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
-        class_message_display_prompt.say(message, color: COLOR_MAP.fetch(type, :white))
+        # Ensure message is UTF-8 encoded to handle emoji and special characters
+        message_str = message.to_s
+        message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
+        message_str = message_str.encode("UTF-8", invalid: :replace, undef: :replace)
+        class_message_display_prompt.say(message_str, color: COLOR_MAP.fetch(type, :white))
       end
 
       private

data/lib/aidp/prompt_optimization/style_guide_indexer.rb

@@ -82,7 +82,7 @@ module Aidp
         guide_path = File.join(@project_dir, "docs", "LLM_STYLE_GUIDE.md")
         return nil unless File.exist?(guide_path)
 
-        File.read(guide_path)
+        File.read(guide_path, encoding: "UTF-8")
       end
 
       # Parse markdown content into fragments
@@ -90,6 +90,8 @@ module Aidp
       # @param content [String] Markdown content
       # @return [Array<Fragment>] Parsed fragments
       def parse_fragments(content)
+        # Ensure content is UTF-8 encoded
+        content = content.encode("UTF-8", invalid: :replace, undef: :replace) unless content.encoding == Encoding::UTF_8
         lines = content.lines
         current_content = []
         current_heading = nil

data/lib/aidp/provider_manager.rb

@@ -142,6 +142,8 @@ module Aidp
           Aidp::Providers::Anthropic.new(prompt: prompt)
         when "gemini"
           Aidp::Providers::Gemini.new(prompt: prompt)
+        when "kilocode"
+          Aidp::Providers::Kilocode.new(prompt: prompt)
         when "github_copilot"
           Aidp::Providers::GithubCopilot.new(prompt: prompt)
         when "codex"