@slugbugblue/trax 0.20.0 → 0.21.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @slugbugblue/trax
 
+## 0.21.0 -2023-03-12
+
+- Update the analysis engine to be more lazy
+
+  - Call `validateThreats()` to make it work harder
+  - This also increases LRU cache hits
+  - This makes the suggestions much faster because it skips validations for
+    low-scoring moves
+
 ## 0.20.0 - 2023-02-11
 
 - Provide timing feedback on the puzzlebot's actions

package/README.md

@@ -23,15 +23,26 @@ changes to the engine should meet the same standard.
 
 ## Installation
 
+Installation can be done in one of three ways, each for a slightly different
+purpose.
+
+If you want to use this code in your own javascript project:
+
 ```bash
-# Install into a javascript project
 npm install @slugbugblue/trax
+```
+
+If you want to use the trax CLI on your computer:
 
-# Or install globally to use the trax CLI more easily
+```bash
 npm install -g @slugbugblue/trax
+```
+
+If you don't have node installed and want to use the CLI as a docker container:
 
-# Or create a docker image
-docker build -t trax .
+```bash
+git clone https://gitlab.com/slugbugblue/trax.git ~/trax
+docker build -t trax ~/trax
 ```
 
 ## CLI Usage
@@ -75,7 +86,7 @@ entered `play 1. @0/`.
 Multiple games can be started at once, and the CLI will remember the currently
 active game and apply future actions to that game. Each game will retain its
 `#id` number until it is deleted, and you can use that number to switch between
-games. For example, to make game #1 active, enter `select 1` or `select #1` or
+games. For example, to make game \#1 active, enter `select 1` or `select #1` or
 simply `#1` at the interactive prompt.
 
 For ease of working at the command line, the symbols used as the last character
