aidp 0.14.1 → 0.15.0

data/lib/aidp/execute/deterministic_unit.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../message_display"
+require_relative "../rescue_logging"
+require_relative "../util"
+
+module Aidp
+  module Execute
+    module DeterministicUnits
+      # Represents a deterministic unit configured in aidp.yml.
+      # Definitions are immutable and provide helper accessors used by the scheduler.
+      class Definition
+        VALID_TYPES = [:command, :wait].freeze
+        NEXT_KEY_ALIASES = {
+          if_pass: :success,
+          if_success: :success,
+          if_fail: :failure,
+          if_failure: :failure,
+          if_error: :failure,
+          if_timeout: :timeout,
+          if_wait: :waiting,
+          if_new_item: :event,
+          if_event: :event
+        }.freeze
+
+        attr_reader :name, :type, :command, :output_file, :next_map,
+          :min_interval_seconds, :max_backoff_seconds, :backoff_multiplier,
+          :enabled, :metadata
+
+        def initialize(config)
+          @name = config.fetch(:name)
+          @type = normalize_type(config[:type]) || default_type_for(config)
+          validate_type!
+
+          @command = config[:command]
+          @output_file = config[:output_file]
+          @next_map = normalize_next_config(config[:next] || {})
+          @min_interval_seconds = config.fetch(:min_interval_seconds, 60)
+          @max_backoff_seconds = config.fetch(:max_backoff_seconds, 900)
+          @backoff_multiplier = config.fetch(:backoff_multiplier, 2.0)
+          @enabled = config.fetch(:enabled, true)
+          @metadata = config.fetch(:metadata, {}).dup
+        end
+
+        def command?
+          type == :command
+        end
+
+        def wait?
+          type == :wait
+        end
+
+        def next_for(result_status, default: nil)
+          next_map[result_status.to_sym] || default || next_map[:else]
+        end
+
+        private
+
+        def normalize_type(type)
+          return nil if type.nil?
+          symbol = type.to_sym
+          VALID_TYPES.include?(symbol) ? symbol : nil
+        end
+
+        def default_type_for(config)
+          return :command if config[:command]
+          :wait
+        end
+
+        def validate_type!
+          return if VALID_TYPES.include?(type)
+          raise ArgumentError, "Unsupported deterministic unit type: #{type.inspect}"
+        end
+
+        def normalize_next_config(raw)
+          return {} unless raw
+
+          raw.each_with_object({}) do |(key, value), normalized|
+            symbol_key = key.to_sym
+            normalized[NEXT_KEY_ALIASES.fetch(symbol_key, symbol_key)] = value
+          end
+        end
+      end
+
+      # Result wrapper returned after executing a deterministic unit.
+      class Result
+        attr_reader :name, :status, :output_path, :started_at, :finished_at,
+          :duration, :data, :error
+
+        def initialize(name:, status:, output_path:, started_at:, finished_at:, data: {}, error: nil)
+          @name = name
+          @status = status.to_sym
+          @output_path = output_path
+          @started_at = started_at
+          @finished_at = finished_at
+          @duration = finished_at - started_at
+          @data = data
+          @error = error
+        end
+
+        def success?
+          status == :success
+        end
+
+        def failure?
+          status == :failure
+        end
+
+        def timeout?
+          status == :timeout
+        end
+      end
+
+      # Executes deterministic units by running commands or internal behaviours.
+      class Runner
+        include Aidp::MessageDisplay
+        include Aidp::RescueLogging
+
+        DEFAULT_TIMEOUT = 3600 # One hour ceiling for long-running commands
+
+        def initialize(project_dir, command_runner: nil, clock: Time)
+          @project_dir = project_dir
+          @clock = clock
+          @command_runner = command_runner || build_default_command_runner
+        end
+
+        def run(definition, context = {})
+          raise ArgumentError, "Unit #{definition.name} is not enabled" unless definition.enabled
+
+          case definition.type
+          when :command
+            execute_command_unit(definition, context)
+          when :wait
+            execute_wait_unit(definition, context)
+          else
+            raise ArgumentError, "Unsupported deterministic unit type: #{definition.type}"
+          end
+        end
+
+        private
+
+        def execute_command_unit(definition, context)
+          started_at = @clock.now
+          display_message("🛠️  Running deterministic unit: #{definition.name}", type: :info)
+
+          result = @command_runner.call(definition.command, context)
+
+          data = {
+            exit_status: result[:exit_status],
+            stdout: result[:stdout],
+            stderr: result[:stderr]
+          }
+
+          status = result[:exit_status].to_i.zero? ? :success : :failure
+          output_path = write_output(definition, data)
+
+          display_message("✅ Deterministic unit #{definition.name} finished with status #{status}", type: :success) if status == :success
+          display_message("⚠️  Deterministic unit #{definition.name} finished with status #{status}", type: :warning) if status != :success
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: status,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: @clock.now,
+            data: data
+          )
+        rescue => e
+          finished_at = @clock.now
+          log_rescue(e, component: "deterministic_runner", action: "execute_command_unit", fallback: "failure", unit: definition.name)
+          display_message("❌ Deterministic unit #{definition.name} failed: #{e.message}", type: :error)
+
+          output_path = write_output(definition, {error: e.message})
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: :failure,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: finished_at,
+            data: {error: e.message},
+            error: e
+          )
+        end
+
+        def execute_wait_unit(definition, context)
+          started_at = @clock.now
+
+          wait_seconds = definition.metadata.fetch(:interval_seconds, 60)
+          backoff_seconds = definition.metadata.fetch(:backoff_seconds, wait_seconds)
+          reason = context[:reason] || "Waiting for GitHub activity"
+
+          display_message("🕒 Deterministic wait: #{definition.name} (#{reason})", type: :info)
+          max_window = definition.max_backoff_seconds || backoff_seconds
+          sleep_duration = backoff_seconds.clamp(1, max_window)
+
+          sleep_handler = context[:sleep_handler] || method(:sleep)
+          sleep_handler.call(sleep_duration)
+
+          event_detected = context[:event_detected] == true
+
+          payload = {
+            message: "Waited #{sleep_duration} seconds",
+            reason: reason,
+            backoff_seconds: sleep_duration,
+            event_detected: event_detected
+          }
+
+          output_path = write_output(definition, payload)
+
+          DeterministicUnits::Result.new(
+            name: definition.name,
+            status: event_detected ? :event : :waiting,
+            output_path: output_path,
+            started_at: started_at,
+            finished_at: @clock.now,
+            data: payload
+          )
+        end
+
+        def write_output(definition, payload)
+          return nil unless definition.output_file
+
+          path = File.join(@project_dir, definition.output_file)
+          Aidp::Util.safe_file_write(path, payload.to_yaml)
+          path
+        end
+
+        def build_default_command_runner
+          lambda do |command, _context|
+            require "tty-command"
+
+            cmd = TTY::Command.new(printer: :quiet)
+            result = cmd.run(command, chdir: @project_dir)
+
+            {
+              exit_status: result.exit_status,
+              stdout: result.out,
+              stderr: result.err
+            }
+          rescue TTY::Command::ExitError => e
+            result = e.result
+            {
+              exit_status: result.exit_status,
+              stdout: result.out,
+              stderr: result.err
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/execute/interactive_repl.rb

@@ -4,6 +4,7 @@ require "tty-prompt"
 require "tty-spinner"
 require_relative "async_work_loop_runner"
 require_relative "repl_macros"
+require_relative "../rescue_logging"
 
 module Aidp
   module Execute
@@ -19,6 +20,8 @@ module Aidp
     #   repl = InteractiveRepl.new(project_dir, provider_manager, config)
     #   repl.start_work_loop(step_name, step_spec, context)
     class InteractiveRepl
+      include Aidp::RescueLogging
+
       def initialize(project_dir, provider_manager, config, options = {})
         @project_dir = project_dir
         @provider_manager = provider_manager
@@ -85,6 +88,7 @@ module Aidp
           rescue Interrupt
             handle_interrupt
           rescue => e
+            log_rescue(e, component: "interactive_repl", action: "repl_command_loop", fallback: "error_display")
             @prompt.error("REPL error: #{e.message}")
           end
         end
@@ -98,6 +102,7 @@ module Aidp
         command = $stdin.gets&.chomp
         command&.strip
       rescue => e
+        log_rescue(e, component: "interactive_repl", action: "read_command", fallback: nil)
         @prompt.error("Input error: #{e.message}")
         nil
       end
@@ -165,6 +170,7 @@ module Aidp
           @prompt.error(result[:message])
         end
       rescue => e
+        log_rescue(e, component: "interactive_repl", action: "handle_command", fallback: "error_display", command: result[:data])
         @prompt.error("Command error: #{e.message}")
       end
 
@@ -215,6 +221,7 @@ module Aidp
           message: success ? "Reset #{count} commit(s)" : output
         }
       rescue => e
