sixth_sense 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d460a31490dfd9d4ac8c096fbcb86afdad696ba0beafef3e8893e6fbf81aa6a
+  data.tar.gz: 75850592152aa8d123d7265402113db56a7cf2316a15092890b60d7ebc0fd6ee
+SHA512:
+  metadata.gz: 5c0960e29d12302ed481552c384994a0e05adb9f493b9850751c1c029d5753fdf0df96e77147ae574db2697dce4e8d26df348ce38abbd8b78bbb3d58f71ff5b8
+  data.tar.gz: b0bd4de300fbf8fde89299f04da91f49bc10816ce1a59c60ddecfdf7a83765451ef319f0f15300ff9100ecb4f2302d520b065aad8676d4fe67cdeba3bc452fdc

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,125 @@
+# SixthSense
+
+Evidence-based test suite adequacy analysis for Ruby projects.
+
+SixthSense scores test files across three axes:
+
+- Adequacy: coverage, checked coverage, and mutation score where available.
+- Redundancy: coverage- and mutation-requirement overlap, plus static clone detection.
+- Quality: test smells, assertion density, and flaky-test triggers.
+
+## Installation
+
+Add the gem to your application's Gemfile:
+
+```ruby
+gem "sixth_sense"
+```
+
+Then install dependencies:
+
+```sh
+bundle install
+```
+
+For local development from this repository:
+
+```sh
+bundle install
+rake test
+```
+
+## Usage
+
+Run a static quality and redundancy pass:
+
+```sh
+ruby -Ilib exe/sixth_sense analyze spec --level 0
+```
+
+Run coverage and checked-coverage analysis:
+
+```sh
+ruby -Ilib exe/sixth_sense analyze spec --level 1 --format json
+```
+
+Run Level 2 analysis after producing mutation cache data:
+
+```sh
+ruby -Ilib exe/sixth_sense mutation-run spec --mutation-mode matrix
+ruby -Ilib exe/sixth_sense analyze spec --level 2
+```
+
+Use guard mode in CI:
+
+```sh
+ruby -Ilib exe/sixth_sense guard --diff origin/main
+```
+
+Explain an analyzer and its references:
+
+```sh
+ruby -Ilib exe/sixth_sense explain adequacy/mutation
+```
+
+## Capabilities
+
+- RSpec, Minitest, and test-unit discovery and parsing.
+- Per-example coverage through subprocess probes, plus in-process coverage mode.
+- TracePoint checked coverage with windowed and strict modes.
+- Built-in mutation matrix producer for RSpec, Minitest, and test-unit.
+- External `mutant` score ingestion when available.
+- Console, JSON, Markdown, HTML, and SARIF reports.
+- Baseline ratcheting for gradual adoption.
+- Plugin hooks for custom adapters and analyzers.
+
+## Configuration
+
+Create `.sixth_sense.yml` when defaults need to be adjusted:
+
+```yaml
+guardrail:
+  fail_under:
+    adequacy: 70
+    redundancy: 60
+    quality: 75
+  require_level: 1
+  ratchet: true
+  tolerance: 1.0
+coverage:
+  enabled: true
+  load_path: lib
+  checked_mode: windowed # windowed | strict
+  checked_window: 20
+adequacy:
+  coverage_transform: raw # raw | calibrated
+  coverage_gamma: 0.5
+mutation:
+  cache_dir: .sixth_sense_cache/kill_matrix
+  mode: score # score | matrix
+  score_engine: auto # auto | mutant | builtin
+  timeout: 10
+  timeout_policy: killed # killed | separate
+  max_mutants: 500
+  equivalent_threshold: 0.2
+  operators:
+    exclude: []
+```
+
+## Development
+
+Run the test suite:
+
+```sh
+rake test
+```
+
+Build the gem locally:
+
+```sh
+gem build sixth_sense.gemspec
+```
+
+## License
+
+SixthSense is available under the MIT License.

