testgenai 0.1.0

data/lib/testgenai/generator/base.rb

@@ -0,0 +1,70 @@
+require "ruby_llm"
+
+module Testgenai
+  module Generator
+    class Base
+      def initialize(config)
+        @config = config
+        configure_llm
+      end
+
+      def generate(method_info, context, feedback: nil)
+        prompt = build_prompt(method_info, context, feedback: feedback)
+        response = call_llm(prompt)
+        CodeExtractor.extract(response)
+      end
+
+      def output_path_for(method_info)
+        raise NotImplementedError, "#{self.class} must implement #output_path_for"
+      end
+
+      def injection_fallback_path_for(method_info)
+        primary = output_path_for(method_info)
+        method_part = method_info[:method].to_s.gsub(/\Aself\./, "").tr(".", "_")
+        primary.sub(/_(spec|test)\.rb\z/, "_#{method_part}_\\1.rb")
+      end
+
+      private
+
+      def configure_llm
+        return unless @config.api_key && @config.provider
+        RubyLLM.configure do |c|
+          c.public_send(:"#{@config.provider}_api_key=", @config.api_key)
+        end
+      end
+
+      def call_llm(prompt)
+        if @config.provider.nil? && @config.model.nil?
+          raise ConfigurationError,
+            "provider and model must be configured. " \
+            "Set TESTGENAI_PROVIDER and TESTGENAI_MODEL, or use --provider and --model flags."
+        end
+        if @config.provider.nil?
+          raise ConfigurationError,
+            "provider must be configured. Set TESTGENAI_PROVIDER or use --provider flag."
+        end
+        if @config.model.nil?
+          raise ConfigurationError,
+            "model must be configured. Set TESTGENAI_MODEL or use --model flag."
+        end
+        chat = RubyLLM.chat(model: @config.model)
+        chat.ask(prompt).content
+      end
+
+      def build_prompt(method_info, context, feedback: nil)
+        raise NotImplementedError, "#{self.class} must implement #build_prompt"
+      end
+
+      def conventions_preamble(context)
+        return "" unless context[:conventions]
+        "## Project conventions\n#{context[:conventions]}\n\nApply these conventions to all generated tests.\n\n"
+      end
+
+      def custom_output_path(method_info, suffix)
+        class_part = method_info[:class]&.downcase&.gsub("::", "/") || "unknown"
+        method_part = method_info[:method].to_s.gsub(/\Aself\./, "").tr(".", "_")
+        File.join(@config.output_dir, "#{class_part}_#{method_part}#{suffix}")
+      end
+    end
+  end
+end

data/lib/testgenai/generator/minitest_generator.rb

