aidp 0.10.0 → 0.11.0

data/lib/aidp/execute/checkpoint.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+require "json"
+
+module Aidp
+  module Execute
+    # Manages periodic checkpoints during work loop execution
+    # Tracks progress metrics, code quality, and task completion
+    class Checkpoint
+      attr_reader :project_dir, :checkpoint_file, :history_file
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @checkpoint_file = File.join(project_dir, ".aidp", "checkpoint.yml")
+        @history_file = File.join(project_dir, ".aidp", "checkpoint_history.jsonl")
+        ensure_checkpoint_directory
+      end
+
+      # Record a checkpoint during work loop iteration
+      def record_checkpoint(step_name, iteration, metrics = {})
+        checkpoint_data = {
+          step_name: step_name,
+          iteration: iteration,
+          timestamp: Time.now.iso8601,
+          metrics: collect_metrics.merge(metrics),
+          status: determine_status(metrics)
+        }
+
+        save_checkpoint(checkpoint_data)
+        append_to_history(checkpoint_data)
+
+        checkpoint_data
+      end
+
+      # Get the latest checkpoint data
+      def latest_checkpoint
+        return nil unless File.exist?(@checkpoint_file)
+        YAML.load_file(@checkpoint_file)
+      end
+
+      # Get checkpoint history for analysis
+      def checkpoint_history(limit: 100)
+        return [] unless File.exist?(@history_file)
+
+        File.readlines(@history_file).last(limit).map do |line|
+          JSON.parse(line, symbolize_names: true)
+        end
+      rescue JSON::ParserError
+        []
+      end
+
+      # Get progress summary comparing current state to previous checkpoints
+      def progress_summary
+        latest = latest_checkpoint
+        return nil unless latest
+
+        history = checkpoint_history(limit: 10)
+        previous = history[-2] if history.size > 1
+
+        {
+          current: latest,
+          previous: previous,
+          trends: calculate_trends(history),
+          quality_score: calculate_quality_score(latest[:metrics])
+        }
+      end
+
+      # Clear all checkpoint data
+      def clear
+        File.delete(@checkpoint_file) if File.exist?(@checkpoint_file)
+        File.delete(@history_file) if File.exist?(@history_file)
+      end
+
+      private
+
+      def ensure_checkpoint_directory
+        dir = File.dirname(@checkpoint_file)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      end
+
+      # Collect current metrics from the project
+      def collect_metrics
+        {
+          lines_of_code: count_lines_of_code,
+          file_count: count_project_files,
+          test_coverage: estimate_test_coverage,
+          code_quality: assess_code_quality,
+          prd_task_progress: calculate_prd_task_progress
+        }
+      end
+
+      def count_lines_of_code
+        extensions = %w[.rb .js .py .java .go .ts .tsx .jsx]
+        total_lines = 0
+
+        Dir.glob(File.join(@project_dir, "**", "*")).each do |file|
+          next unless File.file?(file)
+          next unless extensions.include?(File.extname(file))
+          next if file.include?("node_modules") || file.include?("vendor")
+
+          total_lines += File.readlines(file).size
+        end
+
+        total_lines
+      rescue
+        0
+      end
+
+      def count_project_files
+        extensions = %w[.rb .js .py .java .go .ts .tsx .jsx]
+        count = 0
+
+        Dir.glob(File.join(@project_dir, "**", "*")).each do |file|
+          next unless File.file?(file)
+          next unless extensions.include?(File.extname(file))
+          next if file.include?("node_modules") || file.include?("vendor")
+
+          count += 1
+        end
+
+        count
+      rescue
+        0
+      end
+
+      # Estimate test coverage based on test files vs source files
+      def estimate_test_coverage
+        source_files = count_files_by_pattern("**/*.rb", exclude: ["spec/**", "test/**"])
+        test_files = count_files_by_pattern("{spec,test}/**/*_{spec,test}.rb")
+
+        return 0 if source_files == 0
+
+        coverage_ratio = (test_files.to_f / source_files * 100).round(2)
+        [coverage_ratio, 100].min
+      rescue
+        0
+      end
+
+      def count_files_by_pattern(pattern, exclude: [])
+        files = Dir.glob(File.join(@project_dir, pattern))
+        exclude.each do |exc_pattern|
+          excluded = Dir.glob(File.join(@project_dir, exc_pattern))
+          files -= excluded
+        end
+        files.size
+      end
+
+      # Assess code quality based on available linters
+      def assess_code_quality
+        quality_score = 100
+
+        # Check for Ruby linter output
+        if File.exist?(File.join(@project_dir, ".rubocop.yml"))
+          rubocop_score = run_rubocop_check
+          quality_score = [quality_score, rubocop_score].min if rubocop_score
+        end
+
+        quality_score
+      end
+
+      def run_rubocop_check
+        # Run rubocop and parse output to get a quality score
+        # This is a simplified version - could be enhanced
+        result = `cd #{@project_dir} && rubocop --format json 2>/dev/null`
+        return nil if result.empty?
+
+        data = JSON.parse(result)
+        total_files = data["files"]&.size || 0
+        return 100 if total_files == 0
+
+        offense_count = data["summary"]["offense_count"] || 0
+        # Simple scoring: fewer offenses = higher score
+        [100 - (offense_count / total_files.to_f * 10), 0].max.round(2)
+      rescue
+        nil
+      end
+
+      # Calculate PRD task completion progress
+      def calculate_prd_task_progress
+        prd_path = File.join(@project_dir, "docs", "prd.md")
+        return 0 unless File.exist?(prd_path)
+
+        content = File.read(prd_path)
+
+        # Count completed vs total checkboxes
+        total_tasks = content.scan(/- \[[ x]\]/).size
+        completed_tasks = content.scan(/- \[x\]/i).size
+
+        return 0 if total_tasks == 0
+
+        (completed_tasks.to_f / total_tasks * 100).round(2)
+      rescue
+        0
+      end
+
+      def determine_status(metrics)
+        # Determine overall status based on metrics
+        quality_score = calculate_quality_score(metrics)
+
+        if quality_score >= 80
+          "healthy"
+        elsif quality_score >= 60
+          "warning"
+        else
+          "needs_attention"
+        end
+      end
+
+      def calculate_quality_score(metrics)
+        # Weighted average of different metrics
+        weights = {
+          test_coverage: 0.3,
+          code_quality: 0.4,
+          prd_task_progress: 0.3
+        }
+
+        score = 0
+        weights.each do |metric, weight|
+          score += (metrics[metric] || 0) * weight
+        end
+
+        score.round(2)
+      end
+
+      # Calculate trends from historical data
+      def calculate_trends(history)
+        return {} if history.size < 2
+
+        latest = history.last
+        previous = history[-2]
+
+        {
+          lines_of_code: calculate_trend_direction(
+            previous.dig(:metrics, :lines_of_code),
+            latest.dig(:metrics, :lines_of_code)
+          ),
+          test_coverage: calculate_trend_direction(
+            previous.dig(:metrics, :test_coverage),
+            latest.dig(:metrics, :test_coverage)
+          ),
+          code_quality: calculate_trend_direction(
+            previous.dig(:metrics, :code_quality),
+            latest.dig(:metrics, :code_quality)
+          ),
+          prd_task_progress: calculate_trend_direction(
+            previous.dig(:metrics, :prd_task_progress),
+            latest.dig(:metrics, :prd_task_progress)
+          )
+        }
+      end
+
+      def calculate_trend_direction(previous_value, current_value)
+        return "stable" if previous_value.nil? || current_value.nil?
+
+        diff = current_value - previous_value
+        diff_percent = (previous_value == 0) ? 0 : ((diff.to_f / previous_value) * 100).round(2)
+
+        {
+          direction: if diff > 0
+                       "up"
+                     else
+                       ((diff < 0) ? "down" : "stable")
+                     end,
+          change: diff,
+          change_percent: diff_percent
+        }
+      end
+
+      def save_checkpoint(data)
+        File.write(@checkpoint_file, data.to_yaml)
+      end
+
+      def append_to_history(data)
+        File.open(@history_file, "a") do |f|
+          f.puts(data.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/execute/checkpoint_display.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Aidp
+  module Execute
+    # Formats and displays checkpoint information to the user
+    class CheckpointDisplay
+      include Aidp::MessageDisplay
+
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      # Display a checkpoint during work loop iteration
+      def display_checkpoint(checkpoint_data, show_details: false)
+        return unless checkpoint_data
+
+        puts
+        puts @pastel.bold("📊 Checkpoint - Iteration #{checkpoint_data[:iteration]}")
+        puts @pastel.dim("─" * 60)
+
+        display_metrics(checkpoint_data[:metrics])
+        display_status(checkpoint_data[:status])
+
+        if show_details
+          display_trends(checkpoint_data[:trends]) if checkpoint_data[:trends]
+        end
+
+        puts @pastel.dim("─" * 60)
+        puts
+      end
+
+      # Display progress summary with trends
+      def display_progress_summary(summary)
+        return unless summary
+
+        puts
+        puts @pastel.bold("📈 Progress Summary")
+        puts @pastel.dim("=" * 60)
+
+        current = summary[:current]
+        puts "Step: #{@pastel.cyan(current[:step_name])}"
+        puts "Iteration: #{current[:iteration]}"
+        puts "Status: #{format_status(current[:status])}"
+        puts
+
+        puts @pastel.bold("Current Metrics:")
+        display_metrics(current[:metrics])
+
+        if summary[:trends]
+          puts
+          puts @pastel.bold("Trends:")
+          display_trends(summary[:trends])
+        end
+
+        if summary[:quality_score]
+          puts
+          display_quality_score(summary[:quality_score])
+        end
+
+        puts @pastel.dim("=" * 60)
+        puts
+      end
+
+      # Display checkpoint history as a table
+      def display_checkpoint_history(history, limit: 10)
+        return if history.empty?
+
+        puts
+        puts @pastel.bold("📜 Checkpoint History (Last #{[limit, history.size].min})")
+        puts @pastel.dim("=" * 80)
+
+        # Table header
+        puts format_table_row([
+          "Iteration",
+          "Time",
+          "LOC",
+          "Coverage",
+          "Quality",
+          "PRD Progress",
+          "Status"
+        ], header: true)
+        puts @pastel.dim("-" * 80)
+
+        # Table rows
+        history.last(limit).each do |checkpoint|
+          metrics = checkpoint[:metrics]
+          timestamp = Time.parse(checkpoint[:timestamp]).strftime("%H:%M:%S")
+
+          puts format_table_row([
+            checkpoint[:iteration].to_s,
+            timestamp,
+            metrics[:lines_of_code].to_s,
+            "#{metrics[:test_coverage]}%",
+            "#{metrics[:code_quality]}%",
+            "#{metrics[:prd_task_progress]}%",
+            format_status(checkpoint[:status])
+          ])
+        end
+
+        puts @pastel.dim("=" * 80)
+        puts
+      end
+
+      # Display inline progress indicator (for work loop)
+      def display_inline_progress(iteration, metrics)
+        loc = metrics[:lines_of_code] || 0
+        coverage = metrics[:test_coverage] || 0
+        quality = metrics[:code_quality] || 0
+        prd = metrics[:prd_task_progress] || 0
+
+        status_line = [
+          "Iter: #{iteration}",
+          "LOC: #{loc}",
+          "Cov: #{format_percentage(coverage)}",
+          "Qual: #{format_percentage(quality)}",
+          "PRD: #{format_percentage(prd)}"
+        ].join(" | ")
+
+        display_message("  #{@pastel.dim(status_line)}", type: :info)
+      end
+
+      private
+
+      def display_metrics(metrics)
+        puts "  Lines of Code: #{@pastel.yellow(metrics[:lines_of_code].to_s)}"
+        puts "  Test Coverage: #{format_percentage_with_color(metrics[:test_coverage])}"
+        puts "  Code Quality: #{format_percentage_with_color(metrics[:code_quality])}"
+        puts "  PRD Task Progress: #{format_percentage_with_color(metrics[:prd_task_progress])}"
+        puts "  File Count: #{metrics[:file_count]}"
+      end
+
+      def display_status(status)
+        puts "  Overall Status: #{format_status(status)}"
+      end
+
+      def format_status(status)
+        case status.to_s
+        when "healthy"
+          @pastel.green("✓ Healthy")
+        when "warning"
+          @pastel.yellow("⚠ Warning")
+        when "needs_attention"
+          @pastel.red("✗ Needs Attention")
+        else
+          @pastel.dim(status.to_s)
+        end
+      end
+
+      def display_trends(trends)
+        trends.each do |metric, trend_data|
+          next unless trend_data.is_a?(Hash)
+
+          metric_name = metric.to_s.split("_").map(&:capitalize).join(" ")
+          arrow = trend_arrow(trend_data[:direction])
+          change = format_change(trend_data[:change], trend_data[:change_percent])
+
+          puts "  #{metric_name}: #{arrow} #{change}"
+        end
+      end
+
+      def trend_arrow(direction)
+        case direction.to_s
+        when "up"
+          @pastel.green("↑")
+        when "down"
+          @pastel.red("↓")
+        else
+          @pastel.dim("→")
+        end
+      end
+
+      def format_change(change, change_percent)
+        sign = (change >= 0) ? "+" : ""
+        "#{sign}#{change} (#{sign}#{change_percent}%)"
+      end
+
+      def display_quality_score(score)
+        color = if score >= 80
+          :green
+        elsif score >= 60
+          :yellow
+        else
+          :red
+        end
+
+        puts "  Quality Score: #{@pastel.send(color, "#{score.round(2)}%")}"
+      end
+
+      def format_percentage(value)
+        return "0%" unless value
+        "#{value.round(1)}%"
+      end
+
+      def format_percentage_with_color(value)
+        return @pastel.dim("0%") unless value
+
+        color = if value >= 80
+          :green
+        elsif value >= 60
+          :yellow
+        else
+          :red
+        end
+
+        @pastel.send(color, "#{value.round(1)}%")
+      end
+
+      def format_table_row(columns, header: false)
+        widths = [10, 10, 8, 10, 10, 14, 18]
+        formatted = columns.each_with_index.map do |col, i|
+          col.to_s.ljust(widths[i])
+        end
+
+        row = formatted.join(" ")
+        header ? @pastel.bold(row) : row
+      end
+    end
+  end
+end

data/lib/aidp/execute/progress.rb

@@ -11,7 +11,7 @@ module Aidp
 
       def initialize(project_dir)
         @project_dir = project_dir
-        @progress_file = File.join(project_dir, ".aidp-progress.yml")
+        @progress_file = File.join(project_dir, ".aidp", "progress", "execute.yml")
         load_progress
       end
 
@@ -78,6 +78,7 @@ module Aidp
         # In test mode, skip file operations to avoid hanging
         return if ENV["RACK_ENV"] == "test" || defined?(RSpec)
 
+        FileUtils.mkdir_p(File.dirname(@progress_file))
         File.write(@progress_file, @progress.to_yaml)
       end
     end

data/lib/aidp/execute/prompt_manager.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  module Execute
+    # Manages the PROMPT.md file lifecycle for work loops
+    # Responsibilities:
+    # - Read/write PROMPT.md
+    # - Check existence
+    # - Archive completed prompts
+    class PromptManager
+      PROMPT_FILENAME = "PROMPT.md"
+      ARCHIVE_DIR = ".aidp/prompt_archive"
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @prompt_path = File.join(project_dir, PROMPT_FILENAME)
+        @archive_dir = File.join(project_dir, ARCHIVE_DIR)
+      end
+
+      # Write content to PROMPT.md
+      def write(content)
+        File.write(@prompt_path, content)
+      end
+
+      # Read content from PROMPT.md
+      def read
+        return nil unless exists?
+        File.read(@prompt_path)
+      end
+
+      # Check if PROMPT.md exists
+      def exists?
+        File.exist?(@prompt_path)
+      end
+
+      # Archive PROMPT.md with timestamp and step name
+      def archive(step_name)
+        return unless exists?
+
+        FileUtils.mkdir_p(@archive_dir)
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        archive_filename = "#{timestamp}_#{step_name}_PROMPT.md"
+        archive_path = File.join(@archive_dir, archive_filename)
+
+        FileUtils.cp(@prompt_path, archive_path)
+        archive_path
+      end
+
+      # Delete PROMPT.md (typically after archiving)
+      def delete
+        File.delete(@prompt_path) if exists?
+      end
+
+      # Get the full path to PROMPT.md
+      def path
+        @prompt_path
+      end
+    end
+  end
+end

data/lib/aidp/execute/runner.rb

@@ -3,11 +3,14 @@
 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
+      include Aidp::MessageDisplay
+
       def initialize(project_dir, harness_runner = nil, prompt: TTY::Prompt.new)
         @project_dir = project_dir
         @harness_runner = harness_runner
@@ -22,18 +25,6 @@ module Aidp
 
       private
 
-      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
-        else :white
-        end
-        @prompt.say(message, color: color)
-      end
-
       public
 
       def run_step(step_name, options = {})
@@ -51,18 +42,17 @@ module Aidp
 
       # Harness-aware step execution
       def run_step_with_harness(step_name, 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)
+        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)
@@ -154,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
@@ -280,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