@slugbugblue/trax 0.8.0 → 0.9.0

package/src/cli.js

@@ -16,47 +16,31 @@
 
 // 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
+// Load all the commands as individual plugins
+import { deleteCmd } from './cmds/delete.js'
+import { helpCmd } from './cmds/help.js'
+import {
+  importCmd,
+  exportCmd,
+  getFile,
+  saveFile,
+  findFiles,
+} from './cmds/import-export.js'
+import { listCmd } from './cmds/list.js'
+import { newCmd } from './cmds/new.js'
+import { playCmd, tryCmd } from './cmds/play-try.js'
+import { selectCmd } from './cmds/select.js'
+import { undoCmd } from './cmds/undo.js'
+import { viewCmd } from './cmds/view.js'
 
 // Because typeof [] and null are both 'object'. is([], 'arr') => true
 const is = (variable, type) =>
@@ -66,128 +50,80 @@ const is = (variable, type) =>
     .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)
+// Sample command:
+const versionCmd = {
+  name: 'version',
+  opts: ['--version', '-v'],
+  desc: 'display version number',
+  help: 'Print out the current version of this program.',
+  fn: (CLI) => CLI.out('Trax CLI v' + version),
+}
+
+const quitCmd = {
+  name: 'quit',
+  alt: 'exit',
+  desc: 'press <Ctrl-D> to exit',
+  help: 'To exit, press Ctrl-D on a blank line or type "quit".',
+  hide: true,
+  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 (CLI.repl) {
+        CLI.repl.close()
       }
-    }
-  }
-
-  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 + ' '
+const plugins = [
+  deleteCmd,
+  exportCmd,
+  helpCmd,
+  importCmd,
+  listCmd,
+  newCmd,
+  playCmd,
+  quitCmd,
+  selectCmd,
+  tryCmd,
+  undoCmd,
+  versionCmd,
+  viewCmd,
+]
+
+const newId = (DATA) => {
+  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 = {}
   }
 
-  return action && cmd.length === 0 ? undefined : cmd.slice(0, -1)
+  if (max === 0 || min <= 1) return String(max + 1)
+
+  return String(min - 1)
 }
 
+// Colorize text according to simplistic and not very complete patterns
 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()
+  const c = (t) => tty.color(t, colors[colors.length - 1] || CLI.COLORS.default)
+  const short = (t) => tty.color(t, CLI.COLORS.short) + c()
   for (const char of text) {
     switch (char) {
       case '"':
         if (quote) {
           colors.pop()
         } else {
-          colors.push(COLORS.command)
+          colors.push(CLI.COLORS.command)
         }
 
         out += c('')
@@ -195,14 +131,14 @@ const color = (text, def) => {
         break
       case '#':
         id = true
-        colors.push(COLORS.id)
+        colors.push(CLI.COLORS.id)
         out += c('#')
         break
       case '|':
         out += short('|')
         break
       case '[':
-        colors.push(COLORS.optional)
+        colors.push(CLI.COLORS.optional)
         out += short('[')
         break
       case ']':
@@ -210,7 +146,7 @@ const color = (text, def) => {
         out += short(']')
         break
       case '<':
-        colors.push(COLORS.variable)
+        colors.push(CLI.COLORS.variable)
         out += c('')
         break
       case '>':
@@ -228,726 +164,423 @@ const color = (text, def) => {
     }
   }
 
-  return tty.color(out, def || COLORS.default)
+  return tty.color(out, def || CLI.COLORS.default)
 }
 
-const error = (text) => {
-  tty.outty(color(text, COLORS.error))
-}
+// Internal representations of files
+const CONFIG = { id: 0 }
+const DATA = { games: {} }
 
-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.',
+// CLI context object for plugins
+const CLI = {
+  // Quick access to all stored games
+  get GAMES() {
+    return DATA.games || {}
   },
-  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.',
-    ],
+  // And information about the current game
+  get GAME() {
+    return (CONFIG.id && DATA.games?.[CONFIG.id]) || {}
   },
-  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.',
-    ],
+  // And the current game ID
+  get ID() {
+    return CONFIG.id
   },
-  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".',
+
+  // Provide access to the current Trax object
+  TRAX: new Trax(),
+
+  // Color codes
+  COLORS: {
+    black: 240,
+    command: 33,
+    default: 39,
+    error: 205,
+    fatal: 127,
+    help: 74,
+    id: 195,
+    variable: 123,
+    optional: 110,
+    short: 153,
+    white: 250,
   },
-}
 