data/exe/sixth_sense

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "sixth_sense"
+require "sixth_sense/cli"
+
+exit SixthSense::CLI.new.run(ARGV)

data/lib/sixth_sense/adapters/minitest.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../framework_adapter"
+require_relative "../model"
+require_relative "../source_location"
+require_relative "rspec"
+
+module SixthSense
+  module Adapters
+    class Minitest < FrameworkAdapter
+      ASSERTION_PREFIXES = %w[assert refute].freeze
+
+      def handles?(path)
+        return false unless path.end_with?("_test.rb")
+        return false unless File.file?(path)
+
+        source = File.read(path)
+        return false if source.match?(/\bTest::Unit::TestCase\b/)
+
+        source.match?(/\b(Minitest::Test|assert_|refute_|assert\b|refute\b)/)
+      end
+
+      def parse(path)
+        parsed = Prism.parse_file(path)
+        unless parsed.success?
+          messages = parsed.errors.map(&:message).join(", ")
+          raise Error, "failed to parse #{path}: #{messages}"
+        end
+
+        Model::TestFile.new(
+          path: path,
+          framework: :minitest,
+          test_cases: Parser.new(path, parsed.value).test_cases,
+          sut_candidates: map_to_sut_path(path),
+          metadata: {}
+        )
+      end
+
+      def run_with_coverage(test_files:, isolation:)
+        require_relative "../runners/coverage_runner"
+
+        Runners::CoverageRunner.new.run(test_files: test_files, isolation: isolation)
+      end
+
+      def mutation_session(test_files:)
+        { framework: :minitest, test_files: test_files.map(&:path), runner: "ruby" }
+      end
+
+      def map_to_sut(test_file)
+        map_to_sut_path(test_file.path)
+      end
+
+      private
+
+      def map_to_sut_path(test_path)
+        relative = test_path.tr("\\", "/").sub(%r{\A(?:.*?/)?test/}, "").sub(/_test\.rb\z/, ".rb")
+        root = project_root_for(test_path)
+        candidates = [File.join("lib", relative), File.join("app", relative), relative]
+        if root
+          candidates << File.join(root, "lib", relative)
+          candidates << File.join(root, "app", relative)
+        end
+        candidates.uniq.filter_map do |candidate|
+          next unless File.file?(candidate)
+
+          Adapters::RSpec::CodeUnitExtractor.new(candidate).code_unit
+        end
+      end
+
+      def project_root_for(test_path)
+        normalized = test_path.tr("\\", "/")
+        match = %r{\A(.+?)/test/}.match(normalized)
+        match&.[](1)
+      end
+
+      class Parser
+        def initialize(path, ast)
+          @path = path
+          @ast = ast
+        end
+
+        def test_cases
+          cases = []
+          walk(@ast) do |node|
+            next unless node.is_a?(Prism::DefNode)
+            next unless node.name.to_s.start_with?("test_")
+
+            cases << test_case_for(node)
+          end
+          cases
+        end
+
+        private
+
+        def test_case_for(node)
+          body = node.slice.to_s
+          Model::TestCase.new(
+            id: "#{@path}:#{node.name}",
+            description: node.name.to_s.tr("_", " "),
+            location: location_for(node),
+            assertions: assertions_for(node),
+            ast: node,
+            body: body,
+            metadata: {}
+          )
+        end
+
+        def assertions_for(node)
+          assertions = []
+          walk(node) do |child|
+            next unless child.is_a?(Prism::CallNode)
+            next unless assertion_call?(child.name)
+
+            assertions << Model::Assertion.new(
+              location: location_for(child),
+              matcher: child.name,
+              subject_expr: child.arguments&.arguments&.map(&:slice)&.join(", "),
+              message: nil
+            )
+          end
+          assertions
+        end
+
+        def assertion_call?(name)
+          ASSERTION_PREFIXES.any? { |prefix| name.to_s.start_with?(prefix) }
+        end
+
+        def walk(node, &block)
+          return unless node
+
+          yield node
+          node.each_child_node { |child| walk(child, &block) }
+        end
+
+        def location_for(node)
+          SourceLocation.new(path: @path, line: node.location.start_line, column: node.location.start_column + 1)
+        end
+      end
+    end
+  end
+end
+
+SixthSense::FrameworkAdapter.register(:minitest, SixthSense::Adapters::Minitest)

