aidp 0.32.0 → 0.33.0

data/lib/aidp/auto_update/coordinator.rb

@@ -1,12 +1,5 @@
 # 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
@@ -188,8 +181,105 @@ module Aidp
         }
       end
 
+      # Perform hot code reload without restarting the process
+      #
+      # This method performs a git pull and then uses Zeitwerk to reload
+      # all Ruby classes. Unlike initiate_update (which exits with code 75),
+      # this method keeps the process running.
+      #
+      # @param update_check [UpdateCheck] Update check result
+      # @return [Boolean] Whether reload was successful
+      # @raise [UpdateError] If updates are disabled or reload fails
+      def hot_reload_update(update_check = nil)
+        raise UpdateError, "Updates disabled by configuration" unless @policy.enabled
+
+        # Verify Zeitwerk loader is set up for reloading
+        unless Aidp::Loader.setup? && Aidp::Loader.reloading?
+          Aidp.log_warn("auto_update_coordinator", "hot_reload_not_available",
+            reason: "Zeitwerk loader not configured for reloading")
+          raise UpdateError, "Hot reloading not available. Loader must be configured with enable_reloading: true"
+        end
+
+        update_check ||= check_for_update
+        return false unless update_check.should_update?
+
+        from_version = update_check.current_version
+        to_version = update_check.available_version
+
+        Aidp.log_info("auto_update_coordinator", "hot_reload_starting",
+          from_version: from_version,
+          to_version: to_version)
+
+        # Perform git pull
+        unless perform_git_pull
+          raise UpdateError, "Git pull failed"
+        end
+
+        # Reload all classes using Zeitwerk
+        unless Aidp::Loader.reload!
+          @failure_tracker.record_failure
+          @update_logger.log_failure("Zeitwerk reload failed")
+          raise UpdateError, "Zeitwerk reload failed"
+        end
+
+        # Log success
+        @update_logger.log_success(
+          from_version: from_version,
+          to_version: to_version
+        )
+        @failure_tracker.reset_on_success
+
+        Aidp.log_info("auto_update_coordinator", "hot_reload_complete",
+          from_version: from_version,
+          to_version: to_version)
+
+        true
+      rescue UpdateError
+        raise
+      rescue => e
+        @failure_tracker.record_failure
+        @update_logger.log_failure("Hot reload failed: #{e.message}")
+        Aidp.log_error("auto_update_coordinator", "hot_reload_failed",
+          error: e.message)
+        raise UpdateError, "Hot reload failed: #{e.message}"
+      end
+
+      # Check if hot reloading is available
+      # @return [Boolean]
+      def hot_reload_available?
+        Aidp::Loader.setup? && Aidp::Loader.reloading?
+      end
+
       private
 
