bot_twitter_ebooks 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01cb997f239d1bc64a15b0ccbc6b1e83d641c9fd
+  data.tar.gz: f09849a1882a75c3c32f4cd0c6811c6c40a4968f
+SHA512:
+  metadata.gz: e8ca65ed4046b3665a5d5675efa37643cafda354b953d935aa9e3ef2d2c4399f437d10deb337db8e6545e96afc3b48467be9c23e53b42c3786ca3b8997c4ef39
+  data.tar.gz: 8694e98af0cf9f66d627c62ae33206ea387cfae51e40a414eace37818fce90d70c673dea2f1f86c82607d6073052e3adedf2953f194556297e50eb0cffe3b6db

data/.gitattributes

@@ -0,0 +1 @@
+* text=auto

data/.gitignore

@@ -0,0 +1,200 @@
+
+# Created by https://www.gitignore.io/api/git,vim,ruby,linux,macos,emacs,windows
+
+### Emacs ###
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+projectile-bookmarks.eld
+
+# directory configuration
+.dir-locals.el
+
+# saveplace
+places
+
+# url cache
+url/cache/
+
+# cedet
+ede-projects.el
+
+# smex
+smex-items
+
+# company-statistics
+company-statistics-cache.el
+
+# anaconda-mode
+anaconda-mode/
+
+### Git ###
+*.orig
+
+### Linux ###
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+.env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+### Vim ###
+# swap
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-v][a-z]
+[._]sw[a-p]
+# session
+Session.vim
+# temporary
+.netrwhist
+# auto-generated tag files
+tags
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.gitignore.io/api/git,vim,ruby,linux,macos,emacs,windows

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 2.4.2
+script:
+  - rspec spec
+notifications:
+  email:
+    - astro@astrolince.com

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bot_twitter_ebooks.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jaiden Mispy
+
+MIT License
+
+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,168 @@
+# bot_twitter_ebooks
+
+[![Gem Version](https://badge.fury.io/rb/bot_twitter_ebooks.svg)](http://badge.fury.io/rb/bot_twitter_ebooks)
+[![Build Status](https://travis-ci.org/astrolince/bot_twitter_ebooks.svg)](https://travis-ci.org/astrolince/bot_twitter_ebooks)
+[![Dependency Status](https://gemnasium.com/astrolince/bot_twitter_ebooks.svg)](https://gemnasium.com/astrolince/bot_twitter_ebooks)
+
+A framework for building interactive twitterbots which generate tweets based on pseudo-Markov texts models and respond to mentions/DMs/favs/rts. See [ebooks_example](https://github.com/astrolince/ebooks_example) for a fully-fledged bot definition.
+
+## New in 3.0
+
+- About 80% less memory and storage use for models
+- Bots run in their own threads (no eventmachine), and startup is parallelized
+- Bots start with `ebooks start`, and no longer die on unhandled exceptions
+- `ebooks auth` command will create new access tokens, for running multiple bots
+- `ebooks console` starts a ruby interpreter with bots loaded (see Ebooks::Bot.all)
+- Replies are slightly rate-limited to prevent infinite bot convos
+- Non-participating users in a mention chain will be dropped after a few tweets
+- [API documentation](http://rdoc.info/github/astrolince/bot_twitter_ebooks) and tests
+
+Note that 3.0 is not backwards compatible with 2.x, so upgrade carefully! In particular, **make sure to regenerate your models** since the storage format changed.
+
+## Installation
+
+Requires Ruby 2.1+. Ruby 2.4+ is recommended.
+
+```bash
+gem install bot_twitter_ebooks
+```
+
+## Setting up a bot
+
+Run `ebooks new <reponame>` to generate a new repository containing a sample bots.rb file, which looks like this:
+
+``` ruby
+# This is an example bot definition with event handlers commented out
+# You can define and instantiate as many bots as you like
+
+class MyBot < Ebooks::Bot
+  # Configuration here applies to all MyBots
+  def configure
+    # Consumer details come from registering an app at https://dev.twitter.com/
+    # Once you have consumer details, use "ebooks auth" for new access tokens
+    self.consumer_key = '' # Your app consumer key
+    self.consumer_secret = '' # Your app consumer secret
+
+    # Users to block instead of interacting with
+    self.blacklist = ['tnietzschequote']
+
+    # Range in seconds to randomize delay when bot.delay is called
+    self.delay_range = 1..6
+  end
+
+  def on_startup
+    scheduler.every '24h' do
+      # Tweet something every 24 hours
+      # See https://github.com/jmettraux/rufus-scheduler
+      # tweet("hi")
+      # pictweet("hi", "cuteselfie.jpg")
+    end
+  end
+
+  def on_message(dm)
+    # Reply to a DM
+    # Make sure to set your API permissions to "Read, Write and Access direct messages" or this won't work!
+    # reply(dm, "secret secrets")
+  end
+
+  def on_follow(user)
+    # Follow a user back
+    # follow(user.screen_name)
+  end
+
+  def on_mention(tweet)
+    # Reply to a mention
+    # reply(tweet, "oh hullo")
+  end
+
+  def on_timeline(tweet)
+    # Reply to a tweet in the bot's timeline
+    # reply(tweet, "nice tweet")
+  end
+
+  def on_favorite(user, tweet)
+    # Follow user who just favorited bot's tweet
+    # follow(user.screen_name)
+  end
+
+  def on_retweet(tweet)
+    # Follow user who just retweeted bot's tweet
+    # follow(tweet.user.screen_name)
+  end
+end
+
+# Make a MyBot and attach it to an account
+MyBot.new("elonmusk_ebooks") do |bot|
+  bot.access_token = "" # Token connecting the app to this account
+  bot.access_token_secret = "" # Secret connecting the app to this account
+end
+```
+
+`ebooks start` will run all defined bots in their own threads. The easiest way to run bots in a semi-permanent fashion is with [Heroku](https://www.heroku.com); just make an app, push the bot repository to it, enable a worker process in the web interface and it ought to chug along merrily forever.
+
+The underlying streaming and REST clients from the [twitter gem](https://github.com/sferik/twitter) can be accessed at `bot.stream` and `bot.twitter` respectively.
+
+## Archiving accounts
+
+bot_twitter_ebooks comes with a syncing tool to download and then incrementally update a local json archive of a user's tweets (in this case, my good friend @elonmusk):
+
+``` zsh
+➜  ebooks archive elonmusk corpus/elonmusk.json
+Currently 2584 tweets for elonmusk
+Received 34 new tweets
+```
+
+The first time you'll run this, it'll ask for auth details to connect with. Due to API limitations, for users with high numbers of tweets it may not be possible to get their entire history in the initial download. However, so long as you run it frequently enough you can maintain a perfect copy indefinitely into the future.
+
+If you have full access to the account you can request your full Twitter archive in web settings and convert the tweets.csv to .json with the command: `ebooks jsonify tweets.csv`
+
+## Text models
+
+In order to use the included text modeling, you'll first need to preprocess your archive into a more efficient form:
+
+``` zsh
+➜  ebooks consume corpus/elonmusk.json
+Reading json corpus from corpus/elonmusk.json
+Removing commented lines and sorting mentions
+Segmenting text into sentences
+Tokenizing 987 statements and 1597 mentions
+Ranking keywords
+Corpus consumed to model/elonmusk.model
+```
+
+Notably, this works with both json tweet archives and plaintext files (based on file extension), so you can make a model out of any kind of text.
+
+Text files use newlines and full stops to seperate statements.
+
+You can also consume multiple archives / plaintext files into a single model using `ebooks consume-all <model_name> <corpus_paths>`.
+
+Once you have a model, the primary use is to produce statements and related responses to input, using a pseudo-Markov generator:
+
+``` ruby
+> model = Ebooks::Model.load("model/elonmusk.model")
+> model.make_statement(140)
+=> "Rainbows, unicorns and LA and seems to be working on the Falcon fireball investigation."
+> model.make_response("Will you give free trips to Mars?", 130)
+=> "Plan is to provide something special that only existing owners can give to friends and it is limited to 5 people."
+```
+
+The secondary function is the "interesting keywords" list. For example, I use this to determine whether a bot wants to fav/retweet/reply to something in its timeline:
+
+``` ruby
+top100 = model.keywords.take(100)
+tokens = Ebooks::NLP.tokenize(tweet.text)
+
+if tokens.find { |t| top100.include?(t) }
+  favorite(tweet)
+end
+```
+
+## Bot niceness
+
+bot_twitter_ebooks will drop bystanders from mentions for you and avoid infinite bot conversations, but it won't prevent you from doing a lot of other spammy things. Make sure your bot is a good and polite citizen!
+
+## License
+
+bot_twitter_ebooks is [MIT licensed](https://github.com/astrolince/bot_twitter_ebooks/blob/master/LICENSE) and is a fork of [twitter_ebooks](https://github.com/mispy/twitter_ebooks).
+
+Thanks to Jaiden Mispy ([@mispy](https://github.com/mispy)) and all the human beings/bots/star stuff affected by universe entropy that contribute to the project.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/ebooks

@@ -0,0 +1,454 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'bot_twitter_ebooks'
+require 'ostruct'
+require 'fileutils'
+
+module Ebooks::Util
+  def pretty_exception(e)
+
+  end
+end
+
+module Ebooks::CLI
+  APP_PATH = Dir.pwd # XXX do some recursive thing instead
+  HELP = OpenStruct.new
+
+  HELP.default = <<STR
+Usage:
+     ebooks help <command>
+
+     ebooks new <reponame>
+     ebooks s[tart]
+     ebooks c[onsole]
+     ebooks auth
+     ebooks consume <corpus_path> [corpus_path2] [...]
+     ebooks consume-all <model_name> <corpus_path> [corpus_path2] [...]
+     ebooks append <model_name> <corpus_path>
+     ebooks gen <model_path> [input]
+     ebooks archive <username> [path]
+     ebooks sync <botname> [username]
+     ebooks tweet <model_path> <botname>
+     ebooks version
+STR
+
+  def self.help(command=nil)
+    if command.nil?
+      log HELP.default
+    else
+      log HELP[command].gsub(/^ {4}/, '')
+    end
+  end
+
+  HELP.new = <<-STR
+    Usage: ebooks new <reponame>
+
+    Creates a new skeleton repository defining a template bot in
+    the current working directory specified by <reponame>.
+  STR
+
+  def self.new(reponame)
+    if reponame.nil?
+      help :new
+      exit 1
+    end
+
+    path = "./#{reponame}"
+
+    if File.exists?(path)
+      log "#{path} already exists. Please remove if you want to recreate."
+      exit 1
+    end
+
+    FileUtils.cp_r(Ebooks::SKELETON_PATH, path)
+    FileUtils.mv(File.join(path, 'gitignore'), File.join(path, '.gitignore'))
+
+    File.open(File.join(path, 'bots.rb'), 'w') do |f|
+      template = File.read(File.join(Ebooks::SKELETON_PATH, 'bots.rb'))
+      f.write(template.gsub("{{BOT_NAME}}", reponame))
+    end
+
+    File.open(File.join(path, 'Gemfile'), 'w') do |f|
+      template = File.read(File.join(Ebooks::SKELETON_PATH, 'Gemfile'))
+      f.write(template.gsub("{{RUBY_VERSION}}", RUBY_VERSION))
+    end
+
+    log "New twitter_ebooks app created at #{reponame}"
+  end
+
+  HELP.consume = <<-STR
+    Usage: ebooks consume <corpus_path> [corpus_path2] [...]
+
+    Processes some number of text files or json tweet corpuses
+    into usable models. These will be output at model/<corpus_name>.model
+  STR
+
+  def self.consume(pathes)
+    if pathes.empty?
+      help :consume
+      exit 1
+    end
+
+    pathes.each do |path|
+      filename = File.basename(path)
+      shortname = filename.split('.')[0..-2].join('.')
+
+      FileUtils.mkdir_p(File.join(APP_PATH, 'model'))
+      outpath = File.join(APP_PATH, 'model', "#{shortname}.model")
+
+      Ebooks::Model.consume(path).save(outpath)
+      log "Corpus consumed to #{outpath}"
+    end
+  end
+
+  HELP.consume_all = <<-STR
+    Usage: ebooks consume-all <model_name> <corpus_path> [corpus_path2] [...]
+
+    Processes some number of text files or json tweet corpuses
+    into one usable model. It will be output at model/<model_name>.model
+  STR
+
+  def self.consume_all(name, paths)
+    if paths.empty?
+      help :consume_all
+      exit 1
+    end
+
+    outpath = File.join(APP_PATH, 'model', "#{name}.model")
+    Ebooks::Model.consume_all(paths).save(outpath)
+    log "Corpuses consumed to #{outpath}"
+  end
+
+  HELP.append = <<-STR
+    Usage: ebooks append <model_name> <corpus_path>
+
+    Process then append the provided corpus to the model
+    instead of overwriting.
+  STR
+
+  def self.append(name, path)
+    if !name || !path
+      help :append
+      exit 1
+    end
+
+    Ebooks::Model.consume(path).append(File.join(APP_PATH,'model',"#{name}.model"))
+    log "Corpus appended to #{name}.model"
+  end
+
+
+  HELP.jsonify = <<-STR
+    Usage: ebooks jsonify <tweets.csv> [tweets.csv2] [...]
+
+    Takes a csv twitter archive and converts it to json.
+  STR
+
+  def self.jsonify(paths)
+    if paths.empty?
+      log usage
+      exit
+    end
+
+    paths.each do |path|
+      name = File.basename(path).split('.')[0]
+      new_path = name + ".json"
+
+      tweets = []
+      id = nil
+      if path.split('.')[-1] == "csv" #from twitter archive
+        csv_archive = CSV.read(path, :headers=>:first_row)
+        tweets = csv_archive.map do |tweet|
+          { text: tweet['text'], id: tweet['tweet_id'].to_i }
+        end
+      else
+        File.read(path).split("\n").each do |l|
+          if l.start_with?('# ')
+            id = l.split('# ')[-1]
+          else
+            tweet = { text: l }
+            if id
+              tweet[:id] = id
+              id = nil
+            end
+            tweets << tweet
+          end
+        end
+      end
+
+      File.open(new_path, 'w') do |f|
+        log "Writing #{tweets.length} tweets to #{new_path}"
+        f.write(JSON.pretty_generate(tweets))
+      end
+    end
+  end
+
+
+  HELP.gen = <<-STR
+    Usage: ebooks gen <model_path> [input]
+
+    Make a test tweet from the processed model at <model_path>.
+    Will respond to input if provided.
+  STR
+
+  def self.gen(model_path, input)
+    if model_path.nil?
+      help :gen
+      exit 1
+    end
+
+    model = Ebooks::Model.load(model_path)
+    if input && !input.empty?
+      puts "@cmd " + model.make_response(input, 135)
+    else
+      puts model.make_statement
+    end
+  end
+
+  HELP.archive = <<-STR
+    Usage: ebooks archive <username> [outpath]
+
+    Downloads a json corpus of the <username>'s tweets.
+    Output defaults to corpus/<username>.json
+    Due to API limitations, this can only receive up to ~3000 tweets
+    into the past.
+
+    The first time you run archive, you will need to enter the auth
+    details of some account to use for accessing the API. This info
+    will then be stored in ~/.ebooksrc for later use, and can be
+    modified there if needed.
+  STR
+
+  def self.archive(username, outpath=nil)
+    if username.nil?
+      help :archive
+      exit 1
+    end
+
+    Ebooks::Archive.new(username, outpath).sync
+  end
+
+    HELP.sync = <<-STR
+    Usage: ebooks sync <botname> <username>
+
+    Copies and flips <username>'s avatar and cover photo, uploading them to <botname>'s profile.
+
+    Stores saved avatar's and covers in image/.
+
+  STR
+
+  def self.sync(botname, username)
+    if botname.nil?
+      help :sync
+      exit 1
+    end
+
+    load File.join(APP_PATH, 'bots.rb')
+    Ebooks::Sync::run(botname, username)
+  end
+
+  HELP.tweet = <<-STR
+    Usage: ebooks tweet <model_path> <botname>
+
+    Sends a public tweet from the specified bot using text
+    from the processed model at <model_path>.
+  STR
+
+  def self.tweet(modelpath, botname)
+    if modelpath.nil? || botname.nil?
+      help :tweet
+      exit 1
+    end
+
+    load File.join(APP_PATH, 'bots.rb')
+    model = Ebooks::Model.load(modelpath)
+    statement = model.make_statement
+    bot = Ebooks::Bot.get(botname)
+    if bot.nil?
+      log "No such bot configured in bots.rb: #{botname}"
+      exit 1
+    end
+    bot.configure
+    bot.tweet(statement)
+  end
+
+  HELP.auth = <<-STR
+    Usage: ebooks auth
+
+    Authenticates your Twitter app for any account. By default, will
+    use the consumer key and secret from the first defined bot. You
+    can specify another by setting the CONSUMER_KEY and CONSUMER_SECRET
+    environment variables.
+  STR
+
+  def self.auth
+    consumer_key, consumer_secret = find_consumer
+    require 'oauth'
+
+    consumer = OAuth::Consumer.new(
+      consumer_key,
+      consumer_secret,
+      site: 'https://twitter.com/',
+      scheme: :header
+    )
+
+    request_token = consumer.get_request_token
+    auth_url = request_token.authorize_url()
+
+    pin = nil
+    loop do
+      log auth_url
+
+      log "Go to the above url and follow the prompts, then enter the PIN code here."
+      print "> "
+
+      pin = STDIN.gets.chomp
+
+      break unless pin.empty?
+    end
+
+    access_token = request_token.get_access_token(oauth_verifier: pin)
+
+    log "Account authorized successfully. Make sure to put these in your bots.rb!\n" +
+         "  bot.access_token = \"#{access_token.token}\"\n" +
+         "  bot.access_token_secret = \"#{access_token.secret}\""
+  end
+
+  HELP.console = <<-STR
+    Usage: ebooks c[onsole]
+
+    Starts an interactive ruby session with your bots loaded
+    and configured.
+  STR
+
+  def self.console
+    load_bots
+    require 'pry'; Ebooks.module_exec { pry }
+  end
+
+  HELP.version = <<-STR
+    Usage: ebooks version
+
+    Shows you twitter_ebooks' version number.
+  STR
+
+  def self.version
+    require File.expand_path('../../lib/twitter_ebooks/version', __FILE__)
+    log Ebooks::VERSION
+  end
+
+  HELP.start = <<-STR
+    Usage: ebooks s[tart] [botname]
+
+    Starts running bots. If botname is provided, only runs that bot.
+  STR
+
+  def self.start(botname=nil)
+    load_bots
+
+    if botname.nil?
+      bots = Ebooks::Bot.all
+    else
+      bots = Ebooks::Bot.all.select { |bot| bot.username == botname }
+      if bots.empty?
+        log "Couldn't find a defined bot for @#{botname}!"
+        exit 1
+      end
+    end
+
+    threads = []
+    bots.each do |bot|
+      threads << Thread.new { bot.prepare }
+    end
+    threads.each(&:join)
+
+    threads = []
+    bots.each do |bot|
+      threads << Thread.new do
+        loop do
+          begin
+            bot.start
+          rescue Exception => e
+            bot.log e.inspect
+            puts e.backtrace.map { |s| "\t"+s }.join("\n")
+          end
+          bot.log "Sleeping before reconnect"
+          sleep 60
+        end
+      end
+    end
+    threads.each(&:join)
+  end
+
+  # Non-command methods
+
+  def self.find_consumer
+    if ENV['CONSUMER_KEY'] && ENV['CONSUMER_SECRET']
+      log "Using consumer details from environment variables:\n" +
+          "  consumer key: #{ENV['CONSUMER_KEY']}\n" +
+          "  consumer secret: #{ENV['CONSUMER_SECRET']}"
+      return [ENV['CONSUMER_KEY'], ENV['CONSUMER_SECRET']]
+    end
+
+    load_bots
+    consumer_key = nil
+    consumer_secret = nil
+    Ebooks::Bot.all.each do |bot|
+      if bot.consumer_key && bot.consumer_secret
+        consumer_key = bot.consumer_key
+        consumer_secret = bot.consumer_secret
+        log "Using consumer details from @#{bot.username}:\n" +
+            "  consumer key: #{bot.consumer_key}\n" +
+            "  consumer secret: #{bot.consumer_secret}\n"
+        return consumer_key, consumer_secret
+      end
+    end
+
+    if consumer_key.nil? || consumer_secret.nil?
+      log "Couldn't find any consumer details to auth an account with.\n" +
+          "Please either configure a bot with consumer_key and consumer_secret\n" +
+          "or provide the CONSUMER_KEY and CONSUMER_SECRET environment variables."
+      exit 1
+    end
+  end
+
+  def self.load_bots
+    load 'bots.rb'
+
+    if Ebooks::Bot.all.empty?
+      puts "Couldn't find any bots! Please make sure bots.rb instantiates at least one bot."
+    end
+  end
+
+  def self.command(args)
+    if args.length == 0
+      help
+      exit 1
+    end
+
+    case args[0]
+    when "new" then new(args[1])
+    when "consume" then consume(args[1..-1])
+    when "consume-all" then consume_all(args[1], args[2..-1])
+    when "append" then append(args[1],args[2])
+    when "gen" then gen(args[1], args[2..-1].join(' '))
+    when "archive" then archive(args[1], args[2])
+    when "sync" then sync(args[1], args[2])
+    when "tweet" then tweet(args[1], args[2])
+    when "jsonify" then jsonify(args[1..-1])
+    when "auth" then auth
+    when "console" then console
+    when "c" then console
+    when "start" then start(args[1])
+    when "s" then start(args[1])
+    when "help" then help(args[1])
+    when "version" then version
+    else
+      log "No such command '#{args[0]}'"
+      help
+      exit 1
+    end
+  end
+end
+
+Ebooks::CLI.command(ARGV)