code_qualia 0.1.0

data/lib/code_qualia/complexity_analyzer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'json'
+require 'set'
+require_relative 'config_helper'
+require_relative 'logger'
+
+module CodeQualia
+  class ComplexityAnalyzer
+    def self.analyze
+      new.analyze
+    end
+
+    def analyze
+      Logger.log("Starting complexity analysis")
+      Logger.log("Running RuboCop command for complexity analysis")
+      
+      rubocop_output = run_rubocop
+      parse_rubocop_output(rubocop_output)
+    rescue StandardError => e
+      Logger.log_error('Complexity analysis', e)
+      raise Error, "Failed to analyze complexity: #{e.message}"
+    end
+
+    private
+
+    def get_analysis_directories
+      config = ConfigHelper.load_config
+      directories = extract_directories_from_config(config)
+      directories.select { |dir| Dir.exist?(dir) }
+    end
+
+    def extract_directories_from_config(config)
+      patterns = config.architectural_weights.map { |entry| entry['path'] }
+      directories = PatternExpander.extract_base_directories(patterns)
+
+      # Ensure directories end with '/' and exist
+      directories.map! { |dir| dir.end_with?('/') ? dir : "#{dir}/" }
+      directories.select { |dir| Dir.exist?(dir) }
+    end
+
+    def run_rubocop
+      directories = get_analysis_directories
+      return '' if directories.empty?
+
+      command = "bundle exec rubocop --format json --only Metrics/CyclomaticComplexity #{directories.join(' ')}"
+      result = `#{command} 2>/dev/null`
+
+      if last_exit_status == 127
+        # If bundler is not available, try without bundle exec
+        command = "rubocop --format json --only Metrics/CyclomaticComplexity #{directories.join(' ')}"
+        result = `#{command} 2>/dev/null`
+      end
+
+      result
+    end
+
+    def last_exit_status
+      $CHILD_STATUS.exitstatus
+    end
+
+    def parse_rubocop_output(output)
+      return {} if output.strip.empty?
+
+      # Try to find JSON portion of the output
+      json_start = output.index('{')
+      return {} unless json_start
+
+      json_output = output[json_start..]
+
+      data = JSON.parse(json_output)
+      results = {}
+
+      data['files'].each do |file_data|
+        file_path = file_data['path']
+
+        # Use relative path for consistency
+        relative_path = ConfigHelper.normalize_file_path(file_path)
+
+        next if relative_path.nil? || relative_path.empty?
+
+        file_data['offenses'].each do |offense|
+          next unless offense['cop_name'] == 'Metrics/CyclomaticComplexity'
+
+          method_info = extract_method_info(offense['message'])
+          next unless method_info
+
+          results[relative_path] ||= []
+          results[relative_path] << {
+            method_name: method_info[:method_name],
+            line_number: offense['location']['start_line'],
+            complexity: method_info[:complexity]
+          }
+        end
+      end
+
+      results
+    rescue JSON::ParserError
+      {}
+    end
+
+    def extract_method_info(message)
+      # Extract complexity value and method name from RuboCop message
+      # Example: "Cyclomatic complexity for `calculate_fee` is too high. [12/6]"
+      match = message.match(%r{Cyclomatic complexity for `([^`]+)` is too high\. \[(\d+)/\d+\]})
+      return nil unless match
+
+      {
+        method_name: match[1],
+        complexity: match[2].to_i
+      }
+    end
+  end
+end

data/lib/code_qualia/config.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'pattern_expander'
+
+module CodeQualia
+  class Config
+    attr_reader :quality_weights, :importance_weights, :architectural_weights, :exclude_patterns, :git_history_days
+
+    def initialize(data = {})
+      @quality_weights = data['quality_weights'] || default_quality_weights
+      @importance_weights = data['importance_weights'] || default_importance_weights
+      @architectural_weights = expand_architectural_weights(data['architectural_weights'] || default_architectural_weights)
+      @exclude_patterns = data['exclude'] || default_exclude_patterns
+      @git_history_days = data['git_history_days'] || 90
+    end
+
+    def self.load(file_path)
+      return new unless File.exist?(file_path)
+
+      data = YAML.load_file(file_path)
+      new(data)
+    rescue StandardError => e
+      raise Error, "Failed to load config file: #{e.message}"
+    end
+
+    def architectural_weight_for(file_path)
+      @architectural_weights.each do |entry|
+        return entry['weight'] if File.fnmatch(entry['path'], file_path, File::FNM_PATHNAME)
+      end
+      1.0
+    end
+
+    def excluded?(file_path)
+      @exclude_patterns.any? { |pattern| File.fnmatch(pattern, file_path, File::FNM_PATHNAME) }
+    end
+
+    private
+
+    def default_quality_weights
+      {
+        'test_coverage' => 1.5,
+        'cyclomatic_complexity' => 1.0
+      }
+    end
+
+    def default_importance_weights
+      {
+        'change_frequency' => 0.8,
+        'architectural_importance' => 1.2
+      }
+    end
+
+    def default_architectural_weights
+      [
+        { 'path' => '**/*.rb', 'weight' => 1.0 }
+      ]
+    end
+
+    def default_exclude_patterns
+      [
+        'config/**/*',
+        'db/**/*'
+      ]
+    end
+
+    def expand_architectural_weights(weights)
+      expanded_weights = []
+      weights.each do |entry|
+        path = entry['path']
+        weight = entry['weight']
+        if path.include?('{') && path.include?('}')
+          expanded_paths = PatternExpander.expand_brace_patterns(path)
+          expanded_paths.each do |expanded_path|
+            expanded_weights << { 'path' => expanded_path, 'weight' => weight }
+          end
+        else
+          expanded_weights << entry
+        end
+      end
+      expanded_weights
+    end
+  end
+end

data/lib/code_qualia/config_helper.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative 'pattern_expander'
+require_relative 'config'
+
+module CodeQualia
+  class ConfigHelper
+    class << self
+      # Gets target file patterns from configuration and expands them to glob patterns.
+      #
+      # This method reads the architectural_weights configuration, expands any brace patterns
+      # (e.g., 'app/{models,controllers}/**/*.rb'), and converts directory patterns to
+      # file patterns by appending '**/*.rb' when necessary.
+      #
+      # @return [Array<String>] Array of expanded glob patterns for target files
+      # @example
+      #   ConfigHelper.get_target_patterns
+      #   # => ["app/models/**/*.rb", "app/controllers/**/*.rb", "lib/**/*.rb"]
+      def get_target_patterns
+        config = load_config
+        patterns = config.architectural_weights.map { |entry| entry['path'] }
+
+        # Expand brace patterns and convert to file patterns if they're directory patterns
+        expanded_patterns = []
+        patterns.each do |pattern|
+          if pattern.include?('{') && pattern.include?('}')
+            expanded = PatternExpander.expand_brace_patterns(pattern)
+            expanded_patterns.concat(expanded)
+          else
+            expanded_patterns << pattern
+          end
+        end
+
+        # Convert directory patterns to file patterns
+        expanded_patterns.map do |pattern|
+          if pattern.end_with?('/')
+            "#{pattern}**/*.rb"
+          elsif pattern.end_with?('/**/*')
+            "#{pattern}.rb"
+          elsif !pattern.include?('*')
+            # Assume it's a directory
+            "#{pattern}/**/*.rb"
+          else
+            pattern
+          end
+        end
+      end
+
+      # Checks if a file should be included based on target patterns.
+      #
+      # This method determines whether a given file path matches any of the provided
+      # target patterns. Only Ruby files (.rb extension) are considered for inclusion.
+      #
+      # @param file_path [String] The file path to check
+      # @param target_patterns [Array<String>] Array of glob patterns to match against
+      # @return [Boolean] true if the file should be included, false otherwise
+      # @example
+      #   patterns = ["app/models/**/*.rb", "lib/**/*.rb"]
+      #   ConfigHelper.should_include_file?("app/models/user.rb", patterns)
+      #   # => true
+      #   ConfigHelper.should_include_file?("app/views/index.html.erb", patterns)
+      #   # => false
+      def should_include_file?(file_path, target_patterns)
+        return false unless file_path.end_with?('.rb')
+
+        target_patterns.any? do |pattern|
+          File.fnmatch(pattern, file_path, File::FNM_PATHNAME)
+        end
+      end
+
+      # Normalizes a file path to a relative path from the current working directory.
+      #
+      # This method takes an absolute file path and converts it to a relative path
+      # from the current working directory. This preserves the full directory structure
+      # including any intermediate directories like 'packs/users/'.
+      #
+      # @param file_path [String] The file path to normalize (can be absolute or relative)
+      # @return [String] Relative path from current working directory
+      # @example
+      #   ConfigHelper.normalize_file_path("/full/path/to/project/packs/users/app/models/user.rb")
+      #   # => "packs/users/app/models/user.rb"
+      #   ConfigHelper.normalize_file_path("app/models/user.rb")
+      #   # => "app/models/user.rb"
+      def normalize_file_path(file_path)
+        # If already a relative path, return as-is
+        return file_path unless Pathname.new(file_path).absolute?
+
+        # Convert absolute path to relative path from current working directory
+        current_dir = Dir.pwd
+        if file_path.start_with?(current_dir)
+          relative_path = file_path[(current_dir.length + 1)..-1]
+          return relative_path || file_path
+        end
+
+        # If it doesn't start with current directory, return as-is
+        file_path
+      end
+
+      # Loads the Code Qualia configuration from file or returns default configuration.
+      #
+      # This method attempts to load the configuration from the default config file
+      # (qualia.yml). If the file doesn't exist, it returns a new Config instance
+      # with default values.
+      #
+      # @return [CodeQualia::Config] Loaded configuration or default configuration
+      # @example
+      #   config = ConfigHelper.load_config
+      #   puts config.architectural_weights
+      #   # => [{"path"=>"**/*.rb", "weight"=>1.0}]
+      def load_config
+        if File.exist?(DEFAULT_CONFIG_FILE)
+          Config.load(DEFAULT_CONFIG_FILE)
+        else
+          Config.new
+        end
+      end
+
+      private
+    end
+  end
+end

data/lib/code_qualia/config_installer.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative 'config_helper'
+
+module CodeQualia
+  class ConfigInstaller
+    def initialize(directory)
+      @directory = File.expand_path(directory)
+    end
+
+    def install
+      if config_exists?
+        puts "⚠️  Configuration file '#{DEFAULT_CONFIG_FILE}' already exists."
+        puts '   Use --force to overwrite or remove the existing file.'
+        return
+      end
+
+      project_type = detect_project_type
+      puts "🔍 Detected project type: #{project_type}"
+
+      config_content = generate_config(project_type)
+      write_config(config_content)
+
+      puts "✅ Configuration file '#{DEFAULT_CONFIG_FILE}' created successfully!"
+      puts '   You can now run: code-qualia generate'
+    end
+
+    private
+
+    def config_exists?
+      File.exist?(config_path)
+    end
+
+    def config_path
+      File.join(@directory, DEFAULT_CONFIG_FILE)
+    end
+
+    def detect_project_type
+      if rails_project?
+        'Rails application'
+      elsif gem_project?
+        'Ruby gem'
+      else
+        'Ruby project'
+      end
+    end
+
+    def rails_project?
+      # Check for Rails indicators
+      gemfile_path = File.join(@directory, 'Gemfile')
+      return false unless File.exist?(gemfile_path)
+
+      gemfile_content = File.read(gemfile_path)
+      rails_in_gemfile = gemfile_content.match?(/gem\s+['"]rails['"]/)
+      app_directory_exists = Dir.exist?(File.join(@directory, 'app'))
+
+      rails_in_gemfile && app_directory_exists
+    end
+
+    def gem_project?
+      # Check for gem indicators
+      gemspec_files = Dir.glob(File.join(@directory, '*.gemspec'))
+      lib_directory_exists = Dir.exist?(File.join(@directory, 'lib'))
+
+      !gemspec_files.empty? && lib_directory_exists
+    end
+
+    def generate_config(project_type)
+      case project_type
+      when 'Rails application'
+        rails_config
+      when 'Ruby gem'
+        gem_config
+      else
+        default_config
+      end
+    end
+
+    def rails_config
+      <<~YAML
+        quality_weights:
+          test_coverage: 1.5
+          cyclomatic_complexity: 1.0
+
+        importance_weights:
+          change_frequency: 0.8
+          architectural_importance: 1.2
+
+        architectural_weights:
+          - path: 'app/models/**/*.rb'
+            weight: 2.0
+          - path: 'app/controllers/**/*.rb'
+            weight: 1.5
+          - path: 'app/services/**/*.rb'
+            weight: 1.8
+          - path: 'app/**/*.rb'
+            weight: 1.0
+          - path: 'lib/**/*.rb'
+            weight: 1.0
+
+        exclude:
+          - 'app/channels/**/*'
+          - 'app/helpers/**/*'
+          - 'app/views/**/*'
+          - 'app/assets/**/*'
+          - 'config/**/*'
+          - 'db/**/*'
+          - 'spec/**/*'
+          - 'test/**/*'
+
+        git_history_days: 90
+      YAML
+    end
+
+    def gem_config
+      <<~YAML
+        quality_weights:
+          test_coverage: 1.5
+          cyclomatic_complexity: 1.0
+
+        importance_weights:
+          change_frequency: 0.8
+          architectural_importance: 1.2
+
+        architectural_weights:
+          - path: 'lib/**/*.rb'
+            weight: 1.0
+          - path: 'bin/**/*'
+            weight: 1.3
+
+        exclude:
+          - 'spec/**/*'
+          - 'test/**/*'
+          - 'Gemfile*'
+
+        git_history_days: 90
+      YAML
+    end
+
+    def default_config
+      <<~YAML
+        quality_weights:
+          test_coverage: 1.5
+          cyclomatic_complexity: 1.0
+
+        importance_weights:
+          change_frequency: 0.8
+          architectural_importance: 1.2
+
+        architectural_weights:
+          - path: 'app/**/*.rb'
+            weight: 1.0
+          - path: 'lib/**/*.rb'
+            weight: 1.0
+
+        exclude:
+          - 'config/**/*'
+          - 'db/**/*'
+          - 'spec/**/*'
+          - 'test/**/*'
+
+        git_history_days: 90
+      YAML
+    end
+
+    def write_config(content)
+      File.write(config_path, content)
+    end
+  end
+end

data/lib/code_qualia/coverage_analyzer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'config_helper'
+require_relative 'logger'
+
+module CodeQualia
+  class CoverageAnalyzer
+    RESULTSET_PATH = 'coverage/.resultset.json'
+
+    def self.analyze
+      new.analyze
+    end
+
+    def analyze
+      Logger.log("Looking for coverage data at #{RESULTSET_PATH}")
+      
+      unless File.exist?(RESULTSET_PATH)
+        Logger.log("Coverage file not found: #{RESULTSET_PATH}")
+        return {}
+      end
+
+      Logger.log("Reading coverage data from #{RESULTSET_PATH}")
+      data = JSON.parse(File.read(RESULTSET_PATH))
+      resultset = data.values.first
+
+      unless resultset && resultset['coverage']
+        Logger.log("No coverage data found in resultset")
+        return {}
+      end
+
+      Logger.log("Found coverage data for #{resultset['coverage'].size} files")
+      parse_coverage_data(resultset['coverage'])
+    rescue JSON::ParserError => e
+      Logger.log_error('Coverage analysis', e)
+      raise Error, "Failed to parse coverage data: #{e.message}"
+    end
+
+    private
+
+    def parse_coverage_data(coverage_data)
+
+      results = {}
+      target_patterns = ConfigHelper.get_target_patterns
+
+      coverage_data.each do |file_path, line_coverage|
+        next unless should_include_file_for_coverage?(file_path, target_patterns)
+        next if line_coverage.nil?
+
+        line_data = line_coverage.is_a?(Hash) ? line_coverage['lines'] : line_coverage
+        next if line_data.nil?
+
+        covered_lines = line_data.count { |hits| hits&.positive? }
+        total_lines = line_data.count { |hits| !hits.nil? }
+
+        next if total_lines.zero?
+
+        coverage_rate = covered_lines.to_f / total_lines
+        relative_path = ConfigHelper.normalize_file_path(file_path)
+
+        next if relative_path.nil?
+
+        results[relative_path] = {
+          coverage_rate: coverage_rate,
+          covered_lines: covered_lines,
+          total_lines: total_lines,
+          line_coverage: line_data
+        }
+      end
+
+      results
+    end
+
+    def should_include_file_for_coverage?(file_path, target_patterns)
+      return false unless file_path.end_with?('.rb')
+
+      target_patterns.any? do |pattern|
+        File.fnmatch(pattern, file_path, File::FNM_PATHNAME) ||
+          File.fnmatch("**/#{pattern}", file_path, File::FNM_PATHNAME)
+      end
+    end
+  end
+end

data/lib/code_qualia/git_analyzer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'date'
+require_relative 'config_helper'
+require_relative 'logger'
+
+module CodeQualia
+  class GitAnalyzer
+    def self.analyze(days = 90)
+      new(days).analyze
+    end
+
+    def initialize(days = 90)
+      @days = days
+    end
+
+    def analyze
+      Logger.log("Checking if current directory is a git repository")
+      
+      unless git_repository?
+        Logger.log("Not a git repository, skipping git analysis")
+        return {}
+      end
+
+      Logger.log("Git repository detected, analyzing #{@days} days of history")
+      config = ConfigHelper.load_config
+      git_log_output = run_git_log
+      Logger.log("Git log retrieved, parsing file changes")
+      
+      result = parse_git_log(git_log_output, config)
+      Logger.log("Found git history for #{result.size} files")
+      result
+    rescue StandardError => e
+      Logger.log_error('Git analysis', e)
+      raise Error, "Failed to analyze git history: #{e.message}"
+    end
+
+    private
+
+    def git_repository?
+      system('git rev-parse --git-dir > /dev/null 2>&1')
+    end
+
+    def run_git_log
+      since_date = (Date.today - @days).strftime('%Y-%m-%d')
+      command = "git log --since=#{since_date} --name-only --pretty=format:"
+      `#{command} 2>/dev/null`
+    end
+
+    def parse_git_log(output, config = nil)
+      # For backward compatibility with tests
+      config = ConfigHelper.load_config if config.nil?
+
+      results = {}
+      target_patterns = ConfigHelper.get_target_patterns
+
+      output.split("\n").each do |line|
+        line = line.strip
+        next if line.empty?
+        next unless ConfigHelper.should_include_file?(line, target_patterns)
+
+        results[line] ||= 0
+        results[line] += 1
+      end
+
+      results
+    end
+  end
+end

