aidp 0.34.0 → 0.39.3

data/lib/aidp/interfaces/ui_interface.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Interfaces
+    # UiInterface defines the contract for user interface operations.
+    # This interface abstracts TTY-based UI components for extraction
+    # into the agent-harness gem, allowing different UI implementations.
+    #
+    # The interface covers two main areas:
+    # 1. Message display - showing status messages to users
+    # 2. Spinner/progress - showing activity indicators
+    #
+    # @example Implementing the interface
+    #   class MyUI
+    #     include Aidp::Interfaces::UiInterface
+    #
+    #     def say(message, type: :info)
+    #       puts "[#{type.upcase}] #{message}"
+    #     end
+    #
+    #     def with_spinner(title:, &block)
+    #       puts "Starting: #{title}"
+    #       result = yield
+    #       puts "Done: #{title}"
+    #       result
+    #     end
+    #   end
+    #
+    # @example Using an injected UI
+    #   class Provider
+    #     def initialize(ui: NullUI.new)
+    #       @ui = ui
+    #     end
+    #
+    #     def process
+    #       @ui.say("Starting process", type: :info)
+    #       @ui.with_spinner(title: "Processing") do
+    #         # do work
+    #       end
+    #     end
+    #   end
+    #
+    module UiInterface
+      # Message types for display_message
+      MESSAGE_TYPES = [:info, :success, :warning, :error, :highlight, :muted].freeze
+
+      # Display a message to the user.
+      #
+      # @param message [String] the message to display
+      # @param type [Symbol] one of MESSAGE_TYPES (:info, :success, :warning, :error, :highlight, :muted)
+      # @return [void]
+      def say(message, type: :info)
+        raise NotImplementedError, "#{self.class} must implement #say"
+      end
+
+      # Execute a block with a spinner indicator.
+      #
+      # @param title [String] the spinner title
+      # @yield the block to execute
+      # @return [Object] the result of the block
+      def with_spinner(title:)
+        raise NotImplementedError, "#{self.class} must implement #with_spinner"
+      end
+
+      # Create a spinner for manual control.
+      # Returns an object that responds to :auto_spin, :success, :error, and :update_title
+      #
+      # @param title [String] initial spinner title
+      # @return [SpinnerInterface] a spinner object
+      def spinner(title:)
+        raise NotImplementedError, "#{self.class} must implement #spinner"
+      end
+
+      # Check if we're in quiet mode (suppress non-critical messages).
+      #
+      # @return [Boolean] true if non-critical messages should be suppressed
+      def quiet?
+        false
+      end
+    end
+
+    # SpinnerInterface defines the contract for spinner objects.
+    module SpinnerInterface
+      # Start the spinner animation.
+      # @return [void]
+      def auto_spin
+        raise NotImplementedError, "#{self.class} must implement #auto_spin"
+      end
+
+      # Stop the spinner with a success indicator.
+      # @param message [String, nil] optional success message
+      # @return [void]
+      def success(message = nil)
+        raise NotImplementedError, "#{self.class} must implement #success"
+      end
+
+      # Stop the spinner with an error indicator.
+      # @param message [String, nil] optional error message
+      # @return [void]
+      def error(message = nil)
+        raise NotImplementedError, "#{self.class} must implement #error"
+      end
+
+      # Update the spinner title.
+      # @param title [String] new title
+      # @return [void]
+      def update_title(title)
+        raise NotImplementedError, "#{self.class} must implement #update_title"
+      end
+    end
+
+    # NullUI is a no-op implementation.
+    # Useful for testing or non-interactive environments.
+    #
+    class NullUI
+      include UiInterface
+
+      def say(message, type: :info)
+        # no-op
+      end
+
+      def with_spinner(title:)
+        yield
+      end
+
+      def spinner(title:)
+        NullSpinner.new
+      end
+
+      def quiet?
+        true
+      end
+    end
+
+    # NullSpinner is a no-op spinner implementation.
+    #
+    class NullSpinner
+      include SpinnerInterface
+
+      def auto_spin
+        # no-op
+      end
+
+      def success(message = nil)
+        # no-op
+      end
+
+      def error(message = nil)
+        # no-op
+      end
+
+      def update_title(title)
+        # no-op
+      end
+    end
+
+    # TtyUI wraps TTY::Prompt and TTY::Spinner for UI operations.
+    # This is the standard implementation used by AIDP.
+    #
+    # @example Creating a TtyUI
+    #   ui = TtyUI.new
+    #   ui.say("Hello", type: :success)
+    #   ui.with_spinner(title: "Working") { sleep(1) }
+    #
+    class TtyUI
+      include UiInterface
+
+      COLOR_MAP = {
+        info: :blue,
+        success: :green,
+        warning: :yellow,
+        error: :red,
+        highlight: :cyan,
+        muted: :bright_black
+      }.freeze
+
+      CRITICAL_TYPES = [:error, :warning, :success].freeze
+
+      # @param prompt [TTY::Prompt, nil] optional pre-configured prompt
+      # @param quiet [Boolean] whether to suppress non-critical messages
+      def initialize(prompt: nil, quiet: false)
+        @prompt = prompt
+        @quiet = quiet
+      end
+
+      def say(message, type: :info)
+        return if @quiet && !CRITICAL_TYPES.include?(type)
+
+        prompt.say(message.to_s, color: COLOR_MAP.fetch(type, :white))
+      end
+
+      def with_spinner(title:)
+        require "tty-spinner"
+        spin = TTY::Spinner.new("[:spinner] #{title}", format: :dots, hide_cursor: true)
+        spin.auto_spin
+
+        begin
+          result = yield
+          spin.success("done")
+          result
+        rescue
+          spin.error("failed")
+          raise
+        end
+      end
+
+      def spinner(title:)
+        require "tty-spinner"
+        TtySpinnerWrapper.new(title: title)
+      end
+
+      def quiet?
+        @quiet
+      end
+
+      private
+
+      def prompt
+        @prompt ||= begin
+          require "tty-prompt"
+          TTY::Prompt.new
+        end
+      end
+    end
+
+    # TtySpinnerWrapper wraps TTY::Spinner to implement SpinnerInterface.
+    #
+    class TtySpinnerWrapper
+      include SpinnerInterface
+
+      def initialize(title:)
+        require "tty-spinner"
+        @spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
+        @spinner.update(title: title)
+      end
+
+      def auto_spin
+        @spinner.auto_spin
+      end
+
+      def success(message = nil)
+        @spinner.success(message || "done")
+      end
+
+      def error(message = nil)
+        @spinner.error(message || "failed")
+      end
+
+      def update_title(title)
+        @spinner.update(title: title)
+      end
+    end
+  end
+end