+      # Perform git pull to fetch latest code
+      # @return [Boolean] Whether pull was successful
+      def perform_git_pull
+        require "open3"
+
+        Aidp.log_debug("auto_update_coordinator", "git_pull_starting",
+          project_dir: @project_dir)
+
+        Dir.chdir(@project_dir) do
+          stdout, stderr, status = Open3.capture3("git", "pull", "--ff-only")
+
+          if status.success?
+            Aidp.log_info("auto_update_coordinator", "git_pull_success",
+              output: stdout.strip)
+            true
+          else
+            Aidp.log_error("auto_update_coordinator", "git_pull_failed",
+              stderr: stderr.strip,
+              exit_code: status.exitstatus)
+            false
+          end
+        end
+      rescue => e
+        Aidp.log_error("auto_update_coordinator", "git_pull_error",
+          error: e.message)
+        false
+      end
+
       def build_checkpoint(current_state, target_version)
         Checkpoint.new(
           mode: current_state[:mode] || "watch",

data/lib/aidp/auto_update.rb

@@ -1,17 +1,5 @@
 # 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

data/lib/aidp/cli/devcontainer_commands.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../setup/devcontainer/parser"
-require_relative "../setup/devcontainer/generator"
-require_relative "../setup/devcontainer/port_manager"
-require_relative "../setup/devcontainer/backup_manager"
-require_relative "../message_display"
 require "json"
 require "yaml"
 

data/lib/aidp/cli.rb

@@ -8,6 +8,7 @@ require_relative "harness/ui/enhanced_tui"
 require_relative "harness/ui/enhanced_workflow_selector"
 require_relative "harness/enhanced_runner"
 require_relative "cli/first_run_wizard"
+require_relative "cli/issue_importer"
 require_relative "rescue_logging"
 require_relative "concurrency"
 
@@ -669,7 +670,7 @@ module Aidp
             return
           end
 
-          importer = IssueImporter.new
+          importer = Aidp::IssueImporter.new
           issue_data = importer.import_issue(identifier)
 
           if issue_data

data/lib/aidp/comment_consolidator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Consolidates comments for GitHub issues and PRs by category
+  class CommentConsolidator
+    CATEGORY_HEADERS = {
+      progress: "## 🔄 Progress Report",
+      exceptions: "## 🚨 Exceptions and Errors",
+      completion: "## ✅ Completion Summary"
+    }
+
+    # @param repository_client [Aidp::Watch::RepositoryClient] GitHub repository client
+    # @param number [Integer] Issue or PR number
+    def initialize(repository_client:, number:)
+      @client = repository_client
+      @number = number
+    end
+
+    # Search for an existing comment by its category header
+    # @param category [Symbol] Comment category (:progress, :exceptions, :completion)
+    # @return [Hash, nil] Existing comment or nil if not found
+    def find_category_comment(category)
+      Aidp.log_debug("comment_consolidator", "searching_category_comment",
+        number: @number, category: category)
+
+      header = CATEGORY_HEADERS[category]
+      raise ArgumentError, "Invalid category: #{category}" unless header
+
+      comment = @client.find_comment(@number, header)
+      Aidp.log_debug("comment_consolidator", "find_category_comment_result",
+        found: !comment.nil?)
+      comment
+    end
+
+    # Update an existing category comment or create a new one
+    # @param category [Symbol] Comment category (:progress, :exceptions, :completion)
+    # @param new_content [String] New content to add to the comment
+    # @param append [Boolean] Whether to append or replace existing content
+    # @return [String] Result of comment operation (comment ID or response body)
+    def consolidate_comment(category:, new_content:, append: true)
+      Aidp.log_debug("comment_consolidator", "consolidating_comment", number: @number, category: category, append: append)
+
+      header = CATEGORY_HEADERS[category]
+      raise ArgumentError, "Invalid category: #{category}" unless header
+
+      existing_comment = find_category_comment(category)
+
+      content = if existing_comment && append
+        # Append new content with timestamp
+        existing_body = existing_comment[:body]
+        updated_body = if existing_body.include?(header)
+          existing_body.lines.first(1).join +
+            "### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" +
+            new_content + "\n\n" +
+            existing_body.lines[1..]&.join
+        else
+          # Reconstruct comment if header is missing
+          "#{header}\n\n### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" +
+            new_content + "\n\n" +
+            existing_body
+        end
+        updated_body
+      else
+        # Create new or replace content
+        "#{header}\n\n### #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n" + new_content
+      end
+
+      # Update or create comment
+      if existing_comment
+        Aidp.log_debug("comment_consolidator", "updating_existing_comment", comment_id: existing_comment[:id])
+        @client.update_comment(existing_comment[:id], content)
+      else
+        Aidp.log_debug("comment_consolidator", "creating_new_comment")
+        @client.post_comment(@number, content)
+      end
+    end
+  end
+end

data/lib/aidp/concurrency.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent-ruby"
-require_relative "concurrency/wait"
-require_relative "concurrency/backoff"
-require_relative "concurrency/exec"
 
 module Aidp
   # Concurrency utilities for deterministic waiting, retry/backoff, and executor management.

data/lib/aidp/config.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "yaml"
-require_relative "config/paths"
 
 module Aidp
   # Configuration management for both execute and analyze modes

data/lib/aidp/config_paths.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  # Centralized path management for all AIDP internal files
+  # Ensures consistent file locations and prevents path-related bugs
+  module ConfigPaths
+    def self.aidp_dir(project_dir = Dir.pwd) = File.join(project_dir, ".aidp")
+    def self.config_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "aidp.yml")
+    def self.config_dir(project_dir = Dir.pwd) = aidp_dir(project_dir)
+    def self.progress_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "progress")
+    def self.execute_progress_file(project_dir = Dir.pwd) = File.join(progress_dir(project_dir), "execute.yml")
+    def self.analyze_progress_file(project_dir = Dir.pwd) = File.join(progress_dir(project_dir), "analyze.yml")
+    def self.harness_state_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "harness")
+    def self.harness_state_file(mode, project_dir = Dir.pwd) = File.join(harness_state_dir(project_dir), "#{mode}_state.json")
+    def self.providers_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "providers")
+    def self.provider_info_file(provider_name, project_dir = Dir.pwd) = File.join(providers_dir(project_dir), "#{provider_name}_info.yml")
+    def self.jobs_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "jobs")
+    def self.checkpoint_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "checkpoint.yml")
+    def self.checkpoint_history_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "checkpoint_history.jsonl")
+    def self.json_storage_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "json")
+    def self.model_cache_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "model_cache")
+    def self.work_loop_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "work_loop")
+    def self.logs_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "logs")
+
+    def self.config_exists?(project_dir = Dir.pwd)
+      File.exist?(config_file(project_dir))
+    end
+
+    def self.ensure_aidp_dir(project_dir = Dir.pwd)
+      dir = aidp_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_config_dir(project_dir = Dir.pwd)
+      ensure_aidp_dir(project_dir)
+    end
+
+    def self.ensure_progress_dir(project_dir = Dir.pwd)
+      dir = progress_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_harness_state_dir(project_dir = Dir.pwd)
+      dir = harness_state_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_providers_dir(project_dir = Dir.pwd)
+      dir = providers_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_jobs_dir(project_dir = Dir.pwd)
+      dir = jobs_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    def self.ensure_json_storage_dir(project_dir = Dir.pwd)
+      dir = json_storage_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+  end
+end