aidp 0.9.6 → 0.11.0

data/lib/aidp/execute/runner.rb

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
 
+require "tty-prompt"
 require_relative "steps"
 require_relative "progress"
+require_relative "work_loop_runner"
 require_relative "../storage/file_manager"
 
 module Aidp
   module Execute
     class Runner
-      def initialize(project_dir, harness_runner = nil)
+      include Aidp::MessageDisplay
+
+      def initialize(project_dir, harness_runner = nil, prompt: TTY::Prompt.new)
         @project_dir = project_dir
         @harness_runner = harness_runner
         @is_harness_mode = !harness_runner.nil?
         @file_manager = Aidp::Storage::FileManager.new(File.join(project_dir, ".aidp"))
+        @prompt = prompt
       end
 
       def progress
         @progress ||= Aidp::Execute::Progress.new(@project_dir)
       end
 
+      private
+
+      public
+
       def run_step(step_name, options = {})
         # Always validate step exists first
         step_spec = Aidp::Execute::Steps::SPEC[step_name]
@@ -33,23 +42,22 @@ module Aidp
 
       # Harness-aware step execution
       def run_step_with_harness(step_name, options = {})
-        # Get current provider from harness
-        current_provider = @harness_runner.instance_variable_get(:@current_provider)
-        provider_type = current_provider || "cursor"
-
-        # Compose prompt with harness context
-        prompt = composed_prompt_with_harness_context(step_name, options)
-
-        # Execute with harness error handling
-        result = execute_with_harness_provider(provider_type, prompt, step_name, options)
+        step_spec = Aidp::Execute::Steps::SPEC[step_name]
 
-        # Process result for harness
-        process_result_for_harness(result, step_name, options)
+        # Check if work loops are enabled in configuration
+        config = @harness_runner.instance_variable_get(:@configuration)
+        if config&.work_loop_enabled?
+          # Use WorkLoopRunner for execution
+          run_step_with_work_loop(step_name, step_spec, options)
+        else
+          # Use traditional single-pass execution
+          run_step_traditional(step_name, step_spec, options)
+        end
       end
 
       # Standalone step execution (simplified - synchronous)
       def run_step_standalone(step_name, options = {})
-        puts "🚀 Running execution step synchronously: #{step_name}"
+        display_message("🚀 Running execution step synchronously: #{step_name}", type: :info)
 
         start_time = Time.now
         prompt = composed_prompt(step_name, options)
@@ -62,7 +70,7 @@ module Aidp
         # Store execution metrics
         @file_manager.record_step_execution(step_name, "cursor", duration, result[:status] == "completed")
 
-        puts "✅ Execution step completed in #{duration.round(2)}s"
+        display_message("✅ Execution step completed in #{duration.round(2)}s", type: :success)
         result
       end
 
@@ -136,6 +144,42 @@ module Aidp
 
       private
 
+      # Execute step with work loop
+      def run_step_with_work_loop(step_name, step_spec, options)
+        config = @harness_runner.instance_variable_get(:@configuration)
+        provider_manager = @harness_runner.provider_manager
+
+        # Create work loop runner
+        work_loop_runner = WorkLoopRunner.new(
+          @project_dir,
+          provider_manager,
+          config,
+          options
+        )
+
+        # Execute with work loop
+        result = work_loop_runner.execute_step(step_name, step_spec, options)
+
+        # Process result for harness
+        process_result_for_harness(result, step_name, options)
+      end
+
+      # Execute step traditionally (single pass)
+      def run_step_traditional(step_name, step_spec, options)
+        # Get current provider from harness
+        current_provider = @harness_runner.current_provider
+        provider_type = current_provider || "cursor"
+
+        # Compose prompt with harness context
+        prompt = composed_prompt_with_harness_context(step_name, options)
+
+        # Execute with harness error handling
+        result = execute_with_harness_provider(provider_type, prompt, step_name, options)
+
+        # Process result for harness
+        process_result_for_harness(result, step_name, options)
+      end
+
       # Simple synchronous step execution
       def execute_step_synchronously(step_name, prompt, options)
         # Execute step synchronously with provider
