aidp 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2ec07f1c36212b7ace8e467e098fc3bcd917dc0738e27125bbddcef9bbcc30e
-  data.tar.gz: edbc40f6c50b581729d185186eae3510e8c23885f12655c46868117af361f31a
+  metadata.gz: 348238e998f8d75ef9f23fcb5a8f4517b6fde0dd9612a4520583b03ab692cc23
+  data.tar.gz: ed8db8dbd0459211e65b76784b6074b65f2689cdb76f7b7c74bcb029d4c9f74d
 SHA512:
-  metadata.gz: f6472e33b88cf45f0c0abc5131dd608ba20d73480074552275d6d886222357c435023845fa8762b7f527268ba34fc2d3841d504309c8c068adbc38d6ac41f12b
-  data.tar.gz: 4283ba15ee02985603adbdba0be476adec35efc9fa6730a01beef1eac50d068647f3560aa03d75fcdb24ffc102e742bc1c3d9ff53fe95662a20241c711b54ae7
+  metadata.gz: ac5628709db6248036d75e5873252089e497b96bac785a610bcc9b153b350714d4a5e441610501b3897cf6994d9081fa36e990da67678b86c167d5e58b048f64
+  data.tar.gz: dd660df245ffd1bb28048e4b76b231efce515e880fc8cfa088af6a25b1fcb42b98562d592880d256ade4474a3db6879567f3fb2670e750da0ee94ea5347b2df7

data/README.md

@@ -406,6 +406,7 @@ AIDP intelligently manages multiple providers with automatic switching:
 - **Cursor CLI** - IDE-integrated provider for code-specific tasks
 - **Gemini CLI** - Google's Gemini command-line interface for general tasks
 - **GitHub Copilot CLI** - GitHub's AI pair programmer command-line interface
+- **Kilocode** - Modern AI coding assistant with autonomous mode support
 - **OpenCode** - Alternative open-source code generation provider
 
 The system automatically switches providers when:
@@ -456,12 +457,37 @@ providers:
     type: "subscription"
 ```
 
+### Provider Installation
+
+Each provider requires its CLI tool to be installed:
+
+```bash
+# Cursor CLI
+npm install -g @cursor/cli
+
+# Kilocode CLI
+npm install -g @kilocode/cli
+
+# OpenCode CLI
+npm install -g @opencode/cli
+
+# GitHub Copilot CLI (requires GitHub account)
+gh extension install github/gh-copilot
+```
+
 ### Environment Variables
 
 ```bash
-# Set API keys
+# Set API keys for usage-based providers
 export AIDP_CLAUDE_API_KEY="your-claude-api-key"
 export AIDP_GEMINI_API_KEY="your-gemini-api-key"
