aidp 0.34.1 → 0.39.3

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require "temporalio/workflow"
+require_relative "base_workflow"
+
+module Aidp
+  module Temporal
+    module Workflows
+      # Workflow that implements the fix-forward work loop pattern
+      # Handles iterative implementation with test validation
+      #
+      # State machine:
+      # READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH} → READY
+      class WorkLoopWorkflow < BaseWorkflow
+        # Query handlers
+        workflow_query
+        def current_state
+          @state
+        end
+
+        workflow_query
+        def iteration_count
+          @iteration
+        end
+
+        workflow_query
+        def test_results
+          @last_test_results
+        end
+
+        workflow_query
+        def progress
+          {
+            state: @state,
+            iteration: @iteration,
+            max_iterations: @max_iterations,
+            step_name: @step_name,
+            consecutive_failures: @consecutive_failures,
+            started_at: @started_at
+          }
+        end
+
+        # Signal handlers
+        workflow_signal
+        def pause
+          @paused = true
+          log_workflow("paused", iteration: @iteration)
+        end
+
+        workflow_signal
+        def resume
+          @paused = false
+          log_workflow("resumed", iteration: @iteration)
+        end
+
+        workflow_signal
+        def inject_instruction(instruction)
+          @instruction_queue ||= []
+          @instruction_queue << {
+            content: instruction,
+            type: :user_input,
+            queued_at: Time.now.iso8601
+          }
+          log_workflow("instruction_queued", queue_size: @instruction_queue.length)
+        end
+
+        workflow_signal
+        def escalate_model
+          @escalate_requested = true
+          log_workflow("escalation_requested", current_iteration: @iteration)
+        end
+
+        # Main workflow execution
+        def execute(input)
+          initialize_state(input)
+          log_workflow("started",
+            step_name: @step_name,
+            max_iterations: @max_iterations,
+            project_dir: @project_dir)
+
+          begin
+            result = run_work_loop
+            build_result(result)
+          rescue Temporalio::Error::CanceledError
+            log_workflow("canceled", state: @state, iteration: @iteration)
+            build_canceled_result
+          end
+        end
+
+        private
+
+        def initialize_state(input)
+          @project_dir = input[:project_dir]
+          @step_name = input[:step_name]
+          @step_spec = input[:step_spec]
+          @context = input[:context] || {}
+          @max_iterations = input[:max_iterations] || 50
+          @checkpoint_interval = input[:checkpoint_interval] || 5
+
+          @state = :ready
+          @iteration = 0
+          @paused = false
+          @escalate_requested = false
+          @consecutive_failures = 0
+          @last_test_results = nil
+          @instruction_queue = []
+          @started_at = Time.now.iso8601
+        end
+
+        def run_work_loop
+          # Create initial prompt
+          transition_to(:initializing)
+          prompt_result = create_initial_prompt
+
+          unless prompt_result[:success]
+            return {success: false, reason: "prompt_creation_failed", error: prompt_result[:error]}
+          end
+
+          loop do
+            # Handle pause signal
+            while @paused
+              workflow_sleep(1)
+            end
+
+            # Check cancellation
+            return {success: false, reason: "canceled"} if cancellation_requested?
+
+            @iteration += 1
+            log_workflow("iteration_start", iteration: @iteration)
+
+            # Check iteration limit
+            if @iteration > @max_iterations
+              log_workflow("max_iterations_reached", max: @max_iterations)
+              return {success: false, reason: "max_iterations", iterations: @iteration}
+            end
+
+            # APPLY_PATCH: Send prompt to agent
+            transition_to(:apply_patch)
+            agent_result = run_agent_activity
+
+            unless agent_result[:success]
+              @consecutive_failures += 1
+              if @consecutive_failures >= 3
+                handle_escalation
+              end
+              # Fix-forward: continue to next iteration
+              next
+            end
+
+            # TEST: Run validation
+            transition_to(:test)
+            test_result = run_test_activity
+            @last_test_results = test_result
+
+            if test_result[:all_passing]
+              # PASS → DONE
+              transition_to(:done)
+              log_workflow("completed", iterations: @iteration)
+              return {
+                success: true,
+                iterations: @iteration,
+                test_results: test_result
+              }
+            end
+
+            # FAIL → DIAGNOSE
+            transition_to(:diagnose)
+            handle_failure(test_result)
+
+            # Record checkpoint at intervals
+            if (@iteration % @checkpoint_interval).zero?
+              record_checkpoint
+            end
+
+            # Reset failure count on progress
+            @consecutive_failures = 0 if test_result[:partial_pass]
+
+            # NEXT_PATCH: Prepare for next iteration
+            transition_to(:next_patch)
+            prepare_next_iteration(test_result)
+
+            transition_to(:ready)
+          end
+        end
+
+        def transition_to(new_state)
+          old_state = @state
+          @state = new_state
+          log_workflow("state_transition", from: old_state, to: new_state, iteration: @iteration)
+        end
+
+        def create_initial_prompt
+          Temporalio::Workflow.execute_activity(
+            Activities::CreatePromptActivity,
+            {
+              project_dir: @project_dir,
+              step_name: @step_name,
+              step_spec: @step_spec,
+              context: @context
+            },
+            **activity_options(start_to_close_timeout: 120)
+          )
+        end
+
+        def run_agent_activity
+          instructions = drain_instruction_queue
+
+          Temporalio::Workflow.execute_activity(
+            Activities::RunAgentActivity,
+            {
+              project_dir: @project_dir,
+              step_name: @step_name,
+              iteration: @iteration,
+              injected_instructions: instructions,
+              escalate: @escalate_requested
+            },
+            **activity_options(
+              start_to_close_timeout: 900,  # 15 minutes
+              heartbeat_timeout: 120         # 2 minutes
+            )
+          )
+        ensure
+          @escalate_requested = false
+        end
+
+        def run_test_activity
+          Temporalio::Workflow.execute_activity(
+            Activities::RunTestsActivity,
+            {
+              project_dir: @project_dir,
+              iteration: @iteration
+            },
+            **activity_options(
+              start_to_close_timeout: 600,  # 10 minutes
+              heartbeat_timeout: 60
+            )
+          )
+        end
+
+        def handle_failure(test_result)
+          Temporalio::Workflow.execute_activity(
+            Activities::DiagnoseFailureActivity,
+            {
+              project_dir: @project_dir,
+              iteration: @iteration,
+              test_result: test_result
+            },
+            **activity_options(start_to_close_timeout: 120)
+          )
+        end
+
+        def prepare_next_iteration(test_result)
+          Temporalio::Workflow.execute_activity(
+            Activities::PrepareNextIterationActivity,
+            {
+              project_dir: @project_dir,
+              iteration: @iteration,
+              test_result: test_result,
+              failures_only: true
+            },
+            **activity_options(start_to_close_timeout: 60)
+          )
+        end
+
+        def record_checkpoint
+          Temporalio::Workflow.execute_activity(
+            Activities::RecordCheckpointActivity,
+            {
+              project_dir: @project_dir,
+              step_name: @step_name,
+              iteration: @iteration,
+              state: @state,
+              test_results: @last_test_results
+            },
+            **activity_options(start_to_close_timeout: 30)
+          )
+        end
+
+        def handle_escalation
+          log_workflow("escalating_model", consecutive_failures: @consecutive_failures)
+          @escalate_requested = true
+          @consecutive_failures = 0
+        end
+
+        def drain_instruction_queue
+          instructions = @instruction_queue.dup
+          @instruction_queue.clear
+          instructions
+        end
+
+        def activity_options(overrides = {})
+          self.class.activity_options(overrides)
+        end
+
+        def build_result(result)
+          {
+            status: result[:success] ? "completed" : "failed",
+            step_name: @step_name,
+            iterations: @iteration,
+            success: result[:success],
+            reason: result[:reason],
+            test_results: result[:test_results],
+            started_at: @started_at,
+            completed_at: Time.now.iso8601
+          }
+        end
+
+        def build_canceled_result
+          {
+            status: "canceled",
+            step_name: @step_name,
+            iterations: @iteration,
+            state: @state,
+            started_at: @started_at,
+            completed_at: Time.now.iso8601
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# Temporal integration for AIDP
+# Provides durable workflow orchestration for issue-to-PR pipelines
+#
+# Components:
+# - Connection: Manages Temporal client connections
+# - Worker: Runs workflows and activities
+# - WorkflowClient: Interface for starting/managing workflows
+# - Configuration: Loads Temporal settings from aidp.yml
+#
+# Workflows:
+# - IssueToPrWorkflow: Full issue analysis → implementation → PR pipeline
+# - WorkLoopWorkflow: Fix-forward iteration pattern
+# - SubIssueWorkflow: Child workflow for decomposed tasks
+#
+# Activities:
+# - RunAgentActivity: Execute AI agent
+# - RunTestsActivity: Run tests/linters
+# - AnalyzeIssueActivity: Analyze GitHub issue
+# - CreatePlanActivity: Generate implementation plan
+# - CreatePromptActivity: Build PROMPT.md
+# - DiagnoseFailureActivity: Analyze failures
+# - PrepareNextIterationActivity: Set up next iteration
+# - RecordCheckpointActivity: Save progress
+# - CreatePrActivity: Create GitHub PR
+
+module Aidp
+  module Temporal
+    class << self
+      # Get the default configuration
+      def configuration(project_dir = Dir.pwd)
+        @configurations ||= {}
+        @configurations[project_dir] ||= Configuration.new(project_dir)
+      end
+
+      # Check if Temporal is enabled
+      def enabled?(project_dir = Dir.pwd)
+        configuration(project_dir).enabled?
+      end
+
+      # Build a connection with project configuration
+      def connection(project_dir = Dir.pwd)
+        configuration(project_dir).build_connection
+      end
+
+      # Build a workflow client with project configuration
+      def workflow_client(project_dir = Dir.pwd)
+        configuration(project_dir).build_workflow_client
+      end
+
+      # Build a worker with project configuration
+      def worker(project_dir = Dir.pwd)
+        configuration(project_dir).build_worker
+      end
+
+      # Start a workflow
+      def start_workflow(workflow_class, input, project_dir: Dir.pwd, **options)
+        client = workflow_client(project_dir)
+        client.start_workflow(workflow_class, input, options)
+      end
+
+      # Execute a workflow synchronously
+      def execute_workflow(workflow_class, input, project_dir: Dir.pwd, **options)
+        client = workflow_client(project_dir)
+        client.execute_workflow(workflow_class, input, options)
+      end
+
+      # Get workflow status
+      def workflow_status(workflow_id, project_dir: Dir.pwd)
+        client = workflow_client(project_dir)
+        handle = client.get_workflow(workflow_id)
+        handle.describe
+      end
+
+      # Signal a workflow
+      def signal_workflow(workflow_id, signal_name, *args, project_dir: Dir.pwd)
+        client = workflow_client(project_dir)
+        client.signal_workflow(workflow_id, signal_name, *args)
+      end
+
+      # Cancel a workflow
+      def cancel_workflow(workflow_id, project_dir: Dir.pwd)
+        client = workflow_client(project_dir)
+        client.cancel_workflow(workflow_id)
+      end
+
+      # Reset configuration cache (useful for testing)
+      def reset!
+        @configurations = {}
+      end
+    end
+  end
+end
+
+# Require components in dependency order
+require_relative "temporal/configuration"
+require_relative "temporal/connection"
+require_relative "temporal/worker"
+require_relative "temporal/workflow_client"
+
+# Require workflows
+require_relative "temporal/workflows/base_workflow"
+require_relative "temporal/workflows/issue_to_pr_workflow"
+require_relative "temporal/workflows/work_loop_workflow"
+require_relative "temporal/workflows/sub_issue_workflow"
+
+# Require activities
+require_relative "temporal/activities/base_activity"
+require_relative "temporal/activities/run_agent_activity"
+require_relative "temporal/activities/run_tests_activity"
+require_relative "temporal/activities/analyze_issue_activity"
+require_relative "temporal/activities/create_plan_activity"
+require_relative "temporal/activities/create_prompt_activity"
+require_relative "temporal/activities/diagnose_failure_activity"
+require_relative "temporal/activities/prepare_next_iteration_activity"
+require_relative "temporal/activities/record_checkpoint_activity"
+require_relative "temporal/activities/create_pr_activity"
+require_relative "temporal/activities/run_work_loop_iteration_activity"
+require_relative "temporal/activities/analyze_sub_task_activity"

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.34.1"
+  VERSION = "0.39.3"
 end

data/lib/aidp/watch/base_processor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Watch
+    # Base class for Watch Mode processors
+    class BaseProcessor
+      def initialize(repository_client:, state_store: nil, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @verbose = verbose
+
+        # Only use string or symbol access for label_config
+        @rebase_label = label_config[:rebase_trigger] ||
+          label_config["rebase_trigger"] ||
+          "aidp-rebase"
+      end
+
+      # Checks if this processor can handle the current work item
+      # @param work_item [WorkItem] The work item to check
+      # @return [Boolean] Whether the work item can be processed
+      def can_process?(work_item)
+        raise NotImplementedError, "Subclasses must implement can_process?"
+      end
+
+      # Process the work item
+      # @param work_item [WorkItem] The work item to process
+      # @return [Boolean] Whether the work item was processed successfully
+      def process(work_item)
+        raise NotImplementedError, "Subclasses must implement process"
+      end
+
+      attr_reader :rebase_label
+    end
+  end
+end

data/lib/aidp/watch/build_processor.rb

@@ -67,6 +67,17 @@ module Aidp
 
         sync_local_aidp_config(working_dir)
 
+        # Check for stuck work loop: work appears done but protocol wasn't followed
+        if work_loop_stuck_but_complete?(working_dir: working_dir, base_branch: base_branch)
+          display_message("🔧 Detected stuck work loop - work appears complete, bypassing harness", type: :info)
+          Aidp.log_info("build_processor", "stuck_work_loop_detected",
+            issue: number, working_dir: working_dir)
+
+          # Skip harness and go directly to success handling
+          handle_success(issue: issue, slug: slug, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data, working_dir: working_dir)
+          return
+        end
+
         prompt_content = build_prompt(issue: issue, plan_data: plan_data)
         write_prompt(prompt_content, working_dir: working_dir)
 
@@ -1023,6 +1034,127 @@ module Aidp
         string_key = key.to_s
         plan_data[symbol_key] || plan_data[string_key]
       end
+
+      # Detect if work loop is stuck but work appears complete.
+      # This handles cases where the agent did the work but didn't follow the protocol
+      # (e.g., didn't mark STATUS: COMPLETE in .aidp/PROMPT.md, didn't file tasks).
+      #
+      # Conditions for "stuck but complete":
+      # 1. Has commits ahead of base branch (work was done)
+      # 2. Tests pass (work is valid)
+      # 3. Linters pass (code quality is acceptable)
+      # 4. .aidp/PROMPT.md exists but doesn't have STATUS: COMPLETE (protocol not followed)
+      #
+      # @param working_dir [String] Path to the working directory
+      # @param base_branch [String] Base branch to compare against
+      # @return [Boolean] True if work loop appears stuck but work is complete
+      def work_loop_stuck_but_complete?(working_dir:, base_branch:)
+        Aidp.log_debug("build_processor", "checking_stuck_work_loop", working_dir: working_dir)
+
+        # Check 1: Has commits ahead of base branch
+        unless has_commits_ahead?(working_dir: working_dir, base_branch: base_branch)
+          Aidp.log_debug("build_processor", "stuck_check_no_commits_ahead")
+          return false
+        end
+
+        # Check 2: .aidp/PROMPT.md exists but doesn't have STATUS: COMPLETE
+        prompt_path = File.join(working_dir, ".aidp", "PROMPT.md")
+        if File.exist?(prompt_path)
+          prompt_content = File.read(prompt_path)
+          if prompt_content.match?(/^STATUS:\s*COMPLETE/i)
+            # Protocol was followed, not stuck
+            Aidp.log_debug("build_processor", "stuck_check_already_marked_complete")
+            return false
+          end
+        else
+          # No prompt file means this is a fresh start, not stuck
+          Aidp.log_debug("build_processor", "stuck_check_no_prompt_file")
+          return false
+        end
+
+        # Check 3: Run quick validation (tests + linters)
+        unless quick_validation_passes?(working_dir: working_dir)
+          Aidp.log_debug("build_processor", "stuck_check_validation_failed")
+          return false
+        end
+
+        Aidp.log_info("build_processor", "work_loop_stuck_but_complete",
+          working_dir: working_dir,
+          reason: "has_commits_tests_pass_but_no_status_complete")
+        true
+      rescue => e
+        Aidp.log_warn("build_processor", "stuck_check_error", error: e.message)
+        false
+      end
+
+      # Check if branch has commits ahead of base branch
+      def has_commits_ahead?(working_dir:, base_branch:)
+        Dir.chdir(working_dir) do
+          # Fetch to ensure we have latest refs (use Open3 directly to avoid test mocks)
+          Open3.capture3("git", "fetch", "origin")
+
+          # Count commits ahead of origin/base_branch
+          stdout, _stderr, status = Open3.capture3(
+            "git", "rev-list", "--count", "HEAD", "^origin/#{base_branch}"
+          )
+          return false unless status.success?
+
+          commits_ahead = stdout.strip.to_i
+          Aidp.log_debug("build_processor", "commits_ahead_check",
+            base_branch: base_branch, commits_ahead: commits_ahead)
+          commits_ahead > 0
+        end
+      rescue => e
+        Aidp.log_warn("build_processor", "commits_ahead_check_error", error: e.message)
+        false
+      end
+
+      # Run quick validation to check if tests and linters pass
+      def quick_validation_passes?(working_dir:)
+        Dir.chdir(working_dir) do
+          # Load config to get test/lint commands
+          config_manager = Aidp::Harness::ConfigManager.new(working_dir)
+          harness_config = config_manager.config || {}
+
+          # Try to run tests
+          test_commands = harness_config.dig(:harness, :tests) ||
+            harness_config.dig("harness", "tests") || []
+
+          test_commands.each do |cmd|
+            command = cmd.is_a?(Hash) ? (cmd[:command] || cmd["command"]) : cmd.to_s
+            next if command.nil? || command.empty?
+
+            Aidp.log_debug("build_processor", "quick_validation_running_test", command: command)
+            _stdout, _stderr, status = Open3.capture3(command)
+            unless status.success?
+              Aidp.log_debug("build_processor", "quick_validation_test_failed", command: command)
+              return false
+            end
+          end
+
+          # Try to run linters
+          lint_commands = harness_config.dig(:harness, :linters) ||
+            harness_config.dig("harness", "linters") || []
+
+          lint_commands.each do |cmd|
+            command = cmd.is_a?(Hash) ? (cmd[:command] || cmd["command"]) : cmd.to_s
+            next if command.nil? || command.empty?
+
+            Aidp.log_debug("build_processor", "quick_validation_running_lint", command: command)
+            _stdout, _stderr, status = Open3.capture3(command)
+            unless status.success?
+              Aidp.log_debug("build_processor", "quick_validation_lint_failed", command: command)
+              return false
+            end
+          end
+
+          Aidp.log_debug("build_processor", "quick_validation_passed")
+          true
+        end
+      rescue => e
+        Aidp.log_warn("build_processor", "quick_validation_error", error: e.message)
+        false
+      end
     end
   end
 end

data/lib/aidp/watch/github_state_extractor.rb

@@ -17,18 +17,10 @@ module Aidp
       # Pattern for detecting plan proposal comments
       PLAN_PROPOSAL_PATTERN = /<!-- PLAN_SUMMARY_START -->/i
 
-      # Pattern for detecting in-progress label
-      IN_PROGRESS_LABEL = "aidp-in-progress"
-
       def initialize(repository_client:)
         @repository_client = repository_client
       end
 
-      # Check if an issue/PR is currently being worked on by another instance
-      def in_progress?(item)
-        has_label?(item, IN_PROGRESS_LABEL)
-      end
-
       # Check if build is already completed for an issue
       # Looks for completion comment from AIDP
       def build_completed?(issue)