aidp 0.32.0 → 0.33.0

data/lib/aidp/analyze/feature_analyzer.rb

@@ -3,110 +3,126 @@
 require "fileutils"
 
 module Aidp
-  class FeatureAnalyzer
-    def initialize(project_dir = Dir.pwd)
-      @project_dir = project_dir
-    end
-
-    # Detect and categorize features in the codebase
-    def detect_features
-      features = []
-
-      # Scan directories for potential features
-      scan_directories_for_features(features)
-
-      # Scan files for feature indicators
-      scan_files_for_features(features)
-
-      # Analyze feature relationships
-      analyze_feature_relationships(features)
-
-      # Categorize features
-      categorize_features(features)
+  module Analyze
+    class FeatureAnalyzer
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+      end
 
-      features
-    end
+      # Detect and categorize features in the codebase
+      def detect_features
+        features = []
 
-    # Get feature-specific agent recommendations
-    def get_feature_agent_recommendations(feature)
-      {
-        feature: feature[:name],
-        primary_agent: determine_primary_agent(feature),
-        specialized_agents: determine_specialized_agents(feature),
-        analysis_priority: determine_analysis_priority(feature)
-      }
-    end
+        # Scan directories for potential features
+        scan_directories_for_features(features)
 
-    # Coordinate multi-agent analysis for a feature
-    def coordinate_feature_analysis(feature)
-      agents = get_feature_agent_recommendations(feature)
-
-      {
-        feature: feature[:name],
-        primary_analysis: {
-          agent: agents[:primary_agent],
-          focus_areas: get_agent_focus_areas(agents[:primary_agent]),
-          output_files: generate_output_files(feature, agents[:primary_agent])
-        },
-        specialized_analyses: agents[:specialized_agents].map do |agent|
-          {
-            agent: agent,
-            focus_areas: get_agent_focus_areas(agent),
-            output_files: generate_output_files(feature, agent)
-          }
-        end,
-        coordination_notes: generate_coordination_notes(feature, agents)
-      }
-    end
+        # Scan files for feature indicators
+        scan_files_for_features(features)
 
-    private
+        # Analyze feature relationships
+        analyze_feature_relationships(features)
 
-    def scan_directories_for_features(features)
-      # Common feature directory patterns
-      feature_patterns = [
-        "features/", "modules/", "components/", "services/",
-        "controllers/", "models/", "views/", "api/",
-        "handlers/", "processors/", "managers/", "utils/"
-      ]
+        # Categorize features
+        categorize_features(features)
 
-      feature_patterns.each do |pattern|
-        pattern_path = File.join(@project_dir, pattern)
-        next unless Dir.exist?(pattern_path)
+        features
+      end
 
-        Dir.entries(pattern_path).each do |entry|
-          next if entry.start_with?(".") || entry == ".."
+      # Get feature-specific agent recommendations
+      def get_feature_agent_recommendations(feature)
+        {
+          feature: feature[:name],
+          primary_agent: determine_primary_agent(feature),
+          specialized_agents: determine_specialized_agents(feature),
+          analysis_priority: determine_analysis_priority(feature)
+        }
+      end
 
-          feature_path = File.join(pattern_path, entry)
-          next unless Dir.exist?(feature_path)
+      # Coordinate multi-agent analysis for a feature
+      def coordinate_feature_analysis(feature)
+        agents = get_feature_agent_recommendations(feature)
+
+        {
+          feature: feature[:name],
+          primary_analysis: {
+            agent: agents[:primary_agent],
+            focus_areas: get_agent_focus_areas(agents[:primary_agent]),
+            output_files: generate_output_files(feature, agents[:primary_agent])
+          },
+          specialized_analyses: agents[:specialized_agents].map do |agent|
+            {
+              agent: agent,
+              focus_areas: get_agent_focus_areas(agent),
+              output_files: generate_output_files(feature, agent)
+            }
+          end,
+          coordination_notes: generate_coordination_notes(feature, agents)
+        }
+      end
 