-const length = (text) => (text ? text.replace(/[<">]/g, '').length : 0)
+  // All of the above COLORS will be populated automatically into "color", where
+  // they can be called as functions, to apply the given color, eg:
+  // CLI.color('hi') and CLI.color.default('hi') are equivalent
+  color,
 
-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))
-  }
+  cmd(command) {
+    // Return a command structure object or an empty object
+    if (is(command, 'str') && command in commands) {
+      return commands[command]
+    }
 
-  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))
-  }
+    return {}
+  },
 
-  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),
-    )
-  }
+  get commands() {
+    return Object.keys(commands)
+  },
 
-  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))
-      }
-    }
+  delete(id) {
+    delete DATA.games[id]
+    saveData()
+  },
 
-    tty.outty()
-    if (is(topic.help, 'str')) {
-      tty.outty('    ' + color(topic.help, COLORS.help))
+  do(cmd, ...args) {
+    // Call another plugin
+    if (cmd in commands) {
+      commands[cmd].fn(CLI, ...args)
     } else {
-      for (const line of topic.help || []) {
-        tty.outty('    ' + color(line, COLORS.help))
-      }
+      throw new SyntaxError(`${cmd} is not a valid command`)
     }
-  }
-}
-
-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)
-}
+  async doNext(...cmd) {
+    // Execute another command line
+    await evaluate(cmd.join(' '))
+  },
 
-commands.import.fn = async (filename) => {
-  if (!filename) {
-    error('Missing filename.')
-    return commands.help.fn('import')
-  }
+  error(text) {
+    // Prints an error to stdout
+    CLI.out(CLI.color.error(text))
+  },
 
-  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
-      }
+  newGame(rules, players, moves) {
+    // Creates a new game
+    const id = newId(DATA)
+    const trax = new Trax(rules, moves, 'cli')
+    DATA.games[id] = {
+      id,
+      rules: trax.rules,
+      name: trax.name,
+      turn: trax.turn,
+      players,
+      moves: trax.moves.join(' '),
     }
 
-    if (!content) error(fsError.toString())
-  }
+    CONFIG.id = id
+    CLI.TRAX = trax
 
-  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(' '))
-      }
-    }
+    saveConfig()
+    saveData()
 
-    if (game) {
-      commands.new.fn(game, ...players)
-      commands.play.fn(...moves.filter((m) => m))
-    } else {
-      error(filename + ' does not appear to be formatted correctly.')
-    }
-  }
-}
+    return id
+  },
 
-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
+  out(text) {
+    // Prints to stdout
+    console.info(text + tty.color(''))
+  },
+
+  resolveCommand(word) {
+    // Determine if an entered word is a valid command.
+    // Returns the command if a single match is found, an array if multiple
+    // commands match, or undefined if nothing matches.
+    if (is(word, 'str') && word.length > 0) {
+      return abbreviations[word.toLowerCase()]
     }
-  }
 
-  if (!game || !game.id) {
-    return error('No active game. Type "new" to start a game.')
-  }
+    return undefined
+  },
 
-  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)
-  }
-}
+  setGame(moves) {
+    // Updates the moves for the current game
+    const game = CLI.GAME
+    const trax = new Trax(game.rules, moves, 'cli')
+    if (game.over || trax.over) game.over = trax.over
+    game.moves = trax.moves.join(' ')
+    game.turn = trax.turn
+    CLI.TRAX = trax
 
-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
-      }
+  updateGameData() {
+    const data = DATA.games[CLI.GAME.id]
+    const moves = CLI.TRAX.moves.join(' ')
+    if (data.moves !== moves) {
+      data.moves = moves
+      data.turn = CLI.TRAX.turn
+      if (CLI.TRAX.over) data.over = true
+      saveData()
     }
-  }
+  },
 
-  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]
-    }
-  }
+  load(id) {
+    if (!id) id = Object.keys(DATA.games || {})[0]
+    if (id && DATA.games?.[id] && DATA.games[id].rules) {
+      if (id !== String(CONFIG.id)) {
+        CONFIG.id = id
+        saveConfig()
+      }
 
-  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]
+      const game = CLI.GAME
+      if (!game.players) game.players = ['white', 'black']
+      CLI.TRAX = new Trax(game.rules, game.moves, 'cli')
+    }
+  },
 