data/lib/sixth_sense/adapters/rspec.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../framework_adapter"
+require_relative "../model"
+require_relative "../source_location"
+
+module SixthSense
+  module Adapters
+    class RSpec < FrameworkAdapter
+      GROUP_NAMES = %i[describe context feature].freeze
+      EXAMPLE_NAMES = %i[it specify example scenario].freeze
+      PENDING_EXAMPLE_NAMES = %i[xit xspecify xexample pending skip].freeze
+      SHARED_GROUP_NAMES = %i[shared_examples shared_examples_for shared_context].freeze
+      SHARED_USAGE_NAMES = %i[it_behaves_like it_should_behave_like include_examples include_context].freeze
+      FIXTURE_NAMES = %i[let let! subject subject! before around].freeze
+
+      def handles?(path)
+        return false unless path.end_with?("_spec.rb")
+        return false unless File.file?(path)
+
+        source = File.read(path)
+        source.match?(/\b(RSpec\.)?(describe|context|it|specify|example)\b/)
+      end
+
+      def parse(path)
+        source = File.read(path)
+        parsed = Prism.parse(source)
+        unless parsed.success?
+          messages = parsed.errors.map(&:message).join(", ")
+          raise Error, "failed to parse #{path}: #{messages}"
+        end
+
+        test_file = Model::TestFile.new(
+          path: path,
+          framework: :rspec,
+          test_cases: Parser.new(path, parsed.value).test_cases,
+          sut_candidates: [],
+          metadata: {}
+        )
+        test_file.sut_candidates = map_to_sut(test_file)
+        test_file
+      end
+
+      def run_with_coverage(test_files:, isolation:)
+        require_relative "../runners/coverage_runner"
+
+        Runners::CoverageRunner.new.run(test_files: test_files, isolation: isolation)
+      end
+
+      def mutation_session(test_files:)
+        {
+          framework: :rspec,
+          test_files: test_files.map(&:path),
+          runner: "mutant-rspec"
+        }
+      end
+
+      def map_to_sut(test_file)
+        conventional_sut_paths(test_file.path).filter_map do |candidate|
+          next unless File.file?(candidate)
+
+          CodeUnitExtractor.new(candidate).code_unit
+        end
+      end
+
+      def assertion_patterns
+        %i[expect is_expected should should_not]
+      end
+
+      private
+
+      def conventional_sut_paths(spec_path)
+        relative = spec_relative_path(spec_path).sub(/_spec\.rb\z/, ".rb")
+        root = project_root_for(spec_path)
+        candidates = [
+          File.join("lib", relative),
+          File.join("app", relative),
+          relative
+        ]
+        if root
+          candidates << File.join(root, "lib", relative)
+          candidates << File.join(root, "app", relative)
+        end
+        candidates.uniq
+      end
+
+      def spec_relative_path(spec_path)
+        normalized = spec_path.tr("\\", "/")
+        return normalized.sub(%r{\Aspec/}, "") if normalized.start_with?("spec/")
+
+        normalized.sub(%r{\A.*?/spec/}, "")
+      end
+
+      def project_root_for(spec_path)
+        normalized = spec_path.tr("\\", "/")
+        match = %r{\A(.+?)/spec/}.match(normalized)
+        match&.[](1)
+      end
+
+      class Parser
+        def initialize(path, ast)
+          @path = path
+          @ast = ast
+          @shared_examples = {}
+        end
+
+        def test_cases
+          cases = []
+          process_statements(@ast.statements, [], [], [], cases)
+          cases
+        end
+
+        private
+
+        def process_statements(statements, index_stack, descriptions, fixtures, cases)
+          return unless statements
+
+          counter = 0
+          statements.body.each do |node|
+            if call_node?(node) && shared_definition_call?(node)
+              @shared_examples[description_for(node)] = {
+                body: node.block&.body,
+                descriptions: descriptions + [description_for(node)],
+                fixtures: fixtures.dup
+              }
+            elsif call_node?(node) && fixture_call?(node)
+              fixtures << fixture_metadata(node)
+            elsif call_node?(node) && (group_call?(node) || example_call?(node) || shared_usage_call?(node))
+              counter += 1
+              process_rspec_call(node, index_stack + [counter], descriptions, fixtures, cases)
+            else
+              process_nested(node, index_stack, descriptions, fixtures, cases)
+            end
+          end
+        end
+
+        def process_nested(node, index_stack, descriptions, fixtures, cases)
+          node.each_child_node do |child|
+            if child.respond_to?(:body) && child.body.respond_to?(:body)
+              process_statements(child.body, index_stack, descriptions, fixtures.dup, cases)
+            elsif child.respond_to?(:statements)
+              process_statements(child.statements, index_stack, descriptions, fixtures.dup, cases)
+            else
+              process_nested(child, index_stack, descriptions, fixtures, cases)
+            end
+          end
+        end
+
+        def process_rspec_call(node, index_stack, descriptions, fixtures, cases)
+          if group_call?(node)
+            group_description = description_for(node)
+            process_statements(node.block&.body, index_stack, descriptions + [group_description], fixtures.dup, cases)
+            return
+          end
+
+          if shared_usage_call?(node)
+            expand_shared_usage(node, index_stack, descriptions, fixtures, cases)
+            return
+          end
+
+          cases << build_test_case(node, index_stack, descriptions, fixtures)
+        end
+
+        def expand_shared_usage(node, index_stack, descriptions, fixtures, cases)
+          shared = @shared_examples[description_for(node)]
+          unless shared
+            cases << build_test_case(node, index_stack, descriptions, fixtures)
+            return
+          end
+
+          process_statements(
+            shared[:body],
+            index_stack,
+            descriptions + [description_for(node)],
+            fixtures + shared[:fixtures],
+            cases
+          )
+        end
+
+        def build_test_case(node, index_stack, descriptions, fixtures)
+          body_node = node.block&.body
+          description = (descriptions + [description_for(node)]).compact.reject(&:empty?).join(" ")
+          body = node.block&.slice.to_s
+          assertions = body_node ? extract_assertions(body_node) : []
+          metadata = metadata_for(node)
+          metadata[:fixtures] = fixtures.dup
+          metadata[:shared_usage] = true if shared_usage_call?(node)
+          metadata[:pending] = true if PENDING_EXAMPLE_NAMES.include?(node.name) || (node.block.nil? && !shared_usage_call?(node))
+
+          Model::TestCase.new(
+            id: "#{@path}[#{index_stack.join(":")}]",
+            description: description,
+            location: location_for(node),
+            assertions: assertions,
+            ast: node,
+            body: body,
+            metadata: metadata
+          )
+        end
+
+        def extract_assertions(node)
+          assertions = []
+          walk(node) do |child|
+            assertion = assertion_from(child)
+            assertions << assertion if assertion
+          end
+          assertions
+        end
+
+        def assertion_from(node)
+          return unless call_node?(node)
+
+          if %i[to not_to to_not].include?(node.name) && expect_receiver?(node.receiver)
+            matcher_node = node.arguments&.arguments&.first
+            return Model::Assertion.new(
+              location: location_for(node),
+              matcher: matcher_name(matcher_node),
+              subject_expr: subject_expression(node.receiver),
+              message: expectation_message(node.receiver)
+            )
+          end
+
+          return unless %i[should should_not].include?(node.name)
+
+          matcher_node = node.arguments&.arguments&.first
+          Model::Assertion.new(
+            location: location_for(node),
+            matcher: matcher_name(matcher_node),
+            subject_expr: node.receiver&.slice.to_s,
+            message: nil
+          )
+        end
+
+        def expect_receiver?(receiver)
+          call_node?(receiver) && %i[expect is_expected].include?(receiver.name)
+        end
+
+        def subject_expression(receiver)
+          return "is_expected" if receiver.name == :is_expected
+
+          receiver.arguments&.arguments&.first&.slice.to_s
+        end
+
+        def expectation_message(receiver)
+          receiver.arguments&.arguments&.[](1)&.slice&.delete_prefix("\"")&.delete_suffix("\"")
+        end
+
+        def matcher_name(node)
+          return :unknown unless node
+          return node.name if call_node?(node)
+
+          node.slice.to_sym
+        end
+
+        def walk(node, &block)
+          return unless node
+
+          yield node
+          node.each_child_node { |child| walk(child, &block) }
+        end
+
+        def metadata_for(node)
+          args = node.arguments&.arguments || []
+          args.drop(1).each_with_object({}) do |arg, metadata|
+            case arg
+            when Prism::SymbolNode
+              metadata[arg.unescaped.to_sym] = true
+            when Prism::KeywordHashNode, Prism::HashNode
+              metadata[:hash] = arg.slice
+            end
+          end
+        end
+
+        def fixture_metadata(node)
+          {
+            type: node.name,
+            name: fixture_name(node),
+            ivars: node.block&.slice.to_s.scan(/@\w+/).uniq,
+            body: node.block&.slice.to_s,
+            location: location_for(node).to_h
+          }
+        end
+
+        def fixture_name(node)
+          first = node.arguments&.arguments&.first
+          return nil unless first
+          return first.unescaped.to_s if first.respond_to?(:unescaped)
+
+          first.slice.to_s
+        end
+
+        def description_for(node)
+          first = node.arguments&.arguments&.first
+          return "" unless first
+          return first.unescaped if first.respond_to?(:unescaped)
+
+          first.slice.to_s
+        end
+
+        def group_call?(node)
+          GROUP_NAMES.include?(node.name)
+        end
+
+        def example_call?(node)
+          EXAMPLE_NAMES.include?(node.name) || PENDING_EXAMPLE_NAMES.include?(node.name)
+        end
+
+        def shared_usage_call?(node)
+          SHARED_USAGE_NAMES.include?(node.name)
+        end
+
+        def shared_definition_call?(node)
+          SHARED_GROUP_NAMES.include?(node.name)
+        end
+
+        def fixture_call?(node)
+          FIXTURE_NAMES.include?(node.name)
+        end
+
+        def call_node?(node)
+          node.is_a?(Prism::CallNode)
+        end
+
+        def location_for(node)
+          SourceLocation.new(
+            path: @path,
+            line: node.location.start_line,
+            column: node.location.start_column + 1
+          )
+        end
+      end
+
+      class CodeUnitExtractor
+        def initialize(path)
+          @path = path
+          @ast = Prism.parse_file(path).value
+        end
+
+        def code_unit
+          constants = []
+          methods = []
+          walk(@ast) do |node|
+            constants << constant_name(node) if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+            methods << node.name.to_s if node.is_a?(Prism::DefNode)
+          end
+
+          Model::CodeUnit.new(
+            path: @path,
+            constants: constants.compact.uniq,
+            methods: methods.compact.uniq
+          )
+        end
+
+        private
+
+        def constant_name(node)
+          node.constant_path.slice
+        end
+
+        def walk(node, &block)
+          return unless node
+
+          yield node
+          node.each_child_node { |child| walk(child, &block) }
+        end
+      end
+    end
+  end
+end
+
+SixthSense::FrameworkAdapter.register(:rspec, SixthSense::Adapters::RSpec)