@slugbugblue/trax 0.7.0 → 0.8.0

package/src/cli.js

@@ -0,0 +1,994 @@
+#!/usr/bin/env node
+/* Copyright 2022 Chad Transtrum
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLI for Trax, with a fallback REPL
+
+import fs from 'node:fs/promises'
+import process from 'node:process'
+import repl from 'node:repl'
+
+import envPaths from 'env-paths'
+import makeDir from 'make-dir'
+import YAML from 'yaml'
+
+import { Trax } from './engine.js'
+import { version } from './version.js'
+import * as tty from './tty.js'
+
+const notationRx = /^([@a-z]+)(\d+)([bps/\\+])$/i
+const moveRx = /^(\d+)\.?$/
+
+const CONFIG = {}
+const DATA = {}
+
+const paths = envPaths('trax', { suffix: '' })
+const PATHS = {}
+
+const state = {
+  game: {},
+  trax: new Trax(),
+}
+
+const COLORS = {
+  black: 240,
+  command: 33,
+  default: 39,
+  error: 205,
+  fatal: 127,
+  help: 74,
+  id: 195,
+  variable: 123,
+  optional: 110,
+  short: 153,
+  white: 250,
+}
+
+let startRepl = false
+
+// Because typeof [] and null are both 'object'. is([], 'arr') => true
+const is = (variable, type) =>
+  Object.prototype.toString
+    .call(variable)
+    .slice(8, -1)
+    .toLowerCase()
+    .startsWith(type)
+
+// Return the actual path on disk, creating it if necessary.
+// Path is one of cache, config, data, log, temp.
+const getPath = async (path) => {
+  if (path in PATHS) return PATHS[path]
+  if (path in paths) {
+    const realPath = await makeDir(paths[path])
+    PATHS[path] = realPath
+    return realPath
+  }
+
+  return false
+}
+
+const hexy = (length = 6) => {
+  let hex = ''
+  while (hex.length < length) {
+    hex += '0123456789abcdef'[Math.floor(Math.random() * 16)]
+  }
+
+  return hex
+}
+
+const fsOuch = (fsError) => {
+  tty.outty(fsError, COLORS.fatal)
+  throw fsError
+}
+
+// Hope this works
+const getFile = async (filetype, filename, variable, decode) => {
+  const path = await getPath(filetype)
+  if (path) {
+    try {
+      const contents = await fs.readFile(`${path}/${filename}`, 'utf8')
+      for (const [key, value] of Object.entries(decode(contents))) {
+        variable[key] = value
+      }
+    } catch (fsError) {
+      if (fsError instanceof TypeError || fsError instanceof SyntaxError) {
+        error(`Unable to read ${filetype} file ${path}/${filename}`)
+      } else if (fsError.code !== 'ENOENT') {
+        fsOuch(fsError)
+      }
+    }
+  }
+
+  return variable
+}
+
+const getConfig = async () => {
+  await getFile('config', 'trax.yaml', CONFIG, YAML.parse)
+  return CONFIG
+}
+
+const getData = async () => {
+  await getFile('data', 'trax.json', DATA, JSON.parse)
+  return DATA
+}
+
+const saveFile = (filetype, filename, data) => {
+  getPath(filetype).then((path) => {
+    if (path) {
+      const parts = filename.split('.')
+      parts.splice(1, 0, hexy())
+      const tmpfile = path + '/' + parts.join('.')
+      filename = path + '/' + filename
+      fs.writeFile(tmpfile, data)
+        .then(() => {
+          fs.rm(filename, { force: true, maxRetries: 5 })
+            .then(() => {
+              fs.rename(tmpfile, filename).catch(fsOuch)
+            })
+            .catch(fsOuch)
+        })
+        .catch(fsOuch)
+    }
+  })
+}
+
+const saveConfig = () => {
+  saveFile('config', 'trax.yaml', YAML.stringify(CONFIG))
+}
+
+const saveData = () => {
+  saveFile('data', 'trax.json', JSON.stringify(DATA, null, 2) + '\n')
+}
+
+const parseCommandLine = () => {
+  let cmd = ''
+  const args = process.argv.slice(2)
+  let dash = true
+  let action = false
+  for (const arg of args) {
+    if (dash && arg.startsWith('-')) {
+      if (arg === '--') dash = false
+      if (arg === '-i' || arg === '--interactive') startRepl = true
+      if (arg === '-h' || arg === '--help') cmd = 'help ' + cmd
+      if (arg === '-v' || arg === '--version') {
+        console.info('trax v' + version)
+        action = true
+      }
+    } else {
+      cmd += arg + ' '
+    }
+  }
+
+  return action && cmd.length === 0 ? undefined : cmd.slice(0, -1)
+}
+
+const color = (text, def) => {
+  let out = ''
+  let quote = false
+  let id = false
+  const colors = [def]
+  const c = (t) => tty.color(t, colors[colors.length - 1] || COLORS.default)
+  const short = (t) => tty.color(t, COLORS.short) + c()
+  for (const char of text) {
+    switch (char) {
+      case '"':
+        if (quote) {
+          colors.pop()
+        } else {
+          colors.push(COLORS.command)
+        }
+
+        out += c('')
+        quote = !quote
+        break
+      case '#':
+        id = true
+        colors.push(COLORS.id)
+        out += c('#')
+        break
+      case '|':
+        out += short('|')
+        break
+      case '[':
+        colors.push(COLORS.optional)
+        out += short('[')
+        break
+      case ']':
+        colors.pop()
+        out += short(']')
+        break
+      case '<':
+        colors.push(COLORS.variable)
+        out += c('')
+        break
+      case '>':
+        colors.pop()
+        out += c('')
+        break
+      default:
+        if (id && !/[\da-z]/.test(char)) {
+          id = false
+          colors.pop()
+          out += c(char)
+        } else {
+          out += char
+        }
+    }
+  }
+
+  return tty.color(out, def || COLORS.default)
+}
+
+const error = (text) => {
+  tty.outty(color(text, COLORS.error))
+}
+
+const commands = {
+  delete: {
+    alt: ['remove', 'rm'],
+    args: '[#id] ["force"]',
+    desc: 'delete a game',
+    help: [
+      'Delete the current game. Or specify a game number to delete that game.',
+      'If the game is in progress, you must type "force" to delete it.',
+    ],
+  },
+  export: {
+    alt: ['save', 'keep', 'share'],
+    args: '[#id] [filename]',
+    desc: 'save a game to a file',
+    help: [
+      'Export the current game to an external ".trx" file for safe-keeping or',
+      'to share. Specify a game id to export a different game.',
+    ],
+  },
+  help: {
+    alt: '?',
+    args: '[topic]',
+    desc: 'display help for a command',
+    help: [
+      'Type "help <command>" or "<command> help" to see additional information',
+      'for a specific command.',
+    ],
+  },
+  import: {
+    alt: ['load', 'open'],
+    args: '<filename>',
+    desc: 'open a game file',
+    help: [
+      'Load a ".trx" game file into memory. Once imported, it will be assigned',
+      'a game id and automatically selected for future commands.',
+    ],
+  },
+  list: {
+    alt: 'ls',
+    args: '[sort|filter...] ["reverse"]',
+    desc: 'list all games',
+    help: [
+      'Valid sort options are:',
+      '  <id>: sort by game id',
+      '  <game>: sort by game type',
+      '  <player1> or <player2>: sort by player name',
+      '  <moves>: sort by the number of moves',
+      'Available filters:',
+      '  #id: match a game or a certain number of moves',
+      '  <active> or <over>: whether a game is in progress or not',
+      '  <loop> or <8x8> or <trax>: filter by game type',
+      "  other text: match a player's name",
+      'Add the "reverse" option to reverse the sort order.',
+    ],
+  },
+  new: {
+    alt: 'start',
+    args: '[variant] [[p1 name] "vs" [p2 name]]',
+    desc: 'start a new game',
+    help: [
+      'Valid variants are <trax>, <loop>, and <8x8>. Defaults to "trax" if not',
+      'specified. Use the "vs" keyword to use specific names for the players.',
+    ],
+  },
+  play: {
+    alt: ['move', 'mv'],
+    args: '<move> [...]',
+    desc: 'play a move',
+    help: [
+      'Enter the move in standard Trax notation. The final character of the',
+      'notation can be replaced with a letter for ease of entering at the',
+      'command line. Use <s> for "/", <b> for "\\", and <p> for "+".',
+      'Multiple moves can be submitted at once. Move numbers are optional,',
+      'but if included, they will be checked for accuracy.',
+    ],
+  },
+  select: {
+    alt: ['choose', '#'],
+    args: '#id',
+    desc: 'select a different game',
+    help: 'Make another game the default game of future commands.',
+  },
+  try: {
+    alt: 'see',
+    args: '<move>',
+    desc: 'see the effects of a move',
+    help: [
+      'View a move without committing to it. This is useful for seeing the',
+      'effects of forced tiles.',
+    ],
+  },
+  undo: {
+    args: '[n]',
+    desc: 'undo the last move in a game',
+    help: [
+      'Backtrack one or more moves in a game. Type "undo" to take back the last',
+      'move, or "undo 2" to undo the last two moves.',
+    ],
+  },
+  view: {
+    alt: ['show', 'display'],
+    args: '[#id]',
+    desc: 'show the game board',
+    help: [
+      'Show the current game. Or specify a game number to switch to and view',
+      'that game. Future commands will default to that game.',
+    ],
+  },
+  quit: {
+    alt: 'exit',
+    desc: 'press <Ctrl-D> to exit',
+    help: 'To exit, press Ctrl-D on a blank line or type "quit".',
+  },
+}
+
+const length = (text) => (text ? text.replace(/[<">]/g, '').length : 0)
+
+commands.help.fn = (word) => {
+  word = (word && abbreviations[word.toLowerCase()]) || word
+  let cmds = Object.keys(commands).filter((c) => !word || c.startsWith(word))
+  if (cmds.length === 0) {
+    cmds = Object.keys(commands).filter((c) => c.includes(word))
+  }
+
+  if (cmds.length === 0) cmds = Object.keys(commands)
+  let max = 1
+  for (const key of cmds) {
+    max = Math.max(max, key.length + length(commands[key].args))
+  }
+
+  for (const key of cmds.sort()) {
+    if (key === 'quit' && !state.repl) continue // Hide quit unless in repl
+    const topic = commands[key]
+    const space = ' '.repeat(5 + max - length(topic.args) - key.length)
+    tty.outty(
+      color(`  ${key} ${topic.args || ''}`, COLORS.command) +
+        color(space + topic.desc, COLORS.short),
+    )
+  }
+
+  if (cmds.length === 1) {
+    const topic = commands[cmds[0]]
+    const { alt } = topic
+    if (alt) {
+      const alts = is(alt, 'arr') ? alt : [alt]
+      for (const alias of alts) {
+        tty.outty(color(`  ${alias}`, COLORS.command))
+      }
+    }
+
+    tty.outty()
+    if (is(topic.help, 'str')) {
+      tty.outty('    ' + color(topic.help, COLORS.help))
+    } else {
+      for (const line of topic.help || []) {
+        tty.outty('    ' + color(line, COLORS.help))
+      }
+    }
+  }
+}
+
+const newId = () => {
+  let max = 0
+  let min = Number.POSITIVE_INFINITY
+  if (DATA.games) {
+    for (const id of Object.keys(DATA.games)) {
+      max = Math.max(max, Number(id) || 0)
+      min = Math.min(min, Number(id) || 0)
+    }
+  } else {
+    DATA.games = {}
+  }
+
+  if (max === 0 || min <= 1) return String(max + 1)
+
+  return String(min - 1)
+}
+
+commands.import.fn = async (filename) => {
+  if (!filename) {
+    error('Missing filename.')
+    return commands.help.fn('import')
+  }
+
+  let content
+  try {
+    content = await fs.readFile(filename, 'utf8')
+  } catch (fsError) {
+    if (fsError.code === 'ENOENT' && !filename.endsWith('.trx')) {
+      try {
+        content = await fs.readFile(filename + '.trx', 'utf8')
+      } catch {
+        content = null
+      }
+    }
+
+    if (!content) error(fsError.toString())
+  }
+
+  if (content) {
+    let game
+    let players = []
+    const moves = []
+    for (const line of content.split('\n')) {
+      if (!line) continue
+      const ln = line.split(';')[0]
+      if (!ln) continue
+      const lower = ln.toLowerCase()
+      if (!game && lower.includes('trax')) {
+        game = 'trax'
+        if (lower.includes('loop')) game = 'traxloop'
+        if (lower.includes('8x8')) game = 'trax8'
+      } else if (players.length === 0 && lower.includes(' vs ')) {
+        players = ln.split(' ').filter((p) => p)
+      } else {
+        moves.push(...ln.split(' '))
+      }
+    }
+
+    if (game) {
+      commands.new.fn(game, ...players)
+      commands.play.fn(...moves.filter((m) => m))
+    } else {
+      error(filename + ' does not appear to be formatted correctly.')
+    }
+  }
+}
+
+commands.export.fn = (id, filename) => {
+  let { game } = state
+  if (id) {
+    const newid = id.replace(/^#/, '')
+    game = DATA.games?.[newid]
+    if (!game) {
+      filename = id
+      game = state.game
+    }
+  }
+
+  if (!game || !game.id) {
+    return error('No active game. Type "new" to start a game.')
+  }
+
+  const trax = new Trax(game.rules, game.moves, 'cli')
+
+  let content = Trax.names[trax.rules].replace(' ', '') + '\n'
+  content += game?.players?.[0] || 'white'
+  content += ' vs '
+  content += game?.players?.[1] || 'black'
+  content += '\n; @slugbugblue/trax cli.js v' + version + '\n'
+  content += trax.notation + '\n'
+  if (filename) filename = filename.replace(/[^ a-z\d./]/g, '')
+  if (filename) {
+    const fname = filename.split('/').pop()
+    if (!fname.includes('.')) filename += '.trx'
+    tty.outty(color('Exporting #' + game.id + ' to ') + filename)
+    fs.writeFile(filename, content).catch(fsOuch)
+  } else {
+    tty.outty(content)
+  }
+}
+
+const updateGameData = () => {
+  const data = DATA.games[state.game.id]
+  const moves = state.trax.moves.join(' ')
+  if (data.moves !== moves) {
+    data.moves = moves
+    data.turn = state.trax.turn
+    if (state.trax.over) data.over = true
+    saveData()
+  }
+}
+
+commands.new.fn = (variant, ...names) => {
+  let rules = ''
+  if (variant) {
+    if (['8x8', '8', 'trax8x8'].includes(variant)) rules = 'trax8'
+    if (['loop', 'l'].includes(variant)) rules = 'traxloop'
+    if (variant === 't') rules = 'trax'
+    if (['trax', 'traxloop', 'trax8'].includes(variant)) rules = variant
+    if (!rules) {
+      if (names.includes('vs') || names.includes('VS')) {
+        // We don't have a variant, we have player names
+        names.unshift(variant)
+      } else {
+        error('Unknown Trax variant.')
+        commands.help.fn('new')
+        return
+      }
+    }
+  }
+
+  const players = ['white', 'black']
+  if (names.length > 0) {
+    let vs = names.indexOf('vs')
+    if (vs === -1) vs = names.indexOf('VS')
+    if (vs >= 0) {
+      players[0] = names.slice(0, vs).join(' ') || players[0]
+      players[1] = names.slice(vs + 1).join(' ') || players[1]
+    }
+  }
+
+  CONFIG.id = newId()
+  state.trax = new Trax(rules, undefined, 'cli')
+  DATA.games[CONFIG.id] = {
+    id: CONFIG.id,
+    rules: state.trax.rules,
+    name: state.trax.name,
+    turn: 1,
+    players,
+    moves: state.trax.moves.join(' '),
+  }
+  state.game = DATA.games[CONFIG.id]
+
+  saveConfig()
+  saveData()
+
+  tty.outty(color('Started new game #' + CONFIG.id))
+}
+
+const fixNotation = (move) => {
+  if (move.endsWith('b')) return move.slice(0, -1) + '\\'
+  if (move.endsWith('s')) return move.slice(0, -1) + '/'
+  if (move.endsWith('p')) return move.slice(0, -1) + '+'
+  return move
+}
+
+commands.play.fn = (...moves) => {
+  if (moves.length === 0 || !moves[0]) {
+    error('You must provide a move.')
+    return commands.help.fn('play')
+  }
+
+  if (!state.trax || !state.game.id) {
+    commands.new.fn()
+  }
+
+  if (state.trax.over) {
+    error('The game is over.')
+    return
+  }
+
+  const start = state.trax.move
+  let checkMove
+
+  for (let move of moves) {
+    if (notationRx.test(move)) {
+      const moveNumber = state.trax.move
+      move = fixNotation(move)
+      if (checkMove) {
+        state.trax.playMove(checkMove, move)
+      } else {
+        state.trax.play(move)
+      }
+
+      if (state.trax.move === moveNumber) {
+        error(
+          'Move "' +
+            (checkMove ? checkMove + '. ' : '') +
+            move +
+            '" is invalid.',
+        )
+      }
+    } else if (moveRx.test(move)) {
+      checkMove = Number(move)
+    } else if (move) {
+      error('Move "' + move + '" is not in the correct notation.')
+    }
+  }
+
+  if (state.trax.move !== start) {
+    updateGameData()
+    commands.view.fn()
+  }
+}
+
+commands.try.fn = (move) => {
+  if (move.length === 0) {
+    error('You must provide a move.')
+    return commands.help.fn('try')
+  }
+
+  if (!state.trax) {
+    commands.new.fn()
+  }
+
+  if (state.trax.over) {
+    error('The game is over.')
+    return
+  }
+
+  if (notationRx.test(move)) {
+    move = fixNotation(move)
+    const play = state.trax.dropTile(move, undefined, 'tentative')
+    if (play.valid || play.dropped.length > 0) {
+      tty.display(state.trax, state.game.players, move)
+    } else {
+      error('Move is invalid.')
+    }
+  } else {
+    error('Move is invalid.')
+  }
+}
+
+commands.view.fn = (id) => {
+  if (id) {
+    // Hand off the hard work to the hard worker
+    commands.select.fn(id)
+  }
+
+  if (!state.game?.id) {
+    return error('No active game. Type "new" to start a game.')
+  }
+
+  tty.outty(
+    color('#' + CONFIG.id + ' ') +
+      tty.name(state.trax.rules) +
+      ' ' +
+      tty.bubble('w', state.game.players[0]) +
+      color(' vs ') +
+      tty.bubble('b', state.game.players[1]),
+  )
+  tty.display(state.trax, state.game.players)
+}
+
+const plural = (n, noun, nouns) =>
+  n + ' ' + (Math.abs(n) === 1 ? noun : nouns ? nouns : noun + 's')
+
+const alphaSort = (a, b) => {
+  a = String(a).toLowerCase()
+  b = String(b).toLowerCase()
+  if (a < b) return -1
+  if (b < a) return 1
+  return 0
+}
+
+const sortBy = (sort) => {
+  if (!sort) return 'id'
+  sort = sort.toLowerCase()
+  if (sort === '#') return 'sid'
+  if ('ids'.startsWith(sort)) return 'sid'
+  if ('games'.startsWith(sort)) return 'rules'
+  if ('rules'.startsWith(sort)) return 'rules'
+  if ('names'.startsWith(sort)) return 'rules'
+  if ('numbers'.startsWith(sort)) return 'sid'
+  if ('moves'.startsWith(sort)) return 'smoves'
+  if ('status'.startsWith(sort)) return 'smoves'
+  if ('turn'.startsWith(sort)) return 'sturn'
+  if ('player'.startsWith(sort) && sort.endsWith('1')) return 'p1'
+  if ('player'.startsWith(sort) && sort.endsWith('2')) return 'p2'
+  if ('reverse'.startsWith(sort)) return 'reverse'
+  return sort
+}
+
+const listSort = (list, filters) => {
+  if (list.length === 0) return list
+  let reverse = false
+  for (const sort of filters) {
+    const by = sortBy(sort)
+    if (by === 'reverse') {
+      reverse = true
+    } else if (list[0]?.[by]) {
+      list.sort((a, b) => alphaSort(a[by], b[by]))
+    } else if (by === 'trax') {
+      list = list.filter((g) => g.rules === by)
+    } else if (['over', 'active'].includes(by)) {
+      list = list.filter((g) => (by === 'over' ? g.over : !g.over))
+    } else {
+      list = list.filter(
+        (g) =>
+          g.id.endsWith(by) ||
+          Trax.names[g.rules].toLowerCase().includes(by) ||
+          g.p1.toLowerCase().includes(by) ||
+          g.p2.toLowerCase().includes(by) ||
+          g.moves.startsWith(by + ' '),
+      )
+    }
+  }
+
+  if (reverse) list.reverse()
+
+  return list
+}
+
+commands.list.fn = (...filters) => {
+  if (!DATA.games || Object.keys(DATA.games).length === 0) {
+    return error('No games. Type "new" to start a new game.')
+  }
+
+  let list = []
+  const size = {
+    id: 1,
+    name: 1,
+    moves: 1,
+    p1: 1,
+    p2: 1,
+  }
+
+  for (const game of Object.values(DATA.games)) {
+    const moves = game.moves.length === 0 ? 0 : game.moves.split(' ').length
+    list.push({
+      sid: String(game.id).padStart(9, '0'),
+      id: (game.id === state.game.id ? '* #' : '#') + String(game.id),
+      name: game.name?.length || 0,
+      rules: game.rules,
+      moves: plural(moves, 'move'),
+      smoves: game.over ? '9999' : String(moves).padStart(9, '0'),
+      sturn: String(game.turn),
+      p1: game.players?.[0] || 'white',
+      p2: game.players?.[1] || 'black',
+      turn: game.turn,
+      over: game.over,
+    })
+  }
+
+  list = listSort(list, filters)
+
+  for (const game of list) {
+    size.id = Math.max(size.id, game.id.length)
+    size.name = Math.max(size.name, game.name)
+    size.moves = Math.max(size.moves, game.moves.length)
+    size.p1 = Math.max(size.p1, game.p1.length)
+    size.p2 = Math.max(size.p2, game.p2.length)
+  }
+
+  for (const game of list) {
+    tty.outty(
+      color(game.id.padStart(size.id) + ' ') +
+        tty.name(game.rules) +
+        ' '.repeat(size.name - game.name + 1) +
+        tty.bubble(game.turn === 1 ? 'wh' : 'w', game.p1) +
+        color('vs '.padStart(size.p1 - game.p1.length + 4)) +
+        tty.bubble(game.turn === 2 ? 'bh' : 'b', game.p2) +
+        color(' '.padStart(size.p2 - game.p2.length + 1)) +
+        color(game.over ? 'game over' : game.moves),
+    )
+  }
+}
+
+const load = (id) => {
+  if (!id) id = Object.keys(DATA.games || {})[0]
+  if (id && DATA.games?.[id] && DATA.games[id].rules) {
+    state.game = DATA.games[id]
+    if (!state.game.players) state.game.players = ['white', 'black']
+    state.trax = new Trax(state.game.rules, state.game.moves, 'cli')
+    if (id !== String(CONFIG.id)) {
+      CONFIG.id = id
+      saveConfig()
+    }
+  }
+}
+
+commands.select.fn = (id) => {
+  if (!id) {
+    error('Missing id.')
+    return commands.help.fn('select')
+  }
+
+  if (id.startsWith('#')) id = id.slice(1)
+  load(id)
+  if (String(state.game.id) === id) {
+    tty.outty(color('Game #' + state.game.id + ' selected.'))
+  } else {
+    error('Invalid id. Type "list" to see available games.')
+  }
+}
+
+const selectAnyGame = () => {
+  if (DATA.games) {
+    const games = Object.values(DATA.games).sort((a, b) => {
+      // Active games first
+      if (a.over && !b.over) return 1
+      if (b.over && !a.over) return -1
+      // Games with more moves first
+      return (b.moves?.length || 0) - (a.moves?.length || 0)
+    })
+    if (games.length > 0) {
+      commands.select.fn(String(games[0].id))
+    }
+  }
+}
+
+commands.delete.fn = (id, force = 'x') => {
+  if (!id) id = String(state.game.id)
+  if ('force'.startsWith(id)) {
+    id = String(state.game.id)
+    force = 'force'
+  }
+
+  if (id.startsWith('#')) id = id.slice(1)
+
+  const game = DATA.games?.[id]
+
+  if (!game || !String(game.id)) {
+    return error('Invalid id. Type "list" to see available games.')
+  }
+
+  if (game.over || game.moves === '' || 'force'.startsWith(force)) {
+    delete DATA.games[id]
+    tty.outty(color('Deleted game #' + id + '.'))
+    saveData()
+
+    if (id === String(state.game.id)) {
+      CONFIG.id = null
+      state.game = null
+      state.trax = new Trax()
+      selectAnyGame()
+    }
+  } else {
+    error('Game #' + id + ' is still active. Use "force" to delete it.')
+  }
+}
+
+commands.undo.fn = (id, n) => {
+  if (Number(n) || (id && id.startsWith('#'))) {
+    // Id has been supplied
+    commands.select.fn(id)
+  } else {
+    n = id
+  }
+
+  n = Math.max(1, Math.floor(Number(n) || 1)) // Get an integer 1 or higher
+
+  const moves = state.game.moves.split(' ')
+  const undo = moves.slice(0, 0 - n)
+  if (moves.length === undo.length) {
+    error('Unable to undo.')
+  } else {
+    if (state.game.over) state.game.over = false
+    state.game.moves = undo.join(' ')
+    state.trax = new Trax(state.game.rules, undo, 'cli')
+    state.game.turn = state.trax.turn
+    saveData()
+    commands.view.fn()
+  }
+}
+
+commands.quit.fn = () => {
+  // I actually have no idea why a broken promise is required here,
+  // but I tried a lot of different options, and this is what worked
+  return new Promise(() => {
+    if (state.repl) {
+      state.repl.close()
+    }
+  })
+}
+
+const abbreviations = {}
+
+const addAbbrev = (abbr, full) => {
+  const abbrArray = is(abbr, 'str') ? [abbr] : abbr
+  for (let abbrev of abbrArray) {
+    while (abbrev.length > 0) {
+      const abbrSet = abbreviations[abbrev] || new Set()
+      abbrSet.add(full)
+      abbreviations[abbrev] = abbrSet
+      abbrev = abbrev.slice(0, -1)
+    }
+  }
+}
+
+const addAbbreviations = () => {
+  for (const key of Object.keys(commands)) {
+    addAbbrev(key, key)
+    if (commands[key].alt) addAbbrev(commands[key].alt, key)
+  }
+
+  for (const [abbr, value] of Object.entries(abbreviations)) {
+    const newValue = [...value]
+    abbreviations[abbr] = value.size > 1 ? newValue.sort() : newValue[0]
+  }
+}
+
+const evaluate = async (command) => {
+  const [CMD, ...words] = command.split(/\s+/)
+  const cmdLower = CMD.toLowerCase()
+  const cmd = abbreviations[cmdLower]
+  if (is(cmd, 'str')) {
+    if (words.length > 0 && abbreviations[words[0].toLowerCase()] === 'help') {
+      commands.help.fn(cmd)
+    } else {
+      await commands[cmd].fn(...words)
+    }
+  } else if (is(cmd, 'arr')) {
+    error('Ambiguous command. Perhaps you meant one of the following:')
+    const maybe = new Set()
+
+    for (const alias of cmd) {
+      if (alias.startsWith(cmdLower)) maybe.add(alias)
+
+      let aliases = commands[alias].alt
+      aliases = is(aliases, 'arr') ? aliases : [aliases || '']
+
+      for (const alt of aliases) {
+        if (alt.startsWith(cmdLower)) maybe.add(alt)
+      }
+    }
+
+    if (maybe.size > 0) {
+      for (const alias of [...maybe].sort()) {
+        tty.outty(color('  ' + alias, COLORS.command))
+      }
+    }
+  } else if (CMD) {
+    if (CMD.startsWith('#') && CMD.length > 1) {
+      commands.select.fn(CMD.slice(1))
+    } else if (
+      notationRx.test(CMD) ||
+      (moveRx.test(CMD) && notationRx.test(words[0]))
+    ) {
+      commands.play.fn(CMD, ...words)
+    } else {
+      error('Unknown command. Type "help" for a list of valid commands.')
+    }
+  }
+
+  return undefined
+}
+
+const main = async () => {
+  const command = parseCommandLine()
+  if (is(command, 'str')) {
+    await Promise.all([getConfig(), getData()])
+    load(CONFIG.id)
+    addAbbreviations()
+    if (command) await evaluate(command)
+    if (startRepl || !command) {
+      if (!command) {
+        tty.outty(color('Welcome to the Trax CLI v' + version + '.'))
+        tty.outty(color('Type "help" for more information.'))
+      }
+
+      state.repl = repl.start({
+        prompt: 'trax❯ ',
+        async eval(cmd, ctx, fn, cb) {
+          try {
+            await evaluate(cmd)
+          } catch (error) {
+            tty.outty(error, COLORS.fatal)
+            throw error
+          }
+
+          cb(null, undefined)
+        },
+        writer(value) {
+          if (value) {
+            return value
+          }
+
+          return ''
+        },
+      })
+    }
+  }
+}
+
+main()