initial commit

CNAME

@@ -0,0 +1 @@
+learnGitBranching.js.org

LICENSE.md

@@ -0,0 +1,21 @@
+## MIT License
+
+Copyright (c) 2012 Peter Cottle
+
+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.

README.md

@@ -6,6 +6,7 @@ colorTo: green
 sdk: static
 pinned: false
 license: mit
+app_file: /src/template.index.html
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

checkgit.sh

@@ -0,0 +1,6 @@
+GIT_STATUS=$(git status --porcelain | wc -l )
+if [[ GIT_STATUS -ne 0 ]]; then
+  echo "${1:-Source files were modified}"
+  git status
+  exit $GIT_STATUS
+fi;

gulpfile.js

@@ -0,0 +1,242 @@
+var { execSync } = require('child_process');
+var {
+  writeFileSync, readdirSync, readFileSync,
+  existsSync, statSync, mkdirSync, copyFileSync,
+} = require('fs');
+var path = require('path');
+
+var glob = require('glob');
+var _ = require('underscore');
+
+var { src, dest, series, watch } = require('gulp');
+var log = require('fancy-log');
+var gHash = require('gulp-hash');
+var gClean = require('gulp-clean');
+var concat = require('gulp-concat');
+var cleanCSS = require('gulp-clean-css');
+var gTerser = require('gulp-terser');
+var gJasmine = require('gulp-jasmine');
+var { minify } = require('html-minifier');
+var { SpecReporter } = require('jasmine-spec-reporter');
+var gJshint = require('gulp-jshint');
+
+var source = require('vinyl-source-stream');
+var buffer = require('vinyl-buffer');
+var browserify = require('browserify');
+var babelify = require('babelify');
+
+_.templateSettings.interpolate = /\{\{(.+?)\}\}/g;
+_.templateSettings.escape = /\{\{\{(.*?)\}\}\}/g;
+_.templateSettings.evaluate = /\{\{-(.*?)\}\}/g;
+
+// precompile for speed
+var indexFile = readFileSync('src/template.index.html').toString();
+var indexTemplate = _.template(indexFile);
+
+var compliments = [
+  'Thanks to Hong4rc for the modern and amazing gulp workflow!',
+  'I hope you all have a great day :)'
+];
+var compliment = (done) => {
+  var index = Math.floor(Math.random() * compliments.length);
+
+  log(compliments[index]);
+  done();
+};
+
+const lintStrings = (done) => {
+  execSync('node src/js/intl/checkStrings');
+  done();
+};
+
+
+var destDir = './build/';
+
+var copyRecursiveSync = (src, dest) => {
+  var exists = existsSync(src);
+  var stats = exists && statSync(src);
+  var isDirectory = exists && stats.isDirectory();
+  if (isDirectory) {
+    mkdirSync(dest);
+    readdirSync(src).forEach((childItemName) => {
+      copyRecursiveSync(
+        path.join(src, childItemName),
+        path.join(dest, childItemName));
+    });
+  } else {
+    copyFileSync(src, dest);
+  }
+};
+
+var buildIndex = function(done) {
+  log('Building index...');
+
+  // first find the one in here that we want
+  var buildFiles = readdirSync(destDir);
+
+  var jsRegex = /bundle-[\.\w]+\.js/;
+  var jsFile = buildFiles.find(function(name) {
+    return jsRegex.exec(name);
+  });
+  if (!jsFile) {
+    throw new Error('no hashed min file found!');
+  }
+  log('Found hashed js file: ' + jsFile);
+
+  var styleRegex = /main-[\.\w]+\.css/;
+  var styleFile = buildFiles.find(function(name) {
+    return styleRegex.exec(name);
+  });
+  if (!styleFile) {
+    throw new Error('no hashed css file found!');
+  }
+  log('Found hashed style file: ' + styleFile);
+
+  var buildDir = process.env.CI ? '.' : 'build';
+
+  // output these filenames to our index template
+  var outputIndex = indexTemplate({
+    buildDir,
+    jsFile,
+    styleFile,
+  });
+
+  if (process.env.NODE_ENV === 'production') {
+    outputIndex = minify(outputIndex, {
+      minifyJS: true,
+      collapseWhitespace: true,
+      processScripts: ['text/html'],
+      removeComments: true,
+    });
+  }
+
+  if (process.env.CI) {
+    writeFileSync('build/index.html', outputIndex);
+    copyRecursiveSync('assets', 'build/assets');
+  } else {
+    writeFileSync('index.html', outputIndex);
+  }
+  done();
+};
+
+var getBundle = function() {
+  return browserify({
+    entries: [...glob.sync('src/**/*.js'), ...glob.sync('src/**/*.jsx')],
+    debug: true,
+  })
+  .transform(babelify, { presets: ['@babel/preset-react'] })
+  .bundle()
+  .pipe(source('bundle.js'))
+  .pipe(buffer())
+  .pipe(gHash());
+};
+
+var clean = function () {
+  return src(destDir, { read: false, allowEmpty: true })
+    .pipe(gClean());
+};
+
+var jshint = function() {
+  return src([
+    'gulpfile.js',
+    '__tests__/',
+    'src/'
+  ])
+  .pipe(gJshint())
+  .pipe(gJshint.reporter('default'));
+};
+
+var ifyBuild = function() {
+  return getBundle()
+    .pipe(dest(destDir));
+};
+
+var miniBuild = function() {
+  process.env.NODE_ENV = 'production';
+  return getBundle()
+    .pipe(gTerser())
+    .pipe(dest(destDir));
+};
+
+var style = function() {
+  var chain = src('src/style/*.css')
+    .pipe(concat('main.css'));
+
+  if (process.env.NODE_ENV === 'production') {
+    chain = chain.pipe(cleanCSS());
+  }
+
+  return chain.pipe(gHash())
+    .pipe(dest(destDir));
+};
+
+var jasmine = function() {
+  return src('__tests__/*.spec.js')
+    .pipe(gJasmine({
+      config: {
+        verbose: true,
+        random: false,
+      },
+      reporter: new SpecReporter(),
+  }));
+};
+
+var gitAdd = function(done) {
+  execSync('git add build/');
+  done();
+};
+
+var gitDeployMergeMain = function(done) {
+  execSync('git checkout gh-pages && git merge main -m "merge main"');
+  done();
+};
+
+var gitDeployPushOrigin = function(done) {
+  execSync('git commit -am "rebuild for prod"; ' +
+    'git push origin gh-pages --force && ' +
+    'git branch -f trunk gh-pages && ' +
+    'git checkout main'
+  );
+  done();
+};
+
+var fastBuild = series(clean, ifyBuild, style, buildIndex, jshint);
+
+var build = series(
+  clean,
+  miniBuild, style, buildIndex,
+  gitAdd, jasmine, jshint,
+  lintStrings, compliment
+);
+
+var deploy = series(
+  clean,
+  jasmine,
+  jshint,
+  gitDeployMergeMain,
+  build,
+  gitDeployPushOrigin,
+  compliment
+);
+
+var lint = series(jshint, compliment);
+
+var watching = function() {
+  return watch([
+    'gulpfile.js',
+    '__tests__/git.spec.js',
+    'src/js/**/*.js',
+    'src/js/**/**/*.js',
+    'src/levels/**/*.js'
+  ], series([fastBuild , jasmine, jshint, lintStrings]));
+};
+
+module.exports = {
+  default: build,
+  lint,
+  fastBuild,
+  watching,
+  build,
+  test: jasmine,
+  deploy,
+};

package.json

@@ -0,0 +1,51 @@
+{
+  "name": "LearnGitBranching",
+  "version": "0.8.0",
+  "description": "An interactive git visualization to challenge and educate!",
+  "homepage": "https://learngitbranching.js.org",
+  "author": "Peter Cottle <petermcottle@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "test": "gulp test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pcottle/learnGitBranching"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.17.5",
+    "@babel/preset-react": "^7.16.7",
+    "babelify": "^10.0.0",
+    "browserify": "^17.0.0",
+    "fancy-log": "^1.3.3",
+    "glob": "^7.2.0",
+    "gulp": "^4.0.2",
+    "gulp-clean": "^0.4.0",
+    "gulp-clean-css": "^4.3.0",
+    "gulp-concat": "^2.6.1",
+    "gulp-hash": "^4.2.2",
+    "gulp-jasmine": "^4.0.0",
+    "gulp-jshint": "^2.1.0",
+    "gulp-terser": "^2.1.0",
+    "gulp-uglify": "^3.0.2",
+    "html-minifier": "^4.0.0",
+    "jasmine-spec-reporter": "^7.0.0",
+    "jshint": "^2.13.4",
+    "prompt": "^1.2.2",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0"
+  },
+  "dependencies": {
+    "backbone": "^1.4.0",
+    "flux": "^4.0.3",
+    "jquery": "^3.4.0",
+    "jquery-ui": "^1.13.1",
+    "marked": "^4.0.12",
+    "prop-types": "^15.8.1",
+    "q": "^1.5.1",
+    "raphael": "^2.1.0",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "underscore": "^1.13.2"
+  }
+}

src/js/actions/CommandLineActions.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var AppConstants = require('../constants/AppConstants');
+var AppDispatcher = require('../dispatcher/AppDispatcher');
+
+var ActionTypes = AppConstants.ActionTypes;
+
+var CommandLineActions = {
+
+  submitCommand: function(text) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.SUBMIT_COMMAND,
+      text: text
+    });
+  }
+
+};
+
+module.exports = CommandLineActions;

src/js/actions/GlobalStateActions.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var AppConstants = require('../constants/AppConstants');
+var AppDispatcher = require('../dispatcher/AppDispatcher');
+
+var ActionTypes = AppConstants.ActionTypes;
+
+var GlobalStateActions = {
+
+  changeIsAnimating: function(isAnimating) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.CHANGE_IS_ANIMATING,
+      isAnimating: isAnimating
+    });
+  },
+
+  levelSolved: function() {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.LEVEL_SOLVED,
+    });
+  },
+
+  disableLevelInstructions: function() {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.DISABLE_LEVEL_INSTRUCTIONS,
+    });
+  },
+
+  changeFlipTreeY: function(flipTreeY) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.CHANGE_FLIP_TREE_Y,
+      flipTreeY: flipTreeY
+    });
+  }
+
+};
+
+module.exports = GlobalStateActions;

src/js/actions/LevelActions.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var AppConstants = require('../constants/AppConstants');
+var AppDispatcher = require('../dispatcher/AppDispatcher');
+
+var ActionTypes = AppConstants.ActionTypes;
+
+var LevelActions = {
+
+  setLevelSolved: function(levelID) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.SET_LEVEL_SOLVED,
+      levelID: levelID
+    });
+  },
+
+  resetLevelsSolved: function() {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.RESET_LEVELS_SOLVED
+    });
+  }
+
+};
+
+module.exports = LevelActions;

src/js/actions/LocaleActions.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var AppConstants = require('../constants/AppConstants');
+var AppDispatcher = require('../dispatcher/AppDispatcher');
+
+var ActionTypes = AppConstants.ActionTypes;
+
+var LocaleActions = {
+
+  changeLocale: function(newLocale) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.CHANGE_LOCALE,
+      locale: newLocale
+    });
+  },
+
+  changeLocaleFromURI: function(newLocale) {
+    AppDispatcher.handleURIAction({
+      type: ActionTypes.CHANGE_LOCALE,
+      locale: newLocale
+    });
+  },
+
+  changeLocaleFromHeader: function(header) {
+    AppDispatcher.handleViewAction({
+      type: ActionTypes.CHANGE_LOCALE_FROM_HEADER,
+      header: header
+    });
+  }
+};
+
+module.exports = LocaleActions;

src/js/app/index.js

@@ -0,0 +1,363 @@
+var Backbone = require('backbone');
+var jQuery = require('jquery');
+var EventEmitter = require('events').EventEmitter;
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+var util = require('../util');
+var intl = require('../intl');
+var LocaleStore = require('../stores/LocaleStore');
+var LocaleActions = require('../actions/LocaleActions');
+
+/**
+ * Globals
+ */
+
+Backbone.$ = jQuery;
+
+// Bypass jasmine
+if (util.isBrowser()) {
+  window.jQuery = jQuery;
+  window.$ = jQuery;
+  window.Raphael = require('raphael');
+}
+
+var events = Object.assign(
+  {},
+  EventEmitter.prototype,
+  {
+    trigger: function() {
+      // alias this for backwards compatibility
+      this.emit.apply(this, arguments);
+    }
+  }
+);
+// Allow unlimited listeners, so FF doesn't break
+events.setMaxListeners(0);
+var commandUI;
+var sandbox;
+var eventBaton;
+var levelDropdown;
+
+///////////////////////////////////////////////////////////////////////
+
+var init = function() {
+  /**
+    * There is a decent amount of bootstrapping we need just to hook
+    * everything up. The init() method takes on these responsibilities,
+    * including but not limited to:
+    *   - setting up Events and EventBaton
+    *   - calling the constructor for the main visualization
+    *   - initializing the command input bar
+    *   - handling window.focus and zoom events
+  **/
+  var Sandbox = require('../sandbox/').Sandbox;
+  var EventBaton = require('../util/eventBaton').EventBaton;
+  var LevelDropdownView = require('../views/levelDropdownView').LevelDropdownView;
+
+  eventBaton = new EventBaton();
+  commandUI = new CommandUI();
+  sandbox = new Sandbox();
+  levelDropdown = new LevelDropdownView({
+    wait: true
+  });
+
+  LocaleStore.subscribe(function() {
+    if (LocaleStore.getLocale() !== LocaleStore.getDefaultLocale()) {
+      intlRefresh();
+    }
+  });
+  events.on('vcsModeChange', vcsModeRefresh);
+
+  initRootEvents(eventBaton);
+  initDemo(sandbox);
+  // unfortunate global export for casper tests
+  window.LocaleStore = LocaleStore;
+  window.LocaleActions = LocaleActions;
+  window.intl = intl;
+};
+
+var vcsModeRefresh = function(eventData) {
+  if (!window.$) { return; }
+
+  var mode = eventData.mode;
+  var isGit = eventData.mode === 'git';
+
+  var displayMode = mode.slice(0, 1).toUpperCase() + mode.slice(1);
+  var otherMode = (displayMode === 'Git') ? 'Hg' : 'Git';
+  var regex = new RegExp(otherMode, 'g');
+
+  document.title = intl.str('learn-git-branching').replace(regex, displayMode);
+  $('span.vcs-mode-aware').each(function(i, el) {
+    var text = $(el).text().replace(regex, displayMode);
+    $(el).text(text);
+  });
+
+  $('body').toggleClass('gitMode', isGit);
+  $('body').toggleClass('hgMode', !isGit);
+};
+
+var insertAlternateLinks = function(pageId) {
+  // For now pageId is null, which would link to the main page.
+  // In future if pageId is provided this method should link to a specific page
+
+  // The value of the hreflang attribute identifies the language (in ISO 639-1 format)
+  // and optionally a region (in ISO 3166-1 Alpha 2 format) of an alternate URL
+
+  var altLinks = LocaleStore.getSupportedLocales().map(function(langCode) {
+    var url = "https://learngitbranching.js.org/?locale=" + langCode;
+    return '<link rel="alternate" hreflang="'+langCode+'" href="' + url +'" />';
+  });
+  var defaultUrl = "https://learngitbranching.js.org/?locale=" + LocaleStore.getDefaultLocale();
+  altLinks.push('<link rel="alternate" hreflang="x-default" href="' + defaultUrl +'" />');
+  $('head').prepend(altLinks);
+
+};
+
+var intlRefresh = function() {
+  if (!window.$) { return; }
+  var countryCode = LocaleStore.getLocale().split("_")[0];
+  $("html").attr('lang', countryCode);
+  $("meta[http-equiv='content-language']").attr("content", countryCode);
+  $('span.intl-aware').each(function(i, el) {
+    var intl = require('../intl');
+    var key = $(el).attr('data-intl');
+    $(el).text(intl.str(key));
+  });
+};
+
+var initRootEvents = function(eventBaton) {
+  // we always want to focus the text area to collect input
+  var focusTextArea = function() {
+    $('#commandTextField').focus();
+  };
+  focusTextArea();
+
+  $(window).focus(function(e) {
+    eventBaton.trigger('windowFocus', e);
+  });
+  $(document).click(function(e) {
+    eventBaton.trigger('documentClick', e);
+  });
+  $(document).bind('keydown', function(e) {
+    eventBaton.trigger('docKeydown', e);
+  });
+  $(document).bind('keyup', function(e) {
+    eventBaton.trigger('docKeyup', e);
+  });
+  $(window).on('resize', function(e) {
+    events.trigger('resize', e);
+  });
+
+  eventBaton.stealBaton('docKeydown', function() { });
+  eventBaton.stealBaton('docKeyup', function() { });
+
+  // the default action on window focus and document click is to just focus the text area
+  eventBaton.stealBaton('windowFocus', focusTextArea);
+  eventBaton.stealBaton('documentClick', focusTextArea);
+
+  // but when the input is fired in the text area, we pipe that to whoever is
+  // listenining
+  var makeKeyListener = function(name) {
+    return function() {
+      var args = [name];
+      Array.prototype.slice.apply(arguments).forEach(function(arg) {
+        args.push(arg);
+      });
+      eventBaton.trigger.apply(eventBaton, args);
+    };
+  };
+
+  $('#commandTextField').on('keydown', makeKeyListener('keydown'));
+  $('#commandTextField').on('keyup', makeKeyListener('keyup'));
+  $(window).trigger('resize');
+};
+
+var initDemo = function(sandbox) {
+  var params = util.parseQueryString(window.location.href);
+
+  // being the smart programmer I am (not), I don't include a true value on demo, so
+  // I have to check if the key exists here
+  var commands;
+  if (/(iPhone|iPod|iPad).*AppleWebKit/i.test(navigator.userAgent) || /android/i.test(navigator.userAgent)) {
+    sandbox.mainVis.customEvents.on('gitEngineReady', function() {
+      eventBaton.trigger('commandSubmitted', 'mobile alert');
+    });
+  }
+
+  if (params.hasOwnProperty('demo')) {
+    commands = [
+      "git commit; git checkout -b bugFix C1; git commit; git merge main; git checkout main; git commit; git rebase bugFix;",
+      "delay 1000; reset;",
+      "level advanced1 --noFinishDialog --noStartCommand --noIntroDialog;",
+      "delay 2000; show goal; delay 1000; hide goal;",
+      "git checkout bugFix; git rebase main; git checkout side; git rebase bugFix;",
+      "git checkout another; git rebase side; git rebase another main;",
+      "help; levels"
+    ];
+  } else if (params.hasOwnProperty('hgdemo')) {
+    commands = [
+      'importTreeNow {"branches":{"main":{"target":"C3","id":"main"},"feature":{"target":"C2","id":"feature"},"debug":{"target":"C4","id":"debug"}},"commits":{"C0":{"parents":[],"id":"C0","rootCommit":true},"C1":{"parents":["C0"],"id":"C1"},"C2":{"parents":["C1"],"id":"C2"},"C3":{"parents":["C1"],"id":"C3"},"C4":{"parents":["C2"],"id":"C4"}},"HEAD":{"target":"feature","id":"HEAD"}}',
+      'delay 1000',
+      'git rebase main',
+      'delay 1000',
+      'undo',
+      'hg book',
+      'delay 1000',
+      'hg rebase -d main'
+    ];
+    commands = commands.join(';#').split('#'); // hax
+  } else if (params.hasOwnProperty('hgdemo2')) {
+    commands = [
+      'importTreeNow {"branches":{"main":{"target":"C3","id":"main"},"feature":{"target":"C2","id":"feature"},"debug":{"target":"C4","id":"debug"}},"commits":{"C0":{"parents":[],"id":"C0","rootCommit":true},"C1":{"parents":["C0"],"id":"C1"},"C2":{"parents":["C1"],"id":"C2"},"C3":{"parents":["C1"],"id":"C3"},"C4":{"parents":["C2"],"id":"C4"}},"HEAD":{"target":"debug","id":"HEAD"}}',
+      'delay 1000',
+      'git rebase main',
+      'delay 1000',
+      'undo',
+      'hg sum',
+      'delay 1000',
+      'hg rebase -d main'
+    ];
+    commands = commands.join(';#').split('#'); // hax
+  } else if (params.hasOwnProperty('remoteDemo')) {
+    commands = [
+      'git clone',
+      'git commit',
+      'git fakeTeamwork',
+      'git pull',
+      'git push',
+      'git commit',
+      'git fakeTeamwork',
+      'git pull --rebase',
+      'git push',
+      'levels'
+    ];
+    commands = commands.join(';#').split('#'); // hax
+  } else if (params.gist_level_id) {
+    $.ajax({
+      url: 'https://api.github.com/gists/' + params.gist_level_id,
+      type: 'GET',
+      dataType: 'jsonp',
+      success: function(response) {
+        var data = response.data || {};
+        var files = data.files || {};
+        if (!Object.keys(files).length) {
+          console.warn('no files found');
+          return;
+        }
+        var file = files[Object.keys(files)[0]];
+        if (!file.content) {
+          console.warn('file empty');
+        }
+        eventBaton.trigger(
+          'commandSubmitted',
+          'importLevelNow ' + escape(file.content) + '; clear; show goal;'
+        );
+      }
+    });
+  } else if (!params.hasOwnProperty('NODEMO')) {
+    commands = [
+      "help;",
+      "levels"
+    ];
+  }
+  if (params.hasOwnProperty('STARTREACT')) {
+    /*
+    ReactDOM.render(
+      React.createElement(CommandView, {}),
+      document.getElementById(params['STARTREACT'])
+      );*/
+  }
+  if (commands) {
+    sandbox.mainVis.customEvents.on('gitEngineReady', function() {
+      eventBaton.trigger('commandSubmitted', commands.join(''));
+    });
+  }
+
+  if (params.locale !== undefined && params.locale.length) {
+    LocaleActions.changeLocaleFromURI(params.locale);
+  } else {
+    tryLocaleDetect();
+  }
+
+  insertAlternateLinks();
+
+  if (params.command) {
+    var command = unescape(params.command);
+    sandbox.mainVis.customEvents.on('gitEngineReady', function() {
+      eventBaton.trigger('commandSubmitted', command);
+    });
+  }
+
+};
+
+function tryLocaleDetect() {
+  // use navigator to get the locale setting
+  changeLocaleFromHeaders(navigator.language || navigator.browserLanguage);
+}
+
+function changeLocaleFromHeaders(langString) {
+  LocaleActions.changeLocaleFromHeader(langString);
+}
+
+if (require('../util').isBrowser()) {
+  // this file gets included via node sometimes as well
+  $(document).ready(init);
+}
+
+/**
+  * the UI method simply bootstraps the command buffer and
+  * command prompt views. It only interacts with user input
+  * and simply pipes commands to the main events system
+**/
+function CommandUI() {
+  Backbone.$ = $; // lol WTF BACKBONE MANAGE YOUR DEPENDENCIES
+  var Views = require('../views');
+  var Collections = require('../models/collections');
+  var CommandViews = require('../views/commandViews');
+  var CommandHistoryView = require('../react_views/CommandHistoryView.jsx');
+  var MainHelperBarView = require('../react_views/MainHelperBarView.jsx');
+
+  this.commandCollection = new Collections.CommandCollection();
+  this.commandBuffer = new Collections.CommandBuffer({
+    collection: this.commandCollection
+  });
+
+  this.commandPromptView = new CommandViews.CommandPromptView({
+    el: $('#commandLineBar')
+  });
+
+  ReactDOM.render(
+    React.createElement(MainHelperBarView),
+    document.getElementById('helperBarMount')
+  );
+  ReactDOM.render(
+    React.createElement(
+      CommandHistoryView,
+      { commandCollection: this.commandCollection }
+    ),
+    document.getElementById('commandDisplay')
+  );
+}
+
+exports.getEvents = function() {
+  return events;
+};
+
+exports.getSandbox = function() {
+  return sandbox;
+};
+
+exports.getEventBaton = function() {
+  return eventBaton;
+};
+
+exports.getCommandUI = function() {
+  return commandUI;
+};
+
+exports.getLevelDropdown = function() {
+  return levelDropdown;
+};
+
+exports.init = init;

src/js/commands/index.js

@@ -0,0 +1,208 @@
+var intl = require('../intl');
+
+var Errors = require('../util/errors');
+var GitCommands = require('../git/commands');
+var MercurialCommands = require('../mercurial/commands');
+
+var CommandProcessError = Errors.CommandProcessError;
+var CommandResult = Errors.CommandResult;
+
+var commandConfigs = {
+  'git': GitCommands.commandConfig,
+  'hg': MercurialCommands.commandConfig
+};
+
+var commands = {
+  execute: function(vcs, name, engine, commandObj) {
+    if (!commandConfigs[vcs][name]) {
+      throw new Error('i don\'t have a command for ' + name);
+    }
+    var config = commandConfigs[vcs][name];
+    if (config.delegate) {
+      return this.delegateExecute(config, engine, commandObj);
+    }
+
+    config.execute.call(this, engine, commandObj);
+  },
+
+  delegateExecute: function(config, engine, commandObj) {
+    // we have delegated to another vcs command, so lets
+    // execute that and get the result
+    var result = config.delegate.call(this, engine, commandObj);
+
+    if (result.multiDelegate) {
+      // we need to do multiple delegations with
+      // a different command at each step
+      result.multiDelegate.forEach(function(delConfig) {
+        // copy command, and then set opts
+        commandObj.setOptionsMap(delConfig.options || {});
+        commandObj.setGeneralArgs(delConfig.args || []);
+
+        commandConfigs[delConfig.vcs][delConfig.name].execute.call(this, engine, commandObj);
+      }, this);
+    } else {
+      config = commandConfigs[result.vcs][result.name];
+      // commandObj is PASSED BY REFERENCE
+      // and modified in the function
+      commandConfigs[result.vcs][result.name].execute.call(this, engine, commandObj);
+    }
+  },
+
+  blankMap: function() {
+    return {git: {}, hg: {}};
+  },
+
+  getShortcutMap: function() {
+    var map = this.blankMap();
+    this.loop(function(config, name, vcs) {
+      if (!config.sc) {
+        return;
+      }
+      map[vcs][name] = config.sc;
+    }, this);
+    return map;
+  },
+
+  getOptionMap: function() {
+    var optionMap = this.blankMap();
+    this.loop(function(config, name, vcs) {
+      var displayName = config.displayName || name;
+      var thisMap = {};
+      // start all options off as disabled
+      (config.options || []).forEach(function(option) {
+        thisMap[option] = false;
+      });
+      optionMap[vcs][displayName] = thisMap;
+    });
+    return optionMap;
+  },
+
+  getRegexMap: function() {
+    var map = this.blankMap();
+    this.loop(function(config, name, vcs) {
+      var displayName = config.displayName || name;
+      map[vcs][displayName] = config.regex;
+    });
+    return map;
+  },
+
+  /**
+   * which commands count for the git golf game
+   */
+  getCommandsThatCount: function() {
+    var counted = this.blankMap();
+    this.loop(function(config, name, vcs) {
+      if (config.dontCountForGolf) {
+        return;
+      }
+      counted[vcs][name] = config.regex;
+    });
+    return counted;
+  },
+
+  loop: function(callback, context) {
+    Object.keys(commandConfigs).forEach(function(vcs) {
+      var commandConfig = commandConfigs[vcs];
+      Object.keys(commandConfig).forEach(function(name) {
+        var config = commandConfig[name];
+        callback(config, name, vcs);
+      });
+    });
+  }
+};
+
+var parse = function(str) {
+  var vcs;
+  var method;
+  var options;
+
+  // see if we support this particular command
+  var regexMap = commands.getRegexMap();
+  Object.keys(regexMap).forEach(function (thisVCS) {
+    var map = regexMap[thisVCS];
+    Object.keys(map).forEach(function(thisMethod) {
+      var regex = map[thisMethod];
+      if (regex.exec(str)) {
+        vcs = thisVCS;
+        method = thisMethod;
+        // every valid regex has to have the parts of
+        // <vcs> <command> <stuff>
+        // because there are always two space-groups
+        // before our "stuff" we can simply
+        // split on space-groups and grab everything after
+        // the second:
+        options = str.match(/('.*?'|".*?"|\S+)/g).slice(2);
+      }
+    });
+  });
+
+  if (!method) {
+    return false;
+  }
+
+  // we support this command!
+  // parse off the options and assemble the map / general args
+  var parsedOptions = new CommandOptionParser(vcs, method, options);
+  var error = parsedOptions.explodeAndSet();
+  return {
+    toSet: {
+      generalArgs: parsedOptions.generalArgs,
+      supportedMap: parsedOptions.supportedMap,
+      error: error,
+      vcs: vcs,
+      method: method,
+      options: options,
+      eventName: 'processGitCommand'
+    }
+  };
+};
+
+/**
+ * CommandOptionParser
+ */
+function CommandOptionParser(vcs, method, options) {
+  this.vcs = vcs;
+  this.method = method;
+  this.rawOptions = options;
+
+  this.supportedMap = commands.getOptionMap()[vcs][method];
+  if (this.supportedMap === undefined) {
+    throw new Error('No option map for ' + method);
+  }
+
+  this.generalArgs = [];
+}
+
+CommandOptionParser.prototype.explodeAndSet = function() {
+  for (var i = 0; i < this.rawOptions.length; i++) {
+    var part = this.rawOptions[i];
+
+    if (part.slice(0,1) == '-') {
+      // it's an option, check supportedMap
+      if (this.supportedMap[part] === undefined) {
+        return new CommandProcessError({
+          msg: intl.str(
+            'option-not-supported',
+            { option: part }
+          )
+        });
+      }
+
+      var next = this.rawOptions[i + 1];
+      var optionArgs = [];
+      if (next && next.slice(0,1) !== '-') {
+        // only store the next argument as this
+        // option value if its not another option
+        i++;
+        optionArgs = [next];
+      }
+      this.supportedMap[part] = optionArgs;
+    } else {
+      // must be a general arg
+      this.generalArgs.push(part);
+    }
+  }
+};
+
+exports.commands = commands;
+exports.parse = parse;

src/js/constants/AppConstants.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var keyMirror = require('../util/keyMirror');
+
+var CHANGE_EVENT = 'change';
+
+module.exports = {
+
+  CHANGE_EVENT: CHANGE_EVENT,
+
+  StoreSubscribePrototype: {
+    subscribe: function(cb) {
+      this.on(CHANGE_EVENT, cb);
+    },
+
+    unsubscribe: function(cb) {
+      this.removeListener(CHANGE_EVENT, cb);
+    }
+  },
+
+  ActionTypes: keyMirror({
+    SET_LEVEL_SOLVED: null,
+    RESET_LEVELS_SOLVED: null,
+    CHANGE_IS_ANIMATING: null,
+    CHANGE_FLIP_TREE_Y: null,
+    SUBMIT_COMMAND: null,
+    CHANGE_LOCALE: null,
+    CHANGE_LOCALE_FROM_HEADER: null,
+    DISABLE_LEVEL_INSTRUCTIONS: null,
+    /**
+     * only dispatched when you actually
+     * solve the level, not ask for solution
+     * or solve it again.
+     */
+    SOLVE_LEVEL: null
+  }),
+
+  PayloadSources: keyMirror({
+    VIEW_ACTION: null,
+    URI_ACTION: null
+  })
+};

src/js/dialogs/confirmShowSolution.js

@@ -0,0 +1,192 @@
+exports.dialog = {
+  'en_US': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Are you sure you want to see the solution?',
+        '',
+        'I believe in you! You can do it'
+      ]
+    }
+  }],
+  'de_DE': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bist du sicher, dass du die Auflösung sehen willst?',
+        '',
+        'Ich glaube an dich! Du schaffst das!'
+      ]
+    }
+  }],
+  'zh_CN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 确定要看答案吗？',
+        '',
+        '相信自己，你可以的！'
+      ]
+    }
+  }],
+  'zh_TW': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 確定偷看解答嗎？',
+        '',
+        '我相信你！你可以的'
+      ]
+    }
+  }],
+  'es_AR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¿Realmente querés ver la solución?',
+        '',
+        '¡Creo en vos! ¡Dale que podés!'
+      ]
+    }
+  }],
+  'es_MX': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¿Estás seguro de que quieres ver la solución?',
+        '',
+        '¡Creo en ti! ¡Yo sé que puedes!'
+      ]
+    }
+  }],
+  'es_ES': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¿Estás seguro de que quieres ver la solución?',
+        '',
+        '¡Creo en ti! ¡Ánimo!'
+      ]
+    }
+  }],
+  'pt_BR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Tem certeza que quer ver a solução?',
+        '',
+        'Vamos lá, acredito que você consegue!'
+      ]
+    }
+  }],
+  'gl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¿Queres ver a solución?',
+        '',
+        'Seguro que podes, ¡inténtao unha vez máis!'
+      ]
+    }
+  }],
+  'fr_FR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Êtes-vous sûr de vouloir voir la solution ?',
+        '',
+        'Je crois en vous ! Vous pouvez le faire !'
+      ]
+    }
+  }],
+  'ja': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## どうしても正解がみたいですか?',
+        '',
+        '頑張れ頑張れできるできる絶対できる頑張れもっとやれるって',
+        '',
+        'やれる気持ちの問題だ頑張れ頑張れそこだ！',
+        '',
+        'そこで諦めるな絶対に頑張れ積極的にポジティブに頑張る頑張る',
+        '',
+        '北京だって頑張ってるんだから！'
+      ]
+    }
+  }],
+  'ru_RU': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Уверен, что хочешь посмотреть решение?',
+        '',
+        'Мы верим в тебя! Не прыгай! Ты сможешь!'
+      ]
+    }
+  }],
+  'uk': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Впевнений, що хочеш побачити розв’язок?',
+        '',
+        'Я вірю в тебе! Ти впораєшся!'
+      ]
+    }
+  }],
+  'vi': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bạn chắc là muốn xem đáp án chứ?',
+        '',
+        'Tôi tin ở bạn! Bạn có thể làm được!'
+      ]
+    }
+  }],
+  'sl_SI': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Si prepričan, da hočeš videti rešitev?',
+        '',
+        'Verjamem vate! Maš ti to! Ali pač ne?'
+      ]
+    }
+  }],
+  'pl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Czy na pewno chcesz zobaczyć rozwiązanie?',
+        '',
+        'Wierzę w Ciebie! Możesz to zrobić'
+      ]
+    }
+  }],
+    'ta_IN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## நீங்கள் நிச்சயமாக தீர்வை காண விரும்புகிறீர்களா?',
+        '',
+        'நான் உங்களால் அதை செய்ய முடியும் என நினைக்கிறேன்!'
+      ]
+    }
+  }],
+    "it_IT": [
+    {
+      type: "ModalAlert",
+      options: {
+        markdowns: [
+          "## Sicuro di voler sbirciare la soluzione?",
+          "",
+          "Io credo in te, dai che ce la fai!",
+        ],
+      },
+    },
+  ],
+};
+
+

src/js/dialogs/levelBuilder.js

@@ -0,0 +1,368 @@
+exports.dialog = {
+  'en_US': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Welcome to the level builder!',
+        '',
+        'Here are the main steps:',
+        '',
+        '  * Set up the initial environment with git commands',
+        '  * Define the starting tree with ```define start```',
+        '  * Enter the series of git commands that compose the (optimal) solution',
+        '  * Define the goal tree with ```define goal```. Defining the goal also defines the solution',
+        '  * Optionally define a hint with ```define hint```',
+        '  * Edit the name with ```define name```',
+        '  * Optionally define a nice start dialog with ```edit dialog```',
+        '  * Enter the command ```finish``` to output your level JSON!'
+      ]
+    }
+  }],
+  'de_DE': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Willkommen zum Level-Editor!',
+        '',
+        'So funktioniert\'s:',
+        '',
+        '  * Stelle mit Git-Befehlen die Ausgangssituation her',
+        '  * Leg den Startpunkt mit ```define start``` fest',
+        '  * Gib eine Abfolge von Git-Befehlen ein, welche die (optimale) Lösung darstellen',
+        '  * Leg den Ziel-Baum mit ```define goal``` fest. Damit markierst du den Endpunkt der Lösung',
+        '  * Gib einen Hinweis mittels ```define hint``` an, wenn du willst',
+        '  * Änder den Namen mittels ```define name```',
+        '  * Wenn du magst, erstelle einen schönen Einführungsdialog mit ```edit dialog```',
+        '  * Gib das Kommando ```finish``` ein um deinen Level als JSON auszugeben'
+      ]
+    }
+  }],
+  'zh_CN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 欢迎使用关卡生成器！',
+        '',
+        '关键步骤如下：',
+        '',
+        '  * 用 Git 命令建立初始环境',
+        '  * 用 ```define start``` 命令定义初始提交树',
+        '  * 输入一系列 Git 命令作为（最佳）答案',
+        '  * 用 ```define goal``` 命令定义目标提交树。定义目标的同时也定义了答案',
+        '  * （选做）还可以用 ```define hint``` 命令定义提示',
+        '  * 用 ```define name``` 命令设置关卡名称',
+        '  * （选做）还可以用 ```edit dialog``` 定义一个漂亮的开始对话框',
+        '  * 用 ```finish``` 命令就可以输出你的关卡的JSON数据了！'
+      ]
+    }
+  }],
+  'zh_TW': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 歡迎使用關卡編輯器！',
+        '',
+        '主要步驟如下：',
+        '',
+        '  * 使用 git 指令建立初始環境',
+        '  * 使用 ```define start``` 指令定義起始樹',
+        '  * 輸入一系列 git 命令，編好答案',
+        '  * 使用 ```define goal``` 指令定義目標樹。定義目標的同時定義答案',
+        '  * 還可以用 ```define hint``` 指令定義一個提示',
+        '  * 用 ```define name``` 修改名稱',
+        '  * 還可以用 ```edit dialog``` 定義一個漂亮的開始對話視窗',
+        '  * 輸入 ```finish``` 即可將您的關卡輸出為 JSON！'
+      ]
+    }
+  }],
+  'es_AR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Te damos la bienvenida al constructor de niveles!',
+        '',
+        'Estos son los pasos principales:',
+        '',
+        '  * Prepará el entorno inicial usando comandos de Git',
+        '  * Definí el árbol inicial con ```define start```',
+        '  * Ingresá la serie de comandos de git que representan la solución óptima',
+        '  * Definí el árbol objetivo con ```define goal```. El objetivo también determina la solución',
+        '  * Opcionalmente, definí pistas con ```define hint```',
+        '  * Dale un nombre con ```define name```',
+        '  * Opcionalmente, definí un mensaje inicial con ```edit dialog```',
+        '  * ¡Ingresá el comando ```finish``` para obtener tu nivel en formato JSON!'
+      ]
+    }
+  }],
+  'es_MX': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Bienvenido al constructor de niveles!',
+        '',
+        'Estos son los pasos principales:',
+        '',
+        '  * Preparar el entorno inicial usando comandos de Git',
+        '  * Definir el árbol inicial con ```define start```',
+        '  * Introducir la serie de comandos de git que representan la solución óptima',
+        '  * Crear el árbol objetivo con ```define goal```. El objetivo también determina la solución',
+        '  * Opcionalmente, crea pistas con ```define hint```',
+        '  * Dale un nombre con ```define name```',
+        '  * Opcionalmente, crea un mensaje inicial con ```edit dialog```',
+        '  * ¡Introduce el comando ```finish``` para obtener tu nivel en formato JSON!'
+      ]
+    }
+  }],
+  'es_ES': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Bienvenido al constructor de niveles!',
+        '',
+        'Estos son los pasos principales:',
+        '',
+        '  * Prepara el entorno inicial usando comandos de Git',
+        '  * Define el árbol inicial con ```define start```',
+        '  * Introduce la serie de comandos de git que representan la solución óptima',
+        '  * Crea el árbol objetivo con ```define goal```. El objetivo también determina la solución',
+        '  * Opcionalmente, crea pistas con ```define hint```',
+        '  * Dale un nombre con ```define name```',
+        '  * Opcionalmente, crea un mensaje inicial con ```edit dialog```',
+        '  * ¡Introduce el comando ```finish``` para obtener tu nivel en formato JSON!'
+      ]
+    }
+  }],
+  'pt_BR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bem-vindo ao construtor de níveis!',
+        '',
+        'Estes são os passos principais:',
+        '',
+        '  * Prepare o ambiente inicial usando comandos do Git',
+        '  * Define a árvore inicial com ```define start```',
+        '  * Insira a série de comandos do git que representam a solução ótima',
+        '  * Defina a árvore objetivo com ```define goal```. O objetivo também determina a solução',
+        '  * Opcionalmente, defina dicas com ```define hint```',
+        '  * Dê um nome com ```define name```',
+        '  * Opcionalmente, defina uma mensagem inicial com ```edit dialog```',
+        '  * Digite o comando ```finish``` para obter seu nível em formato JSON!'
+      ]
+    }
+  }],
+  'gl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Benvido ó constructor de niveis!',
+        '',
+        'Estes son os pasos principais:',
+        '',
+        '  * Prepara o eido inicial usando comandos de Git',
+        '  * Define a árbore inicial con ```define start```',
+        '  * Inserta a secuencia de comandos de git que representan a mellor solución',
+        '  * Define a árbore obxectivo con ```define goal```. O obxectivo tamén determina a solución',
+        '  * Opcionalmente, define axudas con ```define hint```',
+        '  * Dalle un nome con ```define name```',
+        '  * Opcionalmente, define unha mensaxe inicial con ```edit dialog```',
+        '  * Escribe o comando ```finish``` para obter seu nivel en formato JSON!'
+      ]
+    }
+  }],
+  'fr_FR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bienvenue dans l\'éditeur niveaux !',
+        '',
+        'Voici les étapes principales :',
+        '',
+        '  * Mettez en place l\'environnement initial avec des commandes git',
+        '  * Définissez l\'arbre de départ avec ```define start```',
+        '  * Saisissez la série de commandes git qui composent la solution (optimale)',
+        '  * Définissez l\'arbre cible avec ```define goal```. Cela définit aussi la solution',
+        '  * Optionnellement, définissez un indice avec ```define hint```',
+        '  * Changez le nom avec ```define name```',
+        '  * Optionellement, definissez un joli dialogue de départ avec ```edit dialog```',
+        '  * Entrez la commande ```finish``` pour délivrer votre niveau JSON!'
+      ]
+    }
+  }],
+  'ja': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Levelエディタへようこそ!',
+        '',
+        'ここでは、以下の主にステップを踏みます:',
+        '',
+        '  * Gitコマンドで初期設定をします',
+        '  * ```define start```で開始時のコミットツリーを定義します',
+        '  * 一連のGitコマンドの（最適な）解答を入力します',
+        '  * ```define goal```でゴールのコミットツリーを定義します（ゴールを定義するということは、解答を定義するということでもあります）',
+        '  * オプションで```define hint```でヒントを定義します',
+        '  * ```define name```で名前を編集します',
+        '  * オプションで```edit dialog```で良い感じに開始時のダイアログを定義します',
+        '  * ```finish```コマンドを打つことであなたのlevelがJSONで出力されます',
+        '',
+        '*Note: このダイアログは`help builder`で何回でも表示できます！活用してください！*'
+      ]
+    }
+  }],
+  'ru_RU': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Добро пожаловать в конструктор уровней!',
+        '',
+        'Вот основные шаги:',
+        '',
+        '  * Настроить стартовое дерево при помощи команд git',
+        '  * Обозначить старовое дерево при помощи ```define start```',
+        '  * Ввести команды "оптимального" решения уровня',
+        '  * Обозначить цель уровня при помощи ```define goal```. Одновременно обозначится решение.',
+        '  * По желанию, можно указать подсказку при помощи ```define hint```',
+        '  * Указать название уровня при помощи ```define name```',
+        '  * По желанию, указать стартовое сообщение при помощи ```edit dialog```',
+        '  * Ввести ```finish``` и получить JSON с описанием уровня!'
+      ]
+    }
+  }],
+  'uk': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Ласкаво просимо до конструктора рівнів!',
+        '',
+        'Ось основні кроки:',
+        '',
+        '  * Налаштувати початкове середовище за допомогою команд git',
+        '  * Визначити стартове дерево за допомогою ```define start```',
+        '  * Ввести набір команд, що описують (оптимальний) розв’язок',
+        '  * Визначити кінцеве дерево за допомогою ```define goal```. Одночасно це визначить розв’язок',
+        '  * Додатково можна задати підказку за допомогою ```define hint```',
+        '  * Редагувати назву рівня за допомогою ```define name```',
+        '  * Додатково можна вказати файний початковий діалог за допомогою ```edit dialog```',
+        '  * Ввести команду ```finish``` й отримати JSON з описом рівня!'
+      ]
+    }
+  }],
+  'ko': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 레벨 생성기 입니다. 환영합니다!',
+        '',
+        'Here are the main steps:',
+        '',
+        '  * git 명령어로 초기 환경을 만들어주세요',
+        '  * 시작 트리를 ```define start```로 정의하세요',
+        '  * (최적화된)정답을 만드는 git 명령어들을 입력하세요',
+        '  * 골 트리를 ```define goal```로 정의해주세요. 골을 정의하면 정답도 같이 정의됩니다',
+        '  * ```define hint```로 원하면 힌트도 정의해줄수 있습니다',
+        '  * 문제의 이름을 ```define name```로 수정하세요',
+        '  * 시작 글이 필요하다면 ```edit dialog```로 쓸 수 있습니다',
+        '  * ```finish```로 여러분의 레벨을 JSON결과로 받을 수 있습니다!'
+      ]
+    }
+  }],
+  'vi': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Chào mừng đến trình tạo cấp độ!',
+        '',
+        'Có những bước chính sau:',
+        '',
+        '  * Khởi tạo môi trường với các lệnh git',
+        '  * Định nghĩa cây để bắt đầu với ```define start```',
+        '  * Nhập chuỗi lệnh git để tạo đáp án (tốt nhất) của bạn',
+        '  * Định nghĩa cây mục tiêu với ```define goal```. Định nghĩa mục tiêu đồng thời cũng xác định đáp án',
+        '  * Có thể định nghĩa gợi ý với ```define hint```',
+        '  * Chỉnh sửa tên với ```define name```',
+        '  * Có thể định nghĩa hội thoại bắt đầu với ```edit dialog```',
+        '  * Nhập lệnh ```finish``` xuất cấp độ của bạn dưới dạng JSON!'
+      ]
+    }
+  }],
+  'sl_SI': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Dobrodošel v graditelju stopenj!',
+        '',
+        'Tu so glavni koraki:',
+        '',
+        '  * Postavi začetno stanje z git ukazi',
+        '  * Določi začetno drevo z ```define start```',
+        '  * Vnesi zaporedje ukazov, ki predstavljajo (najboljšo) rešitev',
+        '  * Določi ciljno drevo z ```define goal```. Določanje cilja določi tudi rešitev',
+        '  * Opcijsko določi namig z ```define hint```',
+        '  * Uredi ime z ```define name```',
+        '  * Opcijsko določi ličen začetni dialog z ```edit dialog```',
+        '  * Vnesi ukaz ```finish``` za ustvarjanje JSON različice tvoje stopnje!'
+      ]
+    }
+  }],
+  'pl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Witamy w kreatorze poziomów!',
+        '',
+        'Oto główne kroki:',
+        '',
+        '  * Przygotuj środowisko początkowe za pomocą poleceń GIT-a',
+        '  * Zdefiniuj drzewo początkowe za pomocą ```define start```',
+        '  * Wprowadź serię poleceń GIT-a, które tworzą (optymalne) rozwiązanie',
+        '  * Utwórz drzewo celów za pomocą ```define goal```. Określenie celu określa również rozwiązanie',
+        '  * Opcjonalnie utwórz podpowiedzi (wskazówkę) za pomocą ```define hint```',
+        '  * Nadaj nazwę za pomocą ```define name```',
+        '  * Opcjonalnie, utwórz wiadomość początkową za pomocą ```edit dialog```',
+        '  * Wpisz polecenie ```finish```, aby wyświetlić swój poziom w JSON!'
+      ]
+    }
+  }],
+    'ta_IN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## நிலைகளை நிருவகிக்கும் கட்டமைப்பிற்க்கு வருக!',
+        '',
+        'அடிப்படை நடைமுறைகள்:',
+        '',
+        '  * முதலாவதாக ஆரம்ப சூழலை git கட்டளைகள் கொன்டுகொன்டு அமைக்கவும்.',
+        '  * ```define start``` தொடக்க செயல் முறையை வரையறுக்கவும்.',
+        '  * உகந்த தீர்வினை அடையும் git கட்டளைகளின் தொடரை உள்ளிடவும்.',
+        '  * ```define goal``` கொண்டு இலக்கினை அடையும் கிளை வரைமுரைகளை தீர்வுடன் அமைக்கவும்.',
+        '  * தேவை எனில் ```define hint``` கொண்டு உதவி குறிப்பை வரையறுக்கவும்.',
+        '  * ```define name``` கொண்டு பெயரைத் திருத்தவும்.',
+        '  * தேவை எனில் ```edit dialog``` கொண்டு ஒரு நல்ல முன்னுறையை வரையறுக்கவும்.',
+        '  * ```finish``` கொண்டு இந்த நிலையின் JSON!-ஐ அச்சிடுக.'
+      ]
+    }
+  }],
+   "it_IT": [
+    {
+      type: "ModalAlert",
+      options: {
+        markdowns: [
+          "## Benvenuto al generatore di livelli !",
+          "",
+          "Ecco i passaggi principali:",
+          "",
+          "  * Inizializza l'ambiente con i comandi git",
+          "  * Definisci l'albero di partenza con ```define start```",
+          "  * Inserisci la serie di comandi git che compongono la soluzione (ottimale)",
+          "  * Definisci l'albero finale da ottenere con ```define goal```. L'albero finale costituisce la soluzione",
+          "  * E' possibile inserire un suggerimento con ```define hint```",
+          "  * Modifica il nome con ```define name```",
+          "  * E' possibile personalizzare la finestra iniziale con ```edit dialog```",
+          "  * Inserire il comando ```finish``` per generare il livello JSON!",
+        ],
+      },
+    },
+  ],
+};
+

src/js/dialogs/nextLevel.js

@@ -0,0 +1,216 @@
+exports.dialog = {
+  'en_US': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Great Job!!',
+        '',
+        'You solved the level in *{numCommands}* command(s); ',
+        'our solution uses {best}.'
+      ]
+    }
+  }],
+  'de_DE': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Super gemacht',
+        '',
+        'Du hast den Level in *{numCommands}* Befehl(en) gelöst;',
+        'meine Lösung besteht aus {best}.'
+      ]
+    }
+  }],
+  'ja': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 完成!',
+        '',
+        'あなたは*{numCommands}*回のコマンドでこの課題をクリアしました; ',
+        '模範解答では{best}回です。',
+        '',
+        '模範解答は、右下の`?`メニューの`Solution`から見ることができます。'
+      ]
+    }
+  }],
+  'zh_CN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 好样的！',
+        '',
+        '你用 *{numCommands}* 条命令通过了这一关；',
+        '我们的答案要用 {best} 条命令。'
+      ]
+    }
+  }],
+  'zh_TW': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 太棒了！',
+        '',
+        '您用了 *{numCommands}* 個指令完成這一關，',
+        '我們的解答用了 {best} 個。'
+      ]
+    }
+  }],
+  'es_AR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Buen trabajo!',
+        '',
+        'Resolviste el nivel en *{numCommands}* comandos; ',
+        'nuestra mejor solución usa {best}.'
+      ]
+    }
+  }],
+  'es_MX': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Buen trabajo!',
+        '',
+        'Resolviste el nivel en *{numCommands}* comandos; ',
+        'nuestra mejor solución usa: {best}.'
+      ]
+    }
+  }],
+  'es_ES': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Buen trabajo!',
+        '',
+        'Resolviste el nivel en *{numCommands}* comandos; ',
+        'nuestra mejor solución usa {best}.'
+      ]
+    }
+  }],
+  'pt_BR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bom trabalho!!',
+        '',
+        'Você resolveu o nível usando *{numCommands}* comandos; ',
+        'nossa melhor solução usa {best}.'
+      ]
+    }
+  }],
+  'gl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bo traballo!!',
+        '',
+        'Resolviches o nivel empregando *{numCommands}* comandos; ',
+        'a nosa mellor solución é en {best}.'
+      ]
+    }
+  }],
+  'fr_FR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Beau Travail!!',
+        '',
+        'Vous avez résolu le niveau en *{numCommands}* commande(s); ',
+        'notre solution le fait en {best}.'
+      ]
+    }
+  }],
+  'ru_RU': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Супер!',
+        '',
+        'Ты прошёл уровень. Количество использованных команд - *{numCommands}* ; ',
+        'а наше решение состоит из {best}.'
+      ]
+    }
+  }],
+  'uk': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Молодець!',
+        '',
+        'Ти пройшов рівень. Кількість використаних команд \u2014 *{numCommands}*; ',
+        'наш розв’язок складається з {best}.'
+      ]
+    }
+  }],
+  'ko': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 훌륭합니다!!',
+        '',
+        '*{numCommands}*개의 명령으로 레벨을 통과했습니다; ',
+        '모범 답안은 {best}개를 사용합니다.'
+      ]
+    }
+  }],
+  'vi': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Làm tốt lắm!!',
+        '',
+        'Bạn hoàn thành cấp độ này với *{numCommands}* câu lệnh; ',
+        'Đáp án của chúng tôi sử dụng {best}.'
+      ]
+    }
+  }],
+  'sl_SI': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Dobro opravljeno!!',
+        '',
+        'Rešil si stopnjo z *{numCommands}* ukazi; ',
+        'naša rešitev uporabi {best}.'
+      ]
+    }
+  }],
+  'pl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Dobra robota!!',
+        '',
+        'Rozwiązałeś poziom używając *{numCommands}* poleceń/ia; ',
+        'nasze rozwiązanie składa się z {best}.'
+      ]
+    }
+  }],
+  'ta_IN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ஆக சிரந்த செயல்!!',
+        '',
+        'நீங்கள் *{numCommands}* நிலைக்கான கட்டளை(கள்) கொண்டு தீர்வை அடிந்து விட்டீர்கள்; ',
+        'நமது தீர்வு {best}-ஐ பயன்படுத்து கின்றது.'
+      ]
+    }
+  }],
+   "it_IT": [
+    {
+      type: "ModalAlert",
+      options: {
+        markdowns: [
+          "## Ben fatto!!",
+          "",
+          "Hai risolto il livello con *{numCommands}* comando(i); ",
+          "noi l'abbiamo risolto con {best}.",
+        ],
+      },
+    },
+  ],
+};
+ 

src/js/dialogs/sandbox.js

@@ -0,0 +1,812 @@
+exports.dialog = {
+  'en_US': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Welcome to Learn Git Branching',
+        '',
+        'Interested in learning Git? Well you\'ve come to the right place! ',
+        '"Learn Git Branching" is the most visual and interactive way to learn Git ',
+        'on the web; you\'ll be challenged with exciting levels, given step-by-step ',
+        'demonstrations of powerful features, and maybe even have a bit of fun along the way.',
+        '',
+        'After this dialog you\'ll see the variety of levels we have to offer. If you\'re a ',
+        'beginner, just go ahead and start with the first. If you already know some Git basics, ',
+        'try some of our later more challenging levels.',
+        '',
+        'You can see all the commands available with `show commands` at the terminal.',
+        '',
+        'PS: Want to go straight to a sandbox next time?',
+        'Try out ',
+        '[this special link](https://pcottle.github.io/learnGitBranching/?NODEMO)',
+        '',
+        'PPS: GitHub has started naming the default branch `main` instead of `master` ',
+        'to migrate away from biased terminology [(more details available here)](https://github.com/github/renaming). ',
+        'In accordance with this industry-wide movement, we have also updated "Learn Git Branching" to ',
+        'use `main` instead of `master` in our lessons. This rename should be fairly consistent by ',
+        'now but if you notice any errors, feel free to submit a PR (or open an issue).'
+      ]
+    }
+  }],
+  'es_AR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Te damos la bienvenida a Learn Git Branching!',
+        '',
+        'Esta aplicación está diseñada para ayudar a los principiantes ',
+        'a manejar los poderosos conceptos que hay detrás del trabajo ',
+        'con ramas (branches) en Git. Esperamos que disfrutes la aplicación ',
+        'y tal vez incluso ¡que aprendas algo! ',
+        '',
+        '# ¡Demo!',
+        '',
+        'Si no viste la demo, mirala en esta dirección:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_AR&demo](https://pcottle.github.io/learnGitBranching/?locale=es_AR&demo)',
+        '',
+        '¿Querés dejar de ver este mensaje? Agregale `NODEMO` a la URL para dejar de verlo, como en este link:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_AR&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=es_AR&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Comandos de Git',
+        '',
+        'Tenés una gran variedad de comandos de git en este sandbox. Estos incluyen: ',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Compartí!',
+        '',
+        'Compartí tus árboles con tus amigos usando `export tree` e `import tree`',
+        '',
+        '¿Tenés una buena lección que compartir? Probá construyendo un nivel con `build level` o probá el nivel de un amigo con `import level`',
+        '',
+        'Para ver todos los comandos disponibles, probá `show commands`. Hay algunas joyitas como `undo` y `reset`',
+        '',
+        'Por ahora, arranquemos con los `levels`...'
+      ]
+    }
+  }],
+  'es_MX': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Bienvenid@ a Learn Git Branching!',
+        '',
+        'Esta aplicación está diseñada para ayudar a los principiantes',
+        'a manejar los poderosos conceptos que hay detrás del trabajo',
+        'con ramas (branches) en Git. Esperamos que disfrutes la aplicación',
+        'y tal vez incluso ¡que aprendas algo!',
+        '',
+        '# ¡Demo!',
+        '',
+        'Si no viste la demo, mirala en ésta dirección:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_MX&demo](https://pcottle.github.io/learnGitBranching/?locale=es_MX&demo)',
+        '',
+        '¿Harto de este mensaje? Agregale `NODEMO` a la URL para dejar de verlo, como en éste link:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_MX&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=es_MX&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Comandos de git',
+        '',
+        'Tienes una gran variedad de comandos de git en este sandbox. He aquí una lista de los incluidos:',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Comparte!',
+        '',
+        'Comparte tus árboles con tus amigos usando `export tree` e `import tree`',
+        '',
+        '¿Tienes una buena lección que compartir? Prueba construyendo un nivel con `build level` o prueba el nivel de un amigo con `import level`',
+        '',
+        'Para ver todos los comandos disponibles, prueba `show commands`. Hay algunos muy prácticos como `undo` y `reset`',
+        '',
+        'Por ahora, arranquemos con los `levels`...'
+      ]
+    }
+  }],
+  'es_ES': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Bienvenid@ a Learn Git Branching!',
+        '',
+        'Esta aplicación está diseñada para ayudar a los principiantes ',
+        'a manejar los poderosos conceptos que hay detrás del trabajo ',
+        'con ramas (branches) en Git. Esperamos que disfrutes la aplicación ',
+        'y tal vez incluso ¡que aprendas algo! ',
+        '',
+        '# ¡Demo!',
+        '',
+        'Si no viste la demo, mírala en esta dirección:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_ES&demo](https://pcottle.github.io/learnGitBranching/?locale=es_ES&demo)',
+        '',
+        '¿Harto de este mensaje? Agrégale `NODEMO` a la URL para dejar de verlo, como en este link:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=es_ES&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=es_ES&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Comandos de Git',
+        '',
+        'Tienes una gran variedad de comandos de git en este sandbox. Estos incluyen: ',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ¡Comparte!',
+        '',
+        'Comparte tus árboles con tus amigos usando `export tree` e `import tree`',
+        '',
+        '¿Tienes una buena lección que compartir? Prueba construyendo un nivel con `build level` o prueba el nivel de un amigo con `import level`',
+        '',
+        'Para ver todos los comandos disponibles, escribe `show commands`. Hay algunas joyitas como `undo` y `reset`',
+        '',
+        'Por ahora, empecemos con los `levels`...'
+      ]
+    }
+  }],
+  'pt_BR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bem-vindo ao Learn Git Branching!',
+        '',
+        'Este aplicativo foi desenvolvido para ajudar os iniciantes a ',
+        'aprender os poderosos conceitos por trás do branching com ',
+        'o git. Esperamos que você goste deste aplicativo e talvez ',
+        'até aprenda alguma coisa!',
+        '',
+        '# Demo!',
+        '',
+        'Se você ainda não viu o demo, veja aqui:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=pt_BR&demo](https://pcottle.github.io/learnGitBranching/?locale=pt_BR&demo)',
+        '',
+        'Farto desta mensagem? Acrescente `NODEMO` ao endereço para se livrar dela, como no link abaixo:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=pt_BR&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=pt_BR&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Comandos do git',
+        '',
+        'Você tem à sua disposição no sandbox uma variedade de comandos do git:',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Compartilhar é se importar!',
+        '',
+        'Compartilhe árvores com seus amigos usando `export tree` e `import tree`',
+        '',
+        'Tem uma grande lição para compartilhar? Tente construir um nível com `build level` ou experimente o nível de um amigo com `import level`',
+        '',
+        'Para ver todos os comandos, use `show commands`. Há algumas jóias como `undo` e `reset`',
+        '',
+        'Por hora, vamos começar com o `levels`...'
+      ]
+    }
+  }],
+  'gl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Benvido a Learn Git Branching!',
+        '',
+        'Esta aplicación foi desenvolvida para axudar os iniciados en git a ',
+        'aprender os poderosos conceptos que hai por detrás do branching con ',
+        ' git. Agardamos que disfrutes desta aplicación, e tal vez, ',
+        'ata aprendas algunha cousa!',
+        '',
+        '# Demostracións!',
+        '',
+        'Se aínda non viches a demo, olla aquí:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=gl&demo](https://pcottle.github.io/learnGitBranching/?locale=gl&demo)',
+        '',
+        '¿Farto destas mensaxes? Engade `NODEMO` á dirección para librarte dela, como no link de abaixo:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=gl&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=gl&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Comandos de git',
+        '',
+        'Tes a túa disposición unha caixa de área con unha variedade de comandos de git:',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Compartir e importar!',
+        '',
+        'Comparte árbores cos seus amigas con `export tree` e `import tree`',
+        '',
+        '¿Tes un enlace moi grande para compartir? Intenta construír un nivel con `build level` ou importe o nivel dun amigo con `import level`',
+        '',
+        'Para ver tódolos comandos, usa `show commands`. Hai algunha xoia como `undo` e `reset`',
+        '',
+        'Por agora, imos comezar cos `levels`...'
+      ]
+    }
+  }],
+  'de_DE': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Willkommen bei Learn Git Branching!',
+        '',
+        'Der Sinn dieser Anwendung ist, die umfangreichen und komplexen Zusammenhänge der Prozesse, die bei der Arbeit mit Git ablaufen, zu verdeutlichen. Ich hoffe du hast Spaß dabei und lernst vielleicht sogar etwas!',
+        '',
+        '# Demo!',
+        '',
+        'Falls du die Demonstration noch nicht gesehen hast, schau sie dir hier an:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=de_DE&demo](https://pcottle.github.io/learnGitBranching/?locale=de_DE&demo)',
+        '',
+        'Genervt von diesem Fenster? Häng `NODEMO` an die URL um es los zu werden, so wie hier:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=de_DE&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=de_DE&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Git-Kommandos',
+        '',
+        'Dir steht eine große Zahl von Git-Befehlen im Sandkasten-Modus zur Verfügung. Unter anderem',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Teilen macht Spaß!',
+        '',
+        'Teile diese Git-Bäume mit deinen Freunden mittels `export tree` und `import tree`.',
+        '',
+        'Hast du Wissenswertes zu Git zu vermitteln? Versuch einen Level mit `build level` zu bauen oder probier den Level eines Freundes mit `import level` aus.',
+        '',
+        'Um alle Kommandos zu sehen, gib `show commands` ein. Darunter gibt\'s kleine Schätze wie `undo` und `reset`.',
+        '',
+        'Für\'s Erste lass uns mit `levels` anfangen ...'
+      ]
+    }
+  }],
+  'ja': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Learn Git Branchingへようこそ',
+        '',
+        'gitのパワフルなブランチ機能のコンセプトが ',
+        '学びやすくなるようにこのアプリケーションを作りました。 ',
+        'このアプリケーションを楽しんで使って頂いて、 ',
+        '何かを学習して頂けたなら嬉しいです。',
+        '',
+        '# とりあえず触ってみたい方へ：',
+        '',
+        '簡単なデモを用意してあるので、もしよければこちらもご覧ください：',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=ja&demo](https://pcottle.github.io/learnGitBranching/?demo&locale=ja)',
+        '',
+        'このダイアログ自体を省略するには、以下のようにURLの末尾にクエリストリング`NODEMO`を付加してアクセスしてください。',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=ja&NODEMO](https://pcottle.github.io/learnGitBranching/?NODEMO&locale=ja)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## ここで学べるGitのオペレーション',
+        '',
+        'ここでは、下記の種類のgitコマンドを学ぶことができます。',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 学習した内容を共有できます',
+        '',
+        '画面左のコマンドプロンプトから`export tree`や`import tree`とタイプすることで、gitのツリー構造を友達に送ることができます',
+        '',
+        '何か教材になるようなケースはご存知ないでしょうか。`build level`で課題を作成したり、`import level`で他の人の課題に挑戦してみてください。',
+        '',
+        '何か詰まったことがあったら、右下メニューの?ボタンを押してみてください',
+        '',
+        'それから、不自然な記号が出てきたときは顔を左方向に傾けてみるといいかもしれません :P（ペロッ）',
+        '',
+        'それでは教材の選択画面に進んでみることにします。',
+        '',
+        '（なお、日本語版製作者のフォークサイトは[こちら](https://remore.github.io/learnGitBranching-ja/)になります。）'
+      ]
+    }
+  }],
+  'zh_CN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 欢迎光临 Learn Git Branching',
+        '',
+        '你对 Git 感兴趣吗？那么算是来对地方了！',
+        '“Learning Git Branching” 可以说是目前为止最好的教程了，在沙盒里你能执行相应的命令，还能看到每个命令的执行情况；',
+        '通过一系列刺激的关卡挑战，逐步深入的学习 Git 的强大功能，在这个过程中你可能还会发现一些有意思的事情。',
+        '',
+        '关闭这个对话框以后，你会看到我们提供的许多关卡。如果你是初学者，从第一关开始逐个向后挑战就是了。',
+        '而如果你已经入门了，可以略过前面，直接挑战后面更有难度的关卡。',
+        '',
+        '### 演示',
+        '',
+        '如果你还没看过演示，请[到此](?demo)查看。',
+        '',
+        'PS：想直接进入沙盒？ 在 URL 后头加上 `NODEMO` 就可以了，试一下[这个链接](https://pcottle.github.io/learnGitBranching/?locale=zh_CN&NODEMO)'
+      ]
+    }
+  }],
+  'zh_TW': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 歡迎光臨 Learn Git Branching!',
+        '',
+        '本應用旨在幫助初學者領會 git 分支背後的強大概念。',
+        '希望你能喜歡這個應用，並學到知識！',
+        '',
+        '# 演示！',
+        '',
+        '如果你還沒看過演示，請到此查看：',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=zh_TW&demo](https://pcottle.github.io/learnGitBranching/?locale=zh_TW&demo)',
+        '',
+        '厭煩這個對話視窗嗎？在 URL 後頭加上 `NODEMO` 就看不到它了，也可以直接點下邊這個連結：',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=zh_TW&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=zh_TW&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Git 命令',
+        '',
+        '在沙盒模式中，你有很多指令可用。包括：',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 分享即關懷',
+        '',
+        '使用 `export tree` 和 `import tree` 與朋友分享 Git 樹',
+        '',
+        '有個好課程可以分享？試試用 `build level` 創建一個關卡，或者 `import level` 試試朋友的。',
+        '',
+        '言歸正傳，讓我們先從 `levels` 開始……'
+      ]
+    }
+  }],
+  'ko': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Git 브랜치 배우기를 시작합니다!',
+        '',
+        '이 애플리케이션은 git을 쓸 때 필요한 브랜치에 대한 개념을',
+        '탄탄히 잡게끔 도와드리기 위해 만들었습니다. 재밌게 사용해주시기를',
+        '바라며, 무언가를 배워가신다면 더 기쁘겠습니다!',
+        '',
+        '이 애플리케이션은 [Peter Cottle](https://github.io/pcottle)님의 [LearnGitBranching](https://pcottle.github.io/learnGitBranching/)를 번역한 것입니다.',
+        '아래 데모를 먼저 보셔도 좋습니다.',
+        '',
+        '<https://pcottle.github.io/learnGitBranching/?demo&locale=ko>'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Git 명령어',
+        '',
+        '연습 모드에서 쓸 수 있는 다양한 git명령어는 다음과 같습니다',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## 공유해주세요!',
+        '',
+        '`export tree` 와 `import tree`로 여러분의 친구들에게 트리를 공유해주세요',
+        '',
+        '훌륭한 학습 자료가 있으신가요? `build level`로 레벨을 만들어 보시거나, 친구의 레벨을 `import level`로 가져와서 실험해보세요',
+        '',
+        '이제 레슨을 시작해봅시다...'
+      ]
+    }
+  }],
+  'fr_FR': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Bienvenue sur Learn Git Branching !',
+        '',
+        'Cette application a été conçue pour aider les débutants à saisir ',
+        'les puissants concepts derrière les branches en travaillant ',
+        'avec git. Nous espérons que vous apprécierez cette application et ',
+        'que vous apprendrez peut-être quelque chose d\'intéressant !',
+        '',
+        '# Démo !',
+        '',
+        'Si vous n\'avez pas vu la démo, vous pouvez le faire là :',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=fr_FR&demo](https://pcottle.github.io/learnGitBranching/?locale=fr_FR&demo)',
+        '',
+        'Agacé par ce dialogue ? Ajoutez `NODEMO` à l\'URL pour le supprimer, en lien ci-dessous pour votre commodité :',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=fr_FR&NODEMO](https://pcottle.github.io/learnGitBranching/?locale=fr_FR&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Commandes Git',
+        '',
+        'Il existe une large variété de commandes git disponibles dans le mode bac à sable. Sont incluses :',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Partager, c\'est se soucier !',
+        '',
+        'Partagez des arbres avec vos amis via `export tree` et `import tree`',
+        '',
+        'Vous avez une grande leçon à partager ? Essayez de construire un niveau avec `build level` ou essayez le niveau d\'un ami avec `import level`',
+        '',
+        'Pour voir la gamme complète des commandes, tapez `show commands`. Il y a quelques perles telles que `undo` et `reset`',
+        '',
+        'Mais tout de suite commencez sur les `levels`…'
+      ]
+    }
+  }],
+  'ru_RU': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Добро пожаловать в LearnGitBranching!',
+        '',
+        'Это приложение создано, чтобы помочь новичкам постичь ',
+        'мощные возможности ветвления и работы ',
+        'с git. Мы надеемся, что вам понравится эта игра ',
+        'и может вы что-то усвоите!',
+        '',
+        '# Демо!',
+        '',
+        'Если ты не видел демонстрацию – посмотри её тут:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=ru_RU&demo](https://pcottle.github.io/learnGitBranching/?locale=ru_RU&demo)',
+        '',
+        'Достало это сообщение? Добавь `NODEMO` к адресу и навсегда забудь о нём, ниже ссылка для удобства:',
+        '',
+        '[https://pcottle.github.io/learnGitBranching/?locale=ru_RU&NODEMO](?locale=ru_RU&NODEMO)'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Команды Git',
+        '',
+        'В нашей песочнице можно использовать множество команд:',
+        '',
+        ' * commit',
+        ' * branch',
+        ' * checkout',
+        ' * cherry-pick',
+        ' * reset',
+        ' * revert',
+        ' * rebase',
+        ' * merge'
+      ]
+    }
+  }, {
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Бог велел – делись!',
+        '',
+        'Ты можешь делиться результатами с друзьями при помощи `export tree` и `import tree`',
+        '',
+        'Хочешь создать классный уровень? Сделай это при помощи `build level` или добавь уровень друга при помощи `import level`',
+        '',
+        'Команда `show commands` покажет все доступные инструкции. Там есть очень полезные, например `undo` и `reset`',
+        '',
+        'А пока просто начни игру при помощи `levels`...'
+      ]
+    }
+  }],
+  'uk': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Ласкаво просимо до Learn Git Branching',
+        '',
+        'Хочеш вивчити Git? Тоді ти знайшов те, що шукав!',
+        '"Learn Git Branching" \u2014 це найбільш візуальний та інтерактивний спосіб вивчення Git в Інтернеті. ',
+        'Ти з��ожеш проходити захопливі рівні, дивитися ',
+        'покрокові інструкції з використання потужних функцій Git, навіть трохи ',
+        'розважитись в процесі навчання.',
+        '',
+        'Після цього діалогу побачиш список доступних рівнів. Якщо ти новачок, ',
+        'просто почни з першого рівня. Якщо вже знаєш основи Git, ',
+        'спробуй більш складні рівні в кінці.',
+        '',
+        'P.S. Хочеш перейти одразу до пісочниці наступного разу?',
+        'Спробуй ',
+        '[це спеціальне посилання.](https://pcottle.github.io/learnGitBranching/?locale=uk&NODEMO)'
+      ]
+    }
+  }],
+  'vi': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Chào mừng đến với Học Nhánh Git',
+        '',
+        'Bạn có hứng thú học Git? Bạn đến đúng nơi rồi đấy! ',
+        '"Học Nhánh Git" là cách trực quan và hiệu quả nhất để học Git trên web; ',
+        'thông qua một loạt các thử thách cấp độ thú vị, bạn sẽ từng bước tìm hiểu sức mạnh của git',
+        '',
+        'Sau khi hội thoại này đóng lại, bạn sẽ thấy nhiều cấp độ mà chúng tôi cung cấp. ',
+        'Nếu bạn là người mới thì hãy bắt đầu từ bài đầu tiên. Nếu bạn đã có hiểu biết cơ bản về git, ',
+        'hãy thử những bài mang tính thách thức hơn phía sau.',
+        '',
+        'Bạn có thể dùng lệnh `show commands` để xem tất cả các lệnh hiện hữu.',
+        '',
+        'Ghi chú: Nếu muốn trực tiếp vào hộp cát ở lần sau?',
+        'Hãy dùng',
+        '[đường link đặc biệt này của chúng tôi](https://pcottle.github.io/learnGitBranching/?locale=vi&NODEMO)'
+      ]
+    }
+  }],
+  'sl_SI': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Dobrodošel na učenju Git Branchanja',
+        '',
+        'Bi se rad naučil Git? No, prišel si na pravo mesto! ',
+        '"Learn Git Branching" je najbolj vizualen in interaktiven način učenja Git-a ',
+        'na spletu; zagrizel boš v zanimive stopnje, po korakih boš spoznaval osupljive ',
+        'funkcije in kaj pa veš, morda ti bo celo zabavno. ;)',
+        '',
+        'Za tem oknom boš videl kopico stopenj, ki so na razpolago. Če si ',
+        'začetnik, kar pogumno, začni s prvo. Če pa že poznaš Git osnove, ',
+        'se preizkusi v zahtevnejših stopnjah.',
+        '',
+        'Vidiš lahko vse ukaze, ki so na voljo, z ukazom `show commands` v terminalu.',
+        '',
+        'PS: Bi šel rad naslednjič naravnost v peskovnik?',
+        'Poizkusi s',
+        '[to posebno povezavo](https://pcottle.github.io/learnGitBranching/?locale=sl_SI&NODEMO)'
+      ]
+    }
+  }],
+  'pl': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Witaj w Learn Git Branching!',
+        '',
+        'Jesteś zainteresowany nauką Gita? Cóż, trafiłeś we właściwe miejsce!',
+        '"Learn Git Branching" jest najbardziej wizualnym i interaktywnym sposobem na naukę gita w sieci.',
+        'Czekają na Ciebie ekscytujące poziomy, demonstracje zaawansowanych funkcji krok po kroku. Może nawet będziesz się dobrze bawić.',
+        '',
+        'Po tym oknie dialogowym zobaczysz różnorodność poziomów, które mamy do zaoferowania.',
+        'Jeśli jesteś początkujący, po prostu zacznij od pierwszego poziomu.',
+        'Jeśli znasz już podstawy gita, wypróbuj niektóre z naszych późniejszych, bardziej wymagających poziomów.',
+        '',
+        'Możesz zobaczyć wszystkie komendy wpisując `show commands` w terminalu.',
+        '',
+        'Chcesz następnym razem przejść prosto do trybu piaskownicy? Kilknij [tutaj](https://pcottle.github.io/learnGitBranching/?locale=pl&NODEMO)',
+        '',
+        'PS. GitHub zaczął nazywać domyślną gałąź `main` zamiast `master`, aby odejść od tendencyjnej terminologii. [(więcej informacji tutaj)](https://github.com/github/renaming)',,
+        'Zgodnie z tym ogólnobranżowym ruchem, zaktualizowaliśmy również "Learn Git Branching", by używać `main` zamiast `master` w naszych zadaniach.',
+        'Ta zmiana nazwy powinna być już w miarę spójna, ale jeśli zauważysz jakieś błędy, nie krępuj się dodać pull request (lub zgłosić issue na githubie - prawy górny róg).'
+      ]
+    }
+  }],
+  'ta_IN': [{
+    type: 'ModalAlert',
+    options: {
+      markdowns: [
+        '## Git Branching கற்க வரவேற்கிறோம்',
+        '',
+        'கிட் கற்க ஆர்வமா? அப்படியானால் நீங்கள் சரியான இடத்திற்கு வந்துவிட்டீர்கள்! ',
+        '"Learn Git Branching" Git ஐக் கற்றுக்கொள்வதற்கான வரைபடம் மற்றும் செயல்முறை ',
+        'பயிற்சியுடன் கூடிய சிரந்த கருவி; ',
+        'உங்களை சோதிக்கும் வகையிலான நிலைகளுடன் மிகுந்த சக்திவாய்ந்த அம்சங்களை ',
+        'படிப்படியாகவும், சில சமையம் விளையாட்டாகவும் கற்றுத்தர கூடியது.',
+        '',
+        'இந்த அறிவிற்ப்புக்கு பிறகு, நாங்கள் வழங்க உள்ள பல்வேறு நிலைகளை நீங்கள் காண்பீர்கள். ',
+        'நீங்கள் ஆரம்ம நிலையில் இருந்தால், முதல் கட்டத்தில் இருந்து  தொடங்கவும். ',
+        'கிட்டின் சில அடிப்படைகளை நீங்கள் ஏற்கனவே அறிந்திருந்தால், மெலும் உள்ள கடினமான கட்டங்களை முயற்ச்சி செய்யுங்கள்.',
+        '',
+        'தேவையானால் `show commands` ஐ பயன்படுத்தி அனைத்து கட்டளைகளையும் முனையத்தில் பார்க்கலாம்.',
+        '',
+        'பின்குறிப்பு: அடுத்தமுறை நேராக sandbox செல்ல வேண்டுமா?',
+        'அப்படியானால் பின் வரும் இணைப்பை பயன்பாடித்துக ',
+        '[this special link](https://pcottle.github.io/learnGitBranching/?locale=ta_IN&NODEMO)',
+        '',
+        'பின்குறிப்பு: GitHub (பெரிய அளவில் பயன்பாட்டில் உள்ள இணையதலம்) `main` என்ற கிளையை `master`-க்கு பதில் ',
+        'முன்னிருப்பு கிளையாக பயன் படுத்த உள்ளது [more details available here](https://github.com/github/renaming). ',
+        'இந்த மாற்றத்தை பின்னோக்கி இணக்கமான வழியில் பொருத்துவதற்காக, `main`-ஐ முதன்மையாக கருதி ',
+        'இந்த இரண்டு பெயர்களும் ஒன்றுக்கொன்று மாற்றுப்பெயர்களாகக் கருதப்படும். ',
+        'இந்த மாற்றத்தை அனைத்து நிலை உள்ளடக்கங்களிலும் புதுப்பிக்க நாங்கள் சிறந்த முயற்சியை ',
+        'மேற்கொண்டோம், ஆயினும் ஏதேனும் விடுபட்டி இருந்தால் PR உருவாக்கி உதவுங்கள்.',
+        'ஒருபக்கச்சார்பான சொற்களிலிருந்து விலகிச் செல்ல உதவியதற்கு நன்றி.'
+      ]
+    }
+  }],
+  "it_IT": [
+    {
+      type: "ModalAlert",
+      options: {
+        markdowns: [
+          "## Benvenuto su Learn Git Branching",
+          "",
+          "Vorresti imparare Git? Bene, sei nel posto giusto! ",
+          '"Learn Git Branching" è il modo più chiaro e interattivo per imparare Git ',
+          "su internet; sarai messo alla prova tramite livelli stimolanti, con dimostrazioni ",
+          "passo a passo sulle sue potenzialità e, perché no, magari ti divertirai lungo questo percorso.",
+          "",
+          "Dopo questa finestra vedrai una varietà di livelli che abbiamo da offrire. Se sei alle",
+          "prime armi procedi e parti dall'inizio. Se hai delle conoscenze base di Git ",
+          "prova con gli ultimi livelli più impegnativi.",
+          "",
+          "Puoi vedere tutti i comandi disponibili digitando `show commands` sul terminale.",
+          "",
+          "PS: Preferisci andare direttamente al sandbox?",
+          "Prova ",
+          "[questo link](https://pcottle.github.io/learnGitBranching/?NODEMO?locale=it_IT).",
+          "",
+          "PPS: GitHub (e il settore in generale) sta modificando il nome del ramo di default in `main` invece che `master` ",
+          "(leggi [qui per ulteriori dettagli](https://github.com/github/renaming)). Per adattarci a questo cambiamento ",
+          "mantenendo la retrocompatibilità, questi nomi saranno considerati equivalenti. `main` sarà comunque ",
+          "il nome predefinito. Ci siamo impegnati per aggiornare tutti i livelli ma ci sarà ",
+          "sicuramente qualcosa che potremmo aver dimenticato. Esegui una PR (o segnala un problema) se ne trovi. ",
+          "Grazie per l'aiuto!",
+        ],
+      },
+    },
+  ],
+};

src/js/dispatcher/AppDispatcher.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var AppConstants = require('../constants/AppConstants');
+var Dispatcher = require('flux').Dispatcher;
+
+var PayloadSources = AppConstants.PayloadSources;
+
+var AppDispatcher = new Dispatcher();
+
+AppDispatcher.handleViewAction = function(action) {
+  this.dispatch({
+    source: PayloadSources.VIEW_ACTION,
+    action: action
+  });
+};
+
+AppDispatcher.handleURIAction = function(action) {
+  this.dispatch({
+    source: PayloadSources.URI_ACTION,
+    action: action
+  });
+};
+
+module.exports = AppDispatcher;

src/js/git/commands.js

@@ -0,0 +1,955 @@
+var escapeString = require('../util/escapeString');
+var intl = require('../intl');
+
+var Graph = require('../graph');
+var Errors = require('../util/errors');
+var CommandProcessError = Errors.CommandProcessError;
+var GitError = Errors.GitError;
+var Warning = Errors.Warning;
+var CommandResult = Errors.CommandResult;
+
+var ORIGIN_PREFIX = 'o/';
+
+var crappyUnescape = function(str) {
+  return str.replace(/'/g, "'").replace(///g, "/");
+};
+
+function isColonRefspec(str) {
+  return str.indexOf(':') !== -1 && str.split(':').length === 2;
+}
+
+var assertIsRef = function(engine, ref) {
+  engine.resolveID(ref); // will throw git error if can't resolve
+};
+
+var validateBranchName = function(engine, name) {
+  return engine.validateBranchName(name);
+};
+
+var validateOriginBranchName = function(engine, name) {
+  return engine.origin.validateBranchName(name);
+};
+
+var validateBranchNameIfNeeded = function(engine, name) {
+  if (engine.refs[name]) {
+    return name;
+  }
+  return validateBranchName(engine, name);
+};
+
+var assertNotCheckedOut = function(engine, ref) {
+  if (!engine.refs[ref]) {
+    return;
+  }
+  if (engine.HEAD.get('target') === engine.refs[ref]) {
+    throw new GitError({
+      msg: intl.todo(
+        'cannot fetch to ' + ref + ' when checked out on ' + ref
+      )
+    });
+  }
+};
+
+var assertIsBranch = function(engine, ref) {
+  assertIsRef(engine, ref);
+  var obj = engine.resolveID(ref);
+  if (!obj || obj.get('type') !== 'branch') {
+    throw new GitError({
+      msg: intl.todo(
+        ref + ' is not a branch'
+      )
+    });
+  }
+};
+
+var assertIsRemoteBranch = function(engine, ref) {
+  assertIsRef(engine, ref);
+  var obj = engine.resolveID(ref);
+
+  if (obj.get('type') !== 'branch' ||
+      !obj.getIsRemote()) {
+    throw new GitError({
+      msg: intl.todo(
+        ref + ' is not a remote branch'
+      )
+    });
+  }
+};
+
+var assertOriginSpecified = function(generalArgs) {
+  if (!generalArgs.length) {
+    return;
+  }
+  if (generalArgs[0] !== 'origin') {
+    throw new GitError({
+      msg: intl.todo(
+        generalArgs[0] + ' is not a remote in your repository! try adding origin to that argument'
+      )
+    });
+  }
+};
+
+var assertBranchIsRemoteTracking = function(engine, branchName) {
+  branchName = crappyUnescape(branchName);
+  if (!engine.resolveID(branchName)) {
+    throw new GitError({
+      msg: intl.todo(branchName + ' is not a branch!')
+    });
+  }
+  var branch = engine.resolveID(branchName);
+  if (branch.get('type') !== 'branch') {
+    throw new GitError({
+      msg: intl.todo(branchName + ' is not a branch!')
+    });
+  }
+
+  var tracking = branch.getRemoteTrackingBranchID();
+  if (!tracking) {
+    throw new GitError({
+      msg: intl.todo(
+        branchName + ' is not a remote tracking branch! I don\'t know where to push'
+      )
+    });
+  }
+  return tracking;
+};
+
+var commandConfig = {
+  commit: {
+    sc: /^(gc|git ci)($|\s)/,
+    regex: /^git +commit($|\s)/,
+    options: [
+      '--amend',
+      '-a',
+      '--all',
+      '-am',
+      '-m'
+    ],
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      command.acceptNoGeneralArgs();
+
+      if (commandOptions['-am'] && (
+          commandOptions['-a'] || commandOptions['--all'] || commandOptions['-m'])) {
+        throw new GitError({
+          msg: intl.str('git-error-options')
+        });
+      }
+
+      var msg = null;
+      var args = null;
+      if (commandOptions['-a'] || commandOptions['--all']) {
+        command.addWarning(intl.str('git-warning-add'));
+      }
+
+      if (commandOptions['-am']) {
+        args = commandOptions['-am'];
+        command.validateArgBounds(args, 1, 1, '-am');
+        msg = args[0];
+      }
+
+      if (commandOptions['-m']) {
+        args = commandOptions['-m'];
+        command.validateArgBounds(args, 1, 1, '-m');
+        msg = args[0];
+      }
+
+      if (commandOptions['--amend']) {
+        args = commandOptions['--amend'];
+        command.validateArgBounds(args, 0, 0, '--amend');
+      }
+
+      var newCommit = engine.commit({
+        isAmend: !!commandOptions['--amend']
+      });
+      if (msg) {
+        msg = msg
+          .replace(/"/g, '"')
+          .replace(/^"/g, '')
+          .replace(/"$/g, '');
+
+        newCommit.set('commitMessage', msg);
+      }
+
+      var promise = engine.animationFactory.playCommitBirthPromiseAnimation(
+        newCommit,
+        engine.gitVisuals
+      );
+      engine.animationQueue.thenFinish(promise);
+    }
+  },
+
+  cherrypick: {
+    displayName: 'cherry-pick',
+    regex: /^git +cherry-pick($|\s)/,
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+
+      command.validateArgBounds(generalArgs, 1, Number.MAX_VALUE);
+
+      var set = Graph.getUpstreamSet(engine, 'HEAD');
+      // first resolve all the refs (as an error check)
+      var toCherrypick = generalArgs.map(function (arg) {
+        var commit = engine.getCommitFromRef(arg);
+        // and check that its not upstream
+        if (set[commit.get('id')]) {
+          throw new GitError({
+            msg: intl.str(
+              'git-error-already-exists',
+              { commit: commit.get('id') }
+            )
+          });
+        }
+        return commit;
+      }, this);
+
+      engine.setupCherrypickChain(toCherrypick);
+    }
+  },
+
+  gc: {
+    displayName: 'gc',
+    regex: /^git +gc($|\s)/,
+    execute: function(engine, command) {
+      engine.pruneTree(false);
+    }
+  },
+
+  pull: {
+    regex: /^git +pull($|\s)/,
+    options: [
+      '--rebase'
+    ],
+    execute: function(engine, command) {
+      if (!engine.hasOrigin()) {
+        throw new GitError({
+          msg: intl.str('git-error-origin-required')
+        });
+      }
+
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+      command.twoArgsForOrigin(generalArgs);
+      assertOriginSpecified(generalArgs);
+      // here is the deal -- git pull is pretty complex with
+      // the arguments it wants. You can
+      //   A) specify the remote branch you want to
+      //      merge & fetch, in which case it completely
+      //      ignores the properties of branch you are on, or
+      //
+      //  B) specify no args, in which case it figures out
+      //     the branch to fetch from the remote tracking
+      //     and merges those in, or
+      //
+      //  C) specify the colon refspec like fetch, where it does
+      //     the fetch and then just merges the dest
+
+      var source;
+      var destination;
+      var firstArg = generalArgs[1];
+      // COPY PASTA validation code from fetch. maybe fix this?
+      if (firstArg && isColonRefspec(firstArg)) {
+        var refspecParts = firstArg.split(':');
+        source = refspecParts[0];
+        destination = validateBranchNameIfNeeded(
+          engine,
+          crappyUnescape(refspecParts[1])
+        );
+        assertNotCheckedOut(engine, destination);
+      } else if (firstArg) {
+        source = firstArg;
+        assertIsBranch(engine.origin, source);
+        // get o/main locally if main is specified
+        destination = engine.origin.resolveID(source).getPrefixedID();
+      } else {
+        // can't be detached
+        if (engine.getDetachedHead()) {
+          throw new GitError({
+            msg: intl.todo('Git pull can not be executed in detached HEAD mode if no remote branch specified!')
+          });
+        }
+        // ok we need to get our currently checked out branch
+        // and then specify source and dest
+        var branch = engine.getOneBeforeCommit('HEAD');
+        var branchName = branch.get('id');
+        assertBranchIsRemoteTracking(engine, branchName);
+        destination = branch.getRemoteTrackingBranchID();
+        source = destination.replace(ORIGIN_PREFIX, '');
+      }
+
+      engine.pull({
+        source: source,
+        destination: destination,
+        isRebase: !!commandOptions['--rebase']
+      });
+    }
+  },
+
+  fakeTeamwork: {
+    regex: /^git +fakeTeamwork($|\s)/,
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+      if (!engine.hasOrigin()) {
+        throw new GitError({
+          msg: intl.str('git-error-origin-required')
+        });
+      }
+
+      command.validateArgBounds(generalArgs, 0, 2);
+      var branch;
+      var numToMake;
+
+      // allow formats of: git fakeTeamwork 2 or git fakeTeamwork side 3
+      switch (generalArgs.length) {
+        // git fakeTeamwork
+        case 0:
+          branch = 'main';
+          numToMake = 1;
+          break;
+
+        // git fakeTeamwork 10 or git fakeTeamwork foo
+        case 1:
+          if (isNaN(parseInt(generalArgs[0], 10))) {
+            branch = validateOriginBranchName(engine, generalArgs[0]);
+            numToMake = 1;
+          } else {
+            numToMake = parseInt(generalArgs[0], 10);
+            branch = 'main';
+          }
+          break;
+
+        case 2:
+          branch = validateOriginBranchName(engine, generalArgs[0]);
+          if (isNaN(parseInt(generalArgs[1], 10))) {
+            throw new GitError({
+              msg: 'Bad numeric argument: ' + generalArgs[1]
+            });
+          }
+          numToMake = parseInt(generalArgs[1], 10);
+          break;
+
+      }
+
+      // make sure its a branch and exists
+      var destBranch = engine.origin.resolveID(branch);
+      if (destBranch.get('type') !== 'branch') {
+        throw new GitError({
+          msg: intl.str('git-error-options')
+        });
+      }
+
+      engine.fakeTeamwork(numToMake, branch);
+    }
+  },
+
+  clone: {
+    regex: /^git +clone *?$/,
+    execute: function(engine, command) {
+      command.acceptNoGeneralArgs();
+      engine.makeOrigin(engine.printTree());
+    }
+  },
+
+  remote: {
+    regex: /^git +remote($|\s)/,
+    options: [
+      '-v'
+    ],
+    execute: function(engine, command) {
+      command.acceptNoGeneralArgs();
+      if (!engine.hasOrigin()) {
+        throw new CommandResult({
+          msg: ''
+        });
+      }
+
+      engine.printRemotes({
+        verbose: !!command.getOptionsMap()['-v']
+      });
+    }
+  },
+
+  fetch: {
+    regex: /^git +fetch($|\s)/,
+    execute: function(engine, command) {
+      if (!engine.hasOrigin()) {
+        throw new GitError({
+          msg: intl.str('git-error-origin-required')
+        });
+      }
+
+      var source;
+      var destination;
+      var generalArgs = command.getGeneralArgs();
+      command.twoArgsForOrigin(generalArgs);
+      assertOriginSpecified(generalArgs);
+
+      var firstArg = generalArgs[1];
+      if (firstArg && isColonRefspec(firstArg)) {
+        var refspecParts = firstArg.split(':');
+        source = refspecParts[0];
+        destination = validateBranchNameIfNeeded(
+          engine,
+          crappyUnescape(refspecParts[1])
+        );
+        assertNotCheckedOut(engine, destination);
+      } else if (firstArg) {
+        // here is the deal -- its JUST like git push. the first arg
+        // is used as both the destination and the source, so we need
+        // to make sure it exists as the source on REMOTE. however
+        // technically we have a destination here as the remote branch
+        source = firstArg;
+        assertIsBranch(engine.origin, source);
+        // get o/main locally if main is specified
+        destination = engine.origin.resolveID(source).getPrefixedID();
+      }
+      if (source) { // empty string fails this check
+        assertIsRef(engine.origin, source);
+      }
+
+      engine.fetch({
+        source: source,
+        destination: destination
+      });
+    }
+  },
+
+  branch: {
+    sc: /^(gb|git br)($|\s)/,
+    regex: /^git +branch($|\s)/,
+    options: [
+      '-d',
+      '-D',
+      '-f',
+      '--force',
+      '-a',
+      '-r',
+      '-u',
+      '--contains'
+    ],
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+
+      var args = null;
+      // handle deletion first
+      if (commandOptions['-d'] || commandOptions['-D']) {
+        var names = commandOptions['-d'] || commandOptions['-D'];
+        names = names.concat(generalArgs);
+        command.validateArgBounds(names, 1, Number.MAX_VALUE, '-d');
+
+        names.forEach(function(name) {
+          engine.validateAndDeleteBranch(name);
+        });
+        return;
+      }
+
+      if (commandOptions['-u']) {
+        args = commandOptions['-u'].concat(generalArgs);
+        command.validateArgBounds(args, 1, 2, '-u');
+        var remoteBranch = crappyUnescape(args[0]);
+        var branch = args[1] || engine.getOneBeforeCommit('HEAD').get('id');
+
+        // some assertions, both of these have to exist first
+        assertIsRemoteBranch(engine, remoteBranch);
+        assertIsBranch(engine, branch);
+        engine.setLocalToTrackRemote(
+          engine.resolveID(branch),
+          engine.resolveID(remoteBranch)
+        );
+        return;
+      }
+
+      if (commandOptions['--contains']) {
+        args = commandOptions['--contains'];
+        command.validateArgBounds(args, 1, 1, '--contains');
+        engine.printBranchesWithout(args[0]);
+        return;
+      }
+
+      if (commandOptions['-f'] || commandOptions['--force']) {
+        args = commandOptions['-f'] || commandOptions['--force'];
+        args = args.concat(generalArgs);
+        command.twoArgsImpliedHead(args, '-f');
+
+        // we want to force a branch somewhere
+        engine.forceBranch(args[0], args[1]);
+        return;
+      }
+
+
+      if (generalArgs.length === 0) {
+        var branches;
+        if (commandOptions['-a']) {
+          branches = engine.getBranches();
+        } else if (commandOptions['-r']) {
+          branches = engine.getRemoteBranches();
+        } else {
+          branches = engine.getLocalBranches();
+        }
+        engine.printBranches(branches);
+        return;
+      }
+
+      command.twoArgsImpliedHead(generalArgs);
+      engine.branch(generalArgs[0], generalArgs[1]);
+    }
+  },
+
+  add: {
+    dontCountForGolf: true,
+    sc: /^ga($|\s)/,
+    regex: /^git +add($|\s)/,
+    execute: function() {
+      throw new CommandResult({
+        msg: intl.str('git-error-staging')
+      });
+    }
+  },
+
+  reset: {
+    regex: /^git +reset($|\s)/,
+    options: [
+      '--hard',
+      '--soft'
+    ],
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+
+      if (commandOptions['--soft']) {
+        throw new GitError({
+          msg: intl.str('git-error-staging')
+        });
+      }
+      if (commandOptions['--hard']) {
+        command.addWarning(
+          intl.str('git-warning-hard')
+        );
+        // don't absorb the arg off of --hard
+        generalArgs = generalArgs.concat(commandOptions['--hard']);
+      }
+
+      command.validateArgBounds(generalArgs, 1, 1);
+
+      if (engine.getDetachedHead()) {
+        throw new GitError({
+          msg: intl.str('git-error-reset-detached')
+        });
+      }
+
+      engine.reset(generalArgs[0]);
+    }
+  },
+
+  revert: {
+    regex: /^git +revert($|\s)/,
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+
+      command.validateArgBounds(generalArgs, 1, Number.MAX_VALUE);
+      engine.revert(generalArgs);
+    }
+  },
+
+  merge: {
+    regex: /^git +merge($|\s)/,
+    options: [
+      '--no-ff'
+    ],
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs().concat(commandOptions['--no-ff'] || []);
+      command.validateArgBounds(generalArgs, 1, 1);
+
+      var newCommit = engine.merge(
+        generalArgs[0],
+        { noFF: !!commandOptions['--no-ff'] }
+      );
+
+      if (newCommit === undefined) {
+        // its just a fast forward
+        engine.animationFactory.refreshTree(
+          engine.animationQueue, engine.gitVisuals
+        );
+        return;
+      }
+
+      engine.animationFactory.genCommitBirthAnimation(
+        engine.animationQueue, newCommit, engine.gitVisuals
+      );
+    }
+  },
+
+  revlist: {
+    dontCountForGolf: true,
+    displayName: 'rev-list',
+    regex: /^git +rev-list($|\s)/,
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+      command.validateArgBounds(generalArgs, 1);
+
+      engine.revlist(generalArgs);
+    }
+  },
+
+  log: {
+    dontCountForGolf: true,
+    regex: /^git +log($|\s)/,
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+
+      command.impliedHead(generalArgs, 0);
+      engine.log(generalArgs);
+    }
+  },
+
+  show: {
+    dontCountForGolf: true,
+    regex: /^git +show($|\s)/,
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+      command.oneArgImpliedHead(generalArgs);
+      engine.show(generalArgs[0]);
+    }
+  },
+
+  rebase: {
+    sc: /^gr($|\s)/,
+    options: [
+      '-i',
+      '--solution-ordering',
+      '--interactive-test',
+      '--aboveAll',
+      '-p',
+      '--preserve-merges',
+      '--onto'
+    ],
+    regex: /^git +rebase($|\s)/,
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+
+      if (commandOptions['-i']) {
+        var args = commandOptions['-i'].concat(generalArgs);
+        command.twoArgsImpliedHead(args, ' -i');
+
+        if (commandOptions['--interactive-test']) {
+          engine.rebaseInteractiveTest(
+            args[0],
+            args[1], {
+              interactiveTest: commandOptions['--interactive-test']
+            }
+          );
+        } else {
+          engine.rebaseInteractive(
+            args[0],
+            args[1], {
+              aboveAll: !!commandOptions['--aboveAll'],
+              initialCommitOrdering: commandOptions['--solution-ordering']
+            }
+          );
+        }
+        return;
+      }
+
+      if (commandOptions['--onto']) {
+        var args = commandOptions['--onto'].concat(generalArgs);
+        command.threeArgsImpliedHead(args, ' --onto');
+
+        engine.rebaseOnto(args[0], args[1], args[2], {
+          preserveMerges: commandOptions['-p'] || commandOptions['--preserve-merges']
+        });
+
+        return;
+      }
+
+      command.twoArgsImpliedHead(generalArgs);
+      engine.rebase(generalArgs[0], generalArgs[1], {
+        preserveMerges: commandOptions['-p'] || commandOptions['--preserve-merges']
+      });
+    }
+  },
+
+  status: {
+    dontCountForGolf: true,
+    sc: /^(gst|gs|git st)($|\s)/,
+    regex: /^git +status($|\s)/,
+    execute: function(engine) {
+      // no parsing at all
+      engine.status();
+    }
+  },
+
+  checkout: {
+    sc: /^(go|git co)($|\s)/,
+    regex: /^git +checkout($|\s)/,
+    options: [
+      '-b',
+      '-B',
+      '-'
+    ],
+    execute: function(engine, command) {
+      var commandOptions = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+
+      var args = null;
+      if (commandOptions['-b']) {
+        // the user is really trying to just make a
+        // branch and then switch to it. so first:
+        args = commandOptions['-b'].concat(generalArgs);
+        command.twoArgsImpliedHead(args, '-b');
+
+        var validId = engine.validateBranchName(args[0]);
+        engine.branch(validId, args[1]);
+        engine.checkout(validId);
+        return;
+      }
+
+      if (commandOptions['-']) {
+        // get the heads last location
+        var lastPlace = engine.HEAD.get('lastLastTarget');
+        if (!lastPlace) {
+          throw new GitError({
+            msg: intl.str('git-result-nothing')
+          });
+        }
+        engine.HEAD.set('target', lastPlace);
+        return;
+      }
+
+      if (commandOptions['-B']) {
+        args = commandOptions['-B'].concat(generalArgs);
+        command.twoArgsImpliedHead(args, '-B');
+
+        engine.forceBranch(args[0], args[1]);
+        engine.checkout(args[0]);
+        return;
+      }
+
+      command.validateArgBounds(generalArgs, 1, 1);
+
+      engine.checkout(engine.crappyUnescape(generalArgs[0]));
+    }
+  },
+
+  push: {
+    regex: /^git +push($|\s)/,
+    options: [
+      '--force'
+    ],
+    execute: function(engine, command) {
+      if (!engine.hasOrigin()) {
+        throw new GitError({
+          msg: intl.str('git-error-origin-required')
+        });
+      }
+
+      var options = {};
+      var destination;
+      var source;
+      var sourceObj;
+      var commandOptions = command.getOptionsMap();
+
+      // git push is pretty complex in terms of
+      // the arguments it wants as well... get ready!
+      var generalArgs = command.getGeneralArgs();
+      command.twoArgsForOrigin(generalArgs);
+      assertOriginSpecified(generalArgs);
+
+      var firstArg = generalArgs[1];
+      if (firstArg && isColonRefspec(firstArg)) {
+        var refspecParts = firstArg.split(':');
+        source = refspecParts[0];
+        destination = validateBranchName(engine, refspecParts[1]);
+        if (source === "" && !engine.origin.resolveID(destination)) {
+          throw new GitError({
+            msg: intl.todo(
+              'cannot delete branch ' + options.destination + ' which doesnt exist'
+            )
+          });
+        }
+      } else {
+        if (firstArg) {
+          // we are using this arg as destination AND source. the dest branch
+          // can be created on demand but we at least need this to be a source
+          // locally otherwise we will fail
+          assertIsRef(engine, firstArg);
+          sourceObj = engine.resolveID(firstArg);
+        } else {
+          // since they have not specified a source or destination, then
+          // we source from the branch we are on (or HEAD)
+          sourceObj = engine.getOneBeforeCommit('HEAD');
+        }
+        source = sourceObj.get('id');
+
+        // HOWEVER we push to either the remote tracking branch we have
+        // OR a new named branch if we aren't tracking anything
+        if (sourceObj.getRemoteTrackingBranchID &&
+            sourceObj.getRemoteTrackingBranchID()) {
+          assertBranchIsRemoteTracking(engine, source);
+          var remoteBranch = sourceObj.getRemoteTrackingBranchID();
+          destination = engine.resolveID(remoteBranch).getBaseID();
+        } else {
+          destination = validateBranchName(engine, source);
+        }
+      }
+      if (source) {
+        assertIsRef(engine, source);
+      }
+
+      engine.push({
+        // NOTE -- very important! destination and source here
+        // are always, always strings. very important :D
+        destination: destination,
+        source: source,
+        force: !!commandOptions['--force']
+      });
+    }
+  },
+
+  describe: {
+    regex: /^git +describe($|\s)/,
+    execute: function(engine, command) {
+      // first if there are no tags, we cant do anything so just throw
+      if (engine.tagCollection.toArray().length === 0) {
+        throw new GitError({
+          msg: intl.todo(
+            'fatal: No tags found, cannot describe anything.'
+          )
+        });
+      }
+
+      var generalArgs = command.getGeneralArgs();
+      command.oneArgImpliedHead(generalArgs);
+      assertIsRef(engine, generalArgs[0]);
+
+      engine.describe(generalArgs[0]);
+    }
+  },
+
+  tag: {
+    regex: /^git +tag($|\s)/,
+    options: [
+      '-d'
+    ],
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+      var commandOptions = command.getOptionsMap();
+
+      if (commandOptions['-d']) {
+        var tagID = commandOptions['-d'];
+        var tagToRemove;
+
+        assertIsRef(engine, tagID);
+
+        command.oneArgImpliedHead(tagID);
+        engine.tagCollection.each(function(tag) {
+          if(tag.get('id') == tagID){
+            tagToRemove = tag;
+          }
+        }, true);
+
+        if(tagToRemove == undefined){
+          throw new GitError({
+            msg: intl.todo(
+              'No tag found, nothing to remove'
+            )
+          });
+        }
+
+        engine.tagCollection.remove(tagToRemove);
+        delete engine.refs[tagID];
+
+        engine.gitVisuals.refreshTree();
+        return;
+      }
+
+      if (generalArgs.length === 0) {
+        var tags = engine.getTags();
+        engine.printTags(tags);
+        return;
+      }
+
+      command.twoArgsImpliedHead(generalArgs);
+      engine.tag(generalArgs[0], generalArgs[1]);
+    }
+  },
+
+  switch: {
+    sc: /^(gsw|git sw)($|\s)/,
+    regex: /^git +switch($|\s)/,
+    options: [
+      '-c',
+      '-'
+    ],
+    execute: function(engine, command) {
+      var generalArgs = command.getGeneralArgs();
+      var commandOptions = command.getOptionsMap();
+
+      var args = null;
+      if (commandOptions['-c']) {
+        // the user is really trying to just make a
+        // branch and then switch to it. so first:
+        args = commandOptions['-c'].concat(generalArgs);
+        command.twoArgsImpliedHead(args, '-c');
+
+        var validId = engine.validateBranchName(args[0]);
+        engine.branch(validId, args[1]);
+        engine.checkout(validId);
+        return;
+      }
+
+      if (commandOptions['-']) {
+        // get the heads last location
+        var lastPlace = engine.HEAD.get('lastLastTarget');
+        if (!lastPlace) {
+          throw new GitError({
+            msg: intl.str('git-result-nothing')
+          });
+        }
+        engine.HEAD.set('target', lastPlace);
+        return;
+      }
+
+      command.validateArgBounds(generalArgs, 1, 1);
+
+      engine.checkout(engine.crappyUnescape(generalArgs[0]));
+    }
+  }
+};
+
+var instantCommands = [
+  [/^(git help($|\s)|git$)/, function() {
+    var lines = [
+      intl.str('git-version'),
+      '<br/>',
+      intl.str('git-usage'),
+      escapeString(intl.str('git-usage-command')),
+      '<br/>',
+      intl.str('git-supported-commands'),
+      '<br/>'
+    ];
+
+    var commands = require('../commands').commands.getOptionMap()['git'];
+    // build up a nice display of what we support
+    Object.keys(commands).forEach(function(command) {
+      var commandOptions = commands[command];
+      lines.push('git ' + command);
+      Object.keys(commandOptions).forEach(function(optionName) {
+        lines.push('\t ' + optionName);
+      }, this);
+    }, this);
+
+    // format and throw
+    var msg = lines.join('\n');
+    msg = msg.replace(/\t/g, '&nbsp;&nbsp;&nbsp;');
+    throw new CommandResult({
+      msg: msg
+    });
+  }]
+];
+
+exports.commandConfig = commandConfig;
+exports.instantCommands = instantCommands;

src/js/git/gitShim.js

@@ -0,0 +1,83 @@
+var Q = require('q');
+
+var Main = require('../app');
+var MultiView = require('../views/multiView').MultiView;
+
+function GitShim(options) {
+  options = options || {};
+
+  // these variables are just functions called before / after for
+  // simple things (like incrementing a counter)
+  this.beforeCB = options.beforeCB || function() {};
+  this.afterCB = options.afterCB || function() {};
+
+  // these guys handle an optional async process before the git
+  // command executes or afterwards. If there is none,
+  // it just resolves the deferred immediately
+  var resolveImmediately = function(deferred) {
+    deferred.resolve();
+  };
+  this.beforeDeferHandler = options.beforeDeferHandler || resolveImmediately;
+  this.afterDeferHandler = options.afterDeferHandler || resolveImmediately;
+  this.eventBaton = options.eventBaton || Main.getEventBaton();
+}
+
+GitShim.prototype.insertShim = function() {
+  this.eventBaton.stealBaton('processGitCommand', this.processGitCommand, this);
+};
+
+GitShim.prototype.removeShim = function() {
+  this.eventBaton.releaseBaton('processGitCommand', this.processGitCommand, this);
+};
+
+GitShim.prototype.processGitCommand = function(command, deferred) {
+  this.beforeCB(command);
+
+  // ok we make a NEW deferred that will, upon resolution,
+  // call our afterGitCommandProcessed. This inserts the 'after' shim
+  // functionality. we give this new deferred to the eventBaton handler
+  var newDeferred = Q.defer();
+  newDeferred.promise
+  .then(function() {
+    // give this method the original defer so it can resolve it
+    this.afterGitCommandProcessed(command, deferred);
+  }.bind(this))
+  .done();
+
+  // now our shim owner might want to launch some kind of deferred beforehand, like
+  // a modal or something. in order to do this, we need to defer the passing
+  // of the event baton backwards, and either resolve that promise immediately or
+  // give it to our shim owner.
+  var passBaton = function() {
+    // punt to the previous listener
+    this.eventBaton.passBatonBack('processGitCommand', this.processGitCommand, this, [command, newDeferred]);
+  }.bind(this);
+
+  var beforeDefer = Q.defer();
+  beforeDefer.promise
+  .then(passBaton)
+  .done();
+
+  // if we didnt receive a defer handler in the options, this just
+  // resolves immediately
+  this.beforeDeferHandler(beforeDefer, command);
+};
+
+GitShim.prototype.afterGitCommandProcessed = function(command, deferred) {
+  this.afterCB(command);
+
+  // again we can't just resolve this deferred right away... our shim owner might
+  // want to insert some promise functionality before that happens. so again
+  // we make a defer
+  var afterDefer = Q.defer();
+  afterDefer.promise
+  .then(function() {
+    deferred.resolve();
+  })
+  .done();
+
+  this.afterDeferHandler(afterDefer, command);
+};
+
+exports.GitShim = GitShim;
+

src/js/git/headless.js

@@ -0,0 +1,145 @@
+var Backbone = require('backbone');
+var Q = require('q');
+
+var GitEngine = require('../git').GitEngine;
+var AnimationFactory = require('../visuals/animation/animationFactory').AnimationFactory;
+var GitVisuals = require('../visuals').GitVisuals;
+var TreeCompare = require('../graph/treeCompare');
+var EventBaton = require('../util/eventBaton').EventBaton;
+
+var Collections = require('../models/collections');
+var CommitCollection = Collections.CommitCollection;
+var BranchCollection = Collections.BranchCollection;
+var TagCollection = Collections.TagCollection;
+var Command = require('../models/commandModel').Command;
+
+var mock = require('../util/mock').mock;
+var util = require('../util');
+
+function getMockFactory() {
+  var mockFactory = {};
+  var mockReturn = function() {
+    var d = Q.defer();
+    // fall through!
+    d.resolve();
+    return d.promise;
+  };
+  for (var key in AnimationFactory) {
+    mockFactory[key] = mockReturn;
+  }
+
+  mockFactory.playRefreshAnimationAndFinish = function(gitVisuals, aQueue) {
+    aQueue.finish();
+  };
+  mockFactory.refreshTree = function(aQueue, gitVisuals) {
+    aQueue.finish();
+  };
+
+  mockFactory.highlightEachWithPromise = function(chain, toRebase, destBranch) {
+    // don't add any steps
+    return chain;
+  };
+
+  return mockFactory;
+}
+
+function getMockVisualization() {
+  return {
+    makeOrigin: function(options) {
+      var localRepo = options.localRepo;
+      var treeString = options.treeString;
+
+      var headless = new HeadlessGit();
+      headless.gitEngine.loadTreeFromString(treeString);
+      return {
+        customEvents: {
+          on: function(key, cb, context) {
+            cb.apply(context, []);
+          }
+        },
+        gitEngine: headless.gitEngine
+      };
+    }
+  };
+}
+
+var HeadlessGit = function() {
+  this.init();
+};
+
+HeadlessGit.prototype.init = function() {
+  this.commitCollection = new CommitCollection();
+  this.branchCollection = new BranchCollection();
+  this.tagCollection = new TagCollection();
+
+  // here we mock visuals and animation factory so the git engine
+  // is headless
+  var animationFactory = getMockFactory();
+  var gitVisuals = mock(GitVisuals);
+  // add some stuff for origin making
+  var mockVis = getMockVisualization();
+  gitVisuals.getVisualization = function() {
+    return mockVis;
+  };
+
+  this.gitEngine = new GitEngine({
+    collection: this.commitCollection,
+    branches: this.branchCollection,
+    tags: this.tagCollection,
+    gitVisuals: gitVisuals,
+    animationFactory: animationFactory,
+    eventBaton: new EventBaton()
+  });
+  this.gitEngine.init();
+};
+
+// horrible hack so we can just quickly get a tree string for async git
+// operations, aka for git demonstration views
+var getTreeQuick = function(commandStr, getTreePromise) {
+  var deferred = Q.defer();
+  var headless = new HeadlessGit();
+  headless.sendCommand(commandStr, deferred);
+  deferred.promise.then(function() {
+    getTreePromise.resolve(headless.gitEngine.exportTree());
+  });
+};
+
+HeadlessGit.prototype.sendCommand = function(value, entireCommandPromise) {
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+  var startTime = new Date().getTime();
+
+  var commands = [];
+
+  util.splitTextCommand(value, function(commandStr) {
+    chain = chain.then(function() {
+      var commandObj = new Command({
+        rawStr: commandStr
+      });
+
+      var thisDeferred = Q.defer();
+      this.gitEngine.dispatch(commandObj, thisDeferred);
+      commands.push(commandObj);
+      return thisDeferred.promise;
+    }.bind(this));
+  }, this);
+
+  chain.then(function() {
+    var nowTime = new Date().getTime();
+    if (entireCommandPromise) {
+      entireCommandPromise.resolve(commands);
+    }
+  });
+
+  chain.fail(function(err) {
+    console.log('!!!!!!!! error !!!!!!!');
+    console.log(err);
+    console.log(err.stack);
+    console.log('!!!!!!!!!!!!!!!!!!!!!!');
+  });
+  deferred.resolve();
+  return chain;
+};
+
+exports.HeadlessGit = HeadlessGit;
+exports.getTreeQuick = getTreeQuick;

src/js/git/index.js

@@ -0,0 +1,3202 @@
+var Backbone = require('backbone');
+var Q = require('q');
+
+var intl = require('../intl');
+
+var AnimationFactory = require('../visuals/animation/animationFactory').AnimationFactory;
+var AnimationQueue = require('../visuals/animation').AnimationQueue;
+var TreeCompare = require('../graph/treeCompare');
+
+var Graph = require('../graph');
+var Errors = require('../util/errors');
+var Main = require('../app');
+var Commands = require('../commands');
+var GitError = Errors.GitError;
+var CommandResult = Errors.CommandResult;
+
+var ORIGIN_PREFIX = 'o/';
+var TAB = '   ';
+var SHORT_CIRCUIT_CHAIN = 'STAPH';
+
+function catchShortCircuit(err) {
+  if (err !== SHORT_CIRCUIT_CHAIN) {
+    throw err;
+  }
+}
+
+function GitEngine(options) {
+  this.rootCommit = null;
+  this.refs = {};
+  this.HEAD = null;
+  this.origin = null;
+  this.mode = 'git';
+  this.localRepo = null;
+
+  this.branchCollection = options.branches;
+  this.tagCollection = options.tags;
+  this.commitCollection = options.collection;
+  this.gitVisuals = options.gitVisuals;
+
+  this.eventBaton = options.eventBaton;
+  this.eventBaton.stealBaton('processGitCommand', this.dispatch, this);
+
+  // poor man's dependency injection. we can't reassign
+  // the module variable because its get clobbered :P
+  this.animationFactory = (options.animationFactory) ?
+    options.animationFactory : AnimationFactory;
+
+  this.initUniqueID();
+}
+
+GitEngine.prototype.initUniqueID = function() {
+  // backbone or something uses _ .uniqueId, so we make our own here
+  this.uniqueId = (function() {
+    var n = 0;
+    return function(prepend) {
+      return prepend ? prepend + n++ : n++;
+    };
+  })();
+};
+
+GitEngine.prototype.handleModeChange = function(vcs, callback) {
+  if (this.mode === vcs) {
+    // don't fire event aggressively
+    callback();
+    return;
+  }
+  Main.getEvents().trigger('vcsModeChange', {mode: vcs});
+  var chain = this.setMode(vcs);
+  if (this.origin) {
+    this.origin.setMode(vcs, function() {});
+  }
+
+  if (!chain) {
+    callback();
+    return;
+  }
+  // we have to do it async
+  chain.then(callback);
+};
+
+GitEngine.prototype.getIsHg = function() {
+  return this.mode === 'hg';
+};
+
+GitEngine.prototype.setMode = function(vcs) {
+  var switchedToHg = (this.mode === 'git' && vcs === 'hg');
+  this.mode = vcs;
+  if (!switchedToHg) {
+    return;
+  }
+  // if we are switching to mercurial then we have some
+  // garbage collection and other tidying up to do. this
+  // may or may not require a refresh so lets check.
+  var deferred = Q.defer();
+  deferred.resolve();
+  var chain = deferred.promise;
+
+  // this stuff is tricky because we don't animate when
+  // we didn't do anything, but we DO animate when
+  // either of the operations happen. so a lot of
+  // branching ahead...
+  var neededUpdate = this.updateAllBranchesForHg();
+  if (neededUpdate) {
+    chain = chain.then(function() {
+      return this.animationFactory.playRefreshAnimationSlow(this.gitVisuals);
+    }.bind(this));
+
+    // ok we need to refresh anyways, so do the prune after
+    chain = chain.then(function() {
+      var neededPrune = this.pruneTree();
+      if (!neededPrune) {
+        return;
+      }
+      return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    }.bind(this));
+
+    return chain;
+  }
+
+  // ok might need prune though
+  var pruned = this.pruneTree();
+  if (!pruned) {
+    // do sync
+    return;
+  }
+
+  return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+};
+
+GitEngine.prototype.assignLocalRepo = function(repo) {
+  this.localRepo = repo;
+};
+
+GitEngine.prototype.defaultInit = function() {
+  var defaultTree = Graph.getDefaultTree();
+  this.loadTree(defaultTree);
+};
+
+GitEngine.prototype.init = function() {
+  // make an initial commit and a main branch
+  this.rootCommit = this.makeCommit(null, null, {rootCommit: true});
+  this.commitCollection.add(this.rootCommit);
+
+  var main = this.makeBranch('main', this.rootCommit);
+  this.HEAD = new Ref({
+    id: 'HEAD',
+    target: main
+  });
+  this.refs[this.HEAD.get('id')] = this.HEAD;
+
+  // commit once to get things going
+  this.commit();
+};
+
+GitEngine.prototype.hasOrigin = function() {
+  return !!this.origin;
+};
+
+GitEngine.prototype.isOrigin = function() {
+  return !!this.localRepo;
+};
+
+GitEngine.prototype.exportTreeForBranch = function(branchName) {
+  // this method exports the tree and then prunes everything that
+  // is not connected to branchname
+  var tree = this.exportTree();
+  // get the upstream set
+  var set = Graph.getUpstreamSet(this, branchName);
+  // now loop through and delete commits
+  var commitsToLoop = tree.commits;
+  tree.commits = {};
+  commitsToLoop.forEach(function(commit, id) {
+    if (set[id]) {
+      // if included in target branch
+      tree.commits[id] = commit;
+    }
+  });
+
+  var branchesToLoop = tree.branches;
+  tree.branches = {};
+  branchesToLoop.forEach(function(branch, id) {
+    if (id === branchName) {
+      tree.branches[id] = branch;
+    }
+  });
+
+  tree.HEAD.target = branchName;
+  return tree;
+};
+
+GitEngine.prototype.exportTree = function() {
+  // need to export all commits, their connectivity / messages, branches, and state of head.
+  // this would be simple if didn't have circular structures.... :P
+  // thus, we need to loop through and "flatten" our graph of objects referencing one another
+  var totalExport = {
+    branches: {},
+    commits: {},
+    tags: {},
+    HEAD: null
+  };
+
+  this.branchCollection.toJSON().forEach(function(branch) {
+    branch.target = branch.target.get('id');
+    delete branch.visBranch;
+
+    totalExport.branches[branch.id] = branch;
+  });
+
+  this.commitCollection.toJSON().forEach(function(commit) {
+    // clear out the fields that reference objects and create circular structure
+    Commit.prototype.constants.circularFields.forEach(function(field) {
+      delete commit[field];
+    });
+
+    // convert parents
+    commit.parents = (commit.parents || []).map(function(par) {
+      return par.get('id');
+    });
+
+    totalExport.commits[commit.id] = commit;
+  }, this);
+
+  this.tagCollection.toJSON().forEach(function(tag) {
+    delete tag.visTag;
+    tag.target = tag.target.get('id');
+
+    totalExport.tags[tag.id] = tag;
+  }, this);
+
+  var HEAD = this.HEAD.toJSON();
+  HEAD.lastTarget = HEAD.lastLastTarget = HEAD.visBranch = HEAD.visTag = undefined;
+  HEAD.target = HEAD.target.get('id');
+  totalExport.HEAD = HEAD;
+
+  if (this.hasOrigin()) {
+    totalExport.originTree = this.origin.exportTree();
+  }
+
+  return totalExport;
+};
+
+GitEngine.prototype.printTree = function(tree) {
+  tree = tree || this.exportTree();
+  TreeCompare.reduceTreeFields([tree]);
+
+  var str = JSON.stringify(tree);
+  if (/'/.test(str)) {
+    // escape it to make it more copy paste friendly
+    str = escape(str);
+  }
+  return str;
+};
+
+GitEngine.prototype.printAndCopyTree = function() {
+  window.prompt(
+    intl.str('Copy the tree string below'),
+    this.printTree()
+  );
+};
+
+GitEngine.prototype.loadTree = function(tree) {
+  // deep copy in case we use it a bunch. lol awesome copy method
+  tree = JSON.parse(JSON.stringify(tree));
+
+  // first clear everything
+  this.removeAll();
+
+  this.instantiateFromTree(tree);
+
+  this.reloadGraphics();
+  this.initUniqueID();
+};
+
+GitEngine.prototype.loadTreeFromString = function(treeString) {
+  this.loadTree(JSON.parse(unescape(this.crappyUnescape(treeString))));
+};
+
+GitEngine.prototype.instantiateFromTree = function(tree) {
+  // now we do the loading part
+  var createdSoFar = {};
+
+  Object.values(tree.commits).forEach(function(commitJSON) {
+    var commit = this.getOrMakeRecursive(tree, createdSoFar, commitJSON.id, this.gitVisuals);
+    this.commitCollection.add(commit);
+  }, this);
+
+  Object.values(tree.branches).forEach(function(branchJSON) {
+    var branch = this.getOrMakeRecursive(tree, createdSoFar, branchJSON.id, this.gitVisuals);
+
+    this.branchCollection.add(branch, {silent: true});
+  }, this);
+
+  Object.values(tree.tags || {}).forEach(function(tagJSON) {
+    var tag = this.getOrMakeRecursive(tree, createdSoFar, tagJSON.id, this.gitVisuals);
+
+    this.tagCollection.add(tag, {silent: true});
+  }, this);
+
+  var HEAD = this.getOrMakeRecursive(tree, createdSoFar, tree.HEAD.id, this.gitVisuals);
+  this.HEAD = HEAD;
+
+  this.rootCommit = createdSoFar['C0'];
+  if (!this.rootCommit) {
+    throw new Error('Need root commit of C0 for calculations');
+  }
+  this.refs = createdSoFar;
+
+  this.gitVisuals.gitReady = false;
+  this.branchCollection.each(function(branch) {
+        this.gitVisuals.addBranch(branch);
+      }, this);
+  this.tagCollection.each(function(tag) {
+        this.gitVisuals.addTag(tag);
+      }, this);
+
+  if (tree.originTree) {
+    var treeString = JSON.stringify(tree.originTree);
+    // if we don't have an animation queue (like when loading
+    // right away), just go ahead and make an empty one
+    this.animationQueue = this.animationQueue || new AnimationQueue({
+      callback: function() {}
+    });
+    this.makeOrigin(treeString);
+  }
+};
+
+GitEngine.prototype.makeOrigin = function(treeString) {
+  if (this.hasOrigin()) {
+    throw new GitError({
+      msg: intl.str('git-error-origin-exists')
+    });
+  }
+  treeString = treeString || this.printTree(this.exportTreeForBranch('main'));
+
+  // this is super super ugly but a necessary hack because of the way LGB was
+  // originally designed. We need to get to the top level visualization from
+  // the git engine -- aka we need to access our own visuals, then the
+  // visualization and ask the main vis to create a new vis/git pair. Then
+  // we grab the gitengine out of that and assign that as our origin repo
+  // which connects the two. epic
+  var mainVis = this.gitVisuals.getVisualization();
+  var originVis = mainVis.makeOrigin({
+    localRepo: this,
+    treeString: treeString
+  });
+
+  // defer the starting of our animation until origin has been created
+  this.animationQueue.set('promiseBased', true);
+  originVis.customEvents.on('gitEngineReady', function() {
+    this.origin = originVis.gitEngine;
+    originVis.gitEngine.assignLocalRepo(this);
+    this.syncRemoteBranchFills();
+    // and then here is the crazy part -- we need the ORIGIN to refresh
+    // itself in a separate animation. @_____@
+    this.origin.externalRefresh();
+    this.animationFactory.playRefreshAnimationAndFinish(this.gitVisuals, this.animationQueue);
+  }, this);
+
+  var originTree = JSON.parse(unescape(treeString));
+  // make an origin branch for each branch mentioned in the tree if its
+  // not made already...
+  Object.keys(originTree.branches).forEach(function(branchName) {
+    var branchJSON = originTree.branches[branchName];
+    if (this.refs[ORIGIN_PREFIX + branchName]) {
+      // we already have this branch
+      return;
+    }
+
+    var originTarget = this.findCommonAncestorWithRemote(
+      branchJSON.target
+    );
+
+    // now we have something in common, lets make the tracking branch
+    var remoteBranch = this.makeBranch(
+      ORIGIN_PREFIX + branchName,
+      this.getCommitFromRef(originTarget)
+    );
+
+    this.setLocalToTrackRemote(this.refs[branchJSON.id], remoteBranch);
+  }, this);
+};
+
+GitEngine.prototype.makeRemoteBranchIfNeeded = function(branchName) {
+  if (this.doesRefExist(ORIGIN_PREFIX + branchName)) {
+    return;
+  }
+  // if its not a branch on origin then bounce
+  var source = this.origin.resolveID(branchName);
+  if (source.get('type') !== 'branch') {
+    return;
+  }
+
+  return this.makeRemoteBranchForRemote(branchName);
+};
+
+GitEngine.prototype.makeBranchIfNeeded = function(branchName) {
+  if (this.doesRefExist(branchName)) {
+    return;
+  }
+  var where = this.findCommonAncestorForRemote(
+    this.getCommitFromRef('HEAD').get('id')
+  );
+
+  return this.validateAndMakeBranch(branchName, this.getCommitFromRef(where));
+};
+
+GitEngine.prototype.makeRemoteBranchForRemote = function(branchName) {
+  var target = this.origin.resolveID(branchName).get('target');
+  var originTarget = this.findCommonAncestorWithRemote(
+    target.get('id')
+  );
+  return this.makeBranch(
+    ORIGIN_PREFIX + branchName,
+    this.getCommitFromRef(originTarget)
+  );
+};
+
+GitEngine.prototype.findCommonAncestorForRemote = function(myTarget) {
+  if (this.origin.refs[myTarget]) {
+    return myTarget;
+  }
+  var parents = this.refs[myTarget].get('parents');
+  if (parents.length === 1) {
+    // Easy, we only have one parent. lets just go upwards
+    myTarget = parents[0].get('id');
+    // Recurse upwards to find where our remote has a commit.
+    return this.findCommonAncestorForRemote(myTarget);
+  }
+  // We have multiple parents so find out where these two meet.
+  var leftTarget = this.findCommonAncestorForRemote(parents[0].get('id'));
+  var rightTarget = this.findCommonAncestorForRemote(parents[1].get('id'));
+  return this.getCommonAncestor(
+      leftTarget,
+      rightTarget,
+      true // don't throw since we don't know the order here.
+  ).get('id');
+};
+
+GitEngine.prototype.findCommonAncestorWithRemote = function(originTarget) {
+  if (this.refs[originTarget]) {
+    return originTarget;
+  }
+  // now this is tricky -- our remote could have commits that we do
+  // not have. so lets go upwards until we find one that we have
+  var parents = this.origin.refs[originTarget].get('parents');
+  if (parents.length === 1) {
+    return this.findCommonAncestorWithRemote(parents[0].get('id'));
+  }
+  // Like above, could have two parents
+  var leftTarget = this.findCommonAncestorWithRemote(parents[0].get('id'));
+  var rightTarget = this.findCommonAncestorWithRemote(parents[1].get('id'));
+  return this.getCommonAncestor(leftTarget, rightTarget, true /* don't throw */).get('id');
+};
+
+GitEngine.prototype.makeBranchOnOriginAndTrack = function(branchName, target) {
+  var remoteBranch = this.makeBranch(
+    ORIGIN_PREFIX + branchName,
+    this.getCommitFromRef(target)
+  );
+
+  if (this.refs[branchName]) { // not all remote branches have tracking ones
+    this.setLocalToTrackRemote(this.refs[branchName], remoteBranch);
+  }
+
+  var originTarget = this.findCommonAncestorForRemote(
+    this.getCommitFromRef(target).get('id')
+  );
+  this.origin.makeBranch(
+    branchName,
+    this.origin.getCommitFromRef(originTarget)
+  );
+};
+
+GitEngine.prototype.setLocalToTrackRemote = function(localBranch, remoteBranch) {
+  localBranch.setRemoteTrackingBranchID(remoteBranch.get('id'));
+
+  if (!this.command) {
+    // during init we have no command
+    return;
+  }
+
+  var msg = 'local branch "' +
+    localBranch.get('id') +
+    '" set to track remote branch "' +
+    remoteBranch.get('id') +
+    '"';
+  this.command.addWarning(intl.todo(msg));
+};
+
+GitEngine.prototype.getOrMakeRecursive = function(
+  tree,
+  createdSoFar,
+  objID,
+  gitVisuals
+) {
+  if (createdSoFar[objID]) {
+    // base case
+    return createdSoFar[objID];
+  }
+
+  var getType = function(tree, id) {
+    if (tree.commits[id]) {
+      return 'commit';
+    } else if (tree.branches[id]) {
+      return 'branch';
+    } else if (id == 'HEAD') {
+      return 'HEAD';
+    } else if (tree.tags[id]) {
+      return 'tag';
+    }
+    throw new Error("bad type for " + id);
+  };
+
+  // figure out what type
+  var type = getType(tree, objID);
+
+  if (type == 'HEAD') {
+    var headJSON = tree.HEAD;
+    var HEAD = new Ref(Object.assign(
+      tree.HEAD,
+      {
+        target: this.getOrMakeRecursive(tree, createdSoFar, headJSON.target)
+      }
+    ));
+    createdSoFar[objID] = HEAD;
+    return HEAD;
+  }
+
+  if (type == 'branch') {
+    var branchJSON = tree.branches[objID];
+
+    var branch = new Branch(Object.assign(
+      tree.branches[objID],
+      {
+        target: this.getOrMakeRecursive(tree, createdSoFar, branchJSON.target)
+      }
+    ));
+    createdSoFar[objID] = branch;
+    return branch;
+  }
+
+  if (type == 'tag') {
+    var tagJSON = tree.tags[objID];
+
+    var tag = new Tag(Object.assign(
+      tree.tags[objID],
+      {
+        target: this.getOrMakeRecursive(tree, createdSoFar, tagJSON.target)
+      }
+    ));
+    createdSoFar[objID] = tag;
+    return tag;
+  }
+
+  if (type == 'commit') {
+    // for commits, we need to grab all the parents
+    var commitJSON = tree.commits[objID];
+
+    var parentObjs = commitJSON.parents.map(function(parentID) {
+      return this.getOrMakeRecursive(tree, createdSoFar, parentID);
+    }, this);
+
+    var commit = new Commit(Object.assign(
+      commitJSON,
+      {
+        parents: parentObjs,
+        gitVisuals: this.gitVisuals
+      }
+    ));
+    createdSoFar[objID] = commit;
+    return commit;
+  }
+
+  throw new Error('ruh rho!! unsupported type for ' + objID);
+};
+
+GitEngine.prototype.tearDown = function() {
+  if (this.tornDown) {
+    return;
+  }
+  this.eventBaton.releaseBaton('processGitCommand', this.dispatch, this);
+  this.removeAll();
+  this.tornDown = true;
+};
+
+GitEngine.prototype.reloadGraphics = function() {
+  // get the root commit
+  this.gitVisuals.rootCommit = this.refs['C0'];
+  // this just basically makes the HEAD branch. the head branch really should have been
+  // a member of a collection and not this annoying edge case stuff... one day
+  this.gitVisuals.initHeadBranch();
+
+  // when the paper is ready
+  this.gitVisuals.drawTreeFromReload();
+
+  this.gitVisuals.refreshTreeHarsh();
+};
+
+GitEngine.prototype.removeAll = function() {
+  this.branchCollection.reset();
+  this.tagCollection.reset();
+  this.commitCollection.reset();
+  this.refs = {};
+  this.HEAD = null;
+  this.rootCommit = null;
+
+  if (this.origin) {
+    // we will restart all this jazz during init from tree
+    this.origin.gitVisuals.getVisualization().tearDown();
+    delete this.origin;
+    this.gitVisuals.getVisualization().clearOrigin();
+  }
+
+  this.gitVisuals.resetAll();
+};
+
+GitEngine.prototype.getDetachedHead = function() {
+  // detached head is if HEAD points to a commit instead of a branch...
+  var target = this.HEAD.get('target');
+  var targetType = target.get('type');
+  return targetType !== 'branch';
+};
+
+GitEngine.prototype.validateBranchName = function(name) {
+  // Lets escape some of the nasty characters
+  name = name.replace(///g,"\/");
+  name = name.replace(/\s/g, '');
+  // And then just make sure it starts with alpha-numeric,
+  // can contain a slash or dash, and then ends with alpha
+  if (
+    !/^(\w+[.\/\-]?)+\w+$/.test(name) ||
+    name.search('o/') === 0
+  ) {
+    throw new GitError({
+      msg: intl.str(
+        'bad-branch-name',
+        { branch: name }
+      )
+    });
+  }
+  if (/^[cC]\d+$/.test(name)) {
+    throw new GitError({
+      msg: intl.str(
+        'bad-branch-name',
+        { branch: name }
+      )
+    });
+  }
+  if (/[hH][eE][aA][dD]/.test(name)) {
+    throw new GitError({
+      msg: intl.str(
+        'bad-branch-name',
+        { branch: name }
+      )
+    });
+  }
+  if (name.length > 9) {
+    name = name.slice(0, 9);
+    this.command.addWarning(
+      intl.str(
+        'branch-name-short',
+        { branch: name }
+      )
+    );
+  }
+  return name;
+};
+
+GitEngine.prototype.validateAndMakeBranch = function(id, target) {
+  id = this.validateBranchName(id);
+  if (this.doesRefExist(id)) {
+    throw new GitError({
+      msg: intl.str(
+        'bad-branch-name',
+        { branch: id }
+      )
+    });
+  }
+
+  return this.makeBranch(id, target);
+};
+
+GitEngine.prototype.validateAndMakeTag = function(id, target) {
+  id = this.validateBranchName(id);
+  if (this.refs[id]) {
+    throw new GitError({
+      msg: intl.str(
+        'bad-tag-name',
+        { tag: id }
+      )
+    });
+  }
+
+  this.makeTag(id, target);
+};
+
+GitEngine.prototype.makeBranch = function(id, target) {
+  if (this.refs[id]) {
+    var err = new Error();
+    throw new Error('woah already have that ref ' + id + ' ' + err.stack);
+  }
+
+  var branch = new Branch({
+    target: target,
+    id: id
+  });
+  this.branchCollection.add(branch);
+  this.refs[branch.get('id')] = branch;
+  return branch;
+};
+
+GitEngine.prototype.makeTag = function(id, target) {
+  if (this.refs[id]) {
+    throw new Error('woah already have that');
+  }
+
+  var tag = new Tag({
+    target: target,
+    id: id
+  });
+  this.tagCollection.add(tag);
+  this.refs[tag.get('id')] = tag;
+  return tag;
+};
+
+GitEngine.prototype.getHead = function() {
+  return Object.assign({}, this.HEAD);
+};
+
+GitEngine.prototype.getTags = function() {
+  var toReturn = [];
+  this.tagCollection.each(function(tag) {
+    toReturn.push({
+      id: tag.get('id'),
+      target: tag.get('target'),
+      remote: tag.getIsRemote(),
+      obj: tag
+    });
+  }, this);
+  return toReturn;
+};
+
+GitEngine.prototype.getBranches = function() {
+  var toReturn = [];
+  this.branchCollection.each(function(branch) {
+    toReturn.push({
+      id: branch.get('id'),
+      selected: this.HEAD.get('target') === branch,
+      target: branch.get('target'),
+      remote: branch.getIsRemote(),
+      obj: branch
+    });
+  }, this);
+  return toReturn;
+};
+
+GitEngine.prototype.getRemoteBranches = function() {
+  var all = this.getBranches();
+  return all.filter(function(branchJSON) {
+    return branchJSON.remote === true;
+  });
+};
+
+GitEngine.prototype.getLocalBranches = function() {
+  var all = this.getBranches();
+  return all.filter(function(branchJSON) {
+    return branchJSON.remote === false;
+  });
+};
+
+GitEngine.prototype.printBranchesWithout = function(without) {
+  var commitToBranches = this.getUpstreamBranchSet();
+  var commitID = this.getCommitFromRef(without).get('id');
+
+  var toPrint = commitToBranches[commitID].map(function (branchJSON) {
+    branchJSON.selected = this.HEAD.get('target').get('id') == branchJSON.id;
+    return branchJSON;
+  }, this);
+  this.printBranches(toPrint);
+};
+
+GitEngine.prototype.printBranches = function(branches) {
+  var result = '';
+  branches.forEach(branch => {
+    result += (branch.selected ? '* ' : '') + this.resolveName(branch.id).split('"')[1] + '\n';
+  });
+  throw new CommandResult({
+    msg: result
+  });
+};
+
+GitEngine.prototype.printTags = function(tags) {
+  var result = '';
+  tags.forEach(function (tag) {
+    result += tag.id + '\n';
+  });
+  throw new CommandResult({
+    msg: result
+  });
+};
+
+GitEngine.prototype.printRemotes = function(options) {
+  var result = '';
+  if (options.verbose) {
+    result += 'origin (fetch)\n';
+    result += TAB + 'git@github.com:pcottle/foo.git' + '\n\n';
+    result += 'origin (push)\n';
+    result += TAB + 'git@github.com:pcottle/foo.git';
+  } else {
+    result += 'origin';
+  }
+  throw new CommandResult({
+    msg: result
+  });
+};
+
+GitEngine.prototype.getUniqueID = function() {
+  var id = this.uniqueId('C');
+
+  var hasID = function(idToCheck) {
+    // loop through and see if we have it locally or
+    // remotely
+    if (this.refs[idToCheck]) {
+      return true;
+    }
+    if (this.origin && this.origin.refs[idToCheck]) {
+      return true;
+    }
+    return false;
+  }.bind(this);
+
+  while (hasID(id)) {
+    id = this.uniqueId('C');
+  }
+  return id;
+};
+
+GitEngine.prototype.makeCommit = function(parents, id, options) {
+  // ok we need to actually manually create commit IDs now because
+  // people like nikita (thanks for finding this!) could
+  // make branches named C2 before creating the commit C2
+  if (!id) {
+    id = this.getUniqueID();
+  }
+
+  var commit = new Commit(Object.assign({
+      parents: parents,
+      id: id,
+      gitVisuals: this.gitVisuals
+    },
+    options || {}
+  ));
+
+  this.refs[commit.get('id')] = commit;
+  this.commitCollection.add(commit);
+  return commit;
+};
+
+GitEngine.prototype.revert = function(whichCommits) {
+  // resolve the commits we will rebase
+  var toRevert = whichCommits.map(function(stringRef) {
+    return this.getCommitFromRef(stringRef);
+  }, this);
+
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+  var destBranch = this.resolveID('HEAD');
+
+  chain = this.animationFactory.highlightEachWithPromise(
+    chain,
+    toRevert,
+    destBranch
+  );
+
+  var base = this.getCommitFromRef('HEAD');
+  // each step makes a new commit
+  var chainStep = function(oldCommit) {
+    var newId = this.rebaseAltID(oldCommit.get('id'));
+    var commitMessage = intl.str('git-revert-msg', {
+      oldCommit: this.resolveName(oldCommit),
+      oldMsg: oldCommit.get('commitMessage')
+    });
+    var newCommit = this.makeCommit([base], newId, {
+      commitMessage: commitMessage
+    });
+    base = newCommit;
+
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.gitVisuals
+    );
+  }.bind(this);
+
+  // set up the promise chain
+  toRevert.forEach(function (commit) {
+    chain = chain.then(function() {
+      return chainStep(commit);
+    });
+  });
+
+  // done! update our location
+  chain = chain.then(function() {
+    this.setTargetLocation('HEAD', base);
+    return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+  }.bind(this));
+
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+GitEngine.prototype.reset = function(target) {
+  this.setTargetLocation('HEAD', this.getCommitFromRef(target));
+};
+
+GitEngine.prototype.setupCherrypickChain = function(toCherrypick) {
+  // error checks are all good, lets go!
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+  var destinationBranch = this.resolveID('HEAD');
+
+  chain = this.animationFactory.highlightEachWithPromise(
+    chain,
+    toCherrypick,
+    destinationBranch
+  );
+
+  var chainStep = function(commit) {
+    var newCommit = this.cherrypick(commit);
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.gitVisuals
+    );
+  }.bind(this);
+
+  toCherrypick.forEach(function (arg) {
+    chain = chain.then(function() {
+      return chainStep(arg);
+    });
+  }, this);
+
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+/*************************************
+ * Origin stuff!
+ ************************************/
+
+GitEngine.prototype.checkUpstreamOfSource = function(
+  target,
+  source,
+  targetBranch,
+  sourceBranch,
+  errorMsg
+) {
+  // here we are downloading some X number of commits from source onto
+  // target. Hence target should be strictly upstream of source
+
+  // lets first get the upstream set from source's dest branch
+  var upstream = Graph.getUpstreamSet(source, sourceBranch);
+
+  var targetLocationID = target.getCommitFromRef(targetBranch).get('id');
+  if (!upstream[targetLocationID]) {
+    throw new GitError({
+      msg: errorMsg || intl.str('git-error-origin-fetch-no-ff')
+    });
+  }
+};
+
+GitEngine.prototype.getTargetGraphDifference = function(
+  target,
+  source,
+  targetBranch,
+  sourceBranch,
+  options
+) {
+  options = options || {};
+  sourceBranch = source.resolveID(sourceBranch);
+
+  var targetSet = Graph.getUpstreamSet(target, targetBranch);
+  var sourceStartCommit = source.getCommitFromRef(sourceBranch);
+
+  var sourceTree = source.exportTree();
+  var sourceStartCommitJSON = sourceTree.commits[sourceStartCommit.get('id')];
+
+  if (targetSet[sourceStartCommitJSON.id]) {
+    // either we throw since theres no work to be done, or we return an empty array
+    if (options.dontThrowOnNoFetch) {
+      return [];
+    } else {
+      throw new GitError({
+        msg: intl.str('git-error-origin-fetch-uptodate')
+      });
+    }
+  }
+
+  // ok great, we have our starting point and our stopping set. lets go ahead
+  // and traverse upwards and keep track of depth manually
+  sourceStartCommitJSON.depth = 0;
+  var difference = [];
+  var toExplore = [sourceStartCommitJSON];
+
+  var pushParent = function(parentID) {
+    if (targetSet[parentID]) {
+      // we already have that commit, lets bounce
+      return;
+    }
+
+    var parentJSON = sourceTree.commits[parentID];
+    parentJSON.depth = here.depth + 1;
+    toExplore.push(parentJSON);
+  };
+
+  while (toExplore.length) {
+    var here = toExplore.pop();
+    difference.push(here);
+    here.parents.forEach(pushParent);
+  }
+
+  // filter because we weren't doing graph search
+  var differenceUnique = Graph.getUniqueObjects(difference);
+  /**
+   * Ok now we have to determine the order in which to make these commits.
+   * We used to just sort by depth because we were lazy but that is incorrect
+   * since it doesn't represent the actual dependency tree of the commits.
+   *
+   * So here is what we are going to do -- loop through the differenceUnique
+   * set and find a commit that has _all_ its parents in the targetSet. Then
+   * decide to make that commit first, expand targetSet, and then rinse & repeat
+   */
+  var inOrder = [];
+  var allParentsMade = function(node) {
+    var allParents = true;
+    node.parents.forEach(function(parent) {
+      allParents = allParents && targetSet[parent];
+    });
+    return allParents;
+  };
+
+  while (differenceUnique.length) {
+    for (var i = 0; i < differenceUnique.length; i++) {
+      if (!allParentsMade(differenceUnique[i])) {
+        // This commit cannot be made since not all of its dependencies are
+        // satisfied.
+        continue;
+      }
+
+      var makeThis = differenceUnique[i];
+      inOrder.push(makeThis);
+      // remove the commit
+      differenceUnique.splice(i, 1);
+      // expand target set
+      targetSet[makeThis.id] = true;
+    }
+  }
+  return inOrder;
+};
+
+GitEngine.prototype.push = function(options) {
+  options = options || {};
+
+  if (options.source === "") {
+    // delete case
+    this.pushDeleteRemoteBranch(
+      this.refs[ORIGIN_PREFIX + options.destination],
+      this.origin.refs[options.destination]
+    );
+    return;
+  }
+
+  var sourceBranch = this.resolveID(options.source);
+  if (sourceBranch && sourceBranch.attributes.type === 'tag') {
+    throw new GitError({
+      msg: intl.todo('Tags are not allowed as sources for pushing'),
+    });
+  }
+
+  if (!this.origin.doesRefExist(options.destination)) {
+    console.warn('ref', options.destination);
+    this.makeBranchOnOriginAndTrack(
+      options.destination,
+      this.getCommitFromRef(sourceBranch)
+    );
+    // play an animation now since we might not have to fast forward
+    // anything... this is weird because we are punting an animation
+    // and not resolving the promise but whatever
+    this.animationFactory.playRefreshAnimation(this.origin.gitVisuals);
+    this.animationFactory.playRefreshAnimation(this.gitVisuals);
+  }
+  var branchOnRemote = this.origin.resolveID(options.destination);
+  var sourceLocation = this.resolveID(options.source || 'HEAD');
+
+  // first check if this is even allowed by checking the sync between
+  if (!options.force) {
+    this.checkUpstreamOfSource(
+      this,
+      this.origin,
+      branchOnRemote,
+      sourceLocation,
+      intl.str('git-error-origin-push-no-ff')
+    );
+  }
+
+  var commitsToMake = this.getTargetGraphDifference(
+    this.origin,
+    this,
+    branchOnRemote,
+    sourceLocation,
+    /* options */ {
+      dontThrowOnNoFetch: true,
+    }
+  );
+  if (!commitsToMake.length) {
+    if (!options.force) {
+      // We are already up to date, and we can't be deleting
+      // either since we don't have --force
+      throw new GitError({
+        msg: intl.str('git-error-origin-fetch-uptodate')
+      });
+    } else {
+      var sourceCommit = this.getCommitFromRef(sourceBranch);
+      var originCommit = this.getCommitFromRef(branchOnRemote);
+      if (sourceCommit.id === originCommit.id) {
+        // This is essentially also being up to date
+        throw new GitError({
+          msg: intl.str('git-error-origin-fetch-uptodate')
+        });
+      }
+      // Otherwise fall through! We will update origin
+      // and essentially delete the commit
+    }
+  }
+
+  // now here is the tricky part -- the difference between local main
+  // and remote main might be commits C2, C3, and C4, but the remote
+  // might already have those commits. In this case, we don't need to
+  // make them, so filter these out
+  commitsToMake = commitsToMake.filter(function(commitJSON) {
+    return !this.origin.refs[commitJSON.id];
+  }, this);
+
+  var makeCommit = function(id, parentIDs) {
+    // need to get the parents first. since we order by depth, we know
+    // the dependencies are there already
+    var parents = parentIDs.map(function(parentID) {
+      return this.origin.refs[parentID];
+    }, this);
+    return this.origin.makeCommit(parents, id);
+  }.bind(this);
+
+  // now make the promise chain to make each commit
+  var chainStep = function(id, parents) {
+    var newCommit = makeCommit(id, parents);
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.origin.gitVisuals
+    );
+  }.bind(this);
+
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+
+  commitsToMake.forEach(function(commitJSON) {
+    chain = chain.then(function() {
+      return this.animationFactory.playHighlightPromiseAnimation(
+        this.refs[commitJSON.id],
+        branchOnRemote
+      );
+    }.bind(this));
+
+    chain = chain.then(function() {
+      return chainStep(
+        commitJSON.id,
+        commitJSON.parents
+      );
+    });
+  }, this);
+
+  chain = chain.then(function() {
+    var localLocationID = this.getCommitFromRef(sourceLocation).get('id');
+    var remoteCommit = this.origin.refs[localLocationID];
+    this.origin.setTargetLocation(branchOnRemote, remoteCommit);
+    // unhighlight local
+    this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    return this.animationFactory.playRefreshAnimation(this.origin.gitVisuals);
+  }.bind(this));
+
+  // HAX HAX update main and remote tracking for main
+  chain = chain.then(function() {
+    var localCommit = this.getCommitFromRef(sourceLocation);
+    this.setTargetLocation(this.resolveID(ORIGIN_PREFIX + options.destination), localCommit);
+    return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+  }.bind(this));
+
+  if (!options.dontResolvePromise) {
+    this.animationQueue.thenFinish(chain, deferred);
+  }
+};
+
+GitEngine.prototype.pushDeleteRemoteBranch = function(
+  remoteBranch,
+  branchOnRemote
+) {
+  if (branchOnRemote.get('id') === 'main') {
+    throw new GitError({
+      msg: intl.todo('You cannot delete main branch on remote!')
+    });
+  }
+  // ok so this isn't too bad -- we basically just:
+  // 1) instruct the remote to delete the branch
+  // 2) kill off the remote branch locally
+  // 3) find any branches tracking this remote branch and set them to not track
+  var id = remoteBranch.get('id');
+  this.origin.deleteBranch(branchOnRemote);
+  this.deleteBranch(remoteBranch);
+  this.branchCollection.each(function(branch) {
+    if (branch.getRemoteTrackingBranchID() === id) {
+      branch.setRemoteTrackingBranchID(null);
+    }
+  }, this);
+
+  // animation needs to be triggered on origin directly
+  this.origin.pruneTree();
+  this.origin.externalRefresh();
+};
+
+GitEngine.prototype.fetch = function(options) {
+  options = options || {};
+  var didMakeBranch;
+
+  // first check for super stupid case where we are just making
+  // a branch with fetch...
+  if (options.destination && options.source === '') {
+    this.validateAndMakeBranch(
+      options.destination,
+      this.getCommitFromRef('HEAD')
+    );
+    return;
+  } else if (options.destination && options.source) {
+    didMakeBranch = didMakeBranch || this.makeRemoteBranchIfNeeded(options.source);
+    didMakeBranch = didMakeBranch || this.makeBranchIfNeeded(options.destination);
+    options.didMakeBranch = didMakeBranch;
+
+    return this.fetchCore([{
+        destination: options.destination,
+        source: options.source
+      }],
+      options
+    );
+  }
+  // get all remote branches and specify the dest / source pairs
+  var allBranchesOnRemote = this.origin.branchCollection.toArray();
+  var sourceDestPairs = allBranchesOnRemote.map(function(branch) {
+    var branchName = branch.get('id');
+    didMakeBranch = didMakeBranch || this.makeRemoteBranchIfNeeded(branchName);
+
+    return {
+      destination: branch.getPrefixedID(),
+      source: branchName
+    };
+  }, this);
+  options.didMakeBranch = didMakeBranch;
+  return this.fetchCore(sourceDestPairs, options);
+};
+
+GitEngine.prototype.fetchCore = function(sourceDestPairs, options) {
+  // first check if our local remote branch is upstream of the origin branch set.
+  // this check essentially pretends the local remote branch is in origin and
+  // could be fast forwarded (basic sanity check)
+  sourceDestPairs.forEach(function (pair) {
+    this.checkUpstreamOfSource(
+      this,
+      this.origin,
+      pair.destination,
+      pair.source
+    );
+  }, this);
+
+  // then we get the difference in commits between these two graphs
+  var commitsToMake = [];
+  sourceDestPairs.forEach(function (pair) {
+    commitsToMake = commitsToMake.concat(this.getTargetGraphDifference(
+      this,
+      this.origin,
+      pair.destination,
+      pair.source,
+      Object.assign(
+        {},
+        options,
+        {dontThrowOnNoFetch: true}
+      )
+    ));
+  }, this);
+
+  if (!commitsToMake.length && !options.dontThrowOnNoFetch) {
+    throw new GitError({
+      msg: intl.str('git-error-origin-fetch-uptodate')
+    });
+  }
+
+  // we did this for each remote branch, but we still need to reduce to unique
+  // and sort. in this particular app we can never have unfected remote
+  // commits that are upstream of multiple branches (since the fakeTeamwork
+  // command simply commits), but we are doing it anyways for correctness
+  commitsToMake = Graph.getUniqueObjects(commitsToMake);
+  commitsToMake = Graph.descendSortDepth(commitsToMake);
+
+  // now here is the tricky part -- the difference between local main
+  // and remote main might be commits C2, C3, and C4, but we
+  // might already have those commits. In this case, we don't need to
+  // make them, so filter these out
+  commitsToMake = commitsToMake.filter(function(commitJSON) {
+    return !this.refs[commitJSON.id];
+  }, this);
+
+  var makeCommit = function(id, parentIDs) {
+    // need to get the parents first. since we order by depth, we know
+    // the dependencies are there already
+    var parents = parentIDs.map(function(parentID) {
+      return this.resolveID(parentID);
+    }, this);
+    return this.makeCommit(parents, id);
+  }.bind(this);
+
+  // now make the promise chain to make each commit
+  var chainStep = function(id, parents) {
+    var newCommit = makeCommit(id, parents);
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.gitVisuals
+    );
+  }.bind(this);
+
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+  if (options.didMakeBranch) {
+    chain = chain.then(function() {
+      this.animationFactory.playRefreshAnimation(this.origin.gitVisuals);
+      return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    }.bind(this));
+  }
+
+  var originBranchSet = this.origin.getUpstreamBranchSet();
+  commitsToMake.forEach(function (commitJSON) {
+    // technically we could grab the wrong one here
+    // but this works for now
+    var originBranch = originBranchSet[commitJSON.id][0].obj;
+    var localBranch = this.refs[originBranch.getPrefixedID()];
+
+    chain = chain.then(function() {
+      return this.animationFactory.playHighlightPromiseAnimation(
+        this.origin.resolveID(commitJSON.id),
+        localBranch
+      );
+    }.bind(this));
+
+    chain = chain.then(function() {
+      return chainStep(
+        commitJSON.id,
+        commitJSON.parents
+      );
+    });
+  }, this);
+
+  chain = chain.then(function() {
+    // update all the destinations
+    sourceDestPairs.forEach(function (pair) {
+      var ours = this.resolveID(pair.destination);
+      var theirCommitID = this.origin.getCommitFromRef(pair.source).get('id');
+      // by definition we just made the commit with this id,
+      // so we can grab it now
+      var localCommit = this.refs[theirCommitID];
+      this.setTargetLocation(ours, localCommit);
+    }, this);
+
+    // unhighlight origin by refreshing
+    this.animationFactory.playRefreshAnimation(this.origin.gitVisuals);
+    return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+  }.bind(this));
+
+  if (!options.dontResolvePromise) {
+    this.animationQueue.thenFinish(chain, deferred);
+  }
+  return {
+    chain: chain,
+    deferred: deferred
+  };
+};
+
+GitEngine.prototype.pull = function(options) {
+  options = options || {};
+  var localBranch = this.getOneBeforeCommit('HEAD');
+
+  // no matter what fetch
+  var pendingFetch = this.fetch({
+    dontResolvePromise: true,
+    dontThrowOnNoFetch: true,
+    source: options.source,
+    destination: options.destination
+  });
+
+  if (!pendingFetch) {
+    // short circuited for some reason
+    return;
+  }
+
+  var destBranch = this.resolveID(options.destination);
+  // then either rebase or merge
+  if (options.isRebase) {
+    this.pullFinishWithRebase(pendingFetch, localBranch, destBranch);
+  } else {
+    this.pullFinishWithMerge(pendingFetch, localBranch, destBranch);
+  }
+};
+
+GitEngine.prototype.pullFinishWithRebase = function(
+  pendingFetch,
+  localBranch,
+  remoteBranch
+) {
+  var chain = pendingFetch.chain;
+  var deferred = pendingFetch.deferred;
+  chain = chain.then(function() {
+    if (this.isUpstreamOf(remoteBranch, localBranch)) {
+      this.command.set('error', new CommandResult({
+        msg: intl.str('git-result-uptodate')
+      }));
+      throw SHORT_CIRCUIT_CHAIN;
+    }
+  }.bind(this));
+
+  // delay a bit after the intense refresh animation from
+  // fetch
+  chain = chain.then(function() {
+    return this.animationFactory.getDelayedPromise(300);
+  }.bind(this));
+
+  chain = chain.then(function() {
+    // highlight last commit on o/main to color of
+    // local branch
+    return this.animationFactory.playHighlightPromiseAnimation(
+      this.getCommitFromRef(remoteBranch),
+      localBranch
+    );
+  }.bind(this));
+
+  chain = chain.then(function() {
+    pendingFetch.dontResolvePromise = true;
+
+    // Lets move the git pull --rebase check up here.
+    if (this.isUpstreamOf(localBranch, remoteBranch)) {
+      this.setTargetLocation(
+        localBranch,
+        this.getCommitFromRef(remoteBranch)
+      );
+      this.checkout(localBranch);
+      return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    }
+
+    try {
+      return this.rebase(remoteBranch, localBranch, pendingFetch);
+    } catch (err) {
+      this.filterError(err);
+      if (err.getMsg() !== intl.str('git-error-rebase-none')) {
+        throw err;
+      }
+      this.setTargetLocation(
+        localBranch,
+        this.getCommitFromRef(remoteBranch)
+      );
+      this.checkout(localBranch);
+      return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    }
+  }.bind(this));
+  chain = chain.fail(catchShortCircuit);
+
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+GitEngine.prototype.pullFinishWithMerge = function(
+  pendingFetch,
+  localBranch,
+  remoteBranch
+) {
+  var chain = pendingFetch.chain;
+  var deferred = pendingFetch.deferred;
+
+  chain = chain.then(function() {
+    if (this.mergeCheck(remoteBranch, localBranch)) {
+      this.command.set('error', new CommandResult({
+        msg: intl.str('git-result-uptodate')
+      }));
+      throw SHORT_CIRCUIT_CHAIN;
+    }
+  }.bind(this));
+
+  // delay a bit after the intense refresh animation from
+  // fetch
+  chain = chain.then(function() {
+    return this.animationFactory.getDelayedPromise(300);
+  }.bind(this));
+
+  chain = chain.then(function() {
+    // highlight last commit on o/main to color of
+    // local branch
+    return this.animationFactory.playHighlightPromiseAnimation(
+      this.getCommitFromRef(remoteBranch),
+      localBranch
+    );
+  }.bind(this));
+
+  chain = chain.then(function() {
+    // highlight commit on main to color of remote
+    return this.animationFactory.playHighlightPromiseAnimation(
+      this.getCommitFromRef(localBranch),
+      remoteBranch
+    );
+  }.bind(this));
+
+  // delay and merge
+  chain = chain.then(function() {
+    return this.animationFactory.getDelayedPromise(700);
+  }.bind(this));
+  chain = chain.then(function() {
+    var newCommit = this.merge(remoteBranch);
+    if (!newCommit) {
+      // it is a fast forward
+      return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+    }
+
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.gitVisuals
+    );
+  }.bind(this));
+  chain = chain.fail(catchShortCircuit);
+
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+GitEngine.prototype.fakeTeamwork = function(numToMake, branch) {
+  var makeOriginCommit = function() {
+    var id = this.getUniqueID();
+    return this.origin.receiveTeamwork(id, branch, this.animationQueue);
+  }.bind(this);
+
+  var chainStep = function() {
+    var newCommit = makeOriginCommit();
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.origin.gitVisuals
+    );
+  }.bind(this);
+
+  var deferred = Q.defer();
+  var chain = deferred.promise;
+
+  for(var i = 0; i < numToMake; i++) {
+    chain = chain.then(chainStep);
+  }
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+GitEngine.prototype.receiveTeamwork = function(id, branch, animationQueue) {
+  this.checkout(this.resolveID(branch));
+  var newCommit = this.makeCommit([this.getCommitFromRef('HEAD')], id);
+  this.setTargetLocation(this.HEAD, newCommit);
+
+  return newCommit;
+};
+
+GitEngine.prototype.cherrypick = function(commit) {
+  // alter the ID slightly
+  var id = this.rebaseAltID(commit.get('id'));
+
+  // now commit with that id onto HEAD
+  var newCommit = this.makeCommit([this.getCommitFromRef('HEAD')], id);
+  this.setTargetLocation(this.HEAD, newCommit);
+
+  return newCommit;
+};
+
+GitEngine.prototype.commit = function(options) {
+  options = options || {};
+  var targetCommit = this.getCommitFromRef(this.HEAD);
+  var id = null;
+
+  // if we want to amend, go one above
+  if (options.isAmend) {
+    targetCommit = this.resolveID('HEAD~1');
+    id = this.rebaseAltID(this.getCommitFromRef('HEAD').get('id'));
+  }
+
+  var newCommit = this.makeCommit([targetCommit], id);
+  if (this.getDetachedHead() && this.mode === 'git') {
+    this.command.addWarning(intl.str('git-warning-detached'));
+  }
+
+  this.setTargetLocation(this.HEAD, newCommit);
+  return newCommit;
+};
+
+GitEngine.prototype.resolveNameNoPrefix = function(someRef) {
+  // first get the obj
+  var obj = this.resolveID(someRef);
+  if (obj.get('type') == 'commit') {
+    return obj.get('id');
+  }
+  if (obj.get('type') == 'branch') {
+    return obj.get('id');
+  }
+  // we are dealing with HEAD
+  return this.resolveNameNoPrefix(obj.get('target'));
+};
+
+GitEngine.prototype.resolveName = function(someRef) {
+  // first get the obj
+  var obj = this.resolveID(someRef);
+  if (obj.get('type') == 'commit') {
+    return 'commit ' + obj.get('id');
+  }
+  if (obj.get('type') == 'branch') {
+    return 'branch "' + obj.get('id') + '"';
+  }
+  // we are dealing with HEAD
+  return this.resolveName(obj.get('target'));
+};
+
+GitEngine.prototype.resolveID = function(idOrTarget) {
+  if (idOrTarget === null || idOrTarget === undefined) {
+    var err = new Error();
+    throw new Error('Don\'t call this with null / undefined: ' + err.stack);
+  }
+
+  if (typeof idOrTarget !== 'string') {
+    return idOrTarget;
+  }
+  return this.resolveStringRef(idOrTarget);
+};
+
+GitEngine.prototype.resolveRelativeRef = function(commit, relative) {
+  var regex = /([~\^])(\d*)/g;
+  var matches;
+
+  while (matches = regex.exec(relative)) {
+    var next = commit;
+    var num = matches[2] ? parseInt(matches[2], 10) : 1;
+
+    if (matches[1] == '^') {
+      next = commit.getParent(num-1);
+    } else {
+      while (next && num--) {
+        next = next.getParent(0);
+      }
+    }
+
+    if (!next) {
+      var msg = intl.str('git-error-relative-ref', {
+        commit: commit.id,
+        match: matches[0]
+      });
+      throw new GitError({
+        msg: msg
+      });
+    }
+
+    commit = next;
+  }
+
+  return commit;
+};
+
+GitEngine.prototype.doesRefExist = function(ref) {
+  return !!this.refs[ref]
+};
+
+GitEngine.prototype.resolveStringRef = function(ref) {
+  ref = this.crappyUnescape(ref);
+
+  if (this.refs[ref]) {
+    return this.refs[ref];
+  }
+  // Commit hashes like C4 are case insensitive
+  if (ref.match(/^c\d+'*/) && this.refs[ref.toUpperCase()]) {
+    return this.refs[ref.toUpperCase()];
+  }
+
+  // Attempt to split ref string into a reference and a string of ~ and ^ modifiers.
+  var startRef = null;
+  var relative = null;
+  var regex = /^([a-zA-Z0-9]+)(([~\^]\d*)*)$/;
+  var matches = regex.exec(ref);
+  if (matches) {
+    startRef = matches[1];
+    relative = matches[2];
+  } else {
+    throw new GitError({
+      msg: intl.str('git-error-exist', {ref: ref})
+    });
+  }
+
+  if (!this.refs[startRef]) {
+    throw new GitError({
+      msg: intl.str('git-error-exist', {ref: ref})
+    });
+  }
+  var commit = this.getCommitFromRef(startRef);
+
+  if (relative) {
+    commit = this.resolveRelativeRef( commit, relative );
+  }
+
+  return commit;
+};
+
+GitEngine.prototype.getCommitFromRef = function(ref) {
+  var start = this.resolveID(ref);
+
+  // works for both HEAD and just a single layer. aka branch
+  while (start.get('type') !== 'commit') {
+    start = start.get('target');
+  }
+  return start;
+};
+
+GitEngine.prototype.getType = function(ref) {
+  return this.resolveID(ref).get('type');
+};
+
+GitEngine.prototype.setTargetLocation = function(ref, target) {
+  if (this.getType(ref) == 'commit') {
+    // nothing to do
+    return;
+  }
+
+  // sets whatever ref is (branch, HEAD, etc) to a target. so if
+  // you pass in HEAD, and HEAD is pointing to a branch, it will update
+  // the branch to that commit, not the HEAD
+  ref = this.getOneBeforeCommit(ref);
+  ref.set('target', target);
+};
+
+GitEngine.prototype.updateBranchesFromSet = function(commitSet) {
+  if (!commitSet) {
+    throw new Error('need commit set here');
+  }
+  // commitSet is the set of commits that are stale or moved or whatever.
+  // any branches POINTING to these commits need to be moved!
+
+  // first get a list of what branches influence what commits
+  var upstreamSet = this.getUpstreamBranchSet();
+
+  var branchesToUpdate = {};
+  // now loop over the set we got passed in and find which branches
+  // that means (aka intersection)
+  commitSet.forEach(function (val, id) {
+    upstreamSet[id].forEach(function (branchJSON) {
+        branchesToUpdate[branchJSON.id] = true;
+    });
+  }, this);
+
+  var branchList = branchesToUpdate.map(function(val, id) {
+    return id;
+  });
+  return this.updateBranchesForHg(branchList);
+};
+
+GitEngine.prototype.updateAllBranchesForHgAndPlay = function(branchList) {
+  return this.updateBranchesForHg(branchList) &&
+    this.animationFactory.playRefreshAnimationSlow(this.gitVisuals);
+};
+
+GitEngine.prototype.updateAllBranchesForHg = function() {
+  var branchList = this.branchCollection.map(function(branch) {
+    return branch.get('id');
+  });
+  return this.updateBranchesForHg(branchList);
+};
+
+GitEngine.prototype.syncRemoteBranchFills = function() {
+  this.branchCollection.each(function(branch) {
+    if (!branch.getIsRemote()) {
+      return;
+    }
+    var originBranch = this.origin.refs[branch.getBaseID()];
+    if (!originBranch.get('visBranch')) {
+      // testing mode doesn't get this
+      return;
+    }
+    var originFill = originBranch.get('visBranch').get('fill');
+    branch.get('visBranch').set('fill', originFill);
+  }, this);
+};
+
+GitEngine.prototype.updateBranchesForHg = function(branchList) {
+  var hasUpdated = false;
+  branchList.forEach(function (branchID) {
+    // ok now just check if this branch has a more recent commit available.
+    // that mapping is easy because we always do rebase alt id --
+    // theres no way to have C3' and C3''' but no C3''. so just
+    // bump the ID once -- if thats not filled in we are updated,
+    // otherwise loop until you find undefined
+    var commitID = this.getCommitFromRef(branchID).get('id');
+    var altID = this.getBumpedID(commitID);
+    if (!this.refs[altID]) {
+      return;
+    }
+    hasUpdated = true;
+
+    var lastID;
+    while (this.refs[altID]) {
+      lastID = altID;
+      altID = this.rebaseAltID(altID);
+    }
+
+    // last ID is the one we want to update to
+    this.setTargetLocation(this.refs[branchID], this.refs[lastID]);
+  }, this);
+
+  if (!hasUpdated) {
+    return false;
+  }
+  return true;
+};
+
+GitEngine.prototype.updateCommitParentsForHgRebase = function(commitSet) {
+  var anyChange = false;
+  Object.keys(commitSet).forEach(function(commitID) {
+    var commit = this.refs[commitID];
+    var thisUpdated = commit.checkForUpdatedParent(this);
+    anyChange = anyChange || thisUpdated;
+  }, this);
+  return anyChange;
+};
+
+GitEngine.prototype.pruneTreeAndPlay = function() {
+  return this.pruneTree() &&
+    this.animationFactory.playRefreshAnimationSlow(this.gitVisuals);
+};
+
+GitEngine.prototype.pruneTree = function(doPrintWarning = true) {
+  var set = this.getUpstreamBranchSet();
+  // don't prune commits that HEAD depends on
+  var headSet = Graph.getUpstreamSet(this, 'HEAD');
+  Object.keys(headSet).forEach(function(commitID) {
+    set[commitID] = true;
+  });
+  Object.keys(this.getUpstreamTagSet()).forEach(commitID => set[commitID] = true);
+
+  var toDelete = [];
+  this.commitCollection.each(function(commit) {
+    // nothing cares about this commit :(
+    if (!set[commit.get('id')]) {
+      toDelete.push(commit);
+    }
+  }, this);
+
+  if (!toDelete.length) {
+    // returning nothing will perform
+    // the switch sync
+    return;
+  }
+  if (this.command && doPrintWarning) {
+    this.command.addWarning(intl.str('hg-prune-tree'));
+  }
+
+  toDelete.forEach(function (commit) {
+    commit.removeFromParents();
+    this.commitCollection.remove(commit);
+
+    var ID = commit.get('id');
+    this.refs[ID] = undefined;
+    delete this.refs[ID];
+
+    var visNode = commit.get('visNode');
+    if (visNode) {
+      visNode.removeAll();
+    }
+  }, this);
+
+  return true;
+};
+GitEngine.prototype.getUpstreamBranchSet = function() {
+  return this.getUpstreamCollectionSet(this.branchCollection);
+};
+
+GitEngine.prototype.getUpstreamTagSet = function() {
+  return this.getUpstreamCollectionSet(this.tagCollection);
+};
+
+GitEngine.prototype.getUpstreamCollectionSet = function(collection) {
+  // this is expensive!! so only call once in a while
+  var commitToSet = {};
+
+  var inArray = function(arr, id) {
+    var found = false;
+    arr.forEach(function (wrapper) {
+      if (wrapper.id == id) {
+        found = true;
+      }
+    });
+
+    return found;
+  };
+
+  var bfsSearch = function(commit) {
+    var set = [];
+    var pQueue = [commit];
+    while (pQueue.length) {
+      var popped = pQueue.pop();
+      set.push(popped.get('id'));
+
+      if (popped.get('parents') && popped.get('parents').length) {
+        pQueue = pQueue.concat(popped.get('parents'));
+      }
+    }
+    return set;
+  };
+
+  collection.each(function(ref) {
+    var set = bfsSearch(ref.get('target'));
+    set.forEach(function (id) {
+      commitToSet[id] = commitToSet[id] || [];
+
+      // only add it if it's not there, so hue blending is ok
+      if (!inArray(commitToSet[id], ref.get('id'))) {
+        commitToSet[id].push({
+          obj: ref,
+          id: ref.get('id')
+        });
+      }
+    });
+  });
+
+  return commitToSet;
+};
+
+GitEngine.prototype.getUpstreamHeadSet = function() {
+  var set = Graph.getUpstreamSet(this, 'HEAD');
+  var including = this.getCommitFromRef('HEAD').get('id');
+
+  set[including] = true;
+  return set;
+};
+
+GitEngine.prototype.getOneBeforeCommit = function(ref) {
+  // you can call this command on HEAD in detached, HEAD, or on a branch
+  // and it will return the ref that is one above a commit. aka
+  // it resolves HEAD to something that we can move the ref with
+  var start = this.resolveID(ref);
+  if (start === this.HEAD && !this.getDetachedHead()) {
+    start = start.get('target');
+  }
+  return start;
+};
+
+GitEngine.prototype.scrapeBaseID = function(id) {
+  var results = /^C(\d+)/.exec(id);
+
+  if (!results) {
+    throw new Error('regex failed on ' + id);
+  }
+
+  return 'C' + results[1];
+};
+
+/*
+ * grabs a bumped ID that is NOT currently reserved
+ */
+GitEngine.prototype.rebaseAltID = function(id) {
+  var newID = this.getBumpedID(id);
+  while (this.refs[newID]) {
+    newID = this.getBumpedID(newID);
+  }
+  return newID;
+};
+
+GitEngine.prototype.getMostRecentBumpedID = function(id) {
+  var newID = id;
+  var lastID;
+  while (this.refs[newID]) {
+    lastID = newID;
+    newID = this.getBumpedID(newID);
+  }
+  return lastID;
+};
+
+GitEngine.prototype.getBumpedID = function(id) {
+  // this function alters an ID to add a quote to the end,
+  // indicating that it was rebased.
+  var regexMap = [
+    [/^C(\d+)[']{0,2}$/, function(bits) {
+      // this id can use another quote, so just add it
+      return bits[0] + "'";
+    }],
+    [/^C(\d+)[']{3}$/, function(bits) {
+      // here we switch from C''' to C'^4
+      return bits[0].slice(0, -3) + "'^4";
+    }],
+    [/^C(\d+)['][\^](\d+)$/, function(bits) {
+      return 'C' + String(bits[1]) + "'^" + String(Number(bits[2]) + 1);
+    }]
+  ];
+
+  // for loop for early return (instead of _.each)
+  for (var i = 0; i < regexMap.length; i++) {
+    var regex = regexMap[i][0];
+    var func = regexMap[i][1];
+    var results = regex.exec(id);
+    if (results) {
+      return func(results);
+    }
+  }
+  throw new Error('could not modify the id ' + id);
+};
+
+GitEngine.prototype.idSortFunc = function(cA, cB) {
+  // commit IDs can come in many forms:
+  //  C4
+  //  C4' (from a rebase)
+  //  C4'' (from multiple rebases)
+  //  C4'^3 (from a BUNCH of rebases)
+
+  var scale = 1000;
+
+  var regexMap = [
+    [/^C(\d+)$/, function(bits) {
+      // return the 4 from C4
+      return scale * bits[1];
+    }],
+    [/^C(\d+)([']+)$/, function(bits) {
+      // return the 4 from C4, plus the length of the quotes
+      return scale * bits[1] + bits[2].length;
+    }],
+    [/^C(\d+)['][\^](\d+)$/, function(bits) {
+      return scale * bits[1] + Number(bits[2]);
+    }]
+  ];
+
+  var getNumToSort = function(id) {
+    for (var i = 0; i < regexMap.length; i++) {
+      var regex = regexMap[i][0];
+      var func = regexMap[i][1];
+      var results = regex.exec(id);
+      if (results) {
+        return func(results);
+      }
+    }
+    throw new Error('Could not parse commit ID ' + id);
+  };
+
+  // We usually want to sort by reverse chronological order, aka the
+  // "latest" commits have the highest values. When we did this
+  // with date sorting, that means the commit C1 at t=0 should have
+  // a lower value than the commit C2 at t=1. We do this by doing
+  // t0 - t1 and get a negative number. Same goes for ID sorting,
+  // which means C1 - C2 = -1
+  return getNumToSort(cA.get('id')) - getNumToSort(cB.get('id'));
+};
+
+GitEngine.prototype.dateSortFunc = function(cA, cB) {
+  // We used to use date sorting, but its hacky so lets switch to ID sorting
+  // to eliminate non-determinism
+  return GitEngine.prototype.idSortFunc(cA, cB);
+};
+
+GitEngine.prototype.hgRebase = function(destination, base) {
+  var deferred = Q.defer();
+  var chain = this.rebase(destination, base, {
+    dontResolvePromise: true,
+    deferred: deferred
+  });
+
+  // was upstream or something
+  if (!chain) {
+    return;
+  }
+
+  // ok lets grab the merge base first
+  var commonAncestor = this.getCommonAncestor(destination, base);
+  var baseCommit = this.getCommitFromRef(base);
+  // we need everything BELOW ourselves...
+  var downstream = this.getDownstreamSet(base);
+  // and we need to go upwards to the stop set
+  var stopSet = Graph.getUpstreamSet(this, destination);
+  var upstream = this.getUpstreamDiffSetFromSet(stopSet, base);
+
+  // and NOWWWwwww get all the descendants of this set
+  var moreSets = [];
+  Object.keys(upstream).forEach(function(id) {
+    moreSets.push(this.getDownstreamSet(id));
+  }, this);
+
+  var mainSet = {};
+  mainSet[baseCommit.get('id')] = true;
+  [upstream, downstream].concat(moreSets).forEach(function(set) {
+    Object.keys(set).forEach(function(id) {
+      mainSet[id] = true;
+    });
+  });
+
+  // we also need the branches POINTING to main set
+  var branchMap = {};
+  var upstreamSet = this.getUpstreamBranchSet();
+  Object.keys(mainSet).forEach(function(commitID) {
+    // now loop over that commits branches
+    upstreamSet[commitID].forEach(function(branchJSON) {
+      branchMap[branchJSON.id] = true;
+    });
+  });
+
+  var branchList = Object.keys(branchMap);
+
+  chain = chain.then(function() {
+    // now we just moved a bunch of commits, but we haven't updated the
+    // dangling guys. lets do that and then prune
+    var anyChange = this.updateCommitParentsForHgRebase(mainSet);
+    if (!anyChange) {
+      return;
+    }
+    return this.animationFactory.playRefreshAnimationSlow(this.gitVisuals);
+  }.bind(this));
+
+  chain = chain.then(function() {
+    return this.updateAllBranchesForHgAndPlay(branchList);
+  }.bind(this));
+
+  chain = chain.then(function() {
+    // now that we have moved branches, lets prune
+    return this.pruneTreeAndPlay();
+  }.bind(this));
+
+  this.animationQueue.thenFinish(chain, deferred);
+};
+
+GitEngine.prototype.rebase = function(targetSource, currentLocation, options) {
+  // first some conditions
+  if (this.isUpstreamOf(targetSource, currentLocation)) {
+    this.command.setResult(intl.str('git-result-uptodate'));
+
+    // git for some reason always checks out the branch you are rebasing,
+    // no matter the result of the rebase
+    this.checkout(currentLocation);
+
+    // returning instead of throwing makes a tree refresh
+    return;
+  }
+
+  if (this.isUpstreamOf(currentLocation, targetSource)) {
+    // just set the target of this current location to the source
+    this.setTargetLocation(currentLocation, this.getCommitFromRef(targetSource));
+    // we need the refresh tree animation to happen, so set the result directly
+    // instead of throwing
+    this.command.setResult(intl.str('git-result-fastforward'));
+
+    this.checkout(currentLocation);
+    return;
+  }
+
+  // now the part of actually rebasing.
+  // We need to get the downstream set of targetSource first.
+  // then we BFS from currentLocation, using the downstream set as our stopping point.
+  // we need to BFS because we need to include all commits below
+  // pop these commits on top of targetSource and modify their ids with quotes
+  var stopSet = Graph.getUpstreamSet(this, targetSource);
+  var toRebaseRough = this.getUpstreamDiffFromSet(stopSet, currentLocation);
+  return this.rebaseFinish(toRebaseRough, stopSet, targetSource, currentLocation, options);
+};
+
+GitEngine.prototype.rebaseOnto = function(targetSource, oldSource, unit, options) {
+  if (this.isUpstreamOf(unit, targetSource)) {
+    this.setTargetLocation(unit, this.getCommitFromRef(targetSource));
+    this.command.setResult(intl.str('git-result-fastforward'));
+
+    this.checkout(unit);
+    return;
+  }
+
+  var stopSet = Graph.getUpstreamSet(this, targetSource);
+  var oldBranchSet = Graph.getUpstreamSet(this, oldSource);
+  var toRebaseRough = this.getUpstreamDiffFromSet(oldBranchSet, unit);
+  return this.rebaseFinish(toRebaseRough, stopSet, targetSource, unit, options);
+};
+
+GitEngine.prototype.getUpstreamDiffSetFromSet = function(stopSet, location) {
+  var set = {};
+  this.getUpstreamDiffFromSet(stopSet, location).forEach(function (commit) {
+    set[commit.get('id')] = true;
+  });
+  return set;
+};
+
+GitEngine.prototype.getUpstreamDiffFromSet = function(stopSet, location) {
+  var result = Graph.bfsFromLocationWithSet(this, location, stopSet);
+  result.sort(this.dateSortFunc);
+  return result;
+};
+
+GitEngine.prototype.getInteractiveRebaseCommits = function(targetSource, currentLocation) {
+  var stopSet = Graph.getUpstreamSet(this, targetSource);
+  var toRebaseRough = [];
+
+  // standard BFS
+  var pQueue = [this.getCommitFromRef(currentLocation)];
+
+  while (pQueue.length) {
+    var popped = pQueue.pop();
+
+    if (stopSet[popped.get('id')]) {
+      continue;
+    }
+
+    toRebaseRough.push(popped);
+    pQueue = pQueue.concat(popped.get('parents'));
+    pQueue.sort(this.dateSortFunc);
+  }
+
+  // throw out merge's real fast and see if we have anything to do
+  var toRebase = [];
+  toRebaseRough.forEach(function (commit) {
+    if (commit.get('parents').length == 1) {
+      toRebase.push(commit);
+    }
+  });
+
+  if (!toRebase.length) {
+    throw new GitError({
+      msg: intl.str('git-error-rebase-none')
+    });
+  }
+
+  return toRebase;
+};
+
+GitEngine.prototype.rebaseInteractiveTest = function(targetSource, currentLocation, options) {
+  options = options || {};
+
+  // Get the list of commits that would be displayed to the user
+  var toRebase = this.getInteractiveRebaseCommits(targetSource, currentLocation);
+
+  var rebaseMap = {};
+  toRebase.forEach(function (commit) {
+    var id = commit.get('id');
+    rebaseMap[id] = commit;
+  });
+
+  var rebaseOrder;
+  if (options['interactiveTest'].length === 0) {
+    // If no commits were explicitly specified for the rebase, act like the user didn't change anything
+    // in the rebase dialog and hit confirm
+    rebaseOrder = toRebase;
+  } else {
+    // Get the list and order of commits specified
+    var idsToRebase = options['interactiveTest'][0].split(',');
+
+    // Verify each chosen commit exists in the list of commits given to the user
+    var extraCommits = [];
+    rebaseOrder = [];
+    idsToRebase.forEach(function (id) {
+      if (id in rebaseMap) {
+        rebaseOrder.push(rebaseMap[id]);
+      } else {
+        extraCommits.push(id);
+      }
+    });
+
+    if (extraCommits.length > 0) {
+      throw new GitError({
+        msg: intl.todo('Hey those commits don\'t exist in the set!')
+      });
+    }
+  }
+
+  this.rebaseFinish(rebaseOrder, {}, targetSource, currentLocation);
+};
+
+GitEngine.prototype.rebaseInteractive = function(targetSource, currentLocation, options) {
+  options = options || {};
+
+  // there are a reduced set of checks now, so we can't exactly use parts of the rebase function
+  // but it will look similar.
+  var toRebase = this.getInteractiveRebaseCommits(targetSource, currentLocation);
+
+  // now do stuff :D since all our validation checks have passed, we are going to defer animation
+  // and actually launch the dialog
+  this.animationQueue.set('defer', true);
+
+  var deferred = Q.defer();
+  deferred.promise
+  .then(function(userSpecifiedRebase) {
+    // first, they might have dropped everything (annoying)
+    if (!userSpecifiedRebase.length) {
+      throw new CommandResult({
+        msg: intl.str('git-result-nothing')
+      });
+    }
+
+    // finish the rebase crap and animate!
+    this.rebaseFinish(userSpecifiedRebase, {}, targetSource, currentLocation);
+  }.bind(this))
+  .fail(function(err) {
+    this.filterError(err);
+    this.command.set('error', err);
+    this.animationQueue.start();
+  }.bind(this))
+  .done();
+
+  // If we have a solution provided, set up the GUI to display it by default
+  var initialCommitOrdering;
+  if (options.initialCommitOrdering && options.initialCommitOrdering.length > 0) {
+    var rebaseMap = {};
+    toRebase.forEach(function (commit) {
+      rebaseMap[commit.get('id')] = true;
+    });
+
+    // Verify each chosen commit exists in the list of commits given to the user
+    initialCommitOrdering = [];
+    options.initialCommitOrdering[0].split(',').forEach(function (id) {
+      if (!rebaseMap[id]) {
+        throw new GitError({
+          msg: intl.todo('Hey those commits don\'t exist in the set!')
+        });
+      }
+      initialCommitOrdering.push(id);
+    });
+  }
+
+  var InteractiveRebaseView = require('../views/rebaseView').InteractiveRebaseView;
+  // interactive rebase view will reject or resolve our promise
+  new InteractiveRebaseView({
+    deferred: deferred,
+    toRebase: toRebase,
+    initialCommitOrdering: initialCommitOrdering,
+    aboveAll: options.aboveAll
+  });
+};
+
+GitEngine.prototype.filterRebaseCommits = function(
+  toRebaseRough,
+  stopSet,
+  options
+) {
+  var changesAlreadyMade = {};
+  Object.keys(stopSet).forEach(function(key) {
+    changesAlreadyMade[this.scrapeBaseID(key)] = true;
+  }, this);
+  var uniqueIDs = {};
+
+  // resolve the commits we will rebase
+  return toRebaseRough.filter(function(commit) {
+    // no merge commits, unless we preserve
+    if (commit.get('parents').length !== 1 && !options.preserveMerges) {
+      return false;
+    }
+
+    // we ALSO need to throw out commits that will do the same changes. like
+    // if the upstream set has a commit C4 and we have C4', we don't rebase the C4' again.
+    var baseID = this.scrapeBaseID(commit.get('id'));
+    if (changesAlreadyMade[baseID]) {
+      return false;
+    }
+
+    // make unique
+    if (uniqueIDs[commit.get('id')]) {
+      return false;
+    }
+
+    uniqueIDs[commit.get('id')] = true;
+    return true;
+  }, this);
+};
+
+GitEngine.prototype.getRebasePreserveMergesParents = function(oldCommit) {
+  var oldParents = oldCommit.get('parents');
+  return oldParents.map(function(parent) {
+    var oldID = parent.get('id');
+    var newID = this.getMostRecentBumpedID(oldID);
+    return this.refs[newID];
+  }, this);
+};
+
+GitEngine.prototype.rebaseFinish = function(
+  toRebaseRough,
+  stopSet,
+  targetSource,
+  currentLocation,
+  options
+) {
+  options = options || {};
+  // now we have the all the commits between currentLocation and the set of target to rebase.
+  var destinationBranch = this.resolveID(targetSource);
+  var deferred = options.deferred || Q.defer();
+  var chain = options.chain || deferred.promise;
+
+  var toRebase = this.filterRebaseCommits(toRebaseRough, stopSet, options);
+  if (!toRebase.length) {
+    throw new GitError({
+      msg: intl.str('git-error-rebase-none')
+    });
+  }
+
+  chain = this.animationFactory.highlightEachWithPromise(
+    chain,
+    toRebase,
+    destinationBranch
+  );
+
+  // now pop all of these commits onto targetLocation
+  var base = this.getCommitFromRef(targetSource);
+  var hasStartedChain = false;
+  // each step makes a new commit
+  var chainStep = function(oldCommit) {
+    var newId = this.rebaseAltID(oldCommit.get('id'));
+    var parents;
+    if (!options.preserveMerges || !hasStartedChain) {
+      // easy logic since we just have a straight line
+      parents = [base];
+    } else { // preserving merges
+      // we always define the parent for the first commit to plop,
+      // otherwise search for most recent parents
+      parents = (hasStartedChain) ?
+        this.getRebasePreserveMergesParents(oldCommit) :
+        [base];
+    }
+
+    var newCommit = this.makeCommit(parents, newId);
+    base = newCommit;
+    hasStartedChain = true;
+
+    return this.animationFactory.playCommitBirthPromiseAnimation(
+      newCommit,
+      this.gitVisuals
+    );
+  }.bind(this);
+
+  // set up the promise chain
+  toRebase.forEach(function (commit) {
+    chain = chain.then(function() {
+      return chainStep(commit);
+    });
+  }, this);
+
+  chain = chain.then(function() {
+    if (this.resolveID(currentLocation).get('type') == 'commit') {
+      // we referenced a commit like git rebase C2 C1, so we have
+      // to manually check out C1'
+      this.checkout(base);
+    } else {
+      // now we just need to update the rebased branch is
+      this.setTargetLocation(currentLocation, base);
+      this.checkout(currentLocation);
+    }
+    return this.animationFactory.playRefreshAnimation(this.gitVisuals);
+  }.bind(this));
+
+  if (!options.dontResolvePromise) {
+    this.animationQueue.thenFinish(chain, deferred);
+  }
+  return chain;
+};
+
+GitEngine.prototype.mergeCheck = function(targetSource, currentLocation) {
+  var sameCommit = this.getCommitFromRef(targetSource) ===
+    this.getCommitFromRef(currentLocation);
+  return this.isUpstreamOf(targetSource, currentLocation) || sameCommit;
+};
+
+GitEngine.prototype.merge = function(targetSource, options) {
+  options = options || {};
+  var currentLocation = 'HEAD';
+
+  // first some conditions
+  if (this.mergeCheck(targetSource, currentLocation)) {
+    throw new CommandResult({
+      msg: intl.str('git-result-uptodate')
+    });
+  }
+
+  if (this.isUpstreamOf(currentLocation, targetSource) && !options.noFF) {
+    // just set the target of this current location to the source
+    this.setTargetLocation(currentLocation, this.getCommitFromRef(targetSource));
+    // get fresh animation to happen
+    this.command.setResult(intl.str('git-result-fastforward'));
+    return;
+  }
+
+  // now the part of making a merge commit
+  var parent1 = this.getCommitFromRef(currentLocation);
+  var parent2 = this.getCommitFromRef(targetSource);
+
+  // we need a fancy commit message
+  var msg = intl.str(
+    'git-merge-msg',
+    {
+      target: this.resolveName(targetSource),
+      current: this.resolveName(currentLocation)
+    }
+  );
+  // since we specify parent 1 as the first parent, it is the "main" parent
+  // and the node will be displayed below that branch / commit / whatever
+  var mergeCommit = this.makeCommit(
+    [parent1, parent2],
+    null,
+    {
+      commitMessage: msg
+    }
+  );
+
+  this.setTargetLocation(currentLocation, mergeCommit);
+  return mergeCommit;
+};
+
+GitEngine.prototype.checkout = function(idOrTarget) {
+  var target = this.resolveID(idOrTarget);
+  if (target.get('id') === 'HEAD') {
+    // git checkout HEAD is a
+    // meaningless command but i used to do this back in the day
+    return;
+  }
+
+  var type = target.get('type');
+  // check if this is an origin branch, and if so go to the commit referenced
+  if (type === 'branch' && target.getIsRemote()) {
+    target = this.getCommitFromRef(target.get('id'));
+  }
+
+  if (type !== 'branch' && type !== 'tag' && type !== 'commit') {
+    throw new GitError({
+      msg: intl.str('git-error-options')
+    });
+  }
+  if (type === 'tag') {
+    target = target.get('target');
+  }
+
+  this.HEAD.set('target', target);
+};
+
+GitEngine.prototype.forceBranch = function(branchName, where) {
+  branchName = this.crappyUnescape(branchName);
+  // if branchname doesn't exist...
+  if (!this.doesRefExist(branchName)) {
+    this.branch(branchName, where);
+  }
+
+  var branch = this.resolveID(branchName);
+
+  if (branch.get('type') !== 'branch') {
+    throw new GitError({
+      msg: intl.str('git-error-options')
+    });
+  }
+  if (branch.getIsRemote()) {
+    throw new GitError({
+      msg: intl.str('git-error-remote-branch')
+    });
+  }
+
+  var whereCommit = this.getCommitFromRef(where);
+
+  this.setTargetLocation(branch, whereCommit);
+};
+
+GitEngine.prototype.branch = function(name, ref) {
+  var target = this.getCommitFromRef(ref);
+  var newBranch = this.validateAndMakeBranch(name, target);
+
+  ref = this.resolveID(ref);
+  if (this.isRemoteBranchRef(ref)) {
+    this.setLocalToTrackRemote(newBranch, ref);
+  }
+};
+
+GitEngine.prototype.isRemoteBranchRef = function(ref) {
+  var resolved = this.resolveID(ref);
+  if (resolved.get('type') !== 'branch') {
+    return false;
+  }
+  return resolved.getIsRemote();
+};
+
+GitEngine.prototype.tag = function(name, ref) {
+  var target = this.getCommitFromRef(ref);
+  this.validateAndMakeTag(name, target);
+};
+
+GitEngine.prototype.describe = function(ref) {
+  var startCommit = this.getCommitFromRef(ref);
+  // ok we need to BFS from start upwards until we hit a tag. but
+  // first we need to get a reverse mapping from tag to commit
+  var tagMap = {};
+  this.tagCollection.toJSON().forEach(function (tag) {
+    tagMap[tag.target.get('id')] = tag.id;
+  });
+
+  var pQueue = [startCommit];
+  var foundTag;
+  var numAway = [];
+  while (pQueue.length) {
+    var popped = pQueue.pop();
+    var thisID = popped.get('id');
+    if (tagMap[thisID]) {
+      foundTag = tagMap[thisID];
+      break;
+    }
+    // ok keep going
+    numAway.push(popped.get('id'));
+
+    var parents = popped.get('parents');
+    if (parents && parents.length) {
+      pQueue = pQueue.concat(parents);
+      pQueue.sort(this.dateSortFunc);
+    }
+  }
+
+  if (!foundTag) {
+    throw new GitError({
+      msg: intl.todo('Fatal: no tags found upstream')
+    });
+  }
+
+  if (numAway.length === 0) {
+    throw new CommandResult({
+      msg: foundTag
+    });
+  }
+
+  // then join
+  throw new CommandResult({
+    msg: foundTag + '_' + numAway.length + '_g' + startCommit.get('id')
+  });
+};
+
+GitEngine.prototype.validateAndDeleteBranch = function(name) {
+  // trying to delete, lets check our refs
+  var target = this.resolveID(name);
+
+  if (target.get('type') !== 'branch' ||
+      target.get('id') == 'main' ||
+      this.HEAD.get('target') === target) {
+    throw new GitError({
+      msg: intl.str('git-error-branch')
+    });
+  }
+
+  // now we know it's a branch
+  var branch = target;
+  // if its remote
+  if (target.getIsRemote()) {
+    throw new GitError({
+      msg: intl.str('git-error-remote-branch')
+    });
+  }
+  this.deleteBranch(branch);
+};
+
+GitEngine.prototype.deleteBranch = function(branch) {
+  this.branchCollection.remove(branch);
+  this.refs[branch.get('id')] = undefined;
+  delete this.refs[branch.get('id')];
+  // also in some cases external engines call our delete, so
+  // verify integrity of HEAD here
+  if (this.HEAD.get('target') === branch) {
+    this.HEAD.set('target', this.refs['main']);
+  }
+
+  if (branch.get('visBranch')) {
+    branch.get('visBranch').remove();
+  }
+};
+
+GitEngine.prototype.crappyUnescape = function(str) {
+  return str.replace(/&#x27;/g, "'").replace(/&#x2F;/g, "/");
+};
+
+GitEngine.prototype.filterError = function(err) {
+ if (!(err instanceof GitError ||
+      err instanceof CommandResult)) {
+    throw err;
+  }
+};
+
+// called on a origin repo from a local -- simply refresh immediately with
+// an animation
+GitEngine.prototype.externalRefresh = function() {
+  this.animationQueue = new AnimationQueue({
+    callback: function() {}
+  });
+  this.animationFactory.refreshTree(this.animationQueue, this.gitVisuals);
+  this.animationQueue.start();
+};
+
+GitEngine.prototype.dispatch = function(command, deferred) {
+  this.command = command;
+  var vcs = command.get('vcs');
+  var executeCommand = function() {
+    this.dispatchProcess(command, deferred);
+  }.bind(this);
+  // handle mode change will either execute sync or
+  // animate during tree pruning / etc
+  this.handleModeChange(vcs, executeCommand);
+};
+
+GitEngine.prototype.dispatchProcess = function(command, deferred) {
+  // set up the animation queue
+  var whenDone = function() {
+    command.finishWith(deferred);
+  }.bind(this);
+  this.animationQueue = new AnimationQueue({
+    callback: whenDone
+  });
+
+  var vcs = command.get('vcs');
+  var methodName = command.get('method').replace(/-/g, '');
+
+  try {
+    Commands.commands.execute(vcs, methodName, this, this.command);
+  } catch (err) {
+    this.filterError(err);
+    // short circuit animation by just setting error and returning
+    command.set('error', err);
+    deferred.resolve();
+    return;
+  }
+
+  var willStartAuto = this.animationQueue.get('defer') ||
+    this.animationQueue.get('promiseBased');
+
+  // only add the refresh if we didn't do manual animations
+  if (!this.animationQueue.get('animations').length && !willStartAuto) {
+    this.animationFactory.refreshTree(this.animationQueue, this.gitVisuals);
+  }
+
+  // animation queue will call the callback when its done
+  if (!willStartAuto) {
+    this.animationQueue.start();
+  }
+};
+
+GitEngine.prototype.show = function(ref) {
+  var commit = this.getCommitFromRef(ref);
+
+  throw new CommandResult({
+    msg: commit.getShowEntry()
+  });
+};
+
+GitEngine.prototype.status = function() {
+  // UGLY todo
+  var lines = [];
+  if (this.getDetachedHead()) {
+    lines.push(intl.str('git-status-detached'));
+  } else {
+    var branchName = this.resolveNameNoPrefix('HEAD');
+    lines.push(intl.str('git-status-onbranch', {branch: branchName}));
+  }
+  lines.push('Changes to be committed:');
+  lines.push('');
+  lines.push(TAB + 'modified: cal/OskiCostume.stl');
+  lines.push('');
+  lines.push(intl.str('git-status-readytocommit'));
+
+  var msg = '';
+  lines.forEach(function (line) {
+    msg += '# ' + line + '\n';
+  });
+
+  throw new CommandResult({
+    msg: msg
+  });
+};
+
+GitEngine.prototype.logWithout = function(ref, omitBranch) {
+  // slice off the ^branch
+  omitBranch = omitBranch.slice(1);
+  this.log(ref, Graph.getUpstreamSet(this, omitBranch));
+};
+
+GitEngine.prototype.revlist = function(refs) {
+  var range = new RevisionRange(this, refs);
+
+  // now go through and collect ids
+  var bigLogStr = range.formatRevisions(function(c) {
+    return c.id + '\n';
+  });
+
+  throw new CommandResult({
+    msg: bigLogStr
+  });
+};
+
+GitEngine.prototype.log = function(refs) {
+  var range = new RevisionRange(this, refs);
+
+  // now go through and collect logs
+  var bigLogStr = range.formatRevisions(function(c) {
+    return c.getLogEntry();
+  });
+
+  throw new CommandResult({
+    msg: bigLogStr
+  });
+};
+
+GitEngine.prototype.getCommonAncestor = function(ancestor, cousin, dontThrow) {
+  if (this.isUpstreamOf(cousin, ancestor) && !dontThrow) {
+    throw new Error('Don\'t use common ancestor if we are upstream!');
+  }
+
+  var upstreamSet = Graph.getUpstreamSet(this, ancestor);
+  // now BFS off of cousin until you find something
+
+  var queue = [this.getCommitFromRef(cousin)];
+  while (queue.length) {
+    var here = queue.pop();
+    if (upstreamSet[here.get('id')]) {
+      return here;
+    }
+    queue = queue.concat(here.get('parents'));
+  }
+  throw new Error('something has gone very wrong... two nodes aren\'t connected!');
+};
+
+GitEngine.prototype.isUpstreamOf = function(child, ancestor) {
+  child = this.getCommitFromRef(child);
+
+  // basically just do a completely BFS search on ancestor to the root, then
+  // check for membership of child in that set of explored nodes
+  var upstream = Graph.getUpstreamSet(this, ancestor);
+  return upstream[child.get('id')] !== undefined;
+};
+
+GitEngine.prototype.getDownstreamSet = function(ancestor) {
+  var commit = this.getCommitFromRef(ancestor);
+
+  var ancestorID = commit.get('id');
+  var queue = [commit];
+
+  var exploredSet = {};
+  exploredSet[ancestorID] = true;
+
+  var addToExplored = function(child) {
+    exploredSet[child.get('id')] = true;
+    queue.push(child);
+  };
+
+  while (queue.length) {
+    var here = queue.pop();
+    var children = here.get('children');
+
+    children.forEach(addToExplored);
+  }
+  return exploredSet;
+};
+
+var Ref = Backbone.Model.extend({
+  initialize: function() {
+    if (!this.get('target')) {
+      throw new Error('must be initialized with target');
+    }
+    if (!this.get('id')) {
+      throw new Error('must be given an id');
+    }
+    this.set('type', 'general ref');
+
+    if (this.get('id') == 'HEAD') {
+      this.set('lastLastTarget', null);
+      this.set('lastTarget', this.get('target'));
+      // have HEAD remember where it is for checkout -
+      this.on('change:target', this.targetChanged, this);
+    }
+  },
+
+  getIsRemote: function() {
+    return false;
+  },
+
+  getName: function() {
+    return this.get('id');
+  },
+
+  targetChanged: function(model, targetValue, ev) {
+    // push our little 3 stack back. we need to do this because
+    // backbone doesn't give you what the value WAS, only what it was changed
+    // TO
+    this.set('lastLastTarget', this.get('lastTarget'));
+    this.set('lastTarget', targetValue);
+  },
+
+  toString: function() {
+    return 'a ' + this.get('type') + 'pointing to ' + String(this.get('target'));
+  }
+});
+
+var Branch = Ref.extend({
+  defaults: {
+    visBranch: null,
+    remoteTrackingBranchID: null,
+    remote: false
+  },
+
+  initialize: function() {
+    Ref.prototype.initialize.call(this);
+    this.set('type', 'branch');
+  },
+
+  /**
+   * Here is the deal -- there are essentially three types of branches
+   * we deal with:
+   * 1) Normal local branches (that may track a remote branch)
+   * 2) Local remote branches (o/main) that track an origin branch
+   * 3) Origin branches (main) that exist in origin
+   *
+   * With that in mind, we change our branch model to support the following
+   */
+  setRemoteTrackingBranchID: function(id) {
+    this.set('remoteTrackingBranchID', id);
+  },
+
+  getRemoteTrackingBranchID: function() {
+    return this.get('remoteTrackingBranchID');
+  },
+
+  getPrefixedID: function() {
+    if (this.getIsRemote()) {
+      throw new Error('im already remote');
+    }
+    return ORIGIN_PREFIX + this.get('id');
+  },
+
+  getBaseID: function() {
+    if (!this.getIsRemote()) {
+      throw new Error('im not remote so can\'t get base');
+    }
+    return this.get('id').replace(ORIGIN_PREFIX, '');
+  },
+
+  getIsRemote: function() {
+    if (typeof this.get('id') !== 'string') {
+      debugger;
+    }
+    return this.get('id').slice(0, 2) === ORIGIN_PREFIX;
+  }
+});
+
+var Commit = Backbone.Model.extend({
+  defaults: {
+    type: 'commit',
+    children: null,
+    parents: null,
+    author: 'Peter Cottle',
+    createTime: null,
+    commitMessage: null,
+    visNode: null,
+    gitVisuals: null
+  },
+
+  constants: {
+    circularFields: ['gitVisuals', 'visNode', 'children']
+  },
+
+  getLogEntry: function() {
+    return [
+      'Author: ' + this.get('author'),
+      'Date: ' + this.get('createTime'),
+      '',
+      this.get('commitMessage'),
+      '',
+      'Commit: ' + this.get('id')
+    ].join('<br/>') + '\n';
+  },
+
+  getShowEntry: function() {
+    // same deal as above, show log entry and some fake changes
+    return [
+      this.getLogEntry().replace('\n', ''),
+      'diff --git a/bigGameResults.html b/bigGameResults.html',
+      '--- bigGameResults.html',
+      '+++ bigGameResults.html',
+      '@@ 13,27 @@ Winner, Score',
+      '- Stanfurd, 14-7',
+      '+ Cal, 21-14'
+    ].join('<br/>') + '\n';
+  },
+
+  validateAtInit: function() {
+    if (!this.get('id')) {
+      throw new Error('Need ID!!');
+    }
+
+    if (!this.get('createTime')) {
+      this.set('createTime', new Date().toString());
+    }
+    if (!this.get('commitMessage')) {
+      this.set('commitMessage', intl.str('git-dummy-msg'));
+    }
+
+    this.set('children', []);
+
+    // root commits have no parents
+    if (!this.get('rootCommit')) {
+      if (!this.get('parents') || !this.get('parents').length) {
+        throw new Error('needs parents');
+      }
+    }
+  },
+
+  addNodeToVisuals: function() {
+    var visNode = this.get('gitVisuals').addNode(this.get('id'), this);
+    this.set('visNode', visNode);
+  },
+
+  addEdgeToVisuals: function(parent) {
+    this.get('gitVisuals').addEdge(this.get('id'), parent.get('id'));
+  },
+
+  getParent: function(parentNum) {
+    if (this && this.attributes && this.attributes.parents) {
+      return this.attributes.parents[parentNum];
+    } else {
+      return null;
+    }
+  },
+
+  removeFromParents: function() {
+    this.get('parents').forEach(function (parent) {
+      parent.removeChild(this);
+    }, this);
+  },
+
+  checkForUpdatedParent: function(engine) {
+    var parents = this.get('parents');
+    if (parents.length > 1) {
+      return;
+    }
+    var parent = parents[0];
+    var parentID = parent.get('id');
+    var newestID = engine.getMostRecentBumpedID(parentID);
+
+    if (parentID === newestID) {
+      // BOOM done, its already updated
+      return;
+    }
+
+    // crap we have to switch
+    var newParent = engine.refs[newestID];
+
+    this.removeFromParents();
+    this.set('parents', [newParent]);
+    newParent.get('children').push(this);
+
+    // when we run in test mode, our visnode and
+    // visuals will be undefined so we need to check for their existence
+    var visNode = this.get('visNode');
+    if (visNode) {
+      visNode.removeAllEdges();
+    }
+
+    var gitVisuals = this.get('gitVisuals');
+    if (gitVisuals) {
+      gitVisuals.addEdge(this.get('id'), newestID);
+    }
+
+    return true;
+  },
+
+  removeChild: function(childToRemove) {
+    var newChildren = [];
+    this.get('children').forEach(function (child) {
+      if (child !== childToRemove) {
+        newChildren.push(child);
+      }
+    });
+    this.set('children', newChildren);
+  },
+
+  isMainParent: function(parent) {
+    var index = this.get('parents').indexOf(parent);
+    return index === 0;
+  },
+
+  initialize: function(options) {
+    this.validateAtInit();
+    this.addNodeToVisuals();
+
+    (this.get('parents') || []).forEach(function (parent) {
+      parent.get('children').push(this);
+      this.addEdgeToVisuals(parent);
+    }, this);
+  }
+});
+
+var Tag = Ref.extend({
+  defaults: {
+    visTag: null
+  },
+
+  initialize: function() {
+    Ref.prototype.initialize.call(this);
+    this.set('type', 'tag');
+  }
+});
+
+function RevisionRange(engine, specifiers) {
+  this.engine = engine;
+  this.tipsToInclude = [];
+  this.tipsToExclude = [];
+  this.includedRefs = {};
+  this.excludedRefs = {};
+  this.revisions = [];
+
+  this.processSpecifiers(specifiers);
+}
+
+var rangeRegex = /^(.*)\.\.(.*)$/;
+
+RevisionRange.prototype.processAsRange = function(specifier) {
+  var match = specifier.match(rangeRegex);
+  if(!match) {
+    return false;
+  }
+  this.tipsToExclude.push(match[1]);
+  this.tipsToInclude.push(match[2]);
+  return true;
+};
+
+RevisionRange.prototype.processAsExclusion = function(specifier) {
+  if(!specifier.startsWith('^')) {
+    return false;
+  }
+  this.tipsToExclude.push(specifier.slice(1));
+  return true;
+};
+
+RevisionRange.prototype.processAsInclusion = function(specifier) {
+  this.tipsToInclude.push(specifier);
+  return true;
+};
+
+RevisionRange.prototype.processSpecifiers = function(specifiers) {
+  var self = this;
+  var processors = [
+    this.processAsRange,
+    this.processAsExclusion
+  ];
+
+  specifiers.forEach(function(specifier) {
+    if(!processors.some(function(processor) { return processor.bind(self)(specifier); })) {
+      self.processAsInclusion(specifier);
+    }
+  });
+
+  this.tipsToExclude.forEach(function(exclusion) {
+    self.addExcluded(Graph.getUpstreamSet(self.engine, exclusion));
+  });
+
+  this.tipsToInclude.forEach(function(inclusion) {
+    self.addIncluded(Graph.getUpstreamSet(self.engine, inclusion));
+  });
+
+  var includedKeys = Array.from(Object.keys(self.includedRefs));
+
+  self.revisions = includedKeys.map(function(revision) {
+    return self.engine.resolveStringRef(revision);
+  });
+  self.revisions.sort(self.engine.dateSortFunc);
+  self.revisions.reverse();
+};
+
+RevisionRange.prototype.isExcluded = function(revision) {
+  return this.excludedRefs.hasOwnProperty(revision);
+};
+
+RevisionRange.prototype.addExcluded = function(setToExclude) {
+  var self = this;
+  Object.keys(setToExclude).forEach(function(toExclude) {
+    if(!self.isExcluded(toExclude)) {
+      self.excludedRefs[toExclude] = true;
+    }
+  });
+};
+
+RevisionRange.prototype.addIncluded = function(setToInclude) {
+  var self = this;
+  Object.keys(setToInclude).forEach(function(toInclude) {
+    if(!self.isExcluded(toInclude)) {
+      self.includedRefs[toInclude] = true;
+    }
+  });
+};
+
+RevisionRange.prototype.formatRevisions = function(revisionFormatter) {
+  var output = "";
+  this.revisions.forEach(function(c) {
+    output += revisionFormatter(c);
+  });
+  return output;
+};
+
+exports.GitEngine = GitEngine;
+exports.Commit = Commit;
+exports.Branch = Branch;
+exports.Tag = Tag;
+exports.Ref = Ref;

src/js/graph/index.js

@@ -0,0 +1,167 @@
+function invariant(truthy, reason) {
+  if (!truthy) {
+    throw new Error(reason);
+  }
+}
+
+var Graph = {
+
+  getOrMakeRecursive: function(
+    tree,
+    createdSoFar,
+    objID,
+    gitVisuals
+  ) {
+    // circular dependency, should move these base models OUT of
+    // the git class to resolve this
+    var Git = require('../git');
+    var Commit = Git.Commit;
+    var Ref = Git.Ref;
+    var Branch = Git.Branch;
+    var Tag = Git.Tag;
+    if (createdSoFar[objID]) {
+      // base case
+      return createdSoFar[objID];
+    }
+
+    var getType = function(tree, id) {
+      if (tree.commits[id]) {
+        return 'commit';
+      } else if (tree.branches[id]) {
+        return 'branch';
+      } else if (id == 'HEAD') {
+        return 'HEAD';
+      } else if (tree.tags[id]) {
+        return 'tag';
+      }
+      throw new Error("bad type for " + id);
+    };
+
+    // figure out what type
+    var type = getType(tree, objID);
+
+    if (type == 'HEAD') {
+      var headJSON = tree.HEAD;
+      var HEAD = new Ref(Object.assign(
+        tree.HEAD,
+        {
+          target: this.getOrMakeRecursive(tree, createdSoFar, headJSON.target)
+        }
+      ));
+      createdSoFar[objID] = HEAD;
+      return HEAD;
+    }
+
+    if (type == 'branch') {
+      var branchJSON = tree.branches[objID];
+
+      var branch = new Branch(Object.assign(
+        tree.branches[objID],
+        {
+          target: this.getOrMakeRecursive(tree, createdSoFar, branchJSON.target)
+        }
+      ));
+      createdSoFar[objID] = branch;
+      return branch;
+    }
+
+    if (type == 'tag') {
+      var tagJSON = tree.tags[objID];
+
+      var tag = new Tag(Object.assign(
+        tree.tags[objID],
+        {
+          target: this.getOrMakeRecursive(tree, createdSoFar, tagJSON.target)
+        }
+      ));
+      createdSoFar[objID] = tag;
+      return tag;
+    }
+
+    if (type == 'commit') {
+      // for commits, we need to grab all the parents
+      var commitJSON = tree.commits[objID];
+
+      var parentObjs = [];
+      commitJSON.parents.forEach(function(parentID) {
+        parentObjs.push(this.getOrMakeRecursive(tree, createdSoFar, parentID));
+      }, this);
+
+      var commit = new Commit(Object.assign(
+        commitJSON,
+        {
+          parents: parentObjs,
+          gitVisuals: this.gitVisuals
+        }
+      ));
+      createdSoFar[objID] = commit;
+      return commit;
+    }
+
+    throw new Error('ruh rho!! unsupported type for ' + objID);
+  },
+
+  descendSortDepth: function(objects) {
+    return objects.sort(function(oA, oB) {
+      return oB.depth - oA.depth;
+    });
+  },
+
+  bfsFromLocationWithSet: function(engine, location, set) {
+    var result = [];
+    var pQueue = [engine.getCommitFromRef(location)];
+
+    while (pQueue.length) {
+      var popped = pQueue.pop();
+      if (set[popped.get('id')]) {
+        continue;
+      }
+
+      result.push(popped);
+      // keep searching
+      pQueue = pQueue.concat(popped.get('parents'));
+    }
+    return result;
+  },
+
+  getUpstreamSet: function(engine, ancestor) {
+    var commit = engine.getCommitFromRef(ancestor);
+    var ancestorID = commit.get('id');
+    var queue = [commit];
+
+    var exploredSet = {};
+    exploredSet[ancestorID] = true;
+
+    var addToExplored = function(rent) {
+      exploredSet[rent.get('id')] = true;
+      queue.push(rent);
+    };
+
+    while (queue.length) {
+      var here = queue.pop();
+      var rents = here.get('parents');
+
+      (rents || []).forEach(addToExplored);
+    }
+    return exploredSet;
+  },
+
+  getUniqueObjects: function(objects) {
+    var unique = {};
+    var result = [];
+    objects.forEach(function(object) {
+      if (unique[object.id]) {
+        return;
+      }
+      unique[object.id] = true;
+      result.push(object);
+    });
+    return result;
+  },
+
+  getDefaultTree: function() {
+    return JSON.parse(unescape("%7B%22branches%22%3A%7B%22main%22%3A%7B%22target%22%3A%22C1%22%2C%22id%22%3A%22main%22%2C%22type%22%3A%22branch%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22type%22%3A%22commit%22%2C%22parents%22%3A%5B%5D%2C%22author%22%3A%22Peter%20Cottle%22%2C%22createTime%22%3A%22Mon%20Nov%2005%202012%2000%3A56%3A47%20GMT-0800%20%28PST%29%22%2C%22commitMessage%22%3A%22Quick%20Commit.%20Go%20Bears%21%22%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22type%22%3A%22commit%22%2C%22parents%22%3A%5B%22C0%22%5D%2C%22author%22%3A%22Peter%20Cottle%22%2C%22createTime%22%3A%22Mon%20Nov%2005%202012%2000%3A56%3A47%20GMT-0800%20%28PST%29%22%2C%22commitMessage%22%3A%22Quick%20Commit.%20Go%20Bears%21%22%2C%22id%22%3A%22C1%22%7D%7D%2C%22HEAD%22%3A%7B%22id%22%3A%22HEAD%22%2C%22target%22%3A%22main%22%2C%22type%22%3A%22general%20ref%22%7D%7D"));
+  }
+};
+
+module.exports = Graph;

src/js/graph/treeCompare.js

@@ -0,0 +1,465 @@
+var _ = require('underscore');
+
+// static class...
+var TreeCompare = {};
+
+TreeCompare.dispatchFromLevel = function(levelBlob, treeToCompare) {
+  var goalTreeString = levelBlob.goalTreeString;
+  if (typeof treeToCompare !== 'string') {
+    console.warn('NEED to pass in string!! gah');
+  }
+  return TreeCompare.dispatch(levelBlob, goalTreeString, treeToCompare);
+};
+
+TreeCompare.onlyMainCompared = function(levelBlob) {
+  var getAroundLintTrue = true;
+  switch (getAroundLintTrue) {
+    case !!levelBlob.compareOnlyMain:
+    case !!levelBlob.compareOnlyMainHashAgnostic:
+    case !!levelBlob.compareOnlyMainHashAgnosticWithAsserts:
+      return true;
+    default:
+      return false;
+  }
+};
+
+TreeCompare.dispatch = function(levelBlob, goalTreeString, treeToCompare) {
+  var goalTree = this.convertTreeSafe(goalTreeString);
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  if (typeof goalTree.originTree !== typeof treeToCompare.originTree) {
+    // origin status does not match
+    return false;
+  }
+  var shallowResult = this.dispatchShallow(
+    levelBlob, goalTree, treeToCompare
+  );
+  if (!shallowResult || !goalTree.originTree) {
+    // we only have one level (or failed on shallow), punt
+    return shallowResult;
+  }
+
+  var originBlob = (levelBlob.originCompare) ?
+    levelBlob.originCompare : levelBlob;
+  // compare origin trees
+  return shallowResult && this.dispatchShallow(
+    originBlob, goalTree.originTree, treeToCompare.originTree
+  );
+};
+
+TreeCompare.dispatchShallow = function(levelBlob, goalTreeString, treeToCompare) {
+  var getAroundLintTrue = true;
+  // i actually prefer this to else if
+  switch (getAroundLintTrue) {
+    case !!levelBlob.compareOnlyMain:
+      return TreeCompare.compareBranchWithinTrees(
+        treeToCompare, goalTreeString, 'main'
+      );
+    case !!levelBlob.compareAllBranchesAndEnforceBranchCleanup:
+      return TreeCompare.compareAllBranchesAndEnforceBranchCleanup(
+        treeToCompare, goalTreeString
+      );
+    case !!levelBlob.compareOnlyBranches:
+      return TreeCompare.compareAllBranchesWithinTrees(
+        treeToCompare, goalTreeString
+      );
+    case !!levelBlob.compareAllBranchesHashAgnostic:
+      return TreeCompare.compareAllBranchesWithinTreesHashAgnostic(
+        treeToCompare, goalTreeString
+      );
+    case !!levelBlob.compareOnlyMainHashAgnostic:
+      return TreeCompare.compareBranchesWithinTreesHashAgnostic(
+        treeToCompare, goalTreeString, ['main']
+      );
+    case !!levelBlob.compareOnlyMainHashAgnosticWithAsserts:
+      return TreeCompare.compareBranchesWithinTreesHashAgnostic(
+        treeToCompare, goalTreeString, ['main']
+      ) && TreeCompare.evalAsserts(treeToCompare, levelBlob.goalAsserts);
+    default:
+      return TreeCompare.compareAllBranchesWithinTreesAndHEAD(
+        treeToCompare, goalTreeString
+      );
+  }
+};
+
+// would love to have copy properties here.. :(
+TreeCompare.compareAllBranchesWithinTreesAndHEAD = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+
+  // also compare tags!! for just one level
+  return treeToCompare.HEAD.target === goalTree.HEAD.target &&
+    this.compareAllBranchesWithinTrees(treeToCompare, goalTree) &&
+    this.compareAllTagsWithinTrees(treeToCompare, goalTree);
+};
+
+TreeCompare.compareAllBranchesAndEnforceBranchCleanup = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+
+  // Unlike compareAllBranchesWithinTrees, here we consider both the branches
+  // in the goalTree and the branches in the treeToCompare. This means that
+  // we enforce that you clean up any branches that you have locally that
+  // the goal does not have. this is helpful when we want to verify that you
+  // have deleted branch, for instance.
+  var allBranches = Object.assign(
+    {},
+    treeToCompare.branches,
+    goalTree.branches
+  );
+  return Object.keys(allBranches).every(function(branch) {
+    return this.compareBranchWithinTrees(treeToCompare, goalTree, branch);
+  }.bind(this));
+};
+
+
+TreeCompare.compareAllBranchesWithinTrees = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+
+  /**
+   * Disclaimer / reminder!! We only care about branches in the goal tree;
+   * if you have extra branches in your source tree thats ok. but that means
+   * the arguments here are important -- always call this function with
+   * goalTree being the latter argument, since we will discard extra branches
+   * from treeToCompare (the first argument).
+   */
+  return Object.keys(goalTree.branches).every(function(branch) {
+    return this.compareBranchWithinTrees(treeToCompare, goalTree, branch);
+  }.bind(this));
+};
+
+TreeCompare.compareAllTagsWithinTrees = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+  this.reduceTreeFields([treeToCompare, goalTree]);
+
+  return _.isEqual(treeToCompare.tags, goalTree.tags);
+};
+
+TreeCompare.compareBranchesWithinTrees = function(treeToCompare, goalTree, branches) {
+  var result = true;
+  branches.forEach(function(branchName) {
+    result = result && this.compareBranchWithinTrees(treeToCompare, goalTree, branchName);
+  }, this);
+
+  return result;
+};
+
+TreeCompare.compareBranchWithinTrees = function(treeToCompare, goalTree, branchName) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+  this.reduceTreeFields([treeToCompare, goalTree]);
+
+  var recurseCompare = this.getRecurseCompare(treeToCompare, goalTree);
+  var branchA = treeToCompare.branches[branchName];
+  var branchB = goalTree.branches[branchName];
+
+  return _.isEqual(branchA, branchB) &&
+    recurseCompare(treeToCompare.commits[branchA.target], goalTree.commits[branchB.target]);
+};
+
+TreeCompare.compareAllBranchesWithinTreesHashAgnostic = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+  this.reduceTreeFields([treeToCompare, goalTree]);
+
+  var allBranches = Object.assign(
+    {},
+    treeToCompare.branches,
+    goalTree.branches
+  );
+  var branchNames = Object.keys(allBranches || {});
+
+  return this.compareBranchesWithinTreesHashAgnostic(treeToCompare, goalTree, branchNames);
+};
+
+TreeCompare.compareBranchesWithinTreesHashAgnostic = function(treeToCompare, goalTree, branches) {
+  // we can't DRY unfortunately here because we need a special _.isEqual function
+  // for both the recursive compare and the branch compare
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+  this.reduceTreeFields([treeToCompare, goalTree]);
+
+  // get a function to compare branch objects without hashes
+  var compareBranchObjs = function(branchA, branchB) {
+    if (!branchA || !branchB) {
+      return false;
+    }
+
+    // don't mess up the rest of comparison
+    branchA = Object.assign({}, branchA);
+    branchB = Object.assign({}, branchB);
+    branchA.target = this.getBaseRef(branchA.target);
+    branchB.target = this.getBaseRef(branchB.target);
+
+    return _.isEqual(branchA, branchB);
+  }.bind(this);
+  // and a function to compare recursively without worrying about hashes
+  var recurseCompare = this.getRecurseCompareHashAgnostic(treeToCompare, goalTree);
+
+  var result = true;
+  branches.forEach(function(branchName) {
+    var branchA = treeToCompare.branches[branchName];
+    var branchB = goalTree.branches[branchName];
+
+    result = result && compareBranchObjs(branchA, branchB) &&
+      recurseCompare(treeToCompare.commits[branchA.target], goalTree.commits[branchB.target]);
+  }, this);
+  return result;
+};
+
+TreeCompare.evalAsserts = function(tree, assertsPerBranch) {
+  var result = true;
+  Object.keys(assertsPerBranch).forEach(function(branchName) {
+    var asserts = assertsPerBranch[branchName];
+    result = result && this.evalAssertsOnBranch(tree, branchName, asserts);
+  }, this);
+  return result;
+};
+
+TreeCompare.evalAssertsOnBranch = function(tree, branchName, asserts) {
+  tree = this.convertTreeSafe(tree);
+
+  // here is the outline:
+  // * make a data object
+  // * go to the branch given by the key
+  // * traverse upwards, storing the amount of hashes on each in the data object
+  // * then come back and perform functions on data
+
+  if (!tree.branches[branchName]) {
+    return false;
+  }
+
+  var branch = tree.branches[branchName];
+  var queue = [branch.target];
+  var data = {};
+  while (queue.length) {
+    var commitRef = queue.pop();
+    data[this.getBaseRef(commitRef)] = this.getNumHashes(commitRef);
+    queue = queue.concat(tree.commits[commitRef].parents);
+  }
+
+  var result = true;
+  asserts.forEach(function(assert) {
+    try {
+      result = result && assert(data);
+    } catch (err) {
+      console.warn('error during assert', err);
+      console.log(err);
+      result = false;
+    }
+  });
+
+  return result;
+};
+
+TreeCompare.getNumHashes = function(ref) {
+  var regexMap = [
+    [/^C(\d+)([']{0,3})$/, function(bits) {
+      if (!bits[2]) {
+        return 0;
+      }
+      return bits[2].length;
+    }],
+    [/^C(\d+)['][\^](\d+)$/, function(bits) {
+      return Number(bits[2]);
+    }]
+  ];
+
+  for (var i = 0; i < regexMap.length; i++) {
+    var regex = regexMap[i][0];
+    var func = regexMap[i][1];
+    var results = regex.exec(ref);
+    if (results) {
+      return func(results);
+    }
+  }
+  throw new Error('couldn\'t parse ref ' + ref);
+};
+
+TreeCompare.getBaseRef = function(ref) {
+  var idRegex = /^C(\d+)/;
+  var bits = idRegex.exec(ref);
+  if (!bits) { throw new Error('no regex matchy for ' + ref); }
+  // no matter what hash this is (aka C1', C1'', C1'^3, etc) we
+  // return C1
+  return 'C' + bits[1];
+};
+
+TreeCompare.getRecurseCompareHashAgnostic = function(treeToCompare, goalTree) {
+  // here we pass in a special comparison function to pass into the base
+  // recursive compare.
+
+  // some buildup functions
+  var getStrippedCommitCopy = function(commit) {
+    if (!commit) { return {}; }
+    return Object.assign(
+      {},
+      commit,
+      {
+        id: this.getBaseRef(commit.id),
+        parents: null
+      }
+    );
+  }.bind(this);
+
+  var isEqual = function(commitA, commitB) {
+    return _.isEqual(
+      getStrippedCommitCopy(commitA),
+      getStrippedCommitCopy(commitB)
+    );
+  };
+  return this.getRecurseCompare(treeToCompare, goalTree, {isEqual: isEqual});
+};
+
+TreeCompare.getRecurseCompare = function(treeToCompare, goalTree, options) {
+  options = options || {};
+
+  // we need a recursive comparison function to bubble up the branch
+  var recurseCompare = function(commitA, commitB) {
+    // this is the short-circuit base case
+    var result = options.isEqual ?
+      options.isEqual(commitA, commitB) : _.isEqual(commitA, commitB);
+    if (!result) {
+      return false;
+    }
+
+    // we loop through each parent ID. we sort the parent ID's beforehand
+    // so the index lookup is valid. for merge commits this will duplicate some of the
+    // checking (because we aren't doing graph search) but it's not a huge deal
+    var maxNumParents = Math.max(commitA.parents.length, commitB.parents.length);
+    for (var index = 0; index < maxNumParents; index++) {
+      var pAid = commitA.parents[index];
+      var pBid = commitB.parents[index];
+
+      // if treeToCompare or goalTree doesn't have this parent,
+      // then we get an undefined child which is fine when we pass into _.isEqual
+      var childA = treeToCompare.commits[pAid];
+      var childB = goalTree.commits[pBid];
+
+      result = result && recurseCompare(childA, childB);
+    }
+    // if each of our children recursively are equal, we are good
+    return result;
+  };
+  return recurseCompare;
+};
+
+TreeCompare.lowercaseTree = function(tree) {
+  if (tree.HEAD) {
+    tree.HEAD.target = tree.HEAD.target.toLocaleLowerCase();
+  }
+
+  var branches = tree.branches || {};
+  tree.branches = {};
+  Object.keys(branches).forEach(function(name) {
+    var obj = branches[name];
+    obj.id = obj.id.toLocaleLowerCase();
+    tree.branches[name.toLocaleLowerCase()] = obj;
+  });
+  return tree;
+};
+
+TreeCompare.convertTreeSafe = function(tree) {
+  if (typeof tree !== 'string') {
+    return tree;
+  }
+  tree = JSON.parse(unescape(tree));
+  // ok we are almost done -- but we need to case insensitive
+  // certain fields. so go ahead and do that.
+  // handle HEAD target first
+  this.lowercaseTree(tree);
+  if (tree.originTree) {
+    tree.originTree = this.lowercaseTree(tree.originTree);
+  }
+  return tree;
+};
+
+TreeCompare.reduceTreeFields = function(trees) {
+  var commitSaveFields = [
+    'parents',
+    'id',
+    'rootCommit'
+  ];
+  var branchSaveFields = [
+    'target',
+    'id',
+    'remoteTrackingBranchID'
+  ];
+  var tagSaveFields = [
+    'target',
+    'id'
+  ];
+
+  var commitSortFields = ['children', 'parents'];
+  // for backwards compatibility, fill in some fields if missing
+  var defaults = {
+    remoteTrackingBranchID: null
+  };
+  // also fill tree-level defaults
+  var treeDefaults = {
+    tags: {}
+  };
+
+  trees.forEach(function(tree) {
+    Object.keys(treeDefaults).forEach(function(key) {
+      var val = treeDefaults[key];
+      if (tree[key] === undefined) {
+        tree[key] = val;
+      }
+    });
+  });
+
+  // this function saves only the specified fields of a tree
+  var saveOnly = function(tree, treeKey, saveFields, sortFields) {
+    var objects = tree[treeKey];
+    Object.keys(objects).forEach(function(objKey) {
+      var obj = objects[objKey];
+      // our blank slate to copy over
+      var blank = {};
+      saveFields.forEach(function(field) {
+        if (obj[field] !== undefined) {
+          blank[field] = obj[field];
+        } else if (defaults[field] !== undefined) {
+          blank[field] = defaults[field];
+        }
+      });
+
+      Object.values(sortFields || {}).forEach(function(field) {
+        // also sort some fields
+        if (obj[field]) {
+          obj[field].sort();
+          blank[field] = obj[field];
+        }
+      });
+      tree[treeKey][objKey] = blank;
+    });
+  };
+
+  trees.forEach(function(tree) {
+    saveOnly(tree, 'commits', commitSaveFields, commitSortFields);
+    saveOnly(tree, 'branches', branchSaveFields);
+    saveOnly(tree, 'tags', tagSaveFields);
+
+    tree.HEAD = {
+      target: tree.HEAD.target,
+      id: tree.HEAD.id
+    };
+    if (tree.originTree) {
+      this.reduceTreeFields([tree.originTree]);
+    }
+  }, this);
+};
+
+TreeCompare.compareTrees = function(treeToCompare, goalTree) {
+  treeToCompare = this.convertTreeSafe(treeToCompare);
+  goalTree = this.convertTreeSafe(goalTree);
+
+  // now we need to strip out the fields we don't care about, aka things
+  // like createTime, message, author
+  this.reduceTreeFields([treeToCompare, goalTree]);
+
+  return _.isEqual(treeToCompare, goalTree);
+};
+
+module.exports = TreeCompare;

src/js/intl/checkStrings.js

@@ -0,0 +1,33 @@
+var { join } = require('path');
+var { readFileSync } = require('fs');
+
+var util = require('../util');
+var { strings } = require('../intl/strings');
+
+var easyRegex = /intl\.str\(\s*'([a-zA-Z\-]+)'/g;
+
+var allKetSet = new Set(Object.keys(strings));
+allKetSet.delete('error-untranslated'); // used in ./index.js
+
+var goodKeySet = new Set();
+var validateKey = function(key) {
+  if (!strings[key]) {
+    console.log('NO KEY for: "', key, '"');
+  } else {
+    goodKeySet.add(key);
+    allKetSet.delete(key);
+  }
+};
+
+if (!util.isBrowser()) {
+  util.readDirDeep(join(__dirname, '../../')).forEach(function(path) {
+    var content = readFileSync(path);
+    var match;
+    while (match = easyRegex.exec(content)) {
+      validateKey(match[1]);
+    }
+  });
+  console.log(goodKeySet.size, ' good keys found!');
+  console.log(allKetSet.size, ' keys did not use!');
+  console.log(allKetSet);
+}

src/js/intl/index.js

@@ -0,0 +1,118 @@
+var LocaleStore = require('../stores/LocaleStore');
+
+var _ = require('underscore');
+var strings = require('../intl/strings').strings;
+
+var getDefaultLocale = LocaleStore.getDefaultLocale;
+
+var fallbackMap = {
+  'zh_TW': 'zh_CN',
+  'es_AR': 'es_ES',
+  'es_MX': 'es_ES'
+};
+
+// lets change underscores template settings so it interpolates
+// things like "{branchName} does not exist".
+var templateSettings = Object.assign({}, _.templateSettings);
+templateSettings.interpolate = /\{(.+?)\}/g;
+var template = exports.template = function(str, params) {
+  return _.template(str, templateSettings)(params);
+};
+
+var str = exports.str = function(key, params) {
+  params = params || {};
+  // this function takes a key like "error-branch-delete"
+  // and parameters like {branchName: 'bugFix', num: 3}.
+  //
+  // it sticks those into a translation string like:
+  //   'en': 'You can not delete the branch {branchName} because' +
+  //         'you are currently on that branch! This is error number + {num}'
+  //
+  // to produce:
+  //
+  // 'You can not delete the branch bugFix because you are currently on that branch!
+  //  This is error number 3'
+
+  var locale = LocaleStore.getLocale();
+  if (!strings[key]) {
+    console.warn('NO INTL support for key ' + key);
+    return 'NO INTL support for key ' + key + '. this is probably a dev error';
+  }
+
+  if (!strings[key][locale]) {
+    // try falling back to another locale if in the map
+    locale = fallbackMap[locale] || getDefaultLocale();
+  }
+
+  if (!strings[key][locale]) {
+    if (key !== 'error-untranslated') {
+      return str('error-untranslated');
+    }
+    return 'No translation for the key "' + key + '"';
+  }
+
+  return template(
+    strings[key][locale],
+    params
+  );
+};
+
+var getIntlKey = exports.getIntlKey = function(obj, key, overrideLocale) {
+  if (!obj || !obj[key]) {
+    throw new Error('that key ' + key + ' doesn\'t exist in this blob ' + obj);
+  }
+  if (!obj[key][getDefaultLocale()]) {
+    console.warn(
+      'WARNING!! This blob does not have intl support:',
+      obj,
+      'for this key',
+      key
+    );
+  }
+
+  var locale = overrideLocale || LocaleStore.getLocale();
+  return obj[key][locale];
+};
+
+exports.todo = function(str) {
+  return str;
+};
+
+exports.getDialog = function(obj) {
+  return getIntlKey(obj, 'dialog') || obj.dialog[getDefaultLocale()];
+};
+
+exports.getHint = function(level) {
+  if (!getIntlKey(level, 'hint')) {
+    return getIntlKey(level, 'hint', getDefaultLocale()) + ' -- ' + str('error-untranslated');
+  }
+  return getIntlKey(level, 'hint');
+};
+
+exports.getName = function(level) {
+  if (!getIntlKey(level, 'name')) {
+    return getIntlKey(level, 'name', getDefaultLocale()) + ' -- ' + str('error-untranslated');
+  }
+  return getIntlKey(level, 'name');
+};
+
+exports.getStartDialog = function(level) {
+  var startDialog = getIntlKey(level, 'startDialog');
+  if (startDialog) { return startDialog; }
+
+  // this level translation isn't supported yet, so lets add
+  // an alert to the front and give the english version.
+  var errorAlert = {
+    type: 'ModalAlert',
+    options: {
+      markdown: str('error-untranslated')
+    }
+  };
+  var startCopy = Object.assign(
+    {},
+    level.startDialog[getDefaultLocale()] || level.startDialog
+  );
+  startCopy.childViews.unshift(errorAlert);
+
+  return startCopy;
+};

src/js/level/builder.js

@@ -0,0 +1,408 @@
+var Backbone = require('backbone');
+var Q = require('q');
+
+var util = require('../util');
+var Main = require('../app');
+var intl = require('../intl');
+var Errors = require('../util/errors');
+
+var Visualization = require('../visuals/visualization').Visualization;
+var ParseWaterfall = require('../level/parseWaterfall').ParseWaterfall;
+var Level = require('../level').Level;
+var LocaleStore = require('../stores/LocaleStore');
+var LevelStore = require('../stores/LevelStore');
+
+var Command = require('../models/commandModel').Command;
+var GitShim = require('../git/gitShim').GitShim;
+
+var MultiView = require('../views/multiView').MultiView;
+
+var CanvasTerminalHolder = require('../views').CanvasTerminalHolder;
+var ConfirmCancelTerminal = require('../views').ConfirmCancelTerminal;
+var NextLevelConfirm = require('../views').NextLevelConfirm;
+
+var MarkdownPresenter = require('../views/builderViews').MarkdownPresenter;
+var MultiViewBuilder = require('../views/builderViews').MultiViewBuilder;
+var MarkdownGrabber = require('../views/builderViews').MarkdownGrabber;
+
+var regexMap = {
+  'define goal': /^define goal$/,
+  'define name': /^define name$/,
+  'help builder': /^help builder$/,
+  'define start': /^define start$/,
+  'edit dialog': /^edit dialog$/,
+  'show start': /^show start$/,
+  'hide start': /^hide start$/,
+  'define hint': /^define hint$/,
+  'finish': /^finish$/
+};
+
+var parse = util.genParseCommand(regexMap, 'processLevelBuilderCommand');
+
+var LevelBuilder = Level.extend({
+  initialize: function(options) {
+    options = options || {};
+    options.level = {};
+    this.options = options;
+
+    var locale = LocaleStore.getLocale();
+    options.level.startDialog = {};
+    options.level.startDialog[locale] = {
+      childViews: intl.getDialog(require('../dialogs/levelBuilder'))
+    };
+
+    // if we are editing a level our behavior is a bit different
+    var editLevelJSON;
+    if (options.editLevel) {
+      editLevelJSON = LevelStore.getLevel(options.editLevel);
+      options.level = editLevelJSON;
+    }
+
+    LevelBuilder.__super__.initialize.apply(this, [options]);
+    if (!options.editLevel) {
+      this.startDialogObj = undefined;
+      this.definedGoal = false;
+    } else {
+      this.startDialogObj = editLevelJSON.startDialog[locale];
+      this.definedGoal = true;
+    }
+
+    // we won't be using this stuff, and it is deleted to ensure we overwrite all functions that
+    // include that functionality
+    delete this.treeCompare;
+    delete this.solved;
+  },
+
+  initName: function() {
+  },
+
+  initGoalData: function() {
+    // add some default behavior in the beginning if we are not editing
+    if (!this.options.editLevel) {
+      this.level.goalTreeString = '{"branches":{"main":{"target":"C1","id":"main"},"makeLevel":{"target":"C2","id":"makeLevel"}},"commits":{"C0":{"parents":[],"id":"C0","rootCommit":true},"C1":{"parents":["C0"],"id":"C1"},"C2":{"parents":["C1"],"id":"C2"}},"HEAD":{"target":"makeLevel","id":"HEAD"}}';
+      this.level.solutionCommand = 'git checkout -b makeLevel; git commit';
+    }
+    LevelBuilder.__super__.initGoalData.apply(this, arguments);
+  },
+
+  /**
+   * need custom handlers since we have two visualizations >___<
+   */
+  minimizeGoal: function (position, size) {
+    this.doBothVis('hide');
+    this.goalWindowPos = position;
+    this.goalWindowSize = size;
+    if ($('#goalPlaceholder').is(':visible')) {
+      $('#goalPlaceholder').hide();
+      this.mainVis.myResize();
+    }
+  },
+
+  doBothVis: function(method) {
+    if (this.startVis) {
+      this.startVis[method].call(this.startVis);
+    }
+    if (this.goalVis) {
+      this.goalVis[method].call(this.goalVis);
+    }
+  },
+
+  resizeGoal: function () {
+    this.doBothVis('myResize');
+  },
+
+  initStartVisualization: function() {
+    this.startCanvasHolder = new CanvasTerminalHolder({
+      parent: this,
+      additionalClass: 'startTree',
+      text: intl.str('hide-start')
+    });
+
+    this.startVis = new Visualization({
+      el: this.startCanvasHolder.getCanvasLocation(),
+      containerElement: this.startCanvasHolder.getCanvasLocation(),
+      treeString: this.level.startTree,
+      noKeyboardInput: true,
+      smallCanvas: true,
+      noClick: true
+    });
+    return this.startCanvasHolder;
+  },
+
+  startOffCommand: function() {
+    Main.getEventBaton().trigger(
+      'commandSubmitted',
+      'echo :D'
+    );
+  },
+
+  objectiveDialog: function(command, deferred) {
+    var args = [
+      command,
+      deferred,
+      (this.startDialogObj === undefined) ?
+        null :
+        {
+          startDialog: {
+            'en_US': this.startDialogObj
+          }
+        }
+    ];
+    LevelBuilder.__super__.objectiveDialog.apply(this, args);
+  },
+
+  initParseWaterfall: function(options) {
+    LevelBuilder.__super__.initParseWaterfall.apply(this, [options]);
+
+    this.parseWaterfall.addFirst(
+      'parseWaterfall',
+      parse
+    );
+    this.parseWaterfall.addFirst(
+      'instantWaterfall',
+      this.getInstantCommands()
+    );
+  },
+
+  buildLevel: function(command, deferred) {
+    this.exitLevel();
+
+    setTimeout(function() {
+      Main.getSandbox().buildLevel(command, deferred);
+    }, this.getAnimationTime() * 1.5);
+  },
+
+  getInstantCommands: function() {
+    return [
+      [/^help$|^\?$/, function() {
+        throw new Errors.CommandResult({
+          msg: intl.str('help-vague-builder')
+        });
+      }]
+    ];
+  },
+
+  takeControl: function() {
+    Main.getEventBaton().stealBaton('processLevelBuilderCommand', this.processLevelBuilderCommand, this);
+
+    LevelBuilder.__super__.takeControl.apply(this);
+  },
+
+  releaseControl: function() {
+    Main.getEventBaton().releaseBaton('processLevelBuilderCommand', this.processLevelBuilderCommand, this);
+
+    LevelBuilder.__super__.releaseControl.apply(this);
+  },
+
+  showGoal: function() {
+    this.hideStart();
+    LevelBuilder.__super__.showGoal.apply(this, arguments);
+  },
+
+  showStart: function(command, deferred) {
+    this.hideGoal();
+    this.showSideVis(command, deferred, this.startCanvasHolder, this.initStartVisualization);
+  },
+
+  resetSolution: function() {
+    this.gitCommandsIssued = [];
+    this.level.solutionCommand = undefined;
+  },
+
+  hideStart: function(command, deferred) {
+    this.hideSideVis(command, deferred, this.startCanvasHolder);
+  },
+
+  defineStart: function(command, deferred) {
+    this.hideStart();
+
+    command.addWarning(intl.str('define-start-warning'));
+    this.resetSolution();
+
+    this.level.startTree = this.mainVis.gitEngine.printTree();
+    this.mainVis.resetFromThisTreeNow(this.level.startTree);
+
+    this.showStart(command, deferred);
+  },
+
+  defineGoal: function(command, deferred) {
+    this.hideGoal();
+
+    if (!this.gitCommandsIssued.length) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('solution-empty')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    this.definedGoal = true;
+    this.level.solutionCommand = this.gitCommandsIssued.join(';');
+    this.level.goalTreeString = this.mainVis.gitEngine.printTree();
+    this.initGoalVisualization();
+
+    this.showGoal(command, deferred);
+  },
+
+  defineName: function(command, deferred) {
+    this.level.name = {
+      'en_US': prompt(intl.str('prompt-name'))
+    };
+
+    if (command) { command.finishWith(deferred); }
+  },
+
+  defineHint: function(command, deferred) {
+    this.level.hint = {
+      'en_US': prompt(intl.str('prompt-hint'))
+    };
+    if (command) { command.finishWith(deferred); }
+  },
+
+  editDialog: function(command, deferred) {
+    var whenDoneEditing = Q.defer();
+    this.currentBuilder = new MultiViewBuilder({
+      multiViewJSON: this.startDialogObj,
+      deferred: whenDoneEditing
+    });
+    whenDoneEditing.promise
+    .then(function(levelObj) {
+      this.startDialogObj = levelObj;
+    }.bind(this))
+    .fail(function() {
+      // nothing to do, they don't want to edit it apparently
+    })
+    .done(function() {
+      if (command) {
+        command.finishWith(deferred);
+      } else {
+        deferred.resolve();
+      }
+    });
+  },
+
+  finish: function(command, deferred) {
+    if (!this.options.editLevel && (!this.gitCommandsIssued.length || !this.definedGoal)) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('solution-empty')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    while (!this.level.name) {
+      this.defineName();
+    }
+
+    var mainDeferred = Q.defer();
+    var chain = mainDeferred.promise;
+
+    if (this.level.hint === undefined) {
+      var askForHintDeferred = Q.defer();
+      chain = chain.then(function() {
+        return askForHintDeferred.promise;
+      });
+
+      // ask for a hint if there is none
+      var askForHintView = new ConfirmCancelTerminal({
+        markdowns: [
+          intl.str('want-hint')
+        ]
+      });
+      askForHintView.getPromise()
+      .then(this.defineHint.bind(this))
+      .fail(function() {
+        this.level.hint = {'en_US': ''};
+      }.bind(this))
+      .done(function() {
+        askForHintDeferred.resolve();
+      });
+    }
+
+    if (this.startDialogObj === undefined) {
+      var askForStartDeferred = Q.defer();
+      chain = chain.then(function() {
+        return askForStartDeferred.promise;
+      });
+
+      var askForStartView = new ConfirmCancelTerminal({
+        markdowns: [
+          intl.str('want-start-dialog')
+        ]
+      });
+      askForStartView.getPromise()
+      .then(function() {
+        // oh boy this is complex
+        var whenEditedDialog = Q.defer();
+        // the undefined here is the command that doesn't need resolving just yet...
+        this.editDialog(undefined, whenEditedDialog);
+        return whenEditedDialog.promise;
+      }.bind(this))
+      .fail(function() {
+        // if they don't want to edit the start dialog, do nothing
+      })
+      .done(function() {
+        askForStartDeferred.resolve();
+      });
+    }
+
+    chain = chain.done(function() {
+      // ok great! lets just give them the goods
+      new MarkdownPresenter({
+        fillerText: JSON.stringify(this.getExportObj(), null, 2),
+        previewText: intl.str('share-json')
+      });
+      command.finishWith(deferred);
+    }.bind(this));
+
+    mainDeferred.resolve();
+  },
+
+  getExportObj: function() {
+    var compiledLevel = Object.assign(
+      {},
+      this.level
+    );
+    // the start dialog now is just our help intro thing
+    delete compiledLevel.startDialog;
+    if (this.startDialogObj) {
+      compiledLevel.startDialog = {'en_US': this.startDialogObj};
+    }
+    return compiledLevel;
+  },
+
+  processLevelBuilderCommand: function(command, deferred) {
+    var methodMap = {
+      'define goal': this.defineGoal,
+      'define start': this.defineStart,
+      'show start': this.showStart,
+      'hide start': this.hideStart,
+      'finish': this.finish,
+      'define hint': this.defineHint,
+      'define name': this.defineName,
+      'edit dialog': this.editDialog,
+      'help builder': LevelBuilder.__super__.startDialog
+    };
+    if (!methodMap[command.get('method')]) {
+      throw new Error('woah we don\'t support that method yet');
+    }
+
+    methodMap[command.get('method')].apply(this, arguments);
+  },
+
+  afterCommandDefer: function(defer, command) {
+    // we don't need to compare against the goal anymore
+    defer.resolve();
+  },
+
+  die: function() {
+    this.hideStart();
+    LevelBuilder.__super__.die.apply(this, arguments);
+
+    delete this.startVis;
+    delete this.startCanvasHolder;
+  }
+});
+
+exports.LevelBuilder = LevelBuilder;
+exports.regexMap = regexMap;

src/js/level/disabledMap.js

@@ -0,0 +1,42 @@
+var intl = require('../intl');
+
+var Commands = require('../commands');
+
+var Errors = require('../util/errors');
+var GitError = Errors.GitError;
+
+function DisabledMap(options) {
+  options = options || {};
+  this.disabledMap = options.disabledMap || {
+    'git cherry-pick': true,
+    'git rebase': true
+  };
+}
+
+DisabledMap.prototype.getInstantCommands = function() {
+  // this produces an array of regex / function pairs that can be
+  // piped into a parse waterfall to disable certain git commands
+  // :D
+  var instants = [];
+  var onMatch = function() {
+    throw new GitError({
+      msg: intl.str('command-disabled')
+    });
+  };
+
+  Object.keys(this.disabledMap).forEach(function(disabledCommand) {
+    // XXX get hold of vcs from disabledMap
+    var vcs = 'git';
+    disabledCommand = disabledCommand.slice(vcs.length + 1);
+    var gitRegex = Commands.commands.getRegexMap()[vcs][disabledCommand];
+    if (!gitRegex) {
+      throw new Error('wuttttt this disbaled command' + disabledCommand +
+        ' has no regex matching');
+    }
+    instants.push([gitRegex, onMatch]);
+  }.bind(this));
+  return instants;
+};
+
+exports.DisabledMap = DisabledMap;
+

src/js/level/index.js

@@ -0,0 +1,672 @@
+var Q = require('q');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+var util = require('../util');
+var Main = require('../app');
+var intl = require('../intl');
+var log = require('../log');
+
+var Errors = require('../util/errors');
+var Sandbox = require('../sandbox/').Sandbox;
+var GlobalStateActions = require('../actions/GlobalStateActions');
+var GlobalStateStore = require('../stores/GlobalStateStore');
+var LevelActions = require('../actions/LevelActions');
+var LevelStore = require('../stores/LevelStore');
+var Visualization = require('../visuals/visualization').Visualization;
+var DisabledMap = require('../level/disabledMap').DisabledMap;
+var GitShim = require('../git/gitShim').GitShim;
+var Commands = require('../commands');
+
+var MultiView = require('../views/multiView').MultiView;
+var CanvasTerminalHolder = require('../views').CanvasTerminalHolder;
+var ConfirmCancelTerminal = require('../views').ConfirmCancelTerminal;
+var NextLevelConfirm = require('../views').NextLevelConfirm;
+var LevelToolbarView = require('../react_views/LevelToolbarView.jsx');
+
+var TreeCompare = require('../graph/treeCompare');
+
+var regexMap = {
+  'help level': /^help level$/,
+  'start dialog': /^start dialog$/,
+  'show goal': /^(show goal|goal|help goal)$/,
+  'hide goal': /^hide goal$/,
+  'show solution': /^show solution($|\s)/,
+  'objective': /^(objective|assignment)$/
+};
+
+var parse = util.genParseCommand(regexMap, 'processLevelCommand');
+
+var Level = Sandbox.extend({
+  initialize: function(options) {
+    options = options || {};
+    options.level = options.level || {};
+
+    this.level = options.level;
+
+    this.gitCommandsIssued = [];
+    this.solved = false;
+    this.wasResetAfterSolved = false;
+
+    this.initGoalData(options);
+    this.initName(options);
+    this.on('minimizeCanvas', this.minimizeGoal);
+    this.on('resizeCanvas', this.resizeGoal);
+    this.isGoalExpanded = false;
+
+    Level.__super__.initialize.apply(this, [options]);
+    this.startOffCommand();
+
+    this.handleOpen(options.deferred);
+  },
+
+  getIsGoalExpanded: function() {
+    return this.isGoalExpanded;
+  },
+
+  handleOpen: function(deferred) {
+    deferred = deferred || Q.defer();
+
+    // if there is a multiview in the beginning, open that
+    // and let it resolve our deferred
+    if (GlobalStateStore.getShouldDisableLevelInstructions()) {
+      setTimeout(function() {
+        deferred.resolve();
+      }, 100);
+      return;
+    }
+
+    if (this.level.startDialog && !this.testOption('noIntroDialog')) {
+      new MultiView(Object.assign(
+        {},
+        intl.getStartDialog(this.level),
+        { deferred: deferred }
+      ));
+      return;
+    }
+
+    // otherwise, resolve after a 700 second delay to allow
+    // for us to animate easily
+    setTimeout(function() {
+      deferred.resolve();
+    }, this.getAnimationTime() * 1.2);
+  },
+
+  objectiveDialog: function(command, deferred, levelObj) {
+    levelObj = (levelObj === undefined) ? this.level : levelObj;
+
+    if (!levelObj || !levelObj.startDialog) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('no-start-dialog')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    var dialog = $.extend({}, intl.getStartDialog(levelObj));
+    // grab the last slide only
+    dialog.childViews = dialog.childViews.slice(-1);
+    new MultiView(Object.assign(
+      dialog,
+      { deferred: deferred }
+    ));
+
+    // when its closed we are done
+    deferred.promise.then(function() {
+      command.set('status', 'finished');
+    });
+  },
+
+  startDialog: function(command, deferred) {
+    if (!this.level.startDialog) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('no-start-dialog')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    this.handleOpen(deferred);
+    deferred.promise.then(function() {
+      command.set('status', 'finished');
+    });
+  },
+
+  getEnglishName: function() {
+    return this.level.name.en_US;
+  },
+
+  initName: function() {
+    var name = intl.getName(this.level);
+    this.levelToolbar = React.createElement(
+      LevelToolbarView,
+      {
+        name: name,
+        onGoalClick: this.toggleGoal.bind(this),
+        onObjectiveClick: this.toggleObjective.bind(this),
+        parent: this
+      }
+    );
+    ReactDOM.render(
+      this.levelToolbar,
+      document.getElementById('levelToolbarMount')
+    );
+  },
+
+  initGoalData: function(options) {
+    if (!this.level.goalTreeString || !this.level.solutionCommand) {
+      throw new Error('need goal tree and solution');
+    }
+  },
+
+  takeControl: function() {
+    Main.getEventBaton().stealBaton('processLevelCommand', this.processLevelCommand, this);
+
+    Level.__super__.takeControl.apply(this);
+  },
+
+  releaseControl: function() {
+    Main.getEventBaton().releaseBaton('processLevelCommand', this.processLevelCommand, this);
+
+    Level.__super__.releaseControl.apply(this);
+  },
+
+  startOffCommand: function() {
+    var method = this.options.command.get('method');
+    if (GlobalStateStore.getShouldDisableLevelInstructions()) {
+      Main.getEventBaton().trigger(
+        'commandSubmitted',
+        'hint; show goal'
+      );
+      return;
+    }
+
+    if (!this.testOption('noStartCommand') && method !== 'importLevelNow') {
+      Main.getEventBaton().trigger(
+        'commandSubmitted',
+        'hint; delay 2000; show goal'
+      );
+    }
+  },
+
+  initVisualization: function(options) {
+    this.mainVis = new Visualization({
+      el: options.el || this.getDefaultVisEl(),
+      treeString: options.level.startTree
+    });
+  },
+
+  initGoalVisualization: function() {
+    var onlyMain = TreeCompare.onlyMainCompared(this.level);
+    // first we make the goal visualization holder
+    this.goalCanvasHolder = new CanvasTerminalHolder({
+      text: (onlyMain) ? intl.str('goal-only-main') : undefined,
+      parent: this
+    });
+
+    // then we make a visualization. the "el" here is the element to
+    // track for size information. the container is where the canvas will be placed
+    this.goalVis = new Visualization({
+      el: this.goalCanvasHolder.getCanvasLocation(),
+      containerElement: this.goalCanvasHolder.getCanvasLocation(),
+      treeString: this.level.goalTreeString,
+      noKeyboardInput: true,
+      smallCanvas: true,
+      isGoalVis: true,
+      levelBlob: this.level,
+      noClick: true
+    });
+
+    // If the goal visualization gets dragged to the right side of the screen, then squeeze the main
+    // repo visualization a bit to make room. This way, you could have the goal window hang out on
+    // the right side of the screen and still see the repo visualization.
+    this.goalVis.customEvents.on('drag', function(event, ui) {
+      if (ui.position.left > 0.5 * $(window).width()) {
+        if (!$('#goalPlaceholder').is(':visible')) {
+          $('#goalPlaceholder').show();
+          this.mainVis.myResize();
+        }
+      } else {
+        if ($('#goalPlaceholder').is(':visible')) {
+          $('#goalPlaceholder').hide();
+          this.mainVis.myResize();
+        }
+      }
+    }.bind(this));
+
+    return this.goalCanvasHolder;
+  },
+
+  minimizeGoal: function (position, size) {
+    this.isGoalExpanded = false;
+    this.trigger('goalToggled');
+    this.goalVis.hide();
+    this.goalWindowPos = position;
+    this.goalWindowSize = size;
+    if ($('#goalPlaceholder').is(':visible')) {
+      $('#goalPlaceholder').hide();
+      this.mainVis.myResize();
+    }
+  },
+
+  resizeGoal: function () {
+    if (!this.goalVis) {
+      return;
+    }
+    this.goalVis.myResize();
+  },
+
+  showSolution: function(command, deferred) {
+    var toIssue = this.level.solutionCommand;
+    var issueFunc = function() {
+      this.isShowingSolution = true;
+      Main.getEventBaton().trigger(
+        'commandSubmitted',
+        toIssue
+      );
+      log.showLevelSolution(this.getEnglishName());
+    }.bind(this);
+
+    var commandStr = command.get('rawStr');
+    if (!this.testOptionOnString(commandStr, 'noReset')) {
+      toIssue = 'reset --forSolution; ' + toIssue;
+    }
+    if (this.testOptionOnString(commandStr, 'force')) {
+      issueFunc();
+      command.finishWith(deferred);
+      return;
+    }
+
+    // allow them for force the solution
+    var confirmDefer = Q.defer();
+    var dialog = intl.getDialog(require('../dialogs/confirmShowSolution'))[0];
+    var confirmView = new ConfirmCancelTerminal({
+      markdowns: dialog.options.markdowns,
+      deferred: confirmDefer
+    });
+
+    confirmDefer.promise
+    .then(issueFunc)
+    .fail(function() {
+      command.setResult("");
+    })
+    .done(function() {
+     // either way we animate, so both options can share this logic
+     setTimeout(function() {
+        command.finishWith(deferred);
+      }, confirmView.getAnimationTime());
+    });
+  },
+
+  toggleObjective: function() {
+    Main.getEventBaton().trigger(
+      'commandSubmitted',
+      'objective'
+    );
+  },
+
+  toggleGoal: function () {
+    if (this.goalCanvasHolder && this.goalCanvasHolder.inDom) {
+      this.hideGoal();
+    } else {
+      this.showGoal();
+    }
+  },
+
+  showGoal: function(command, defer) {
+    this.isGoalExpanded = true;
+    this.trigger('goalToggled');
+    this.showSideVis(command, defer, this.goalCanvasHolder, this.initGoalVisualization);
+    // show the squeezer again we are to the side
+    if ($(this.goalVis.el).offset().left > 0.5 * $(window).width()) {
+      $('#goalPlaceholder').show();
+      this.mainVis.myResize();
+    }
+  },
+
+  showSideVis: function(command, defer, canvasHolder, initMethod) {
+    var safeFinish = function() {
+      if (command) { command.finishWith(defer); }
+    };
+    if (!canvasHolder || !canvasHolder.inDom) {
+      canvasHolder = initMethod.apply(this);
+    }
+
+    canvasHolder.restore(this.goalWindowPos, this.goalWindowSize);
+    setTimeout(safeFinish, canvasHolder.getAnimationTime());
+  },
+
+  hideGoal: function(command, defer) {
+    this.isGoalExpanded = false;
+    this.trigger('goalToggled');
+    this.hideSideVis(command, defer, this.goalCanvasHolder);
+  },
+
+  hideSideVis: function(command, defer, canvasHolder, vis) {
+    var safeFinish = function() {
+      if (command) { command.finishWith(defer); }
+    };
+
+    if (canvasHolder && canvasHolder.inDom) {
+      canvasHolder.die();
+      setTimeout(safeFinish, canvasHolder.getAnimationTime());
+    } else {
+      safeFinish();
+    }
+  },
+
+  initParseWaterfall: function(options) {
+    Level.__super__.initParseWaterfall.apply(this, [options]);
+
+    // add our specific functionality
+    this.parseWaterfall.addFirst(
+      'parseWaterfall',
+      parse
+    );
+
+    this.parseWaterfall.addFirst(
+      'instantWaterfall',
+      this.getInstantCommands()
+    );
+
+    // if we want to disable certain commands...
+    if (options.level.disabledMap) {
+      // disable these other commands
+      this.parseWaterfall.addFirst(
+        'instantWaterfall',
+        new DisabledMap({
+          disabledMap: options.level.disabledMap
+        }).getInstantCommands()
+      );
+    }
+  },
+
+  initGitShim: function(options) {
+    // ok we definitely want a shim here
+    this.gitShim = new GitShim({
+      beforeCB: this.beforeCommandCB.bind(this),
+      afterCB: this.afterCommandCB.bind(this),
+      afterDeferHandler: this.afterCommandDefer.bind(this)
+    });
+  },
+
+  undo: function() {
+    this.gitCommandsIssued.pop();
+    Level.__super__.undo.apply(this, arguments);
+  },
+
+  beforeCommandCB: function(command) {
+    // Alright we actually no-op this in the level subclass
+    // so we can tell if the command counted or not... kinda :P
+    // We have to save the state in this method since the git
+    // engine will change by the time afterCommandCB runs
+    this._treeBeforeCommand = this.mainVis.gitEngine.printTree();
+  },
+
+  afterCommandCB: function(command) {
+    if (this.doesCommandCountTowardsTotal(command)) {
+      // Count it as a command AND...
+      this.gitCommandsIssued.push(command.get('rawStr'));
+      // add our state for undo since our undo pops a command.
+      //
+      // Ugly inheritance overriding on private implementations ahead!
+      this.undoStack.push(this._treeBeforeCommand);
+    }
+  },
+
+  doesCommandCountTowardsTotal: function(command) {
+    if (command.get('error')) {
+      // don't count errors towards our count
+      return false;
+    }
+
+    var matched = false;
+    var commandsThatCount = Commands.commands.getCommandsThatCount();
+    Object.values(commandsThatCount).forEach(function(map) {
+      Object.values(map).forEach(function(regex) {
+        matched = matched || regex.test(command.get('rawStr'));
+      });
+    });
+    return matched;
+  },
+
+  afterCommandDefer: function(defer, command) {
+    if (this.solved) {
+      command.addWarning(intl.str('already-solved'));
+      defer.resolve();
+      return;
+    }
+
+    var current = this.mainVis.gitEngine.printTree();
+    var solved = TreeCompare.dispatchFromLevel(this.level, current);
+
+    if (!solved) {
+      defer.resolve();
+      return;
+    }
+
+    // woohoo!!! they solved the level, lets animate and such
+    this.levelSolved(defer);
+  },
+
+  getNumSolutionCommands: function() {
+    // strip semicolons in bad places
+    var toAnalyze = this.level.solutionCommand.replace(/^;|;$/g, '');
+    return toAnalyze.split(';').length;
+  },
+
+  testOption: function(option) {
+    return this.options.command && new RegExp('--' + option).test(this.options.command.get('rawStr'));
+  },
+
+  testOptionOnString: function(str, option) {
+    return str && new RegExp('--' + option).test(str);
+  },
+
+  levelSolved: function(defer) {
+    this.solved = true;
+    if (!this.isShowingSolution) {
+      LevelActions.setLevelSolved(this.level.id);
+      log.levelSolved(this.getEnglishName());
+    }
+
+    this.hideGoal();
+
+    var nextLevel = LevelStore.getNextLevel(this.level.id);
+    var numCommands = this.gitCommandsIssued.length;
+    var best = this.getNumSolutionCommands();
+
+    var skipFinishDialog = this.testOption('noFinishDialog') ||
+      this.wasResetAfterSolved;
+    var skipFinishAnimation = this.wasResetAfterSolved;
+
+    if (!skipFinishAnimation) {
+      GlobalStateActions.levelSolved();
+    }
+
+    /**
+     * Speed up the animation each time we see it.
+     */
+    var speed = 1.0;
+    switch (GlobalStateStore.getNumLevelsSolved()) {
+      case 2:
+        speed = 1.5;
+        break;
+      case 3:
+        speed = 1.8;
+        break;
+      case 4:
+        speed = 2.1;
+        break;
+      case 5:
+        speed = 2.4;
+        break;
+    }
+    if (GlobalStateStore.getNumLevelsSolved() > 5) {
+      speed = 2.5;
+    }
+
+    var finishAnimationChain = null;
+    if (skipFinishAnimation) {
+      var deferred = Q.defer();
+      deferred.resolve();
+      finishAnimationChain = deferred.promise;
+      Main.getEventBaton().trigger(
+        'commandSubmitted',
+        'echo "level solved! type in \'levels\' to access the next level"'
+      );
+    } else {
+      GlobalStateActions.changeIsAnimating(true);
+      finishAnimationChain = this.mainVis.gitVisuals.finishAnimation(speed);
+      if (this.mainVis.originVis) {
+        finishAnimationChain = finishAnimationChain.then(
+          this.mainVis.originVis.gitVisuals.finishAnimation(speed)
+        );
+      }
+    }
+
+    if (!skipFinishDialog) {
+      finishAnimationChain = finishAnimationChain.then(function() {
+        // we want to ask if they will move onto the next level
+        // while giving them their results...
+        var nextDialog = new NextLevelConfirm({
+          nextLevel: nextLevel,
+          numCommands: numCommands,
+          best: best
+        });
+
+        return nextDialog.getPromise();
+      });
+    }
+
+    finishAnimationChain
+    .then(function() {
+      if (!skipFinishDialog && nextLevel) {
+        log.choseNextLevel(nextLevel.id);
+        Main.getEventBaton().trigger(
+          'commandSubmitted',
+          'level ' + nextLevel.id
+        );
+      }
+    })
+    .fail(function() {
+      // nothing to do, we will just close
+    })
+    .done(function() {
+      GlobalStateActions.changeIsAnimating(false);
+      defer.resolve();
+    });
+  },
+
+  die: function() {
+    ReactDOM.unmountComponentAtNode(
+      document.getElementById('levelToolbarMount')
+    );
+
+    this.hideGoal();
+    this.mainVis.die();
+    this.releaseControl();
+
+    this.clear();
+
+    delete this.commandCollection;
+    delete this.mainVis;
+    delete this.goalVis;
+    delete this.goalCanvasHolder;
+  },
+
+  getInstantCommands: function() {
+    var getHint = function() {
+      var hint = intl.getHint(this.level);
+      if (!hint || !hint.length) {
+        return intl.str('no-hint');
+      }
+      return hint;
+    }.bind(this);
+
+    return [
+      [/^help$|^\?$/, function() {
+        throw new Errors.CommandResult({
+          msg: intl.str('help-vague-level')
+        });
+      }],
+      [/^hint$/, function() {
+        throw new Errors.CommandResult({
+          msg: getHint()
+        });
+      }]
+    ];
+  },
+
+  reset: function(command, deferred) {
+    this.gitCommandsIssued = [];
+
+    var commandStr = (command) ? command.get('rawStr') : '';
+    if (!this.testOptionOnString(commandStr, 'forSolution')) {
+      this.isShowingSolution = false;
+    }
+    if (this.solved) {
+      this.wasResetAfterSolved = true;
+    }
+    this.solved = false;
+    Level.__super__.reset.apply(this, arguments);
+  },
+
+  buildLevel: function(command, deferred) {
+    this.exitLevel();
+    setTimeout(function() {
+      Main.getSandbox().buildLevel(command, deferred);
+    }, this.getAnimationTime() * 1.5);
+  },
+
+  importLevel: function(command, deferred) {
+    this.exitLevel();
+    setTimeout(function() {
+      Main.getSandbox().importLevel(command, deferred);
+    }, this.getAnimationTime() * 1.5);
+  },
+
+  startLevel: function(command, deferred) {
+    this.exitLevel();
+
+    setTimeout(function() {
+      Main.getSandbox().startLevel(command, deferred);
+    }, this.getAnimationTime() * 1.5);
+    // wow! that was simple :D
+  },
+
+  exitLevel: function(command, deferred) {
+    this.die();
+
+    if (!command || !deferred) {
+      return;
+    }
+
+    setTimeout(function() {
+      command.finishWith(deferred);
+    }, this.getAnimationTime());
+
+    // we need to fade in the sandbox
+    Main.getEventBaton().trigger('levelExited');
+  },
+
+  processLevelCommand: function(command, defer) {
+    var methodMap = {
+      'show goal': this.showGoal,
+      'hide goal': this.hideGoal,
+      'show solution': this.showSolution,
+      'start dialog': this.startDialog,
+      'help level': this.startDialog,
+      'objective': this.objectiveDialog
+    };
+    var method = methodMap[command.get('method')];
+    if (!method) {
+      throw new Error('woah we don\'t support that method yet', method);
+    }
+
+    method.apply(this, [command, defer]);
+  }
+});
+
+exports.Level = Level;
+exports.regexMap = regexMap;

src/js/level/parseWaterfall.js

@@ -0,0 +1,122 @@
+var GitCommands = require('../git/commands');
+var Commands = require('../commands');
+var SandboxCommands = require('../sandbox/commands');
+
+// more or less a static class
+var ParseWaterfall = function(options) {
+  options = options || {};
+  this.options = options;
+  this.shortcutWaterfall = options.shortcutWaterfall || [
+    Commands.commands.getShortcutMap()
+  ];
+
+  this.instantWaterfall = options.instantWaterfall || [
+    GitCommands.instantCommands,
+    SandboxCommands.instantCommands
+  ];
+
+  // defer the parse waterfall until later...
+};
+
+ParseWaterfall.prototype.initParseWaterfall = function() {
+  // check for node when testing
+  if (!require('../util').isBrowser()) {
+    this.parseWaterfall = [Commands.parse];
+    return;
+  }
+
+  // by deferring the initialization here, we don't require()
+  // level too early (which barfs our init)
+  this.parseWaterfall = this.options.parseWaterfall || [
+    Commands.parse,
+    SandboxCommands.parse,
+    SandboxCommands.getOptimisticLevelParse(),
+    SandboxCommands.getOptimisticLevelBuilderParse()
+  ];
+};
+
+ParseWaterfall.prototype.clone = function() {
+  return new ParseWaterfall({
+    shortcutWaterfall: this.shortcutWaterfall.slice(),
+    instantWaterfall: this.instantWaterfall.slice(),
+    parseWaterfall: this.parseWaterfall.slice()
+  });
+};
+
+ParseWaterfall.prototype.getWaterfallMap = function() {
+  if (!this.parseWaterfall) {
+    this.initParseWaterfall();
+  }
+  return {
+    shortcutWaterfall: this.shortcutWaterfall,
+    instantWaterfall: this.instantWaterfall,
+    parseWaterfall: this.parseWaterfall
+  };
+};
+
+ParseWaterfall.prototype.addFirst = function(which, value) {
+  if (!which || !value) {
+    throw new Error('need to know which!!!');
+  }
+  this.getWaterfallMap()[which].unshift(value);
+};
+
+ParseWaterfall.prototype.addLast = function(which, value) {
+  this.getWaterfallMap()[which].push(value);
+};
+
+ParseWaterfall.prototype.expandAllShortcuts = function(commandStr) {
+  this.shortcutWaterfall.forEach(function(shortcutMap) {
+    commandStr = this.expandShortcut(commandStr, shortcutMap);
+  }, this);
+  return commandStr;
+};
+
+ParseWaterfall.prototype.expandShortcut = function(commandStr, shortcutMap) {
+  Object.keys(shortcutMap).forEach(function(vcs) {
+    var map = shortcutMap[vcs];
+    Object.keys(map).forEach(function(method) {
+      var regex = map[method];
+      var results = regex.exec(commandStr);
+      if (results) {
+        commandStr = vcs + ' ' + method + ' ' + commandStr.slice(results[0].length);
+      }
+    });
+  });
+  return commandStr;
+};
+
+ParseWaterfall.prototype.processAllInstants = function(commandStr) {
+  this.instantWaterfall.forEach(function(instantCommands) {
+    this.processInstant(commandStr, instantCommands);
+  }, this);
+};
+
+ParseWaterfall.prototype.processInstant = function(commandStr, instantCommands) {
+  instantCommands.forEach(function(tuple) {
+    var regex = tuple[0];
+    var results = regex.exec(commandStr);
+    if (results) {
+      // this will throw a result because it's an instant
+      tuple[1](results);
+    }
+  });
+};
+
+ParseWaterfall.prototype.parseAll = function(commandStr) {
+  if (!this.parseWaterfall) {
+    this.initParseWaterfall();
+  }
+
+  var toReturn = false;
+  this.parseWaterfall.forEach(function(parseFunc) {
+    var results = parseFunc(commandStr);
+    if (results) {
+      toReturn = results;
+    }
+  }, this);
+
+  return toReturn;
+};
+
+exports.ParseWaterfall = ParseWaterfall;

src/js/log/index.js

@@ -0,0 +1,31 @@
+
+var log = function(category, action, label) {
+  window._gaq = window._gaq || [];
+  window._gaq.push(['_trackEvent', category, action, label]);
+  //console.log('just logged ', [category, action, label].join('|'));
+};
+
+exports.viewInteracted = function(viewName) {
+  log('views', 'interacted', viewName);
+};
+
+exports.showLevelSolution = function(levelName) {
+  log('levels', 'showedLevelSolution', levelName);
+};
+
+exports.choseNextLevel = function(levelID) {
+  log('levels', 'nextLevelChosen', levelID);
+};
+
+exports.levelSelected = function(levelName) {
+  log('levels', 'levelSelected', levelName);
+};
+
+exports.levelSolved = function(levelName) {
+  log('levels', 'levelSolved', levelName);
+};
+
+exports.commandEntered = function(value) {
+  log('commands', 'commandEntered', value);
+};
+

src/js/mercurial/commands.js

@@ -0,0 +1,261 @@
+var intl = require('../intl');
+
+var GitCommands = require('../git/commands');
+var Errors = require('../util/errors');
+
+var CommandProcessError = Errors.CommandProcessError;
+var GitError = Errors.GitError;
+var Warning = Errors.Warning;
+var CommandResult = Errors.CommandResult;
+
+var commandConfig = {
+  commit: {
+    regex: /^hg +(commit|ci)($|\s)/,
+    options: [
+      '--amend',
+      '-A',
+      '-m'
+    ],
+    delegate: function(engine, command) {
+      var options = command.getOptionsMap();
+      if (options['-A']) {
+        command.addWarning(intl.str('hg-a-option'));
+      }
+
+      return {
+        vcs: 'git',
+        name: 'commit'
+      };
+    }
+  },
+
+  status: {
+    regex: /^hg +(status|st) *$/,
+    dontCountForGolf: true,
+    execute: function(engine, command) {
+      throw new GitError({
+        msg: intl.str('hg-error-no-status')
+      });
+    }
+  },
+
+  'export': {
+    regex: /^hg +export($|\s)/,
+    dontCountForGolf: true,
+    delegate: function(engine, command) {
+      command.mapDotToHead();
+      return {
+        vcs: 'git',
+        name: 'show'
+      };
+    }
+  },
+
+  graft: {
+    regex: /^hg +graft($|\s)/,
+    options: [
+      '-r'
+    ],
+    delegate: function(engine, command) {
+      command.acceptNoGeneralArgs();
+      command.prependOptionR();
+      return {
+        vcs: 'git',
+        name: 'cherrypick'
+      };
+    }
+  },
+
+  log: {
+    regex: /^hg +log($|\s)/,
+    options: [
+      '-f'
+    ],
+    dontCountForGolf: true,
+    delegate: function(engine, command) {
+      var options = command.getOptionsMap();
+      command.acceptNoGeneralArgs();
+
+      if (!options['-f']) {
+        throw new GitError({
+          msg: intl.str('hg-error-log-no-follow')
+        });
+      }
+      command.mapDotToHead();
+      return {
+        vcs: 'git',
+        name: 'log'
+      };
+    }
+  },
+
+  bookmark: {
+    regex: /^hg (bookmarks|bookmark|book)($|\s)/,
+    options: [
+      '-r',
+      '-f',
+      '-d'
+    ],
+    delegate: function(engine, command) {
+      var options = command.getOptionsMap();
+      var generalArgs = command.getGeneralArgs();
+      var branchName;
+      var rev;
+
+      var delegate = {vcs: 'git'};
+
+      if (options['-m'] && options['-d']) {
+        throw new GitError({
+          msg: intl.todo('-m and -d are incompatible')
+        });
+      }
+      if (options['-d'] && options['-r']) {
+        throw new GitError({
+          msg: intl.todo('-r is incompatible with -d')
+        });
+      }
+      if (options['-m'] && options['-r']) {
+        throw new GitError({
+          msg: intl.todo('-r is incompatible with -m')
+        });
+      }
+      if (generalArgs.length + (options['-r'] ? options['-r'].length : 0) +
+          (options['-d'] ? options['-d'].length : 0) === 0) {
+        delegate.name = 'branch';
+        return delegate;
+      }
+
+      if (options['-d']) {
+        options['-D'] = options['-d'];
+        delete options['-d'];
+        delegate.name = 'branch';
+      } else {
+        if (options['-r']) {
+          // we specified a revision with -r but
+          // need to flip the order
+          generalArgs = command.getGeneralArgs();
+          branchName = generalArgs[0];
+          rev = options['-r'][0];
+          delegate.name = 'branch';
+
+          // transform to what git wants
+          command.setGeneralArgs([branchName, rev]);
+        } else if (generalArgs.length > 0) {
+          command.setOptionsMap({'-b': [generalArgs[0]]});
+          delegate.name = 'checkout';
+          command.setGeneralArgs([]);
+        } else {
+          delegate.name = 'branch';
+        }
+      }
+
+      return delegate;
+    }
+  },
+
+  rebase: {
+    regex: /^hg +rebase($|\s+)/,
+    options: [
+      '-d',
+      '-s',
+      '-b'
+    ],
+    execute: function(engine, command) {
+      var throwE = function() {
+        throw new GitError({
+          msg: intl.str('git-error-options')
+        });
+      };
+
+      var options = command.getOptionsMap();
+      // if we have both OR if we have neither
+      if ((options['-d'] && options['-s']) ||
+          (!options['-d'] && !options['-s'])) {
+      }
+
+      if (!options['-b']) {
+        options['-b'] = ['.'];
+      }
+
+      command.setOptionsMap(options);
+      command.mapDotToHead();
+      options = command.getOptionsMap();
+
+      if (options['-d']) {
+        var dest = options['-d'][0] || throwE();
+        var base = options['-b'][0];
+
+        engine.hgRebase(dest, base);
+      } else {
+        // TODO!!!
+        throwE();
+      }
+    }
+  },
+
+  update: {
+    regex: /^hg +(update|up)($|\s+)/,
+    options: [
+      '-r'
+    ],
+    delegate: function(engine, command) {
+      command.appendOptionR();
+      return {
+        vcs: 'git',
+        name: 'checkout'
+      };
+    }
+  },
+
+  backout: {
+    regex: /^hg +backout($|\s+)/,
+    options: [
+      '-r'
+    ],
+    delegate: function(engine, command) {
+      command.prependOptionR();
+      return {
+        vcs: 'git',
+        name: 'revert'
+      };
+    }
+  },
+
+  histedit: {
+    regex: /^hg +histedit($|\s+)/,
+    delegate: function(engine, command) {
+      var args = command.getGeneralArgs();
+      command.validateArgBounds(args, 1, 1);
+      command.setOptionsMap({
+        '-i': args
+      });
+      command.setGeneralArgs([]);
+      return {
+        vcs: 'git',
+        name: 'rebase'
+      };
+    }
+  },
+
+  pull: {
+    regex: /^hg +pull($|\s+)/,
+    delegate: function(engine, command) {
+      return {
+        vcs: 'git',
+        name: 'pull'
+      };
+    }
+  },
+
+  summary: {
+    regex: /^hg +(summary|sum) *$/,
+    delegate: function(engine, command) {
+      return {
+        vcs: 'git',
+        name: 'branch'
+      };
+    }
+  }
+};
+
+exports.commandConfig = commandConfig;

src/js/models/collections.js

@@ -0,0 +1,128 @@
+var Q = require('q');
+var Backbone = require('backbone');
+
+var Commit = require('../git').Commit;
+var Branch = require('../git').Branch;
+var Tag = require('../git').Tag;
+
+var Command = require('../models/commandModel').Command;
+var TIME = require('../util/constants').TIME;
+
+var intl = require('../intl');
+
+var CommitCollection = Backbone.Collection.extend({
+  model: Commit
+});
+
+var CommandCollection = Backbone.Collection.extend({
+  model: Command
+});
+
+var BranchCollection = Backbone.Collection.extend({
+  model: Branch
+});
+
+var TagCollection = Backbone.Collection.extend({
+  model: Tag
+});
+
+var CommandBuffer = Backbone.Model.extend({
+  defaults: {
+    collection: null
+  },
+
+  initialize: function(options) {
+    options.collection.bind('add', this.addCommand, this);
+
+    this.buffer = [];
+    this.timeout = null;
+  },
+
+  addCommand: function(command) {
+    this.buffer.push(command);
+    this.touchBuffer();
+  },
+
+  touchBuffer: function() {
+    // touch buffer just essentially means we just check if our buffer is being
+    // processed. if it's not, we immediately process the first item
+    // and then set the timeout.
+    if (this.timeout) {
+      // timeout existence implies its being processed
+      return;
+    }
+    this.setTimeout();
+  },
+
+
+  setTimeout: function() {
+    this.timeout = setTimeout(function() {
+        this.sipFromBuffer();
+    }.bind(this), TIME.betweenCommandsDelay);
+  },
+
+  popAndProcess: function() {
+    var popped = this.buffer.shift(0);
+
+    // find a command with no error (aka unprocessed)
+    while (popped.get('error') && this.buffer.length) {
+      popped = this.buffer.shift(0);
+    }
+    if (!popped.get('error')) {
+      this.processCommand(popped);
+    } else {
+      // no more commands to process
+      this.clear();
+    }
+  },
+
+  processCommand: function(command) {
+    command.set('status', 'processing');
+
+    var deferred = Q.defer();
+    deferred.promise.then(function() {
+      this.setTimeout();
+    }.bind(this));
+
+    var eventName = command.get('eventName');
+    if (!eventName) {
+      throw new Error('I need an event to trigger when this guy is parsed and ready');
+    }
+
+    var Main = require('../app');
+    var eventBaton = Main.getEventBaton();
+
+    var numListeners = eventBaton.getNumListeners(eventName);
+    if (!numListeners) {
+      var Errors = require('../util/errors');
+      command.set('error', new Errors.GitError({
+        msg: intl.str('error-command-currently-not-supported')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    Main.getEventBaton().trigger(eventName, command, deferred);
+  },
+
+  clear: function() {
+    clearTimeout(this.timeout);
+    this.timeout = null;
+  },
+
+  sipFromBuffer: function() {
+    if (!this.buffer.length) {
+      this.clear();
+      return;
+    }
+
+    this.popAndProcess();
+  }
+});
+
+exports.CommitCollection = CommitCollection;
+exports.CommandCollection = CommandCollection;
+exports.BranchCollection = BranchCollection;
+exports.TagCollection = TagCollection;
+exports.CommandBuffer = CommandBuffer;
+

src/js/models/commandModel.js

@@ -0,0 +1,309 @@
+var Backbone = require('backbone');
+
+var Errors = require('../util/errors');
+
+var ParseWaterfall = require('../level/parseWaterfall').ParseWaterfall;
+var LevelStore = require('../stores/LevelStore');
+var intl = require('../intl');
+
+var CommandProcessError = Errors.CommandProcessError;
+var GitError = Errors.GitError;
+var Warning = Errors.Warning;
+var CommandResult = Errors.CommandResult;
+
+var Command = Backbone.Model.extend({
+  defaults: {
+    status: 'inqueue',
+    rawStr: null,
+    result: '',
+    createTime: null,
+
+    error: null,
+    warnings: null,
+    parseWaterfall: new ParseWaterfall(),
+
+    generalArgs: null,
+    supportedMap: null,
+    options: null,
+    method: null
+
+  },
+
+  initialize: function() {
+    this.initDefaults();
+    this.validateAtInit();
+
+    this.on('change:error', this.errorChanged, this);
+    // catch errors on init
+    if (this.get('error')) {
+      this.errorChanged();
+    }
+
+    this.parseOrCatch();
+  },
+
+  initDefaults: function() {
+    // weird things happen with defaults if you don't
+    // make new objects
+    this.set('generalArgs', []);
+    this.set('supportedMap', {});
+    this.set('warnings', []);
+  },
+
+  replaceDotWithHead: function(string) {
+    return string.replace(/\./g, 'HEAD');
+  },
+
+  /**
+   * Since mercurial always wants revisions with
+   * -r, we want to just make these general
+   * args for git
+   */
+  appendOptionR: function() {
+    var rOptions = this.getOptionsMap()['-r'] || [];
+    this.setGeneralArgs(
+      this.getGeneralArgs().concat(rOptions)
+    );
+  },
+
+  // if order is important
+  prependOptionR: function() {
+    var rOptions = this.getOptionsMap()['-r'] || [];
+    this.setGeneralArgs(
+      rOptions.concat(this.getGeneralArgs())
+    );
+  },
+
+  mapDotToHead: function() {
+    var generalArgs = this.getGeneralArgs();
+    var options = this.getOptionsMap();
+
+    generalArgs = generalArgs.map(function(arg) {
+      return this.replaceDotWithHead(arg);
+    }, this);
+    var newMap = {};
+    Object.keys(options).forEach(function(key) {
+      var args = options[key];
+      newMap[key] = Object.values(args).map(function (arg) {
+        return this.replaceDotWithHead(arg);
+      }, this);
+    }, this);
+    this.setGeneralArgs(generalArgs);
+    this.setOptionsMap(newMap);
+  },
+
+  deleteOptions: function(options) {
+    var map = this.getOptionsMap();
+    options.forEach(function(option) {
+      delete map[option];
+    }, this);
+    this.setOptionsMap(map);
+  },
+
+  getGeneralArgs: function() {
+    return this.get('generalArgs');
+  },
+
+  setGeneralArgs: function(args) {
+    this.set('generalArgs', args);
+  },
+
+  setOptionsMap: function(map) {
+    this.set('supportedMap', map);
+  },
+
+  getOptionsMap: function() {
+    return this.get('supportedMap');
+  },
+
+  acceptNoGeneralArgs: function() {
+    if (this.getGeneralArgs().length) {
+      throw new GitError({
+        msg: intl.str('git-error-no-general-args')
+      });
+    }
+  },
+
+  argImpliedHead: function (args, lower, upper, option) {
+    // our args we expect to be between {lower} and {upper}
+    this.validateArgBounds(args, lower, upper, option);
+    // and if it's one, add a HEAD to the back
+    this.impliedHead(args, lower);
+  },
+
+  oneArgImpliedHead: function(args, option) {
+    this.argImpliedHead(args, 0, 1, option);
+  },
+
+  twoArgsImpliedHead: function(args, option) {
+    this.argImpliedHead(args, 1, 2, option);
+  },
+
+  threeArgsImpliedHead: function(args, option) {
+    this.argImpliedHead(args, 2, 3, option);
+  },
+
+  oneArgImpliedOrigin: function(args) {
+    this.validateArgBounds(args, 0, 1);
+    if (!args.length) {
+      args.unshift('origin');
+    }
+  },
+
+  twoArgsForOrigin: function(args) {
+    this.validateArgBounds(args, 0, 2);
+  },
+
+  impliedHead: function(args, min) {
+    if(args.length == min) {
+      args.push('HEAD');
+    }
+  },
+
+  // this is a little utility class to help arg validation that happens over and over again
+  validateArgBounds: function(args, lower, upper, option) {
+    var what = (option === undefined) ?
+      'git ' + this.get('method') :
+      this.get('method') + ' ' + option + ' ';
+    what = 'with ' + what;
+
+    if (args.length < lower) {
+      throw new GitError({
+        msg: intl.str(
+          'git-error-args-few',
+          {
+            lower: String(lower),
+            what: what
+          }
+        )
+      });
+    }
+    if (args.length > upper) {
+      throw new GitError({
+        msg: intl.str(
+          'git-error-args-many',
+          {
+            upper: String(upper),
+            what: what
+          }
+        )
+      });
+    }
+  },
+
+  validateAtInit: function() {
+    if (this.get('rawStr') === null) {
+      throw new Error('Give me a string!');
+    }
+    if (!this.get('createTime')) {
+      this.set('createTime', new Date().toString());
+    }
+  },
+
+  setResult: function(msg) {
+    this.set('result', msg);
+  },
+
+  finishWith: function(deferred) {
+    this.set('status', 'finished');
+    deferred.resolve();
+  },
+
+  addWarning: function(msg) {
+    this.get('warnings').push(msg);
+    // change numWarnings so the change event fires. This is bizarre -- Backbone can't
+    // detect if an array changes, so adding an element does nothing
+    this.set('numWarnings', this.get('numWarnings') ? this.get('numWarnings') + 1 : 1);
+  },
+
+  parseOrCatch: function() {
+    this.expandShortcuts(this.get('rawStr'));
+    try {
+      this.processInstants();
+    } catch (err) {
+      Errors.filterError(err);
+      // errorChanged() will handle status and all of that
+      this.set('error', err);
+      return;
+    }
+
+    if (this.parseAll()) {
+      // something in our parse waterfall succeeded
+      return;
+    }
+
+    // if we reach here, this command is not supported :-/
+    this.set('error', new CommandProcessError({
+        msg: intl.str(
+          'git-error-command-not-supported',
+          {
+            command: this.get('rawStr')
+          })
+      })
+    );
+  },
+
+  errorChanged: function() {
+    var err = this.get('error');
+    if (!err) { return; }
+    if (err instanceof CommandProcessError ||
+        err instanceof GitError) {
+      this.set('status', 'error');
+    } else if (err instanceof CommandResult) {
+      this.set('status', 'finished');
+    } else if (err instanceof Warning) {
+      this.set('status', 'warning');
+    }
+    this.formatError();
+  },
+
+  formatError: function() {
+    this.set('result', this.get('error').getMsg());
+  },
+
+  expandShortcuts: function(str) {
+    str = this.get('parseWaterfall').expandAllShortcuts(str);
+    this.set('rawStr', str);
+  },
+
+  processInstants: function() {
+    var str = this.get('rawStr');
+    // first if the string is empty, they just want a blank line
+    if (!str.length) {
+      throw new CommandResult({msg: ""});
+    }
+
+    // then instant commands that will throw
+    this.get('parseWaterfall').processAllInstants(str);
+  },
+
+  parseAll: function() {
+    var rawInput = this.get('rawStr');
+    const aliasMap = LevelStore.getAliasMap();
+    for (var i = 0; i<Object.keys(aliasMap).length; i++) {
+      var alias = Object.keys(aliasMap)[i];
+      var searcher = new RegExp(alias + "(\\s|$)", "g");
+      if (searcher.test(rawInput)) {
+        rawInput = rawInput.replace(searcher, aliasMap[alias] + ' ');
+        break;
+      }
+    }
+
+    var results = this.get('parseWaterfall').parseAll(rawInput);
+
+    if (!results) {
+      // nothing parsed successfully
+      return false;
+    }
+
+    Object.keys(results.toSet).forEach(function(key) {
+      var obj = results.toSet[key];
+      // data comes back from the parsing functions like
+      // options (etc) that need to be set
+      this.set(key, obj);
+    }, this);
+    return true;
+  }
+});
+
+exports.Command = Command;

src/js/react_views/CommandHistoryView.jsx

@@ -0,0 +1,107 @@
+var React = require('react');
+var PropTypes = require('prop-types');
+
+var CommandView = require('../react_views/CommandView.jsx');
+var Main = require('../app');
+
+var _subscribeEvents = [
+  'add',
+  'reset',
+  'change',
+  'all'
+];
+
+class CommandHistoryView extends React.Component {
+
+  componentDidMount() {
+    for (var i = 0; i < _subscribeEvents.length; i++) {
+      this.props.commandCollection.on(
+        _subscribeEvents[i],
+        this.updateFromCollection,
+        this
+      );
+    }
+
+    this.props.commandCollection.on('change', this.scrollDown, this);
+    Main.getEvents().on('commandScrollDown', this.scrollDown, this);
+    Main.getEvents().on('clearOldCommands', () => this.clearOldCommands(), this);
+  }
+
+  componentWillUnmount() {
+    for (var i = 0; i < _subscribeEvents.length; i++) {
+      this.props.commandCollection.off(
+        _subscribeEvents[i],
+        this.updateFromCollection,
+        this
+      );
+    }
+  }
+
+  updateFromCollection() {
+    this.forceUpdate();
+  }
+
+  render() {
+    var allCommands = [];
+    this.props.commandCollection.each(function(command, index) {
+      allCommands.push(
+        <CommandView
+          id={'command_' + index}
+          command={command}
+          key={command.cid}
+        />
+      );
+    }, this);
+    return (
+      <div>
+        {allCommands}
+      </div>
+    );
+  }
+
+  scrollDown() {
+    var cD = document.getElementById('commandDisplay');
+    var t = document.getElementById('terminal');
+
+    // firefox hack
+    var shouldScroll = (cD.clientHeight > t.clientHeight) ||
+      (window.innerHeight < cD.clientHeight);
+
+    // ugh sometimes i wish i had toggle class
+    var hasScroll = t.className.match(/scrolling/g);
+    if (shouldScroll && !hasScroll) {
+      t.className += ' scrolling';
+    } else if (!shouldScroll && hasScroll) {
+      t.className = t.className.replace(/shouldScroll/g, '');
+    }
+
+    if (shouldScroll) {
+      t.scrollTop = t.scrollHeight;
+    }
+  }
+
+  clearOldCommands() {
+    // go through and get rid of every command that is "processed" or done
+    var toDestroy = [];
+
+    this.props.commandCollection.each(function(command) {
+      if (command.get('status') !== 'inqueue' &&
+          command.get('status') !== 'processing') {
+        toDestroy.push(command);
+      }
+    }, this);
+    for (var i = 0; i < toDestroy.length; i++) {
+      toDestroy[i].destroy();
+    }
+    this.updateFromCollection();
+    this.scrollDown();
+  }
+
+}
+
+CommandHistoryView.propTypes = {
+  // the backbone command model collection
+  commandCollection: PropTypes.object.isRequired
+};
+
+module.exports = CommandHistoryView;

src/js/react_views/CommandView.jsx

@@ -0,0 +1,134 @@
+var React = require('react');
+var ReactDOM = require('react-dom');
+var PropTypes = require('prop-types');
+
+var reactUtil = require('../util/reactUtil');
+var keyMirror = require('../util/keyMirror');
+
+var STATUSES = keyMirror({
+  inqueue: null,
+  processing: null,
+  finished: null
+});
+
+class CommandView extends React.Component{
+
+  componentDidMount() {
+    this.props.command.on('change', this.updateStateFromModel, this);
+    this.updateStateFromModel();
+  }
+
+  componentWillUnmount() {
+    this.props.command.off('change', this.updateStateFromModel, this);
+  }
+
+  updateStateFromModel() {
+    var commandJSON = this.props.command.toJSON();
+    this.setState({
+      status: commandJSON.status,
+      rawStr: commandJSON.rawStr,
+      warnings: commandJSON.warnings,
+      result: commandJSON.result
+    });
+  }
+
+  constructor(props, context) {
+    super(props, context);
+    this.state = {
+      status: STATUSES.inqueue,
+      rawStr: 'git commit',
+      warnings: [],
+      result: ''
+    };
+  }
+
+  render() {
+    var commandClass = reactUtil.joinClasses([
+      this.state.status,
+      'commandLine',
+      'transitionBackground'
+    ]);
+
+    return (
+      <div id={this.props.id} className="reactCommandView">
+        <p className={commandClass}>
+          <span className="prompt">{'$'}</span>
+          {' '}
+          <span dangerouslySetInnerHTML={{
+              __html: this.state.rawStr
+            }}
+          />
+          <span className="icons transitionAllSlow">
+            <i className="icon-exclamation-sign"></i>
+            <i className="icon-check-empty"></i>
+            <i className="icon-retweet"></i>
+            <i className="icon-check"></i>
+          </span>
+        </p>
+        {this.renderResult()}
+        <div className="commandLineWarnings">
+          {this.renderFormattedWarnings()}
+        </div>
+      </div>
+    );
+  }
+
+  renderResult() {
+    if (!this.state.result) {
+      return null;
+    }
+    // We are going to get a ton of raw markup here
+    // so lets split into paragraphs ourselves
+    var paragraphs = this.state.result.split("\n");
+    var result = [];
+    for (var i = 0; i < paragraphs.length; i++) {
+      if (paragraphs[i].startsWith('https://')) {
+        result.push(
+          <a
+            href={paragraphs[i]}
+            key={'paragraph_' + i}
+            dangerouslySetInnerHTML={{
+              __html: paragraphs[i]
+            }}
+          />
+        );
+      } else {
+        result.push(
+          <p
+            key={'paragraph_' + i}
+            dangerouslySetInnerHTML={{
+              __html: paragraphs[i]
+            }}
+          />
+        );
+      }
+    }
+    return (
+      <div className={'commandLineResult'}>
+        {result}
+      </div>
+    );
+  }
+
+  renderFormattedWarnings() {
+    var warnings = this.state.warnings;
+    var result = [];
+    for (var i = 0; i < warnings.length; i++) {
+      result.push(
+        <p key={'warning_' + i}>
+          <i className="icon-exclamation-sign"></i>
+          {warnings[i]}
+        </p>
+      );
+    }
+    return result;
+  }
+};
+
+CommandView.propTypes = {
+  // the backbone command model
+  command: PropTypes.object.isRequired,
+  id: PropTypes.string,
+};
+
+module.exports = CommandView;

src/js/react_views/CommandsHelperBarView.jsx

@@ -0,0 +1,71 @@
+var React = require('react');
+var PropTypes = require('prop-types');
+var HelperBarView = require('../react_views/HelperBarView.jsx');
+var Main = require('../app');
+
+var log = require('../log');
+var intl = require('../intl');
+
+class CommandsHelperBarView extends React.Component {
+
+  render() {
+    return (
+      <HelperBarView
+        items={this.getItems()}
+        shown={this.props.shown}
+      />
+    );
+  }
+
+  fireCommand(command) {
+    log.viewInteracted('commandHelperBar');
+    Main.getEventBaton().trigger('commandSubmitted', command);
+  }
+
+  getItems() {
+    return [{
+      text: intl.str('command-helper-bar-levels'),
+      onClick: function() {
+        this.fireCommand('levels');
+      }.bind(this),
+    }, {
+      text: intl.str('command-helper-bar-solution'),
+      onClick: function() {
+        this.fireCommand('show solution');
+      }.bind(this),
+    }, {
+      text: intl.str('command-helper-bar-reset'),
+      onClick: function() {
+        this.fireCommand('reset');
+      }.bind(this),
+    }, {
+      text: intl.str('command-helper-bar-undo'),
+      onClick: function() {
+        this.fireCommand('undo');
+      }.bind(this),
+    }, {
+      text: intl.str('command-helper-bar-objective'),
+      onClick: function() {
+        this.fireCommand('objective');
+      }.bind(this),
+    }, {
+      text: intl.str('command-helper-bar-help'),
+      onClick: function() {
+        this.fireCommand('help general; git help');
+      }.bind(this)
+    }, {
+      icon: 'signout',
+      onClick: function() {
+        this.props.onExit();
+      }.bind(this)
+    }];
+  }
+
+};
+
+CommandsHelperBarView.propTypes = {
+  shown: PropTypes.bool.isRequired,
+  onExit: PropTypes.func.isRequired
+};
+
+module.exports = CommandsHelperBarView;

src/js/react_views/HelperBarView.jsx

@@ -0,0 +1,70 @@
+var React = require('react');
+var PropTypes = require('prop-types');
+
+var reactUtil = require('../util/reactUtil');
+
+class HelperBarView extends React.Component {
+
+  render() {
+    var topClassName = reactUtil.joinClasses([
+      'helperBar',
+      'transitionAll',
+      this.props.shown ? 'show' : '',
+      this.props.className ? this.props.className : ''
+    ]);
+
+    return (
+      <div className={topClassName}>
+        {this.props.items.map(function(item, index) {
+          return [
+            this.renderItem(item, index),
+            // ugh -- we need this spacer at the end only
+            // if we are not the last element
+            index === this.props.items.length - 1 ?
+              null :
+              <span key={'helper_bar_span_' + index}>{' '}</span>
+          ];
+        }.bind(this))}
+      </div>
+    );
+  }
+
+  renderItem(item, index) {
+    var testID = item.icon || item.testID ||
+      item.text.toLowerCase();
+    if (item.newPageLink) {
+      return (
+        <a
+          data-testid={testID}
+          key={'helper_bar_' + index}
+          onClick={item.onClick}
+          target="_blank"
+          href={item.href}>
+          <i className={'icon-' + item.icon} />
+          {' '}
+        </a>
+      );
+    }
+    return (
+      <a
+        data-testid={testID}
+        key={'helper_bar_' + index}
+        onClick={item.onClick}>
+        {item.text ? item.text :
+          <i className={'icon-' + item.icon} />
+        }
+        {' '}
+      </a>
+    );
+  }
+
+};
+
+HelperBarView.propTypes = {
+  className: PropTypes.string,
+  shown: PropTypes.bool.isRequired,
+  items: PropTypes.array.isRequired
+};
+
+
+module.exports = HelperBarView;

src/js/react_views/IntlHelperBarView.jsx

@@ -0,0 +1,157 @@
+var PropTypes = require('prop-types');
+
+var HelperBarView = require('../react_views/HelperBarView.jsx');
+var Main = require('../app');
+var React = require('react');
+
+var log = require('../log');
+
+class IntlHelperBarView extends React.Component{
+
+  render() {
+    return (
+      <HelperBarView
+        items={this.getItems()}
+        shown={this.props.shown}
+      />
+    );
+  }
+
+  fireCommand(command) {
+    log.viewInteracted('intlSelect');
+    Main.getEventBaton().trigger('commandSubmitted', command);
+    this.props.onExit();
+  }
+
+  getItems() {
+    return [{
+      text: 'Git Branching',
+      testID: 'english',
+      onClick: function() {
+        this.fireCommand('locale en_US; levels');
+      }.bind(this)
+    }, {
+      text: '日本語版リポジトリ',
+      testID: 'japanese',
+      onClick: function() {
+        this.fireCommand('locale ja; levels');
+      }.bind(this)
+    }, {
+      text: 'Git 브랜치 배우기',
+      testID: 'korean',
+      onClick: function() {
+        this.fireCommand('locale ko; levels');
+      }.bind(this)
+    }, {
+      text: '学习 Git 分支',
+      testID: 'simplifiedChinese',
+      onClick: function() {
+        this.fireCommand('locale zh_CN; levels');
+      }.bind(this)
+    }, {
+      text: '學習 Git 分支',
+      testID: 'traditionalChinese',
+      onClick: function() {
+        this.fireCommand('locale zh_TW; levels');
+      }.bind(this)
+    }, {
+      text: 'español',
+      testID: 'spanish',
+      onClick: function() {
+        this.fireCommand('locale es_ES; levels');
+      }.bind(this)
+    }, {
+      text: 'argentino',
+      testID: 'argentinian',
+      onClick: function() {
+        this.fireCommand('locale es_AR; levels');
+      }.bind(this)
+    }, {
+      text: 'mexicano',
+      testID: 'mexican',
+      onClick: function() {
+        this.fireCommand('locale es_MX; levels');
+      }.bind(this)
+    }, {
+      text: 'português',
+      testID: 'portuguese',
+      onClick: function() {
+        this.fireCommand('locale pt_BR; levels');
+      }.bind(this)
+    }, {
+      text: 'français',
+      testID: 'french',
+      onClick: function() {
+        this.fireCommand('locale fr_FR; levels');
+      }.bind(this)
+    }, {
+      text: 'Deutsch',
+      testID: 'german',
+      onClick: function() {
+        this.fireCommand('locale de_DE; levels');
+      }.bind(this)
+    }, {
+      text: 'Русский',
+      testID: 'russian',
+      onClick: function() {
+        this.fireCommand('locale ru_RU; levels');
+      }.bind(this)
+    }, {
+      text: 'Українська',
+      testID: 'ukrainian',
+      onClick: function() {
+        this.fireCommand('locale uk; levels');
+      }.bind(this)
+    }, {
+      text: 'Tiếng Việt',
+      testID: 'vietnamese',
+      onClick: function() {
+        this.fireCommand('locale vi; levels');
+      }.bind(this)
+    }, {
+      text: 'Galego',
+      testID: 'galician',
+      onClick: function() {
+        this.fireCommand('locale gl; levels');
+      }.bind(this)
+    }, {
+      text: 'Slovensko',
+      testID: 'slovenian',
+      onClick: function() {
+        this.fireCommand('locale sl_SI; levels');
+      }.bind(this)
+    }, {
+      text: 'Polski',
+      testID: 'polish',
+      onClick: function() {
+        this.fireCommand('locale pl; levels');
+      }.bind(this)
+    }, {
+      text: 'தமிழ்',
+      testID: 'tamil',
+      onClick: function() {
+        this.fireCommand('locale ta_IN; levels');
+      }.bind(this)
+    }, {
+        text: "italiano",
+        testID: "italian",
+        onClick: function () {
+          this.fireCommand("locale it_IT; levels");
+        }.bind(this),
+    },{
+      icon: 'signout',
+      onClick: function() {
+        this.props.onExit();
+      }.bind(this)
+    }
+    ];
+  }
+
+};
+
+IntlHelperBarView.propTypes = {
+  shown: PropTypes.bool.isRequired,
+  onExit: PropTypes.func.isRequired
+}
+
+module.exports = IntlHelperBarView;

src/js/react_views/LevelToolbarView.jsx

@@ -0,0 +1,89 @@
+var React = require('react');
+var PropTypes = require('prop-types');
+
+var intl = require('../intl');
+var reactUtil = require('../util/reactUtil');
+
+class LevelToolbarView extends React.Component {
+
+  constructor(props, context) {
+    super(props, context);
+    this.state = {
+      isHidden: true,
+      isGoalExpanded: this.props.parent.getIsGoalExpanded()
+    };
+  }
+
+  componentWillUnmount() {
+    this._isMounted = false;
+  }
+  componentDidMount() {
+    this._isMounted = true;
+    this.setState({
+      isHidden: this.props.parent.getIsGoalExpanded(),
+      isGoalExpanded: this.props.parent.getIsGoalExpanded()
+    });
+    this.props.parent.on('goalToggled', function() {
+      if (!this._isMounted) {
+        return;
+      }
+
+      this.setState({
+        isGoalExpanded: this.props.parent.getIsGoalExpanded()
+      });
+    }.bind(this));
+  }
+
+  render() {
+    return (
+      <div className={reactUtil.joinClasses([
+          'toolbar',
+          'level-toolbar',
+          'box',
+          'vertical',
+          'center',
+          'transitionAll',
+          this.state.isHidden ? 'hidden' : ''
+        ])}>
+        <div className="clearfix">
+          <div className="levelNameWrapper">
+            <i className="icon-bolt"></i>
+            { intl.str('level-label') }
+            <span className="levelToolbarSpan">
+              {this.props.name}
+            </span>
+          </div>
+        </div>
+        <div className="buttonsWrapper">
+          <div className="showGoalWrapper">
+            <button
+              onClick={this.props.onGoalClick}
+              type="button">
+              {this.state.isGoalExpanded ?
+                intl.str('hide-goal-button') :
+                intl.str('show-goal-button')
+              }
+            </button>
+          </div>
+          <div className="showObjectiveWrapper">
+            <button
+              onClick={this.props.onObjectiveClick}
+              type="button">
+              {intl.str('objective-button')}
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+};
+
+LevelToolbarView.propTypes = {
+  name: PropTypes.string.isRequired,
+  onGoalClick: PropTypes.func.isRequired,
+  onObjectiveClick: PropTypes.func.isRequired,
+  parent: PropTypes.object.isRequired
+}
+
+module.exports = LevelToolbarView;

src/js/react_views/MainHelperBarView.jsx

@@ -0,0 +1,76 @@
+var HelperBarView = require('../react_views/HelperBarView.jsx');
+var IntlHelperBarView =
+  require('../react_views/IntlHelperBarView.jsx');
+var CommandsHelperBarView =
+  require('../react_views/CommandsHelperBarView.jsx');
+var React = require('react');
+
+var keyMirror = require('../util/keyMirror');
+var log = require('../log');
+
+var BARS = keyMirror({
+  SELF: null,
+  INTL: null,
+  COMMANDS: null
+});
+
+class MainHelperBarView extends React.Component {
+
+  constructor(props, context) {
+    super(props, context);
+    this.state = {
+      shownBar: BARS.SELF
+    };
+  }
+
+  render() {
+    return (
+      <div>
+        <HelperBarView
+          className="BaseHelperBar"
+          items={this.getItems()}
+          shown={this.state.shownBar === BARS.SELF}
+        />
+        <CommandsHelperBarView
+          shown={this.state.shownBar === BARS.COMMANDS}
+          onExit={this.showSelf.bind(this)}
+        />
+        <IntlHelperBarView
+          shown={this.state.shownBar === BARS.INTL}
+          onExit={this.showSelf.bind(this)}
+        />
+      </div>
+    );
+  }
+
+  showSelf() {
+    this.setState({
+      shownBar: BARS.SELF
+    });
+  }
+
+  getItems() {
+    return [{
+      icon: 'question-sign',
+      onClick: function() {
+        this.setState({
+          shownBar: BARS.COMMANDS
+        });
+      }.bind(this)
+    }, {
+      icon: 'globe',
+      onClick: function() {
+        this.setState({
+          shownBar: BARS.INTL
+        });
+      }.bind(this)
+    }, {
+      newPageLink: true,
+      icon: 'twitter',
+      href: 'https://twitter.com/petermcottle'
+    }];
+  }
+
+};
+
+module.exports = MainHelperBarView;

src/js/sandbox/commands.js

@@ -0,0 +1,219 @@
+var util = require('../util');
+
+var constants = require('../util/constants');
+var intl = require('../intl');
+
+var Commands = require('../commands');
+var Errors = require('../util/errors');
+var CommandProcessError = Errors.CommandProcessError;
+var LocaleStore = require('../stores/LocaleStore');
+var LocaleActions = require('../actions/LocaleActions');
+var LevelStore = require('../stores/LevelStore');
+var GlobalStateStore = require('../stores/GlobalStateStore');
+var GlobalStateActions = require('../actions/GlobalStateActions');
+var GitError = Errors.GitError;
+var Warning = Errors.Warning;
+var CommandResult = Errors.CommandResult;
+
+var instantCommands = [
+  [/^ls( |$)/, function() {
+    throw new CommandResult({
+      msg: intl.str('ls-command')
+    });
+  }],
+  [/^cd( |$)/, function() {
+    throw new CommandResult({
+      msg: intl.str('cd-command')
+    });
+  }],
+  [/^(locale|locale reset)$/, function(bits) {
+    LocaleActions.changeLocale(
+      LocaleStore.getDefaultLocale()
+    );
+
+    throw new CommandResult({
+      msg: intl.str(
+        'locale-reset-command',
+        { locale: LocaleStore.getDefaultLocale() }
+      )
+    });
+  }],
+  [/^show$/, function(bits) {
+    var lines = [
+      intl.str('show-command'),
+      '<br/>',
+      'show commands',
+      'show solution',
+      'show goal'
+    ];
+
+    throw new CommandResult({
+      msg: lines.join('\n')
+    });
+  }],
+  [/^alias (\w+)="(.+)"$/, function(bits) {
+    const alias = bits[1];
+    const expansion = bits[2];
+    LevelStore.addToAliasMap(alias, expansion);
+    throw new CommandResult({
+      msg: 'Set alias "'+alias+'" to "'+expansion+'"',
+    });
+  }],
+  [/^unalias (\w+)$/, function(bits) {
+    const alias = bits[1];
+    LevelStore.removeFromAliasMap(alias);
+    throw new CommandResult({
+      msg: 'Removed alias "'+alias+'"',
+    });
+  }],
+  [/^locale (\w+)$/, function(bits) {
+    LocaleActions.changeLocale(bits[1]);
+    throw new CommandResult({
+      msg: intl.str(
+        'locale-command',
+        { locale: bits[1] }
+      )
+    });
+  }],
+  [/^flip$/, function() {
+    GlobalStateActions.changeFlipTreeY(
+      !GlobalStateStore.getFlipTreeY()
+    );
+    require('../app').getEvents().trigger('refreshTree');
+    throw new CommandResult({
+      msg: intl.str('flip-tree-command')
+    });
+  }],
+  [/^disableLevelInstructions$/, function() {
+    GlobalStateActions.disableLevelInstructions();
+    throw new CommandResult({
+      msg: intl.todo('Level instructions disabled'),
+    });
+  }],
+  [/^refresh$/, function() {
+    var events = require('../app').getEvents();
+
+    events.trigger('refreshTree');
+    throw new CommandResult({
+      msg: intl.str('refresh-tree-command')
+    });
+  }],
+  [/^rollup (\d+)$/, function(bits) {
+    var events = require('../app').getEvents();
+
+    // go roll up these commands by joining them with semicolons
+    events.trigger('rollupCommands', bits[1]);
+    throw new CommandResult({
+      msg: 'Commands combined!'
+    });
+  }],
+  [/^echo "(.*?)"$|^echo (.*?)$/, function(bits) {
+    var msg = bits[1] || bits[2];
+    throw new CommandResult({
+      msg: msg
+    });
+  }],
+  [/^show +commands$/, function(bits) {
+    var allCommands = getAllCommands();
+    var allOptions = Commands.commands.getOptionMap();
+    var commandToOptions = {};
+
+    Object.keys(allOptions).forEach(function(vcs) {
+      var vcsMap = allOptions[vcs];
+      Object.keys(vcsMap).forEach(function(method) {
+        var options = vcsMap[method];
+        if (options) {
+          commandToOptions[vcs + ' ' + method] = Object.keys(options).filter(option => option.length > 1);
+        }
+      });
+    });
+
+
+    var lines = [
+      intl.str('show-all-commands'),
+      '<br/>'
+    ];
+    Object.keys(allCommands)
+      .forEach(function(command) {
+        lines.push(command);
+        if (commandToOptions[command]) {
+          commandToOptions[command].forEach(option => lines.push('&nbsp;&nbsp;&nbsp;&nbsp;' + option));
+        }
+      });
+
+    throw new CommandResult({
+      msg: lines.join('\n')
+    });
+  }]
+];
+
+var regexMap = {
+  'reset solved': /^reset solved($|\s)/,
+  'help': /^help( +general)?$|^\?$/,
+  'reset': /^reset( +--forSolution)?$/,
+  'delay': /^delay (\d+)$/,
+  'clear': /^clear($|\s)/,
+  'exit level': /^exit level($|\s)/,
+  'sandbox': /^sandbox($|\s)/,
+  'level': /^level\s?([a-zA-Z0-9]*)/,
+  'levels': /^levels($|\s)/,
+  'mobileAlert': /^mobile alert($|\s)/,
+  'build level': /^build +level\s?([a-zA-Z0-9]*)$/,
+  'export tree': /^export +tree$/,
+  'importTreeNow': /^importTreeNow($|\s)/,
+  'importLevelNow': /^importLevelNow($|\s)/,
+  'import tree': /^import +tree$/,
+  'import level': /^import +level$/,
+  'undo': /^undo($|\s)/,
+  'share permalink': /^share( +permalink)?$/
+};
+
+var getAllCommands = function() {
+  var toDelete = [
+    'mobileAlert'
+  ];
+
+  var allCommands = Object.assign(
+    {},
+    require('../level').regexMap,
+    regexMap
+  );
+  var mRegexMap = Commands.commands.getRegexMap();
+  Object.keys(mRegexMap).forEach(function(vcs) {
+    var map = mRegexMap[vcs];
+    Object.keys(map).forEach(function(method) {
+      var regex = map[method];
+      allCommands[vcs + ' ' + method] = regex;
+    });
+  });
+  toDelete.forEach(function(key) {
+    delete allCommands[key];
+  });
+
+  return allCommands;
+};
+
+exports.getAllCommands = getAllCommands;
+exports.instantCommands = instantCommands;
+exports.parse = util.genParseCommand(regexMap, 'processSandboxCommand');
+
+// optimistically parse some level and level builder commands; we do this
+// so you can enter things like "level intro1; show goal" and not
+// have it barf. when the
+// command fires the event, it will check if there is a listener and if not throw
+// an error
+
+// note: these are getters / setters because the require kills us
+exports.getOptimisticLevelParse = function() {
+  return util.genParseCommand(
+    require('../level').regexMap,
+    'processLevelCommand'
+  );
+};
+
+exports.getOptimisticLevelBuilderParse = function() {
+  return util.genParseCommand(
+    require('../level/builder').regexMap,
+    'processLevelBuilderCommand'
+  );
+};

src/js/sandbox/index.js

@@ -0,0 +1,487 @@
+var Q = require('q');
+var Backbone = require('backbone');
+
+var util = require('../util');
+var intl = require('../intl');
+var Main = require('../app');
+var Errors = require('../util/errors');
+
+var Visualization = require('../visuals/visualization').Visualization;
+var ParseWaterfall = require('../level/parseWaterfall').ParseWaterfall;
+var DisabledMap = require('../level/disabledMap').DisabledMap;
+var Command = require('../models/commandModel').Command;
+var GitShim = require('../git/gitShim').GitShim;
+var LevelActions = require('../actions/LevelActions');
+var LevelStore = require('../stores/LevelStore');
+
+var Views = require('../views');
+var ModalTerminal = Views.ModalTerminal;
+var ModalAlert = Views.ModalAlert;
+var BuilderViews = require('../views/builderViews');
+var MultiView = require('../views/multiView').MultiView;
+
+var Sandbox = Backbone.View.extend({
+  // tag name here is purely vestigial. I made this a view
+  // simply to use inheritance and have a nice event system in place
+  tagName: 'div',
+  initialize: function(options) {
+    options = options || {};
+    this.options = options;
+
+    this.initVisualization(options);
+    this.initCommandCollection(options);
+    this.initParseWaterfall(options);
+    this.initGitShim(options);
+    this.initUndoStack(options);
+
+    if (!options.wait) {
+      this.takeControl();
+    }
+  },
+
+  getDefaultVisEl: function() {
+    return $('#mainVisSpace')[0];
+  },
+
+  getAnimationTime: function() { return 700 * 1.5; },
+
+  initVisualization: function(options) {
+    this.mainVis = new Visualization({
+      el: options.el || this.getDefaultVisEl()
+    });
+  },
+
+  initUndoStack: function(options) {
+    this.undoStack = [];
+  },
+
+  initCommandCollection: function(options) {
+    // don't add it to just any collection -- adding to the
+    // CommandUI collection will put in history
+    this.commandCollection = Main.getCommandUI().commandCollection;
+  },
+
+  initParseWaterfall: function(options) {
+    this.parseWaterfall = new ParseWaterfall();
+  },
+
+  initGitShim: function(options) {
+    this.gitShim = new GitShim({
+      beforeCB: this.beforeCommandCB.bind(this)
+    });
+  },
+
+  takeControl: function() {
+    // we will be handling commands that are submitted, mainly to add the sandbox
+    // functionality (which is included by default in ParseWaterfall())
+    Main.getEventBaton().stealBaton('commandSubmitted', this.commandSubmitted, this);
+    // we obviously take care of sandbox commands
+    Main.getEventBaton().stealBaton('processSandboxCommand', this.processSandboxCommand, this);
+
+    // a few things to help transition between levels and sandbox
+    Main.getEventBaton().stealBaton('levelExited', this.levelExited, this);
+
+    this.insertGitShim();
+  },
+
+  releaseControl: function() {
+    // we will be handling commands that are submitted, mainly to add the sandbox
+    // functionality (which is included by default in ParseWaterfall())
+    Main.getEventBaton().releaseBaton('commandSubmitted', this.commandSubmitted, this);
+    // we obviously take care of sandbox commands
+    Main.getEventBaton().releaseBaton('processSandboxCommand', this.processSandboxCommand, this);
+    // a few things to help transition between levels and sandbox
+    Main.getEventBaton().releaseBaton('levelExited', this.levelExited, this);
+
+    this.releaseGitShim();
+  },
+
+  releaseGitShim: function() {
+    if (this.gitShim) {
+      this.gitShim.removeShim();
+    }
+  },
+
+  insertGitShim: function() {
+    // and our git shim goes in after the git engine is ready so it doesn't steal the baton
+    // too early
+    if (this.gitShim) {
+      this.mainVis.customEvents.on('gitEngineReady', function() {
+          this.gitShim.insertShim();
+      },this);
+    }
+  },
+
+  beforeCommandCB: function(command) {
+    this.pushUndo();
+  },
+
+  pushUndo: function() {
+    // go ahead and push the three onto the stack
+    this.undoStack.push(this.mainVis.gitEngine.printTree());
+  },
+
+  undo: function(command, deferred) {
+    var toRestore = this.undoStack.pop();
+    if (!toRestore) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('undo-stack-empty')
+      }));
+      deferred.resolve();
+      return;
+    }
+
+    this.mainVis.reset(toRestore);
+    setTimeout(function() {
+      command.finishWith(deferred);
+    }, this.mainVis.getAnimationTime());
+  },
+
+  commandSubmitted: function(value) {
+    // allow other things to see this command (aka command history on terminal)
+    Main.getEvents().trigger('commandSubmittedPassive', value);
+
+    util.splitTextCommand(value, function(command) {
+      this.commandCollection.add(new Command({
+        rawStr: command,
+        parseWaterfall: this.parseWaterfall
+      }));
+    }, this);
+  },
+
+  startLevel: function(command, deferred) {
+    var regexResults = command.get('regexResults') || [];
+    var desiredID = regexResults[1] || '';
+    var levelJSON = LevelStore.getLevel(desiredID);
+
+    // handle the case where that level is not found...
+    if (!levelJSON) {
+      command.addWarning(
+        intl.str(
+          'level-no-id',
+          { id: desiredID }
+        )
+      );
+      Main.getEventBaton().trigger('commandSubmitted', 'levels');
+
+      command.set('status', 'error');
+      deferred.resolve();
+      return;
+    }
+
+    // we are good to go!! lets prep a bit visually
+    this.hide();
+    this.clear();
+
+    // we don't even need a reference to this,
+    // everything will be handled via event baton :DDDDDDDDD
+    var whenLevelOpen = Q.defer();
+    var Level = require('../level').Level;
+
+    this.currentLevel = new Level({
+      level: levelJSON,
+      deferred: whenLevelOpen,
+      command: command
+    });
+
+    whenLevelOpen.promise.then(function() {
+      command.finishWith(deferred);
+    });
+  },
+
+  buildLevel: function(command, deferred) {
+    this.hide();
+    this.clear();
+
+    var whenBuilderOpen = Q.defer();
+    var LevelBuilder = require('../level/builder').LevelBuilder;
+
+    var regexResults = command.get('regexResults') || [];
+    var toEdit = regexResults[1] || false;
+    this.levelBuilder = new LevelBuilder({
+      deferred: whenBuilderOpen,
+      editLevel: toEdit
+    });
+    whenBuilderOpen.promise.then(function() {
+      command.finishWith(deferred);
+    });
+  },
+
+  exitLevel: function(command, deferred) {
+    command.addWarning(
+      intl.str('level-cant-exit')
+    );
+    command.set('status', 'error');
+    deferred.resolve();
+  },
+
+  showLevels: function(command, deferred) {
+    var whenClosed = Q.defer();
+    Main.getLevelDropdown().show(whenClosed, command);
+    whenClosed.promise.done(function() {
+      command.finishWith(deferred);
+    });
+  },
+
+  sharePermalink: function(command, deferred) {
+    var treeJSON = JSON.stringify(this.mainVis.gitEngine.exportTree());
+    var url =
+      'https://learngitbranching.js.org/?NODEMO&command=importTreeNow%20' + escape(treeJSON);
+    command.setResult(
+      intl.todo('Here is a link to the current state of the tree: ') + '\n' + url
+    );
+    command.finishWith(deferred);
+  },
+
+  resetSolved: function(command, deferred) {
+    if (command.get('regexResults').input !== 'reset solved --confirm') {
+      command.set('error', new Errors.GitError({
+        msg: 'Reset solved will mark each level as not yet solved; because ' +
+             'this is a destructive command, please pass in --confirm to execute',
+      }));
+      command.finishWith(deferred);
+      return;
+    }
+
+    LevelActions.resetLevelsSolved();
+    command.addWarning(
+      intl.str('solved-map-reset')
+    );
+    command.finishWith(deferred);
+  },
+
+  processSandboxCommand: function(command, deferred) {
+    // I'm tempted to do cancel case conversion, but there are
+    // some exceptions to the rule
+    var commandMap = {
+      'reset solved': this.resetSolved,
+      'undo': this.undo,
+      'help general': this.helpDialog,
+      'help': this.helpDialog,
+      'reset': this.reset,
+      'delay': this.delay,
+      'clear': this.clear,
+      'exit level': this.exitLevel,
+      'level': this.startLevel,
+      'sandbox': this.exitLevel,
+      'levels': this.showLevels,
+      'mobileAlert': this.mobileAlert,
+      'build level': this.buildLevel,
+      'export tree': this.exportTree,
+      'import tree': this.importTree,
+      'importTreeNow': this.importTreeNow,
+      'import level': this.importLevel,
+      'importLevelNow': this.importLevelNow,
+      'share permalink': this.sharePermalink,
+    };
+
+    var method = commandMap[command.get('method')];
+    if (!method) { throw new Error('no method for that wut'); }
+
+    method.apply(this, [command, deferred]);
+  },
+
+  hide: function() {
+    this.mainVis.hide();
+  },
+
+  levelExited: function() {
+    this.show();
+  },
+
+  show: function() {
+    this.mainVis.show();
+  },
+
+  importLevelNow: function(command, deferred) {
+    var options = command.get('regexResults') || [];
+    if (options.length < 2) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('git-error-options')
+      }));
+      command.finishWith(deferred);
+      return;
+    }
+    var string = options.input.replace(/importLevelNow\s+/g, '');
+    var Level = require('../level').Level;
+    try {
+      var levelJSON = JSON.parse(unescape(string));
+      var whenLevelOpen = Q.defer();
+      this.currentLevel = new Level({
+        level: levelJSON,
+        deferred: whenLevelOpen,
+        command: command
+      });
+      this.hide();
+
+      whenLevelOpen.promise.then(function() {
+        command.finishWith(deferred);
+      });
+    } catch(e) {
+      command.set('error', new Errors.GitError({
+        msg: 'Something went wrong ' + String(e)
+      }));
+      throw e;
+    }
+    command.finishWith(deferred);
+  },
+
+  importTreeNow: function(command, deferred) {
+    var options = command.get('regexResults') || [];
+    if (options.length < 2) {
+      command.set('error', new Errors.GitError({
+        msg: intl.str('git-error-options')
+      }));
+      command.finishWith(deferred);
+    }
+    var string = options.input.replace(/importTreeNow\s+/g, '');
+    try {
+      this.mainVis.gitEngine.loadTreeFromString(string);
+    } catch (e) {
+      command.set('error', new Errors.GitError({
+        msg: String(e)
+      }));
+    }
+    command.finishWith(deferred);
+  },
+
+  importTree: function(command, deferred) {
+    var jsonGrabber = new BuilderViews.MarkdownPresenter({
+      previewText: intl.str('paste-json'),
+      fillerText: ' '
+    });
+    jsonGrabber.deferred.promise
+    .then(function(treeJSON) {
+      try {
+        this.mainVis.gitEngine.loadTree(JSON.parse(treeJSON));
+      } catch(e) {
+        this.mainVis.reset();
+        new MultiView({
+          childViews: [{
+            type: 'ModalAlert',
+            options: {
+              markdowns: [
+                '## Error!',
+                '',
+                'Something is wrong with that JSON! Here is the error:',
+                '',
+                String(e)
+              ]
+            }
+          }]
+        });
+      }
+    }.bind(this))
+    .fail(function() { })
+    .done(function() {
+      command.finishWith(deferred);
+    });
+  },
+
+  importLevel: function(command, deferred) {
+    var jsonGrabber = new BuilderViews.MarkdownPresenter({
+      previewText: intl.str('paste-json'),
+      fillerText: ' '
+    });
+
+    jsonGrabber.deferred.promise
+    .then(function(inputText) {
+      var Level = require('../level').Level;
+      try {
+        var levelJSON = JSON.parse(inputText);
+        var whenLevelOpen = Q.defer();
+        this.currentLevel = new Level({
+          level: levelJSON,
+          deferred: whenLevelOpen,
+          command: command
+        });
+        this.hide();
+
+        whenLevelOpen.promise.then(function() {
+          command.finishWith(deferred);
+        });
+      } catch(e) {
+        new MultiView({
+          childViews: [{
+            type: 'ModalAlert',
+            options: {
+              markdowns: [
+                '## Error!',
+                '',
+                'Something is wrong with that level JSON, this happened:',
+                '',
+                String(e)
+              ]
+            }
+          }]
+        });
+        command.finishWith(deferred);
+      }
+    }.bind(this))
+    .fail(function() {
+      command.finishWith(deferred);
+    })
+    .done();
+  },
+
+  exportTree: function(command, deferred) {
+    var treeJSON = JSON.stringify(this.mainVis.gitEngine.exportTree(), null, 2);
+
+    var showJSON = new MultiView({
+      childViews: [{
+        type: 'MarkdownPresenter',
+        options: {
+          previewText: intl.str('share-tree'),
+          fillerText: treeJSON,
+          noConfirmCancel: true
+        }
+      }]
+    });
+    showJSON.getPromise()
+    .then(function() {
+      command.finishWith(deferred);
+    })
+    .done();
+  },
+
+  clear: function(command, deferred) {
+    Main.getEvents().trigger('clearOldCommands');
+    if (command && deferred) {
+      command.finishWith(deferred);
+    }
+  },
+
+  mobileAlert: function(command, deferred) {
+    alert(intl.str('mobile-alert'));
+    command.finishWith(deferred);
+  },
+
+  delay: function(command, deferred) {
+    var amount = parseInt(command.get('regexResults')[1], 10);
+    setTimeout(function() {
+      command.finishWith(deferred);
+    }, amount);
+  },
+
+  reset: function(command, deferred) {
+    this.mainVis.reset();
+    this.initUndoStack();
+
+    setTimeout(function() {
+      command.finishWith(deferred);
+    }, this.mainVis.getAnimationTime());
+  },
+
+  helpDialog: function(command, deferred) {
+    var helpDialog = new MultiView({
+      childViews: intl.getDialog(require('../dialogs/sandbox'))
+    });
+    helpDialog.getPromise().then(function() {
+      // the view has been closed, lets go ahead and resolve our command
+      command.finishWith(deferred);
+    }.bind(this))
+    .done();
+  }
+});
+
+exports.Sandbox = Sandbox;