@slugbugblue/trax 0.8.0 → 0.9.0

package/src/cmds/delete.js

@@ -0,0 +1,71 @@
+/* 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 delete command
+
+export const deleteCmd = {
+  name: 'delete',
+  alt: ['remove', 'rm'],
+  args: '[#id] ["force"]',
+  comp: '<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.',
+  ],
+}
+
+const selectAnyGame = (CLI) => {
+  if (CLI.GAMES) {
+    const games = Object.values(CLI.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) {
+      CLI.do('select', String(games[0].id))
+    }
+  }
+}
+
+deleteCmd.fn = (CLI, id, force = 'x') => {
+  const current = String(CLI.GAME.id)
+  if (!id) id = current
+  if ('force'.startsWith(id)) {
+    id = current
+    force = 'force'
+  }
+
+  if (id.startsWith('#')) id = id.slice(1)
+
+  const game = CLI.GAMES[id]
+
+  if (!game || !String(game.id)) {
+    return CLI.error('Invalid id. Type "list" to see available games.')
+  }
+
+  if (game.over || game.moves === '' || 'force'.startsWith(force)) {
+    CLI.delete(id)
+    CLI.out(CLI.color('Deleted game #' + id + '.'))
+
+    if (id === String(current)) {
+      selectAnyGame(CLI)
+    }
+  } else {
+    CLI.error('Game #' + id + ' is still active. Use "force" to delete it.')
+  }
+}

package/src/cmds/help.js

@@ -0,0 +1,81 @@
+/* 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 help command
+
+export const helpCmd = {
+  name: 'help',
+  opts: ['--help', '-h', '-?'],
+  alt: '?',
+  args: '[topic]',
+  comp: '<cmd>',
+  desc: 'display information on commands',
+  help: [
+    'Type "help <command>" or "<command> help" to see additional information',
+    'for a specific command.',
+  ],
+}
+
+// Find the length of the printable characters of the string
+const length = (text) => text.replace(/[<">]/g, '').length
+
+helpCmd.fn = (CLI, word) => {
+  // If we are looking for help on a particular commands, get that command
+  word = CLI.resolveCommand(word) || (word ? String(word).toLowerCase() : '')
+  let cmds = CLI.commands.filter((c) => !word || c.startsWith(word))
+  if (cmds.length === 0) {
+    cmds = CLI.commands.filter((c) => c.includes(word))
+  }
+
+  // If we don't have a few commands, select all commands
+  if (cmds.length === 0) cmds = CLI.commands
+
+  // Load all the commands we need to print into a local variable
+  // and also use the loop to get the length of the longest args
+  let max = 1
+  const commands = {}
+  for (const key of cmds) {
+    commands[key] = CLI.cmd(key)
+    max = Math.max(max, key.length + length(commands[key].args))
+  }
+
+  // Print a summary of all matching commands
+  for (const key of cmds.sort()) {
+    const topic = commands[key]
+    if (topic.hide && !CLI.repl) continue // Hidden commands only in repl
+    const space = ' '.repeat(5 + max - length(topic.args) - key.length)
+    CLI.out(
+      CLI.color.command(`  ${key} ${topic.args}`) +
+        CLI.color.short(space + topic.desc),
+    )
+  }
+
+  // And if we have just one command, print details on that command
+  if (cmds.length === 1) {
+    const topic = commands[cmds[0]]
+    for (const alias of topic.alt) {
+      CLI.out(CLI.color.command(`  ${alias}`))
+    }
+
+    CLI.out('')
+    if (CLI.is(topic.help, 'str')) {
+      CLI.out('    ' + CLI.color.help(topic.help))
+    } else {
+      for (const line of topic.help) {
+        CLI.out('    ' + CLI.color.help(line))
+      }
+    }
+  }
+}

package/src/cmds/import-export.js

@@ -0,0 +1,250 @@
+/* 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 import/export commands
+
+import fs from 'node:fs/promises'
+import process from 'node:process'
+
+import envPaths from 'env-paths'
+import makeDir from 'make-dir'
+
+import { Trax } from '../engine.js'
+
+const paths = envPaths('trax', { suffix: '' })
+const PATHS = {}
+
+// Store a copy of the CLI context object locally
+let cli = {}
+
+const fsOuch = (fsError) => {
+  cli.out(fsError, cli.COLORS.fatal)
+  throw fsError
+}
+
+const expandPath = (name) => {
+  // Expand home directory ... anything else?
+  if (name.includes('~')) name = name.replace('~', process.env.HOME)
+  return name
+}
+
+// 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
+}
+
+export 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) {
+        cli.error(`Unable to read ${filetype} file ${path}/${filename}`)
+      } else if (fsError.code !== 'ENOENT') {
+        fsOuch(fsError)
+      }
+    }
+  }
+
+  return variable
+}
+
+export 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)
+    }
+  })
+}
+
+export const importCmd = {
+  name: 'import',
+  alt: ['load', 'open'],
+  args: '<filename>',
+  comp: '<file>',
+  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.',
+  ],
+}
+
+export const exportCmd = {
+  name: 'export',
+  alt: ['save', 'keep', 'share'],
+  args: '[#id] [filename]',
+  comp: '<id> <file>',
+  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.',
+  ],
+}
+
+importCmd.fn = async (CLI, filename) => {
+  cli = CLI
+  if (!filename) {
+    CLI.error('Missing filename.')
+    return CLI.do('help', 'import')
+  }
+
+  let content
+  try {
+    content = await fs.readFile(expandPath(filename), 'utf8')
+  } catch (fsError) {
+    if (fsError.code === 'ENOENT' && !filename.endsWith('.trx')) {
+      try {
+        content = await fs.readFile(expandPath(filename + '.trx'), 'utf8')
+      } catch {
+        content = null
+      }
+    }
+
+    if (!content) CLI.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) {
+      CLI.do('new', game, ...players)
+      CLI.do('play', ...moves.filter((m) => m))
+    } else {
+      CLI.error(filename + ' does not appear to be formatted correctly.')
+    }
+  }
+}
+
+exportCmd.fn = (CLI, id, filename) => {
+  cli = CLI
+  let game = CLI.GAME
+  if (id) {
+    const newid = id.replace(/^#/, '')
+    game = CLI.GAMES[newid]
+    if (!game) {
+      filename = id
+      game = CLI.GAME
+    }
+  }
+
+  if (!game || !game.id) {
+    return CLI.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' + CLI.version + '\n'
+  content += trax.notation + '\n'
+  if (filename) filename = filename.replace(/[^ a-z\d.~/]/g, '')
+  if (filename) {
+    const fname = filename.split('/').pop()
+    if (!fname) filename += game.rules + game.id
+    if (!fname.includes('.')) filename += '.trx'
+    CLI.out(CLI.color('Exporting #' + game.id + ' to ') + filename)
+    fs.writeFile(expandPath(filename), content).catch(fsOuch)
+  } else {
+    CLI.out(content)
+  }
+}
+
+const FOLDERS = {}
+
+export const findFiles = (path) => {
+  if (typeof path !== 'string') path = ''
+  let folder = '.'
+  if (path.includes('/')) {
+    folder = path.slice(0, path.lastIndexOf('/'))
+  }
+
+  const prefix = folder + '/'
+
+  folder = expandPath(folder)
+
+  if (!FOLDERS[prefix]) {
+    FOLDERS[prefix] = []
+    fs.readdir(folder, { withFileTypes: true })
+      .then((dir) => {
+        // This is all happening asynchronously, so we have to call findFiles
+        // at least twice before we get any useful information ...
+        const entries = []
+        for (const entry of dir) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            entries.push(prefix + entry.name + '/')
+          } else if (entry.isFile() && entry.name.endsWith('.trx')) {
+            entries.push(prefix + entry.name)
+          }
+        }
+
+        FOLDERS[prefix] = entries
+      })
+      .catch(() => {})
+  }
+
+  return FOLDERS[prefix]
+}

package/src/cmds/list.js

@@ -0,0 +1,155 @@
+/* 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 list command
+
+import { Trax } from '../engine.js'
+
+export const listCmd = {
+  name: 'list',
+  alt: 'ls',
+  args: '[sort|filter...] ["reverse"]',
+  desc: 'list all games',
+  comp:
+    'id|number game|rules|name player1|p1 player2|p2 move|status turn' +
+    ' active|over trax|8x8|loop reverse',
+  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.',
+  ],
+}
+
+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
+}
+
+listCmd.fn = (CLI, ...filters) => {
+  if (Object.keys(CLI.GAMES).length === 0) {
+    return CLI.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(CLI.GAMES)) {
+    const moves = game.moves.length === 0 ? 0 : game.moves.split(' ').length
+    list.push({
+      sid: String(game.id).padStart(9, '0'),
+      id: (game.id === CLI.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) {
+    CLI.out(
+      CLI.color(game.id.padStart(size.id) + ' ') +
+        Trax.names[game.rules] +
+        ' '.repeat(size.name - game.name + 1) +
+        CLI.bubble(game.turn === 1 ? 'wh' : 'w', game.p1) +
+        CLI.color('vs '.padStart(size.p1 - game.p1.length + 4)) +
+        CLI.bubble(game.turn === 2 ? 'bh' : 'b', game.p2) +
+        CLI.color(' '.padStart(size.p2 - game.p2.length + 1)) +
+        CLI.color(game.over ? 'game over' : game.moves),
+    )
+  }
+}

package/src/cmds/new.js

@@ -0,0 +1,131 @@
+/* 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 new command
+
+export const newCmd = {
+  name: 'new',
+  alt: 'start',
+  args: '[variant] [[p1 name] "vs" [p2 name]]',
+  comp: 'trax|loop|8x8 vs',
+  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.',
+  ],
+}
+
+// Okay, yes, this is silly
+const pairs = [
+  ['Abbott', 'Costello'],
+  ['Adam', 'Eve'],
+  ['Anne Boleyn', 'Henry VIII'],
+  ['Ash', 'Pikachu'],
+  ['Barbie', 'Ken'],
+  ['Batman', 'Robin'],
+  ['Bert', 'Ernie'],
+  ['Bonnie', 'Clyde'],
+  ['Calvin', 'Hobbes'],
+  ['Chip', 'Dale'],
+  ['Donald', 'Daisy'],
+  ['Fred', 'Barney'],
+  ['Fred', 'George'],
+  ['Frodo', 'Sam'],
+  ['Han', 'Chewie'],
+  ['Harry', 'Ron'],
+  ['Holmes', 'Watson'],
+  ['Jekyll', 'Hyde'],
+  ['Jim', 'Pam'],
+  ['Joe', 'Volcano'],
+  ['John', 'Yoko'],
+  ['King Kong', 'Godzilla'],
+  ['Lewis', 'Clark'],
+  ['Lilo', 'Stitch'],
+  ['Luke', 'Leia'],
+  ['Marge', 'Homer'],
+  ['Mario', 'Luigi'],
+  ['Marlin', 'Dory'],
+  ['Mary-Kate', 'Ashley'],
+  ['Micky', 'Minnie'],
+  ['Miss Piggy', 'Kermit'],
+  ['Mork', 'Mindy'],
+  ['Obi-Wan', 'Anakin'],
+  ['Pan', 'Hook'],
+  ['Phineas', 'Ferb'],
+  ['Player 1', 'Player 2'],
+  ['p1', 'p2'],
+  ['R2-D2', 'C-3PO'],
+  ['Ren', 'Stimpy'],
+  ['Rick', 'Morty'],
+  ['Romeo', 'Juliet'],
+  ['Shaggy', 'Scooby'],
+  ['Shrek', 'Fiona'],
+  ['Simon', 'Garfunkel'],
+  ['Snoopy', 'Woodstock'],
+  ['Sonny', 'Cher'],
+  ['Spongebob', 'Patrick'],
+  ['Tarzan', 'Jane'],
+  ['Thelma', 'Louise'],
+  ['Thing 1', 'Thing 2'],
+  ['Tom', 'Huckleberry'],
+  ['Tom', 'Jerry'],
+  ['Tweety', 'Sylvester'],
+  ['Waldorf', 'Statler'],
+  ['Wallace', 'Gromit'],
+  ['white', 'black'],
+  ['Woody', 'Buzz'],
+]
+
+const pairUp = () => {
+  return pairs[Math.floor(Math.random() * pairs.length)]
+}
+
+newCmd.fn = (CLI, variant, ...names) => {
+  let rules = ''
+  if (variant) {
+    variant = variant.toLowerCase()
+
+    if (['8x8', '8', 'trax8x8', '8trax', '8x8trax'].includes(variant)) {
+      rules = 'trax8'
+    }
+
+    if (['loop', 'l', 'looptrax'].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 {
+        CLI.error('Unknown Trax variant.')
+        return CLI.do('help', 'new')
+      }
+    }
+  }
+
+  const players = pairUp()
+  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(' ') || 'white'
+      players[1] = names.slice(vs + 1).join(' ') || 'black'
+    }
+  }
+
+  const id = CLI.newGame(rules, players, '')
+  CLI.out(CLI.color('Started new game #' + id))
+}