aidp 0.5.0 → 0.8.0

data/lib/aidp/config.rb

@@ -5,29 +5,317 @@ require "yaml"
 module Aidp
   # Configuration management for both execute and analyze modes
   class Config
+    # Default configuration for harness
+    DEFAULT_HARNESS_CONFIG = {
+      harness: {
+        max_retries: 2,
+        default_provider: "cursor",
+        fallback_providers: ["cursor"],
+        restrict_to_non_byok: false,
+        provider_weights: {
+          "cursor" => 3,
+          "anthropic" => 2,
+          "macos" => 1
+        },
+        circuit_breaker: {
+          enabled: true,
+          failure_threshold: 5,
+          timeout: 300,
+          half_open_max_calls: 3
+        },
+        retry: {
+          enabled: true,
+          max_attempts: 3,
+          base_delay: 1.0,
+          max_delay: 60.0,
+          exponential_base: 2.0,
+          jitter: true
+        },
+        rate_limit: {
+          enabled: true,
+          default_reset_time: 3600,
+          burst_limit: 10,
+          sustained_limit: 5
+        },
+        load_balancing: {
+          enabled: true,
+          strategy: "weighted_round_robin",
+          health_check_interval: 30,
+          unhealthy_threshold: 3
+        },
+        model_switching: {
+          enabled: true,
+          auto_switch_on_error: true,
+          auto_switch_on_rate_limit: true,
+          fallback_strategy: "sequential"
+        },
+        health_check: {
+          enabled: true,
+          interval: 60,
+          timeout: 10,
+          failure_threshold: 3,
+          success_threshold: 2
+        },
+        metrics: {
+          enabled: true,
+          retention_days: 30,
+          aggregation_interval: 300,
+          export_interval: 3600
+        },
+        session: {
+          enabled: true,
+          timeout: 1800,
+          sticky_sessions: true,
+          session_affinity: "provider_model"
+        }
+      },
+      providers: {
+        cursor: {
+          type: "package",
+          priority: 1,
+          default_flags: [],
+          models: ["cursor-default", "cursor-fast", "cursor-precise"],
+          model_weights: {
+            "cursor-default" => 3,
+            "cursor-fast" => 2,
+            "cursor-precise" => 1
+          },
+          models_config: {
+            "cursor-default" => {
+              flags: [],
+              timeout: 600
+            },
+            "cursor-fast" => {
+              flags: ["--fast"],
+              timeout: 300
+            },
+            "cursor-precise" => {
+              flags: ["--precise"],
+              timeout: 900
+            }
+          },
+          features: {
+            file_upload: true,
+            code_generation: true,
+            analysis: true
+          },
+          monitoring: {
+            enabled: true,
+            metrics_interval: 60
+          }
+        },
+        anthropic: {
+          type: "usage_based",
+          priority: 2,
+          max_tokens: 100_000,
+          default_flags: ["--dangerously-skip-permissions"],
+          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022", "claude-3-opus-20240229"],
+          model_weights: {
+            "claude-3-5-sonnet-20241022" => 3,
+            "claude-3-5-haiku-20241022" => 2,
+            "claude-3-opus-20240229" => 1
+          },
+          models_config: {
+            "claude-3-5-sonnet-20241022" => {
+              flags: ["--dangerously-skip-permissions"],
+              max_tokens: 200_000,
+              timeout: 300
+            },
+            "claude-3-5-haiku-20241022" => {
+              flags: ["--dangerously-skip-permissions"],
+              max_tokens: 200_000,
+              timeout: 180
+            },
+            "claude-3-opus-20240229" => {
+              flags: ["--dangerously-skip-permissions"],
+              max_tokens: 200_000,
+              timeout: 600
+            }
+          },
+          auth: {
+            api_key_env: "ANTHROPIC_API_KEY"
+          },
+          endpoints: {
+            default: "https://api.anthropic.com/v1/messages"
+          },
+          features: {
+            file_upload: true,
+            code_generation: true,
+            analysis: true,
+            vision: true
+          },
+          monitoring: {
+            enabled: true,
+            metrics_interval: 60
+          }
+        },
+        macos: {
+          type: "passthrough",
+          priority: 4,
+          underlying_service: "cursor",
+          models: ["cursor-chat"],
+          features: {
+            file_upload: false,
+            code_generation: true,
+            analysis: true,
+            interactive: true
+          }
+        }
+      }
+    }.freeze
+
     def self.load(project_dir = Dir.pwd)
