aidp 0.17.1 → 0.18.0

data/lib/aidp/prompt_optimization/relevance_scorer.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Aidp
+  module PromptOptimization
+    # Scores fragments based on relevance to current task context
+    #
+    # Calculates relevance scores (0.0-1.0) for fragments based on:
+    # - Task type (feature, bugfix, refactor, test)
+    # - Affected files and code locations
+    # - Work loop step (planning vs implementation)
+    # - Keywords and semantic similarity
+    #
+    # @example Basic usage
+    #   scorer = RelevanceScorer.new
+    #   context = TaskContext.new(task_type: :feature, affected_files: ["user.rb"])
+    #   score = scorer.score_fragment(fragment, context)
+    class RelevanceScorer
+      # Default scoring weights
+      DEFAULT_WEIGHTS = {
+        task_type_match: 0.3,
+        tag_match: 0.25,
+        file_location_match: 0.25,
+        step_match: 0.2
+      }.freeze
+
+      def initialize(weights: DEFAULT_WEIGHTS)
+        @weights = weights
+      end
+
+      # Score a single fragment
+      #
+      # @param fragment [Fragment, TemplateFragment, CodeFragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Float] Relevance score (0.0-1.0)
+      def score_fragment(fragment, context)
+        scores = {}
+
+        scores[:task_type] = score_task_type_match(fragment, context) * @weights[:task_type_match]
+        scores[:tags] = score_tag_match(fragment, context) * @weights[:tag_match]
+        scores[:location] = score_file_location_match(fragment, context) * @weights[:file_location_match]
+        scores[:step] = score_step_match(fragment, context) * @weights[:step_match]
+
+        total_score = scores.values.sum
+        normalize_score(total_score)
+      end
+
+      # Score multiple fragments
+      #
+      # @param fragments [Array] List of fragments
+      # @param context [TaskContext] Task context
+      # @return [Array<Hash>] List of {fragment:, score:, breakdown:}
+      def score_fragments(fragments, context)
+        fragments.map do |fragment|
+          score = score_fragment(fragment, context)
+          {
+            fragment: fragment,
+            score: score,
+            breakdown: score_breakdown(fragment, context)
+          }
+        end.sort_by { |result| -result[:score] }
+      end
+
+      private
+
+      # Score based on task type matching
+      #
+      # @param fragment [Fragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Float] Score 0.0-1.0
+      def score_task_type_match(fragment, context)
+        return 0.5 unless context.task_type # Neutral if unknown
+
+        task_tags = task_type_to_tags(context.task_type)
+        return 0.3 if task_tags.empty? # Low default score
+
+        if fragment.respond_to?(:tags)
+          matching_tags = fragment.tags & task_tags
+          matching_tags.empty? ? 0.3 : (matching_tags.count.to_f / task_tags.count)
+        else
+          0.3
+        end
+      end
+
+      # Score based on tag matching
+      #
+      # @param fragment [Fragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Float] Score 0.0-1.0
+      def score_tag_match(fragment, context)
+        return 0.5 unless context.tags && !context.tags.empty?
+
+        if fragment.respond_to?(:tags)
+          matching_tags = fragment.tags & context.tags
+          matching_tags.empty? ? 0.2 : (matching_tags.count.to_f / context.tags.count).clamp(0.0, 1.0)
+        else
+          0.5
+        end
+      end
+
+      # Score based on file location matching
+      #
+      # @param fragment [Fragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Float] Score 0.0-1.0
+      def score_file_location_match(fragment, context)
+        return 0.5 unless context.affected_files && !context.affected_files.empty?
+
+        # Only code fragments have file_path
+        return 0.5 unless fragment.respond_to?(:file_path)
+
+        # Check if fragment is from an affected file
+        (context.affected_files.any? do |affected_file|
+          fragment.file_path.include?(affected_file)
+        end) ? 1.0 : 0.1
+      end
+
+      # Score based on work loop step
+      #
+      # @param fragment [Fragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Float] Score 0.0-1.0
+      def score_step_match(fragment, context)
+        return 0.5 unless context.step_name
+
+        step_tags = step_to_tags(context.step_name)
+        return 0.5 if step_tags.empty?
+
+        if fragment.respond_to?(:tags)
+          matching_tags = fragment.tags & step_tags
+          matching_tags.empty? ? 0.3 : 0.8
+        elsif fragment.respond_to?(:category)
+          # Template fragments have categories
+          step_tags.include?(fragment.category) ? 0.9 : 0.4
+        else
+          0.5
+        end
+      end
+
+      # Get detailed score breakdown
+      #
+      # @param fragment [Fragment] Fragment to score
+      # @param context [TaskContext] Task context
+      # @return [Hash] Score breakdown
+      def score_breakdown(fragment, context)
+        {
+          task_type: score_task_type_match(fragment, context),
+          tags: score_tag_match(fragment, context),
+          location: score_file_location_match(fragment, context),
+          step: score_step_match(fragment, context)
+        }
+      end
+
+      # Normalize score to 0.0-1.0 range
+      #
+      # @param score [Float] Raw score
+      # @return [Float] Normalized score
+      def normalize_score(score)
+        score.clamp(0.0, 1.0)
+      end
+
+      # Map task type to relevant tags
+      #
+      # @param task_type [Symbol] Task type
+      # @return [Array<String>] List of relevant tags
+      def task_type_to_tags(task_type)
+        case task_type
+        when :feature, :enhancement
+          ["implementation", "planning", "testing", "api"]
+        when :bugfix, :fix
+          ["testing", "error", "debugging", "logging"]
+        when :refactor, :refactoring
+          ["refactor", "architecture", "testing", "performance"]
+        when :test, :testing
+          ["testing", "analyst"]
+        when :documentation, :docs
+          ["documentation", "planning"]
+        when :security
+          ["security", "testing", "error"]
+        when :performance
+          ["performance", "testing", "refactor"]
+        else
+          []
+        end
+      end
+
+      # Map work loop step to relevant tags
+      #
+      # @param step_name [String] Step name
+      # @return [Array<String>] List of relevant tags
+      def step_to_tags(step_name)
+        step_lower = step_name.to_s.downcase
+
+        tags = []
+        tags << "planning" if step_lower.include?("plan") || step_lower.include?("design")
+        tags << "analysis" if step_lower.include?("analy")
+        tags << "implementation" if step_lower.include?("implement") || step_lower.include?("code")
+        tags << "testing" if step_lower.include?("test")
+        tags << "refactor" if step_lower.include?("refactor")
+        tags << "documentation" if step_lower.include?("doc")
+        tags << "security" if step_lower.include?("security")
+
+        tags
+      end
+    end
+
+    # Represents the context for a task
+    #
+    # Contains information about the current work being done,
+    # used to calculate relevance scores for fragments
+    class TaskContext
+      attr_accessor :task_type, :description, :affected_files, :step_name, :tags
+
+      # @param task_type [Symbol] Type of task (:feature, :bugfix, :refactor, etc.)
+      # @param description [String] Task description
+      # @param affected_files [Array<String>] List of files being modified
+      # @param step_name [String] Current work loop step name
+      # @param tags [Array<String>] Additional context tags
+      def initialize(task_type: nil, description: nil, affected_files: [], step_name: nil, tags: [])
+        @task_type = task_type
+        @description = description
+        @affected_files = affected_files || []
+        @step_name = step_name
+        @tags = tags || []
+
+        # Extract additional tags from description if provided
+        extract_tags_from_description if @description
+      end
+
+      # Extract relevant tags from description text
+      def extract_tags_from_description
+        return unless @description
+
+        desc_lower = @description.downcase
+
+        @tags << "testing" if /test|spec|coverage/.match?(desc_lower)
+        @tags << "security" if /security|auth|permission/.match?(desc_lower)
+        @tags << "performance" if /performance|speed|optimization/.match?(desc_lower)
+        @tags << "database" if /database|sql|migration/.match?(desc_lower)
+        @tags << "api" if /\bapi\b|endpoint|rest/.match?(desc_lower)
+        @tags << "ui" if /\bui\b|interface|view/.match?(desc_lower)
+
+        @tags.uniq!
+      end
+
+      def to_h
+        {
+          task_type: @task_type,
+          description: @description,
+          affected_files: @affected_files,
+          step_name: @step_name,
+          tags: @tags
+        }
+      end
+    end
+  end
+end

