aidp 0.13.0 → 0.14.0

data/lib/aidp/execute/work_loop_runner.rb

@@ -3,24 +3,41 @@
 require_relative "prompt_manager"
 require_relative "checkpoint"
 require_relative "checkpoint_display"
+require_relative "guard_policy"
 require_relative "../harness/test_runner"
 
 module Aidp
   module Execute
-    # Executes work loops for a single step
+    # Executes work loops for a single step using the fix-forward pattern
     # Responsibilities:
     # - Create initial PROMPT.md from templates and context
     # - Loop: send PROMPT.md to agent, run tests/linters, check completion
     # - Only send test/lint failures back to agent
-    # - Track iteration count
+    # - Never rollback, only move forward through fixes
+    # - Track iteration count and state transitions
     # - Record periodic checkpoints with metrics
+    #
+    # Fix-Forward State Machine:
+    # READY → APPLY_PATCH → TEST → {PASS → DONE | FAIL → DIAGNOSE → NEXT_PATCH} → READY
     class WorkLoopRunner
+      # State machine states
+      STATES = {
+        ready: "READY",               # Ready to start new iteration
+        apply_patch: "APPLY_PATCH",   # Agent applying changes
+        test: "TEST",                 # Running tests and linters
+        pass: "PASS",                 # Tests passed
+        fail: "FAIL",                 # Tests failed
+        diagnose: "DIAGNOSE",         # Analyzing failures
+        next_patch: "NEXT_PATCH",     # Preparing next iteration
+        done: "DONE"                  # Work complete
+      }.freeze
       include Aidp::MessageDisplay
 
-      attr_reader :iteration_count, :project_dir
+      attr_reader :iteration_count, :project_dir, :current_state
 
       MAX_ITERATIONS = 50 # Safety limit
       CHECKPOINT_INTERVAL = 5 # Record checkpoint every N iterations
+      STYLE_GUIDE_REMINDER_INTERVAL = 5 # Re-inject LLM_STYLE_GUIDE every N iterations
 
       def initialize(project_dir, provider_manager, config, options = {})
         @project_dir = project_dir
@@ -30,60 +47,162 @@ module Aidp
         @test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
         @checkpoint = Checkpoint.new(project_dir)
         @checkpoint_display = CheckpointDisplay.new
+        @guard_policy = GuardPolicy.new(project_dir, config.guards_config)
         @iteration_count = 0
         @step_name = nil
         @options = options
+        @current_state = :ready
+        @state_history = []
       end
 
-      # Execute a step using work loop pattern
+      # Execute a step using fix-forward work loop pattern
       # Returns final result when step is complete
+      # Never rolls back - only moves forward through fixes
       def execute_step(step_name, step_spec, context = {})
         @step_name = step_name
         @iteration_count = 0
+        transition_to(:ready)
 
-        display_message("🔄 Starting work loop for step: #{step_name}", type: :info)
+        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)
+
+        # Display guard policy status
+        display_guard_policy_status
 
         # Create initial PROMPT.md
         create_initial_prompt(step_spec, context)
 
-        # Main work loop
+        # Main fix-forward work loop
         loop do
           @iteration_count += 1
-          display_message("  Iteration #{@iteration_count}", type: :info)
+          display_message("  Iteration #{@iteration_count} [State: #{STATES[@current_state]}]", type: :info)
 
           break if @iteration_count > MAX_ITERATIONS
 
-          # Send PROMPT.md to agent
-          result = send_to_agent
+          # 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
 
-          # Run tests and linters
+          # 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 step is complete
-          if step_complete?(result, test_results, lint_results)
-            # Record final checkpoint
-            record_final_checkpoint(test_results, lint_results)
-            display_message("✅ Step #{step_name} completed after #{@iteration_count} iterations", type: :success)
-            archive_and_cleanup
-            return build_success_result(result)
+          # 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
+              transition_to(:done)
+              record_final_checkpoint(test_results, lint_results)
+              display_message("✅ Step #{step_name} completed after #{@iteration_count} iterations", type: :success)
+              display_state_summary
+              archive_and_cleanup
+              return build_success_result(result)
+            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
-
-          # If not complete, prepare next iteration with failures (if any)
-          prepare_next_iteration(test_results, lint_results)
         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
       end
 
       private
 