-  saveConfig()
-  saveData()
+  // Pass through functions
+  bubble: tty.bubble,
+  display: tty.display,
+  name: tty.name,
 
-  tty.outty(color('Started new game #' + CONFIG.id))
+  is,
+  version,
 }
 
-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
-}
+let startRepl = false
 
-commands.play.fn = (...moves) => {
-  if (moves.length === 0 || !moves[0]) {
-    error('You must provide a move.')
-    return commands.help.fn('play')
-  }
+const getConfig = async () => {
+  await getFile('config', 'trax.yaml', CONFIG, YAML.parse)
+  return CONFIG
+}
 
-  if (!state.trax || !state.game.id) {
-    commands.new.fn()
-  }
+const getData = async () => {
+  await getFile('data', 'trax.json', DATA, JSON.parse)
+  return DATA
+}
 
-  if (state.trax.over) {
-    error('The game is over.')
-    return
-  }
+const saveConfig = () => {
+  saveFile('config', 'trax.yaml', YAML.stringify(CONFIG))
+}
 
-  const start = state.trax.move
-  let checkMove
+const saveData = () => {
+  saveFile('data', 'trax.json', JSON.stringify(DATA, null, 2) + '\n')
+}
 
-  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)
-      }
+const OPTS = {}
 
-      if (state.trax.move === moveNumber) {
-        error(
-          'Move "' +
-            (checkMove ? checkMove + '. ' : '') +
-            move +
-            '" is invalid.',
-        )
+const parseCommandLine = () => {
+  let cmd = ''
+  const args = process.argv.slice(2)
+  let dash = true
+  for (const arg of args) {
+    if (dash && arg.startsWith('-')) {
+      if (arg === '--') dash = false
+      if (arg === '-i' || arg === '--interactive') startRepl = true
+      if (arg in OPTS) {
+        cmd = OPTS[arg] + ' ' + cmd
       }
-    } else if (moveRx.test(move)) {
-      checkMove = Number(move)
-    } else if (move) {
-      error('Move "' + move + '" is not in the correct notation.')
+    } else {
+      cmd += arg + ' '
     }
   }
 
-  if (state.trax.move !== start) {
-    updateGameData()
-    commands.view.fn()
-  }
+  return cmd.slice(0, -1)
 }
 
-commands.try.fn = (move) => {
-  if (move.length === 0) {
-    error('You must provide a move.')
-    return commands.help.fn('try')
-  }
+// Auto-populate the color functions
+for (const [name, value] of Object.entries(CLI.COLORS)) {
+  CLI.color[name] = (text) => color(text, value)
+}
 
-  if (!state.trax) {
-    commands.new.fn()
-  }
+const forceArray = (item) =>
+  is(item, 'arr') ? item : is(item, 'undef') ? [] : [item]
 
-  if (state.trax.over) {
-    error('The game is over.')
-    return
-  }
+const abbreviations = {}
+const commands = {}
+const aliases = []
+const regexes = []
 
-  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.')
+const addAbbrev = (abbr, full) => {
+  for (let abbrev of abbr) {
+    while (abbrev.length > 0) {
+      const abbrSet = abbreviations[abbrev] || new Set()
+      abbrSet.add(full)
+      abbreviations[abbrev] = abbrSet
+      abbrev = abbrev.slice(0, -1)
     }
-  } 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 makeComp = (comp) => {
+  if (is(comp, 'arr') || is(comp, 'func')) return comp
+  if (is(comp, 'str')) return comp.split(' ')
+  return []
 }
 
-const plural = (n, noun, nouns) =>
-  n + ' ' + (Math.abs(n) === 1 ? noun : nouns ? nouns : noun + 's')
+const processPlugins = () => {
+  // Process all the plugin command entries
+  for (const cmd of plugins) {
+    if (cmd.opts) {
+      for (const opt of forceArray(cmd.opts)) {
+        OPTS[opt] = cmd.name
+      }
+    }
 
-const alphaSort = (a, b) => {
-  a = String(a).toLowerCase()
-  b = String(b).toLowerCase()
-  if (a < b) return -1
-  if (b < a) return 1
-  return 0
-}
+    if (cmd.rx) {
+      for (const rx of forceArray(cmd.rx)) {
+        regexes.push({ rx, name: cmd.name })
+      }
+    }
 
-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 entry = {
+      alt: forceArray(cmd.alt),
+      args: cmd.args || '',
+      comp: makeComp(cmd.comp),
+      desc: cmd.desc,
+      help: forceArray(cmd.help),
+      hide: cmd.hide,
+      fn: cmd.fn,
+    }
+    addAbbrev([cmd.name, ...entry.alt], cmd.name)
+    commands[cmd.name] = entry
 
-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 + ' '),
-      )
+    aliases.push(cmd.name)
+    for (const alias of entry.alt) {
+      aliases.push(alias)
     }
   }
 
-  if (reverse) list.reverse()
-
-  return list
+  for (const [abbr, value] of Object.entries(abbreviations)) {
+    const newValue = [...value]
+    abbreviations[abbr] = value.size > 1 ? newValue.sort() : newValue[0]
+  }
 }
 
-commands.list.fn = (...filters) => {
-  if (!DATA.games || Object.keys(DATA.games).length === 0) {
-    return error('No games. Type "new" to start a new game.')
+const expand = (completions, match) => {
+  completions = [...completions] // Do not modify in-place
+  if (completions.includes('<cmd>')) {
+    // All commands
+    completions[completions.indexOf('<cmd>')] = aliases.join('|')
   }
 
-  let list = []
-  const size = {
-    id: 1,
-    name: 1,
-    moves: 1,
-    p1: 1,
-    p2: 1,
-  }
+  if (completions.includes('<id>')) {
+    // Game numbers
+    const ids = []
+    for (const game of Object.values(DATA.games || {})) {
+      if (game.id) ids.push('#' + game.id)
+    }
 
-  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,
-    })
+    completions[completions.indexOf('<id>')] = ids.join('|')
   }
 
-  list = listSort(list, filters)
+  if (completions.includes('<move>')) {
+    // Move numbers
+    const moves = []
+    for (let move = 1; move <= CLI.TRAX.moves.length; move++) {
+      moves.push(String(move))
+    }
 
-  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)
+    completions[completions.indexOf('<move>')] = moves.join('|')
   }
 
-  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),
-    )
+  if (completions.includes('<play>')) {
+    // Moves
+    const moves = CLI.TRAX.possibleMoves()
+    completions[completions.indexOf('<play>')] = moves.join('|')
   }
