aidp 0.10.0 → 0.11.0

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" => ["00_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" => ["01_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" => ["02_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" => ["02A_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" => ["03_ADR_FACTORY.md"],
+          "templates" => ["planning/generate_adrs.md"],
           "description" => "Generate Architecture Decision Records",
           "outs" => ["docs/adr/*.md"],
           "gate" => false
         },
         "04_DOMAIN_DECOMPOSITION" => {
-          "templates" => ["04_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" => ["05_CONTRACTS.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" => ["06_THREAT_MODEL.md"],
+          "templates" => ["planning/design_data_model.md"],
           "description" => "Design Data Model",
           "outs" => ["docs/data_model.md"],
           "gate" => true
         },
         "07_SECURITY_REVIEW" => {
-          "templates" => ["07_TEST_PLAN.md"],
+          "templates" => ["planning/plan_testing.md"],
           "description" => "Security Review and Threat Model",
           "outs" => ["docs/security_review.md"],
           "gate" => true
         },
         "08_PERFORMANCE_REVIEW" => {
-          "templates" => ["08_TASKS.md"],
+          "templates" => ["planning/create_tasks.md"],
           "description" => "Performance Review and Optimization",
           "outs" => ["docs/performance_review.md"],
           "gate" => true
         },
         "09_RELIABILITY_REVIEW" => {
-          "templates" => ["09_SCAFFOLDING_DEVEX.md"],
+          "templates" => ["implementation/setup_scaffolding.md"],
           "description" => "Reliability Review and SLOs",
           "outs" => ["docs/reliability_review.md"],
           "gate" => true
         },
         "10_TESTING_STRATEGY" => {
-          "templates" => ["10_IMPLEMENTATION_AGENT.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" => ["11_STATIC_ANALYSIS.md"],
+          "templates" => ["implementation/configure_static_analysis.md"],
           "description" => "Static Code Analysis",
           "outs" => ["docs/static_analysis.md"],
           "gate" => false
         },
         "12_OBSERVABILITY_SLOS" => {
-          "templates" => ["12_OBSERVABILITY_SLOS.md"],
+          "templates" => ["planning/plan_observability.md"],
           "description" => "Define Observability and SLOs",
           "outs" => ["docs/observability_slos.md"],
           "gate" => true
         },
         "13_DELIVERY_ROLLOUT" => {
-          "templates" => ["13_DELIVERY_ROLLOUT.md"],
+          "templates" => ["implementation/plan_delivery.md"],
           "description" => "Plan Delivery and Rollout",
           "outs" => ["docs/delivery_rollout.md"],
           "gate" => true
         },
         "14_DOCS_PORTAL" => {
-          "templates" => ["14_DOCS_PORTAL.md"],
+          "templates" => ["implementation/create_documentation_portal.md"],
           "description" => "Documentation Portal",
           "outs" => ["docs/docs_portal.md"],
           "gate" => false
         },
         "15_POST_RELEASE" => {
-          "templates" => ["15_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" => ["10_IMPLEMENTATION_AGENT.md"],  # Reuse existing implementation template
+          "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

data/lib/aidp/execute/workflow_selector.rb

@@ -1,42 +1,51 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
+require_relative "../workflows/definitions"
+require_relative "../workflows/selector"
 
 module Aidp
   module Execute
     # Handles interactive workflow selection and project setup
     class WorkflowSelector
+      include Aidp::MessageDisplay
+
       def initialize(prompt: TTY::Prompt.new)
         @user_input = {}
         @prompt = prompt
+        @workflow_selector = Aidp::Workflows::Selector.new(prompt: @prompt)
       end
 
       # Main entry point for interactive workflow selection
-      def select_workflow(harness_mode: false)
+      def select_workflow(harness_mode: false, use_new_selector: true, mode: nil)
         if harness_mode
           # In harness mode, use default values to avoid blocking
           select_workflow_with_defaults
+        elsif use_new_selector
+          # Use new unified workflow selector (default as of Issue #79)
+          select_workflow_with_new_selector(mode)
         else
-          # Interactive mode for standalone usage
+          # Legacy interactive mode for backward compatibility
           select_workflow_interactive
         end
       end
 
       private
 
-      # Helper method for consistent message display using TTY::Prompt
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
+      def select_workflow_with_new_selector(mode = nil)
+        # Step 1: Collect project information (still useful for all workflows)
+        collect_project_info
 
-        @prompt.say(message, color: color)
+        # Step 2: Use new workflow selector, defaulting to execute mode if not specified
+        workflow_mode = mode || :execute
+        result = @workflow_selector.select_workflow(workflow_mode)
+
+        {
+          workflow_type: result[:workflow_key],
+          steps: result[:steps],
+          user_input: @user_input,
+          workflow: result[:workflow]
+        }
       end
 
       def select_workflow_interactive
@@ -144,10 +153,10 @@ module Aidp
 
       def exploration_workflow_steps
         [
-          "00_PRD",           # Generate PRD from user input (no manual gate)
+          "00_PRD", # Generate PRD from user input (no manual gate)
           "10_TESTING_STRATEGY", # Ensure we have tests
-          "11_STATIC_ANALYSIS",  # Code quality
-          "16_IMPLEMENTATION"    # Special step for actual development work
+          "11_STATIC_ANALYSIS", # Code quality
+          "16_IMPLEMENTATION" # Special step for actual development work
         ]
       end
 

data/lib/aidp/harness/condition_detector.rb

@@ -1310,13 +1310,13 @@ module Aidp
       # Get timeout duration for operation type
       def get_timeout_duration(operation_type, configuration = nil)
         default_timeouts = {
-          analyze: 300,      # 5 minutes
-          execute: 600,      # 10 minutes
+          analyze: 300, # 5 minutes
+          execute: 600, # 10 minutes
           provider_call: 120, # 2 minutes
           file_operation: 30, # 30 seconds
           network_request: 60, # 1 minute
-          user_input: 300,   # 5 minutes
-          default: 120       # 2 minutes
+          user_input: 300, # 5 minutes
+          default: 120 # 2 minutes
         }
 
         # Get timeout from configuration if available

data/lib/aidp/harness/config_schema.rb

@@ -366,6 +366,46 @@ module Aidp
                   enum: ["provider_model", "provider", "model", "none"]
                 }
               }
+            },
+            work_loop: {
+              type: :hash,
+              required: false,
+              default: {
+                enabled: true,
+                max_iterations: 50,
+                test_commands: [],
+                lint_commands: []
+              },
+              properties: {
+                enabled: {
+                  type: :boolean,
+                  required: false,
+                  default: true
+                },
+                max_iterations: {
+                  type: :integer,
+                  required: false,
+                  default: 50,
+                  min: 1,
+                  max: 200
+                },
+                test_commands: {
+                  type: :array,
+                  required: false,
+                  default: [],
+                  items: {
+                    type: :string
+                  }
+                },
+                lint_commands: {
+                  type: :array,
+                  required: false,
+                  default: [],
+                  items: {
+                    type: :string
+                  }
+                }
+              }
             }
           }
         },

data/lib/aidp/harness/config_validator.rb

@@ -76,8 +76,9 @@ module Aidp
         return false if config_exists?
 
         example_config = ConfigSchema.generate_example
-        config_path = File.join(@project_dir, "aidp.yml")
+        config_path = File.join(@project_dir, ".aidp", "aidp.yml")
 
+        FileUtils.mkdir_p(File.dirname(config_path))
         File.write(config_path, YAML.dump(example_config))
         true
       end
@@ -243,14 +244,10 @@ module Aidp
       private
 
       def find_config_file
-        # Try new aidp.yml format first, then fall back to .aidp.yml
-        config_file = File.join(@project_dir, "aidp.yml")
-        legacy_config_file = File.join(@project_dir, ".aidp.yml")
+        config_file = File.join(@project_dir, ".aidp", "aidp.yml")
 
         if File.exist?(config_file)
           config_file
-        elsif File.exist?(legacy_config_file)
-          legacy_config_file
         end
       end