cogibara 0.0.2

data/lib/cogibara/message_handler.rb

@@ -0,0 +1,153 @@
+module Cogibara
+  class MessageHandler
+
+    def handle(message)
+      if(message.is_a? String)
+        message = Message.new(message, "local")
+      end
+
+      Responder.new.send_reply("@think",message.clientID)
+
+      if Cogibara::config.soft_parse
+        message.structure = derive_structure(message)
+      end
+
+
+      msg = message.text
+      @verbose = Cogibara::config.verbose
+      @name = Cogibara::config.name
+
+      if msg
+        puts "core" if @verbose
+        reply = process_core(msg, message)
+        unless reply
+          reply = process_confirm_deny(msg, message)
+          unless reply
+            splitmsg = msg
+            splitmsg = splitmsg.split
+            puts "instruction #{splitmsg[0]}" if @verbose
+            if splitmsg[0]==@name
+              slicemessage = splitmsg
+              slicemessage.shift
+              slicemessage = slicemessage.join(' ')
+              # slicemessage.slice!(@name)
+              slicemessage = slicemessage.strip
+              puts "instructed #{slicemessage}" if @verbose
+              # if @soft_parse
+
+              reply = process_instruction(slicemessage, message)
+              unless reply
+                puts "defaults" if @verbose
+                reply = process_default(msg, message)
+              end
+            elsif Cogibara::config.active_mode
+              puts "active module #{Cogibara::config.active_mode} processing #{msg}" if @verbose
+              reply = process_instruction(Cogibara::config.active_mode + " " + msg, message)
+              unless reply
+                puts "defaultx" if @verbose
+                reply = process_default(msg, message)
+              end
+            elsif message.structure[:category]
+              reply = process_intent(msg, message)
+              unless reply
+                puts "defaulty" if @verbose
+                reply = process_default(msg, message)
+              end
+            else
+              puts "defaultz" if @verbose
+              reply = process_default(msg, message)
+            end
+          end
+        end
+
+        puts reply if @verbose
+        Responder.new.send_reply("@listen",message.clientID)
+        Cogibara::say Message.new("#{@name}: " + reply.to_s, message.clientID)
+
+        reply
+      end
+    end
+
+    def process_core(message, obj)
+      @yourname = "person"
+      if message == "hey #{@name}"
+        "what's up #{@yourname}?"
+      elsif message == "reset mode"
+        Cogibara::config.active_mode = nil
+        Cogibara::config.active_file_mode = nil
+        "Disabling any active modules"
+      elsif /your name is now/ =~ message
+        message.slice!("your name is now ")
+        @name = message.chomp
+        "OK, you can call me #{@name}"
+      elsif /my name is/ =~ message
+        message.slice!("my name is ")
+        @yourname = message.chomp
+        "OK, I'll call you #{@yourname}"
+      elsif message == "what time is it"
+        "it is #{Time.now.hour} o'clock and #{Time.now.min} minutes"
+      else
+        nil
+      end
+    end
+
+    def process_default(msg, obj)
+        chatmsg = Message.new(msg, obj.clientID, obj.structure)
+        puts chatmsg.inspect if @verbose
+        Cogibara::dispatcher.call("chat", chatmsg)
+    end
+
+    def process_instruction(message, obj)
+
+      puts "instruction: #{message.split[0]} (#{Cogibara::dispatcher.registered?(message.split[0])})" if @verbose
+      if message =~ /\Aset mode/
+        message.slice!("set mode")
+        Cogibara::config.active_mode = message.chomp.strip
+        "Going into #{Cogibara::config.active_mode} mode"
+      elsif message =~ /\Aset file mode/
+        message.slice!("set file mode")
+        Cogibara::config.active_file_mode = message.chomp.strip
+        "Handling files with #{Cogibara::config.active_file_mode}"
+      elsif Cogibara::dispatcher.registered?(message.split[0])
+          splitmsg = message.split
+          Responder.new.send_reply("@search",obj.clientID)
+          puts "recognized instruction #{message.split[0]} (#{splitmsg})" if @verbose
+          mod = splitmsg[0]
+          splitmsg.shift
+          Cogibara::dispatcher.call(mod, Message.new(splitmsg.join(' '), obj.clientID, obj.structure))
+      else
+        puts "didn't understand instruction #{message.split[0]}" if @verbose
+        nil
+      end
+    end
+
+    def process_intent(message, obj)
+      if (obj.structure[:action] && Cogibara::dispatcher.registered?(obj.structure[:action].to_s))
+        puts "recognized instruction #{obj.structure[:action]}" if @verbose
+        Cogibara::dispatcher.call(obj.structure[:category].to_s,obj)
+      elsif (obj.structure[:category] && Cogibara::dispatcher.registered?(obj.structure[:category].to_s))
+        puts "recognized instruction #{obj.structure[:category]}" if @verbose
+        Cogibara::dispatcher.call(obj.structure[:category].to_s,obj)
+      else
+        puts "didn't understand instruction #{message.split[0]}" if @verbose
+        nil
+      end
+    end
+
+    def derive_structure(message)
+      response = Cogibara::dispatcher.call("maluuba",message)
+    end
+
+
+    def process_confirm_deny(message, obj)
+      if message == "yes"
+        if Cogibara::confirmer.waiting?
+          Cogibara::confirmer.confirm_action
+          "Confirmed!"
+        end
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/cogibara/operator_base.rb

