aidp 0.24.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2ec07f1c36212b7ace8e467e098fc3bcd917dc0738e27125bbddcef9bbcc30e
-  data.tar.gz: edbc40f6c50b581729d185186eae3510e8c23885f12655c46868117af361f31a
+  metadata.gz: 0b4770edc850e936b3201ec532cdd369f7fd881ff79dd10e24407c6453b8cb22
+  data.tar.gz: d7d2640aa63d2c25afbf795bbf77d48741bdd99d6a074765fa5595f3982b96e6
 SHA512:
-  metadata.gz: f6472e33b88cf45f0c0abc5131dd608ba20d73480074552275d6d886222357c435023845fa8762b7f527268ba34fc2d3841d504309c8c068adbc38d6ac41f12b
-  data.tar.gz: 4283ba15ee02985603adbdba0be476adec35efc9fa6730a01beef1eac50d068647f3560aa03d75fcdb24ffc102e742bc1c3d9ff53fe95662a20241c711b54ae7
+  metadata.gz: 1841e0b35478d65d382d13dd138955c30655002b91c2a83d96ec2c83925eec4f954892aa710ded867b50554dbc9653bddfad5c5aa915890e674bb49afed347bc
+  data.tar.gz: 1fc1443566c4e01e0c6ff25f1ae62c890ddcd5373257265ee7119ea8db359c20282cf646d61b955204e4dc538ceb9c6313725cb4fed21cda231b97321cc2c030

data/README.md

@@ -218,7 +218,9 @@ aidp watch owner/repo --once
 
 **Label Workflow:**
 
-AIDP uses a smart label-based workflow to manage the lifecycle of automated issue resolution:
+AIDP uses a smart label-based workflow to manage both issues and pull requests:
+
+#### Issue Workflow (Plan & Build)
 
 1. **Planning Phase** (`aidp-plan` label):
    - Add this label to an issue to trigger plan generation
@@ -247,6 +249,32 @@ AIDP uses a smart label-based workflow to manage the lifecycle of automated issu
      - Posts completion comment with summary
      - Automatically removes the `aidp-build` label
 
+#### Pull Request Workflow (Review, CI Fix, Change Requests)
+
+<!-- markdownlint-disable-next-line MD029 -->
+1. **Code Review** (`aidp-review` label):
+   - Add this label to any PR to trigger automated code review
+   - AIDP analyzes code from three expert perspectives (Senior Developer, Security Specialist, Performance Analyst)
+   - Posts a comprehensive review comment with severity-categorized findings (High Priority, Major, Minor, Nit)
+   - Automatically removes the label after posting review
+   - No commits are made - review only
+
+2. **CI Fix** (`aidp-fix-ci` label):
+   - Add this label to a PR with failing CI checks
+   - AIDP analyzes CI failure logs and identifies root causes
+   - Automatically fixes issues like linting errors, simple test failures, and dependency problems
+   - Commits and pushes fixes to the PR branch
+   - Posts a summary of what was fixed
+   - Automatically removes the label after completion
+
+3. **Change Requests** (`aidp-request-changes` label):
+   - Comment on your own PR describing desired changes, then add this label
+   - AIDP implements the requested changes on the PR branch
+   - Runs tests/linters and commits changes
+   - **If clarification needed**: Replaces label with `aidp-needs-input` and posts questions
+   - User responds to questions and re-applies the label to continue
+   - Automatically removes the label after completion
+
 **Customizable Labels:**
 
 All label names are configurable to match your repository's existing label scheme. Configure via the interactive wizard or manually in `aidp.yml`:
@@ -255,10 +283,16 @@ All label names are configurable to match your repository's existing label schem
 # .aidp/aidp.yml
 watch:
   labels:
-    plan_trigger: aidp-plan        # Label to trigger plan generation
-    needs_input: aidp-needs-input  # Label when plan needs user input
-    ready_to_build: aidp-ready     # Label when plan is ready to build
-    build_trigger: aidp-build      # Label to trigger implementation
+    # Issue-based automation
+    plan_trigger: aidp-plan                    # Trigger plan generation
+    needs_input: aidp-needs-input              # Needs user input/clarification
+    ready_to_build: aidp-ready                 # Plan ready for implementation
+    build_trigger: aidp-build                  # Trigger implementation
+
+    # PR-based automation
+    review_trigger: aidp-review                # Trigger code review
+    ci_fix_trigger: aidp-fix-ci                # Trigger CI auto-fix
+    change_request_trigger: aidp-request-changes  # Trigger PR change implementation
 ```
 
 Run `aidp config --interactive` and enable watch mode to configure labels interactively.
@@ -294,7 +328,12 @@ AIDP can automatically request clarification when it needs more information duri
 
 This ensures AIDP never gets stuck - if it needs more information, it will ask for it rather than making incorrect assumptions or failing silently.
 
-See [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) and [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) for complete documentation.
+**Additional Documentation:**
+
+- [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) - Complete guide to watch mode setup and operation
+- [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) - Security features and best practices
+- [PR Automation Guide](docs/PR_AUTOMATION.md) - Detailed guide for code review, CI fixes, and PR changes
+- [PR Change Requests](docs/PR_CHANGE_REQUESTS.md) - Comprehensive documentation for automated PR modifications
 
 ## Command Reference
 
@@ -406,6 +445,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 +496,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/analyze/error_handler.rb

@@ -99,6 +99,13 @@ module Aidp
       private
 
       def setup_logger(log_file, verbose)
+        # Suppress logger output in test/CI environments
+        if suppress_error_logs?
+          logger = ::Logger.new(IO::NULL)
+          logger.level = ::Logger::FATAL
+          return logger
+        end
+
         output_stream = log_file || @output || $stdout
         logger = ::Logger.new(output_stream)
         logger.level = verbose ? ::Logger::DEBUG : ::Logger::INFO
@@ -108,6 +115,10 @@ module Aidp
         logger
       end
 
+      def suppress_error_logs?
+        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+      end
+
       def setup_recovery_strategies
         strategies = {
           Errno::ENOENT => :skip_step_with_warning,

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