ai_safety_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f0ee60e8a0819932e47216f981755ed81ff9a18f4ca48c58d5a132490c40bcf
+  data.tar.gz: 22c71785b1a1b4b09ec9540636b528d30dc4786429854c4ee18d1400ba9d2cee
+SHA512:
+  metadata.gz: 640ec5d1dd9d82d7b9832bacc1631d623b7a9b6121fb670f6c809bbcc1069edc75cc0c395a1deb3d78aa73f50620629d83bde6ec20be00168833317a797cc647
+  data.tar.gz: 78c0e454f76cf880aff2eaca85aa2c59b480945cbd763e6ce94e6c92468d64ced5f79ee9f795d96cebb14b373ef5a0de25b9f31cce3ce6122c4d0d7142b6e896

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,104 @@
+# ai_safety_rails
+
+A Ruby gem that adds **(1) a guardrails/safety layer** around LLM calls and **(2) an evaluation/regression harness** for prompts and models. Provider-agnostic: works with [RubyLLM](https://github.com/crmne/ruby_llm) or any client that exposes a simple request/response interface.
+
+## Features
+
+### Part 1 – Guardrails (middleware-style)
+
+- **Input guardrails**
+  - **PII redaction:** mask or strip emails, phone numbers, SSN-like patterns (configurable regexes).
+  - Optional prompt-injection heuristics (e.g. "ignore previous instructions" blocklist).
+  - Optional max input length and rate limiting (in-memory or Redis).
+- **Output guardrails**
+  - **Schema validation:** validate LLM output against a JSON schema (via `json_schemer`).
+  - Optional blocklist/allowlist for topics or sensitive keywords.
+- **Integration:** Wraps any callable client: `input guardrails → call client → output guardrails → return`. Sync (and optionally async) support.
+
+### Part 2 – Evaluation harness
+
+- **Test sets:** Define evaluation sets (YAML/JSON) with input + expected output or criteria (e.g. "must include key X", "valid JSON", "no PII").
+- **Runner:** Runs all examples, records latency, token usage (if exposed), pass/fail per criterion.
+- **Regression:** Save baseline to JSON; compare runs and exit non-zero if metrics regress beyond a threshold.
+- **CI-friendly:** CLI and Rake tasks (e.g. `bundle exec ai_safety_rails eval path/to/evals`).
+
+### Part 3 – Rails-friendly (optional)
+
+- **Generators:** `rails g guardrail pii_redaction`, `rails g eval_set support_tickets`.
+- **Config:** Optional `config/guardrails.yml` and eval sets under `config/llm_evals/`.
+- **Audit logging:** Optional hook to log when a guardrail fired (Rails logger or audit table).
+
+## Installation
+
+```ruby
+# Gemfile
+gem "ai_safety_rails"
+```
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Guardrails middleware
+
+Wrap any LLM client (callable) with guardrails:
+
+```ruby
+client = ->(input) { YourLLMClient.chat(input) }
+
+guarded = AiSafetyRails::Guardrails::Middleware.wrap(client,
+  input_guardrails: [
+    AiSafetyRails::Guardrails::Input::PiiRedactor.new
+  ],
+  output_guardrails: [
+    AiSafetyRails::Guardrails::Output::SchemaValidator.new(schema: my_json_schema_hash)
+  ]
+)
+
+response = guarded.call("Hello, my email is user@example.com")
+# Input is redacted before calling the client; output is validated before returning.
+```
+
+### Evaluation harness
+
+1. Define an eval set (e.g. `config/llm_evals/support_tickets.yaml`):
+
+```yaml
+name: support_tickets
+description: Support ticket classification
+examples:
+  - id: 1
+    input: "Customer cannot login"
+    expectations:
+      - type: valid_json
+      - type: has_key
+        key: category
+```
+
+2. Run evals via CLI or Rake:
+
+```bash
+bundle exec ai_safety_rails eval config/llm_evals
+```
+
+### Rails
+
+When Rails is present, generators and config are available:
+
+```bash
+rails g ai_safety_rails:guardrail pii_redaction
+rails g ai_safety_rails:eval_set support_tickets
+```
+
+Optional `config/guardrails.yml` is loaded automatically.
+
+## Development
+
+- **Tests:** `bundle exec rake test` (minitest)
+- **Eval CLI:** `bundle exec exe/ai_safety_rails eval path/to/evals`
+
+## License
+
+MIT.

data/exe/ai_safety_rails

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "json"
+require "ai_safety_rails"
+
+def main
+  cmd = ARGV[0]
+  case cmd
+  when "eval"
+    run_eval(ARGV[1] || "config/llm_evals")
+  when "version"
+    puts "ai_safety_rails #{AiSafetyRails::VERSION}"
+  else
+    puts "Usage: ai_safety_rails eval <path>   # run evaluation sets"
+    puts "       ai_safety_rails version      # show version"
+    exit(1)
+  end
+end
+
+def run_eval(path)
+  unless File.exist?(path)
+    warn "Path does not exist: #{path}"
+    exit(1)
+  end
+
+  # Default client: echo back input (for testing without an LLM)
+  client = ->(input) { input.is_a?(String) ? input : input.to_s }
+  runner = AiSafetyRails::Evaluation::Runner.new(client: client)
+  results = runner.run(path)
+  puts JSON.pretty_generate(results)
+
+  # Exit 1 if any run has failures
+  runs = results["runs"] || []
+  all_passed = runs.all? do |run|
+    (run["summary"] || {})["failed"].to_i.zero?
+  end
+  exit(all_passed ? 0 : 1)
+end
+
+main

data/lib/ai_safety_rails/evaluation/runner.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AiSafetyRails
+  module Evaluation
+    # Runs an evaluation set against a callable client and reports pass/fail and latency.
+    class Runner
+      def initialize(client:, loader: SetLoader.new)
+        @client = client
+        @loader = loader
+      end
+
+      def run(path)
+        sets = path.is_a?(Array) ? path : @loader.load(path)
+        sets = [sets] unless sets.is_a?(Array)
+        results = sets.map { |set| run_set(set) }
+        flatten_results(results)
+      end
+
+      def run_set(set)
+        examples = set["examples"] || []
+        name = set["name"] || "unnamed"
+        results = []
+        examples.each do |ex|
+          result = run_example(ex, set)
+          results << result
+        end
+        {
+          "set" => name,
+          "description" => set["description"],
+          "results" => results,
+          "summary" => summarize(results)
+        }
+      end
+
+      private
+
+      def run_example(example, _set)
+        input = example["input"]
+        expectations = example["expectations"] || []
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          output = @client.call(input)
+        rescue StandardError => e
+          output = nil
+          error = e.message
+        end
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+        criterion_results = expectations.map do |exp|
+          check_expectation(exp, output, error: error)
+        end
+
+        {
+          "id" => example["id"],
+          "latency_seconds" => elapsed.round(4),
+          "passed" => criterion_results.all? { |r| r["passed"] },
+          "criteria" => criterion_results,
+          "error" => error
+        }
+      end
+
+      def check_expectation(exp, output, error: nil)
+        type = exp["type"] || "custom"
+        passed = false
+        message = nil
+
+        if error
+          passed = false
+          message = error
+        else
+          case type
+          when "valid_json"
+            passed = valid_json?(output)
+            message = passed ? "Valid JSON" : "Invalid or missing JSON"
+          when "has_key"
+            data = parse_json_safe(output)
+            key = exp["key"]
+            passed = data.is_a?(Hash) && data.key?(key)
+            message = passed ? "Has key #{key}" : "Missing key #{key}"
+          when "not_contains_pii"
+            passed = !contains_pii?(output.to_s)
+            message = passed ? "No PII detected" : "PII may be present"
+          else
+            passed = false
+            message = "Unknown expectation type: #{type}"
+          end
+        end
+
+        { "type" => type, "passed" => passed, "message" => message }
+      end
+
+      def valid_json?(output)
+        parse_json_safe(output) != nil
+      end
+
+      def parse_json_safe(output)
+        return output if output.is_a?(Hash) || output.is_a?(Array)
+        JSON.parse(output.to_s)
+      rescue JSON::ParserError, TypeError
+        nil
+      end
+
+      def contains_pii?(text)
+        AiSafetyRails::Guardrails::Input::PiiRedactor::DEFAULT_PATTERNS.values.any? { |re| re.match?(text) }
+      end
+
+      def summarize(results)
+        total = results.size
+        passed = results.count { |r| r["passed"] }
+        latencies = results.filter_map { |r| r["latency_seconds"] }
+        {
+          "total" => total,
+          "passed" => passed,
+          "failed" => total - passed,
+          "accuracy" => total.positive? ? (passed.to_f / total).round(4) : 0,
+          "avg_latency_seconds" => latencies.any? ? (latencies.sum / latencies.size).round(4) : nil
+        }
+      end
+
+      def flatten_results(results)
+        {
+          "runs" => results,
+          "timestamp" => Time.now.iso8601
+        }
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/evaluation/set_loader.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+require "json"
+
+module AiSafetyRails
+  module Evaluation
+    # Loads evaluation sets from YAML or JSON files/directories.
+    class SetLoader
+      def load(path)
+        path = Pathname(path)
+        if path.directory?
+          load_directory(path)
+        else
+          load_file(path)
+        end
+      end
+
+      def load_file(path)
+        path = Pathname(path)
+        content = File.read(path)
+        data = case path.extname.downcase
+               when ".yaml", ".yml" then YAML.safe_load(content)
+               when ".json" then JSON.parse(content)
+               else raise ArgumentError, "Unsupported format: #{path.extname}"
+               end
+        normalize_set(data, path.to_s)
+      end
+
+      def load_directory(dir)
+        dir = Pathname(dir)
+        sets = []
+        Dir[dir.join("**/*.{yaml,yml,json}")].each do |f|
+          sets << load_file(f)
+        end
+        sets
+      end
+
+      private
+
+      def normalize_set(data, source = nil)
+        {
+          "name" => data["name"] || File.basename(source, ".*"),
+          "description" => data["description"] || "",
+          "examples" => Array(data["examples"]).map { |ex| normalize_example(ex) },
+          "source" => source
+        }
+      end
+
+      def normalize_example(ex)
+        case ex
+        when Hash
+          {
+            "id" => ex["id"] || ex["id"].to_s,
+            "input" => ex["input"],
+            "expectations" => Array(ex["expectations"] || ex["expected"]).map { |e| normalize_expectation(e) }
+          }
+        else
+          { "id" => nil, "input" => ex.to_s, "expectations" => [] }
+        end
+      end
+
+      def normalize_expectation(exp)
+        return { "type" => "custom", "raw" => exp } unless exp.is_a?(Hash)
+        exp.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/evaluation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module AiSafetyRails
+  module Evaluation
+    autoload :Runner, "ai_safety_rails/evaluation/runner"
+    autoload :SetLoader, "ai_safety_rails/evaluation/set_loader"
+  end
+end

data/lib/ai_safety_rails/guardrails/input/pii_redactor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AiSafetyRails
+  module Guardrails
+    module Input
+      # Redacts PII from input text using configurable patterns.
+      # Default patterns: email, US phone (E.164-style), SSN-like (XXX-XX-XXXX).
+      class PiiRedactor < Guardrails::InputGuardrail
+        DEFAULT_PATTERNS = {
+          email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
+          phone: /\b(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}\b/,
+          ssn: /\b\d{3}-\d{2}-\d{4}\b/
+        }.freeze
+
+        DEFAULT_REPLACEMENT = "[REDACTED]"
+
+        def initialize(patterns: nil, replacement: DEFAULT_REPLACEMENT)
+          @patterns = patterns || DEFAULT_PATTERNS
+          @replacement = replacement
+        end
+
+        def process(input)
+          return input unless input.is_a?(String)
+
+          result = input.dup
+          @patterns.each_value do |regex|
+            result = result.gsub(regex, @replacement)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/guardrails/middleware.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module AiSafetyRails
+  module Guardrails
+    # Wraps an LLM client (callable) with input and output guardrails.
+    # Flow: input_guardrails → client.call(input) → output_guardrails → return.
+    class Middleware
+      def initialize(client:, input_guardrails: [], output_guardrails: [])
+        @client = client
+        @input_guardrails = Array(input_guardrails)
+        @output_guardrails = Array(output_guardrails)
+      end
+
+      def call(input)
+        processed_input = run_input_guardrails(input)
+        response = @client.call(processed_input)
+        run_output_guardrails(response)
+        response
+      end
+
+      class << self
+        def wrap(client, input_guardrails: [], output_guardrails: [])
+          new(
+            client: client,
+            input_guardrails: input_guardrails,
+            output_guardrails: output_guardrails
+          )
+        end
+      end
+
+      private
+
+      def run_input_guardrails(input)
+        @input_guardrails.reduce(input) { |acc, g| g.process(acc) }
+      end
+
+      def run_output_guardrails(output)
+        @output_guardrails.each { |g| g.validate(output) }
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/guardrails/output/schema_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json"
+require "json_schemer"
+
+module AiSafetyRails
+  module Guardrails
+    module Output
+      # Validates LLM output against a JSON schema. Expects output to be parseable JSON.
+      class SchemaValidator < Guardrails::OutputGuardrail
+        def initialize(schema:, parse_json: true)
+          @schema = schema.is_a?(Hash) ? schema : JSON.parse(File.read(schema))
+          @parse_json = parse_json
+          @schemer = JSONSchemer.schema(@schema)
+        end
+
+        def validate(output)
+          data = @parse_json ? parse_output(output) : output
+          errors = @schemer.validate(data).to_a
+          return if errors.empty?
+
+          messages = errors.map { |e| e["error"] || e[:error] || e.to_s }
+          raise AiSafetyRails::ValidationError, "Schema validation failed: #{messages.join('; ')}"
+        end
+
+        private
+
+        def parse_output(output)
+          return output if output.is_a?(Hash) || output.is_a?(Array)
+          JSON.parse(output.to_s)
+        rescue JSON::ParserError => e
+          raise AiSafetyRails::ValidationError, "Output is not valid JSON: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/guardrails.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AiSafetyRails
+  module Guardrails
+    # Base for input guardrails: process input string (or messages) before calling the LLM.
+    class InputGuardrail
+      def process(input)
+        raise NotImplementedError, "#{self.class}#process(input) must be implemented"
+      end
+    end
+
+    # Base for output guardrails: validate or transform response after the LLM returns.
+    class OutputGuardrail
+      def validate(output)
+        raise NotImplementedError, "#{self.class}#validate(output) must be implemented"
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AiSafetyRails
+  class Railtie < Rails::Railtie
+    config.after_initialize do
+      # Optional: load config/guardrails.yml when present
+      config_path = Rails.root.join("config", "guardrails.yml")
+      if config_path.exist?
+        Rails.application.config.ai_safety_rails = Rails.application.config_for(:guardrails)
+      end
+    end
+  end
+end

data/lib/ai_safety_rails/version.rb

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

data/lib/ai_safety_rails.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ai_safety_rails/version"
+require "ai_safety_rails/guardrails"
+require "ai_safety_rails/guardrails/middleware"
+require "ai_safety_rails/guardrails/input/pii_redactor"
+require "ai_safety_rails/guardrails/output/schema_validator"
+require "ai_safety_rails/evaluation"
+require "ai_safety_rails/evaluation/runner"
+require "ai_safety_rails/evaluation/set_loader"
+
+# Optional Rails integration (loads only when Rails is defined)
+require "ai_safety_rails/railtie" if defined?(Rails::Railtie)
+
+module AiSafetyRails
+  class Error < StandardError; end
+  class GuardrailError < Error; end
+  class ValidationError < GuardrailError; end
+end

data/lib/generators/ai_safety_rails/eval_set/eval_set_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module AiSafetyRails
+  class EvalSetGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+    desc "Generate an evaluation set under config/llm_evals/"
+
+    def create_eval_set
+      empty_directory "config/llm_evals"
+      template "eval_set.yml.tt", "config/llm_evals/#{file_name}.yml"
+    end
+  end
+end

data/lib/generators/ai_safety_rails/eval_set/templates/eval_set.yml.tt

@@ -0,0 +1,17 @@
+# Evaluation set: <%= file_name %>
+# Run with: bundle exec ai_safety_rails eval config/llm_evals/<%= file_name %>.yml
+# Or: rake "evals:run[config/llm_evals/<%= file_name %>.yml]"
+
+name: <%= file_name %>
+description: "<%= class_name %> evaluation examples"
+
+examples:
+  - id: 1
+    input: "Example prompt or user message"
+    expectations:
+      - type: valid_json
+  - id: 2
+    input: "Another example"
+    expectations:
+      - type: has_key
+        key: category

data/lib/generators/ai_safety_rails/guardrail/guardrail_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module AiSafetyRails
+  class GuardrailGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+    desc "Generate a guardrail config snippet (e.g. pii_redaction)"
+
+    def create_guardrail
+      template "guardrail.rb.tt", "app/guardrails/#{file_name}_guardrail.rb"
+      template "guardrail_spec.rb.tt", "spec/guardrails/#{file_name}_guardrail_spec.rb" if spec_style?
+    end
+
+    private
+
+    def spec_style?
+      File.directory?(Rails.root.join("spec"))
+    end
+  end
+end

data/lib/generators/ai_safety_rails/guardrail/templates/guardrail.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Custom guardrail: <%= file_name %>
+# Register in config/guardrails.yml or wrap your LLM client with AiSafetyRails::Guardrails::Middleware.
+#
+# Example:
+#   input_guardrails: [AiSafetyRails::Guardrails::Input::PiiRedactor.new]
+#   output_guardrails: [AiSafetyRails::Guardrails::Output::SchemaValidator.new(schema: MySchema)]
+
+module Guardrails
+  class <%= class_name %>Guardrail
+    def process(input)
+      # Input guardrail: process input before calling the LLM
+      input
+    end
+  end
+end

data/lib/generators/ai_safety_rails/guardrail/templates/guardrail_spec.rb.tt

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Guardrails::<%= class_name %>Guardrail do
+  subject(:guardrail) { described_class.new }
+
+  it "processes input" do
+    expect(guardrail.process("hello")).to eq("hello")
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: ai_safety_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Raj Panchal
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Provider-agnostic guardrails (PII redaction, schema validation) and evaluation/regression
+  harness for LLM prompts and models.
+email:
+- rajpanchal2810@gmail.com
+executables:
+- ai_safety_rails
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/ai_safety_rails
+- lib/ai_safety_rails.rb
+- lib/ai_safety_rails/evaluation.rb
+- lib/ai_safety_rails/evaluation/runner.rb
+- lib/ai_safety_rails/evaluation/set_loader.rb
+- lib/ai_safety_rails/guardrails.rb
+- lib/ai_safety_rails/guardrails/input/pii_redactor.rb
+- lib/ai_safety_rails/guardrails/middleware.rb
+- lib/ai_safety_rails/guardrails/output/schema_validator.rb
+- lib/ai_safety_rails/railtie.rb
+- lib/ai_safety_rails/version.rb
+- lib/generators/ai_safety_rails/eval_set/eval_set_generator.rb
+- lib/generators/ai_safety_rails/eval_set/templates/eval_set.yml.tt
+- lib/generators/ai_safety_rails/guardrail/guardrail_generator.rb
+- lib/generators/ai_safety_rails/guardrail/templates/guardrail.rb.tt
+- lib/generators/ai_safety_rails/guardrail/templates/guardrail_spec.rb.tt
+homepage: https://github.com/rajpanchal01/ai_safety_rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rajpanchal01/ai_safety_rails
+  source_code_uri: https://github.com/rajpanchal01/ai_safety_rails
+  changelog_uri: https://github.com/rajpanchal01/ai_safety_rails/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: LLM guardrails and evaluation harness for Ruby
+test_files: []