aidp 0.10.0 → 0.12.0

data/lib/aidp/config.rb

@@ -165,14 +165,10 @@ module Aidp
     }.freeze
 
     def self.load(project_dir = Dir.pwd)
-      # 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)
         load_yaml_config(config_file)
-      elsif File.exist?(legacy_config_file)
-        load_yaml_config(legacy_config_file)
       else
         {}
       end
@@ -248,15 +244,16 @@ module Aidp
 
     # Check if configuration file exists
     def self.config_exists?(project_dir = Dir.pwd)
-      File.exist?(File.join(project_dir, "aidp.yml")) ||
-        File.exist?(File.join(project_dir, ".aidp.yml"))
+      File.exist?(File.join(project_dir, ".aidp", "aidp.yml"))
     end
 
     # Create example configuration file
     def self.create_example_config(project_dir = Dir.pwd)
-      config_path = File.join(project_dir, "aidp.yml")
+      config_path = File.join(project_dir, ".aidp", "aidp.yml")
       return false if File.exist?(config_path)
 
+      FileUtils.mkdir_p(File.dirname(config_path))
+
       example_config = {
         harness: {
           max_retries: 2,

data/lib/aidp/debug_logger.rb

@@ -94,7 +94,7 @@ module Aidp
 
       # Also output to console if debug is enabled
       if ENV["DEBUG"] && ENV["DEBUG"].to_i > 0
-        puts "\e[36m#{banner}\e[0m"  # Cyan color
+        puts "\e[36m#{banner}\e[0m" # Cyan color
       end
     end
 
@@ -127,11 +127,11 @@ module Aidp
       when :error
         warn message
       when :warn
-        puts "\e[33m#{message}\e[0m"  # Yellow
+        puts "\e[33m#{message}\e[0m" # Yellow
       when :info
-        puts "\e[36m#{message}\e[0m"   # Cyan
+        puts "\e[36m#{message}\e[0m" # Cyan
       when :debug
-        puts "\e[90m#{message}\e[0m"   # Gray
+        puts "\e[90m#{message}\e[0m" # Gray
       else
         puts message
       end

data/lib/aidp/debug_mixin.rb

@@ -7,8 +7,8 @@ module Aidp
   module DebugMixin
     # Debug levels
     DEBUG_OFF = 0
-    DEBUG_BASIC = 1  # Commands and stderr
-    DEBUG_VERBOSE = 2  # Everything including prompts and stdout
+    DEBUG_BASIC = 1 # Commands and stderr
+    DEBUG_VERBOSE = 2 # Everything including prompts and stdout
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -145,7 +145,7 @@ module Aidp
     end
 
     # Execute command with debug logging
-    def debug_execute_command(cmd, args: [], input: nil, timeout: nil, **options)
+    def debug_execute_command(cmd, args: [], input: nil, timeout: nil, streaming: false, **options)
       require "tty-command"
 
       command_str = [cmd, *args].join(" ")
@@ -154,7 +154,14 @@ module Aidp
       debug_log("🚀 Starting command execution: #{command_str}", level: :info)
 
       begin
-        cmd_obj = TTY::Command.new(printer: :null) # Disable TTY::Command's own output
+        # Configure printer based on streaming mode
+        if streaming
+          # Use progress printer for real-time output
+          cmd_obj = TTY::Command.new(printer: :progress)
+          debug_log("📺 Streaming mode enabled - showing real-time output", level: :info)
+        else
+          cmd_obj = TTY::Command.new(printer: :null) # Disable TTY::Command's own output
+        end
 
         # Prepare input
         input_data = nil

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