@@ -84,11 +95,7 @@ symbol (`/`), `b` for backslash (`\`), and `p` for plus (`+`). While there is no
 need to escape at the interactive prompt, these substitutions will be avilable
 there as well.
 
-The CLI uses standard Windows and Linux [XDG][xdg] file locations as provided by
-the [env-paths library][env-path], with current uses being the `config` and
-`data` folders.
-
-Examples:
+### Examples
 
 ```text
 # Start a new Trax game with Chad playing as white
@@ -115,6 +122,18 @@ Examples:
 > trax ls
 ```
 
+### Environment variables
+
+The CLI uses standard Windows and Linux [XDG][xdg] file locations as provided by
+the [env-paths library][env-path], with current uses being user-specific
+`config` (`XDG_CONFIG_HOME`) and `data` (`XDG_DATA_HOME`) folders.
+
+In addition, the CLI recognizes several environment variables to determine the
+glyphs to use in the user interface. Setting either `NERDFONT` or `NERDFONTS` to
+any non-empty string will use characters from [Nerdfonts][nerfont]. Otherwise,
+any of `POWERLINE`, `P9K_TTY`, or `P9K_SSH` will use characters from [Powerline
+fonts][powerline].
+
 ## API Usage
 
 ### Trax engine
@@ -243,6 +262,8 @@ David Smith and heirs, and are not to be used without permission.
 [env-path]: https://www.npmjs.com/package/env-paths
 [gnutrax]: https://gnutrax.com
 [goldtoken]: https://goldtoken.com/
+[nerdfont]: https://nerdfonts.com/
+[powerline]: https://github.com/powerline/fonts
 [puzzlebook]: https://gnutrax.com/book
 [repo]: https://gitlab.com/slugbugblue/trax
 [sbb]: https://slugbugblue.com/

package/docs/analyst.md

@@ -104,10 +104,12 @@ so that it appears as though all black tiles are white tiles.
 Analyzes the existing threats for the current game position. Returns an object
 with both `b` and `w` keys, where each is an object with zero or more "depth"
 keys. Threats of depth 0 are corners or connectable-pairs. Threats of depth 1
-are immediate attacks. Threats of depth 2 are Ls. etc. Note that the threats are
-not checked for faultiness at this time. In other words, there may be a faulty L
-listed as a threat even if it is not currently possible to activate the L
-successfully.
+are immediate attacks. Threats of depth 2 are Ls. etc.
+
+Note that the threats are not checked for faultiness at this time. In other
+words, there may be a faulty L listed as a threat even if it is not currently
+possible to activate the L successfully. To ensure that the listed threats are
+valid, use the `validateThreats()` method call.
 
 The "depth" keys are arrays of the threats at that level, which means that a
 simple count of the threats at each level can give a good first guess at the
@@ -125,7 +127,8 @@ following keys:
 ##### `faulty`
 
 An object with two keys, `w` and `b`, each of which is a list of threats that
-were found to be fauly.
+were found to be faulty. This object will be empty if `validateThreats()` has
+not yet been called.
 
 Example data:
 
@@ -175,6 +178,12 @@ For any given location, determine the type of playable space. Returns one of:
 - `C`: This location is in a cave, and certain plays at this position result in
   illegal moves.
 
+##### `validateThreats()`
+
+Ensure that all of the threats that are present for each color are actually
+valid. If it finds any faulty threats, it will update the `score` and populate
+the `faulty` property with each threat that was found to be invalid.
+
 ### Suggestion class
 
 Accessible from `suggest(game)`, this class is returned with several useful

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slugbugblue/trax",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Trax game engine and friends",
   "keywords": [
     "trax",

package/src/analyst.js

@@ -12,7 +12,9 @@ import { threats } from '@slugbugblue/trax/threats'
 
 const cache = new LRU(2750)
 
-/** Helper function to generate a unique id for the analysis. */
+/** Helper function to generate a unique id for the analysis.
+ * @returns {string} a 6 character random string
+ */
 const id = () => {
   const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
   let code = ''
@@ -46,19 +48,35 @@ const withinX = (highest, tolerance) => (s) =>
  */
 const randomDraw = (array) => array[Math.floor(Math.random() * array.length)]
 
-// Make parseInt a little shorter
+/** Make parseInt a little shorter with decent defaults.
+ * @arg s {string} - A string representation of a decimal number
+ * @returns {number} the parsed number
+ */
 const int = (s) => Number.parseInt(s, 10)
 
+/** The direction after a left turn. */
 const leftTurn = { d: 'r', l: 'd', r: 'u', u: 'l' }
+/** The direction after a right turn. */
 const rightTurn = { d: 'l', l: 'u', r: 'd', u: 'r' }
+/** Which way to follow. */
 const follow = { d: 'right', l: 'bottom', r: 'top', u: 'left' }
 
+/** Given a tile and a direction, return the color of the line going that
+ * direction.
+ * @arg tile {TileType} - the tile in question
+ * @arg dir {string} - direction u, d, l, or r
+ * @returns {Color}
+ */
 const edgeColor = (tile, dir) => {
   return { d: 'ace', l: 'abd', r: 'bcf', u: 'def' }[dir].includes(tile)
     ? 'w'
     : 'b'
 }
 
+/** Encode a number as a character.
+ * @arg n {number} - the number to encode
+ * @returns {string} the encoded number
+ */
 const encodeNumber = (n) => String.fromCodePoint(48 + n)
 
 /** Explore a raw edge and update cave information.
@@ -267,7 +285,7 @@ const passiveAttack = (from) => passiveCount(from) > 1
  */
 const underThreat = (from) => attackCount(from) + passiveCount(from) > 0
 
-// Analysis class
+/** Trax position analysis. */
 export class Analysis {
   /** @type {TraxVariant} */
   #rules = 'trax'
@@ -275,15 +293,18 @@ export class Analysis {
   /** @type {string[]} - List of moves to arrive at this position */
   #moves = []
   #notation = ''
+  /** @type EdgeObject */
   #edge = undefined
   /** @type {Trax} */
   #game
-  #scores = {}
+  /** @type Scores */
+  #scores = undefined
+  /** @type FoundThreatsCollection */
   #threats = undefined
-  #faulty = { b: [], w: [] }
-  #partial = false
+  #validated = false
 
-  constructor(game, partial = false) {
+  /** @arg game {Trax} - an in-progress trax game */
+  constructor(game) {
     // Make a copy of the game
     this.#rules = game.rules
     this.#moves = game.moves
@@ -294,15 +315,18 @@ export class Analysis {
       w: (level) => this.threats.w[level]?.length || 0,
       b: (level) => this.threats.b[level]?.length || 0,
     }
-    this.#partial = Boolean(partial)
+    /** @type FaultyThreats */
+    this.faulty = { b: [], w: [] }
+    this.#validated = false
     if (this.#moves.length === 0 || game.over) {
-      this.#edge = { b: '', w: '', rawEdge: [] }
+      /** @type EdgeObject */
+      this.#edge = { b: '', w: '', edge: [] }
       this.#threats = { b: {}, w: {} }
     }
   }
 
+  /** A fresh copy of the game as presented on init. */
   get game() {
-    // Return a fresh copy of the game as presented on init
     if (this.#game.notation !== this.#notation) {
       this.#game = new Trax(this.#rules, this.#moves, this.#id)
     }
@@ -310,6 +334,7 @@ export class Analysis {
     return this.#game
   }
 
+  /** The edge of the playing area. */
   get edge() {
     if (!this.#edge) {
       // Cache the edge
@@ -319,20 +344,12 @@ export class Analysis {
     return this.#edge
   }
 
-  /** Any faulty threats
-   * @returns {FaultyThreats}
-   */
-  get faulty() {
-    return this.#faulty
-  }
-
   /** All threats present in this position.
    * @returns {FoundThreatsCollection}
    */
   get threats() {
     if (!this.#threats) {
       this.#threats = { b: this.#applyThreats('b'), w: this.#applyThreats('w') }
-      if (!this.#partial) this.#validateThreats()
     }
 
     return this.#threats
@@ -425,45 +442,56 @@ export class Analysis {
     return [score, multiplier]
   }
 
+  /** Calculate the score for a player.
+   * @arg {Color} color - Color of the player
+   * @returns number
+   */
   #score(color) {
-    if (this.#scores[color] === undefined) {
-      const { game } = this
-      if (game.over) {
-        this.#scores[game.color] = Number.POSITIVE_INFINITY
-        this.#scores[Trax.other(game.color)] = Number.NEGATIVE_INFINITY
-        return this.#scores[color]
-      }
+    const { game } = this
+    if (game.over) {
+      return game.color === color
+        ? Number.POSITIVE_INFINITY
+        : game.color === color
+        ? Number.NEGATIVE_INFINITY
+        : -100_000
+    }
 
-      const [currentPlayer, threatLevel] = this.#activeScore()
-      const [nextPlayer, multiplier] = this.#inactiveScore(color, threatLevel)
+    const [currentPlayer, threatLevel] = this.#activeScore()
+    const [nextPlayer, multiplier] = this.#inactiveScore(color, threatLevel)
 
-      let score = Math.floor(currentPlayer * multiplier) - nextPlayer
-      if (score && game.color !== color) score *= -1
+    let score = Math.floor(currentPlayer * multiplier) - nextPlayer
+    if (score && game.color !== color) score *= -1
 
-      this.#scores[color] = score
-    }
-
-    return this.#scores[color]
+    return score
   }
 
+  /** Get the scores for each player. */
   get scores() {
-    return {
-      w: this.#score('w'),
-      b: this.#score('b'),
+    if (this.#scores === undefined) {
+      this.#scores = {
+        w: this.#score('w'),
+        b: this.#score('b'),
+      }
     }
+
+    return this.#scores
   }
 
+  /** Get the score for the active player. */
   get score() {
     return this.scores[this.game.color]
   }
 
-  // Space type
-  //
-  // determine which type of space we have:
-  // c = in a cave but has no restrictions (converted to n in edge)
-  // C = a cave where some moves are not allowed (converted to c in edge)
-  // n = normal space
-  // x = no tile can be played here
+  /** Determine which type of space we have:
+   *
+   * determine which type of space we have:
+   * c = in a cave but has no restrictions (converted to n in edge)
+   * C = a cave where some moves are not allowed (converted to c in edge)
+   * n = normal space
+   * x = no tile can be played here
+   * @arg {Point} loc - The location of the space
+   * @returns string
+   */
   spaceType(loc) {
     const { game } = this
 
@@ -498,7 +526,7 @@ export class Analysis {
     return 'c'
   }
 
-  // Trace the edge of the playing area
+  /** Trace the edge of the playing area. */
   #traceEdge() {
     const { game } = this
     /** @type {RawEdge} */
@@ -632,10 +660,12 @@ export class Analysis {
   }
 
   /** Clean up the list of matches, removing any false positives. */
-  #validateThreats() {
+  validateThreats() {
+    if (this.#validated) return
+    let someFaulty = false
     for (const bw of ['w', 'b']) {
       /** @type ColorThreats */
-      const matches = this.#threats[bw]
+      const matches = this.threats[bw]
       for (const key of Object.keys(matches)) {
         const level = Number(key)
         if (level < 2) continue
@@ -646,7 +676,8 @@ export class Analysis {
           if (this.#canActivateThreat(threat, bw, level)) {
             verified.push(threat)
           } else {
-            this.#faulty[bw].push(threat)
+            this.faulty[bw].push(threat)
+            someFaulty = true
           }
         }
 
@@ -657,6 +688,9 @@ export class Analysis {
         }
       }
     }
+
+    if (someFaulty) this.#scores = undefined
+    this.#validated = true
   }
 
   /** Determine if the given threat can be activated for this color
@@ -666,11 +700,11 @@ export class Analysis {
    * @returns {boolean}
    */
   #canActivateThreat(threat, color, level) {
-    const attacks = attackCount(this.#threats[color])
+    const attacks = attackCount(this.threats[color])
     const player = Trax.playerNumber(color)
     const other = Trax.other(color)
-    const otherAttacks = attackCount(this.#threats[other])
-    const higher = threatCount(this.#threats[color], level - 1)
+    const otherAttacks = attackCount(this.threats[other])
+    const higher = threatCount(this.threats[color], level - 1)
     for (const loc of this.threatLocs(threat, color)) {
       for (const type of this.game.possibleTiles(loc)) {
         const game = new Trax(this.game.rules, this.game.moves)
@@ -684,7 +718,7 @@ export class Analysis {
         // Otherwise, we cannot evaluate an ended game
         if (game.over) continue
 
-        const { threats } = analyze(game, true)
+        const { threats } = analyze(game)
 
         // If we give our opponent an attack, this is a faulty move
         const faulty = attackCount(threats[other]) - otherAttacks
@@ -724,12 +758,12 @@ export class Analysis {
       custom += tbd
     }
 
+    const score = this.#scores ? this.score : null
     custom += ',\n  threats: '
     custom += this.#threats ? sub(this.#threats) : tbd
     custom += ',\n  scores: '
-    custom += 'w' in this.#scores ? sub(this.#scores) : tbd
+    custom += this.#scores ? sub(this.#scores) : tbd
     custom += ',\n  score: '
-    const score = 'w' in this.#scores ? this.score : null
     custom += score === null ? tbd : style(score, 'number')
 
     return custom + '\n}'
@@ -738,14 +772,13 @@ export class Analysis {
 
 /** Analyze a game position.
  * @arg {Trax} game - the position to analyze
- * @arg {boolean} partial - if the position should only be partially analyzed
  * @returns {Analysis}
  */
-export const analyze = (game, partial = false) => {
-  const id = (partial ? 'y' : 'n') + game.rules + game.normalized
+export const analyze = (game) => {
+  const id = game.rules + game.normalized
   const cached = cache.get(id)
   if (cached) return cached
-  const analysis = new Analysis(game, partial)
+  const analysis = new Analysis(game)
   cache.set(id, analysis)
   return analysis
 }
@@ -759,9 +792,23 @@ export class Suggestion {
   pick
   ms = 0
 
-  constructor(analyzed, ms) {
+  constructor(color, analyzed, ms) {
     this.all = analyzed.sort(byScoreDesc)
-    const best = analyzed[0] || { move: '', score: 0 }
+    let best = analyzed[0] || { move: '', score: 0 }
+    let score = Number.NEGATIVE_INFINITY
+
+    while (score !== best.score) {
+      score = best.score
+      const options = analyzed.filter(withinX(best.score, 5))
+      for (const option of options) {
+        option.analysis.validateThreats()
+        option.score = option.analysis.scores[color]
+      }
+
+      analyzed.sort(byScoreDesc)
+      best = analyzed[0] || { move: '', score: 0 }
+    }
+
     this.options = analyzed.filter(withinX(best.score, 5))
     this.pick = randomDraw(this.options) || best
     this.ms = ms
@@ -789,7 +836,7 @@ export class Suggestion {
   }
 }
 
-export const suggest = (game, partial = false) => {
+export const suggest = (game) => {
   const start = Date.now()
   const analyzed = {}
   const { color, moves, rules } = game
@@ -798,10 +845,14 @@ export const suggest = (game, partial = false) => {
     trax.play(move)
     const unique = trax.normalized
     if (!analyzed[unique]) {
-      const analysis = analyze(trax, partial)
-      analyzed[unique] = { move, score: analysis.scores[color], analysis }
+      const analysis = analyze(trax)
+      analyzed[unique] = {
+        move,
+        analysis,
+        score: analysis.scores[color],
+      }
     }
   }
 
-  return new Suggestion(Object.values(analyzed), Date.now() - start)
+  return new Suggestion(color, Object.values(analyzed), Date.now() - start)
 }

package/src/cmds/puzzles.js

@@ -17,11 +17,14 @@ for (const puzzle of puzzles) {
 const validLevels = levels.slice(0, maxLevel + 1)
 const completions = [...validLevels, ...puzzleIds].join('|')
 
+const listAliases = ['display', 'list', 'ls', 'show', 'view']
+const startAliases = ['new', 'start']
+
 export const puzzlesCmd = {
   name: 'puzzles',
   args: '["list"|"start"] [level|puzzle]',
-  comp: 'list|ls|new|show|start|view ' + completions,
-  desc: 'play puzzles',
+  comp: 'display|list|ls|new|show|start|view ' + completions,
+  desc: 'view and play puzzles',
   help: [
     'Practice your skills with puzzles. Use "list" to see the puzzle',
     'categories, or "start" to play a puzzle.',
@@ -33,7 +36,7 @@ const an = (word = '') => {
   return a + ' ' + word
 }
 
-const showPuzzle = (CLI, id) => {
+const showPuzzle = (CLI, id, started = false) => {
   let puzzle = puzzles.find((p) => p.id === id)
   if (!puzzle) {
     const possibles = puzzles.filter((p) => p.id.includes(id))
@@ -67,6 +70,14 @@ const showPuzzle = (CLI, id) => {
   }
 
   CLI.out(out)
+
+  if (started) return
+
+  CLI.out(
+    CLI.color.short(
+      `Want to try this puzzle? Enter: "puzzles start ${puzzle.id}"`,
+    ),
+  )
 }
 
 const listPuzzles = (CLI) => {
@@ -126,7 +137,7 @@ const listLevel = (CLI, levelName) => {
 const startPuzzle = (CLI, puzzle) => {
   const id = CLI.newPuzzle(puzzle)
   CLI.out(CLI.color(`Started puzzle ${puzzle.id} as game #${id}`))
-  showPuzzle(CLI, puzzle.id)
+  showPuzzle(CLI, puzzle.id, true)
 }
 
 const startNextPuzzle = (CLI, level) => {
@@ -143,7 +154,7 @@ const startNextPuzzle = (CLI, level) => {
 
 puzzlesCmd.fn = (CLI, action, id) => {
   action = action?.toLowerCase() ?? 'list'
-  if ('start'.startsWith(action) || 'new'.startsWith(action)) {
+  if (startAliases.some((alias) => alias.startsWith(action))) {
     if (!id) return startNextPuzzle(CLI)
 
     const puzzle = puzzles.find((p) => p.id === id)
@@ -166,7 +177,7 @@ puzzlesCmd.fn = (CLI, action, id) => {
   if (action) {
     const x = id || action
     if (validLevels.includes(x)) return listLevel(CLI, x)
-    if ('list'.startsWith(x) || 'ls'.startsWith(x)) {
+    if (listAliases.some((alias) => alias.startsWith(x))) {
       return listPuzzles(CLI)
     }
 

package/src/cmds/view.js

@@ -27,11 +27,15 @@ export const viewCmd = {
   ],
 }
 
-viewCmd.fn = (CLI, move) => {
+viewCmd.fn = (CLI, move, ...extra) => {
   if (!CLI.GAME?.id) {
     return CLI.error('No active game. Type "new" to start a game.')
   }
 
+  if (move?.length > 1 && 'puzzles'.startsWith(move)) {
+    return CLI.do('puzzles', 'list', ...extra)
+  }
+
   const trax = CLI.TRAX
 
   let show = Number.POSITIVE_INFINITY

package/src/puzzles.js

@@ -30,6 +30,12 @@ export const sources = {
     license: 'CC BY 4.0',
     licenseUrl: 'https://creativecommons.org/licenses/by/4.0/',
   },
+  book2: {
+    name: 'Martin M. S. Pedersen',
+    copyright: '2023',
+    license: 'CC BY 4.0',
+    licenseUrl: 'https://creativecommons.org/licenses/by/4.0/',
+  },
 }
 
 /** @type {Puzzle[]} */
@@ -1200,6 +1206,29 @@ export const puzzles = [
     max: 16,
     hint: 'D1+',
   },
+  {
+    id: 'book2.132',
+    src: 'book2',
+    game: 'traxloop',
+    notation: '@0+ B1+ C1/ @1\\ D2\\ E2+ D3\\ D4\\',
+    icon: 'aeec:2fb:2ac:2fd',
+    level: 4,
+    player: 1,
+    max: 15,
+    hint: 'C3\\',
+  },
+  {
+    id: 'book2.148',
+    src: 'book2',
+    game: 'traxloop',
+    notation:
+      '@0/ B1\\ A2/ A0/ C1\\ @2/ @2+ A0\\ @2/ @2/ @2/ B4+ A5+ A1+ E0+ E0/ E0/',
+    icon: '3ca:3df:0cdcba:efafaf:dcdcdcaf:afaecdf:fbd1c:b',
+    level: 4,
+    player: 2,
+    max: 24,
+    hint: 'B2\\',
+  },
 ]
 
 puzzles.sort(

package/src/types.d.ts

@@ -76,6 +76,12 @@ type ColorThreats = Record<string, FoundThreat[]>
 /** All the threats found for both the white and black player. */
 type FoundThreatsCollection = { b: ColorThreats; w: ColorThreats }
 
+/** Scores for each player. */
+type Scores = {
+  b: number
+  w: number
+}
+
 /** A note with a move number */
 type GameNote = {
   move: number

package/src/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '0.20.0'
+export const version = '0.21.0'

package/.gitlab-ci.yml

@@ -1,90 +0,0 @@
-include:
-  - template: Security/SAST.gitlab-ci.yml
-  - template: Security/Secret-Detection.gitlab-ci.yml
-
-stages:
-  - test
-  - sast
-  - benchmark
-  - release
-
-sast:
-  stage: sast
-
-nodejs-scan-sast:
-  allow_failure: false
-  rules:
-  - if: "$SAST_DISABLED"
-    when: never
-  - if: "$SAST_EXCLUDED_ANALYZERS =~ /nodejs-scan/"
-    when: never
-  - if: "$CI_COMMIT_BRANCH == 'main'"
-    exists:
-    - "**/package.json"
-
-semgrep-sast:
-  allow_failure: false
-  rules:
-  - if: "$SAST_DISABLED"
-    when: never
-  - if: "$SAST_EXCLUDED_ANALYZERS =~ /semgrep/"
-    when: never
-  - if: "$CI_COMMIT_BRANCH == 'main'"
-    exists:
-    - "**/*.js"
-
-secret_detection:
-  allow_failure: false
-
-code-coverage:
-  stage: test
-  image: node:lts-alpine
-  cache:
-    key: lts
-    paths:
-      - node_modules/
-  script:
-    - node --version
-    - npm install
-    - npm test
-  coverage: /^All files\s*\|\s*([\d.]+)/
-
-node16:
-  stage: test
-  image: node:16.15.0-alpine
-  cache:
-    key: node16
-    paths:
-      - node_modules/
-  script:
-    - node --version
-    - npm install
-    - npm test
-
-benchmark:
-  stage: benchmark
-  image: node:lts-alpine
-  cache:
-    key: lts
-    paths:
-      - node_modules/
-  rules:
-    - if: $CI_COMMIT_TAG =~ /^v\d\+\.\d+\.\d+$/
-  script:
-    - npm run benchmark
-    - awk '/^## /{p++}p==1;p==2{exit}' CHANGELOG.md > RELEASE.$CI_COMMIT_TAG.md
-  artifacts:
-    paths:
-      - RELEASE.$CI_COMMIT_TAG.md
-    expire_in: 1 day
-
-release:
-  stage: release
-  image: registry.gitlab.com/gitlab-org/release-cli:latest
-  rules:
-    - if: $CI_COMMIT_TAG =~ /^v\d\+\.\d+\.\d+$/
-  script:
-    - echo "Releasing $CI_COMMIT_TAG"
-  release:
-    tag_name: $CI_COMMIT_TAG
-    description: ./RELEASE.$CI_COMMIT_TAG.md

package/.husky/pre-commit

@@ -1,5 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npm outdated
-npm test