@@ -0,0 +1,39 @@
+module Cogibara
+  class OperatorBase
+
+    attr :clientID
+    attr :message_text
+    attr :message_structure
+    attr :operator_config
+
+    def initialize(config={})
+      @operator_config = config
+      initialize_operator if self.respond_to?(:initialize_operator)
+    end
+
+    def receive_message(message)
+      @clientID = message.clientID
+      @message_text = message.text
+      @message_structure = message.structure
+      process(message)
+    end
+
+    def process(message)
+      "!!!text processing not implemented for this operator!!!"
+    end
+
+    def process_file(file)
+      "!!!file processing not implemented for this operator!!!"
+    end
+
+    def say(message)
+      Cogibara::say Message.new("#{Cogibara::config.name}: " + message, @clientID)
+    end
+
+    def confirm(message, success=nil, failure=nil)
+      puts "new confirm"
+      Cogibara::confirmer.add_action(message, success)
+      message
+    end
+  end
+end

data/lib/cogibara/operators/calendar.rb

@@ -0,0 +1,41 @@
+require 'google_calendar'
+
+class Calendar < Cogibara::OperatorBase
+
+  def initialize_operator
+    @calendar = Google::Calendar.new(username: self.operator_config["username"], password: self.operator_config["password"], app_name: 'cogibara-calendar-operator')
+  end
+
+  def process(message)
+    info = message.structure
+    puts info
+    case info[:action]
+    when :CALENDAR_CREATE_EVENT
+      # puts info
+      title = info[:entities][:title]? info[:entities][:title][0] : "Untitled event"
+      if info[:entities][:daterange]
+        start_t = Time.parse(info[:entities][:daterange][0][:start] + " " + info[:entities][:timerange][0][:start])
+        end_t = Time.parse(info[:entities][:daterange][0][:start] + " " + info[:entities][:timerange][0][:end]) # use same day because broken?
+      else
+        start_t = Time.parse(info[:entities][:timerange][0][:start])
+        end_t = Time.parse(info[:entities][:timerange][0][:end]) # use same day because broken?
+      end
+
+
+      create_event = lambda do
+        say "adding #{title} to your calendar"
+        @calendar.create_event do |e|
+          e.title = title
+          e.start_time = start_t
+          e.end_time = end_t
+        end
+      end
+      # {code: :confirm, message: "create calendar event #{title} from #{start_t} to #{end_t}?", success: create_event}
+      puts "confirming event"
+      confirm("create calendar event #{title} from #{start_t} to #{end_t}?", create_event)
+    else
+      puts "unsupported calendar operation #{info[:action]}, returning nil"
+      nil
+    end
+  end
+end