+
+# Kilocode authentication (get token from kilocode.ai profile)
+export KILOCODE_TOKEN="your-kilocode-api-token"
+
+# Optional: Configure provider-specific settings
+export KILOCODE_MODEL="your-preferred-model"
+export AIDP_KILOCODE_TIMEOUT="600"  # Custom timeout in seconds
 ```
 
 ## Tree-sitter Static Analysis

data/lib/aidp/auto_update/bundler_adapter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Aidp
+  module AutoUpdate
+    # Adapter for querying gem versions via Bundler
+    class BundlerAdapter
+      # Get the latest version of a gem according to bundle outdated
+      # @param gem_name [String] Name of the gem
+      # @return [Gem::Version, nil] Latest version or nil if unavailable
+      def latest_version_for(gem_name)
+        Aidp.log_debug("bundler_adapter", "checking_gem_version", gem: gem_name)
+
+        # Use mise exec to ensure correct Ruby version
+        stdout, stderr, status = Open3.capture3(
+          "mise", "exec", "--", "bundle", "outdated", gem_name, "--parseable"
+        )
+
+        unless status.success?
+          Aidp.log_debug("bundler_adapter", "bundle_outdated_failed",
+            gem: gem_name,
+            stderr: stderr.strip)
+          return nil
+        end
+
+        # Parse bundle outdated output
+        # Format: "gem_name (newest version, installed version, requested version)"
+        # Example: "aidp (0.25.0, 0.24.0, >= 0)"
+        parse_bundle_outdated(stdout, gem_name)
+      rescue => e
+        Aidp.log_error("bundler_adapter", "version_check_failed",
+          gem: gem_name,
+          error: e.message)
+        nil
+      end
+
+      private
+
+      def parse_bundle_outdated(output, gem_name)
+        # Example output line: "aidp (newest 0.25.0, installed 0.24.0)"
+        output.each_line do |line|
+          next unless line.start_with?(gem_name)
+
+          # Extract newest version using regex
+          if line =~ /newest\s+([0-9.]+[a-z0-9.-]*)/
+            version_string = ::Regexp.last_match(1)
+            Aidp.log_debug("bundler_adapter", "found_version",
+              gem: gem_name,
+              version: version_string)
+            return Gem::Version.new(version_string)
+          end
+        end
+
+        Aidp.log_debug("bundler_adapter", "no_newer_version",
+          gem: gem_name)
+        nil
+      rescue ArgumentError => e
+        Aidp.log_error("bundler_adapter", "invalid_version",
+          gem: gem_name,
+          error: e.message)
+        nil
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/checkpoint.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "socket"
+require "digest"
+require "open3"
+
+module Aidp
+  module AutoUpdate
+    # Aggregate root representing a complete state snapshot for restart recovery
+    class Checkpoint
+      attr_reader :checkpoint_id, :created_at, :aidp_version, :mode, :watch_state,
+        :metadata, :checksum
+
+      SCHEMA_VERSION = 1
+
+      def initialize(
+        mode:, checkpoint_id: SecureRandom.uuid,
+        created_at: Time.now,
+        aidp_version: Aidp::VERSION,
+        watch_state: nil,
+        metadata: {},
+        checksum: nil
+      )
+        @checkpoint_id = checkpoint_id
+        @created_at = created_at
+        @aidp_version = aidp_version
+        @mode = validate_mode(mode)
+        @watch_state = watch_state
+        @metadata = default_metadata.merge(metadata)
+        @checksum = checksum || compute_checksum
+      end
+
+      # Create checkpoint from current watch mode state
+      # @param runner [Aidp::Watch::Runner] Watch mode runner
+      # @return [Checkpoint]
+      def self.from_watch_runner(runner)
+        new(
+          mode: "watch",
+          watch_state: {
+            repository: runner.instance_variable_get(:@repository_client).full_repo,
+            interval: runner.instance_variable_get(:@interval),
+            provider_name: runner.instance_variable_get(:@plan_processor).instance_variable_get(:@plan_generator).instance_variable_get(:@provider_name),
+            persona: nil, # Not currently tracked in runner
+            safety_config: runner.instance_variable_get(:@safety_checker).instance_variable_get(:@config),
+            worktree_context: capture_worktree_context,
+            state_store_snapshot: runner.instance_variable_get(:@state_store).send(:state)
+          }
+        )
+      end
+
+      # Create checkpoint from hash (deserialization)
+      # @param hash [Hash] Serialized checkpoint data
+      # @return [Checkpoint]
+      def self.from_h(hash)
+        new(
+          checkpoint_id: hash[:checkpoint_id] || hash["checkpoint_id"],
+          created_at: Time.parse(hash[:created_at] || hash["created_at"]),
+          aidp_version: hash[:aidp_version] || hash["aidp_version"],
+          mode: hash[:mode] || hash["mode"],
+          watch_state: hash[:watch_state] || hash["watch_state"],
+          metadata: hash[:metadata] || hash["metadata"] || {},
+          checksum: hash[:checksum] || hash["checksum"]
+        )
+      end
+
+      # Convert to hash for serialization
+      # @return [Hash]
+      def to_h
+        {
+          schema_version: SCHEMA_VERSION,
+          checkpoint_id: @checkpoint_id,
+          created_at: @created_at.utc.iso8601(6), # Preserve microsecond precision
+          aidp_version: @aidp_version,
+          mode: @mode,
+          watch_state: @watch_state,
+          metadata: @metadata,
+          checksum: @checksum
+        }
+      end
+
+      # Verify checkpoint integrity
+      # @return [Boolean]
+      def valid?
+        @checksum == compute_checksum
+      end
+
+      # Check if checkpoint is for watch mode
+      # @return [Boolean]
+      def watch_mode?
+        @mode == "watch"
+      end
+
+      # Check if checkpoint is compatible with current Aidp version
+      # @return [Boolean]
+      def compatible_version?
+        # Allow restoring from same major.minor version
+        checkpoint_ver = Gem::Version.new(@aidp_version)
+        current_ver = Gem::Version.new(Aidp::VERSION)
+
+        checkpoint_ver.segments[0] == current_ver.segments[0] &&
+          checkpoint_ver.segments[1] == current_ver.segments[1]
+      rescue ArgumentError
+        false
+      end
+
+      private
+
+      def validate_mode(mode)
+        valid_modes = %w[watch execute analyze]
+        unless valid_modes.include?(mode.to_s)
+          raise ArgumentError, "Invalid mode: #{mode}. Must be one of: #{valid_modes.join(", ")}"
+        end
+        mode.to_s
+      end
+
+      def default_metadata
+        {
+          hostname: Socket.gethostname,
+          project_dir: Dir.pwd,
+          ruby_version: RUBY_VERSION
+        }
+      end
+
+      def compute_checksum
+        # Compute SHA256 of checkpoint data (excluding checksum field)
+        # Use canonical JSON with sorted keys for deterministic hashing
+        data = {
+          checkpoint_id: @checkpoint_id,
+          created_at: @created_at.utc.iso8601(6), # Preserve microsecond precision
+          aidp_version: @aidp_version,
+          mode: @mode,
+          watch_state: @watch_state,
+          metadata: @metadata
+        }
+
+        canonical_json = JSON.generate(sort_keys(data))
+        Digest::SHA256.hexdigest(canonical_json)
+      end
+
+      def sort_keys(obj)
+        case obj
+        when Hash
+          # Convert all keys to strings and sort for consistent ordering
+          obj.transform_keys(&:to_s).sort.to_h { |k, v| [k, sort_keys(v)] }
+        when Array
+          obj.map { |v| sort_keys(v) }
+        else
+          obj
+        end
+      end
+
+      class << self
+        private
+
+        def capture_worktree_context
+          # Check if we're in a git repository
+          _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--git-dir")
+          return {} unless status.success?
+
+          branch, = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD")
+          commit_sha, = Open3.capture3("git", "rev-parse", "HEAD")
+          remote_url, = Open3.capture3("git", "config", "--get", "remote.origin.url")
+
+          {
+            branch: branch.strip,
+            commit_sha: commit_sha.strip,
+            remote_url: remote_url.strip
+          }
+        rescue => e
+          Aidp.log_debug("checkpoint", "worktree_context_unavailable", error: e.message)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/aidp/auto_update/checkpoint_store.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require_relative "checkpoint"
+require_relative "../safe_directory"
+
+module Aidp
+  module AutoUpdate
+    # Repository for persisting and restoring checkpoint state
+    class CheckpointStore
+      include Aidp::SafeDirectory
+
+      attr_reader :checkpoint_dir
+
+      def initialize(project_dir: Dir.pwd)
+        @project_dir = project_dir
+        original_dir = File.join(project_dir, ".aidp", "checkpoints")
+        @checkpoint_dir = safe_mkdir_p(original_dir, component_name: "CheckpointStore")
+      end
+
+      # Save checkpoint atomically
+      # @param checkpoint [Checkpoint] State to persist
+      # @return [Boolean] Success status
+      def save_checkpoint(checkpoint)
+        Aidp.log_info("checkpoint_store", "saving_checkpoint",
+          id: checkpoint.checkpoint_id,
+          mode: checkpoint.mode)
+
+        unless checkpoint.valid?
+          Aidp.log_error("checkpoint_store", "invalid_checkpoint",
+            id: checkpoint.checkpoint_id,
+            error: "Checksum validation failed")
+          return false
+        end
+
+        # Write to temp file first
+        temp_file = "#{checkpoint_path(checkpoint.checkpoint_id)}.tmp"
+        File.write(temp_file, JSON.pretty_generate(checkpoint.to_h))
+
+        # Atomic rename
+        File.rename(temp_file, checkpoint_path(checkpoint.checkpoint_id))
+
+        Aidp.log_info("checkpoint_store", "checkpoint_saved",
+          id: checkpoint.checkpoint_id,
+          path: checkpoint_path(checkpoint.checkpoint_id))
+        true
+      rescue => e
+        Aidp.log_error("checkpoint_store", "save_failed",
+          id: checkpoint.checkpoint_id,
+          error: e.message)
+        File.delete(temp_file) if temp_file && File.exist?(temp_file)
+        false
+      end
+
+      # Find most recent checkpoint for restoration
+      # @return [Checkpoint, nil] Most recent checkpoint or nil
+      def latest_checkpoint
+        checkpoints = list_checkpoints
+
+        if checkpoints.empty?
+          Aidp.log_debug("checkpoint_store", "no_checkpoints_found")
+          return nil
+        end
+
+        # Sort by created_at descending
+        latest = checkpoints.max_by { |cp| cp.created_at }
+
+        Aidp.log_info("checkpoint_store", "found_latest_checkpoint",
+          id: latest.checkpoint_id,
+          created_at: latest.created_at.iso8601)
+
+        latest
+      rescue => e
+        Aidp.log_error("checkpoint_store", "latest_checkpoint_failed",
+          error: e.message)
+        nil
+      end
+
+      # List all checkpoints
+      # @return [Array<Checkpoint>] All available checkpoints
+      def list_checkpoints
+        checkpoint_files = Dir.glob(File.join(@checkpoint_dir, "*.json"))
+
+        checkpoints = checkpoint_files.filter_map do |file|
+          load_checkpoint_file(file)
+        end
+
+        Aidp.log_debug("checkpoint_store", "listed_checkpoints",
+          count: checkpoints.size)
+
+        checkpoints
+      rescue => e
+        Aidp.log_error("checkpoint_store", "list_failed", error: e.message)
+        []
+      end
+
+      # Delete checkpoint after successful restoration
+      # @param checkpoint_id [String] Checkpoint UUID
+      # @return [Boolean] Success status
+      def delete_checkpoint(checkpoint_id)
+        path = checkpoint_path(checkpoint_id)
+
+        unless File.exist?(path)
+          Aidp.log_warn("checkpoint_store", "checkpoint_not_found",
+            id: checkpoint_id,
+            path: path)
+          return false
+        end
+
+        File.delete(path)
+
+        Aidp.log_info("checkpoint_store", "checkpoint_deleted",
+          id: checkpoint_id)
+        true
+      rescue => e
+        Aidp.log_error("checkpoint_store", "delete_failed",
+          id: checkpoint_id,
+          error: e.message)
+        false
+      end
+
+      # Clean up old checkpoints (retention policy)
+      # @param max_age_days [Integer] Maximum age to retain
+      # @return [Integer] Number of checkpoints deleted
+      def cleanup_old_checkpoints(max_age_days: 7)
+        Aidp.log_info("checkpoint_store", "cleaning_old_checkpoints",
+          max_age_days: max_age_days)
+
+        cutoff_time = Time.now - (max_age_days * 24 * 60 * 60)
+        deleted_count = 0
+
+        list_checkpoints.each do |checkpoint|
+          if checkpoint.created_at < cutoff_time
+            if delete_checkpoint(checkpoint.checkpoint_id)
+              deleted_count += 1
+            end
+          end
+        end
+
+        Aidp.log_info("checkpoint_store", "cleanup_complete",
+          deleted: deleted_count,
+          max_age_days: max_age_days)
+
+        deleted_count
+      rescue => e
+        Aidp.log_error("checkpoint_store", "cleanup_failed",
+          error: e.message)
+        0
+      end
+
+      private
+
+      def checkpoint_path(checkpoint_id)
+        File.join(@checkpoint_dir, "#{checkpoint_id}.json")
+      end
+
+      def load_checkpoint_file(file_path)
+        data = JSON.parse(File.read(file_path))
+        checkpoint = Checkpoint.from_h(data)
+
+        unless checkpoint.valid?
+          Aidp.log_warn("checkpoint_store", "invalid_checkpoint_checksum",
+            file: file_path)
+          return nil
+        end
+
+        checkpoint
+      rescue JSON::ParserError => e
+        Aidp.log_warn("checkpoint_store", "invalid_checkpoint_json",
+          file: file_path,
+          error: e.message)
+        nil
+      rescue => e
+        Aidp.log_warn("checkpoint_store", "checkpoint_load_failed",
+          file: file_path,
+          error: e.message)
+        nil
+      end
+    end
+  end
+end

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