data/lib/aidp/logger.rb

@@ -121,13 +121,7 @@ module Aidp
     end
 
     def debug_env_enabled?
-      raw = ENV["AIDP_DEBUG"] || ENV["DEBUG"]
-      return false if raw.nil?
-
-      normalized = raw.to_s.strip.downcase
-      return true if %w[true on yes debug].include?(normalized)
-
-      /\A\d+\z/.match?(normalized) ? normalized.to_i.positive? : false
+      Aidp.debug_env_enabled?
     end
 
     def should_log?(level)
@@ -320,6 +314,30 @@ module Aidp
       @logger ||= Logger.new
     end
 
+    def debug_env_value
+      ENV["AIDP_DEBUG"] || ENV["DEBUG"]
+    end
+
+    def debug_env_enabled?
+      raw = debug_env_value
+      return false if raw.nil?
+
+      normalized = raw.to_s.strip.downcase
+      return true if %w[true on yes debug].include?(normalized)
+
+      /\A\d+\z/.match?(normalized) ? normalized.to_i.positive? : false
+    end
+
+    def debug_env_level
+      raw = debug_env_value
+      return 0 if raw.nil?
+
+      normalized = raw.to_s.strip.downcase
+      return 1 if %w[true on yes debug].include?(normalized)
+
+      /\A\d+\z/.match?(normalized) ? normalized.to_i : 0
+    end
+
     # Convenience logging methods
     def log_info(component, message, **metadata)
       logger.info(component, message, **metadata)