data/lib/cogibara/operators/chat.rb

@@ -0,0 +1,22 @@
+require 'cleverbot'
+require 'curb'
+
+class Chat < Cogibara::OperatorBase
+  def initialize_operator
+    @cleverbot_client = Cleverbot::Client.new
+    pf_ID = self.operator_config["Bot_ID"].to_i
+    if pf_ID > 0
+      @pf_ID = pf_ID
+    end
+  end
+
+  def process(message)
+    if @pf_ID
+      reply = Curl.post("http://www.personalityforge.com/directchat.php?BotID=#{@pf_ID}&MID=8", {Message: message.text, action: "Send Message", UserID: @pf_ID})
+      reply.body_str.slice(/<\!-- Bot's reply -->.*?<\!-- end section -->/m).slice(/<span class="bigfont">.*<\/span>/m).gsub(/<.*>/,'').gsub("\n\t",'')
+    else
+      @cleverbot_client.write message.text
+    end
+
+  end
+end

data/lib/cogibara/operators/help.rb

@@ -0,0 +1,13 @@
+# require_relative 'wolfram_alpha.rb'
+
+class Help < Cogibara::OperatorBase
+
+  def process(message)
+    operators = Cogibara::dispatcher.operators.keys
+
+    soft_operators = operators.reject{ |o| o.upcase != o}
+    hard_operators = operators
+
+    "I understand the following categories of natural speech: #{soft_operators}, and keyword queries of the form <my name>: #{hard_operators}. Most natural speech categories implement a more natural response, so, for example, 'what is 18 dollars in rupees' activates the knowledge module, and returns 'rupee 968.31(Indian rupees)', while the 'ask' keyword sends the query to the knowledge engine and prints raw output, so 'cucumber ask what is 18 dollars in rupees' = 'Input Interpretation: convert $18  (US dollars) to Indian rupees, Result: rupee968.31  (Indian rupees), 1-year  minimum | rupee931.42  (October 4, 2012 | 7 months ago) 1-year  maximum | rupee1030.38  (June 24, 2012 | 10 months ago)"
+  end
+end

data/lib/cogibara/operators/knowledge.rb

@@ -0,0 +1,55 @@
+# require_relative 'wolfram_alpha.rb'
+require 'cleverbot'
+require 'wolfram'
+
+class Knowledge < Cogibara::OperatorBase
+
+  def initialize_operator
+    Wolfram.appid = self.operator_config["WOLFRAM_KEY"]
+    # @wolfram = WolframAlpha.new
+    @cleverbot = Cleverbot::Client.new
+  end
+
+  def is_question_word?(word)
+    qwords = %w{who what why where when how are can if}
+    qwords.include? word.downcase
+  end
+
+  def process(query)
+    word = query.text.split[0]
+
+    if is_question_word?(word)
+      result = Wolfram::HashPresenter.new(Wolfram.fetch(query.text)).to_hash
+      if result[:pods]["Result"] || result[:pods]["Exact result"] || result[:pods]["Basic information"]
+        valid_result = true
+        if result[:pods]["Result"]
+          msg = result[:pods]["Result"][0]
+        elsif result[:pods]["Exact result"]
+          msg = result[:pods]["Exact result"][0]
+        elsif result[:pods]["Basic information"]
+          msg = result[:pods]["Basic information"][0]
+        end
+      else
+        valid_result == false
+      end
+      # valid_result = !(!result[:pods]["Result"] || result[:pods]["Result"][0] == "(data not available)")
+    else
+      valid_result = false
+    end
+
+    if valid_result
+      if msg == "(data not available)"
+        # msg = @cleverbot.write(query.text) + " (dk)"
+        # # puts msg
+        # msg
+        nil
+      else
+        msg
+      end
+    else
+      # @cleverbot.write(query.text)
+      nil
+    end
+    # valid_result ? result[:pods]["Result"][0] : @cleverbot.write(query.text)
+  end
+end

data/lib/cogibara/operators/reminder_setter.rb

@@ -0,0 +1,8 @@
+# require 'twilio-ruby'
+
+class ReminderSetter < Cogibara::OperatorBase
+  def process(message)
+
+   "reminder setter heard #{message.inspect}, set reminder for (nothing right now)"
+  end
+end

data/lib/cogibara/operators/soft_parser.rb

@@ -0,0 +1,48 @@
+require 'maluuba_napi'
+
+class SoftParser < Cogibara::OperatorBase
+  def initialize_operator
+    @api_key = self.operator_config["API_KEY"]
+    @client = MaluubaNapi::Client.new(@api_key)
+  end
+
+  def normalize(message, type)
+    @client.normalize phrase: message, type: type, timezone:"CST"
+  end
+
+  def normalize_response!(msg, response)
+    if response[:entities]
+      if response[:entities][:daterange]
+        n = normalize(msg, "daterange")[:entities][:daterange]
+        response[:entities][:daterange] = n if n
+      end
+      if response[:entities][:timerange]
+        n = normalize(msg, "timerange")[:entities][:timerange]
+        response[:entities][:timerange] = n if n
+      end
+      if response[:entities][:time]
+        n = normalize(msg, "time")[:entities][:time]
+        response[:entities][:time] = n if n
+      end
+    end
+  end
+
+  def process(message)
+    response = @client.interpret phrase: message.text
+    normalize_response!(message.text, response)
+    ## Should normalize times and do something with them
+    # time_categories = [:REMINDER, :ALARM, :TIMER]
+    # timerange_categories = [:TIMER]
+    # date_categories = [:CALENDAR]
+    #
+    # if time_categories.includes? response[:category]
+    #   normalized = @client.normalize phrase: message, type: 'time', timezone: 'CST'
+    # elsif timerange_categories.includes? response[:category]
+    #   normalized = @client.normalize phrase: message, type: 'timerange', timezone: 'CST'
+    # elsif date_categories.includes? response[:category]
+    #   normalized = @client.normalize phrase: message, type: 'daterange', timezone: 'CST'
+    # end
+    #
+    response
+  end
+end

data/lib/cogibara/operators/translate.rb

@@ -0,0 +1,33 @@
+require 'bing_translator'
+
+class Translate < Cogibara::OperatorBase
+
+  LANGUAGES = {'english' => 'en-US', 'English' => 'en-US', 'Japanese' => 'ja', 'japanese' => 'ja', 'en-US' => 'en-US', 'dutch' => 'nl-NL', 'Dutch' => 'nl-NL', 'German' => 'de-DE','german' => 'de-DE', 'Spanish' => 'es-US', 'spanish' => 'es-US'}
+
+  def initialize_operator
+    @bing = BingTranslator.new('wstrinz', 'aMAR9BHp6NxCml97/OjCaZDB/WRpCDCdmXNHXbCz83s=')
+  end
+
+  def translate(message)
+    in_language = @bing.detect message
+    @bing.translate message, :from => in_language, :to => "en"
+  end
+
+  def process(input)
+    message = input.text
+    if LANGUAGES.has_key? message
+      @language = LANGUAGES[message]
+      "Translating from #{message} (#{@language})"
+    elsif message =~ /\Aset language/
+      @language = LANGUAGES[message.split[2]]
+      "Translating from #{message.split[2]} (#{@language})"
+    else
+      "you said: " + translate(message)
+    end
+  end
+
+  def process_file(file)
+    message = Cogibara::Transcriber.new.transcribe_lang(file, @language)
+    "you said: " + translate(message)
+  end
+end

data/lib/cogibara/operators/weather.rb

@@ -0,0 +1,89 @@
+require 'forecast_io'
+require 'geocoder'
+require 'date'
+
+class Weather < Cogibara::OperatorBase
+  def initialize_operator
+    Forecast::IO.api_key = self.operator_config["API_KEY"]
+  end
+
+  # def translate(message)
+  #   in_language = @bing.detect message
+  #   @bing.translate message, :from => in_language, :to => "en"
+  # end
+
+  def location_to_coordinates(location)
+    Geocoder.coordinates(location)
+  end
+
+  def get_location(message)
+    info = message.structure
+    if info[:entities][:location]
+      location_to_coordinates(info[:entities][:location][0])
+    else
+      [43.092, -89.369]
+    end
+  end
+
+  def get_forecast_period(message)
+    info = message.structure[:entities]
+
+    if info[:daterange]
+      start_d = Date.parse(info[:daterange][0][:start])
+      end_d = Date.parse(info[:daterange][0][:end])
+      start_d..end_d
+    elsif info[:time]
+      info[:time]=="tomorrow" ? Date.today + 1 : Date.today
+    else
+      nil
+    end
+  end
+
+  def current_conditions
+    # if @forecast.minutely
+    #   say "now: #{@forecast.minutely.summary}"
+    # end
+    curr_summary = " Currently " + @forecast.currently.summary + ", "
+    curr_cond = "#{@forecast.currently.temperature.round} degrees, cloud cover #{(@forecast.currently.cloudCover * 100).round}% "
+    next_cond =  @forecast.minutely ? @forecast.minutely.summary : ""
+    # next_cond =  @forecast.minutely ? "Then " + @forecast.minutely.summary : ""
+    curr_summary + curr_cond + "then, " + next_cond
+  end
+
+  def todays_forecast
+    temps = @forecast.hourly.data[0..18].map{|hr| hr.temperature}
+    max_t = temps.each_with_index.max
+    min_t = temps.each_with_index.min
+    @forecast.hourly.summary + " The high temperature will be #{max_t[0].round} degrees, in #{max_t[1]} hours, and the low will be #{min_t[0].round} degrees, in #{min_t[1]} hours"
+  end
+
+  def week_forecast
+    say @forecast.daily.summary
+  end
+
+  def process(message)
+    return nil if message.text.split.include?("cool")
+
+    @loc = get_location(message)
+    @date = get_forecast_period(message)
+    @forecast = Forecast::IO.forecast(@loc[0],@loc[1])
+
+    unless @date
+      current_conditions
+    else
+      if @date.is_a? Range
+        if @date.first == Date.today || @date.first == Date.today+1
+          todays_forecast
+        else
+          week_forecast
+        end
+      else
+        if @date == Date.today || @date == Date.today + 1
+          todays_forecast
+        else
+          week_forecast
+        end
+      end
+    end
+  end
+end

data/lib/cogibara/operators/wiki/wiki_getter.rb

@@ -0,0 +1,47 @@
+require 'wikipedia'
+require 'wikicloth'
+require 'json'
+require 'sanitize'
+
+class WikiGetter
+
+  def checkRedirect(article)
+    if(/\Aredirect/ =~ article.strip)
+      return article.strip.gsub(/\Aredirect/,'')
+    elsif(/\AREDIRECT/ =~ article.strip)
+      return article.strip.gsub(/\AREDIRECT/,'').strip
+    end
+  end
+
+  def getArticle(title)
+      article = JSON.parse(Wikipedia.find(title).json)["query"]["pages"].to_a[0][1]["revisions"]
+      unless article
+        "Could not find article, sorry"
+      else
+        raw = article[0]["*"]
+        # parsed = Wikitext::Parser.new.parse(raw)
+        parsed = WikiCloth::Parser.new({:data => raw})
+        sanitized = Sanitize.clean(parsed.to_html)
+        redirect = checkRedirect(sanitized)
+        if redirect
+          puts "redirecting to #{redirect}"
+          getArticle(redirect)
+        else
+          ref_links = sanitized.gsub(/\[\d+\]/,'').gsub(/\[edit\]/,'')
+          http_links = ref_links.gsub(/\[http+\s?\]/m,'')
+
+
+          # leftover = sanitized.gsub(/\[\[.*\]\]/, '').gsub(/\{\{.*\}\}/, '')
+          # leftover = leftover.gsub(/\[\[.*?\]\]/m, '').gsub(/\{\{.*?\}\}/m, '').gsub(/<.*?>/m,'')
+          # leftover = leftover.gsub(/\'\'/,'').gsub(/\[http.*?\]/m,'').gsub(/\{\|.*?\|\}/m,'').gsub(/\}\}/,'')
+          # removeUgly = leftover.gsub(/\|/,' ').gsub(/\_/,'')
+        end
+      end
+
+    # leftover
+    # leftover
+  end
+end
+
+# puts WikiGetter.new.getArticle("Cattle")
+# puts WikiGetter.new.getArticle("Cat").length

data/lib/cogibara/operators/wiki.rb

@@ -0,0 +1,22 @@
+require_relative 'wiki/wiki_getter.rb'
+
+class Wiki < Cogibara::OperatorBase
+
+  def initialize_operator
+    @handler = WikiGetter.new
+  end
+
+  def process(message)
+    search = message.text
+    article = WikiGetter.new.getArticle(search)
+    # splits = article.split
+    # (splits.count / 100).times do |n|
+    #     if (n+1)*100 > splits.count
+    #       chunk = splits[n*100..splits.count] * ' '
+    #     else
+    #       chunk = splits[n*100..((n+1)*100 - 1)] * ' '
+    #     end
+    #     yield chunk
+    #   end
+  end
+end

data/lib/cogibara/operators/wolfram_alpha.rb

@@ -0,0 +1,27 @@
+# require_relative 'wolfram_alpha/'
+require 'wolfram'
+class WolframAlpha < Cogibara::OperatorBase
+
+  def initialize_operator
+    Wolfram.appid = self.operator_config["API_KEY"]
+  end
+
+  def resultToString(result)
+    rhash = Wolfram::HashPresenter.new(result).to_hash
+    rarr = []
+    rhash[:pods].keys.each do |key|
+      value = rhash[:pods][key][0]
+      rarr << (key + ":\n\t" + value + "\n")
+    end
+    rarr.join
+  end
+
+  def process(message)
+    # puts "asking wolfram #{query}"
+    query = message.text
+    result = resultToString(Wolfram.fetch(query))
+    # puts result == "Result:\n"
+    # result == "Result:\n" ? nil : result
+
+  end
+end

data/lib/cogibara/responder.rb

@@ -0,0 +1,24 @@
+require 'redis'
+
+module Cogibara
+  class Responder
+    def redis
+      @redis ||= Redis.new
+    end
+
+    def send_reply(message, client, options={type: "text"})
+      if(Cogibara::config.use_redis)
+        redis.multi do
+          redis.incr "sendMsgNum"
+          @msgid = redis.get "sendMsgNum"
+        end
+
+        redis.hmset("sendMsg:#{@msgid.value}",options[:type],message,"client",client)
+        redis.publish("fromCapy","sendMsg:#{@msgid.value}")
+      end
+      if(Cogibara::config.local)
+        puts message unless message[0] == "@"
+      end
+    end
+  end
+end

data/lib/cogibara/speaker.rb

@@ -0,0 +1,21 @@
+module Cogibara
+  class Speaker
+    def speak_to_local(message, voice="rab_diphone", engine=:festival)
+      if engine == :pico
+        `pico2wave -w out.wav "#{self}"`
+        `aplay out.wav`
+        `rm ./out.wav`
+      else
+        `echo "#{self}" | text2wave -eval "(voice_#{voice})" | aplay`
+      end
+    end
+
+    def speak_to_file(message)
+
+    end
+  end
+end
+
+
+
+

data/lib/cogibara/text_parser.rb

@@ -0,0 +1,8 @@
+module Cogibara
+  class TextParser
+    def parse(message)
+      Message.new(message.text, {msg: message.text + " structured"})
+    end
+  end
+
+end