spec_ai 0.1.0

data/lib/spec_ai/tools/read_schema_table.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rcrewai"
+
+module SpecAi
+  module Tools
+    class ReadSchemaTable < RCrewAI::Tools::Base
+      tool_name "read_schema_table"
+      description "Read the create_table excerpt for a table from db/schema.rb"
+      param :table_name, type: :string, required: true, description: "Database table name, e.g. users"
+
+      def initialize(sandbox: SpecAi::Sandbox.new)
+        @sandbox = sandbox
+        super()
+      end
+
+      def execute(table_name:)
+        dummy = Struct.new(:table_name, :class_name, :factory_name).new(table_name, nil, nil)
+        result = Analyzers::Schema.new(dummy, sandbox: @sandbox).analyze
+        result[:excerpt] || "No schema excerpt found for #{table_name}"
+      rescue SpecAi::Error => error
+        "ERROR: #{error.message}"
+      end
+    end
+  end
+end

data/lib/spec_ai/ui.rb

@@ -0,0 +1,469 @@
+# frozen_string_literal: true
+
+module SpecAi
+  class UI
+    CHECK = "✓"
+    WARN = "⚠"
+    EMPTY = "·"
+    FAIL = "✗"
+    SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+    def initialize(io: $stdout, verbose: SpecAi.configuration.verbose, color: nil)
+      @io = io
+      @verbose = verbose
+      @color = color.nil? ? default_color? : color
+    end
+
+    def header
+      cfg = SpecAi.configuration
+      say "#{magenta('✨')}  #{paint('1;95', 'Spec AI')}"
+      say "    #{dim("v#{VERSION}")}  #{dim('·')}  #{cyan("#{cfg.provider} / #{cfg.model}")}"
+      say ""
+    end
+
+    def analyzing(name)
+      say "#{cyan('🔍')}  #{bold('Analyze')}  #{bold(name)}"
+      say ""
+    end
+
+    def context_collected(snapshot)
+      status_line(true, "model", snapshot.target.model_path)
+
+      if snapshot.schema[:excerpt]
+        status_line(true, "schema", snapshot.schema[:table] || snapshot.target.table_name)
+      else
+        status_line(false, "schema", "none found")
+      end
+
+      associations = Array(snapshot.model[:associations])
+      if associations.any?
+        names = associations.map { |item| hash_value(item, :name) }.compact.join(", ")
+        status_line(true, "associations", names)
+      else
+        status_line(:empty, "associations", "none")
+      end
+
+      if snapshot.has_factory?
+        status_line(true, "factory", ":#{snapshot.factories[:name]}")
+      else
+        status_line(false, "factory", "none found")
+      end
+
+      if snapshot.existing_spec[:present]
+        status_line(true, "existing spec", snapshot.existing_spec[:path])
+      else
+        status_line(false, "existing spec", "will create #{snapshot.target.spec_path}")
+      end
+
+      if snapshot.routes[:excerpt]
+        status_line(true, "routes", first_line(snapshot.routes[:excerpt]))
+      else
+        status_line(:empty, "routes", "none")
+      end
+      say ""
+    end
+
+    def spin_planning
+      cfg = SpecAi.configuration
+      spin("Planning tests", hint: "#{cfg.provider} / #{cfg.model}") { yield }
+    end
+
+    def spin_repairing(attempt, max)
+      spin("Repairing spec", hint: "#{attempt} / #{max}") { yield }
+    end
+
+    def spin_running
+      spin("Running RSpec") { yield }
+    end
+
+    def spin(message, hint: nil)
+      started = monotonic
+      label = spin_label(message, hint)
+
+      unless tty?
+        say "#{cyan('⠋')}  #{label}..."
+        result = yield
+        @last_elapsed = monotonic - started
+        say ""
+        return result
+      end
+
+      stop = false
+      index = 0
+      thread = Thread.new do
+        until stop
+          elapsed = format_elapsed(monotonic - started)
+          @io.print "\r\e[2K#{cyan(SPINNER[index % SPINNER.length])}  #{label}  #{dim(elapsed)}"
+          @io.flush
+          index += 1
+          sleep 0.08
+        end
+      end
+
+      yield
+    ensure
+      @last_elapsed = monotonic - started if started
+      stop = true
+      thread&.join
+      clear_line if thread && tty?
+    end
+
+    def llm_fallback(notice, preview: nil)
+      say "  #{yellow('⚠')}  #{notice}"
+      say "      #{dim(preview)}" if preview && !preview.to_s.empty?
+      say "      #{dim('Using a plan from the model schema and validations instead.')}"
+      say ""
+    end
+
+    def generating(plan)
+      count = plan.scenarios.size
+      categories = plan.scenarios.map(&:category).uniq.map { |item| item.to_s.tr("_", " ") }
+      say "  #{cyan('🧠')}  Planned #{bold(count.to_s)} #{plural(count, 'scenario')}#{elapsed_suffix}"
+      say "      #{dim(categories.join('  ·  '))}" unless categories.empty?
+      say ""
+    end
+
+    def writing(path)
+      say "  #{cyan('📝')}  Wrote #{cyan(path.to_s)}"
+      say ""
+    end
+
+    def merging(path)
+      say "  #{cyan('📝')}  Added examples to #{cyan(path.to_s)}"
+      say "      #{dim('Existing examples were kept. Pass --force to replace the spec.')}"
+      say ""
+    end
+
+    def dropped_unfounded(names)
+      list = Array(names)
+      return if list.empty?
+
+      say "  #{yellow('⚠')}  Dropped #{bold(list.size.to_s)} #{plural(list.size, 'example')} the model does not enforce"
+      list.first(8).each { |name| say "      #{dim(name)}" }
+      say ""
+    end
+
+    def setup_actions(actions)
+      return if Array(actions).empty?
+
+      Array(actions).each do |action|
+        case action.kind
+        when :created
+          say "  #{cyan('📦')}  Created #{cyan(action.path)}"
+          say "      #{dim(action.message)}" if action.message
+        when :updated
+          say "  #{cyan('📦')}  Updated #{cyan(action.path)}"
+          say "      #{dim(action.message)}" if action.message
+        else
+          say "  #{yellow('⚠')}  #{action.message}"
+        end
+      end
+      say ""
+    end
+
+    def running
+      say "  #{cyan('🧪')}  #{bold('Run')}  RSpec"
+      say ""
+    end
+
+    def rspec_result(result)
+      report = result.report
+      mark = result.passed? ? green(report.summary) : red(report.summary)
+      say "  #{result.passed? ? '🧪' : '❌'}  #{mark}#{elapsed_suffix}"
+      print_failures(report) if result.failed?
+      say ""
+    end
+
+    def repairing(attempt, max)
+      say "  #{yellow('🔧')}  Repair  #{attempt}/#{max}"
+      say ""
+    end
+
+    def completed(success, result: nil)
+      if success
+        say "  #{green('✅')}  #{paint('1;92', 'Done')}"
+        return
+      end
+
+      count = result&.report&.failures&.size
+      label = count&.positive? ? "Finished with #{count} #{plural(count, 'failure')}" : "Finished with failures"
+      say "  #{red('❌')}  #{paint('1;91', label)}"
+      if result
+        say "      Spec:    #{result.spec_path}"
+        say "      Re-run:  bundle exec rspec #{result.spec_path}"
+        say "      Repair:  bundle exec spec-ai fix #{result.spec_path}"
+      end
+    end
+
+    def already_passing(path)
+      say "  #{green('✅')}  #{path} is already passing"
+    end
+
+    def snapshot(snapshot)
+      section("Target", "#{bold(snapshot.target.class_name)}  #{dim(snapshot.target.model_path)}")
+      section("Table", snapshot.model[:table_name].to_s)
+      say ""
+
+      heading("Source")
+      say indent(dim(snapshot.model[:source].to_s.rstrip))
+      say ""
+
+      heading("Validations")
+      say format_validations(snapshot.model[:validations])
+      say ""
+
+      heading("Associations")
+      say format_associations(snapshot.model[:associations])
+      say ""
+
+      scopes = Array(snapshot.model[:scopes])
+      section("Scopes", scopes.any? ? scopes.join(", ") : dim("none"))
+      enums = Array(snapshot.model[:enums])
+      section("Enums", enums.any? ? enums.join(", ") : dim("none"))
+      say ""
+
+      if snapshot.schema[:excerpt]
+        heading("Schema", snapshot.schema[:path].to_s)
+        say indent(dim(snapshot.schema[:excerpt].to_s.rstrip))
+        say ""
+      end
+
+      heading("Factory")
+      if snapshot.has_factory?
+        say "  #{cyan(":#{snapshot.factories[:name]}")}  #{dim(snapshot.factories[:path].to_s)}"
+        say indent(dim(snapshot.factories[:excerpt].to_s.rstrip))
+      else
+        say "  #{dim('none found')}"
+      end
+      say ""
+
+      heading("Existing spec")
+      if snapshot.existing_spec[:present]
+        say "  #{snapshot.existing_spec[:path]}"
+      else
+        say "  #{dim("none — will create #{snapshot.target.spec_path}")}"
+      end
+      say ""
+
+      if snapshot.routes[:excerpt]
+        heading("Routes")
+        say indent(snapshot.routes[:excerpt].to_s.rstrip)
+        say ""
+      end
+
+      Array(snapshot.related).each do |item|
+        heading("Related", "#{item[:class_name]}  #{item[:path]}")
+        say indent(dim(item[:excerpt].to_s.rstrip))
+        say ""
+      end
+    end
+
+    def roadmap(command, version)
+      say "#{yellow('🚧')}  spec-ai #{command} is planned for #{bold(version)}. This MVP supports generate, fix, and analyze."
+    end
+
+    def skip_repair(message)
+      say "  #{yellow('⚠')}  Repair skipped"
+      say "      #{message}"
+      say ""
+    end
+
+    def error(message)
+      lines = message.to_s.strip.lines.map(&:rstrip)
+      say "  #{red('❌')}  #{paint('1;91', lines.first)}"
+      lines.drop(1).each do |line|
+        say(line.empty? ? "" : "      #{line}")
+      end
+      say ""
+    end
+
+    def unexpected_error(error)
+      say "  #{red('❌')}  #{paint('1;91', 'Unexpected error')}  #{error.class}"
+      say "      #{explain_exception(error)}"
+      say "      #{error.message}" unless explain_exception(error) == error.message
+      say ""
+    end
+
+    private
+
+    def spin_label(message, hint)
+      return message unless hint
+
+      "#{message}  #{dim('·')}  #{dim(hint)}"
+    end
+
+    def status_line(state, label, detail = nil)
+      mark = case state
+             when true then green(CHECK)
+             when false then yellow(WARN)
+             else dim(EMPTY)
+             end
+      line = "    #{mark}  #{label.ljust(14)}"
+      line += "  #{dim(detail)}" if detail
+      say line
+    end
+
+    def section(title, value)
+      say "  #{cyan(title.ljust(12))}  #{value}"
+    end
+
+    def heading(title, detail = nil)
+      line = "  #{paint('1;96', title)}"
+      line += "  #{dim(detail)}" if detail
+      say line
+    end
+
+    def format_validations(items)
+      return "    #{dim('none')}" if items.nil? || items.empty?
+
+      items.map do |item|
+        attrs = Array(hash_value(item, :attributes)).join(", ")
+        validators = Array(hash_value(item, :validators)).join(", ")
+        "    #{bold(attrs.ljust(16))}  #{dim(validators)}"
+      end.join("\n")
+    end
+
+    def format_associations(items)
+      return "    #{dim('none')}" if items.nil? || items.empty?
+
+      items.map do |item|
+        name = hash_value(item, :name)
+        macro = hash_value(item, :macro)
+        extras = []
+        class_name = hash_value(item, :class_name)
+        extras << class_name if class_name && class_name.to_s != Inflector.camelize(Inflector.singularize(name.to_s))
+        opts = hash_value(item, :options) || {}
+        opts = opts.transform_keys(&:to_sym) if opts.is_a?(Hash)
+        extras << "optional" if opts[:optional]
+        extras << "dependent: #{opts[:dependent]}" if opts[:dependent]
+        suffix = extras.any? ? "  #{dim(extras.join(' · '))}" : ""
+        "    #{cyan(macro)} :#{name}#{suffix}"
+      end.join("\n")
+    end
+
+    def hash_value(item, key)
+      return item unless item.is_a?(Hash)
+
+      item[key] || item[key.to_s]
+    end
+
+    def first_line(text)
+      text.to_s.lines.map(&:strip).reject(&:empty?).first
+    end
+
+    def indent(text)
+      text.to_s.gsub(/^/, "    ")
+    end
+
+    def plural(count, word)
+      count == 1 ? word : "#{word}s"
+    end
+
+    def elapsed_suffix
+      return "" unless @last_elapsed
+
+      "  #{dim(format_elapsed(@last_elapsed))}"
+    ensure
+      @last_elapsed = nil
+    end
+
+    def format_elapsed(seconds)
+      seconds = seconds.to_f
+      return format("%.1fs", seconds) if seconds < 60
+
+      minutes = (seconds / 60).floor
+      rest = (seconds % 60).round
+      "#{minutes}m #{rest}s"
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def clear_line
+      @io.print "\r\e[2K"
+      @io.flush
+    end
+
+    def say(message)
+      @io.puts(message)
+    end
+
+    def tty?
+      @io.respond_to?(:tty?) && @io.tty?
+    end
+
+    def default_color?
+      tty? && ENV["NO_COLOR"].to_s.empty? && ENV["TERM"] != "dumb"
+    end
+
+    def bold(text)
+      paint("1", text)
+    end
+
+    def dim(text)
+      paint("90", text)
+    end
+
+    def green(text)
+      paint("92", text)
+    end
+
+    def yellow(text)
+      paint("93", text)
+    end
+
+    def red(text)
+      paint("91", text)
+    end
+
+    def cyan(text)
+      paint("96", text)
+    end
+
+    def magenta(text)
+      paint("95", text)
+    end
+
+    def print_failures(report)
+      listed = @verbose ? report.failures : report.failures.first(8)
+      listed.each do |failure|
+        say "      #{bold(short_example(failure.example))}"
+        say "      #{dim(failure.detail)}" if failure.detail && !failure.detail.empty?
+        say "      #{yellow(failure.hint)}" if failure.hint
+        say ""
+      end
+      extra = report.failures.size - listed.size
+      say "      #{dim("and #{extra} more. Pass --verbose to see the full RSpec output.")}" if extra.positive?
+      say indent(dim(report.result.output.to_s.strip)) if @verbose
+    end
+
+    def short_example(example)
+      example.to_s.sub(/\A\S+\s+/, "")
+    end
+
+    def explain_exception(error)
+      case error
+      when Errno::ECONNREFUSED
+        "Could not reach the LLM server. If you use Ollama, start it with `ollama serve`."
+      when SocketError
+        "Network lookup failed. Check your connection and the provider in config/spec_ai.yml."
+      else
+        name = error.class.name
+        if name.match?(/Timeout/i)
+          "The LLM request timed out. Retry, or switch provider/model in config/spec_ai.yml."
+        elsif name.match?(/Unauthorized| Faraday::Unauthorized/i) || error.message.match?(/\b401\b/)
+          "The LLM provider rejected the request. Check the API key for this provider."
+        else
+          error.message.to_s
+        end
+      end
+    end
+
+    def paint(code, text)
+      return text.to_s unless @color
+
+      "\e[#{code}m#{text}\e[0m"
+    end
+  end
+end