data/lib/aidp/orchestration_adapter.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Adapter for orchestration execution
+  # Routes to Temporal-based or legacy orchestration based on configuration
+  #
+  # When Temporal is enabled:
+  # - Workflows execute through Temporal for durability and observability
+  # - Activities wrap existing AIDP functionality
+  # - State is persisted in Temporal's history
+  #
+  # When Temporal is disabled (legacy mode):
+  # - Falls back to existing AsyncWorkLoopRunner and BackgroundRunner
+  # - State is tracked in file-based storage
+  #
+  # Migration strategy:
+  # 1. Enable Temporal in aidp.yml
+  # 2. Start Temporal worker: `aidp temporal worker`
+  # 3. Use `aidp temporal start` for new workflows
+  # 4. Existing jobs continue until complete
+  class OrchestrationAdapter
+    include Aidp::MessageDisplay
+
+    def initialize(project_dir: Dir.pwd)
+      @project_dir = project_dir
+    end
+
+    # Check if Temporal orchestration is enabled
+    def temporal_enabled?
+      return @temporal_enabled if defined?(@temporal_enabled)
+
+      begin
+        require_relative "temporal"
+        @temporal_enabled = Aidp::Temporal.enabled?(@project_dir)
+      rescue LoadError
+        @temporal_enabled = false
+      end
+
+      @temporal_enabled
+    end
+
+    # Start an issue-to-PR workflow
+    # Routes to Temporal or legacy based on configuration
+    def start_issue_workflow(issue_number, options = {})
+      if temporal_enabled?
+        start_temporal_issue_workflow(issue_number, options)
+      else
+        start_legacy_issue_workflow(issue_number, options)
+      end
+    end
+
+    # Start a work loop
+    # Routes to Temporal or legacy based on configuration
+    def start_work_loop(step_name, step_spec, context = {}, options = {})
+      if temporal_enabled?
+        start_temporal_work_loop(step_name, step_spec, context, options)
+      else
+        start_legacy_work_loop(step_name, step_spec, context, options)
+      end
+    end
+
+    # Get workflow status
+    def workflow_status(workflow_id)
+      if temporal_enabled?
+        temporal_workflow_status(workflow_id)
+      else
+        legacy_job_status(workflow_id)
+      end
+    end
+
+    # Cancel a workflow
+    def cancel_workflow(workflow_id)
+      if temporal_enabled?
+        cancel_temporal_workflow(workflow_id)
+      else
+        cancel_legacy_job(workflow_id)
+      end
+    end
+
+    # List active workflows
+    def list_workflows
+      if temporal_enabled?
+        list_temporal_workflows
+      else
+        list_legacy_jobs
+      end
+    end
+
+    private
+
+    # Temporal-based implementations
+    def start_temporal_issue_workflow(issue_number, options)
+      Aidp.log_info("orchestration_adapter", "starting_temporal_issue_workflow",
+        issue_number: issue_number)
+
+      input = {
+        project_dir: @project_dir,
+        issue_number: issue_number.to_i,
+        max_iterations: options[:max_iterations] || 50,
+        options: options
+      }
+
+      handle = Aidp::Temporal.start_workflow(
+        Aidp::Temporal::Workflows::IssueToPrWorkflow,
+        input,
+        project_dir: @project_dir,
+        **extract_temporal_options(options)
+      )
+
+      {
+        type: :temporal,
+        workflow_id: handle.id,
+        issue_number: issue_number,
+        status: "started"
+      }
+    end
+
+    def start_temporal_work_loop(step_name, step_spec, context, options)
+      Aidp.log_info("orchestration_adapter", "starting_temporal_work_loop",
+        step_name: step_name)
+
+      input = {
+        project_dir: @project_dir,
+        step_name: step_name,
+        step_spec: step_spec,
+        context: context,
+        max_iterations: options[:max_iterations] || 50
+      }
+
+      handle = Aidp::Temporal.start_workflow(
+        Aidp::Temporal::Workflows::WorkLoopWorkflow,
+        input,
+        project_dir: @project_dir,
+        **extract_temporal_options(options)
+      )
+
+      {
+        type: :temporal,
+        workflow_id: handle.id,
+        step_name: step_name,
+        status: "started"
+      }
+    end
+
+    def temporal_workflow_status(workflow_id)
+      desc = Aidp::Temporal.workflow_status(workflow_id, project_dir: @project_dir)
+
+      {
+        type: :temporal,
+        workflow_id: workflow_id,
+        status: desc.status.to_s,
+        workflow_type: desc.workflow_type,
+        start_time: desc.start_time,
+        close_time: desc.close_time
+      }
+    rescue Temporalio::Error::RPCError => e
+      if e.code == Temporalio::Error::RPCError::Code::NOT_FOUND
+        {type: :temporal, workflow_id: workflow_id, status: "not_found"}
+      else
+        raise
+      end
+    end
+
+    def cancel_temporal_workflow(workflow_id)
+      Aidp::Temporal.cancel_workflow(workflow_id, project_dir: @project_dir)
+      {type: :temporal, workflow_id: workflow_id, status: "canceled"}
+    end
+
+    def list_temporal_workflows
+      client = Aidp::Temporal.workflow_client(@project_dir)
+      workflows = client.list_workflows
+
+      workflows.map do |wf|
+        {
+          type: :temporal,
+          workflow_id: wf.id,
+          workflow_type: wf.workflow_type,
+          status: wf.status.to_s,
+          start_time: wf.start_time
+        }
+      end
+    rescue => e
+      Aidp.log_error("orchestration_adapter", "list_temporal_failed", error: e.message)
+      []
+    end
+
+    def extract_temporal_options(options)
+      temporal_opts = {}
+      temporal_opts[:workflow_id] = options[:workflow_id] if options[:workflow_id]
+      temporal_opts[:task_queue] = options[:task_queue] if options[:task_queue]
+      temporal_opts
+    end
+
+    # Legacy implementations
+    def start_legacy_issue_workflow(issue_number, options)
+      Aidp.log_info("orchestration_adapter", "starting_legacy_issue_workflow",
+        issue_number: issue_number)
+
+      require_relative "jobs/background_runner"
+
+      runner = Aidp::Jobs::BackgroundRunner.new(@project_dir)
+      job_id = runner.start(:execute, options.merge(issue_number: issue_number))
+
+      {
+        type: :legacy,
+        job_id: job_id,
+        issue_number: issue_number,
+        status: "started"
+      }
+    end
+
+    def start_legacy_work_loop(step_name, step_spec, context, options)
+      Aidp.log_info("orchestration_adapter", "starting_legacy_work_loop",
+        step_name: step_name)
+
+      require_relative "jobs/background_runner"
+
+      runner = Aidp::Jobs::BackgroundRunner.new(@project_dir)
+      job_id = runner.start(:execute, options.merge(
+        step_name: step_name,
+        step_spec: step_spec,
+        context: context
+      ))
+
+      {
+        type: :legacy,
+        job_id: job_id,
+        step_name: step_name,
+        status: "started"
+      }
+    end
+
+    def legacy_job_status(job_id)
+      require_relative "jobs/background_runner"
+
+      runner = Aidp::Jobs::BackgroundRunner.new(@project_dir)
+      status = runner.job_status(job_id)
+
+      return {type: :legacy, job_id: job_id, status: "not_found"} unless status
+
+      {
+        type: :legacy,
+        job_id: job_id,
+        status: status[:status],
+        running: status[:running],
+        started_at: status[:started_at],
+        completed_at: status[:completed_at]
+      }
+    end
+
+    def cancel_legacy_job(job_id)
+      require_relative "jobs/background_runner"
+
+      runner = Aidp::Jobs::BackgroundRunner.new(@project_dir)
+      result = runner.stop_job(job_id)
+
+      {
+        type: :legacy,
+        job_id: job_id,
+        status: result[:success] ? "canceled" : "failed",
+        message: result[:message]
+      }
+    end
+
+    def list_legacy_jobs
+      require_relative "jobs/background_runner"
+
+      runner = Aidp::Jobs::BackgroundRunner.new(@project_dir)
+      runner.list_jobs.map do |job|
+        {
+          type: :legacy,
+          job_id: job[:job_id],
+          status: job[:status],
+          started_at: job[:started_at]
+        }
+      end
+    end
+  end
+end