-      config_file = File.join(project_dir, ".aidp.yml")
+      # 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")
+
       if File.exist?(config_file)
-        YAML.load_file(config_file) || {}
+        load_yaml_config(config_file)
+      elsif File.exist?(legacy_config_file)
+        load_yaml_config(legacy_config_file)
       else
         {}
       end
     end
 
-    def self.templates_root
-      File.join(Dir.pwd, "templates")
+    # Load harness configuration with defaults
+    def self.load_harness_config(project_dir = Dir.pwd)
+      config = load(project_dir)
+      merge_harness_defaults(config)
+    end
+
+    # Validate harness configuration
+    def self.validate_harness_config(config, project_dir = Dir.pwd)
+      errors = []
+
+      # Validate harness section (check the merged config, not original)
+      harness_config = config[:harness] || config["harness"]
+      if harness_config
+        unless harness_config[:default_provider] || harness_config["default_provider"]
+          errors << "Default provider not specified in harness config"
+        end
+      end
+
+      # Validate providers section using config_validator
+      # Only validate providers that exist in the original YAML file, not merged defaults
+      original_config = load(project_dir)
+      original_providers = original_config[:providers] || original_config["providers"]
+      if original_providers&.any?
+        require_relative "harness/config_validator"
+        validator = Aidp::Harness::ConfigValidator.new(project_dir)
+
+        original_providers.each do |provider_name, _provider_config|
+          validation_result = validator.validate_provider(provider_name)
+          unless validation_result[:valid]
+            errors.concat(validation_result[:errors])
+          end
+        end
+      end
+
+      errors
+    end
+
+    # Get harness configuration
+    def self.harness_config(project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      harness_section = config[:harness] || config["harness"] || {}
+
+      # Convert string keys to symbols for consistency
+      symbolize_keys(harness_section)
+    end
+
+    # Get provider configuration
+    def self.provider_config(provider_name, project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      providers_section = config[:providers] || config["providers"] || {}
+      provider_config = providers_section[provider_name.to_s] || providers_section[provider_name.to_sym] || {}
+
+      symbolize_keys(provider_config)
     end
 
-    def self.analyze_templates_root
-      File.join(Dir.pwd, "templates", "ANALYZE")
+    # Get all configured providers
+    def self.configured_providers(project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      providers_section = config[:providers] || config["providers"] || {}
+      providers_section.keys.map(&:to_s)
     end
 
-    def self.execute_templates_root
-      File.join(Dir.pwd, "templates", "EXECUTE")
+    # 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"))
     end
 
-    def self.common_templates_root
-      File.join(Dir.pwd, "templates", "COMMON")
+    # Create example configuration file
+    def self.create_example_config(project_dir = Dir.pwd)
+      config_path = File.join(project_dir, "aidp.yml")
+      return false if File.exist?(config_path)
+
+      example_config = {
+        harness: {
+          max_retries: 2,
+          default_provider: "cursor",
+          fallback_providers: ["cursor"],
+          restrict_to_non_byok: false
+        },
+        providers: {
+          cursor: {
+            type: "package",
+            default_flags: []
+          },
+          claude: {
+            type: "api",
+            max_tokens: 100_000,
+            default_flags: ["--dangerously-skip-permissions"]
+          },
+          gemini: {
+            type: "api",
+            max_tokens: 50_000,
+            default_flags: []
+          }
+        }
+      }
+
+      File.write(config_path, YAML.dump(example_config))
+      true
+    end
+
+    private_class_method def self.load_yaml_config(config_file)
+      YAML.load_file(config_file) || {}
+    rescue => e
+      warn "Failed to load configuration file #{config_file}: #{e.message}"
+      {}
+    end
+
+    private_class_method def self.merge_harness_defaults(config)
+      merged = DEFAULT_HARNESS_CONFIG.dup
+
+      # Deep merge harness config
+      if config[:harness] || config["harness"]
+        harness_section = config[:harness] || config["harness"]
+        merged[:harness] = merged[:harness].merge(symbolize_keys(harness_section))
+      end
+
+      # Deep merge provider configs
+      if config[:providers] || config["providers"]
+        providers_section = config[:providers] || config["providers"]
+        merged[:providers] = merged[:providers].dup
+        providers_section.each do |provider, provider_config|
+          merged[:providers][provider.to_sym] = (merged[:providers][provider.to_sym] || {}).merge(symbolize_keys(provider_config))
+        end
+      end
+
+      merged
+    end
+
+    private_class_method def self.symbolize_keys(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        new_key = key.is_a?(String) ? key.to_sym : key
+        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+        result[new_key] = new_value
+      end
     end
   end
 end

data/lib/aidp/debug_logger.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pastel"
+
+module Aidp
+  # Debug logger that outputs to both console and a single log file
+  class DebugLogger
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    }.freeze
+
+    def initialize(log_dir: nil)
+      @log_dir = log_dir || default_log_dir
+      @log_file = nil
+      @run_started = false
+      ensure_log_directory
+      log_run_banner
+    end
+
+    def log(message, level: :info, data: nil)
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
+      level_str = level.to_s.upcase.ljust(5)
+
+      # Format message with timestamp and level
+      formatted_message = "[#{timestamp}] #{level_str} #{message}"
+
+      # Add data if present
+      if data && !data.empty?
+        data_str = format_data(data)
+        formatted_message += "\n#{data_str}" if data_str
+      end
+
+      # Output to console
+      output_to_console(formatted_message, level)
+
+      # Output to log file
+      output_to_file(formatted_message, level, data)
+    end
+
+    def close
+      @log_file&.close
+      @log_file = nil
+    end
+
+    private
+
+    def default_log_dir
+      File.join(Dir.pwd, ".aidp", "debug_logs")
+    end
+
+    def ensure_log_directory
+      FileUtils.mkdir_p(@log_dir) unless Dir.exist?(@log_dir)
+    end
+
+    def log_file_path
+      @log_file_path ||= File.join(@log_dir, "aidp_debug.log")
+    end
+
+    def get_log_file
+      return @log_file if @log_file && !@log_file.closed?
+
+      @log_file = File.open(log_file_path, "a")
+      @log_file
+    end
+
+    def log_run_banner
+      return if @run_started
+      @run_started = true
+
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
+      command_line = build_command_line
+
+      banner = <<~BANNER
+
+        ================================================================================
+        AIDP DEBUG SESSION STARTED
+        ================================================================================
+        Timestamp: #{timestamp}
+        Command: #{command_line}
+        Working Directory: #{Dir.pwd}
+        Debug Level: #{ENV["DEBUG"] || "0"}
+        ================================================================================
+      BANNER
+
+      # Write banner to log file
+      file = get_log_file
+      file.puts banner
+      file.flush
+
+      # Also output to console if debug is enabled
+      if ENV["DEBUG"] && ENV["DEBUG"].to_i > 0
+        puts "\e[36m#{banner}\e[0m"  # Cyan color
+      end
+    end
+
+    def build_command_line
+      # Get the command line arguments
+      cmd_parts = []
+
+      # Add the main command (aidp)
+      cmd_parts << "aidp"
+
+      # Add any arguments from ARGV
+      if defined?(ARGV) && !ARGV.empty?
+        cmd_parts.concat(ARGV)
+      end
+
+      # Add environment variables that affect behavior
+      env_vars = []
+      env_vars << "DEBUG=#{ENV["DEBUG"]}" if ENV["DEBUG"]
+      env_vars << "AIDP_CONFIG=#{ENV["AIDP_CONFIG"]}" if ENV["AIDP_CONFIG"]
+
+      if env_vars.any?
+        cmd_parts << "(" + env_vars.join(" ") + ")"
+      end
+
+      cmd_parts.join(" ")
+    end
+
+    def output_to_console(message, level)
+      case level
+      when :error
+        warn message
+      when :warn
+        puts "\e[33m#{message}\e[0m"  # Yellow
+      when :info
+        puts "\e[36m#{message}\e[0m"   # Cyan
+      when :debug
+        puts "\e[90m#{message}\e[0m"   # Gray
+      else
+        puts message
+      end
+    end
+
+    def output_to_file(message, level, data)
+      file = get_log_file
+      file.puts message
+
+      # Add structured data if present
+      if data && !data.empty?
+        structured_data = {
+          timestamp: Time.now.strftime("%Y-%m-%dT%H:%M:%S.%3N%z"),
+          level: level.to_s,
+          message: message,
+          data: data
+        }
+        file.puts "DATA: #{JSON.generate(structured_data)}"
+      end
+
+      file.flush
+    end
+
+    def format_data(data)
+      return nil if data.nil? || data.empty?
+
+      case data
+      when Hash
+        format_hash_data(data)
+      when Array
+        format_array_data(data)
+      when String
+        (data.length > 200) ? "#{data[0..200]}..." : data
+      else
+        data.to_s
+      end
+    end
+
+    def format_hash_data(hash)
+      lines = []
+      hash.each do |key, value|
+        lines << if value.is_a?(String) && value.length > 100
+          "  #{key}: #{value[0..100]}..."
+        elsif value.is_a?(Hash) || value.is_a?(Array)
+          "  #{key}: #{JSON.pretty_generate(value).gsub("\n", "\n    ")}"
+        else
+          "  #{key}: #{value}"
+        end
+      end
+      lines.join("\n")
+    end
+
+    def format_array_data(array)
+      if array.length > 10
+        "#{array.first(5).join(", ")}... (#{array.length} total items)"
+      else
+        array.join(", ")
+      end
+    end
+  end
+end

data/lib/aidp/debug_mixin.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "debug_logger"
+
+module Aidp
+  # Mixin module for easy debug integration across the codebase
+  module DebugMixin
+    # Debug levels
+    DEBUG_OFF = 0
+    DEBUG_BASIC = 1  # Commands and stderr
+    DEBUG_VERBOSE = 2  # Everything including prompts and stdout
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Class-level debug configuration
+      def debug_enabled?
+        ENV["DEBUG"] && ENV["DEBUG"].to_i > 0
+      end
+
+      def debug_level
+        ENV["DEBUG"]&.to_i || DEBUG_OFF
+      end
+    end
+
+    # Shared logger instance across all classes using DebugMixin
+    def self.shared_logger
+      @shared_logger ||= Aidp::DebugLogger.new
+    end
+
+    # Instance-level debug methods
+    def debug_enabled?
+      self.class.debug_enabled?
+    end
+
+    def debug_level
+      self.class.debug_level
+    end
+
+    def debug_basic?
+      debug_level >= DEBUG_BASIC
+    end
+
+    def debug_verbose?
+      debug_level >= DEBUG_VERBOSE
+    end
+
+    # Get or create debug logger instance (shared across all instances)
+    def debug_logger
+      Aidp::DebugMixin.shared_logger
+    end
+
+    # Log debug information with automatic level detection
+    def debug_log(message, level: :info, data: nil)
+      return unless debug_enabled?
+
+      debug_logger.log(message, level: level, data: data)
+    end
+
+    # Log command execution with debug details
+    def debug_command(cmd, args: [], input: nil, output: nil, error: nil, exit_code: nil)
+      return unless debug_basic?
+
+      command_str = [cmd, *args].join(" ")
+
+      debug_log("🔧 Executing command: #{command_str}", level: :info)
+
+      if input
+        if input.is_a?(String) && input.length > 200
+          # If input is long, show first 100 chars and indicate it's truncated
+          debug_log("📝 Input (truncated): #{input[0..100]}...", level: :info)
+        elsif input.is_a?(String) && File.exist?(input)
+          debug_log("📝 Input file: #{input}", level: :info)
+        else
+          debug_log("📝 Input: #{input}", level: :info)
+        end
+      end
+
+      if error && !error.empty?
+        debug_log("❌ Error output: #{error}", level: :error)
+      end
+
+      if debug_verbose?
+        if output && !output.empty?
+          debug_log("📤 Output: #{output}", level: :info)
+        end
+
+        if exit_code
+          debug_log("🏁 Exit code: #{exit_code}", level: :info)
+        end
+      end
+    end
+
+    # Log step execution with context
+    def debug_step(step_name, action, details = {})
+      return unless debug_basic?
+
+      message = "🔄 #{action}: #{step_name}"
+      if details.any?
+        detail_str = details.map { |k, v| "#{k}=#{v}" }.join(", ")
+        message += " (#{detail_str})"
+      end
+
+      debug_log(message, level: :info, data: details)
+    end
+
+    # Log provider interaction
+    def debug_provider(provider_name, action, details = {})
+      return unless debug_basic?
+
+      message = "🤖 #{provider_name}: #{action}"
+      if details.any?
+        detail_str = details.map { |k, v| "#{k}=#{v}" }.join(", ")
+        message += " (#{detail_str})"
+      end
+
+      debug_log(message, level: :info, data: details)
+    end
+
+    # Log error with debug context
+    def debug_error(error, context = {})
+      return unless debug_basic?
+
+      error_message = "💥 Error: #{error.class.name}: #{error.message}"
+      debug_log(error_message, level: :error, data: {error: error, context: context})
+
+      if debug_verbose? && error.backtrace
+        debug_log("📍 Backtrace: #{error.backtrace.first(5).join("\n")}", level: :error)
+      end
+    end
+
+    # Log timing information
+    def debug_timing(operation, duration, details = {})
+      return unless debug_verbose?
+
+      message = "⏱️  #{operation}: #{duration.round(2)}s"
+      if details.any?
+        detail_str = details.map { |k, v| "#{k}=#{v}" }.join(", ")
+        message += " (#{detail_str})"
+      end
+
+      debug_log(message, level: :info, data: {duration: duration, details: details})
+    end
+
+    # Execute command with debug logging
+    def debug_execute_command(cmd, args: [], input: nil, timeout: nil, **options)
+      require "tty-command"
+
+      command_str = [cmd, *args].join(" ")
+      start_time = Time.now
+
+      debug_log("🚀 Starting command execution: #{command_str}", level: :info)
+
+      begin
+        cmd_obj = TTY::Command.new(printer: :null) # Disable TTY::Command's own output
+
+        # Prepare input
+        input_data = nil
+        if input
+          if input.is_a?(String) && File.exist?(input)
+            input_data = File.read(input)
+            debug_log("📁 Reading input from file: #{input}", level: :info)
+          else
+            input_data = input
+          end
+        end
+
+        # Execute command
+        result = cmd_obj.run(cmd, *args, input: input_data, timeout: timeout, **options)
+
+        duration = Time.now - start_time
+
+        # Log results
+        debug_command(cmd, args: args, input: input, output: result.out, error: result.err, exit_code: result.exit_status)
+        debug_timing("Command execution", duration, {exit_code: result.exit_status})
+
+        result
+      rescue => e
+        duration = Time.now - start_time
+        debug_error(e, {command: command_str, duration: duration})
+        raise
+      end
+    end
+  end
+end