data/lib/code_qualia/logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CodeQualia
+  class Logger
+    class << self
+      attr_accessor :verbose
+
+      def log(message)
+        return unless verbose
+
+        timestamp = Time.now.strftime('%H:%M:%S')
+        $stderr.puts "[#{timestamp}] #{message}"
+      end
+
+      def log_step(step_name)
+        return unless verbose
+
+        timestamp = Time.now.strftime('%H:%M:%S')
+        $stderr.puts "[#{timestamp}] 🔍 Starting #{step_name}..."
+      end
+
+      def log_result(step_name, result_count = nil, duration = nil)
+        return unless verbose
+
+        timestamp = Time.now.strftime('%H:%M:%S')
+        message = "[#{timestamp}] ✅ #{step_name} completed"
+        message += " (#{result_count} items)" if result_count
+        message += " in #{duration.round(2)}s" if duration
+        $stderr.puts message
+      end
+
+      def log_error(step_name, error)
+        return unless verbose
+
+        timestamp = Time.now.strftime('%H:%M:%S')
+        $stderr.puts "[#{timestamp}] ❌ #{step_name} failed: #{error.message}"
+      end
+
+      def log_skip(step_name, reason)
+        return unless verbose
+
+        timestamp = Time.now.strftime('%H:%M:%S')
+        $stderr.puts "[#{timestamp}] ⏭️  Skipping #{step_name}: #{reason}"
+      end
+    end
+  end
+end