data/lib/aidp/prompt_optimization/source_code_fragmenter.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Aidp
+  module PromptOptimization
+    # Fragments source code files into retrievable code units
+    #
+    # Parses Ruby source files and extracts methods, classes, modules
+    # along with their dependencies and imports. Each fragment can be
+    # independently included or excluded from prompts.
+    #
+    # @example Basic usage
+    #   fragmenter = SourceCodeFragmenter.new(project_dir: "/path/to/project")
+    #   fragments = fragmenter.fragment_file("lib/my_file.rb")
+    class SourceCodeFragmenter
+      attr_reader :project_dir
+
+      def initialize(project_dir:)
+        @project_dir = project_dir
+      end
+
+      # Fragment a source file into code units
+      #
+      # @param file_path [String] Path to source file (relative or absolute)
+      # @param context_lines [Integer] Number of context lines around code units
+      # @return [Array<CodeFragment>] List of code fragments
+      def fragment_file(file_path, context_lines: 2)
+        abs_path = File.absolute_path?(file_path) ? file_path : File.join(@project_dir, file_path)
+
+        return [] unless File.exist?(abs_path)
+        return [] unless abs_path.end_with?(".rb")
+
+        content = File.read(abs_path)
+        fragments = []
+
+        # Extract requires/imports as first fragment
+        requires = extract_requires(content)
+        if requires && !requires.empty?
+          fragments << create_requires_fragment(abs_path, requires)
+        end
+
+        # Extract classes and modules
+        fragments.concat(extract_classes_and_modules(abs_path, content))
+
+        # Extract top-level methods
+        fragments.concat(extract_methods(abs_path, content, context_lines: context_lines))
+
+        fragments
+      end
+
+      # Fragment multiple files
+      #
+      # @param file_paths [Array<String>] List of file paths
+      # @return [Array<CodeFragment>] All fragments from all files
+      def fragment_files(file_paths)
+        file_paths.flat_map { |path| fragment_file(path) }
+      end
+
+      private
+
+      # Extract require statements from content
+      #
+      # @param content [String] File content
+      # @return [String, nil] Combined require statements
+      def extract_requires(content)
+        lines = content.lines
+        require_lines = lines.select do |line|
+          line.strip =~ /^require(_relative)?\s+/
+        end
+
+        return nil if require_lines.empty?
+
+        require_lines.join
+      end
+
+      # Create a fragment for require statements
+      #
+      # @param file_path [String] Source file path
+      # @param requires [String] Require statements
+      # @return [CodeFragment] Requires fragment
+      def create_requires_fragment(file_path, requires)
+        CodeFragment.new(
+          id: "#{file_path}:requires",
+          file_path: file_path,
+          type: :requires,
+          name: "requires",
+          content: requires,
+          line_start: 1,
+          line_end: requires.lines.count
+        )
+      end
+
+      # Extract classes and modules with their methods
+      #
+      # @param file_path [String] Source file path
+      # @param content [String] File content
+      # @return [Array<CodeFragment>] Class/module fragments
+      def extract_classes_and_modules(file_path, content)
+        fragments = []
+        lines = content.lines
+
+        current_class = nil
+        class_start = nil
+        indent_level = 0
+
+        lines.each_with_index do |line, idx|
+          # Detect class/module definition
+          if line =~ /^(\s*)(class|module)\s+(\S+)/
+            current_indent = $1.length
+            $2
+            name = $3
+
+            # Save previous class if exists
+            if current_class && class_start
+              class_content = lines[class_start..idx - 1].join
+              fragments << create_class_fragment(file_path, current_class, class_content, class_start + 1, idx)
+            end
+
+            current_class = name
+            class_start = idx
+            indent_level = current_indent
+          elsif line =~ /^(\s*)end/ && current_class
+            end_indent = $1.length
+            if end_indent <= indent_level
+              # Class/module end
+              class_content = lines[class_start..idx].join
+              fragments << create_class_fragment(file_path, current_class, class_content, class_start + 1, idx + 1)
+              current_class = nil
+              class_start = nil
+            end
+          end
+        end
+
+        # Save last class if exists
+        if current_class && class_start
+          class_content = lines[class_start..].join
+          fragments << create_class_fragment(file_path, current_class, class_content, class_start + 1, lines.count)
+        end
+
+        fragments
+      end
+
+      # Create a fragment for a class/module
+      #
+      # @param file_path [String] Source file path
+      # @param name [String] Class/module name
+      # @param content [String] Class/module content
+      # @param line_start [Integer] Starting line number
+      # @param line_end [Integer] Ending line number
+      # @return [CodeFragment] Class fragment
+      def create_class_fragment(file_path, name, content, line_start, line_end)
+        CodeFragment.new(
+          id: "#{file_path}:#{name}",
+          file_path: file_path,
+          type: :class,
+          name: name,
+          content: content,
+          line_start: line_start,
+          line_end: line_end
+        )
+      end
+
+      # Extract top-level methods (not inside classes)
+      #
+      # @param file_path [String] Source file path
+      # @param content [String] File content
+      # @param context_lines [Integer] Lines of context around method
+      # @return [Array<CodeFragment>] Method fragments
+      def extract_methods(file_path, content, context_lines: 2)
+        fragments = []
+        lines = content.lines
+
+        in_class = false
+        method_start = nil
+        method_name = nil
+        indent_level = 0
+
+        lines.each_with_index do |line, idx|
+          # Track if we're inside a class
+          if /^(\s*)(class|module)\s+/.match?(line)
+            in_class = true
+            next
+          elsif line =~ /^end/ && in_class
+            in_class = false
+            next
+          end
+
+          # Skip methods inside classes
+          next if in_class
+
+          # Detect method definition
+          if line =~ /^(\s*)def\s+(\S+)/
+            method_start = [idx - context_lines, 0].max
+            method_name = $2
+            indent_level = $1.length
+          elsif line =~ /^(\s*)end/ && method_name
+            end_indent = $1.length
+            if end_indent <= indent_level
+              # Method end
+              method_end = [idx + context_lines, lines.count - 1].min
+              method_content = lines[method_start..method_end].join
+
+              fragments << CodeFragment.new(
+                id: "#{file_path}:#{method_name}",
+                file_path: file_path,
+                type: :method,
+                name: method_name,
+                content: method_content,
+                line_start: method_start + 1,
+                line_end: method_end + 1
+              )
+
+              method_start = nil
+              method_name = nil
+            end
+          end
+        end
+
+        fragments
+      end
+    end
+
+    # Represents a code fragment (class, method, requires, etc.)
+    #
+    # Each fragment is a logical unit of code that can be independently
+    # included or excluded from prompts based on relevance
+    class CodeFragment
+      attr_reader :id, :file_path, :type, :name, :content, :line_start, :line_end
+
+      # @param id [String] Unique identifier (e.g., "lib/user.rb:User")
+      # @param file_path [String] Source file path
+      # @param type [Symbol] Fragment type (:class, :module, :method, :requires)
+      # @param name [String] Name of the code unit
+      # @param content [String] Code content
+      # @param line_start [Integer] Starting line number
+      # @param line_end [Integer] Ending line number
+      def initialize(id:, file_path:, type:, name:, content:, line_start:, line_end:)
+        @id = id
+        @file_path = file_path
+        @type = type
+        @name = name
+        @content = content
+        @line_start = line_start
+        @line_end = line_end
+      end
+
+      # Get the size of the fragment in characters
+      #
+      # @return [Integer] Character count
+      def size
+        @content.length
+      end
+
+      # Estimate token count (rough approximation: 1 token ≈ 4 chars)
+      #
+      # @return [Integer] Estimated token count
+      def estimated_tokens
+        (size / 4.0).ceil
+      end
+
+      # Get line count
+      #
+      # @return [Integer] Number of lines
+      def line_count
+        @line_end - @line_start + 1
+      end
+
+      # Get relative file path from project root
+      #
+      # @param project_dir [String] Project directory
+      # @return [String] Relative path
+      def relative_path(project_dir)
+        @file_path.sub(%r{^#{Regexp.escape(project_dir)}/?}, "")
+      end
+
+      # Check if this is a test file fragment
+      #
+      # @return [Boolean] True if from spec file
+      def test_file?
+        !!(@file_path =~ /_(spec|test)\.rb$/)
+      end
+
+      # Get a summary of the fragment
+      #
+      # @return [Hash] Fragment summary
+      def summary
+        {
+          id: @id,
+          file_path: @file_path,
+          type: @type,
+          name: @name,
+          lines: "#{@line_start}-#{@line_end}",
+          line_count: line_count,
+          size: size,
+          estimated_tokens: estimated_tokens,
+          test_file: test_file?
+        }
+      end
+
+      def to_s
+        "CodeFragment<#{@type}:#{@name}>"
+      end
+
+      def inspect
+        "#<CodeFragment id=#{@id} type=#{@type} lines=#{@line_start}-#{@line_end}>"
+      end
+    end
+  end
+end