-}
 
-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()
-    }
+  if (completions.includes('<file>')) {
+    // Files ... a bit tricky since we don't want to async in the middle of
+    // a completion, but we do want to list all the .trx files in the folder
+    // we are looking for ... so we cheat and initiate a search on the first
+    // call, and maybe have completions by the second or third call ...
+    completions[completions.indexOf('<file>')] = findFiles(match).join('|')
   }
-}
 
-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.')
-  }
+  return completions
 }
 
-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))
-    }
-  }
-}
+const completer = (line) => {
+  const words = line.split(/\s+/).filter((w) => w)
 
-commands.delete.fn = (id, force = 'x') => {
-  if (!id) id = String(state.game.id)
-  if ('force'.startsWith(id)) {
-    id = String(state.game.id)
-    force = 'force'
+  let match = words.slice(-1)[0] || ''
+  const previous = new Set(words.slice(1, -1).map((s) => s.toLowerCase()))
+  if (line.endsWith(' ')) {
+    previous.add(match.toLowerCase())
+    match = ''
   }
 
-  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.')
-  }
+  let completions = []
+  const cmd = abbreviations[String(words[0]).toLowerCase()]
 
-  if (game.over || game.moves === '' || 'force'.startsWith(force)) {
-    delete DATA.games[id]
-    tty.outty(color('Deleted game #' + id + '.'))
-    saveData()
+  if (is(cmd, 'str') && (line.endsWith(' ') || words.length > 1)) {
+    completions = commands[cmd].comp
+    if (is(completions, 'func')) {
+      completions = completions(CLI, words.slice(1), aliases)
+    }
 
-    if (id === String(state.game.id)) {
-      CONFIG.id = null
-      state.game = null
-      state.trax = new Trax()
-      selectAnyGame()
+    completions = expand(completions, match)
+    if (words.length === 1 || (words.length === 2 && !line.endsWith(' '))) {
+      completions.push('help', '?')
     }
   } else {
-    error('Game #' + id + ' is still active. Use "force" to delete it.')
+    completions = aliases
   }
-}
 
-commands.undo.fn = (id, n) => {
-  if (Number(n) || (id && id.startsWith('#'))) {
-    // Id has been supplied
-    commands.select.fn(id)
-  } else {
-    n = id
+  for (let i = 0; i < completions.length; i++) {
+    const word = completions[i]
+    if (word.includes('|')) {
+      const comps = word.split('|')
+      if (comps.some((c) => previous.has(c.toLowerCase()))) {
+        completions[i] = ''
+      } else {
+        completions[i] = comps
+      }
+    }
   }
 
-  n = Math.max(1, Math.floor(Number(n) || 1)) // Get an integer 1 or higher
+  completions = completions
+    .flat()
+    .filter((c) => c && !previous.has(c.toLowerCase()))
 
-  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()
+  if (match && completions.length > 0) {
+    completions = completions.filter((c) => {
+      return c.toLowerCase().startsWith(match.toLowerCase())
+    })
   }
-}
 
-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)
-    }
-  }
-}
+  if (!match && completions.length === 1) completions.push(' ')
 