+      # 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)
+
+        @state_history << {
+          from: @current_state,
+          to: new_state,
+          iteration: @iteration_count,
+          timestamp: Time.now
+        }
+        @current_state = new_state
+      end
+
+      # Display summary of state transitions
+      def display_state_summary
+        display_message("\n📊 Fix-Forward State Summary:", type: :info)
+        display_message("  Total iterations: #{@iteration_count}", type: :info)
+        display_message("  State transitions: #{@state_history.size}", type: :info)
+
+        # Count transitions by state
+        state_counts = @state_history.group_by { |h| h[:to] }.transform_values(&:size)
+        state_counts.each do |state, count|
+          display_message("    #{STATES[state]}: #{count} times", type: :info)
+        end
+      end
+
+      # Apply patch - send PROMPT.md to agent
+      def apply_patch
+        send_to_agent
+      end
+
+      # Check if agent marked work complete
+      def agent_marked_complete?(result)
+        result[:status] == "completed" || prompt_marked_complete?
+      end
+
+      # Diagnose test/lint failures
+      # Returns diagnostic information to help agent understand what went wrong
+      def diagnose_failures(test_results, lint_results)
+        diagnostic = {
+          iteration: @iteration_count,
+          failures: []
+        }
+
+        unless test_results[:success]
+          diagnostic[:failures] << {
+            type: "tests",
+            count: test_results[:failures]&.size || 0,
+            commands: test_results[:failures]&.map { |f| f[:command] } || []
+          }
+        end
+
+        unless lint_results[:success]
+          diagnostic[:failures] << {
+            type: "linters",
+            count: lint_results[:failures]&.size || 0,
+            commands: lint_results[:failures]&.map { |f| f[:command] } || []
+          }
+        end
+
+        display_message("  [DIAGNOSE] Found #{diagnostic[:failures].size} failure types", type: :warning)
+        diagnostic
+      end
+
       # Create initial PROMPT.md with all context
       def create_initial_prompt(step_spec, context)
         template_content = load_template(step_spec["templates"]&.first)
@@ -168,17 +287,6 @@ module Aidp
         )
       end
 
-      def step_complete?(agent_result, test_results, lint_results)
-        # Check if agent marked step complete
-        agent_complete = agent_result[:status] == "completed" || prompt_marked_complete?
-
-        # Check if tests and linters pass
-        tests_pass = test_results[:success]
-        linters_pass = lint_results[:success]
-
-        agent_complete && tests_pass && linters_pass
-      end
-
       def prompt_marked_complete?
         prompt_content = @prompt_manager.read
         return false unless prompt_content
@@ -187,30 +295,104 @@ module Aidp
         prompt_content.match?(/^STATUS:\s*COMPLETE/i)
       end
 
-      def prepare_next_iteration(test_results, lint_results)
+      def prepare_next_iteration(test_results, lint_results, diagnostic = nil)
         # Only append failures to PROMPT.md for agent to see
+        # This follows fix-forward: never rollback, only add information for next patch
         failures = []
 
+        failures << "## Fix-Forward Iteration #{@iteration_count}"
+        failures << ""
+
+        # Re-inject LLM_STYLE_GUIDE at regular intervals to prevent drift
+        if should_reinject_style_guide?
+          failures << reinject_style_guide_reminder
+          failures << ""
+        end
+
+        if diagnostic
+          failures << "### Diagnostic Summary"
+          diagnostic[:failures].each do |failure_info|
+            failures << "- #{failure_info[:type].capitalize}: #{failure_info[:count]} failures"
+          end
+          failures << ""
+        end
+
         unless test_results[:success]
-          failures << "## Test Failures"
+          failures << "### Test Failures"
           failures << test_results[:output]
           failures << ""
         end
 
         unless lint_results[:success]
-          failures << "## Linter Failures"
+          failures << "### Linter Failures"
           failures << lint_results[:output]
           failures << ""
         end
 
-        return if failures.empty?
+        failures << "**Fix-forward instructions**: Do not rollback changes. Build on what exists and fix the failures above."
+        failures << ""
+
+        return if test_results[:success] && lint_results[:success]
 
         # Append failures to PROMPT.md
         current_prompt = @prompt_manager.read
         updated_prompt = current_prompt + "\n\n---\n\n" + failures.join("\n")
         @prompt_manager.write(updated_prompt)
 