@@ -0,0 +1,52 @@
+module Testgenai
+  module Generator
+    class MinitestGenerator < Base
+      def output_path_for(method_info)
+        return custom_output_path(method_info, "_test.rb") if @config.output_dir
+
+        rel = method_info[:file].sub("#{Dir.pwd}/", "")
+        base = rel.sub(/\A(?:lib|app)\//, "").sub(/\.rb\z/, "")
+        File.join(Dir.pwd, "test", "#{base}_test.rb")
+      end
+
+      private
+
+      def build_prompt(method_info, context, feedback: nil)
+        prompt = conventions_preamble(context) + <<~PROMPT
+          You are an expert Ruby developer. Write Minitest tests for the following method.
+
+          ## Method to test
+          Class: #{method_info[:class]}
+          Method: #{method_info[:method]}
+          Location: #{method_info[:file]}:#{method_info[:start_line]}-#{method_info[:end_line]}
+
+          ## Source file
+          ```ruby
+          #{context[:target_file]}
+          ```
+        PROMPT
+
+        unless context[:dependencies].to_a.empty?
+          prompt += "\n## Dependencies\n"
+          prompt += context[:dependencies].map { |d| "- #{d}" }.join("\n")
+          prompt += "\n"
+        end
+
+        context[:example_usage].to_a.each_with_index do |usage, i|
+          prompt += "\n## Example usage #{i + 1}\n```ruby\n#{usage}\n```\n"
+        end
+
+        if context[:related_tests]
+          prompt += "\n## Existing tests (match this style)\n```ruby\n#{context[:related_tests]}\n```\n"
+        end
+
+        if feedback
+          prompt += "\n## Previous attempt failed — fix these issues\n#{feedback}\n"
+        end
+
+        prompt + "\nWrite comprehensive Minitest tests using test/setup methods and Minitest assertions. " \
+                 "Subclass Minitest::Test. Return ONLY the test code in a ```ruby code block."
+      end
+    end
+  end
+end

data/lib/testgenai/generator/rspec_generator.rb

@@ -0,0 +1,52 @@
+module Testgenai
+  module Generator
+    class RspecGenerator < Base
+      def output_path_for(method_info)
+        return custom_output_path(method_info, "_spec.rb") if @config.output_dir
+
+        rel = method_info[:file].sub("#{Dir.pwd}/", "")
+        base = rel.sub(/\A(?:lib|app)\//, "").sub(/\.rb\z/, "")
+        File.join(Dir.pwd, "spec", "#{base}_spec.rb")
+      end
+
+      private
+
+      def build_prompt(method_info, context, feedback: nil)
+        prompt = conventions_preamble(context) + <<~PROMPT
+          You are an expert Ruby developer. Write RSpec tests for the following method.
+
+          ## Method to test
+          Class: #{method_info[:class]}
+          Method: #{method_info[:method]}
+          Location: #{method_info[:file]}:#{method_info[:start_line]}-#{method_info[:end_line]}
+
+          ## Source file
+          ```ruby
+          #{context[:target_file]}
+          ```
+        PROMPT
+
+        unless context[:dependencies].to_a.empty?
+          prompt += "\n## Dependencies\n"
+          prompt += context[:dependencies].map { |d| "- #{d}" }.join("\n")
+          prompt += "\n"
+        end
+
+        context[:example_usage].to_a.each_with_index do |usage, i|
+          prompt += "\n## Example usage #{i + 1}\n```ruby\n#{usage}\n```\n"
+        end
+
+        if context[:related_tests]
+          prompt += "\n## Existing tests (match this style)\n```ruby\n#{context[:related_tests]}\n```\n"
+        end
+
+        if feedback
+          prompt += "\n## Previous attempt failed — fix these issues\n#{feedback}\n"
+        end
+
+        prompt + "\nWrite comprehensive RSpec tests using describe/context/let/before blocks. " \
+                 "Return ONLY the test code in a ```ruby code block."
+      end
+    end
+  end
+end

data/lib/testgenai/parser_support.rb

@@ -0,0 +1,9 @@
+module Testgenai
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4")
+    require "prism"
+    CurrentParser = Prism::Translation::ParserCurrent
+  else
+    require "parser/current"
+    CurrentParser = Parser::CurrentRuby
+  end
+end

data/lib/testgenai/pipeline.rb

@@ -0,0 +1,57 @@
+require "fileutils"
+
+module Testgenai
+  class Pipeline
+    MAX_ATTEMPTS = 3
+
+    def initialize(generator, validator)
+      @generator = generator
+      @validator = validator
+    end
+
+    def run(method_info, context)
+      output_path = @generator.output_path_for(method_info)
+      original_content = File.exist?(output_path) ? File.read(output_path) : nil
+      feedback = nil
+      last_generated = nil
+
+      MAX_ATTEMPTS.times do |i|
+        last_generated = @generator.generate(method_info, context, feedback: feedback)
+        combined = original_content ? "#{original_content}\n#{last_generated}" : last_generated
+        result = @validator.validate(combined, output_path)
+
+        if result[:runs] && result[:passes]
+          return {success: true, output_path: output_path, attempts: i + 1, errors: []}
+        end
+
+        feedback = build_feedback(result)
+      end
+
+      fallback_path = cleanup_after_failure(output_path, original_content, last_generated, method_info)
+      {success: false, output_path: output_path, fallback_path: fallback_path, attempts: MAX_ATTEMPTS, errors: [feedback]}
+    end
+
+    private
+
+    def cleanup_after_failure(output_path, original_content, last_generated, method_info)
+      if original_content
+        File.write(output_path, original_content)
+        fallback_path = @generator.injection_fallback_path_for(method_info)
+        FileUtils.mkdir_p(File.dirname(fallback_path))
+        File.write(fallback_path, last_generated)
+        fallback_path
+      else
+        File.delete(output_path) if File.exist?(output_path)
+        nil
+      end
+    end
+
+    def build_feedback(result)
+      if result[:runs]
+        "The following tests failed: #{result[:errors].join(", ")}"
+      else
+        "The following errors prevented the tests from running: #{result[:errors].join(", ")}"
+      end
+    end
+  end
+end

data/lib/testgenai/reporter.rb

@@ -0,0 +1,54 @@
+module Testgenai
+  class Reporter
+    def scan_results(methods, files_scanned: nil)
+      if methods.empty?
+        if files_scanned
+          puts "Scanned #{files_scanned} source file(s) — no untested methods found."
+        else
+          puts "No untested methods found."
+        end
+        return
+      end
+      puts "Found #{methods.size} untested method(s):"
+      methods.each do |m|
+        puts "  #{m[:class]}##{m[:method]}  #{m[:file]}:#{m[:start_line]}-#{m[:end_line]}"
+      end
+    end
+
+    def context_result(method_info, context)
+      puts "=== Context for #{method_info[:class]}##{method_info[:method]} ==="
+      puts "  File: #{method_info[:file]}"
+      unless context[:dependencies].to_a.empty?
+        puts "  Dependencies:"
+        context[:dependencies].each { |d| puts "    #{d}" }
+      end
+      unless context[:example_usage].to_a.empty?
+        puts "  Example usages found: #{context[:example_usage].size}"
+      end
+      puts "  Related tests: #{context[:related_tests] ? "yes" : "none"}"
+      puts
+    end
+
+    def success(method_info, result)
+      puts "  ✓ #{method_info[:class]}##{method_info[:method]} → #{result[:output_path]} (#{result[:attempts]} attempt(s))"
+    end
+
+    def failure(method_info, result)
+      puts "  ✗ #{method_info[:class]}##{method_info[:method]} failed after #{result[:attempts]} attempt(s)"
+      puts "    → Generated tests saved to #{result[:fallback_path]} for manual review" if result[:fallback_path]
+    end
+
+    def skipped(method_info, error)
+      puts "  - #{method_info[:class]}##{method_info[:method]} skipped: #{error.message}"
+    end
+
+    def summary(results)
+      puts "\nSummary: #{results[:successful].size} generated, " \
+           "#{results[:failed].size} failed, #{results[:skipped].size} skipped"
+    end
+
+    def fatal_error(error)
+      puts "Fatal error: #{error.message}"
+    end
+  end
+end

data/lib/testgenai/scanner/base.rb

@@ -0,0 +1,52 @@
+require_relative "../parser_support"
+
+module Testgenai
+  module Scanner
+    class Base
+      attr_reader :files_scanned
+
+      def scan
+        raise NotImplementedError, "#{self.class} must implement #scan"
+      end
+
+      private
+
+      def collect_methods(node, file, class_name:)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :class, :module
+          current = [class_name, const_name(node.children[0])].compact.join("::")
+          node.children.flat_map { |c| collect_methods(c, file, class_name: current) }
+        when :def
+          [method_descriptor(node, file, class_name, node.children[0].to_s)]
+        when :defs
+          [method_descriptor(node, file, class_name, "self.#{node.children[1]}")]
+        else
+          node.children.flat_map { |c| collect_methods(c, file, class_name: class_name) }
+        end
+      end
+
+      def method_descriptor(node, file, class_name, method_name)
+        {
+          file: file,
+          class: class_name,
+          method: method_name,
+          start_line: node.loc.line,
+          end_line: node.loc.end.line
+        }
+      end
+
+      def const_name(node)
+        return nil unless node.is_a?(Parser::AST::Node) && node.type == :const
+        parts = []
+        current = node
+        while current.is_a?(Parser::AST::Node) && current.type == :const
+          parts.unshift(current.children[1].to_s)
+          current = current.children[0]
+        end
+        parts.join("::")
+      end
+    end
+  end
+end

data/lib/testgenai/scanner/file_existence_scanner.rb

@@ -0,0 +1,45 @@
+module Testgenai
+  module Scanner
+    class FileExistenceScanner < Base
+      def initialize(root: Dir.pwd)
+        @root = root
+      end
+
+      def scan
+        files = source_files
+        @files_scanned = files.size
+        files.reject { |f| test_exists?(f) }.flat_map { |f| extract_methods(f) }
+      end
+
+      private
+
+      def source_files
+        %w[lib app].flat_map do |dir|
+          full = File.join(@root, dir)
+          Dir.exist?(full) ? Dir.glob(File.join(full, "**", "*.rb")) : []
+        end
+      end
+
+      def test_exists?(source_file)
+        rel = relative(source_file)
+        base = rel.sub(/\A(?:lib|app)\//, "").sub(/\.rb\z/, "")
+        File.exist?(File.join(@root, "spec", "#{base}_spec.rb")) ||
+          File.exist?(File.join(@root, "test", "#{base}_test.rb"))
+      end
+
+      def relative(file)
+        file.sub("#{@root}/", "")
+      end
+
+      def extract_methods(file)
+        source = File.read(file)
+        ast = CurrentParser.parse(source)
+        return [] unless ast
+        collect_methods(ast, file, class_name: nil)
+      rescue Parser::SyntaxError, EncodingError => e
+        warn "Warning: could not parse #{file}: #{e.message}"
+        []
+      end
+    end
+  end
+end

data/lib/testgenai/scanner/simplecov_scanner.rb

@@ -0,0 +1,69 @@
+require "json"
+
+module Testgenai
+  module Scanner
+    class SimplecovScanner < Base
+      RESULTSET_PATH = "coverage/.resultset.json"
+
+      def initialize(root: Dir.pwd)
+        @root = root
+      end
+
+      def scan
+        resultset_path = File.join(@root, RESULTSET_PATH)
+        unless File.exist?(resultset_path)
+          warn "Warning: #{RESULTSET_PATH} not found"
+          return []
+        end
+        coverage = merged_coverage
+        source_coverage = coverage.reject { |file, _| test_file?(file) || !File.exist?(file) }
+        @files_scanned = source_coverage.size
+        source_coverage.flat_map { |file, lines| extract_untested_methods(file, lines) }
+      end
+
+      private
+
+      def merged_coverage
+        resultset = JSON.parse(File.read(File.join(@root, RESULTSET_PATH)))
+        result = {}
+        resultset.each_value do |runner_data|
+          (runner_data["coverage"] || {}).each do |file, data|
+            lines = data["lines"]
+            result[file] = merge_lines(result[file], lines)
+          end
+        end
+        result
+      end
+
+      def merge_lines(existing, new_lines)
+        return new_lines unless existing
+        existing.zip(new_lines).map do |a, b|
+          next nil if a.nil? && b.nil?
+          (a || 0) + (b || 0)
+        end
+      end
+
+      def test_file?(file)
+        relative = file.sub("#{@root}/", "")
+        relative.start_with?("spec/", "test/")
+      end
+
+      def extract_untested_methods(file, coverage_lines)
+        source = File.read(file)
+        ast = CurrentParser.parse(source)
+        return [] unless ast
+        methods = collect_methods(ast, file, class_name: nil)
+        methods.select { |m| untested?(coverage_lines, m[:start_line], m[:end_line]) }
+      rescue Parser::SyntaxError, EncodingError => e
+        warn "Warning: could not parse #{file}: #{e.message}"
+        []
+      end
+
+      def untested?(coverage_lines, start_line, end_line)
+        method_lines = coverage_lines[(start_line - 1)..(end_line - 1)] || []
+        executable = method_lines.compact
+        executable.any? && executable.all?(&:zero?)
+      end
+    end
+  end
+end

data/lib/testgenai/validator/base.rb

@@ -0,0 +1,22 @@
+require "fileutils"
+
+module Testgenai
+  module Validator
+    class Base
+      def validate(test_code, output_path)
+        raise NotImplementedError, "#{self.class} must implement #validate"
+      end
+
+      private
+
+      def write_test_file(test_code, output_path)
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.write(output_path, test_code)
+      end
+
+      def cleanup(output_path)
+        File.delete(output_path) if File.exist?(output_path)
+      end
+    end
+  end
+end

data/lib/testgenai/validator/minitest_validator.rb

@@ -0,0 +1,52 @@
+require "shellwords"
+
+module Testgenai
+  module Validator
+    class MinitestValidator < Base
+      def validate(test_code, output_path)
+        write_test_file(test_code, output_path)
+        output, exit_status = run_minitest(output_path)
+        parse_result(output, exit_status, output_path)
+      end
+
+      private
+
+      def run_minitest(path)
+        output = `bundle exec ruby -Ilib -Itest #{Shellwords.escape(path)} 2>&1`
+        [output, $?.exitstatus]
+      end
+
+      def parse_result(output, exit_status, output_path)
+        if load_error?(output)
+          errors = extract_load_errors(output)
+          cleanup(output_path)
+          {valid: false, runs: false, passes: false, errors: errors}
+        elsif exit_status == 0
+          {valid: true, runs: true, passes: true, errors: []}
+        else
+          errors = extract_failures(output)
+          {valid: true, runs: true, passes: false, errors: errors}
+        end
+      end
+
+      def load_error?(output)
+        output.match?(/LoadError|SyntaxError|cannot load such file/)
+      end
+
+      def extract_load_errors(output)
+        output.lines
+          .select { |l| l.match?(/LoadError|SyntaxError|cannot load/) }
+          .map(&:strip)
+          .first(3)
+      end
+
+      def extract_failures(output)
+        output.lines
+          .select { |l| l.match?(/Failure:|Error:|\d+\) /) }
+          .map(&:strip)
+          .reject(&:empty?)
+          .first(5)
+      end
+    end
+  end
+end

data/lib/testgenai/validator/rspec_validator.rb

@@ -0,0 +1,60 @@
+require "shellwords"
+
+module Testgenai
+  module Validator
+    class RspecValidator < Base
+      def validate(test_code, output_path)
+        write_test_file(test_code, output_path)
+        output, exit_status = run_rspec(output_path)
+        parse_result(output, exit_status, output_path)
+      end
+
+      private
+
+      def run_rspec(path)
+        output = `bundle exec rspec #{Shellwords.escape(path)} --format documentation 2>&1`
+        [output, $?.exitstatus]
+      end
+
+      def parse_result(output, exit_status, output_path)
+        if load_error?(output)
+          errors = extract_load_errors(output)
+          cleanup(output_path)
+          {valid: false, runs: false, passes: false, errors: errors}
+        elsif exit_status == 0
+          {valid: true, runs: true, passes: true, errors: []}
+        else
+          errors = extract_failures(output)
+          {valid: true, runs: true, passes: false, errors: errors}
+        end
+      end
+
+      def load_error?(output)
+        output.match?(/LoadError|SyntaxError|NameError.*uninitialized constant|An error occurred while loading/)
+      end
+
+      def extract_load_errors(output)
+        lines = output.lines
+        lines.select { |l| l.match?(/LoadError|SyntaxError|NameError|cannot load/) }
+          .map(&:strip)
+          .first(3)
+      end
+
+      def extract_failures(output)
+        failures = []
+        in_failure = false
+        output.each_line do |line|
+          if line.match?(/^\s+\d+\)/)
+            in_failure = true
+            failures << line.strip
+          elsif in_failure && line.match?(/^\s+(Failure|Error):/)
+            failures.last << " #{line.strip}"
+          elsif in_failure && line.strip.empty?
+            in_failure = false
+          end
+        end
+        failures.first(5)
+      end
+    end
+  end
+end

data/lib/testgenai/version.rb

@@ -0,0 +1,3 @@
+module Testgenai
+  VERSION = "0.1.0"
+end

data/lib/testgenai.rb

@@ -0,0 +1,24 @@
+require "testgenai/version"
+require "testgenai/configuration"
+require "testgenai/code_extractor"
+require "testgenai/context_builder"
+require "testgenai/reporter"
+require "testgenai/pipeline"
+require "testgenai/batch_pipeline"
+require "testgenai/scanner/base"
+require "testgenai/scanner/simplecov_scanner"
+require "testgenai/scanner/file_existence_scanner"
+require "testgenai/generator/base"
+require "testgenai/generator/rspec_generator"
+require "testgenai/generator/minitest_generator"
+require "testgenai/validator/base"
+require "testgenai/validator/rspec_validator"
+require "testgenai/validator/minitest_validator"
+require "testgenai/conventions_extractor"
+require "testgenai/conventions_synthesizer"
+require "testgenai/cli"
+
+module Testgenai
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+end

data/testgenai.gemspec

@@ -0,0 +1,22 @@
+require_relative "lib/testgenai/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "testgenai"
+  spec.version = Testgenai::VERSION
+  spec.authors = ["Tracy Atteberry"]
+  spec.email = ["tracy@magicbydesign.com"]
+  spec.summary = "Find untested Ruby code and generate tests with AI"
+  spec.homepage = "https://github.com/grymoire7/testgenai"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.files = Dir["lib/**/*.rb", "bin/**/*", "*.md", "*.gemspec", "Gemfile"].reject { |f| f.match?(/\A(CLAUDE|AGENTS)\.md\z/) }
+  spec.bindir = "bin"
+  spec.executables = ["testgenai"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 1.3"
+  spec.add_dependency "ruby_llm", "~> 1.14"
+  spec.add_dependency "parser", "~> 3.3"
+  spec.add_dependency "prism", ">= 1.4.0"
+end