code_qualia 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 24203fd574ea29e81bf9ff29ce73cdacc4a9e88b4cdfe1a67b240dde959c825e
+  data.tar.gz: 5fba6f527637a62f966289d360e830c216b3645e09c7ba6f7cc7ae85f52ec9db
+SHA512:
+  metadata.gz: 9cf345920c0150b7b9fff683d292f2b6e3b464a83142b8001763af49692df9cb58a2d2b8c1d44ed63860d6651247c2191e3c05d8153b23dec29a7c71c063158d
+  data.tar.gz: 65b17c91e1e0c8c360a9a0a52709dd3c75311b412002d0478498ee8c17a3defedc9337d3c980c8c5dbc33a335b1cd77541c0d08d41d7a7398ca2193ec139d55f

data/README.md

@@ -0,0 +1,254 @@
+# Code Qualia
+
+**A tool for communicating developer intuition and code quality perception to AI through configurable parameters**
+
+Code Qualia helps developers express their subjective understanding and feelings about code quality to AI systems. By combining quantitative metrics (coverage, complexity, git activity) with configurable weights that reflect your development priorities and intuitions, it creates a "quality fingerprint" that AI can understand and use for better code analysis and recommendations.
+
+## 🎯 Key Features
+
+- **Developer Intuition Translation**: Convert your subjective code quality perceptions into quantifiable parameters
+- **Configurable Quality Weights**: Express what matters most to you - complexity, coverage, change frequency, or directory importance
+- **AI-Ready Output**: Generate structured data that AI systems can use to understand your code priorities
+- **Multiple Data Sources**: Integrates with SimpleCov, RuboCop, and Git to capture comprehensive code context
+- **Flexible Interface**: CLI tool with JSON, CSV, and human-readable output formats
+
+## 🚀 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'code_qualia', group: [:development, :test]
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+## 📋 Usage
+
+### Setup
+
+First, generate a configuration file for your project:
+
+```bash
+# Auto-detect project type and generate qualia.yml
+bundle exec code-qualia install
+```
+
+This command automatically detects whether you're working with a Rails application or a Ruby gem and generates an appropriate configuration file.
+
+### Basic Analysis
+
+```bash
+# Analyze top 3 methods (default)
+bundle exec code-qualia generate
+
+# Analyze top 10 methods  
+bundle exec code-qualia generate --top-n 10
+
+# Use custom config file
+bundle exec code-qualia generate --config custom_qualia.yml
+
+# Output in different formats
+bundle exec code-qualia generate --format json
+bundle exec code-qualia generate --format csv
+bundle exec code-qualia generate --format table
+```
+
+### Sample Output
+
+```
+📊 Top 3 methods requiring test coverage:
+
+1. app/models/user.rb:21
+   Method: can_access_feature?
+   Priority Score: 18.6
+   Coverage: 50.0%
+   Complexity: 7
+   Git Commits: 0
+
+2. app/models/user.rb:35
+   Method: calculate_discount
+   Priority Score: 11.4
+   Coverage: 50.0%
+   Complexity: 4
+   Git Commits: 0
+
+3. packs/users/app/models/users/user_profile.rb:5
+   Method: display_name
+   Priority Score: 7.8
+   Coverage: 0.0%
+   Complexity: 5
+   Git Commits: 0
+```
+
+## ⚙️ Configuration
+
+Create a `qualia.yml` file in your project root:
+
+```yaml
+# Quality indicators (code issues that need fixing)
+quality_weights:
+  test_coverage: 1.5          # Weight for test coverage (lower coverage = higher priority)
+  cyclomatic_complexity: 1.0  # Weight for cyclomatic complexity (higher complexity = higher priority)
+
+# Importance indicators (how critical the code is)
+importance_weights:
+  change_frequency: 0.8         # Weight for git change frequency (more changes = higher importance)
+  architectural_importance: 1.2 # Weight for architectural importance (critical paths = higher importance)
+
+# Path-based architectural importance weights
+architectural_weights:
+  - path: "app/models/**/*.rb"
+    weight: 2.0      # Models are critical for business logic
+  - path: "app/services/**/*.rb"
+    weight: 1.8      # Services contain complex business logic
+  - path: "app/controllers/**/*.rb"
+    weight: 1.5      # Controllers handle user interactions
+  - path: "lib/**/*.rb"
+    weight: 1.0      # Library code standard weight
+
+# Files to exclude from analysis
+exclude:
+  - "app/helpers/**/*"
+  - "config/**/*"
+  - "db/**/*"
+
+# Days of git history to analyze
+git_history_days: 90
+```
+
+## 🔧 Requirements
+
+- **SimpleCov**: For test coverage data
+- **RuboCop**: For code complexity analysis  
+- **Git**: For file change history
+
+
+## 🏗️ How It Works
+
+Code Qualia calculates a priority score for each method using a multiplicative approach that separates quality issues from code importance:
+
+**FinalScore = QualityScore × ImportanceScore**
+
+Where:
+- **QualityScore** = `(W_test_coverage × TestCoverageFactor) + (W_cyclomatic_complexity × ComplexityFactor)`
+- **ImportanceScore** = `(W_change_frequency × ChangeFrequencyFactor) + (W_architectural_importance × ArchitecturalFactor)`
+
+**Quality Indicators** (code issues that need fixing):
+- **TestCoverageFactor**: `(1.0 - coverage_rate)` - lower coverage = higher quality risk
+- **ComplexityFactor**: Cyclomatic complexity from RuboCop - higher complexity = higher quality risk
+
+**Importance Indicators** (how critical the code is):
+- **ChangeFrequencyFactor**: Number of commits in specified time period - more changes = higher importance
+- **ArchitecturalFactor**: Weight based on file location (configurable) - critical paths = higher importance
+
+This approach ensures that both quality issues AND importance must be present for a method to rank highly, providing more logical prioritization.
+
+
+## 🧪 Development
+
+### Running Tests
+
+```bash
+# Run all tests
+bundle exec rspec
+
+# Run integration tests only
+bundle exec rspec spec/integration/
+```
+
+### Smoke Testing
+
+Code Qualia includes a comprehensive smoke test suite that validates functionality against a sample Rails application in the `smoke/sample_app` directory.
+
+## 📊 Output Formats
+
+Code Qualia supports multiple output formats for flexibility:
+
+### Human-readable (default)
+```
+📊 Top 3 methods requiring test coverage:
+
+1. app/models/user.rb:21
+   Method: can_access_feature?
+   Priority Score: 10.15
+   Coverage: 50.0%
+   Complexity: 7
+   Git Commits: 0
+
+2. packs/users/app/models/users/user_profile.rb:5
+   Method: display_name
+   Priority Score: 7.7
+   Coverage: 0.0%
+   Complexity: 5
+   Git Commits: 0
+```
+
+### JSON Format
+```json
+[
+  {
+    "file_path": "app/models/user.rb",
+    "class_name": "User",
+    "method_name": "can_access_feature?",
+    "line_number": 21,
+    "score": 10.15,
+    "details": {
+      "coverage": 0.5,
+      "complexity": 7,
+      "git_commits": 0
+    }
+  },
+  {
+    "file_path": "packs/users/app/models/users/user_profile.rb",
+    "class_name": "UserProfile",
+    "method_name": "display_name",
+    "line_number": 5,
+    "score": 7.7,
+    "details": {
+      "coverage": 0.0,
+      "complexity": 5,
+      "git_commits": 0
+    }
+  }
+]
+```
+
+### CSV Format
+```csv
+file_path,method_name,line_number,score,coverage,complexity,git_commits
+app/models/user.rb,can_access_feature?,21,10.15,50.0,7,0
+packs/users/app/models/users/user_profile.rb,display_name,5,7.7,0.0,5,0
+```
+
+### Table Format
+```
++----------------------------------------------+---------------------+------+-------+----------+------------+----------+
+| File                                         | Method              | Line | Score | Coverage | Complexity | Commits  |
++----------------------------------------------+---------------------+------+-------+----------+------------+----------+
+| app/models/user.rb                           | can_access_feature? |   21 | 10.15 |    50.0% |          7 |        0 |
+| packs/users/app/models/users/user_profile.rb | display_name        |    5 |  7.70 |     0.0% |          5 |        0 |
++----------------------------------------------+---------------------+------+-------+----------+------------+----------+
+```
+
+All formats can be redirected to files using standard Unix redirection:
+```bash
+bundle exec code-qualia generate --format json > analysis.json
+bundle exec code-qualia generate --format csv > analysis.csv
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Run the test suite (`bundle exec rspec`)
+5. Commit your changes (`git commit -am 'Add amazing feature'`)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License.

data/bin/code-qualia

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+
+# Add lib directory to load path
+lib_path = Pathname.new(__FILE__).dirname.parent.join('lib')
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path.to_s)
+
+require 'code_qualia'
+
+CodeQualia::CLI.new(ARGV).run

data/bin/update_smoke_tests

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# Script to update smoke test expected outputs
+class SmokeTestUpdater
+  def initialize
+    @root_dir = File.expand_path('..', __dir__)
+    @smoke_dir = File.join(@root_dir, 'smoke')
+    @expected_outputs_dir = File.join(@root_dir, 'expected_outputs')
+  end
+
+  def run
+    puts '🔄 Updating smoke test expected outputs...'
+
+    smoke_projects.each do |project|
+      puts "\n📁 Processing #{project[:name]}..."
+      update_project_outputs(project)
+    end
+
+    puts "\n✅ All smoke test expected outputs have been updated!"
+  end
+
+  private
+
+  def smoke_projects
+    projects = []
+    Dir.entries(@smoke_dir).each do |entry|
+      project_path = File.join(@smoke_dir, entry)
+      expected_path = File.join(@expected_outputs_dir, entry)
+
+      # Only include directories that have a Gemfile
+      next unless File.directory?(project_path) &&
+                  !entry.start_with?('.') &&
+                  File.exist?(File.join(project_path, 'Gemfile'))
+
+      projects << {
+        name: entry,
+        dir: project_path,
+        expected_path: expected_path,
+        is_rails: File.exist?(File.join(project_path, 'config', 'application.rb'))
+      }
+    end
+    projects
+  end
+
+  def update_project_outputs(project)
+    # Ensure expected outputs directory exists
+    FileUtils.mkdir_p(project[:expected_path])
+
+    # Generate coverage data if needed
+    generate_coverage_data(project)
+
+    # Generate outputs for each format
+    %w[human json csv table].each do |format|
+      puts "  📊 Generating #{format} format..."
+
+      command_output = if project[:is_rails]
+                         # For Rails projects, run from within the project directory
+                         `cd #{project[:dir]} && bundle exec code-qualia generate --format #{format} --top-n 10 2>&1`
+                       else
+                         # For non-Rails projects, run from project root with --directory option
+                         `bundle exec code-qualia generate --format #{format} --directory #{project[:dir]} --top-n 10 2>&1`
+                       end
+
+      if $?.success?
+        file_extension = if format == 'json'
+                           'json'
+                         else
+                           (format == 'csv' ? 'csv' : 'txt')
+                         end
+        output_file = File.join(project[:expected_path], "output_#{format}.#{file_extension}")
+        File.write(output_file, command_output)
+        puts "    ✓ Saved to #{File.basename(output_file)}"
+      else
+        puts "    ❌ Failed to generate #{format} format for #{project[:name]}"
+        puts "    Error output: #{command_output}"
+      end
+    end
+
+    # Clean up generated files
+    cleanup_generated_files(project)
+  end
+
+  def generate_coverage_data(project)
+    puts '  🧪 Generating coverage data...'
+    Dir.chdir(project[:dir]) do
+      if project[:is_rails]
+        # For Rails projects, run RSpec to generate coverage
+        `bundle exec rspec 2>/dev/null || true`
+      elsif File.exist?('spec/spec_helper.rb')
+        `bundle exec rspec --require spec_helper 2>/dev/null || true`
+      elsif File.exist?('test/test_helper.rb')
+        `bundle exec rake test 2>/dev/null || true`
+      end
+    end
+  end
+
+  def cleanup_generated_files(project)
+    generated_json_path = File.join(project[:dir], 'code_qualia_analysis.json')
+    File.delete(generated_json_path) if File.exist?(generated_json_path)
+  end
+end
+
+# Run the updater
+SmokeTestUpdater.new.run if __FILE__ == $0

