aidp 0.24.0 → 0.25.0

data/lib/aidp/watch/reviewers/base_reviewer.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../../provider_manager"
+require_relative "../../harness/config_manager"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Base class for all PR reviewers
+      class BaseReviewer
+        attr_reader :provider_name, :persona_name, :focus_areas
+
+        def initialize(provider_name: nil)
+          @provider_name = provider_name
+          @persona_name = self.class::PERSONA_NAME
+          @focus_areas = self.class::FOCUS_AREAS
+        end
+
+        # Review the PR and return findings
+        # @param pr_data [Hash] PR metadata (number, title, body, etc.)
+        # @param files [Array<Hash>] Changed files with patches
+        # @param diff [String] Full diff content
+        # @return [Hash] Review findings with structure:
+        #   {
+        #     persona: String,
+        #     findings: [
+        #       {
+        #         severity: "high|major|minor|nit",
+        #         category: String,
+        #         message: String,
+        #         file: String (optional),
+        #         line: Integer (optional),
+        #         suggestion: String (optional)
+        #       }
+        #     ]
+        #   }
+        def review(pr_data:, files:, diff:)
+          raise NotImplementedError, "Subclasses must implement #review"
+        end
+
+        protected
+
+        def provider
+          @provider ||= begin
+            provider_name = @provider_name || detect_default_provider
+            Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+          end
+        end
+
+        def detect_default_provider
+          config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+          config_manager.default_provider || "anthropic"
+        rescue
+          "anthropic"
+        end
+
+        def system_prompt
+          <<~PROMPT
+            You are #{@persona_name}, reviewing a pull request.
+
+            Your focus areas are:
+            #{@focus_areas.map { |area| "- #{area}" }.join("\n")}
+
+            Review the code changes and provide structured feedback in the following JSON format:
+            {
+              "findings": [
+                {
+                  "severity": "high|major|minor|nit",
+                  "category": "Brief category (e.g., 'Security', 'Performance', 'Logic Error')",
+                  "message": "Detailed explanation of the issue",
+                  "file": "path/to/file.rb",
+                  "line": 42,
+                  "suggestion": "Optional: Suggested fix or improvement"
+                }
+              ]
+            }
+
+            Severity levels:
+            - high: Critical issues that must be fixed (security vulnerabilities, data loss, crashes)
+            - major: Significant problems that should be addressed (incorrect logic, performance issues)
+            - minor: Improvements that would be good to have (code quality, maintainability)
+            - nit: Stylistic or trivial suggestions (formatting, naming)
+
+            Focus on actionable, specific feedback. If no issues are found, return an empty findings array.
+          PROMPT
+        end
+
+        def analyze_with_provider(user_prompt)
+          full_prompt = "#{system_prompt}\n\n#{user_prompt}"
+          response = provider.send_message(prompt: full_prompt)
+          content = response.to_s.strip
+
+          # Extract JSON from response (handle code fences)
+          json_content = extract_json(content)
+
+          # Parse JSON response
+          parsed = JSON.parse(json_content)
+          parsed["findings"] || []
+        rescue JSON::ParserError => e
+          Aidp.log_error("reviewer", "Failed to parse provider response", persona: @persona_name, error: e.message, content: content)
+          []
+        rescue => e
+          Aidp.log_error("reviewer", "Review failed", persona: @persona_name, error: e.message)
+          []
+        end
+
+        def extract_json(text)
+          # Try to extract JSON from code fences or find JSON object
+          # Avoid regex to prevent ReDoS - use simple string operations
+          return text if text.start_with?("{") && text.end_with?("}")
+
+          # Extract from code fence using string operations
+          fence_start = text.index("```json")
+          if fence_start
+            json_start = text.index("{", fence_start)
+            fence_end = text.index("```", fence_start + 7)
+            if json_start && fence_end && json_start < fence_end
+              json_end = text.rindex("}", fence_end - 1)
+              return text[json_start..json_end] if json_end && json_end > json_start
+            end
+          end
+
+          # Find JSON object using string operations
+          first_brace = text.index("{")
+          last_brace = text.rindex("}")
+          if first_brace && last_brace && last_brace > first_brace
+            text[first_brace..last_brace]
+          else
+            text
+          end
+        end
+
+        def build_review_prompt(pr_data:, files:, diff:)
+          <<~PROMPT
+            Review this pull request from your expertise perspective:
+
+            **PR ##{pr_data[:number]}: #{pr_data[:title]}**
+
+            #{pr_data[:body]}
+
+            **Changed Files (#{files.length}):**
+            #{files.map { |f| "- #{f[:filename]} (+#{f[:additions]}/-#{f[:deletions]})" }.join("\n")}
+
+            **Diff:**
+            ```diff
+            #{truncate_diff(diff, max_lines: 500)}
+            ```
+
+            Please review the changes and provide your findings in JSON format.
+          PROMPT
+        end
+
+        def truncate_diff(diff, max_lines: 500)
+          lines = diff.lines
+          if lines.length > max_lines
+            lines.first(max_lines).join + "\n... (diff truncated, #{lines.length - max_lines} more lines)"
+          else
+            diff
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/performance_reviewer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Performance Reviewer - focuses on performance issues and optimizations
+      class PerformanceReviewer < BaseReviewer
+        PERSONA_NAME = "Performance Analyst"
+        FOCUS_AREAS = [
+          "Algorithm complexity (O(n) vs O(n²), etc.)",
+          "Database query optimization (N+1 queries, missing indexes)",
+          "Memory allocation and garbage collection pressure",
+          "Blocking I/O operations",
+          "Inefficient data structures",
+          "Unnecessary computations or redundant work",
+          "Caching opportunities",
+          "Resource leaks (connections, file handles, etc.)",
+          "Concurrent access patterns",
+          "Network round-trips and latency"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_performance_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+
+        private
+
+        def build_performance_prompt(pr_data:, files:, diff:)
+          base_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+
+          <<~PROMPT
+            #{base_prompt}
+
+            **Additional Performance Focus:**
+            Pay special attention to:
+            1. Loop complexity and nested iterations
+            2. Database queries (look for N+1 patterns, missing eager loading)
+            3. Memory allocations in hot paths
+            4. I/O operations (file, network, database) - are they batched?
+            5. Synchronous operations that could be asynchronous
+            6. Large data structures being copied or traversed repeatedly
+            7. Missing caching opportunities
+            8. Resource pooling and connection management
+            9. Lazy loading vs eager loading trade-offs
+            10. Potential bottlenecks under high load
+
+            Mark performance issues as:
+            - "high" if they could cause timeouts, out-of-memory errors, or severe degradation
+            - "major" if they significantly impact response time or resource usage
+            - "minor" for optimizations that would improve efficiency
+            - "nit" for micro-optimizations with negligible impact
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/security_reviewer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Security Reviewer - focuses on security vulnerabilities and risks
+      class SecurityReviewer < BaseReviewer
+        PERSONA_NAME = "Security Specialist"
+        FOCUS_AREAS = [
+          "Injection vulnerabilities (SQL, command, XSS, etc.)",
+          "Authentication and authorization flaws",
+          "Sensitive data exposure",
+          "Insecure deserialization",
+          "Security misconfiguration",
+          "Insufficient logging and monitoring",
+          "Insecure dependencies",
+          "Secrets and credentials in code",
+          "Input validation and sanitization",
+          "OWASP Top 10 vulnerabilities"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_security_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+
+        private
+
+        def build_security_prompt(pr_data:, files:, diff:)
+          base_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+
+          <<~PROMPT
+            #{base_prompt}
+
+            **Additional Security Focus:**
+            Pay special attention to:
+            1. User input handling and validation
+            2. Database queries and potential SQL injection
+            3. File operations and path traversal risks
+            4. Authentication and session management
+            5. Cryptographic operations and key management
+            6. API endpoints and their access controls
+            7. Third-party dependencies and their security posture
+            8. Environment variables and configuration
+            9. Logging of sensitive information
+            10. Command execution and shell injection risks
+
+            Mark any security issues as "high" severity if they could lead to:
+            - Unauthorized access or privilege escalation
+            - Data breach or exposure of sensitive information
+            - Remote code execution
+            - Denial of service
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/senior_dev_reviewer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Senior Developer Reviewer - focuses on correctness, architecture, and best practices
+      class SeniorDevReviewer < BaseReviewer
+        PERSONA_NAME = "Senior Developer"
+        FOCUS_AREAS = [
+          "Code correctness and logic errors",
+          "Architecture and design patterns",
+          "API design and consistency",
+          "Error handling and edge cases",
+          "Code maintainability and readability",
+          "Testing coverage and quality",
+          "Documentation completeness"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/runner.rb

@@ -9,6 +9,9 @@ require_relative "state_store"
 require_relative "plan_generator"
 require_relative "plan_processor"
 require_relative "build_processor"
+require_relative "../auto_update"
+require_relative "review_processor"
+require_relative "ci_fix_processor"
 
 module Aidp
   module Watch
@@ -26,6 +29,8 @@ module Aidp
         @project_dir = project_dir
         @force = force
         @verbose = verbose
+        @provider_name = provider_name
+        @safety_config = safety_config
 
         owner, repo = RepositoryClient.parse_issues_url(issues_url)
         @repository_client = RepositoryClient.new(owner: owner, repo: repo, gh_available: gh_available)
@@ -52,9 +57,32 @@ module Aidp
           verbose: verbose,
           label_config: label_config
         )
+
+        # Initialize auto-update coordinator
+        @auto_update_coordinator = Aidp::AutoUpdate.coordinator(project_dir: project_dir)
+        @last_update_check = nil
+        @review_processor = ReviewProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          provider_name: provider_name,
+          project_dir: project_dir,
+          label_config: label_config,
+          verbose: verbose
+        )
+        @ci_fix_processor = CiFixProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          provider_name: provider_name,
+          project_dir: project_dir,
+          label_config: label_config,
+          verbose: verbose
+        )
       end
 
       def start
+        # Check for and restore from checkpoint (after auto-update)
+        restore_from_checkpoint_if_exists
+
         # Validate safety requirements before starting
         @safety_checker.validate_watch_mode_safety!(force: @force)
 
@@ -91,6 +119,9 @@ module Aidp
       def process_cycle
         process_plan_triggers
         process_build_triggers
+        check_for_updates_if_due
+        process_review_triggers
+        process_ci_fix_triggers
       end
 
       def process_plan_triggers
@@ -149,12 +180,166 @@ module Aidp
         end
       end
 
+      def process_review_triggers
+        review_label = @review_processor.review_label
+        prs = @repository_client.list_pull_requests(labels: [review_label], state: "open")
+        Aidp.log_debug("watch_runner", "review_poll", label: review_label, total: prs.size)
+        prs.each do |pr|
+          unless pr_has_label?(pr, review_label)
+            Aidp.log_debug("watch_runner", "review_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "review_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          Aidp.log_debug("watch_runner", "review_process", pr: detailed[:number])
+          @review_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized PR author", pr: pr[:number], error: e.message)
+        end
+      end
+
+      def process_ci_fix_triggers
+        ci_fix_label = @ci_fix_processor.ci_fix_label
+        prs = @repository_client.list_pull_requests(labels: [ci_fix_label], state: "open")
+        Aidp.log_debug("watch_runner", "ci_fix_poll", label: ci_fix_label, total: prs.size)
+        prs.each do |pr|
+          unless pr_has_label?(pr, ci_fix_label)
+            Aidp.log_debug("watch_runner", "ci_fix_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "ci_fix_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          Aidp.log_debug("watch_runner", "ci_fix_process", pr: detailed[:number])
+          @ci_fix_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized PR author", pr: pr[:number], error: e.message)
+        end
+      end
+
       def issue_has_label?(issue, label)
         Array(issue[:labels]).any? do |issue_label|
           name = issue_label.is_a?(Hash) ? issue_label["name"] : issue_label.to_s
           name.casecmp(label).zero?
         end
       end
+
+      # Restore from checkpoint if one exists (after auto-update)
+      def restore_from_checkpoint_if_exists
+        return unless @auto_update_coordinator.policy.enabled
+
+        checkpoint = @auto_update_coordinator.restore_from_checkpoint
+        return unless checkpoint
+
+        # Checkpoint exists and was successfully restored
+        display_message("✨ Restored from checkpoint after update to v#{Aidp::VERSION}", type: :success)
+
+        # Override instance variables with checkpoint state
+        if checkpoint.watch_mode? && checkpoint.watch_state
+          @interval = checkpoint.watch_state[:interval] || @interval
+          Aidp.log_info("watch_runner", "checkpoint_restored",
+            checkpoint_id: checkpoint.checkpoint_id,
+            interval: @interval)
+        end
+      rescue => e
+        # Log but don't fail - continue with fresh start
+        Aidp.log_error("watch_runner", "checkpoint_restore_failed",
+          error: e.message)
+        display_message("⚠️  Checkpoint restore failed, starting fresh: #{e.message}", type: :warning)
+      end
+
+      # Check for updates at appropriate intervals
+      def check_for_updates_if_due
+        return unless @auto_update_coordinator.policy.enabled
+        return unless time_for_update_check?
+
+        update_check = @auto_update_coordinator.check_for_update
+
+        if update_check.should_update?
+          display_message("🔄 Update available: #{update_check.current_version} → #{update_check.available_version}", type: :highlight)
+          display_message("   Saving checkpoint and initiating update...", type: :muted)
+
+          initiate_update(update_check)
+          # Never returns - exits with code 75
+        end
+      rescue Aidp::AutoUpdate::UpdateLoopError => e
+        # Restart loop detected - disable auto-update
+        display_message("⚠️  Auto-update disabled: #{e.message}", type: :error)
+        Aidp.log_error("watch_runner", "update_loop_detected", error: e.message)
+      rescue Aidp::AutoUpdate::UpdateError => e
+        # Non-fatal update error - log and continue
+        Aidp.log_error("watch_runner", "update_check_failed", error: e.message)
+      end
+
+      # Determine if it's time to check for updates
+      # @return [Boolean]
+      def time_for_update_check?
+        return true if @last_update_check.nil?
+
+        elapsed = Time.now - @last_update_check
+        elapsed >= @auto_update_coordinator.policy.check_interval_seconds
+      end
+
+      # Initiate update process: capture state, create checkpoint, exit
+      # @param update_check [Aidp::AutoUpdate::UpdateCheck] Update check result
+      def initiate_update(update_check)
+        current_state = capture_current_state
+
+        # This will exit with code 75 if successful
+        @auto_update_coordinator.initiate_update(current_state)
+      end
+
+      # Capture current watch mode state for checkpoint
+      # @return [Hash] Current state
+      def capture_current_state
+        {
+          mode: "watch",
+          watch_state: {
+            repository: @repository_client.full_repo,
+            interval: @interval,
+            provider_name: @provider_name,
+            persona: nil,
+            safety_config: @safety_config,
+            worktree_context: capture_worktree_context,
+            state_store_snapshot: @state_store.send(:state).dup
+          }
+        }
+      end
+
+      # Capture git worktree context
+      # @return [Hash] Worktree information
+      def capture_worktree_context
+        return {} unless system("git rev-parse --git-dir > /dev/null 2>&1")
+
+        {
+          branch: `git rev-parse --abbrev-ref HEAD`.strip,
+          commit_sha: `git rev-parse HEAD`.strip,
+          remote_url: `git config --get remote.origin.url`.strip
+        }
+      rescue => e
+        Aidp.log_debug("watch_runner", "worktree_context_unavailable", error: e.message)
+        {}
+      end
+
+      def pr_has_label?(pr, label)
+        Array(pr[:labels]).any? do |pr_label|
+          name = pr_label.is_a?(Hash) ? pr_label["name"] : pr_label.to_s
+          name.casecmp(label).zero?
+        end
+      end
     end
   end
 end

data/lib/aidp/watch/state_store.rb

@@ -53,6 +53,49 @@ module Aidp
         save!
       end
 
+      # Review tracking methods
+      def review_processed?(pr_number)
+        reviews.key?(pr_number.to_s)
+      end
+
+      def review_data(pr_number)
+        reviews[pr_number.to_s]
+      end
+
+      def record_review(pr_number, data)
+        payload = {
+          "timestamp" => data[:timestamp] || Time.now.utc.iso8601,
+          "reviewers" => data[:reviewers],
+          "total_findings" => data[:total_findings]
+        }.compact
+
+        reviews[pr_number.to_s] = payload
+        save!
+      end
+
+      # CI fix tracking methods
+      def ci_fix_completed?(pr_number)
+        fix_data = ci_fixes[pr_number.to_s]
+        fix_data && fix_data["status"] == "completed"
+      end
+
+      def ci_fix_data(pr_number)
+        ci_fixes[pr_number.to_s]
+      end
+
+      def record_ci_fix(pr_number, data)
+        payload = {
+          "status" => data[:status],
+          "timestamp" => data[:timestamp] || Time.now.utc.iso8601,
+          "reason" => data[:reason],
+          "root_causes" => data[:root_causes],
+          "fixes_count" => data[:fixes_count]
+        }.compact
+
+        ci_fixes[pr_number.to_s] = payload
+        save!
+      end
+
       private
 
       def ensure_directory
@@ -81,6 +124,8 @@ module Aidp
           base = load_state
           base["plans"] ||= {}
           base["builds"] ||= {}
+          base["reviews"] ||= {}
+          base["ci_fixes"] ||= {}
           base
         end
       end
@@ -93,6 +138,14 @@ module Aidp
         state["builds"]
       end
 
+      def reviews
+        state["reviews"]
+      end
+
+      def ci_fixes
+        state["ci_fixes"]
+      end
+
       def stringify_keys(hash)
         return {} unless hash
 

data/lib/aidp.rb

@@ -26,6 +26,7 @@ require_relative "aidp/providers/base"
 require_relative "aidp/providers/cursor"
 require_relative "aidp/providers/anthropic"
 require_relative "aidp/providers/gemini"
+require_relative "aidp/providers/kilocode"
 # Supervised providers removed - using direct execution model
 require_relative "aidp/provider_manager"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -244,6 +244,18 @@ files:
 - lib/aidp/analyze/steps.rb
 - lib/aidp/analyze/tree_sitter_grammar_loader.rb
 - lib/aidp/analyze/tree_sitter_scan.rb
+- lib/aidp/auto_update.rb
+- lib/aidp/auto_update/bundler_adapter.rb
+- lib/aidp/auto_update/checkpoint.rb
+- lib/aidp/auto_update/checkpoint_store.rb
+- lib/aidp/auto_update/coordinator.rb
+- lib/aidp/auto_update/errors.rb
+- lib/aidp/auto_update/failure_tracker.rb
+- lib/aidp/auto_update/rubygems_api_adapter.rb
+- lib/aidp/auto_update/update_check.rb
+- lib/aidp/auto_update/update_logger.rb
+- lib/aidp/auto_update/update_policy.rb
+- lib/aidp/auto_update/version_detector.rb
 - lib/aidp/cli.rb
 - lib/aidp/cli/devcontainer_commands.rb
 - lib/aidp/cli/enhanced_input.rb
@@ -357,6 +369,7 @@ files:
 - lib/aidp/providers/error_taxonomy.rb
 - lib/aidp/providers/gemini.rb
 - lib/aidp/providers/github_copilot.rb
+- lib/aidp/providers/kilocode.rb
 - lib/aidp/providers/opencode.rb
 - lib/aidp/rescue_logging.rb
 - lib/aidp/safe_directory.rb
@@ -387,10 +400,16 @@ files:
 - lib/aidp/version.rb
 - lib/aidp/watch.rb
 - lib/aidp/watch/build_processor.rb
+- lib/aidp/watch/ci_fix_processor.rb
 - lib/aidp/watch/plan_generator.rb
 - lib/aidp/watch/plan_processor.rb
 - lib/aidp/watch/repository_client.rb
 - lib/aidp/watch/repository_safety_checker.rb
+- lib/aidp/watch/review_processor.rb
+- lib/aidp/watch/reviewers/base_reviewer.rb
+- lib/aidp/watch/reviewers/performance_reviewer.rb
+- lib/aidp/watch/reviewers/security_reviewer.rb
+- lib/aidp/watch/reviewers/senior_dev_reviewer.rb
 - lib/aidp/watch/runner.rb
 - lib/aidp/watch/state_store.rb
 - lib/aidp/workflows/definitions.rb