@@ -172,11 +216,11 @@ module Aidp
         # Add current execution context
         context_parts << "## Execution Context"
         context_parts << "Project Directory: #{@project_dir}"
-        context_parts << "Current Step: #{@harness_runner.instance_variable_get(:@current_step)}"
-        context_parts << "Current Provider: #{@harness_runner.instance_variable_get(:@current_provider)}"
+        context_parts << "Current Step: #{@harness_runner.current_step}"
+        context_parts << "Current Provider: #{@harness_runner.current_provider}"
 
         # Add user input context
-        user_input = @harness_runner.instance_variable_get(:@user_input)
+        user_input = @harness_runner.user_input
         if user_input && !user_input.empty?
           context_parts << "\n## Previous User Input"
           user_input.each do |key, value|
@@ -185,7 +229,7 @@ module Aidp
         end
 
         # Add execution history context
-        execution_log = @harness_runner.instance_variable_get(:@execution_log)
+        execution_log = @harness_runner.execution_log
         if execution_log && !execution_log.empty?
           context_parts << "\n## Execution History"
           recent_logs = execution_log.last(5) # Last 5 entries
@@ -200,7 +244,7 @@ module Aidp
       # Execute step with harness provider management
       def execute_with_harness_provider(provider_type, prompt, step_name, _options)
         # Get provider manager from harness
