janis-ai 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e04e6c4ecd67a77265012befba5150dc07fe1982
+  data.tar.gz: d2c490087a5eaeba9eaf58aec6da55f885280ce8
+SHA512:
+  metadata.gz: 118faf0fa01509910b0666d63c21232ab9b85e311e63736c509e58e25b858d8c8db79cdc68d87445aa20a86e1964ad8f6fd679861001cff531bb162bef8daa0a
+  data.tar.gz: e583ec062aeab59b0c8a7d1bd2b4510a0ee118c59150c8516e3b378bcb2a5ba3bdae3a9299805dfc053e942184a357d73ad9624e3a96e58f4f4d7891b3203e11

data/README.md

@@ -0,0 +1,180 @@
+# [janis](https://www.janis.ai) - SDK For Human + AI Conversational Experiences
+## For Bots Built in Ruby
+
+Bots enable businesses to respond to customers immediately but they often fail to understand user intent.  According to Facebook, bots fail 70% of the time. janis helps solve this problem with a toolkit to easily keep humans in the loop when AI fails your customers.    The solution includes an SDK for bot developers to connect their bots to Slack, and a Slack app to get alerts, then pause and take over a bot.
+
+![Solution](https://cloud.githubusercontent.com/assets/7429980/22609969/491afe58-ea31-11e6-8928-27e1a1f1d6bd.png)
+
+
+
+You can integrate janis in minutes and it begins working immediately, enabling you to deliver exceptional human + AI conversational experiences.
+This module has been tested with Messenger, Slack, Skype, and Microsoft Webchat. Please see our [examples](./examples/).
+It supports bot developers working in Node, Python and Ruby.
+
+### What you can do with janis:
+You can view a full list of features at (https://www.janis.ai).  It's core purpose can be explained with this single GIF  
+
+![Takeover](https://cloud.githubusercontent.com/assets/7429980/22609935/22e39740-ea31-11e6-8286-e5a3ae545565.gif)
+
+### What you need to get started:
+* [A Slack Account](http://www.slack.com)
+* [janis for Slack](https://slack.com/oauth/authorize?scope=users:read,users:read.email,commands,chat:write:bot,chat:write:user,channels:read,channels:history,files:write:user,channels:write,bot&client_id=23850726983.39760486257)
+* [A Chatbot built in Ruby](./examples/)
+
+##### Operational Dependencies:
+1.  You'll need an API key from janis and for each Chatbot a Bot Token.  You can get both of those (free) when you add janis to Slack and through a conversation with janis. 
+2.  If you're building a Messenger Chatbot, you'll need to setup a Facebook App, Facebook Page, get the Page Access Token from Facebook and link the Facebook App to the Facebook Page for janis to work.
+
+
+### Installation
+
+```bash
+$ gem install janis
+```
+
+
+### Usage
+
+Set your environmental variables for `JANIS_API_KEY`, `JANIS_CLIENT_KEY`, `ACCESS_TOKEN`.
+
+```bash
+$ export JANIS_API_KEY=xxxxxxxxxxxxxxxxxxxx
+$ export JANIS_CLIENT_KEY=xxxxxxxxxxxxxxxxxxxx
+$ export ACCESS_TOKEN=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+Add the janis class to your code and set the required parameter values.
+```ruby
+require 'janis'
+
+# janis Api Key
+janis.apikey = ENV['JANIS_API_KEY']
+# Unique janis Client Key for your bot
+janis.clientkey = ENV['JANIS_CLIENT_KEY']
+# possible values: "messenger" or "slack"
+janis.platform = "messenger" 
+# Page Access Token (only required for Messenger bots)
+janis.token = ENV['ACCESS_TOKEN']
+```
+##### Incoming Message Schema:
+Throughout this documentation, you will see references to `incomingMessage`. Depending on whether you have a Messenger or Slack bot, the schema will be different. The value of `incomingMessage` should be equal to the message you receive directly from either the Messenger webhook response, or from the Slack RTM event response.
+
+```python
+# Example of a Slack Incoming Message
+{
+    "type": "message",
+    "channel": "D024BE91L",
+    "user": "U2147483697",
+    "text": "Hello world",
+    "ts": "1355517523.000005"
+}
+
+# Example of a Messenger Incoming Message
+{
+  "sender":{
+    "id":"USER_ID"
+  },
+  "recipient":{
+    "id":"PAGE_ID"
+  },
+  "timestamp":1458692752478,
+  "message":{
+    "mid":"mid.1457764197618:41d102a3e1ae206a38",
+    "seq":73,
+    "text":"hello, world!",
+    "quick_reply": {
+      "payload": "DEVELOPER_DEFINED_PAYLOAD"
+    }
+  }
+}  
+```
+
+##### Outgoing Message Schema:
+Throughout this documentation, you will see references to `outgoingMessage`. Depending on whether you have a Messenger or Slack bot, the schema, as defined by each platform, will be different. Every time you track an outgoing message, the schema requirements match the respective platform.
+
+```python
+# Example of Slack Outgoing Message
+{
+    "channel": "C024BE91L",
+    "text": "Hello world"
+}
+
+# Exmaple of Messenger Outgoing Message
+{
+  "recipient":{
+    "id":"USER_ID"
+  },
+  "message":{
+    "text":"hello, world!"
+  }
+}
+```
+
+##### Tracking received messages:
+
+When your bot receives an incoming message, you'll need to log the data with janis by calling to `janis.hopIn`. 
+__Note__: janis can pause your bot so that it doesn't auto response while a human has taken over. The server response from your `hopIn` request will pass the `paused` state. Use that to stop your bot from responding to an incoming message. Here is an example:
+
+```ruby
+hopInResponse = janis.hopIn(incomingMessage)
+if hopInResponse['paused'] != true
+# proceed to process incoming message
+ ...
+```
+
+##### Tracking sent messages:
+
+Each time your bot sends a message, make sure to log that with janis by calling to `janis.hopOut`. Here is an example of a function that we're calling `sendIt` that tracks an outgoing message and at the same time, has the bot say the message:
+```ruby
+def sendIt(channel, text)
+    # schema matches Messenger
+    outgoingMessage = {recipient: {id: channel},message: {text: text}}
+    janis.hopOut(outgoingMessage)
+    client.say({'text': text, 'channel': channel})  # <= example of bot sending reply
+    ...
+```
+
+##### Log Unknown Intents:
+
+Find the spot in your code your bot processes incoming messages it does not understand. Within that block of code, call to `janis.logUnkownIntent` to capture these conversational ‘dead-ends’. Here's an example:
+
+```ruby
+# let the user know that the bot does not understand
+sendIt(recipient_id, 'Huh?')
+# capture conversational dead-ends.
+janis.logUnknownIntent(incomingMessage) 
+```
+##### Dial 0 to Speak With a Live Human Being:
+
+janis can trigger alerts to suggest when a human should take over for your Chatbot. To enable this, create an intent such as when a customer explicitly requests live assistance, and then include the following lines of code where your bot listens for this intent:
+
+```ruby
+# match an intent to talk to a real human
+if text == 'help'
+    # let the user know that they are being routed to a human
+    sendIt(recipient_id, 'Hang tight. Let me see what I can do.')
+    # send a janis alert to your slack channel
+    # that the user could use assistance
+    janis.assistanceRequested(incomingMessage);
+```
+
+##### Human Take Over:
+
+To enable the ability to have a human take over your bot, add the code below to subscribe to the 'chat response' event. Alternatively, if you'd prefer to use a webhook to receive the payload, please get in touch with us at support@janis.ai and we can enable that for you.
+
+```ruby
+# Handle forwarding the messages sent by a human through your bot
+janis.on :'chat response' do |data|
+    text = data['text']
+    channel = data['channel']
+    client.say({'text': text, 'channel': channel})  # <= example of bot sending message
+end
+```
+
+Go back to Slack and wait for alerts. That's it! 
+[Be sure to check out our examples.](./examples/)
+
+
+### Looking for something we don't yet support?  
+* [Join our mailing list and we'll notifiy you](https://www.janis.ai/contact.html)
+* [Contact Support](mailto:support@janis.ai)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/janis

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'janis'

data/lib/janis.rb

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'socket.io-client-simple'
+require 'httparty'
+
+module janis
+
+    
+    class Partay
+        include HTTParty
+        base_uri 'https://janisapi.herokuapp.com/api/v1'
+    end
+    
+    EVENTS = [:'chat response', :'socket_id_set', :'channel update'].freeze
+    
+    class << self
+    
+        attr_accessor :apikey, :clientkey, :token, :platform
+
+        def initialize
+            @apikey
+            @clientkey
+            @token
+            @platform
+        end
+        
+        def new(*args, &block)
+            obj = allocate
+            obj.initialize(*args, &block)
+            obj
+        end
+    
+        # Return a Hash of hooks.
+        def apikey
+            @apikey ||= ENV['JANIS_API_KEY']
+        end
+        
+        def clientkey
+            @clientkey ||= ENV['JANIS_CLIENT_KEY']
+        end
+        
+        def token
+            @token ||= ENV['ACCESS_TOKEN'] ||= ''
+        end
+        
+        def platform
+            @platform ||= "messenger"
+        end
+        
+        def headers
+            @headers = {'apikey':apikey,'clientkey':clientkey,'platform':platform, 'token': token}
+        end
+        
+        def hooks
+            @hooks ||= {}
+        end
+    
+        socket = SocketIO::Client::Simple.connect 'https://janis-socket-server.herokuapp.com'
+        
+        socket.on :socket_id_set do |data|
+            socket_id = data
+            x = {'socket_id': socket_id, 'clientkey': JANIS_CLIENT_KEY}
+            options = {
+                body: x,
+                headers: headers
+            }
+            Partay.post('/update_bot_socket_id', options)
+        end
+
+        socket.on :'chat response' do |data|
+            channel = data['channel']
+            text = data['text']
+            messageData = {'recipient': {'id': channel},'message': {'text': text}}
+            janis.hopOut(messageData)
+            janis.trigger(:'chat response', messageData)
+        end
+
+        socket.on :'channel update' do |data|
+            janis.trigger(:'channel update', data)
+        end
+
+        def on(event, &block)
+            unless EVENTS.include? event
+                raise ArgumentError,
+                "#{event} is not a valid event; " \
+                "available events are #{EVENTS.join(',')}"
+            end
+            hooks[event] = block
+        end
+
+        def trigger(event, *args)
+            hooks.fetch(event).call(*args)
+        rescue KeyError
+            $stderr.puts "Ignoring #{event} (no hook registered)"
+        end
+
+        def hopIn(x)
+            puts 'hopIn'
+            options = {'body':x, 'headers':headers}
+            return Partay.post('/in', options)
+        end
+            
+        def hopOut(x)
+            puts 'hopOut'
+            options = {'body':x, 'headers':headers}
+            return Partay.post('/out', options)
+        end
+            
+        def logUnknownIntent(x)
+            puts 'logUnknownIntent'
+            options = {'body':x, 'headers':headers}
+            return Partay.post('/unknown', options)
+        end
+            
+        def assistanceRequested(x)
+            puts 'assistanceRequested'
+            options = {'body':x, 'headers':headers}
+            return Partay.post('/human', options)
+        end
+    end
+end
+

data/test/test_janis.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'janis'
+
+class janisTest < Test::Unit::TestCase
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: janis-ai
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Nathanson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-09 00:00:00.000000000 Z
+dependencies: []
+description: "Chatbots allow you scale your customer communications through messaging,
+  \n  \tautomating tasks and enabling transactions, but they can't empathize like
+  humans, reliably \n  \tinterpret intent, or solve overly complex customer problems.
+  With janis, you can monitor your \n  \tChatbot for friction in your conversational
+  experience, and fix problems in in real-time. \n  \tSimply drop in a couple of lines
+  of code into your Chatbot and add janis to Slack. \n  \tCollaborate with your Slack
+  team to identify bottlenecks and take over for your bot at just \n  \tthe right
+  time to engage your users and produce business results. With our reports, you'll
+  gain \n  \tactionable insights that help you train your bot, train your people,
+  and optimize your conversational experience."
+email: nick@quaran.to
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/janis
+- lib/janis.rb
+- test/test_janis.rb
+homepage: http://rubygems.org/gems/janis
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 3
+summary: A toolkit for creating a hybrid Chatbot + Human UX
+test_files:
+- test/test_janis.rb