+        log_rescue(e, component: "interactive_repl", action: "git_reset", fallback: "error_result", count: count)
         {success: false, message: e.message}
       end
 

data/lib/aidp/execute/steps.rb

@@ -128,7 +128,7 @@ module Aidp
         # Simple task execution - for one-off commands and simple fixes
         "99_SIMPLE_TASK" => {
           "templates" => ["implementation/simple_task.md"],
-          "description" => "Execute Simple Task (one-off commands, quick fixes, linting)",
+          "description" => "Execute Simple Task (one-off commands, quick fixes, linting; emit NEXT_UNIT when more tooling is needed)",
           "outs" => [],
           "gate" => false,
           "simple" => true # Special step for simple, focused tasks

data/lib/aidp/execute/work_loop_runner.rb

@@ -4,6 +4,9 @@ require_relative "prompt_manager"
 require_relative "checkpoint"
 require_relative "checkpoint_display"
 require_relative "guard_policy"
+require_relative "work_loop_unit_scheduler"
+require_relative "deterministic_unit"
+require_relative "agent_signal_parser"
 require_relative "../harness/test_runner"
 
 module Aidp
@@ -53,6 +56,8 @@ module Aidp
         @options = options
         @current_state = :ready
         @state_history = []
+        @deterministic_runner = DeterministicUnits::Runner.new(project_dir)
+        @unit_scheduler = nil
       end
 
       # Execute a step using fix-forward work loop pattern
@@ -63,86 +68,218 @@ module Aidp
         @iteration_count = 0
         transition_to(:ready)
 
-        display_message("🔄 Starting fix-forward work loop for step: #{step_name}", type: :info)
-        display_message("  State machine: READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH}", type: :info)
+        Aidp.logger.info("work_loop", "Starting hybrid work loop execution", step: step_name, max_iterations: MAX_ITERATIONS)
+
+        display_message("🔄 Starting hybrid work loop for step: #{step_name}", type: :info)
+        display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
 
-        # Display guard policy status
         display_guard_policy_status
 
-        # Create initial PROMPT.md
+        @unit_scheduler = WorkLoopUnitScheduler.new(units_config)
+        base_context = context.dup
+
+        loop do
+          unit = @unit_scheduler.next_unit
+          break unless unit
+
+          if unit.deterministic?
+            result = @deterministic_runner.run(unit.definition, reason: "scheduled by work loop")
+            @unit_scheduler.record_deterministic_result(unit.definition, result)
+            next
+          end
+
+          enriched_context = base_context.merge(
+            deterministic_outputs: @unit_scheduler.deterministic_context,
+            previous_agent_summary: @unit_scheduler.last_agentic_summary
+          )
+
+          agentic_payload = if unit.name == :decide_whats_next
+            run_decider_agentic_unit(enriched_context)
+          else
+            run_primary_agentic_unit(step_spec, enriched_context)
+          end
+
+          @unit_scheduler.record_agentic_result(
+            agentic_payload[:raw_result] || {},
+            requested_next: agentic_payload[:requested_next],
+            summary: agentic_payload[:summary],
+            completed: agentic_payload[:completed]
+          )
+
+          return agentic_payload[:response] if agentic_payload[:terminate]
+        end
+
+        build_max_iterations_result
+      end
+
+      private
+
+      def run_primary_agentic_unit(step_spec, context)
+        Aidp.logger.info("work_loop", "Running primary agentic unit", step: @step_name)
+
+        display_message("  State machine: READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH}", type: :info)
+
+        @iteration_count = 0
+        @current_state = :ready
+        @state_history.clear
+
         create_initial_prompt(step_spec, context)
 
-        # Main fix-forward work loop
         loop do
           @iteration_count += 1
           display_message("  Iteration #{@iteration_count} [State: #{STATES[@current_state]}]", type: :info)
 
-          break if @iteration_count > MAX_ITERATIONS
+          if @iteration_count > MAX_ITERATIONS
+            Aidp.logger.error("work_loop", "Max iterations exceeded", step: @step_name, iterations: @iteration_count)
+            display_message("⚠️  Max iterations (#{MAX_ITERATIONS}) reached for #{@step_name}", type: :warning)
+            display_state_summary
+            archive_and_cleanup
+            return build_agentic_payload(
+              agent_result: nil,
+              response: build_max_iterations_result,
+              summary: nil,
+              completed: false,
+              terminate: true
+            )
+          end
 
-          # State: READY - Starting new iteration
           transition_to(:ready) unless @current_state == :ready
 
-          # State: APPLY_PATCH - Agent applies changes
           transition_to(:apply_patch)
-          result = apply_patch
+          agent_result = apply_patch
 
-          # State: TEST - Run tests and linters
           transition_to(:test)
           test_results = @test_runner.run_tests
           lint_results = @test_runner.run_linters
 
-          # Record checkpoint at intervals
           record_periodic_checkpoint(test_results, lint_results)
 
-          # Check if tests passed
           tests_pass = test_results[:success] && lint_results[:success]
 
           if tests_pass
-            # State: PASS - Tests passed
             transition_to(:pass)
 
-            # Check if agent marked work complete
-            if agent_marked_complete?(result)
-              # State: DONE - Work complete
+            if agent_marked_complete?(agent_result)
               transition_to(:done)
               record_final_checkpoint(test_results, lint_results)
-              display_message("✅ Step #{step_name} completed after #{@iteration_count} iterations", type: :success)
+              display_message("✅ Step #{@step_name} completed after #{@iteration_count} iterations", type: :success)
               display_state_summary
               archive_and_cleanup
-              return build_success_result(result)
+
+              return build_agentic_payload(
+                agent_result: agent_result,
+                response: build_success_result(agent_result),
+                summary: agent_result[:output],
+                completed: true,
+                terminate: true
+              )
             else
-              # Tests pass but work not complete - continue
               display_message("  Tests passed but work not marked complete", type: :info)
               transition_to(:next_patch)
             end
           else
-            # State: FAIL - Tests failed
             transition_to(:fail)
             display_message("  Tests or linters failed", type: :warning)
 
-            # State: DIAGNOSE - Analyze failures
             transition_to(:diagnose)
             diagnostic = diagnose_failures(test_results, lint_results)
 
-            # State: NEXT_PATCH - Prepare for next iteration
             transition_to(:next_patch)
             prepare_next_iteration(test_results, lint_results, diagnostic)
           end
         end
+      end
 
-        # Safety: max iterations reached
-        display_message("⚠️  Max iterations (#{MAX_ITERATIONS}) reached for #{step_name}", type: :warning)
-        display_state_summary
-        archive_and_cleanup
-        build_max_iterations_result
+      def run_decider_agentic_unit(context)
+        Aidp.logger.info("work_loop", "Running decide_whats_next agentic unit", step: @step_name)
+
+        prompt = build_decider_prompt(context)
+
+        agent_result = @provider_manager.execute_with_provider(
+          @provider_manager.current_provider,
+          prompt,
+          {
+            step_name: @step_name,
+            iteration: @iteration_count,
+            project_dir: @project_dir,
+            mode: :decide_whats_next
+          }
+        )
+
+        requested = AgentSignalParser.extract_next_unit(agent_result[:output])
+
+        build_agentic_payload(
+          agent_result: agent_result,
+          response: agent_result,
+          summary: agent_result[:output],
+          completed: false,
+          terminate: false,
+          requested_next: requested
+        )
       end
 
-      private
+      def units_config
+        if @config.respond_to?(:work_loop_units_config)
+          @config.work_loop_units_config
+        else
+          {}
+        end
+      end
+
+      def build_agentic_payload(agent_result:, response:, summary:, completed:, terminate:, requested_next: nil)
+        {
+          raw_result: agent_result,
+          response: response,
+          summary: summary,
+          requested_next: requested_next || AgentSignalParser.extract_next_unit(agent_result&.dig(:output)),
+          completed: completed,
+          terminate: terminate
+        }
+      end
+
+      def build_decider_prompt(context)
+        outputs = Array(context[:deterministic_outputs])
+        summary = context[:previous_agent_summary]
+
+        sections = []
+        sections << "# Decide Next Work Loop Unit"
+        sections << ""
+        sections << "You are operating in the Aidp work loop. Determine what should happen next."
+        sections << ""
+        sections << "## Recent Deterministic Outputs"
+
+        if outputs.empty?
+          sections << "- None recorded yet."
+        else
+          outputs.each do |entry|
+            sections << "- #{entry[:name]} (status: #{entry[:status]}, finished_at: #{entry[:finished_at]})"
+            sections << "  Output: #{entry[:output_path] || "n/a"}"
+          end
+        end
+
+        if summary
+          sections << ""
+          sections << "## Previous Agent Summary"
+          sections << summary
+        end
+
+        sections << ""
+        sections << "## Instructions"
+        sections << "- Decide whether to run another deterministic unit or resume agentic editing."
+        sections << "- Announce your decision with `NEXT_UNIT: <unit_name>`."
+        sections << "- Valid values: names defined in configuration, `agentic`, or `wait_for_github`."
+        sections << "- Provide a concise rationale below."
+        sections << ""
+        sections << "## Rationale"
+
+        sections.join("\n")
+      end
 
       # Transition to a new state in the fix-forward state machine
       def transition_to(new_state)
         raise "Invalid state: #{new_state}" unless STATES.key?(new_state)
 
+        old_state = @current_state
         @state_history << {
           from: @current_state,
           to: new_state,
@@ -150,6 +287,7 @@ module Aidp
           timestamp: Time.now
         }
         @current_state = new_state
+        Aidp.logger.debug("work_loop", "State transition", from: old_state, to: new_state, iteration: @iteration_count, step: @step_name)
       end
 
       # Display summary of state transitions
@@ -209,20 +347,24 @@ module Aidp
         prd_content = load_prd
         style_guide = load_style_guide
         user_input = format_user_input(context[:user_input])
+        deterministic_outputs = Array(context[:deterministic_outputs])
+        previous_summary = context[:previous_agent_summary]
 
         initial_prompt = build_initial_prompt_content(
           template: template_content,
           prd: prd_content,
           style_guide: style_guide,
           user_input: user_input,
-          step_name: @step_name
+          step_name: @step_name,
+          deterministic_outputs: deterministic_outputs,
+          previous_agent_summary: previous_summary
         )
 
         @prompt_manager.write(initial_prompt)
         display_message("  Created PROMPT.md (#{initial_prompt.length} chars)", type: :info)
       end
 
-      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:)
+      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:, deterministic_outputs:, previous_agent_summary:)
         parts = []
 
         parts << "# Work Loop: #{step_name}"
@@ -252,6 +394,21 @@ module Aidp
           parts << ""
         end
 
+        if previous_agent_summary && !previous_agent_summary.empty?
+          parts << "## Previous Agent Summary"
+          parts << previous_agent_summary
+          parts << ""
+        end
+
+        unless deterministic_outputs.empty?
+          parts << "## Recent Deterministic Outputs"
+          deterministic_outputs.each do |entry|
+            parts << "- #{entry[:name]} (status: #{entry[:status]})"
+            parts << "  Output: #{entry[:output_path] || "n/a"}"
+          end
+          parts << ""
+        end
+
         if style_guide
           parts << "## LLM Style Guide"
           parts << style_guide