data/lib/code_qualia/cli.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'json'
+require_relative '../code_qualia'
+
+module CodeQualia
+  class CLI
+    def initialize(argv)
+      @argv = argv
+      @options = {
+        top_n: 3,
+        config: './qualia.yml',
+        directory: Dir.pwd,
+        format: 'human',
+        verbose: false
+      }
+    end
+
+    def run
+      parse_options
+
+      case @command
+      when 'generate'
+        generate_analysis
+      when 'install'
+        install_config
+      else
+        show_help
+      end
+    end
+
+    private
+
+    def parse_options
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: code-qualia [command] [options]'
+        opts.separator ''
+        opts.separator 'Commands:'
+        opts.separator '  generate    Analyze codebase and generate test recommendations'
+        opts.separator '  install     Setup configuration file for your project'
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('--top-n N', Integer, 'Number of top priority methods to analyze (default: 3)') do |n|
+          @options[:top_n] = n
+        end
+
+        opts.on('--config PATH', String, 'Path to configuration file (default: ./qualia.yml)') do |path|
+          @options[:config] = path
+        end
+
+        opts.on('--directory DIR', String, 'Directory to analyze (default: current directory)') do |dir|
+          @options[:directory] = dir
+        end
+
+        opts.on('--format FORMAT', String, 'Output format: human, json, csv, table (default: human)') do |format|
+          unless %w[human json csv table].include?(format)
+            puts "Error: Invalid format '#{format}'. Valid formats: human, json, csv, table"
+            exit 1
+          end
+          @options[:format] = format
+        end
+
+        opts.on('-v', '--verbose', 'Enable verbose logging') do
+          @options[:verbose] = true
+        end
+
+        opts.on('-h', '--help', 'Show this help message') do
+          puts opts
+          exit
+        end
+      end
+
+      parser.parse!(@argv)
+      @command = @argv.shift
+    end
+
+    def generate_analysis
+      original_dir = Dir.pwd
+
+      begin
+        # Change to target directory for analysis
+        Dir.chdir(@options[:directory])
+
+        results = CodeQualia.analyze(@options[:config], verbose: @options[:verbose])
+
+        if results.empty?
+          case @options[:format]
+          when 'json'
+            puts '[]'
+          when 'csv'
+            puts 'file_path,method_name,line_number,score,coverage,complexity,git_commits'
+          when 'table'
+            puts 'No methods found that need additional testing.'
+          else
+            puts '✅ No methods found that need additional testing.'
+          end
+          return
+        end
+
+        top_results = results.take(@options[:top_n])
+
+        case @options[:format]
+        when 'json'
+          output_json_format(top_results)
+        when 'csv'
+          output_csv_format(top_results)
+        when 'table'
+          output_table_format(top_results)
+        else # 'human'
+          output_human_format(top_results)
+        end
+      rescue CodeQualia::Error => e
+        puts "❌ Error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        puts "❌ Unexpected error: #{e.message}"
+        exit 1
+      ensure
+        Dir.chdir(original_dir)
+      end
+    end
+
+    def output_human_format(results)
+      puts "📊 Top #{results.length} methods requiring test coverage:\n\n"
+
+      results.each_with_index do |method, index|
+        puts "#{index + 1}. #{method[:file_path]}:#{method[:line_number]}"
+        puts "   Method: #{method[:method_name]}"
+        puts "   Priority Score: #{method[:score]}"
+        puts "   Coverage: #{(method[:details][:coverage] * 100).round(1)}%"
+        puts "   Complexity: #{method[:details][:complexity]}"
+        puts "   Git Commits: #{method[:details][:git_commits]}"
+        puts ''
+      end
+    end
+
+    def output_json_format(results)
+      json_output = results.map do |method|
+        {
+          file_path: method[:file_path],
+          class_name: extract_class_name(method[:file_path]),
+          method_name: method[:method_name],
+          line_number: method[:line_number],
+          score: method[:score],
+          details: method[:details]
+        }
+      end
+
+      puts JSON.pretty_generate(json_output)
+    end
+
+    def output_csv_format(results)
+      puts 'file_path,method_name,line_number,score,coverage,complexity,git_commits'
+
+      results.each do |method|
+        coverage_percent = (method[:details][:coverage] * 100).round(1)
+        puts "#{method[:file_path]},#{method[:method_name]},#{method[:line_number]},#{method[:score]},#{coverage_percent},#{method[:details][:complexity]},#{method[:details][:git_commits]}"
+      end
+    end
+
+    def output_table_format(results)
+      require 'io/console'
+
+      # Calculate column widths
+      max_file = results.map { |r| r[:file_path].length }.max || 20
+      max_method = [results.map { |r| r[:method_name].length }.max, 20].min
+
+      # Header
+      puts "+#{'-' * (max_file + 2)}+#{'-' * (max_method + 2)}+------+-------+----------+------------+----------+"
+      printf "| %-#{max_file}s | %-#{max_method}s | Line | Score | Coverage | Complexity | Commits  |\n", 'File', 'Method'
+      puts "+#{'-' * (max_file + 2)}+#{'-' * (max_method + 2)}+------+-------+----------+------------+----------+"
+
+      # Data rows
+      results.each do |method|
+        file_name = method[:file_path]
+        method_name = method[:method_name].length > max_method ? method[:method_name][0...max_method - 1] + '…' : method[:method_name]
+        coverage_percent = (method[:details][:coverage] * 100).round(1)
+
+        printf "| %-#{max_file}s | %-#{max_method}s | %4d | %5.2f | %7.1f%% | %10d | %8d |\n",
+               file_name, method_name, method[:line_number], method[:score],
+               coverage_percent, method[:details][:complexity], method[:details][:git_commits]
+      end
+
+      puts "+#{'-' * (max_file + 2)}+#{'-' * (max_method + 2)}+------+-------+----------+------------+----------+"
+    end
+
+    def extract_class_name(file_path)
+      # Simple heuristic to extract class name from file path
+      File.basename(file_path, '.rb').split('_').map(&:capitalize).join
+    end
+
+    def install_config
+      installer = CodeQualia::ConfigInstaller.new(@options[:directory])
+      installer.install
+    rescue CodeQualia::Error => e
+      puts "❌ Error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      puts "❌ Unexpected error: #{e.message}"
+      exit 1
+    end
+
+    def show_help
+      puts 'code-qualia - AI-powered test coverage analysis tool'
+      puts ''
+      puts 'Usage: code-qualia [command] [options]'
+      puts ''
+      puts 'Commands:'
+      puts '  generate    Analyze codebase and generate test recommendations'
+      puts '  install     Setup configuration file for your project'
+      puts ''
+      puts "Run 'code-qualia [command] --help' for more information."
+    end
+  end
+end