data/lib/spec_ai/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SpecAi
+  VERSION = "0.1.0"
+end

data/lib/spec_ai.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+require "pathname"
+require "zeitwerk"
+require_relative "spec_ai/version"
+
+module SpecAi
+  class Error < StandardError; end
+  class TargetNotFound < Error; end
+  class ConfigurationError < Error; end
+  class InvalidPlan < Error; end
+  class PathNotAllowed < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def boot_rails!(root = configuration.app_root)
+      return if rails_booted?
+
+      env = File.join(root, "config", "environment.rb")
+      return unless File.file?(env)
+
+      require env
+    rescue LoadError, StandardError
+      nil
+    end
+
+    def rails_booted?
+      defined?(::Rails) && ::Rails.respond_to?(:application) && !::Rails.application.nil?
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "cli" => "CLI",
+  "ui" => "UI"
+)
+loader.ignore("#{__dir__}/spec_ai/version.rb")
+loader.ignore("#{__dir__}/generators")
+loader.ignore("#{__dir__}/tasks")
+loader.setup
+
+require "spec_ai/railtie" if defined?(Rails::Railtie)

data/lib/tasks/spec_ai.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :spec_ai do
+  desc "Generate RSpec tests for a Rails model (e.g. rails spec_ai:generate[User])"
+  task :generate, [:target] => :environment do |_task, args|
+    abort "Usage: rails spec_ai:generate[User]" if args[:target].to_s.strip.empty?
+
+    SpecAi.configuration.app_root = Rails.root.to_s if defined?(Rails) && Rails.respond_to?(:root)
+    SpecAi::CLI.start(["generate", args[:target]])
+  end
+
+  desc "Repair a failing spec with Spec AI"
+  task :fix, [:path] => :environment do |_task, args|
+    abort "Usage: rails spec_ai:fix[spec/models/user_spec.rb]" if args[:path].to_s.strip.empty?
+
+    SpecAi.configuration.app_root = Rails.root.to_s if defined?(Rails) && Rails.respond_to?(:root)
+    SpecAi::CLI.start(["fix", args[:path]])
+  end
+end