aidp 0.34.1 → 0.39.3

data/lib/aidp/temporal/activities/record_checkpoint_activity.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that records a checkpoint for progress tracking
+      # Persists state for recovery and observability
+      class RecordCheckpointActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            step_name = input[:step_name]
+            iteration = input[:iteration]
+            state = input[:state]
+            test_results = input[:test_results]
+
+            log_activity("recording_checkpoint",
+              project_dir: project_dir,
+              step_name: step_name,
+              iteration: iteration)
+
+            # Create checkpoint recorder
+            checkpoint = Aidp::Execute::Checkpoint.new(project_dir)
+
+            # Build metrics from test results
+            metrics = build_metrics(test_results)
+
+            # Record the checkpoint
+            checkpoint.record_checkpoint(
+              step_name,
+              iteration,
+              {
+                state: state,
+                test_results_summary: summarize_test_results(test_results),
+                metrics: metrics,
+                workflow_type: "temporal"
+              }
+            )
+
+            success_result(
+              step_name: step_name,
+              iteration: iteration,
+              timestamp: Time.now.iso8601
+            )
+          end
+        end
+
+        private
+
+        def build_metrics(test_results)
+          return {} unless test_results
+
+          results = test_results[:results] || {}
+          passing = results.count { |_, r| r[:success] }
+          total = results.count
+
+          {
+            checks_passing: passing,
+            checks_total: total,
+            pass_rate: (total > 0) ? (passing.to_f / total * 100).round(1) : 0
+          }
+        end
+
+        def summarize_test_results(test_results)
+          return {} unless test_results
+
+          results = test_results[:results] || {}
+
+          results.transform_values do |result|
+            {
+              success: result[:success],
+              duration: result[:duration]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/run_agent_activity.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that executes an AI agent iteration
+      # Wraps the existing AIDP agent execution with Temporal durability
+      class RunAgentActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            step_name = input[:step_name]
+            iteration = input[:iteration]
+            injected_instructions = input[:injected_instructions] || []
+            escalate = input[:escalate] || false
+
+            log_activity("executing_agent",
+              project_dir: project_dir,
+              step_name: step_name,
+              iteration: iteration,
+              instructions_count: injected_instructions.length,
+              escalate: escalate)
+
+            # Load configuration
+            config = load_config(project_dir)
+            provider_manager = create_provider_manager(project_dir, config)
+
+            # Get prompt content
+            prompt_manager = Aidp::Execute::PromptManager.new(project_dir, config: config)
+            prompt_content = prompt_manager.read
+
+            unless prompt_content
+              return error_result("No PROMPT.md found")
+            end
+
+            # Inject any queued instructions
+            if injected_instructions.any?
+              prompt_content = inject_instructions(prompt_content, injected_instructions)
+              prompt_manager.write(prompt_content)
+            end
+
+            # Select model based on escalation status
+            model_selector = create_model_selector(config, escalate: escalate)
+            provider, model = model_selector.select
+
+            log_activity("agent_model_selected",
+              provider: provider,
+              model: model,
+              escalate: escalate)
+
+            # Periodic heartbeat during agent execution
+            heartbeat_thread = start_heartbeat_thread(iteration: iteration)
+
+            begin
+              # Execute agent
+              result = execute_agent(
+                project_dir: project_dir,
+                provider_manager: provider_manager,
+                provider: provider,
+                model: model,
+                prompt_content: prompt_content
+              )
+
+              check_cancellation!
+
+              if result[:success]
+                success_result(
+                  result: result[:output],
+                  provider: provider,
+                  model: model,
+                  iteration: iteration
+                )
+              else
+                error_result(result[:error] || "Agent execution failed",
+                  provider: provider,
+                  model: model,
+                  iteration: iteration)
+              end
+            ensure
+              heartbeat_thread&.kill
+            end
+          end
+        end
+
+        private
+
+        def inject_instructions(prompt_content, instructions)
+          injection_text = instructions.map { |i| i[:content] || i }.join("\n\n")
+
+          <<~PROMPT
+            #{prompt_content}
+
+            ---
+            ## Additional Instructions (Injected)
+
+            #{injection_text}
+          PROMPT
+        end
+
+        def create_model_selector(config, escalate:)
+          require_relative "../../harness/thinking_depth_manager"
+
+          manager = Aidp::Harness::ThinkingDepthManager.new(config)
+          manager.escalate if escalate
+          manager
+        end
+
+        def start_heartbeat_thread(iteration:)
+          Thread.new do
+            loop do
+              sleep 30
+              heartbeat(iteration: iteration, status: "running")
+            end
+          end
+        end
+
+        def execute_agent(project_dir:, provider_manager:, provider:, model:, prompt_content:)
+          # Use the provider manager to execute
+          prompt_path = File.join(project_dir, ".aidp", "PROMPT.md")
+
+          result = provider_manager.execute_with_provider(
+            provider,
+            model: model,
+            prompt_path: prompt_path
+          )
+
+          {success: result[:success], output: result[:output], error: result[:error]}
+        rescue => e
+          Aidp.log_error("run_agent_activity", "agent_execution_failed",
+            error: e.message,
+            error_class: e.class.name)
+          {success: false, error: e.message}
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/run_tests_activity.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that runs tests and linters
+      # Wraps AIDP test runner with Temporal durability
+      class RunTestsActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            iteration = input[:iteration]
+            phases = input[:phases] || [:test, :lint]
+
+            log_activity("running_tests",
+              project_dir: project_dir,
+              iteration: iteration,
+              phases: phases)
+
+            # Load configuration
+            config = load_config(project_dir)
+
+            # Create test runner
+            test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
+
+            # Run tests with periodic heartbeat
+            results = {}
+            all_passing = true
+            partial_pass = false
+
+            phases.each do |phase|
+              heartbeat(phase: phase, iteration: iteration)
+              check_cancellation!
+
+              result = run_phase(test_runner, phase)
+              results[phase] = result
+
+              if result[:success]
+                partial_pass = true
+              else
+                all_passing = false
+              end
+
+              log_activity("phase_complete",
+                phase: phase,
+                success: result[:success],
+                duration: result[:duration])
+            end
+
+            success_result(
+              all_passing: all_passing,
+              partial_pass: partial_pass,
+              results: results,
+              iteration: iteration,
+              summary: build_summary(results)
+            )
+          end
+        end
+
+        private
+
+        def run_phase(test_runner, phase)
+          start_time = Time.now
+
+          result = case phase
+          when :test, "test"
+            test_runner.run_tests
+          when :lint, "lint"
+            test_runner.run_lint
+          when :typecheck, "typecheck"
+            test_runner.run_typecheck
+          when :build, "build"
+            test_runner.run_build
+          else
+            {success: false, output: "Unknown phase: #{phase}"}
+          end
+
+          duration = Time.now - start_time
+
+          {
+            success: result[:success],
+            output: result[:output],
+            exit_code: result[:exit_code],
+            duration: duration.round(2)
+          }
+        rescue => e
+          Aidp.log_error("run_tests_activity", "phase_failed",
+            phase: phase,
+            error: e.message)
+
+          {
+            success: false,
+            output: e.message,
+            exit_code: -1,
+            duration: (Time.now - start_time).round(2)
+          }
+        end
+
+        def build_summary(results)
+          passing = results.count { |_, r| r[:success] }
+          total = results.count
+
+          {
+            passing: passing,
+            total: total,
+            failed_phases: results.reject { |_, r| r[:success] }.keys
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/run_work_loop_iteration_activity.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that runs a single work loop iteration
+      # Combines agent execution and testing in one activity
+      # Used by IssueToPrWorkflow for simplified orchestration
+      class RunWorkLoopIterationActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            issue_number = input[:issue_number]
+            plan = input[:plan]
+            iteration = input[:iteration]
+            injected_instructions = input[:injected_instructions] || []
+
+            log_activity("running_work_loop_iteration",
+              project_dir: project_dir,
+              issue_number: issue_number,
+              iteration: iteration)
+
+            # Start heartbeat thread
+            heartbeat_thread = start_heartbeat_thread(iteration: iteration)
+
+            begin
+              # Phase 1: Run agent
+              heartbeat(phase: "agent", iteration: iteration)
+              agent_result = run_agent(
+                project_dir: project_dir,
+                issue_number: issue_number,
+                plan: plan,
+                iteration: iteration,
+                injected_instructions: injected_instructions
+              )
+
+              check_cancellation!
+
+              unless agent_result[:success]
+                return error_result("Agent failed: #{agent_result[:error]}",
+                  iteration: iteration,
+                  tests_passing: false)
+              end
+
+              # Phase 2: Run tests
+              heartbeat(phase: "tests", iteration: iteration)
+              test_result = run_tests(project_dir: project_dir)
+
+              check_cancellation!
+
+              # Phase 3: Handle result
+              if test_result[:all_passing]
+                success_result(
+                  result: {
+                    agent_output: agent_result[:output],
+                    test_results: test_result
+                  },
+                  iteration: iteration,
+                  tests_passing: true
+                )
+              else
+                # Update prompt with failures for next iteration
+                update_prompt_with_failures(project_dir, test_result)
+
+                success_result(
+                  result: {
+                    agent_output: agent_result[:output],
+                    test_results: test_result
+                  },
+                  iteration: iteration,
+                  tests_passing: false
+                )
+              end
+            ensure
+              heartbeat_thread&.kill
+            end
+          end
+        end
+
+        private
+
+        def start_heartbeat_thread(iteration:)
+          Thread.new do
+            loop do
+              sleep 30
+              heartbeat(iteration: iteration, status: "running")
+            end
+          end
+        end
+
+        def run_agent(project_dir:, issue_number:, plan:, iteration:, injected_instructions:)
+          config = load_config(project_dir)
+          provider_manager = create_provider_manager(project_dir, config)
+
+          # Prepare prompt with plan context
+          prompt_manager = Aidp::Execute::PromptManager.new(project_dir, config: config)
+          current_prompt = prompt_manager.read
+
+          unless current_prompt
+            # Create initial prompt from plan
+            current_prompt = build_initial_prompt(plan, issue_number)
+            prompt_manager.write(current_prompt)
+          end
+
+          # Inject instructions if any
+          if injected_instructions.any?
+            current_prompt = inject_instructions(current_prompt, injected_instructions)
+            prompt_manager.write(current_prompt)
+          end
+
+          # Select model
+          require_relative "../../harness/thinking_depth_manager"
+          model_selector = Aidp::Harness::ThinkingDepthManager.new(config)
+          provider, model = model_selector.select
+
+          log_activity("agent_executing",
+            provider: provider,
+            model: model,
+            iteration: iteration)
+
+          # Execute
+          result = provider_manager.execute_with_provider(
+            provider,
+            model: model,
+            prompt_path: prompt_manager.prompt_path
+          )
+
+          {success: result[:success], output: result[:output], error: result[:error]}
+        rescue => e
+          Aidp.log_error("run_work_loop_iteration_activity", "agent_failed",
+            error: e.message,
+            iteration: iteration)
+          {success: false, error: e.message}
+        end
+
+        def run_tests(project_dir:)
+          config = load_config(project_dir)
+          test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
+
+          results = {}
+
+          # Run tests
+          test_result = test_runner.run_tests
+          results[:test] = test_result
+
+          # Run lint
+          lint_result = test_runner.run_lint
+          results[:lint] = lint_result
+
+          all_passing = results.values.all? { |r| r[:success] }
+
+          {
+            all_passing: all_passing,
+            results: results
+          }
+        rescue => e
+          Aidp.log_error("run_work_loop_iteration_activity", "tests_failed",
+            error: e.message)
+          {all_passing: false, results: {}, error: e.message}
+        end
+
+        def build_initial_prompt(plan, issue_number)
+          <<~PROMPT
+            # Implementation Task: Issue ##{issue_number}
+
+            ## Objective
+
+            #{plan[:title]}
+
+            ## Requirements
+
+            #{plan[:requirements]&.map { |r| "- #{r}" }&.join("\n")}
+
+            ## Implementation Steps
+
+            #{plan[:steps]&.map { |s| "- #{s[:description]}" }&.join("\n")}
+
+            ## Instructions
+
+            1. Review the existing codebase
+            2. Implement the required changes
+            3. Ensure tests pass
+            4. Follow the project's style guide
+          PROMPT
+        end
+
+        def inject_instructions(prompt, instructions)
+          instruction_text = instructions.map { |i| i[:content] || i }.join("\n\n")
+
+          <<~PROMPT
+            #{prompt}
+
+            ---
+            ## Additional Instructions
+
+            #{instruction_text}
+          PROMPT
+        end
+
+        def update_prompt_with_failures(project_dir, test_result)
+          prompt_manager = Aidp::Execute::PromptManager.new(project_dir)
+          current_prompt = prompt_manager.read
+
+          return unless current_prompt
+
+          failures = extract_failures(test_result)
+
+          updated_prompt = <<~PROMPT
+            #{current_prompt}
+
+            ---
+            ## Failures to Fix
+
+            #{failures}
+
+            Please address the above failures.
+          PROMPT
+
+          prompt_manager.write(updated_prompt)
+        end
+
+        def extract_failures(test_result)
+          results = test_result[:results] || {}
+          sections = []
+
+          results.each do |phase, result|
+            next if result[:success]
+
+            sections << "### #{phase.to_s.capitalize} Failures"
+            sections << ""
+            sections << "```"
+            sections << truncate(result[:output], 1500)
+            sections << "```"
+            sections << ""
+          end
+
+          sections.join("\n")
+        end
+
+        def truncate(text, max_length)
+          return "" unless text
+          (text.length > max_length) ? "#{text.slice(0, max_length)}\n...(truncated)" : text
+        end
+      end
+    end
+  end
+end