aidp 0.34.1 → 0.39.3

data/lib/aidp/temporal/configuration.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "date"
+require "yaml"
+
+module Aidp
+  module Temporal
+    # Configuration management for Temporal integration
+    # Loads settings from aidp.yml and environment variables
+    class Configuration
+      DEFAULT_CONFIG = {
+        enabled: false,  # Disabled by default - users must explicitly opt-in
+        target_host: "localhost:7233",
+        namespace: "default",
+        task_queue: "aidp-workflows",
+        tls: false,
+        worker: {
+          max_concurrent_activities: 10,
+          max_concurrent_workflows: 10,
+          shutdown_grace_period: 30
+        },
+        timeouts: {
+          workflow_execution: 86400,     # 24 hours
+          workflow_run: 3600,            # 1 hour
+          activity_start_to_close: 600,  # 10 minutes
+          activity_schedule_to_close: 1800, # 30 minutes
+          activity_heartbeat: 60         # 1 minute
+        },
+        retry: {
+          initial_interval: 1,
+          backoff_coefficient: 2.0,
+          maximum_interval: 60,
+          maximum_attempts: 3
+        }
+      }.freeze
+
+      attr_reader :config
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+        @config = load_config
+      end
+
+      # Check if Temporal is enabled
+      def enabled?
+        @config[:enabled]
+      end
+
+      # Get connection configuration
+      def connection_config
+        {
+          target_host: @config[:target_host],
+          namespace: @config[:namespace],
+          tls: @config[:tls],
+          api_key: @config[:api_key]
+        }
+      end
+
+      # Get worker configuration
+      def worker_config
+        {
+          task_queue: @config[:task_queue],
+          max_concurrent_activities: @config.dig(:worker, :max_concurrent_activities),
+          max_concurrent_workflows: @config.dig(:worker, :max_concurrent_workflows),
+          shutdown_grace_period: @config.dig(:worker, :shutdown_grace_period)
+        }
+      end
+
+      # Get timeout configuration
+      def timeout_config
+        @config[:timeouts] || {}
+      end
+
+      # Get retry policy configuration
+      def retry_config
+        @config[:retry] || {}
+      end
+
+      # Get task queue name
+      def task_queue
+        @config[:task_queue]
+      end
+
+      # Get target host
+      def target_host
+        @config[:target_host]
+      end
+
+      # Get namespace
+      def namespace
+        @config[:namespace]
+      end
+
+      # Build a connection with this configuration
+      def build_connection
+        Connection.new(connection_config)
+      end
+
+      # Build a worker with this configuration
+      def build_worker(connection: nil)
+        conn = connection || build_connection
+        Worker.new(connection: conn, config: worker_config)
+      end
+
+      # Build a workflow client with this configuration
+      def build_workflow_client(connection: nil)
+        conn = connection || build_connection
+        WorkflowClient.new(connection: conn)
+      end
+
+      private
+
+      def load_config
+        base_config = deep_merge(DEFAULT_CONFIG.dup, load_yaml_config)
+        apply_environment_overrides(base_config)
+      end
+
+      def load_yaml_config
+        config_path = File.join(@project_dir, ".aidp", "aidp.yml")
+        return {} unless File.exist?(config_path)
+
+        full_config = YAML.safe_load_file(config_path, permitted_classes: [Date, Time, Symbol], aliases: true)
+        temporal_config = full_config["temporal"] || full_config[:temporal] || {}
+
+        symbolize_keys(temporal_config)
+      rescue => e
+        Aidp.log_warn("temporal_config", "load_failed", error: e.message)
+        {}
+      end
+
+      def apply_environment_overrides(config)
+        # Environment variables take precedence
+        config[:target_host] = ENV["TEMPORAL_HOST"] if ENV["TEMPORAL_HOST"]
+        config[:namespace] = ENV["TEMPORAL_NAMESPACE"] if ENV["TEMPORAL_NAMESPACE"]
+        config[:task_queue] = ENV["TEMPORAL_TASK_QUEUE"] if ENV["TEMPORAL_TASK_QUEUE"]
+        config[:api_key] = ENV["TEMPORAL_API_KEY"] if ENV["TEMPORAL_API_KEY"]
+        config[:enabled] = ENV["TEMPORAL_ENABLED"] != "false" if ENV.key?("TEMPORAL_ENABLED")
+
+        if ENV["TEMPORAL_TLS"]
+          config[:tls] = ENV["TEMPORAL_TLS"] == "true"
+        end
+
+        config
+      end
+
+      def deep_merge(base, override)
+        return base if override.nil? || override.empty?
+
+        base.merge(override) do |_key, base_val, override_val|
+          if base_val.is_a?(Hash) && override_val.is_a?(Hash)
+            deep_merge(base_val, override_val)
+          else
+            override_val.nil? ? base_val : override_val
+          end
+        end
+      end
+
+      def symbolize_keys(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+          result[new_key] = new_value
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/connection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "temporalio/client"
+
+module Aidp
+  module Temporal
+    # Manages Temporal client connections
+    # Handles connection pooling, configuration, and lifecycle
+    class Connection
+      DEFAULT_TARGET_HOST = "localhost:7233"
+      DEFAULT_NAMESPACE = "default"
+
+      attr_reader :client, :config
+
+      def initialize(config = {})
+        @config = normalize_config(config)
+        @client = nil
+        @mutex = Mutex.new
+      end
+
+      # Get or create a connected client
+      # Thread-safe lazy initialization
+      def connect
+        @mutex.synchronize do
+          @client ||= create_client
+        end
+      end
+
+      # Check if connected
+      def connected?
+        @mutex.synchronize { !@client.nil? }
+      end
+
+      # Close the connection
+      def close
+        @mutex.synchronize do
+          @client = nil
+        end
+      end
+
+      # Get target host
+      def target_host
+        @config[:target_host]
+      end
+
+      # Get namespace
+      def namespace
+        @config[:namespace]
+      end
+
+      private
+
+      def normalize_config(config)
+        {
+          target_host: config[:target_host] || config["target_host"] || ENV["TEMPORAL_HOST"] || DEFAULT_TARGET_HOST,
+          namespace: config[:namespace] || config["namespace"] || ENV["TEMPORAL_NAMESPACE"] || DEFAULT_NAMESPACE,
+          tls: config[:tls] || config["tls"] || false,
+          api_key: config[:api_key] || config["api_key"] || ENV["TEMPORAL_API_KEY"]
+        }
+      end
+
+      def create_client
+        Aidp.log_debug("temporal_connection", "connecting",
+          target_host: @config[:target_host],
+          namespace: @config[:namespace],
+          tls: @config[:tls])
+
+        options = {
+          target_host: @config[:target_host],
+          namespace: @config[:namespace]
+        }
+
+        # Add TLS configuration if enabled
+        if @config[:tls]
+          options[:tls] = true
+        end
+
+        # Add API key if provided (for Temporal Cloud)
+        if @config[:api_key]
+          options[:api_key] = @config[:api_key]
+        end
+
+        client = Temporalio::Client.connect(**options)
+
+        Aidp.log_info("temporal_connection", "connected",
+          target_host: @config[:target_host],
+          namespace: @config[:namespace])
+
+        client
+      end
+    end
+  end
+end

data/lib/aidp/temporal/worker.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "temporalio/worker"
+require_relative "connection"
+
+module Aidp
+  module Temporal
+    # Temporal worker that runs workflows and activities
+    # Manages the worker lifecycle and task queue configuration
+    class Worker
+      DEFAULT_TASK_QUEUE = "aidp-workflows"
+      DEFAULT_MAX_CONCURRENT_ACTIVITIES = 10
+      DEFAULT_MAX_CONCURRENT_WORKFLOWS = 10
+
+      attr_reader :task_queue, :config, :connection
+
+      def initialize(connection:, config: {})
+        @connection = connection
+        @config = normalize_config(config)
+        @task_queue = @config[:task_queue]
+        @worker = nil
+        @running = false
+        @shutdown_requested = false
+      end
+
+      # Register workflow classes
+      def register_workflows(*workflow_classes)
+        @workflow_classes ||= []
+        @workflow_classes.concat(workflow_classes)
+        self
+      end
+
+      # Register activity classes or instances
+      def register_activities(*activity_classes)
+        @activity_classes ||= []
+        @activity_classes.concat(activity_classes)
+        self
+      end
+
+      # Start the worker (blocking)
+      def run
+        return if @running
+
+        Aidp.log_info("temporal_worker", "starting",
+          task_queue: @task_queue,
+          workflows: @workflow_classes&.map(&:name),
+          activities: @activity_classes&.map { |a| a.is_a?(Class) ? a.name : a.class.name })
+
+        @running = true
+        @shutdown_requested = false
+
+        begin
+          @worker = create_worker
+          @worker.run
+        rescue => e
+          Aidp.log_error("temporal_worker", "run_failed",
+            error: e.message,
+            error_class: e.class.name)
+          raise
+        ensure
+          @running = false
+          @worker = nil
+        end
+      end
+
+      # Request graceful shutdown
+      def shutdown
+        return unless @running
+
+        Aidp.log_info("temporal_worker", "shutdown_requested", task_queue: @task_queue)
+        @shutdown_requested = true
+        @worker&.shutdown
+      end
+
+      # Check if running
+      def running?
+        @running
+      end
+
+      # Check if shutdown was requested
+      def shutdown_requested?
+        @shutdown_requested
+      end
+
+      private
+
+      def normalize_config(config)
+        {
+          task_queue: config[:task_queue] || config["task_queue"] || ENV["TEMPORAL_TASK_QUEUE"] || DEFAULT_TASK_QUEUE,
+          max_concurrent_activities: config[:max_concurrent_activities] || config["max_concurrent_activities"] || DEFAULT_MAX_CONCURRENT_ACTIVITIES,
+          max_concurrent_workflows: config[:max_concurrent_workflows] || config["max_concurrent_workflows"] || DEFAULT_MAX_CONCURRENT_WORKFLOWS
+        }
+      end
+
+      def create_worker
+        client = @connection.connect
+
+        worker_options = {
+          client: client,
+          task_queue: @task_queue
+        }
+
+        # Add workflows if registered
+        worker_options[:workflows] = @workflow_classes if @workflow_classes&.any?
+
+        # Add activities if registered
+        if @activity_classes&.any?
+          worker_options[:activities] = @activity_classes
+        end
+
+        # Add tuning options
+        worker_options[:max_concurrent_activity_task_polls] = @config[:max_concurrent_activities]
+        worker_options[:max_concurrent_workflow_task_polls] = @config[:max_concurrent_workflows]
+
+        Temporalio::Worker.new(**worker_options)
+      end
+    end
+  end
+end

data/lib/aidp/temporal/workflow_client.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+
+module Aidp
+  module Temporal
+    # Client interface for starting and managing Temporal workflows
+    # Wraps Temporal client operations with AIDP-specific conventions
+    class WorkflowClient
+      DEFAULT_WORKFLOW_TIMEOUT = 86400 # 24 hours in seconds
+      DEFAULT_TASK_QUEUE = "aidp-workflows"
+
+      attr_reader :connection
+
+      def initialize(connection:)
+        @connection = connection
+      end
+
+      # Start a workflow execution
+      # Returns workflow handle for status tracking
+      def start_workflow(workflow_class, input, options = {})
+        client = @connection.connect
+        workflow_id = options[:workflow_id] || generate_workflow_id(workflow_class)
+        task_queue = options[:task_queue] || DEFAULT_TASK_QUEUE
+
+        Aidp.log_info("workflow_client", "starting_workflow",
+          workflow: workflow_class.name,
+          workflow_id: workflow_id,
+          task_queue: task_queue)
+
+        handle = client.start_workflow(
+          workflow_class,
+          input,
+          id: workflow_id,
+          task_queue: task_queue,
+          execution_timeout: options[:execution_timeout] || DEFAULT_WORKFLOW_TIMEOUT,
+          **extract_temporal_options(options)
+        )
+
+        Aidp.log_debug("workflow_client", "workflow_started",
+          workflow_id: workflow_id,
+          run_id: handle.result_run_id)
+
+        handle
+      end
+
+      # Execute a workflow synchronously (start and wait for result)
+      def execute_workflow(workflow_class, input, options = {})
+        handle = start_workflow(workflow_class, input, options)
+        handle.result
+      end
+
+      # Get a workflow handle by ID
+      def get_workflow(workflow_id, run_id: nil)
+        client = @connection.connect
+        client.workflow_handle(workflow_id, run_id: run_id)
+      end
+
+      # Query workflow state
+      def query_workflow(workflow_id, query_name, *args)
+        handle = get_workflow(workflow_id)
+        handle.query(query_name, *args)
+      end
+
+      # Signal a running workflow
+      def signal_workflow(workflow_id, signal_name, *args)
+        handle = get_workflow(workflow_id)
+
+        Aidp.log_debug("workflow_client", "signaling_workflow",
+          workflow_id: workflow_id,
+          signal: signal_name)
+
+        handle.signal(signal_name, *args)
+      end
+
+      # Cancel a running workflow
+      def cancel_workflow(workflow_id)
+        handle = get_workflow(workflow_id)
+
+        Aidp.log_info("workflow_client", "canceling_workflow",
+          workflow_id: workflow_id)
+
+        handle.cancel
+      end
+
+      # Terminate a workflow
+      def terminate_workflow(workflow_id, reason: nil)
+        handle = get_workflow(workflow_id)
+
+        Aidp.log_info("workflow_client", "terminating_workflow",
+          workflow_id: workflow_id,
+          reason: reason)
+
+        handle.terminate(reason)
+      end
+
+      # Get workflow result (waits for completion)
+      def get_workflow_result(workflow_id, timeout: nil)
+        handle = get_workflow(workflow_id)
+
+        if timeout
+          # Use timeout for waiting
+          Timeout.timeout(timeout) do
+            handle.result
+          end
+        else
+          handle.result
+        end
+      end
+
+      # Check if workflow is running
+      def workflow_running?(workflow_id)
+        handle = get_workflow(workflow_id)
+        desc = handle.describe
+        desc.status == :running
+      rescue Temporalio::Error::RPCError => e
+        # NOT_FOUND means workflow doesn't exist
+        return false if e.code == Temporalio::Error::RPCError::Code::NOT_FOUND
+
+        raise
+      end
+
+      # List workflows with optional filters
+      def list_workflows(query: nil, page_size: 100)
+        client = @connection.connect
+
+        options = {page_size: page_size}
+        options[:query] = query if query
+
+        client.list_workflows(**options)
+      end
+
+      private
+
+      def generate_workflow_id(workflow_class)
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        random = SecureRandom.hex(4)
+        workflow_name = workflow_class.name.split("::").last.gsub(/Workflow$/, "").downcase
+        "#{workflow_name}_#{timestamp}_#{random}"
+      end
+
+      def extract_temporal_options(options)
+        temporal_opts = {}
+
+        # Timeout options
+        temporal_opts[:run_timeout] = options[:run_timeout] if options[:run_timeout]
+        temporal_opts[:task_timeout] = options[:task_timeout] if options[:task_timeout]
+
+        # Retry policy
+        if options[:retry_policy]
+          temporal_opts[:retry_policy] = build_retry_policy(options[:retry_policy])
+        end
+
+        # Memo and search attributes
+        temporal_opts[:memo] = options[:memo] if options[:memo]
+        temporal_opts[:search_attributes] = options[:search_attributes] if options[:search_attributes]
+
+        temporal_opts
+      end
+
+      def build_retry_policy(policy_config)
+        Temporalio::RetryPolicy.new(
+          initial_interval: policy_config[:initial_interval] || 1,
+          backoff_coefficient: policy_config[:backoff_coefficient] || 2.0,
+          maximum_interval: policy_config[:maximum_interval] || 60,
+          maximum_attempts: policy_config[:maximum_attempts] || 3
+        )
+      end
+    end
+  end
+end

data/lib/aidp/temporal/workflows/base_workflow.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "temporalio/workflow"
+
+module Aidp
+  module Temporal
+    module Workflows
+      # Base class for AIDP Temporal workflows
+      # Provides common patterns and utilities for workflow implementations
+      class BaseWorkflow < Temporalio::Workflow::Definition
+        # Default activity options applied to all activities
+        DEFAULT_ACTIVITY_OPTIONS = {
+          start_to_close_timeout: 600,    # 10 minutes
+          heartbeat_timeout: 60,          # 1 minute
+          retry_policy: {
+            initial_interval: 1,
+            backoff_coefficient: 2.0,
+            maximum_interval: 60,
+            maximum_attempts: 3
+          }
+        }.freeze
+
+        class << self
+          # Define workflow name from class name
+          def workflow_name
+            name.split("::").last.gsub(/Workflow$/, "").gsub(/([A-Z])/) { "_#{$1.downcase}" }.sub(/^_/, "")
+          end
+
+          # Helper to define activity with default options
+          def activity_options(overrides = {})
+            DEFAULT_ACTIVITY_OPTIONS.merge(overrides)
+          end
+        end
+
+        protected
+
+        # Log within workflow context
+        def log_workflow(action, **context)
+          workflow_info = Temporalio::Workflow.info
+          Aidp.log_debug("temporal_workflow", action,
+            workflow_id: workflow_info.workflow_id,
+            run_id: workflow_info.run_id,
+            **context)
+        end
+
+        # Sleep that respects cancellation
+        def workflow_sleep(duration)
+          Temporalio::Workflow.sleep(duration)
+        end
+
+        # Get current workflow info
+        def workflow_info
+          Temporalio::Workflow.info
+        end
+
+        # Check if cancellation was requested
+        def cancellation_requested?
+          Temporalio::Workflow.cancellation_pending?
+        end
+
+        # Build retry policy from config
+        def build_retry_policy(config)
+          Temporalio::RetryPolicy.new(
+            initial_interval: config[:initial_interval] || 1,
+            backoff_coefficient: config[:backoff_coefficient] || 2.0,
+            maximum_interval: config[:maximum_interval] || 60,
+            maximum_attempts: config[:maximum_attempts] || 3
+          )
+        end
+      end
+    end
+  end
+end