wordhop 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87eb8237e9e3524b27c93961df3c70c0e3849ca7
+  data.tar.gz: c0a8cb15f9cf1c47139c2f706f9d8972c44b7187
+SHA512:
+  metadata.gz: c446bc98b2ca88e108e099bc4ce551b3ce471f9dcb8d15dc8bb9d8e780cbadeb94dd10b1862128dd835a953b8dfbd6d84cabcbec7532c052a2e1dd9634d58e9e
+  data.tar.gz: ce950685d1bc65bde1464cbb9a01ebd40e993ff988206f80a3e89bf11618ef2ff5a14e6893612531cdabb8d24ba4bf7c76465d0dc0efd2210121f7ac6bad40d2

data/README.md

@@ -0,0 +1,103 @@
+# [Wordhop](https://www.wordhop.io) - Monitor and Optimize Your Conversational Experience
+## For Chatbots Built in Python
+
+With Wordhop you can sync up your Python-based Chatbot to Slack, so you can retain your users without ever leaving Slack.  Wordhop monitors your Chatbot for friction in your conversational experience and alerts you on Slack in real-time. Simply add Wordhop to Slack and then drop in a couple of lines of code into your Chatbot.  Wordhop integrates in minutes, not days, and begins working immediately.  From Slack, you can pause and take over your bot, then hand the conversation back to your bot.  Actionable analytics also show you and your Slack team where you can optimize your conversational experience and measure results. 
+
+### What you can do with Wordhop:
+* [See Key Features](https://developer.wordhop.io)
+* [Watch a Demo](https://www.youtube.com/watch?v=TAcwr3s9l4o)
+
+### What you need to get started:
+* [A Slack Account](http://www.slack.com)
+* [Wordhop for Slack](https://slack.com/oauth/authorize?scope=users:read,users:read.email,commands,chat:write:bot,channels:read,channels:write,bot&client_id=23850726983.39760486257)
+* [A Chatbot built in Ruby](https://github.com/hyperoslo/facebook-messenger)
+
+### Installation
+
+```bash
+$ gem install facebook-messenger
+```
+
+
+### Usage
+
+```ruby
+require 'wordhop'
+
+# Wordhop Api Key
+Wordhop.apikey = ENV['WORDHOP_API_KEY']
+# Unique Wordhop Client Key for your bot
+Wordhop.clientkey = ENV['WORDHOP_CLIENT_KEY']
+# possible values: "messenger" or "slack"
+Wordhop.platform = "messenger" 
+# Page Access Token (only required for Messenger bots)
+Wordhop.token = ENV['ACCESS_TOKEN']
+```
+
+##### Tracking received messages:
+
+When Messenger calls your receiving webhook, you'll need to log the data with Wordhop. 
+__Note__: Wordhop 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 = Wordhop.hopIn(message.messaging)
+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 Wordhop in the request's callback. Here is an example:
+```ruby
+def sendIt(message, data)
+    payload = {
+        recipient: message.sender,
+        message: data
+    }
+    message.reply(data)
+    Wordhop.hopOut(payload)
+end
+```
+
+##### Human Take Over:
+
+To enable the ability to have a human take over your bot, add the following code:
+
+```ruby
+# Handle forwarding the messages sent by a human through your bot
+Wordhop.on :'chat response' do |data|
+    Bot.deliver(data, access_token: ENV['ACCESS_TOKEN'])  # <= example of bot sending message
+end
+```
+##### Log Unknown Intents:
+
+Find the spot in your code your bot processes incoming messages it does not understand. You may have some outgoing fallback message there (i.e. "Oops I didn't get that!"). Within that block of code, call to `wordhop.logUnkownIntent` to capture these conversational ‘dead-ends’. Here's an example:
+
+```ruby
+# let the user know that the bot does not understand
+sendIt(message, text: 'Huh?')
+# capture conversational dead-ends.
+Wordhop.logUnknownIntent(message.messaging)
+```
+##### Dial 0 to Speak With a Live Human Being:
+
+Wordhop 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 line 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(message, text: 'Hang tight. Let me see what I can do.')
+    # send a Wordhop alert to your slack channel
+    # that the user could use assistance
+    Wordhop.assistanceRequested(message.messaging)
+```
+
+Go back to Slack and wait for alerts. That's it! 
+[Be sure to check out our example.](examples/messenger/README.md)
+
+
+### Looking for something we don't yet support?  
+* [Join our mailing list and we'll notifiy you](https://www.wordhop.io/contact.html)
+* [Contact Support](mailto:support@wordhop.io)

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/wordhop

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

data/lib/wordhop.rb

@@ -0,0 +1,117 @@
+require 'rubygems'
+require 'socket.io-client-simple'
+require 'httparty'
+
+module Wordhop
+
+    
+    class Partay
+        include HTTParty
+        base_uri 'https://wordhopapi.herokuapp.com/api/v1'
+    end
+    
+    EVENTS = [:'chat response', :'socket_id_set'].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['WORDHOP_API_KEY']
+        end
+        
+        def clientkey
+            @clientkey ||= ENV['WORDHOP_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://wordhop-socket-server.herokuapp.com'
+        
+        socket.on :socket_id_set do |data|
+            socket_id = data
+            x = {'socket_id': socket_id, 'clientkey': WORDHOP_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}}
+            Wordhop.hopOut(messageData)
+            Wordhop.trigger(:'chat response', messageData)
+        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_wordhop.rb

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

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: wordhop
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Nathanson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-08 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 Wordhop, 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 Wordhop 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/wordhop
+- lib/wordhop.rb
+- test/test_wordhop.rb
+homepage: http://rubygems.org/gems/wordhop
+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_wordhop.rb