jev-feels

# Gemfile
gem "jev-feels"

class SupportEmail < ApplicationRecord
  include Jev::Model

  feels :body, :urgent
  feels :subject, :not_important, "Subject of this email is not important"
  decide :body, :support_team

  validates_feeling :body, :urgent, threshold: 0.9
end

email.feels?(:urgent)        # => true
email.decide(:support_team)  # => :billing

# config/initializers/jev.rb
require "feels/active_model"

Jev.configure do |config|
  config.api_key = ENV.fetch("JEV_API_KEY")
end

Jev.define :urgent, "Requires immediate attention or action"
Jev.define :support_team, "Which team should handle this?", choices: {
  billing: "payments and refunds",
  technical: "bugs and outages",
  other: "none of the above"
}

class Ticket
  include Jev::Model

  feels :description, :urgent
  decide :description, :support_team
end

ticket.feels?(:urgent)
ticket.decide(:support_team)

using Jev::Feels

email.body.feels?(:urgent)
email.body.decide(:support_team)
email.body.score(:severity)

require "feels/string"
# or: require "jev-feels/string"

Jev.define :urgent, "Requires immediate attention or action"
Jev.define :spam, "Unsolicited or unwanted promotional content"

Jev.define :support_team,
  "Which support team should handle this?",
  choices: {
    billing: "payments, invoices, charges and refunds",
    technical: "bugs, outages and integrations",
    sales: "purchase and plan questions",
    other: "none of the above"
  }

Jev.define :severity,
  "How severe is this customer issue?",
  levels: {
    cosmetic: "minor visual or cosmetic issue",
    degraded: "functionality is degraded but a workaround exists",
    blocking: "the customer cannot complete an important task",
    critical: "major outage, data loss, security issue, or severe business impact"
  }

Jev.define Email, :urgent, "Outage, customers cannot sign in"
Jev.define Comment, :urgent, "Legal takedown or self-harm"

Jev.definition(:urgent)
Jev.definition(Email, :urgent)
Jev.definitions
Jev.definitions(Comment)

Jev.feels(email.body, :urgent)   # => 0.93
Jev.feels?(email.body, :urgent)  # => true / false
Jev.decide(ticket, :support_team) # => :billing
Jev.score(ticket, :severity)      # => 2.37

email.body.feels?(:urgent, threshold: 0.8)

email.body.feels?("sounds like the sender is about to cancel their subscription")

Jev.decide(
  ticket,
  "Which support team should handle this?",
  choices: {
    billing: "payments and refunds",
    technical: "bugs and outages",
    other: "none of the above"
  }
)

text.feels?(:urgent, at_least: 0.8)
# p >= 0.8       => true
# p <= 0.2       => false
# 0.2 < p < 0.8  => nil

Jev.decide(ticket, :support_team, confidence: 0.8)
# => :billing or nil

result = Jev.measure(ticket, :urgent)
result.probability
result.type # => :noul

result = Jev.measure(ticket, :support_team)
result.choice
result.confidence
result.probabilities
result.type # => :choice

result = Jev.measure(ticket, :severity)
result.score
result.confidence
result.probabilities
result.levels
result.level # => :blocking
result.type  # => :score

feels?  # boolean, or nil with at_least:
feels   # probability
decide  # Symbol, or nil with confidence:
score   # Float

result = Jev.measure(ticket) do |q|
  q.feels :urgent
  q.feels :angry
  q.decide :support_team
  q.score :severity
end

result[:urgent]        # => Jev::Result::Noul
result[:support_team]  # => Jev::Result::Choice
result[:severity]      # => Jev::Result::Score

result.to_h
# => { urgent: true, angry: false, support_team: :billing, severity: 2.37 }

case Jev.measure(ticket) { |q|
  q.feels :urgent
  q.decide :support_team
  q.score :severity
}
in { urgent: true, support_team: :billing }
  escalate_billing(ticket)
in { support_team: :technical }
  route_to_technical(ticket)
in { urgent: true, severity: 2.0.. }
  escalate(ticket)
else
  manual_review(ticket)
end

Jev.match(ticket, :support_team) do
  on(:billing)   { route_to_billing(ticket) }
  on(:technical) { route_to_technical(ticket) }
  on(:sales)     { route_to_sales(ticket) }
  otherwise      { manual_review(ticket) }
end

Jev.match(ticket, :support_team, confidence: 0.8) do
  on(:billing, :sales) { route_to_commercial(ticket) }
  otherwise            { manual_review(ticket) }
end

Jev.stub(
  urgent: 0.95,
  support_team: :billing,
  severity: 2.4
) do
  expect(ticket.feels?(:urgent)).to be(true)
  expect(Jev.decide(ticket, :support_team)).to eq(:billing)
end

tape = Jev.record do
  ticket.feels?(:urgent)
  Jev.decide(ticket, :support_team)
end

json = tape.to_json

Jev.replay(tape) do
  ticket.feels?(:urgent)
  Jev.decide(ticket, :support_team)
end

Jev.reset_configuration!
Jev.reset_definitions!

Jev.configure do |config|
  config.api_key = ENV["JEV_API_KEY"]
end