-        display_message("  Added failure reports to PROMPT.md", type: :warning)
+        display_message("  [NEXT_PATCH] Added failure reports and diagnostic to PROMPT.md", type: :warning)
+      end
+
+      # Check if we should reinject the style guide at this iteration
+      def should_reinject_style_guide?
+        # Reinject on intervals (5, 10, 15, etc.) but not on iteration 1
+        @iteration_count > 1 && (@iteration_count % STYLE_GUIDE_REMINDER_INTERVAL == 0)
+      end
+
+      # Create style guide reminder text
+      def reinject_style_guide_reminder
+        style_guide = load_style_guide
+        template_content = load_current_template
+
+        reminder = []
+        reminder << "### 🔄 Style Guide & Template Reminder (Iteration #{@iteration_count})"
+        reminder << ""
+        reminder << "**IMPORTANT**: To prevent drift from project conventions, please review:"
+        reminder << ""
+
+        if style_guide
+          reminder << "#### LLM Style Guide"
+          reminder << "```"
+          # Include first 1000 chars of style guide to keep context manageable
+          style_guide_preview = (style_guide.length > 1000) ? style_guide[0...1000] + "\n...(truncated)" : style_guide
+          reminder << style_guide_preview
+          reminder << "```"
+          reminder << ""
+          display_message("  [STYLE_GUIDE] Re-injecting LLM_STYLE_GUIDE at iteration #{@iteration_count}", type: :info)
+        end
+
+        if template_content
+          reminder << "#### Original Template Requirements"
+          reminder << "Remember the original task template requirements. Don't lose sight of the core objectives."
+          reminder << ""
+        end
+
+        reminder << "**Note**: Test failures may indicate style guide violations, not just logic errors."
+        reminder << "Ensure your fixes align with project conventions above."
+
+        reminder.join("\n")
+      end
+
+      # Load current step's template content
+      def load_current_template
+        return nil unless @step_name
+
+        step_spec = Aidp::Execute::Steps::SPEC[@step_name]
+        return nil unless step_spec
+
+        template_name = step_spec["templates"]&.first
+        return nil unless template_name
+
+        load_template(template_name)
       end
 
       def archive_and_cleanup
@@ -303,6 +485,110 @@ module Aidp
         summary = @checkpoint.progress_summary
         @checkpoint_display.display_progress_summary(summary) if summary
       end
+
+      # Display guard policy status
+      def display_guard_policy_status
+        return unless @guard_policy.enabled?
+
+        display_message("\n🛡️  Safety Guards Enabled:", type: :info)
+        summary = @guard_policy.summary
+
+        if summary[:include_patterns].any?
+          display_message("  ✓ Include patterns: #{summary[:include_patterns].join(", ")}", type: :info)
+        end
+
+        if summary[:exclude_patterns].any?
+          display_message("  ✗ Exclude patterns: #{summary[:exclude_patterns].join(", ")}", type: :info)
+        end
+
+        if summary[:confirm_patterns].any?
+          display_message("  ⚠️  Require confirmation: #{summary[:confirm_patterns].join(", ")}", type: :warning)
+        end
+
+        if summary[:max_lines_per_commit]
+          display_message("  📏 Max lines per commit: #{summary[:max_lines_per_commit]}", type: :info)
+        end
+
+        display_message("")
+      end
+
+      # Validate changes against guard policy
+      # Returns validation result with errors if any
+      def validate_guard_policy(changed_files = [])
+        return {valid: true} unless @guard_policy.enabled?
+
+        # Get git diff stats for changed files
+        diff_stats = get_diff_stats(changed_files)
+
+        # Validate against policy
+        result = @guard_policy.validate_changes(diff_stats)
+
+        # Display errors if validation failed
+        if !result[:valid] && result[:errors]
+          display_message("\n🛡️  Guard Policy Violations:", type: :error)
+          result[:errors].each do |error|
+            display_message("  ✗ #{error}", type: :error)
+          end
+          display_message("")
+        end
+
+        result
+      end
+
+      # Get git diff statistics for files
+      def get_diff_stats(files)
+        return {} if files.empty?
+
+        stats = {}
+        files.each do |file|
+          # Use git diff to get line counts
+          output = `git diff --numstat HEAD -- "#{file}" 2>/dev/null`.strip
+          next if output.empty?
+
+          parts = output.split("\t")
+          stats[file] = {
+            additions: parts[0].to_i,
+            deletions: parts[1].to_i
+          }
+        end
+
+        stats
+      end
+
+      # Get list of changed files in current work
+      def get_changed_files
+        # Get list of modified files from git
+        output = `git diff --name-only HEAD 2>/dev/null`.strip
+        return [] if output.empty?
+
+        output.split("\n").map(&:strip).reject(&:empty?)
+      end
+
+      # Handle files requiring confirmation
+      def handle_confirmation_requests
+        return unless @guard_policy.enabled?
+
+        files_needing_confirmation = @guard_policy.files_requiring_confirmation
+        return if files_needing_confirmation.empty?
+
+        files_needing_confirmation.each do |file|
+          next if @guard_policy.confirmed?(file)
+
+          display_message("\n⚠️  File requires confirmation: #{file}", type: :warning)
+          display_message("   Confirm modification? (y/n): ", type: :warning)
+
+          # In automated mode, skip confirmation
+          if @options[:automated]
+            display_message("   [Automated mode: skipping]", type: :info)
+            next
+          end
+
+          # For now, auto-confirm in work loops
+          # TODO: Implement interactive confirmation via REPL
+          @guard_policy.confirm_file(file)
+          display_message("   ✓ Confirmed", type: :success)
+        end
+      end
     end
   end
 end