data/lib/aidp/pr_worktree_manager.rb

@@ -3,17 +3,6 @@ require "fileutils"
 require "shellwords"
 
 module Aidp
-  # Simple shell command executor wrapper for testability
-  class ShellExecutor
-    def run(command)
-      `#{command}`
-    end
-
-    def success?
-      $?.success?
-    end
-  end
-
   # Manages worktrees specifically for Pull Request branches
   class PRWorktreeManager
     def initialize(base_repo_path: nil, project_dir: nil, worktree_registry_path: nil, shell_executor: nil)
@@ -172,7 +161,7 @@ module Aidp
           ]
 
           fetch_commands.each do |fetch_cmd|
-            system(fetch_cmd)
+            @shell_executor.system(fetch_cmd)
             branch_list_output = `git branch -a`.split("\n").map(&:strip)
             base_branch_exists = branch_list_output.any? do |branch|
               branch.end_with?("/#{base_branch}", "remotes/origin/#{base_branch}") ||
@@ -187,7 +176,7 @@ module Aidp
 
         # Robust worktree creation with enhanced error handling and logging
         worktree_create_command = "git worktree add #{Shellwords.escape(worktree_path)} -b #{Shellwords.escape(head_branch)} #{Shellwords.escape(base_branch)}"
-        unless system(worktree_create_command)
+        unless @shell_executor.system(worktree_create_command)
           error_details = {
             pr_number: pr_number,
             base_branch: base_branch,
@@ -390,7 +379,7 @@ module Aidp
 
         # Stage only successfully modified files
         unless successful_files.empty?
-          system("git add #{successful_files.map { |f| Shellwords.escape(f) }.join(" ")}")
+          @shell_executor.system("git add #{successful_files.map { |f| Shellwords.escape(f) }.join(" ")}")
         end
       end
 
@@ -508,7 +497,7 @@ module Aidp
       return false unless existing_worktree
 
       # Remove git worktree
-      system("git worktree remove #{existing_worktree["path"]}") if File.exist?(existing_worktree["path"])
+      @shell_executor.system("git worktree remove #{existing_worktree["path"]}") if File.exist?(existing_worktree["path"])
 
       # Remove from registry and save
       @worktrees.delete(pr_number.to_s)