-const addAbbreviations = () => {
-  for (const key of Object.keys(commands)) {
-    addAbbrev(key, key)
-    if (commands[key].alt) addAbbrev(commands[key].alt, key)
-  }
+  completions = completions.map((c) => c + ' ').sort()
 
-  for (const [abbr, value] of Object.entries(abbreviations)) {
-    const newValue = [...value]
-    abbreviations[abbr] = value.size > 1 ? newValue.sort() : newValue[0]
-  }
+  return [completions, match]
 }
 
 const evaluate = async (command) => {
-  const [CMD, ...words] = command.split(/\s+/)
+  const [CMD, ...words] = command.split(/\s+/).filter((c) => c)
   const cmdLower = CMD.toLowerCase()
+  CLI.CMD = cmdLower
   const cmd = abbreviations[cmdLower]
   if (is(cmd, 'str')) {
     if (words.length > 0 && abbreviations[words[0].toLowerCase()] === 'help') {
-      commands.help.fn(cmd)
+      commands.help.fn(CLI, cmd)
     } else {
-      await commands[cmd].fn(...words)
+      await commands[cmd].fn(CLI, ...words)
     }
   } else if (is(cmd, 'arr')) {
-    error('Ambiguous command. Perhaps you meant one of the following:')
+    CLI.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 || '']
+      let alts = commands[alias].alt
+      alts = is(alts, 'arr') ? alts : [alts || '']
 
-      for (const alt of aliases) {
+      for (const alt of alts) {
         if (alt.startsWith(cmdLower)) maybe.add(alt)
       }
     }
 
     if (maybe.size > 0) {
       for (const alias of [...maybe].sort()) {
-        tty.outty(color('  ' + alias, COLORS.command))
+        tty.outty(CLI.color.command('  ' + alias))
       }
     }
   } 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)
+    let rxCmd
+    for (const regex of regexes) {
+      if (regex.rx.test(CMD)) rxCmd = regex.name
+    }
+
+    if (rxCmd) {
+      await commands[rxCmd].fn(CLI, CMD, ...words)
     } else {
-      error('Unknown command. Type "help" for a list of valid commands.')
+      CLI.error('Unknown command. Type "help" for a list of valid commands.')
     }
   }
 
@@ -955,11 +588,11 @@ const evaluate = async (command) => {
 }
 
 const main = async () => {
+  processPlugins()
   const command = parseCommandLine()
   if (is(command, 'str')) {
     await Promise.all([getConfig(), getData()])
-    load(CONFIG.id)
-    addAbbreviations()
+    CLI.load(CONFIG.id)
     if (command) await evaluate(command)
     if (startRepl || !command) {
       if (!command) {
@@ -967,25 +600,21 @@ const main = async () => {
         tty.outty(color('Type "help" for more information.'))
       }
 
-      state.repl = repl.start({
+      CLI.repl = repl.start({
         prompt: 'trax❯ ',
         async eval(cmd, ctx, fn, cb) {
           try {
             await evaluate(cmd)
           } catch (error) {
-            tty.outty(error, COLORS.fatal)
+            tty.outty(error, CLI.COLORS.fatal)
             throw error
           }
 
           cb(null, undefined)
         },
-        writer(value) {
-          if (value) {
-            return value
-          }
-
-          return ''
-        },
+        ignoreUndefined: true,
+        completer,
+        preview: true,
       })
     }
   }