data/lib/aidp/execute/work_loop_state.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Aidp
+  module Execute
+    # Thread-safe state container for async work loop execution
+    # Manages execution state, control signals, and queued modifications
+    class WorkLoopState
+      include MonitorMixin
+
+      STATES = {
+        idle: "IDLE",
+        running: "RUNNING",
+        paused: "PAUSED",
+        cancelled: "CANCELLED",
+        completed: "COMPLETED",
+        error: "ERROR"
+      }.freeze
+
+      attr_reader :current_state, :iteration, :queued_instructions, :last_error
+
+      def initialize
+        super # Initialize MonitorMixin
+        @current_state = :idle
+        @iteration = 0
+        @queued_instructions = []
+        @guard_updates = {}
+        @config_reload_requested = false
+        @last_error = nil
+        @output_buffer = []
+      end
+
+      # Check current state
+      def idle? = @current_state == :idle
+      def running? = @current_state == :running
+      def paused? = @current_state == :paused
+      def cancelled? = @current_state == :cancelled
+      def completed? = @current_state == :completed
+      def error? = @current_state == :error
+
+      # State transitions (thread-safe)
+      def start!
+        synchronize do
+          raise StateError, "Cannot start from #{@current_state}" unless idle?
+          @current_state = :running
+          @iteration = 0
+        end
+      end
+
+      def pause!
+        synchronize do
+          raise StateError, "Cannot pause from #{@current_state}" unless running?
+          @current_state = :paused
+        end
+      end
+
+      def resume!
+        synchronize do
+          raise StateError, "Cannot resume from #{@current_state}" unless paused?
+          @current_state = :running
+        end
+      end
+
+      def cancel!
+        synchronize do
+          raise StateError, "Cannot cancel from #{@current_state}" if completed? || error?
+          @current_state = :cancelled
+        end
+      end
+
+      def complete!
+        synchronize do
+          @current_state = :completed
+        end
+      end
+
+      def error!(error)
+        synchronize do
+          @current_state = :error
+          @last_error = error
+        end
+      end
+
+      # Iteration management
+      def increment_iteration!
+        synchronize { @iteration += 1 }
+      end
+
+      # Instruction queueing
+      def enqueue_instruction(instruction)
+        synchronize { @queued_instructions << instruction }
+      end
+
+      def dequeue_instructions
+        synchronize do
+          instructions = @queued_instructions.dup
+          @queued_instructions.clear
+          instructions
+        end
+      end
+
+      def queued_count
+        synchronize { @queued_instructions.size }
+      end
+
+      # Guard/config updates
+      def request_guard_update(key, value)
+        synchronize { @guard_updates[key] = value }
+      end
+
+      def pending_guard_updates
+        synchronize do
+          updates = @guard_updates.dup
+          @guard_updates.clear
+          updates
+        end
+      end
+
+      def request_config_reload
+        synchronize { @config_reload_requested = true }
+      end
+
+      def config_reload_requested?
+        synchronize do
+          requested = @config_reload_requested
+          @config_reload_requested = false
+          requested
+        end
+      end
+
+      # Output buffering for streaming display
+      def append_output(message, type: :info)
+        synchronize do
+          @output_buffer << {message: message, type: type, timestamp: Time.now}
+        end
+      end
+
+      def drain_output
+        synchronize do
+          output = @output_buffer.dup
+          @output_buffer.clear
+          output
+        end
+      end
+
+      # Status summary
+      def summary
+        synchronize do
+          {
+            state: STATES[@current_state],
+            iteration: @iteration,
+            queued_instructions: @queued_instructions.size,
+            has_error: !@last_error.nil?
+          }
+        end
+      end
+
+      class StateError < StandardError; end
+    end
+  end
+end