terminal-ai-helper 1.3.1 → 1.3.3

package/LICENSE

@@ -19,3 +19,5 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+Other parts like zsh/bash/vite/... have their own license

package/VERSION

@@ -1 +1 @@
-1.3.1
+1.3.2

package/bin/npm-postinstall

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# npm's postinstall hook: a global install of the published package finishes
+# the job itself, so `npm i -g terminal-ai-helper` is the whole install — the
+# same steps, the same welcome, the same report as the other two doors.
+#
+# Two guards stand before the installer:
+#   * only a *global* install reaches it. npm hands every script the config as
+#     npm_config_* environment, so npm_config_global tells a `-g` install from
+#     a dev `npm i` in a checkout of this repo — which must never edit anyone's
+#     rc files. The node_modules check is the second answer, for a package
+#     manager that speaks the same layout but not the same variable.
+#   * TAI_SKIP_POSTINSTALL=1 skips it, for scripts and containers that want
+#     the files on disk only.
+set -u
+here="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/.." && pwd)"
+
+global=""
+case "${npm_config_global:-}" in
+  true | 1 | yes) global=1 ;;
+esac
+if [ -z "$global" ]; then
+  case "$here" in */node_modules/*) global=1 ;; esac
+fi
+[ -n "$global" ] || exit 0
+[ "${TAI_SKIP_POSTINSTALL:-0}" = "1" ] && exit 0
+
+if TAI_INSTALL_METHOD=npm bash "$here/install.sh"; then
+  exit 0
+fi
+status=$?
+# The package itself is on disk; an installer that could not finish (no
+# writable rc file, an odd HOME) must not fail the npm install over it — that
+# would roll the package back and leave nothing at all. The retry is the same
+# installer, named by its path in the package npm just unpacked.
+echo "tai: automatic setup did not finish (exit $status) — finish with: bash \"$here/install.sh\"" >&2
+exit 0

package/install.sh

@@ -1,13 +1,15 @@
 #!/usr/bin/env bash
 # tai installer — Linux, stdlib python only, <30 seconds.
 #
-# Two doors, one install: from a checkout (./install.sh), or the one line the
+# Three doors, one install: from a checkout (./install.sh), the one line the
 # readme leads with —
 #   curl -fsSL https://raw.githubusercontent.com/mlibre/Terminal-AI-Helper/main/install.sh | bash
 # — where curl's output reaches bash on stdin and the repository has to be
-# fetched before anything below can run. The piped door clones to ~/.tai
+# fetched before anything below can run, and npm's postinstall hook, which
+# runs this script from the package npm just unpacked (bin/npm-postinstall
+# guards it). The piped door clones to ~/.tai
 # (TAI_DIR moves it; TAI_REMOTE points it at a fork) and then executes the
-# cloned copy of this very script, so both doors run the same steps from a
+# cloned copy of this very script, so every door runs the same steps from a
 # real checkout and there is exactly one installer to read.
 set -euo pipefail
 
@@ -130,7 +132,7 @@ if add:
     kept.append("# asynchronously, so tai's own hints never reach the screen. Both work.\n")
     kept.append("# Removed by `tai uninstall`, and by TAI_KEEP_AUTOSUGGEST=1.\n")
     kept.append("add-zsh-hook -d precmd _zsh_autosuggest_start 2>/dev/null\n")
-tmp = path.with_name(path.name + ".tai-install")
+tmp = path.with_name(path.name + ".tai-new")
 tmp.write_text("".join(kept), encoding="utf-8", errors="surrogateescape")
 os.replace(tmp, path)
 PY
@@ -181,7 +183,7 @@ if not has_source:
 # Replaced atomically, the same rule the index builder follows. This file is the
 # user's shell: an interrupt between truncate and write would otherwise leave a
 # half-written .zshrc and a shell that cannot start.
-tmp = path.with_name(path.name + ".tai-install")
+tmp = path.with_name(path.name + ".tai-new")
 tmp.write_text("".join(cleaned), encoding="utf-8", errors="surrogateescape")
 os.replace(tmp, path)
 PY

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "terminal-ai-helper",
-  "version": "1.3.1",
-  "description": "The terminal that knows your next command \u2014 bash/zsh suggestions that learn from your own history. Offline, private, no account.",
+  "version": "1.3.3",
+  "description": "The terminal that knows your next command, Bash/Zsh suggestions that learn from your own history. Offline and private, with no account required",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,9 +17,6 @@
     "suggestions",
     "history"
   ],
-  "bin": {
-    "tai-install": "bin/tai-install"
-  },
   "files": [
     "bin",
     "tai",
@@ -33,9 +30,10 @@
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs",
+    "postinstall": "bash bin/npm-postinstall",
     "prepublishOnly": "find plugins -name '*.zwc' -delete && find . -name __pycache__ -type d -prune -exec rm -rf {} +"
   },
   "devDependencies": {
     "vitepress": "^1.6.3"
   }
-}
+}

package/plugins/zsh/menu.zsh

@@ -30,6 +30,13 @@ typeset -ga _TAI_MENU
 # _tai_menu_open for why the flag travels with the entry.
 typeset -ga _TAI_MENU_Q
 typeset -gi _TAI_MENU_IDX=0 _TAI_MENU_FROM=0 _TAI_MENU_TO=0 _TAI_MENU_LOOSE=0
+# 1 when the rows are whole learned lines that commit onto the word span as
+# whole lines (the first-word menu): _tai_menu_prefix refuses those, because a
+# shared head written into the line would then be written a second time by
+# _tai_menu_commit, which lays the whole entry over the span. Only a per-word
+# menu — every row one word, written over exactly the span the prefix now
+# fills — can take the extension.
+typeset -gi _TAI_MENU_WHOLE=0
 # How deep one first-word key is read, and how many learned whole lines the
 # first-word menu carries ahead of the installed names. Three per key is what
 # keeps a two-line `go mod …` pair beside each other — one per key is the
@@ -62,6 +69,7 @@ _tai_menu_close() {
   _TAI_MENU_IDX=0
   _TAI_MENU_ARMED=0
   _TAI_MENU_LOOSE=0
+  _TAI_MENU_WHOLE=0
   _TAI_MENU_STEM=""
 }
 
@@ -286,6 +294,7 @@ _tai_menu_open() {
   local -A isdir dup
   local word before c rest p real
   local -i len=${#BUFFER} i skip width term limit added=0 cap=0
+  _TAI_MENU_WHOLE=0
 
   # The width of the terminal, which the layout below is built to. Read once
   # here, because the command list is capped by it before the menu knows how
@@ -371,6 +380,7 @@ _tai_menu_open() {
     out+=( "${_TAI_MENU_LEARNED[@]}" )
     repeat ${#_TAI_MENU_LEARNED[@]}; do outq+=( 0 ); done
     learned_whole=1
+    _TAI_MENU_WHOLE=1
   fi
   # An installed command the history has never seen. Worth offering only once
   # the command name is complete, which is the same rule _tai_query keeps so
@@ -589,6 +599,7 @@ _tai_menu_open_loose() {
   _TAI_MENU_TO=${#BUFFER}
   _TAI_MENU_ARMED=0
   _TAI_MENU_LOOSE=1
+  _TAI_MENU_WHOLE=0
   _tai_menu_layout ""
   _TAI_MENU_ARMED=0
 }
@@ -666,6 +677,76 @@ _tai_menu_paint() {
   fi
 }
 
+# Write into the line what every entry already shares, before the list is drawn.
+#
+# The report: `cat .zs` answered with `.zsh/` and `.zshrc` — two candidates that
+# are the same word until the `h` — and the menu showed them under a line still
+# reading `.zs`. Every shell completes the part that is certain first, and
+# readline's was already doing it here (the bash listing test pins `tzz` becoming
+# `tzz_`); the menu made the user type the shared tail themselves, or take a whole
+# entry to get it. So the press that opens the list also advances the line to the
+# longest head every candidate starts with — `.zs` becomes `.zsh`, the list stands
+# under it, and the next press is the choosing press it always was.
+#
+# The head is computed over the forms that would be *written*, not the raw rows:
+# an entry a shell would split — `wombat book.txt` — is written quoted, and a
+# head cut from the quoted forms is the one string that is safe to leave in the
+# line when the user keeps typing instead of choosing. `womb` advances to
+# `wombat\ ` there, one shell word, every entry still extending it.
+#
+# Three refusals, each its own way of being wrong answered:
+#   * a word that is empty (the line ends in a space, or there is no line):
+#     nothing typed is nothing to extend, and the listing is the answer;
+#   * the loose list and the first-word menu, whose rows are whole lines laid
+#     over the whole span — a head written into the line would be written a
+#     second time by _tai_menu_commit, which replaces the span with the entire
+#     entry;
+#   * a head that does not reach past the word, or does not start with it: the
+#     first is no extension at all, and the second is a word the user did not
+#     type — `my doc` answered with the quoted `My\ Documents` head reads as
+#     two words where one was typed, so the list answers instead.
+#
+# The span moves with the text: _TAI_MENU_TO follows the head, the cursor lands
+# after it, and the layout runs again so the stem is cut against what the line
+# now shows and _TAI_MENU_LINE describes the line that is actually standing.
+# Committing an entry afterwards lays the whole entry over the span — the head
+# included — so nothing is written twice.
+_tai_menu_prefix() {
+  (( ${#_TAI_MENU} > 1 )) || return 1
+  (( _TAI_MENU_LOOSE || _TAI_MENU_WHOLE )) && return 1
+  local -i from=$_TAI_MENU_FROM to=$_TAI_MENU_TO k
+  # An empty word — the line ends in a space — has no span to extend.
+  (( from <= to )) || return 1
+  local -a forms
+  local c rest typed
+  forms=()
+  for (( k = 1; k <= ${#_TAI_MENU}; k++ )); do
+    c="${_TAI_MENU[k]}"
+    (( ${_TAI_MENU_Q[k]} )) && { _tai_quote "$c"; c="$_TAI_QUOTED" }
+    forms+=( "$c" )
+  done
+  # The longest head every written form starts with, found by shrinking the
+  # first form until the rest still begin with it — the same walk the stem
+  # makes over the raw rows.
+  rest="${forms[1]}"
+  for c in "${forms[@]}"; do
+    while [[ -n "$rest" && "$c" != "$rest"* ]]; do rest="${rest[1,-2]}"; done
+    [[ -n "$rest" ]] || break
+  done
+  [[ -n "$rest" ]] || return 1
+  typed="${BUFFER[from,to]}"
+  (( ${#rest} > ${#typed} )) || return 1
+  # Folded, like every lookup: `down` advances to `Downloads` when the disk
+  # says that is the word, and the case the candidates carry is the case the
+  # line takes — the same rule the commit below this one keeps.
+  [[ "${rest:l}" == "${typed:l}"* ]] || return 1
+  BUFFER="${BUFFER[1,$(( from - 1 ))]}$rest${BUFFER[$(( to + 1 )),-1]}"
+  CURSOR=${#BUFFER}
+  _TAI_MENU_TO=$(( from + ${#rest} - 1 ))
+  _tai_menu_layout "$rest"
+  return 0
+}
+
 # Put the selected entry where the word was, and close the menu. Nothing runs: the
 # line is now `cd Movies/` with the cursor after it, which is the point — a
 # completion is not a decision to execute.

package/plugins/zsh/widgets.zsh

@@ -272,7 +272,13 @@ tai-tab() {
 zle -N tai-tab
 
 # Tab opens the menu, and every Tab after that moves the selection one entry
-# along. The line is not touched: a menu is a way of looking, not of choosing.
+# along. The one thing the first press writes is the part every entry already
+# shares: `cat .zs` answered by `.zsh/` and `.zshrc` advances to `cat .zsh`
+# before the list draws, because two candidates that are the same word until
+# the `h` are a prefix the user should not have to type (see _tai_menu_prefix,
+# which refuses it where writing it would lie — an empty word, a whole-line
+# list, a head the typed word does not start with). After that the line stands:
+# a menu is a way of choosing, not of typing.
 #
 # When there is nothing to offer, the key goes back to zsh's own completion.
 # `docker` has nothing to complete *to*, because everything tai knows about it
@@ -319,6 +325,11 @@ tai-menu() {
     _tai_menu_commit
     return
   fi
+  # Several entries: the line takes what they all already say (the shared
+  # head — `.zsh` under `.zsh/` and `.zshrc`), and the list draws under it.
+  # _tai_menu_prefix refuses it where the line must not be written; the menu
+  # then behaves exactly as it did.
+  _tai_menu_prefix
   _tai_menu_paint
 }
 zle -N tai-menu

package/readme.md

@@ -21,13 +21,29 @@ answered by the habit it shadows](assets/demo.gif)
 
 [Docs](docs/architecture.md) · [Development](docs/development.md) · [Docs site](https://mlibre.github.io/Terminal-AI-Helper/) · [فارسی](readme-fa.md)
 
-## Install
+## Install Or Update
 
 ```sh
 curl -fsSL https://raw.githubusercontent.com/mlibre/Terminal-AI-Helper/main/install.sh | bash
+# Or using npm
+npm i -g terminal-ai-helper@latest
 ```
 
-npm installs the same files: `npm i -g terminal-ai-helper`, then `tai-install`.
+## Commands
+
+```sh
+tai update      # newest version — GitHub for a checkout, npm for an npm install (alias: tai upgrade)
+tai refresh     # import new history rows, then rebuild the indexes
+tai discover    # learn --help from installed tools (cached, ~5-35s)
+tai doctor      # what is indexed, and what is held back
+tai bench       # build time, latency, memory, each shell's index read time
+tai web         # a read-only localhost dashboard (alias: tai dashboard)
+tai eval        # candidate coverage against your own history
+tai version     # print the release this install is running
+tai purge       # drop unusable rows, then rebuild
+tai forget git sta   # drop every stored row for a command, exactly as typed
+tai uninstall   # remove everything tai added
+```
 
 The line downloads TAI to `~/.tai` and runs the installer from there; run it
 again later and it updates in place. It enables both shells, imports your
@@ -65,23 +81,24 @@ machine. New commands show up within seconds; no restart, ever.
 
 ## The keys
 
-| key                     | what it does                                                                                                   |
-| ----------------------- | -------------------------------------------------------------------------------------------------------------- |
-| `→`                     | take the hint at the end of the line, else move right                                                          |
-| `Ctrl-F`                | take the hint                                                                                                  |
-| `Alt-F` / `Ctrl-Right`  | take **one word** of the hint, leaving the rest to type (bash: `Ctrl-Right`)                                   |
-| `Tab`                   | cycle files, folders and options; on a bare first word the learned lines come first, ranked like the dashboard |
-| `Ctrl-Space` / `Ctrl-T` | open the list, hint or no hint; press again to move the selection                                              |
-| `Enter`                 | take the selected entry and stop; a second `Enter` runs the line                                               |
-| `Alt-G`                 | the command that followed the last one (bash)                                                                  |
+| key                     | what it does                                                                                                                                           |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `→`                     | take the hint at the end of the line, else move right                                                                                                  |
+| `Ctrl-F`                | take the hint                                                                                                                                          |
+| `Alt-F` / `Ctrl-Right`  | take **one word** of the hint, leaving the rest to type (bash: `Ctrl-Right`)                                                                           |
+| `Tab`                   | write what every candidate shares, then cycle files, folders and options; on a bare first word the learned lines come first, ranked like the dashboard |
+| `Ctrl-Space` / `Ctrl-T` | open the list, hint or no hint; press again to move the selection (zsh)                                                                                |
+| `Down`                  | peek at what usually follows — opens the list when the typed line shows no hint; history otherwise (zsh)                                               |
+| `Enter`                 | take the selected entry and stop; a second `Enter` runs the line                                                                                       |
+| `Alt-G`                 | the command that followed the last one (bash)                                                                                                          |
 
 A paste is not a query — pasted text never opens a list, and one typed
 character brings it back. `Enter` fills a selection in and stops; running it
 is always a second, deliberate `Enter`.
 
-**bash** ranks identically and takes the same keys, but readline cannot draw
-a list below the line: `Tab` completes directly — after `tai` by default,
-after every command with `TAI_COMPLETE_ALL=1`.
+**bash** ranks identically and takes the hint keys, but readline cannot draw
+a list below the line and has no menu key: `Tab` completes directly — after
+`tai` by default, after every command with `TAI_COMPLETE_ALL=1`.
 
 ## What it suggests, and what it will not
 
@@ -104,6 +121,9 @@ memory, an array hit in microseconds.
 - **A path is answered by the filesystem** — what is actually there, newest
   first. A `cd` is answered by directories that exist here, judged from where
   you stand, not offered two directories away.
+- **`systemctl` is answered by the machine's own unit list.**
+  `systemctl restart her` cycles `nginx.service` and friends — read once,
+  held in the shell.
 - **A typo is answered by what it is a typo of.** When nothing extends the
   line, the learned lines that hold every word you typed appear; the one-off
   typo ranks below the habit it shadows, in the index itself.
@@ -126,33 +146,13 @@ memory, an array hit in microseconds.
 tai web              # or: tai dashboard  →  http://127.0.0.1:8247/
 ```
 
-![the tai web dashboard — the try box answering `git `, the state of the
+![the tai web dashboard — the try box answering `git`, the state of the
 store, and the ranked panels](assets/web.png)
 
 One server, read-only: it binds `127.0.0.1`, answers GETs only, and writes
 nothing. Clicking a suggestion copies it; `--port N` moves it; `--no-browser`
 skips the auto-open.
 
-## Commands
-
-```sh
-tai refresh     # import new history rows, then rebuild the indexes
-tai discover    # learn --help from installed tools (cached, ~5-35s)
-tai doctor      # what is indexed, and what is held back
-tai bench       # build time, latency, memory, each shell's index read time
-tai web         # a read-only localhost dashboard (alias: tai dashboard)
-tai eval        # candidate coverage against your own history
-tai update      # newest version from GitHub, then reinstall (alias: tai upgrade)
-tai version     # print the release this install is running
-tai purge       # drop unusable rows, then rebuild
-tai forget git sta   # drop every stored row for a command, exactly as typed
-tai uninstall   # remove everything tai added
-```
-
-The plugins call `flush` themselves, and every command drains what is pending
-first — no answer lags a few records behind what you just did, and no restart
-is needed: the index is re-read at the next prompt.
-
 ## Configuration
 
 All have working defaults; they are for when yours is wrong.
@@ -191,7 +191,7 @@ release; it puts `tai` on `PATH` and prints the two `source` lines for your
 rc file.
 
 ```sh
-tai update      # newest version from GitHub, then reinstall; alias: tai upgrade
+tai update      # newest version — GitHub for a checkout, npm for an npm install; alias: tai upgrade
 ```
 
 It stops rather than overwrite a copy you have edited yourself.
@@ -201,8 +201,9 @@ tai uninstall
 ```
 
 Removes the shell integration, the wrapper, the indexes, the SQLite history
-and the cached knowledge. The `~/.tai` folder stays; restart the terminal
-afterwards.
+and the cached knowledge. The `~/.tai` folder stays — on an npm install,
+`npm rm -g terminal-ai-helper` removes the package itself. Restart the
+terminal afterwards.
 
 ## Why it stays fast
 

package/tai/cli.py

@@ -10,7 +10,8 @@ updating, and diagnostics.
     tai record "<cmd>" [--cwd X --git Y --branch B --exit 0]
     tai flush              ingest the records the plugins spooled, then maintain
     tai refresh [--quiet]
-    tai update | upgrade   pull the latest version from GitHub and reinstall
+    tai update | upgrade   pull the latest version and reinstall — from GitHub
+                           for a checkout install, from npm for an npm one
     tai version            print the release this install is running
     tai discover [tool ...]
     tai purge [--stale] [--rebuild/--no-rebuild]
@@ -149,14 +150,107 @@ def cmd_refresh(a) -> int:
     return 0
 
 
+def _install_method(repo: "Path") -> str:
+    """'npm', 'git', or 'none' — decided by where the running code lives.
+
+    The wrapper execs one cli.py, and that file's location is the copy an
+    update has to replace, so the method is a fact about the path, not about
+    the user's memory of how they installed: npm keeps every global package
+    under a node_modules directory, a checkout keeps its .git, and anything
+    else (the .deb, a hand-copied tree) is 'none' — nothing here can pull it
+    forward, and the answer says so instead of guessing.
+    """
+    if "node_modules" in repo.parts:
+        return "npm"
+    if (repo / ".git").exists():
+        return "git"
+    return "none"
+
+
+def _npm_configured() -> bool:
+    """True when npm's postinstall hook already ran the installer from the tree.
+
+    The hook runs install.sh inside the npm install itself, and rerunning it
+    from here would print the welcome twice and rebuild an index that is
+    current. The check is the installer's own two products — the wrapper
+    naming this tree and one rc line per shell sourcing it — asked of the text
+    npm's layout guarantees is unquoted through the middle: a prefix path with
+    a space in it comes out of printf %q escaped, but everything from
+    node_modules down survives intact.
+    """
+    from pathlib import Path
+
+    tail = "node_modules/terminal-ai-helper"
+    wrapper = (Path(os.environ.get("BIN_DIR") or Path.home() / ".local" / "bin")
+               / "tai")
+    try:
+        text = wrapper.read_text(encoding="utf-8", errors="surrogateescape")
+    except OSError:
+        return False
+    if f"{tail}/tai/cli.py" not in text:
+        return False
+    home = Path.home()
+    for rc, plugin in ((".zshrc", "tai.zsh"), (".bashrc", "tai.bash")):
+        try:
+            lines = (home / rc).read_text(
+                encoding="utf-8", errors="surrogateescape").splitlines()
+        except OSError:
+            return False
+        if not any("source" in line and f"{tail}/plugins/{plugin}" in line
+                   for line in lines):
+            return False
+    return True
+
+
+def _update_npm(repo: "Path") -> int:
+    """The npm door of `tai update`: let the registry replace the package.
+
+    npm's own output streams through — the install can take several seconds
+    and its progress is the only thing the user sees while it runs — and the
+    postinstall hook finishes the reinstall from the new tree unless scripts
+    were skipped (--ignore-scripts) or it failed, in which case the installer
+    runs here instead: idempotent, and the same report as every other door.
+    """
+    import shutil
+    import subprocess
+
+    npm = shutil.which("npm")
+    if not npm:
+        print("tai: npm is not installed, so there is nothing to update from")
+        print("     reinstall with: npm i -g terminal-ai-helper@latest")
+        return 1
+    before = _read_version()
+    pulled = subprocess.run([npm, "install", "-g", "terminal-ai-helper@latest"])
+    if pulled.returncode != 0:
+        print("tai: npm install failed — the previous version is still installed")
+        return 1
+    after = _read_version()
+    # Flushed before anything else prints: npm's own output above is the
+    # progress, and this line is the verdict.
+    print("✓ already up to date" if after == before else f"✓ updated to {after}",
+          flush=True)
+    if after == before or _npm_configured():
+        return 0
+    installer = repo / "install.sh"
+    if not installer.exists():
+        print(f"tai: {installer} is missing, so the new code was not installed")
+        return 1
+    # A subprocess, not a re-entrant call: the install just replaced the files
+    # this process was loaded from, so anything it calls now is the old code.
+    return subprocess.run(["bash", str(installer)]).returncode
+
+
 def cmd_update(a) -> int:
-    """Pull the latest version of the checkout and reinstall it.
+    """Pull the latest version and reinstall it, from wherever tai came from.
 
-    The user should never have to remember which folder the project lives in to
-    get a new version, so this is driven from where tai already is rather than
-    from a path they have to type.
+    The user should never have to remember which folder the project lives in —
+    or which package manager put it there — so this is driven from where tai
+    already is rather than from a path they have to type.
     """
     repo = _repo_dir()
+    if _install_method(repo) == "npm":
+        return _update_npm(repo)
+
     import shutil
     import subprocess
 

package/tai/typo.py

@@ -212,10 +212,18 @@ def shadow_map(eng, lines=None) -> dict[str, str]:
       * the two share their first word and are within two edits whole-line,
         which is the shape a mistyped word takes (`unsintall`/`uninstall` is
         two adjacent swaps, invisible to a one-edit rule);
+      * the comparison folds case — every lookup in the product folds case,
+        and the pair loop must agree, or `LS -la` stands beside `ls -la` as
+        its own row (the first words land in different groups) and a case
+        diff longer than two letters clears the edit cap. A capital twin is
+        a typo of the lowercase habit no less than a misspelling is; the
+        map's keys keep the store's own spelling either way;
       * the target is the *stronger* spelling: more successes, then more
         runs, then more recent — and when the evidence ties outright, the
-        lexically smallest of the near-duplicates stands, which is the one
-        honest way to break a tie the store carries no other evidence for;
+        spelling that is all-lowercase stands (commands are lowercase; the
+        capitalised twin is the accident), byte order otherwise, which is
+        the one honest way to break a tie the store carries no other
+        evidence for;
       * the population both sides come from is `lines`: the index passes the
         lines the user actually ran (a corpus convention is not a typo and
         not a habit one shadows), the engine passes the candidates it is
@@ -229,6 +237,9 @@ def shadow_map(eng, lines=None) -> dict[str, str]:
     """
     names = list(eng.cmds) if lines is None else \
         [c for c in lines if c in eng.cmds]
+    # The comparison runs on lowered copies — see the case bullet above —
+    # while every key this map returns is the store's own spelling.
+    low = {c: c.lower() for c in names}
     # Per-line letter sets and counts: the two cheap gates before the edit
     # distance. Two lines within two edits can differ by at most two distinct
     # letters per side (the set gate) and by at most two in character surplus
@@ -238,20 +249,23 @@ def shadow_map(eng, lines=None) -> dict[str, str]:
     # is a pair the distance would reject too. The counts also answer the
     # deficit for free — surplus minus the length difference is deficit, by
     # conservation of characters — so one walk per pair gates both sides.
-    sets = {c: set(c) for c in names}
+    sets = {c: set(low[c]) for c in names}
     counts = {c: {} for c in names}
     for c, bag in counts.items():
-        for ch in c:
+        for ch in low[c]:
             bag[ch] = bag.get(ch, 0) + 1
     groups: dict[str, dict[int, list[str]]] = {}
     for c in names:
-        groups.setdefault(c.split(" ", 1)[0], {}).setdefault(len(c), []).append(c)
+        groups.setdefault(low[c].split(" ", 1)[0], {}).setdefault(len(c), []).append(c)
+    # The full-tie spelling to stand: all-lowercase first (commands are
+    # lowercase; the capitalised twin is the accident), byte order otherwise.
+    tkey = {c: (0, c) if low[c] == c else (1, c) for c in names}
     out: dict[str, str] = {}
     for cmd in names:
         st = eng.cmds[cmd]
         if st.freq > TYPO_FREQ_MAX:
             continue
-        buckets = groups.get(cmd.split(" ", 1)[0])
+        buckets = groups.get(low[cmd].split(" ", 1)[0])
         if not buckets:
             continue
         s_set = sets[cmd]
@@ -281,14 +295,14 @@ def shadow_map(eng, lines=None) -> dict[str, str]:
                 ost = eng.cmds[other]
                 oev = (ost.success, ost.freq, ost.last_ts)
                 # The target must be the stronger spelling — or, on a full
-                # tie, the smaller one. Anything weaker is somebody else's
-                # shadow, not this line's habit.
-                if oev < ev or (oev == ev and other > cmd):
+                # tie, the likelier spelling (the tie bullet above). Anything
+                # weaker is somebody else's shadow, not this line's habit.
+                if oev < ev or (oev == ev and tkey[other] > tkey[cmd]):
                     continue
-                if lev1(cmd, other, 2) > 2:
+                if lev1(low[cmd], low[other], 2) > 2:
                     continue
                 if best is None or oev > best[0] or \
-                        (oev == best[0] and other < best[1]):
+                        (oev == best[0] and tkey[other] < tkey[best[1]]):
                     best = (oev, other)
         if best is not None:
             out[cmd] = best[1]

package/bin/tai-install

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-# npm's bin shim is a symlink into the package directory, and install.sh reads
-# its own location to decide what to install from — so resolve the symlink
-# chain to the real file first, then hand over to the installer at the
-# package root, one level above bin/.
-set -e
-src="${BASH_SOURCE[0]:-$0}"
-while [ -L "$src" ]; do
-  dir="$(cd "$(dirname "$src")" && pwd)"
-  src="$(readlink "$src")"
-  [ "${src:0:1}" = "/" ] || src="$dir/$src"
-done
-exec bash "$(cd "$(dirname "$src")/.." && pwd)/install.sh" "$@"