-        provider_manager = @harness_runner.instance_variable_get(:@provider_manager)
+        provider_manager = @harness_runner.provider_manager
 
         # Execute with provider
         provider_manager.execute_with_provider(provider_type, prompt, {
@@ -262,7 +306,10 @@ module Aidp
 
       def template_search_paths
         [
-          File.join(@project_dir, "templates", "EXECUTE"),
+          File.join(@project_dir, "templates"),        # Root templates folder
+          File.join(@project_dir, "templates", "planning"),
+          File.join(@project_dir, "templates", "analysis"),
+          File.join(@project_dir, "templates", "implementation"),
           File.join(@project_dir, "templates", "COMMON")
         ]
       end

data/lib/aidp/execute/steps.rb

@@ -4,117 +4,126 @@ module Aidp
   module Execute
     module Steps
       # Simplified step specifications with fewer gates
+      # Templates are now organized by purpose (planning/, analysis/, implementation/)
+      # and named with action verbs for clarity
       SPEC = {
+        "00_LLM_STYLE_GUIDE" => {
+          "templates" => ["planning/generate_llm_style_guide.md"],
+          "description" => "Generate project-specific LLM Style Guide",
+          "outs" => ["docs/LLM_STYLE_GUIDE.md"],
+          "gate" => false,
+          "interactive" => false
+        },
         "00_PRD" => {
-          "templates" => ["prd.md"],
+          "templates" => ["planning/create_prd.md"],
           "description" => "Generate Product Requirements Document",
           "outs" => ["docs/prd.md"],
-          "gate" => false,  # Now auto-generated from user input
-          "interactive" => true  # Uses collected user input
+          "gate" => false, # Now auto-generated from user input
+          "interactive" => true # Uses collected user input
         },
         "01_NFRS" => {
-          "templates" => ["nfrs.md"],
+          "templates" => ["planning/define_nfrs.md"],
           "description" => "Define Non-Functional Requirements",
           "outs" => ["docs/nfrs.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         "02_ARCHITECTURE" => {
-          "templates" => ["architecture.md"],
+          "templates" => ["planning/design_architecture.md"],
           "description" => "Design System Architecture",
           "outs" => ["docs/architecture.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         "02A_ARCH_GATE_QUESTIONS" => {
-          "templates" => ["arch_gate_questions.md"],
+          "templates" => ["planning/ask_architecture_questions.md"],
           "description" => "Architecture Gate Questions",
           "outs" => ["docs/arch_gate_questions.md"],
           "gate" => true
         },
         "03_ADR_FACTORY" => {
-          "templates" => ["adr_factory.md"],
+          "templates" => ["planning/generate_adrs.md"],
           "description" => "Generate Architecture Decision Records",
           "outs" => ["docs/adr/*.md"],
           "gate" => false
         },
         "04_DOMAIN_DECOMPOSITION" => {
-          "templates" => ["domain_decomposition.md"],
+          "templates" => ["planning/decompose_domain.md"],
           "description" => "Decompose Domain into Components",
           "outs" => ["docs/domain_decomposition.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         "05_API_DESIGN" => {
-          "templates" => ["api_design.md"],
+          "templates" => ["planning/design_apis.md"],
           "description" => "Design APIs and Interfaces",
           "outs" => ["docs/api_design.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         "06_DATA_MODEL" => {
-          "templates" => ["data_model.md"],
+          "templates" => ["planning/design_data_model.md"],
           "description" => "Design Data Model",
           "outs" => ["docs/data_model.md"],
           "gate" => true
         },
         "07_SECURITY_REVIEW" => {
-          "templates" => ["security_review.md"],
+          "templates" => ["planning/plan_testing.md"],
           "description" => "Security Review and Threat Model",
           "outs" => ["docs/security_review.md"],
           "gate" => true
         },
         "08_PERFORMANCE_REVIEW" => {
-          "templates" => ["performance_review.md"],
+          "templates" => ["planning/create_tasks.md"],
           "description" => "Performance Review and Optimization",
           "outs" => ["docs/performance_review.md"],
           "gate" => true
         },
         "09_RELIABILITY_REVIEW" => {
-          "templates" => ["reliability_review.md"],
+          "templates" => ["implementation/setup_scaffolding.md"],
           "description" => "Reliability Review and SLOs",
           "outs" => ["docs/reliability_review.md"],
           "gate" => true
         },
         "10_TESTING_STRATEGY" => {
-          "templates" => ["testing_strategy.md"],
+          "templates" => ["implementation/implement_features.md"],
           "description" => "Define Testing Strategy",
           "outs" => ["docs/testing_strategy.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         "11_STATIC_ANALYSIS" => {
-          "templates" => ["static_analysis.md"],
+          "templates" => ["implementation/configure_static_analysis.md"],
           "description" => "Static Code Analysis",
           "outs" => ["docs/static_analysis.md"],
           "gate" => false
         },
         "12_OBSERVABILITY_SLOS" => {
-          "templates" => ["observability_slos.md"],
+          "templates" => ["planning/plan_observability.md"],
           "description" => "Define Observability and SLOs",
           "outs" => ["docs/observability_slos.md"],
           "gate" => true
         },
         "13_DELIVERY_ROLLOUT" => {
-          "templates" => ["delivery_rollout.md"],
+          "templates" => ["implementation/plan_delivery.md"],
           "description" => "Plan Delivery and Rollout",
           "outs" => ["docs/delivery_rollout.md"],
           "gate" => true
         },
         "14_DOCS_PORTAL" => {
-          "templates" => ["docs_portal.md"],
+          "templates" => ["implementation/create_documentation_portal.md"],
           "description" => "Documentation Portal",
           "outs" => ["docs/docs_portal.md"],
           "gate" => false
         },
         "15_POST_RELEASE" => {
-          "templates" => ["post_release.md"],
+          "templates" => ["implementation/review_post_release.md"],
           "description" => "Post-Release Review",
           "outs" => ["docs/post_release.md"],
-          "gate" => false  # Auto-generated
+          "gate" => false # Auto-generated
         },
         # New implementation step for actual development work
         "16_IMPLEMENTATION" => {
-          "templates" => ["implementation.md"],
+          "templates" => ["implementation/implement_features.md"], # Reuse existing implementation template
           "description" => "Execute Implementation Tasks",
           "outs" => ["implementation_log.md"],
           "gate" => false,
-          "implementation" => true  # Special step that runs development tasks
+          "implementation" => true # Special step that runs development tasks
         }
       }.freeze
     end

data/lib/aidp/execute/work_loop_runner.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative "prompt_manager"
+require_relative "checkpoint"
+require_relative "checkpoint_display"
+require_relative "../harness/test_runner"
+
+module Aidp
+  module Execute
+    # Executes work loops for a single step
+    # 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
+    # - Record periodic checkpoints with metrics
+    class WorkLoopRunner
+      include Aidp::MessageDisplay
+
+      attr_reader :iteration_count, :project_dir
+
+      MAX_ITERATIONS = 50 # Safety limit
+      CHECKPOINT_INTERVAL = 5 # Record checkpoint every N iterations
+
+      def initialize(project_dir, provider_manager, config, options = {})
+        @project_dir = project_dir
+        @provider_manager = provider_manager
+        @config = config
+        @prompt_manager = PromptManager.new(project_dir)
+        @test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
+        @checkpoint = Checkpoint.new(project_dir)
+        @checkpoint_display = CheckpointDisplay.new
+        @iteration_count = 0
+        @step_name = nil
+        @options = options
+      end
+
+      # Execute a step using work loop pattern
+      # Returns final result when step is complete
+      def execute_step(step_name, step_spec, context = {})
+        @step_name = step_name
+        @iteration_count = 0
+
+        display_message("🔄 Starting work loop for step: #{step_name}", type: :info)
+
+        # Create initial PROMPT.md
+        create_initial_prompt(step_spec, context)
+
+        # Main work loop
+        loop do
+          @iteration_count += 1
+          display_message("  Iteration #{@iteration_count}", type: :info)
+
+          break if @iteration_count > MAX_ITERATIONS
+
+          # Send PROMPT.md to agent
+          result = send_to_agent
+
+          # Run tests and linters
+          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)
+          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)
+        archive_and_cleanup
+        build_max_iterations_result
+      end
+
+      private
+
+      # Create initial PROMPT.md with all context
+      def create_initial_prompt(step_spec, context)
+        template_content = load_template(step_spec["templates"]&.first)
+        prd_content = load_prd
+        style_guide = load_style_guide
+        user_input = format_user_input(context[:user_input])
+
+        initial_prompt = build_initial_prompt_content(
+          template: template_content,
+          prd: prd_content,
+          style_guide: style_guide,
+          user_input: user_input,
+          step_name: @step_name
+        )
+
+        @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:)
+        parts = []
+
+        parts << "# Work Loop: #{step_name}"
+        parts << ""
+        parts << "## Instructions"
+        parts << "You are working in a work loop. Your responsibilities:"
+        parts << "1. Read this PROMPT.md file to understand what needs to be done"
+        parts << "2. Complete the work described below"
+        parts << "3. **IMPORTANT**: Edit this PROMPT.md file yourself to:"
+        parts << "   - Remove completed items"
+        parts << "   - Update with current status"
+        parts << "   - Keep it concise (remove unnecessary context)"
+        parts << "   - Mark the step COMPLETE when 100% done"
+        parts << "4. After you finish, tests and linters will run automatically"
+        parts << "5. If tests/linters fail, you'll see the errors in the next iteration"
+        parts << ""
+        parts << "## Completion Criteria"
+        parts << "Mark this step COMPLETE by adding this line to PROMPT.md:"
+        parts << "```"
+        parts << "STATUS: COMPLETE"
+        parts << "```"
+        parts << ""
+
+        if user_input && !user_input.empty?
+          parts << "## User Input"
+          parts << user_input
+          parts << ""
+        end
+
+        if style_guide
+          parts << "## LLM Style Guide"
+          parts << style_guide
+          parts << ""
+        end
+
+        if prd
+          parts << "## Product Requirements (PRD)"
+          parts << prd
+          parts << ""
+        end
+
+        parts << "## Task Template"
+        parts << template
+        parts << ""
+
+        parts.join("\n")
+      end
+
+      def send_to_agent
+        prompt_content = @prompt_manager.read
+        return {status: "error", message: "PROMPT.md not found"} unless prompt_content
+
+        # Send to provider via provider_manager
+        @provider_manager.execute_with_provider(
+          @provider_manager.current_provider,
+          prompt_content,
+          {
+            step_name: @step_name,
+            iteration: @iteration_count,
+            project_dir: @project_dir
+          }
+        )
+      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
+
+        # Check for STATUS: COMPLETE marker
+        prompt_content.match?(/^STATUS:\s*COMPLETE/i)
+      end
+
+      def prepare_next_iteration(test_results, lint_results)
+        # Only append failures to PROMPT.md for agent to see
+        failures = []
+
+        unless test_results[:success]
+          failures << "## Test Failures"
+          failures << test_results[:output]
+          failures << ""
+        end
+
+        unless lint_results[:success]
+          failures << "## Linter Failures"
+          failures << lint_results[:output]
+          failures << ""
+        end
+
+        return if failures.empty?
+
+        # 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)
+      end
+
+      def archive_and_cleanup
+        @prompt_manager.archive(@step_name)
+        @prompt_manager.delete
+      end
+
+      def load_template(template_name)
+        return "" unless template_name
+
+        # Template name now includes subdirectory (e.g., "planning/create_prd.md")
+        template_path = File.join(@project_dir, "templates", template_name)
+        return File.read(template_path) if File.exist?(template_path)
+
+        # Fallback: try COMMON directory
+        common_path = File.join(@project_dir, "templates", "COMMON", template_name)
+        return File.read(common_path) if File.exist?(common_path)
+
+        ""
+      end
+
+      def load_prd
+        prd_path = File.join(@project_dir, "docs", "prd.md")
+        File.exist?(prd_path) ? File.read(prd_path) : nil
+      end
+
+      def load_style_guide
+        style_guide_path = File.join(@project_dir, "docs", "LLM_STYLE_GUIDE.md")
+        File.exist?(style_guide_path) ? File.read(style_guide_path) : nil
+      end
+
+      def format_user_input(user_input)
+        return nil if user_input.nil? || user_input.empty?
+
+        lines = user_input.map { |key, value| "- **#{key}**: #{value}" }
+        lines.join("\n")
+      end
+
+      def build_success_result(agent_result)
+        {
+          status: "completed",
+          message: "Step #{@step_name} completed successfully",
+          iterations: @iteration_count,
+          final_result: agent_result
+        }
+      end
+
+      def build_max_iterations_result
+        {
+          status: "error",
+          message: "Maximum iterations reached",
+          iterations: @iteration_count,
+          error: "Step did not complete within #{MAX_ITERATIONS} iterations"
+        }
+      end
+
+      # Record checkpoint at regular intervals
+      def record_periodic_checkpoint(test_results, lint_results)
+        # Record every CHECKPOINT_INTERVAL iterations or on iteration 1
+        return unless @iteration_count == 1 || (@iteration_count % CHECKPOINT_INTERVAL == 0)
+
+        metrics = {
+          tests_passing: test_results[:success],
+          linters_passing: lint_results[:success]
+        }
+
+        checkpoint_data = @checkpoint.record_checkpoint(@step_name, @iteration_count, metrics)
+
+        # Display inline progress
+        @checkpoint_display.display_inline_progress(@iteration_count, checkpoint_data[:metrics])
+
+        # Show detailed checkpoint every 10 iterations
+        if @iteration_count % 10 == 0
+          @checkpoint_display.display_checkpoint(checkpoint_data)
+        end
+      end
+
+      # Record final checkpoint when step completes
+      def record_final_checkpoint(test_results, lint_results)
+        metrics = {
+          tests_passing: test_results[:success],
+          linters_passing: lint_results[:success],
+          completed: true
+        }
+
+        checkpoint_data = @checkpoint.record_checkpoint(@step_name, @iteration_count, metrics)
+        @checkpoint_display.display_checkpoint(checkpoint_data, show_details: true)
+
+        # Display progress summary
+        summary = @checkpoint.progress_summary
+        @checkpoint_display.display_progress_summary(summary) if summary
+      end
+    end
+  end
+end