aidp 0.32.0 → 0.34.0

data/lib/aidp/errors.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "time"
+require "json"
+
 module Aidp
   # Error classes for AIDP
   module Errors
@@ -8,5 +11,136 @@ module Aidp
     class ValidationError < StandardError; end
     class StateError < StandardError; end
     class UserError < StandardError; end
+
+    # Exception raised when a Rule of Two policy violation occurs
+    # Contains detailed context about the violation for logging and debugging
+    class PolicyViolation < StandardError
+      attr_reader :flag, :source, :current_state, :suggested_mitigations
+
+      def initialize(flag:, source:, current_state:, message: nil)
+        @flag = flag
+        @source = source
+        @current_state = current_state
+        @suggested_mitigations = build_suggested_mitigations(flag, current_state)
+
+        super(message || default_message)
+      end
+
+      # Export violation details for logging
+      def to_h
+        {
+          type: "rule_of_two_violation",
+          flag_attempted: @flag,
+          source: @source,
+          current_state: @current_state,
+          suggested_mitigations: @suggested_mitigations,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # JSON representation for structured logging
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      private
+
+      def default_message
+        "Rule of Two violation: Cannot enable '#{@flag}' - would create lethal trifecta"
+      end
+
+      # Build contextual mitigation suggestions based on which flags are enabled
+      def build_suggested_mitigations(flag, state)
+        mitigations = []
+
+        # Suggest based on which flags would form the trifecta
+        if state[:untrusted_input]
+          mitigations << {
+            action: "sanitize_input",
+            description: "Sanitize the untrusted input before processing to remove the untrusted_input flag",
+            command: "aidp security sanitize-input --source <source>"
+          }
+        end
+
+        if state[:private_data]
+          mitigations << {
+            action: "use_secrets_proxy",
+            description: "Route credential access through the Secrets Proxy to get short-lived tokens",
+            command: "aidp security proxy-request --secret <name>"
+          }
+        end
+
+        if state[:egress]
+          mitigations << {
+            action: "disable_egress",
+            description: "Disable external communication for this operation",
+            command: "Use deterministic unit or sandbox the operation"
+          }
+        end
+
+        # Add flag-specific suggestion for the attempted flag
+        case flag
+        when :untrusted_input
+          mitigations << {
+            action: "validate_source",
+            description: "Validate and trust the input source (e.g., from trusted author allowlist)",
+            command: "Add author to watch.safety.author_allowlist in aidp.yml"
+          }
+        when :private_data
+          mitigations << {
+            action: "scope_credentials",
+            description: "Use capability-scoped tokens instead of full credentials",
+            command: "aidp security register-secret --scoped"
+          }
+        when :egress
+          mitigations << {
+            action: "queue_for_approval",
+            description: "Queue the operation for manual execution outside the agent context",
+            command: "Operation will be logged for manual review"
+          }
+        end
+
+        mitigations.uniq { |m| m[:action] }
+      end
+    end
+
+    # Exception raised when secrets proxy cannot fulfill a request
+    class SecretsProxyError < StandardError
+      attr_reader :secret_name, :reason
+
+      def initialize(secret_name:, reason:)
+        @secret_name = secret_name
+        @reason = reason
+        super("Secrets proxy error for '#{secret_name}': #{reason}")
+      end
+    end
+
+    # Exception raised when attempting to access an unregistered secret
+    class UnregisteredSecretError < SecretsProxyError
+      def initialize(secret_name:)
+        super(
+          secret_name: secret_name,
+          reason: "Secret not registered. Use 'aidp security register-secret #{secret_name}' to register."
+        )
+      end
+    end
+
+    # Exception raised when a token has expired
+    class TokenExpiredError < SecretsProxyError
+      def initialize(secret_name:, expired_at:)
+        super(
+          secret_name: secret_name,
+          reason: "Token expired at #{expired_at}. Request a new token via the secrets proxy."
+        )
+      end
+    end
+  end
+
+  # Convenience aliases in Security module for backward compatibility
+  module Security
+    PolicyViolation = Aidp::Errors::PolicyViolation
+    SecretsProxyError = Aidp::Errors::SecretsProxyError
+    UnregisteredSecretError = Aidp::Errors::UnregisteredSecretError
+    TokenExpiredError = Aidp::Errors::TokenExpiredError
   end
 end

data/lib/aidp/evaluations/context_capture.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "../config_paths"
+
+module Aidp
+  module Evaluations
+    # Captures rich context for evaluation records
+    #
+    # Gathers information about:
+    # - Prompt metadata (template, persona, skills, provider, model, tokens, settings)
+    # - Work-loop data (unit count, checkpoints, retries, file modifications)
+    # - Environment details (devcontainer status, Ruby version, branch info)
+    #
+    # @example Capturing context
+    #   context = ContextCapture.new(project_dir: Dir.pwd)
+    #   data = context.capture(step_name: "01_INIT", iteration: 3)
+    class ContextCapture
+      def initialize(project_dir: Dir.pwd, config: nil)
+        @project_dir = project_dir
+        @config = config
+
+        Aidp.log_debug("context_capture", "initialize", project_dir: project_dir)
+      end
+
+      # Capture full context for an evaluation
+      #
+      # @param step_name [String, nil] Current work loop step
+      # @param iteration [Integer, nil] Current iteration number
+      # @param provider [String, nil] AI provider being used
+      # @param model [String, nil] AI model being used
+      # @param additional [Hash] Additional context to include
+      # @return [Hash] Captured context
+      def capture(step_name: nil, iteration: nil, provider: nil, model: nil, additional: {})
+        Aidp.log_debug("context_capture", "capture",
+          step_name: step_name, iteration: iteration, provider: provider)
+
+        {
+          prompt: capture_prompt_context(step_name),
+          work_loop: capture_work_loop_context(step_name, iteration),
+          environment: capture_environment_context,
+          provider: {
+            name: provider,
+            model: model
+          },
+          timestamp: Time.now.iso8601
+        }.merge(additional)
+      end
+
+      # Capture minimal context (for quick evaluations)
+      #
+      # @return [Hash] Minimal context with timestamp and environment basics
+      def capture_minimal
+        Aidp.log_debug("context_capture", "capture_minimal")
+
+        {
+          environment: {
+            ruby_version: RUBY_VERSION,
+            branch: current_git_branch,
+            aidp_version: aidp_version
+          },
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      # Capture watch mode context for evaluating watch outputs
+      #
+      # @param repo [String] Repository in owner/repo format
+      # @param number [Integer] Issue or PR number
+      # @param processor_type [String] Type of processor (plan, review, build, ci_fix, change_request)
+      # @return [Hash] Watch mode context
+      def capture_watch(repo:, number:, processor_type:)
+        Aidp.log_debug("context_capture", "capture_watch",
+          repo: repo, number: number, processor_type: processor_type)
+
+        {
+          watch: {
+            repo: repo,
+            number: number,
+            processor_type: processor_type,
+            state: load_watch_state(repo, number, processor_type)
+          },
+          environment: capture_environment_context,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      private
+
+      def load_watch_state(repo, number, processor_type)
+        # Try to load state from the watch state store
+        state_file = find_watch_state_file(repo)
+        return nil unless state_file && File.exist?(state_file)
+
+        require "yaml"
+        state = YAML.safe_load_file(state_file, permitted_classes: [Time, Date, Symbol])
+        return nil unless state
+
+        # Extract relevant state based on processor type
+        case processor_type
+        when "plan"
+          state.dig("issues", number.to_s, "plan") ||
+            state.dig(:issues, number, :plan)
+        when "review"
+          state.dig("pull_requests", number.to_s, "review") ||
+            state.dig(:pull_requests, number, :review)
+        when "build"
+          state.dig("issues", number.to_s, "build") ||
+            state.dig(:issues, number, :build)
+        when "ci_fix"
+          state.dig("pull_requests", number.to_s, "ci_fix") ||
+            state.dig(:pull_requests, number, :ci_fix)
+        when "change_request"
+          state.dig("pull_requests", number.to_s, "change_request") ||
+            state.dig(:pull_requests, number, :change_request)
+        end
+      rescue => e
+        Aidp.log_error("context_capture", "load_watch_state failed", error: e.message)
+        nil
+      end
+
+      def find_watch_state_file(repo)
+        watch_dir = File.join(@project_dir, ".aidp", "watch")
+        return nil unless Dir.exist?(watch_dir)
+
+        # Sanitize repo name the same way StateStore does
+        sanitized = repo.tr("/", "_").gsub(/[^a-zA-Z0-9_-]/, "")
+        state_file = File.join(watch_dir, "#{sanitized}.yml")
+
+        File.exist?(state_file) ? state_file : nil
+      end
+
+      def capture_prompt_context(step_name)
+        prompt_file = File.join(@project_dir, ".aidp", "PROMPT.md")
+        return {} unless File.exist?(prompt_file)
+
+        content = File.read(prompt_file)
+        {
+          step_name: step_name,
+          prompt_length: content.length,
+          has_prompt: true
+        }
+      rescue => e
+        Aidp.log_error("context_capture", "capture_prompt_context failed", error: e.message)
+        {}
+      end
+
+      def capture_work_loop_context(step_name, iteration)
+        checkpoint_file = ConfigPaths.checkpoint_file(@project_dir)
+        checkpoint_data = if File.exist?(checkpoint_file)
+          require "yaml"
+          YAML.safe_load_file(checkpoint_file, permitted_classes: [Time, Date, Symbol])
+        end
+
+        {
+          step_name: step_name,
+          iteration: iteration,
+          checkpoint: checkpoint_data ? {
+            status: checkpoint_data["status"] || checkpoint_data[:status],
+            metrics: checkpoint_data["metrics"] || checkpoint_data[:metrics]
+          } : nil
+        }
+      rescue => e
+        Aidp.log_error("context_capture", "capture_work_loop_context failed", error: e.message)
+        {step_name: step_name, iteration: iteration}
+      end
+
+      def capture_environment_context
+        {
+          ruby_version: RUBY_VERSION,
+          platform: RUBY_PLATFORM,
+          branch: current_git_branch,
+          commit: current_git_commit,
+          devcontainer: in_devcontainer?,
+          aidp_version: aidp_version
+        }
+      end
+
+      def current_git_branch
+        Dir.chdir(@project_dir) do
+          `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        end
+      rescue
+        nil
+      end
+
+      def current_git_commit
+        Dir.chdir(@project_dir) do
+          `git rev-parse --short HEAD 2>/dev/null`.strip
+        end
+      rescue
+        nil
+      end
+
+      def in_devcontainer?
+        File.exist?("/.dockerenv") || ENV["REMOTE_CONTAINERS"] == "true"
+      end
+
+      def aidp_version
+        Aidp::VERSION if defined?(Aidp::VERSION)
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/aidp/evaluations/evaluation_record.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Aidp
+  module Evaluations
+    # Represents a single evaluation record
+    #
+    # An evaluation captures user feedback (good/neutral/bad) for AIDP outputs
+    # such as prompts, work units, or full work loops, along with rich context.
+    #
+    # @example Creating an evaluation
+    #   record = EvaluationRecord.new(
+    #     rating: "good",
+    #     comment: "Generated code was clean and well-structured",
+    #     target_type: "work_unit",
+    #     target_id: "01_INIT"
+    #   )
+    class EvaluationRecord
+      VALID_RATINGS = %w[good neutral bad].freeze
+      VALID_TARGET_TYPES = %w[prompt work_unit work_loop step plan review build ci_fix change_request].freeze
+
+      attr_reader :id, :rating, :comment, :target_type, :target_id,
+        :context, :created_at
+
+      def initialize(rating:, comment: nil, target_type: nil, target_id: nil, context: {}, id: nil, created_at: nil)
+        @id = id || generate_id
+        @rating = validate_rating(rating)
+        @comment = comment
+        @target_type = validate_target_type(target_type)
+        @target_id = target_id
+        @context = context || {}
+        @created_at = created_at || Time.now.iso8601
+
+        Aidp.log_debug("evaluation_record", "create",
+          id: @id, rating: @rating, target_type: @target_type, target_id: @target_id)
+      end
+
+      # Convert to hash for storage
+      def to_h
+        {
+          id: @id,
+          rating: @rating,
+          comment: @comment,
+          target_type: @target_type,
+          target_id: @target_id,
+          context: @context,
+          created_at: @created_at
+        }
+      end
+
+      # Create record from stored hash
+      def self.from_h(hash)
+        hash = symbolize_keys(hash)
+        new(
+          id: hash[:id],
+          rating: hash[:rating],
+          comment: hash[:comment],
+          target_type: hash[:target_type],
+          target_id: hash[:target_id],
+          context: hash[:context] || {},
+          created_at: hash[:created_at]
+        )
+      end
+
+      # Check if rating is positive
+      def good?
+        @rating == "good"
+      end
+
+      # Check if rating is negative
+      def bad?
+        @rating == "bad"
+      end
+
+      # Check if rating is neutral
+      def neutral?
+        @rating == "neutral"
+      end
+
+      private
+
+      def generate_id
+        "eval_#{Time.now.strftime("%Y%m%d_%H%M%S")}_#{SecureRandom.hex(4)}"
+      end
+
+      def validate_rating(rating)
+        rating_str = rating.to_s.downcase
+        unless VALID_RATINGS.include?(rating_str)
+          raise ArgumentError, "Invalid rating '#{rating}'. Must be one of: #{VALID_RATINGS.join(", ")}"
+        end
+        rating_str
+      end
+
+      def validate_target_type(target_type)
+        return nil if target_type.nil?
+        type_str = target_type.to_s.downcase
+        unless VALID_TARGET_TYPES.include?(type_str)
+          raise ArgumentError, "Invalid target_type '#{target_type}'. Must be one of: #{VALID_TARGET_TYPES.join(", ")}"
+        end
+        type_str
+      end
+
+      class << self
+        private
+
+        def symbolize_keys(hash)
+          return hash unless hash.is_a?(Hash)
+          hash.transform_keys { |k| k.is_a?(String) ? k.to_sym : k }
+        end
+      end
+    end
+  end
+end