-          features << {
-            name: entry || "unknown",
-            type: "directory",
-            path: feature_path,
-            category: infer_category_from_path(pattern, entry),
-            complexity: estimate_complexity(feature_path)
-          }
+      private
+
+      def scan_directories_for_features(features)
+        # Common feature directory patterns
+        feature_patterns = [
+          "features/", "modules/", "components/", "services/",
+          "controllers/", "models/", "views/", "api/",
+          "handlers/", "processors/", "managers/", "utils/"
+        ]
+
+        feature_patterns.each do |pattern|
+          pattern_path = File.join(@project_dir, pattern)
+          next unless Dir.exist?(pattern_path)
+
+          Dir.entries(pattern_path).each do |entry|
+            next if entry.start_with?(".") || entry == ".."
+
+            feature_path = File.join(pattern_path, entry)
+            next unless Dir.exist?(feature_path)
+
+            features << {
+              name: entry || "unknown",
+              type: "directory",
+              path: feature_path,
+              category: infer_category_from_path(pattern, entry),
+              complexity: estimate_complexity(feature_path)
+            }
+          end
         end
       end
-    end
-
-    def scan_files_for_features(features)
-      # Scan for feature indicators in files
-      feature_indicators = [
-        "class.*Controller", "class.*Service", "class.*Manager",
-        "module.*Feature", "def.*feature", "function.*feature"
-      ]
-
-      Dir.glob(File.join(@project_dir, "**", "*.rb")).each do |file|
-        next if file.include?("spec/") || file.include?("test/")
-
-        content = File.read(file)
-        feature_found = false
-
-        feature_indicators.each do |indicator|
-          next unless content.match?(/#{indicator}/i)
 
-          feature_name = extract_feature_name(file, content, indicator)
+      def scan_files_for_features(features)
+        # Scan for feature indicators in files
+        feature_indicators = [
+          "class.*Controller", "class.*Service", "class.*Manager",
+          "module.*Feature", "def.*feature", "function.*feature"
+        ]
+
+        Dir.glob(File.join(@project_dir, "**", "*.rb")).each do |file|
+          next if file.include?("spec/") || file.include?("test/")
+
+          content = File.read(file)
+          feature_found = false
+
+          feature_indicators.each do |indicator|
+            next unless content.match?(/#{indicator}/i)
+
+            feature_name = extract_feature_name(file, content, indicator)
+            features << {
+              name: feature_name,
+              type: "file",
+              path: file,
+              category: infer_category_from_file(file, content),
+              complexity: estimate_file_complexity(content)
+            }
+            feature_found = true
+            break
+          end
+
+          # If no specific pattern matched, add the file as a feature using filename
+          next if feature_found
+
+          feature_name = File.basename(file, ".*").capitalize
           features << {
             name: feature_name,
             type: "file",
@@ -114,284 +130,270 @@ module Aidp
             category: infer_category_from_file(file, content),
             complexity: estimate_file_complexity(content)
           }
-          feature_found = true
-          break
         end
-
-        # If no specific pattern matched, add the file as a feature using filename
-        next if feature_found
-
-        feature_name = File.basename(file, ".*").capitalize
-        features << {
-          name: feature_name,
-          type: "file",
-          path: file,
-          category: infer_category_from_file(file, content),
-          complexity: estimate_file_complexity(content)
-        }
       end
-    end
 
-    def analyze_feature_relationships(features)
-      features.each do |feature|
-        feature[:dependencies] = find_feature_dependencies(feature)
-        feature[:dependents] = find_feature_dependents(feature, features)
-        feature[:coupling] = calculate_coupling_score(feature)
+      def analyze_feature_relationships(features)
+        features.each do |feature|
+          feature[:dependencies] = find_feature_dependencies(feature)
+          feature[:dependents] = find_feature_dependents(feature, features)
+          feature[:coupling] = calculate_coupling_score(feature)
+        end
       end
-    end
 
-    def categorize_features(features)
-      features.each do |feature|
-        feature[:category] ||= infer_category(feature)
-        feature[:priority] = calculate_priority(feature)
-        feature[:business_value] = estimate_business_value(feature)
-        feature[:technical_debt] = estimate_technical_debt(feature)
+      def categorize_features(features)
+        features.each do |feature|
+          feature[:category] ||= infer_category(feature)
+          feature[:priority] = calculate_priority(feature)
+          feature[:business_value] = estimate_business_value(feature)
+          feature[:technical_debt] = estimate_technical_debt(feature)
+        end
       end
-    end
 
-    def determine_primary_agent(feature)
-      case feature[:category]
-      when "core_business"
-        "Functionality Analyst"
-      when "api"
-        "Architecture Analyst"
-      when "data"
-        "Functionality Analyst"
-      when "ui"
-        "Functionality Analyst"
-      when "utility"
-        "Static Analysis Expert"
-      else
-        "Functionality Analyst"
+      def determine_primary_agent(feature)
+        case feature[:category]
+        when "core_business"
+          "Functionality Analyst"
+        when "api"
+          "Architecture Analyst"
+        when "data"
+          "Functionality Analyst"
+        when "ui"
+          "Functionality Analyst"
+        when "utility"
+          "Static Analysis Expert"
+        else
+          "Functionality Analyst"
+        end
       end
-    end
 
-    def determine_specialized_agents(feature)
-      agents = []
+      def determine_specialized_agents(feature)
+        agents = []
 
-      # Add specialized agents based on feature characteristics
-      agents << "Test Analyst" if feature[:complexity] > 5
-      agents << "Architecture Analyst" if feature[:coupling] > 0.7
-      agents << "Documentation Analyst" if feature[:business_value] > 0.8
-      agents << "Refactoring Specialist" if feature[:technical_debt] > 0.6
+        # Add specialized agents based on feature characteristics
+        agents << "Test Analyst" if feature[:complexity] > 5
+        agents << "Architecture Analyst" if feature[:coupling] > 0.7
+        agents << "Documentation Analyst" if feature[:business_value] > 0.8
+        agents << "Refactoring Specialist" if feature[:technical_debt] > 0.6
 
-      agents.uniq
-    end
+        agents.uniq
+      end
 
-    def determine_analysis_priority(feature)
-      # Calculate priority based on business value, complexity, and technical debt
-      priority_score = (
-        feature[:business_value] * 0.4 +
-        feature[:complexity] * 0.3 +
-        feature[:technical_debt] * 0.3
-      )
-
-      case priority_score
-      when 0.8..1.0
-        "high"
-      when 0.5..0.8
-        "medium"
-      else
-        "low"
+      def determine_analysis_priority(feature)
+        # Calculate priority based on business value, complexity, and technical debt
+        priority_score = (
+          feature[:business_value] * 0.4 +
+          feature[:complexity] * 0.3 +
+          feature[:technical_debt] * 0.3
+        )
+
+        case priority_score
+        when 0.8..1.0
+          "high"
+        when 0.5..0.8
+          "medium"
+        else
+          "low"
+        end
       end
-    end
 
-    def get_agent_focus_areas(agent_name)
-      case agent_name
-      when "Functionality Analyst"
-        %w[feature_mapping complexity_analysis dead_code_identification]
-      when "Architecture Analyst"
-        %w[dependency_analysis coupling_assessment design_patterns]
-      when "Test Analyst"
-        %w[test_coverage test_quality testing_gaps]
-      when "Documentation Analyst"
-        %w[documentation_gaps documentation_quality user_needs]
-      when "Static Analysis Expert"
-        %w[code_quality tool_integration best_practices]
-      when "Refactoring Specialist"
-        %w[technical_debt code_smells refactoring_opportunities]
-      else
-        ["general_analysis"]
+      def get_agent_focus_areas(agent_name)
+        case agent_name
+        when "Functionality Analyst"
+          %w[feature_mapping complexity_analysis dead_code_identification]
+        when "Architecture Analyst"
+          %w[dependency_analysis coupling_assessment design_patterns]
+        when "Test Analyst"
+          %w[test_coverage test_quality testing_gaps]
+        when "Documentation Analyst"
+          %w[documentation_gaps documentation_quality user_needs]
+        when "Static Analysis Expert"
+          %w[code_quality tool_integration best_practices]
+        when "Refactoring Specialist"
+          %w[technical_debt code_smells refactoring_opportunities]
+        else
+          ["general_analysis"]
+        end
       end
-    end
 
-    def generate_output_files(feature, agent_name)
-      base_name = (feature[:name] || "unknown").downcase.gsub(/[^a-z0-9]/, "_")
-      agent_suffix = agent_name.downcase.gsub(/\s+/, "_")
+      def generate_output_files(feature, agent_name)
+        base_name = (feature[:name] || "unknown").downcase.gsub(/[^a-z0-9]/, "_")
+        agent_suffix = agent_name.downcase.gsub(/\s+/, "_")
 
-      {
-        primary: "docs/#{base_name}_#{agent_suffix}_analysis.md",
-        secondary: "docs/#{base_name}_#{agent_suffix}_details.md",
-        data: "docs/#{base_name}_#{agent_suffix}_data.json"
-      }
-    end
+        {
+          primary: "docs/#{base_name}_#{agent_suffix}_analysis.md",
+          secondary: "docs/#{base_name}_#{agent_suffix}_details.md",
+          data: "docs/#{base_name}_#{agent_suffix}_data.json"
+        }
+      end
 
-    def generate_coordination_notes(feature, agents)
-      notes = []
+      def generate_coordination_notes(feature, agents)
+        notes = []
 
-      notes << "Feature: #{feature[:name] || "unknown"} (#{feature[:category] || "unknown"})"
-      notes << "Primary Agent: #{agents[:primary_agent]}"
-      notes << "Specialized Agents: #{agents[:specialized_agents].join(", ")}"
-      notes << "Priority: #{agents[:analysis_priority]}"
-      notes << "Focus Areas: #{get_agent_focus_areas(agents[:primary_agent]).join(", ")}"
+        notes << "Feature: #{feature[:name] || "unknown"} (#{feature[:category] || "unknown"})"
+        notes << "Primary Agent: #{agents[:primary_agent]}"
+        notes << "Specialized Agents: #{agents[:specialized_agents].join(", ")}"
+        notes << "Priority: #{agents[:analysis_priority]}"
+        notes << "Focus Areas: #{get_agent_focus_areas(agents[:primary_agent]).join(", ")}"
 
-      notes.join("\n")
-    end
+        notes.join("\n")
+      end
 
-    def infer_category_from_path(pattern, entry)
-      case pattern
-      when "controllers/"
-        "api"
-      when "models/"
-        "data"
-      when "views/"
-        "ui"
-      when "services/"
-        "core_business"
-      when "utils/"
-        "utility"
-      else
-        "core_business"
+      def infer_category_from_path(pattern, entry)
+        case pattern
+        when "controllers/"
+          "api"
+        when "models/"
+          "data"
+        when "views/"
+          "ui"
+        when "services/"
+          "core_business"
+        when "utils/"
+          "utility"
+        else
+          "core_business"
+        end
       end
-    end
 
-    def infer_category_from_file(file, content)
-      if content.match?(/class.*Controller/i)
-        "api"
-      elsif content.match?(/class.*Model/i)
-        "data"
-      elsif content.match?(/class.*Service/i)
-        "core_business"
-      elsif content.match?(/class.*Util/i)
-        "utility"
-      else
-        "core_business"
+      def infer_category_from_file(file, content)
+        if content.match?(/class.*Controller/i)
+          "api"
+        elsif content.match?(/class.*Model/i)
+          "data"
+        elsif content.match?(/class.*Service/i)
+          "core_business"
+        elsif content.match?(/class.*Util/i)
+          "utility"
+        else
+          "core_business"
+        end
       end
-    end
 
-    def infer_category(feature)
-      # Default categorization logic
-      if feature[:name]&.match?(/controller|api|endpoint/i)
-        "api"
-      elsif feature[:name]&.match?(/model|data|entity/i)
-        "data"
-      elsif feature[:name]&.match?(/view|ui|component/i)
-        "ui"
-      elsif feature[:name]&.match?(/util|helper|tool/i)
-        "utility"
-      else
-        "core_business"
+      def infer_category(feature)
+        # Default categorization logic
+        if feature[:name]&.match?(/controller|api|endpoint/i)
+          "api"
+        elsif feature[:name]&.match?(/model|data|entity/i)
+          "data"
+        elsif feature[:name]&.match?(/view|ui|component/i)
+          "ui"
+        elsif feature[:name]&.match?(/util|helper|tool/i)
+          "utility"
+        else
+          "core_business"
+        end
       end
-    end
 
-    def estimate_complexity(path)
-      # Simple complexity estimation based on file count and size
-      file_count = Dir.glob(File.join(path, "**", "*.rb")).count
-      total_lines = Dir.glob(File.join(path, "**", "*.rb")).sum { |f| File.readlines(f).count }
+      def estimate_complexity(path)
+        # Simple complexity estimation based on file count and size
+        file_count = Dir.glob(File.join(path, "**", "*.rb")).count
+        total_lines = Dir.glob(File.join(path, "**", "*.rb")).sum { |f| File.readlines(f).count }
 
-      complexity = (file_count * 0.3 + total_lines / 100.0 * 0.7).clamp(0, 10)
-      (complexity / 10.0).round(2)
-    end
+        complexity = (file_count * 0.3 + total_lines / 100.0 * 0.7).clamp(0, 10)
+        (complexity / 10.0).round(2)
+      end
 
-    def estimate_file_complexity(content)
-      # Simple complexity estimation based on lines of code
-      lines = content.lines.count
-      complexity = (lines / 50.0).clamp(0, 10)
-      (complexity / 10.0).round(2)
-    end
+      def estimate_file_complexity(content)
+        # Simple complexity estimation based on lines of code
+        lines = content.lines.count
+        complexity = (lines / 50.0).clamp(0, 10)
+        (complexity / 10.0).round(2)
+      end
 
-    def find_feature_dependencies(feature)
-      # Simplified dependency detection
-      dependencies = []
+      def find_feature_dependencies(feature)
+        # Simplified dependency detection
+        dependencies = []
 
-      if feature[:type] == "file"
-        content = File.read(feature[:path])
-        # Look for require/import statements
-        content.scan(/require\s+['"]([^'"]+)['"]/).each do |match|
-          dependencies << match[0]
+        if feature[:type] == "file"
+          content = File.read(feature[:path])
+          # Look for require/import statements
+          content.scan(/require\s+['"]([^'"]+)['"]/).each do |match|
+            dependencies << match[0]
+          end
         end
+
+        dependencies
       end
 
-      dependencies
-    end
+      def find_feature_dependents(feature, all_features)
+        # Find features that depend on this feature
+        dependents = []
 
-    def find_feature_dependents(feature, all_features)
-      # Find features that depend on this feature
-      dependents = []
+        all_features.each do |other_feature|
+          dependents << other_feature[:name] if other_feature[:dependencies]&.include?(feature[:name])
+        end
 
-      all_features.each do |other_feature|
-        dependents << other_feature[:name] if other_feature[:dependencies]&.include?(feature[:name])
+        dependents
       end
 
-      dependents
-    end
+      def calculate_coupling_score(feature)
+        # Calculate coupling based on dependencies and dependents
+        dependency_count = feature[:dependencies]&.count || 0
+        dependent_count = feature[:dependents]&.count || 0
 
-    def calculate_coupling_score(feature)
-      # Calculate coupling based on dependencies and dependents
-      dependency_count = feature[:dependencies]&.count || 0
-      dependent_count = feature[:dependents]&.count || 0
+        coupling = (dependency_count + dependent_count) / 10.0
+        coupling.clamp(0, 1).round(2)
+      end
 
-      coupling = (dependency_count + dependent_count) / 10.0
-      coupling.clamp(0, 1).round(2)
-    end
+      def calculate_priority(feature)
+        # Calculate priority based on business value and complexity
+        business_value = feature[:business_value] || 0.5
+        complexity = feature[:complexity] || 0.5
 
-    def calculate_priority(feature)
-      # Calculate priority based on business value and complexity
-      business_value = feature[:business_value] || 0.5
-      complexity = feature[:complexity] || 0.5
+        priority = (business_value * 0.7 + complexity * 0.3)
+        priority.clamp(0, 1).round(2)
+      end
 
-      priority = (business_value * 0.7 + complexity * 0.3)
-      priority.clamp(0, 1).round(2)
-    end
+      def estimate_business_value(feature)
+        # Simple business value estimation based on category and name
+        base_value = case feature[:category]
+        when "core_business"
+          0.9
+        when "api"
+          0.8
+        when "data"
+          0.7
+        when "ui"
+          0.6
+        when "utility"
+          0.3
+        else
+          0.5
+        end
 
-    def estimate_business_value(feature)
-      # Simple business value estimation based on category and name
-      base_value = case feature[:category]
-      when "core_business"
-        0.9
-      when "api"
-        0.8
-      when "data"
-        0.7
-      when "ui"
-        0.6
-      when "utility"
-        0.3
-      else
-        0.5
-      end
+        # Adjust based on feature name indicators
+        if feature[:name]&.match?(/user|auth|payment|order/i)
+          base_value += 0.1
+        elsif feature[:name]&.match?(/util|helper|tool/i)
+          base_value -= 0.1
+        end
 
-      # Adjust based on feature name indicators
-      if feature[:name]&.match?(/user|auth|payment|order/i)
-        base_value += 0.1
-      elsif feature[:name]&.match?(/util|helper|tool/i)
-        base_value -= 0.1
+        base_value.clamp(0, 1).round(2)
       end
 
-      base_value.clamp(0, 1).round(2)
-    end
-
-    def estimate_technical_debt(feature)
-      # Simple technical debt estimation based on complexity and coupling
-      complexity = feature[:complexity] || 0.5
-      coupling = feature[:coupling] || 0.5
+      def estimate_technical_debt(feature)
+        # Simple technical debt estimation based on complexity and coupling
+        complexity = feature[:complexity] || 0.5
+        coupling = feature[:coupling] || 0.5
 
-      technical_debt = (complexity * 0.6 + coupling * 0.4)
-      technical_debt.clamp(0, 1).round(2)
-    end
+        technical_debt = (complexity * 0.6 + coupling * 0.4)
+        technical_debt.clamp(0, 1).round(2)
+      end
 
-    def extract_feature_name(file, content, indicator)
-      # Extract feature name from file content
-      if content.match?(/class\s+(\w+)/)
-        ::Regexp.last_match(1)
-      elsif content.match?(/module\s+(\w+)/)
-        ::Regexp.last_match(1)
-      else
+      def extract_feature_name(file, content, indicator)
+        # Extract feature name from file content
+        if content.match?(/class\s+(\w+)/)
+          ::Regexp.last_match(1)
+        elsif content.match?(/module\s+(\w+)/)
+          ::Regexp.last_match(1)
+        else
+          File.basename(file, ".*").capitalize
+        end
+      rescue
+        # Fallback to filename if extraction fails
         File.basename(file, ".*").capitalize
       end
-    rescue
-      # Fallback to filename if extraction fails
-      File.basename(file, ".*").capitalize
     end
   end
 end