terminal-ai-helper 2.0.0 → 2.1.0

package/VERSION

@@ -1 +1 @@
-2.0.0
+2.1.0

package/install.sh

@@ -23,11 +23,19 @@ else
     exit 1
   }
   if [ -d "$TAI_DIR/.git" ]; then
-    # The one-liner is also the update path: an existing checkout is pulled
-    # forward and reinstalled, never cloned over. A pull that cannot happen
-    # (diverged, offline) fails here, loudly, rather than installing old code.
+    # The one-liner is also the update path: an existing checkout is refetched
+    # and reinstalled, never cloned over. The checkout is this install's own —
+    # nobody develops in it — so the update is one commit deep every time:
+    # fetch --depth 1, reset to what origin named, prune what is left behind.
+    # A pull here would download every commit made since the checkout was cut,
+    # and a checkout that predates --depth 1 would carry its whole history
+    # forever. Offline, the fetch fails and set -e stops the install loudly —
+    # the old rule stands: never install old code on the strength of a guess.
     echo "→ updating the checkout at $TAI_DIR…"
-    git -C "$TAI_DIR" pull --ff-only --quiet
+    _branch="$(git -C "$TAI_DIR" rev-parse --abbrev-ref HEAD)"
+    git -C "$TAI_DIR" fetch --depth 1 --quiet origin "$_branch"
+    git -C "$TAI_DIR" reset --hard --quiet FETCH_HEAD
+    git -C "$TAI_DIR" gc --prune=now --quiet 2>/dev/null || true
   elif [ -e "$TAI_DIR" ]; then
     echo "tai: $TAI_DIR exists and is not a tai checkout — remove it or set TAI_DIR" >&2
     exit 1
@@ -142,12 +150,12 @@ _tai_enable() {
   local rc="$1" plugin="$2" source_line="$3" plugin_name
   plugin_name="${plugin##*/}"
   mkdir -p "$(dirname "$rc")"
-  python3 - "$rc" "$source_line" "$plugin_name" <<'PY'
+  python3 - "$rc" "$source_line" "$plugin_name" "$plugin" <<'PY'
 import os
 import sys
 from pathlib import Path
 
-rc, source_line, plugin_name = sys.argv[1:]
+rc, source_line, plugin_name, ours = sys.argv[1:]
 path = Path(rc)
 # surrogateescape, not errors="replace": a dotfile in a legacy encoding has bytes
 # that are not valid UTF-8, and replacing them on read would silently rewrite the
@@ -156,18 +164,47 @@ text = path.read_text(encoding="utf-8", errors="surrogateescape") if path.exists
 marker = "# tai autocomplete (installed by ./install.sh)"
 lines = text.splitlines(keepends=True)
 cleaned = []
+retargeted = []
 i = 0
 while i < len(lines):
     line = lines[i]
     if line.strip() == marker:
-        # Replace the managed two-line block when the checkout path changes.
+        # The managed block: refresh its line in place rather than removing and
+        # re-appending, so the block keeps its place and a moved tree rewrites
+        # the one line instead of gaining a second one.
+        cleaned.append(line)
         i += 1
         if i < len(lines) and plugin_name in lines[i] and "source" in lines[i]:
-            i += 1
+            lines[i] = source_line + "\n"
         continue
+    stripped = line.lstrip()
+    if (not stripped.startswith("#") and "source" in line
+            and "plugins/" in line and plugin_name in line
+            and ours not in line):
+        # A tai source line left by an older door: the same plugin name from
+        # another tree — the checkout the curl one-liner cloned, still in the
+        # rc after npm took over the wrapper. Matching by name alone said
+        # "already enabled" and kept the shell sourcing code npm's updates
+        # never touch: `tai version` reported one tree while the shell ran
+        # another. The line is this install's to own, so it is retargeted.
+        old = [t for t in line.split() if plugin_name in t]
+        retargeted.append(old[-1].strip("\"'") if old else line.strip())
+        line = source_line + "\n"
     cleaned.append(line)
     i += 1
 
+# A retarget can meet a stale line twice (a managed block and a stray copy);
+# the line is sourced once, first occurrence wins.
+wanted = source_line + "\n"
+deduped, seen = [], False
+for line in cleaned:
+    if line == wanted:
+        if seen:
+            continue
+        seen = True
+    deduped.append(line)
+cleaned = deduped
+
 # A manually configured integration is already enabled; do not add a second
 # copy when the installer is rerun.
 has_source = any(
@@ -180,6 +217,9 @@ if not has_source:
     cleaned.append(marker + "\n")
     cleaned.append(source_line + "\n")
 
+for old in retargeted:
+    print(f"tai: retargeted the {plugin_name} source line ({old} — was another install's tree)")
+
 # 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "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": {

package/readme.md

@@ -28,20 +28,6 @@ curl -fsSL https://raw.githubusercontent.com/mlibre/Terminal-AI-Helper/main/inst
 exec zsh
 ```
 
-Or using npm
-
-```sh
-npm i -g terminal-ai-helper@latest --allow-scripts=terminal-ai-helper
-exec zsh
-```
-
-The flag is npm's: newer npm blocks install scripts by default, and without
-it the package unpacks and nothing is wired — no `tai` command, no rc lines.
-
-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
-history, and builds the first index:
-
 ```text
 → cloning tai to /home/you/.tai…
 → learning from your history, building the index…
@@ -57,7 +43,17 @@ history, and builds the first index:
 ```
 
 That last line matters: a terminal that is already open keeps the old
-version until you open a new one — same after `tai update`.
+version until you open a new one — same after `tai update`. An install
+that switched doors could leave the shell's `source` line naming the
+older tree — code updates never reach it; `tai update` retargets that
+line, and `tai version` says where it points.
+
+Or using npm
+
+```sh
+npm i -g terminal-ai-helper@latest --allow-scripts=terminal-ai-helper
+exec zsh
+```
 
 ## Commands
 
@@ -69,7 +65,7 @@ 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 version     # this install's release, and where the shell plugin is wired
 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

package/tai/cli.py

@@ -213,6 +213,15 @@ def _update_npm(repo: "Path") -> int:
     The allow-scripts flag rides along because npm's newer vintages block
     install scripts by default — the same gate the readme's install line
     opens — and a blocked hook would leave a replaced tree nobody wired.
+
+    The rerun is decided by the wiring, not by the version. An install that
+    switched doors could leave the rc line naming an older tree — the
+    checkout the curl one-liner cloned, still sourced after npm took over
+    the wrapper — and then every `tai update` reported a version the shell
+    was not running, "already up to date" being exactly when the old guard
+    (`after == before or configured`) skipped the repair. The installer is
+    idempotent and its configured check is the wiring's own test, so it runs
+    whenever that test fails, whichever the version says.
     """
     import shutil
     import subprocess
@@ -233,7 +242,7 @@ def _update_npm(repo: "Path") -> int:
     # 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():
+    if _npm_configured():
         return 0
     installer = repo / "install.sh"
     if not installer.exists():
@@ -257,6 +266,7 @@ def cmd_update(a) -> int:
 
     import shutil
     import subprocess
+    from pathlib import Path
 
     git = shutil.which("git")
     if not git:
@@ -272,15 +282,49 @@ def cmd_update(a) -> int:
         return subprocess.run([git, "-C", str(repo), "rev-parse", "--short", "HEAD"],
                               capture_output=True, text=True).stdout.strip()
 
+    def run_git(*argv: str) -> subprocess.CompletedProcess:
+        return subprocess.run([git, "-C", str(repo), *argv],
+                              capture_output=True, text=True)
+
+    # The checkout the one-liner cloned is this install's own tree, not a
+    # development branch: nobody commits in it, so the update is a fetch one
+    # commit deep and a reset to what origin named — the same three commands
+    # install.sh's piped door runs. A pull here would download every commit
+    # made since the checkout was cut, and one that predates --depth 1 would
+    # carry its whole history forever. A checkout anywhere else is somebody's
+    # tree — maybe a fork they develop in — and it keeps the careful pull:
+    # fast-forward only, a divergence fails loudly rather than resetting
+    # anybody's work away.
+    managed = (repo.resolve()
+               == Path(os.environ.get("TAI_DIR")
+                       or Path.home() / ".tai").resolve())
+
     before = head()
-    pull = subprocess.run([git, "-C", str(repo), "pull", "--ff-only"],
-                          capture_output=True, text=True)
-    if pull.returncode != 0:
-        # A local edit in the checkout is the usual cause, and git's own message
-        # says exactly what to do about it, so pass it through rather than guess.
-        print("tai: git pull failed:")
-        print((pull.stderr or pull.stdout).strip())
-        return 1
+    if managed:
+        branch = run_git("rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+        failed = None
+        for argv in (("fetch", "--depth", "1", "--quiet", "origin", branch),
+                     ("reset", "--hard", "--quiet", "FETCH_HEAD")):
+            done = run_git(*argv)
+            if done.returncode != 0:
+                failed = argv[0]
+                break
+        if failed:
+            print(f"tai: git {failed} failed:")
+            print((done.stderr or done.stdout).strip())
+            return 1
+        # Hygiene, not a step: what the old history weighed is already
+        # unreachable after the reset, and a failed prune costs nothing.
+        run_git("gc", "--prune=now", "--quiet")
+    else:
+        pull = run_git("pull", "--ff-only")
+        if pull.returncode != 0:
+            # A local edit in the checkout is the usual cause, and git's own
+            # message says exactly what to do about it, so pass it through
+            # rather than guess.
+            print("tai: git pull failed:")
+            print((pull.stderr or pull.stdout).strip())
+            return 1
     after = head()
     # Flushed, because the installer below writes to the same terminal from a
     # child process and would otherwise appear ahead of this line.
@@ -578,21 +622,29 @@ def cmd_uninstall(a) -> int:
             removed.append(str(rc))
     # The piped door clones the code itself to TAI_DIR (default ~/.tai), and
     # leaving it behind would leave the program installed in every way but the
-    # wrapper — the same rule the rc blocks above are held to. What makes the
-    # directory tai's is its layout: cli.py and the installer inside it. A
-    # directory without that shape is not ours to delete, so it is named and
-    # kept. Last on purpose: this command usually runs from inside the checkout
-    # (the wrapper execs this very file), so removing it has to be the last
-    # thing the run does.
+    # wrapper — the same rule the rc blocks above are held to. The name is the
+    # identity: the path is tai's namespace, created by tai's installer and
+    # claimed by nothing else, so whatever the checkout has grown into — a
+    # shape an older door left half-made, files the user dropped beside the
+    # code — goes with the uninstall, and the report says which kind it was.
+    # One floor stands: never a directory the home lives in or under, so a
+    # mistyped TAI_DIR cannot name more than tai owns. Last on purpose: this
+    # command usually runs from inside the checkout (the wrapper execs this
+    # very file), so removing it has to be the last thing the run does.
     checkout = Path(os.environ.get("TAI_DIR") or home / ".tai")
-    left = None
+    held = ""
     if checkout.exists():
-        if ((checkout / "tai" / "cli.py").exists()
-                and (checkout / "install.sh").exists()):
-            shutil.rmtree(checkout)
-            removed.append(str(checkout))
+        if home.is_relative_to(checkout):
+            held = f"left {checkout} — it holds the home directory"
         else:
-            left = checkout
+            ours = ((checkout / "tai" / "cli.py").exists()
+                    and (checkout / "install.sh").exists())
+            if checkout.is_dir():
+                shutil.rmtree(checkout)
+            else:
+                checkout.unlink()
+            removed.append(str(checkout) + ("" if ours
+                           else " (not a tai checkout — removed anyway)"))
     # The npm door's code is npm's to remove, and the running tree says the
     # same thing the wrapper did — this process may itself be executing from
     # the package npm owns. Last, for the same reason the checkout is: the
@@ -613,10 +665,10 @@ def cmd_uninstall(a) -> int:
     print("tai removed" if removed else "tai was not installed")
     for path in removed:
         print(f"  removed {path}")
-    if left:
-        print(f"  left {left} — not a tai checkout")
     if npm_note:
         print(f"  {npm_note}")
+    if held:
+        print(f"  {held}")
     return 0
 
 
@@ -694,9 +746,47 @@ def cmd_jev(a) -> int:
 
 
 def cmd_version(a) -> int:
-    """Say which release this is."""
+    """Which release this is, and where the shell's plugin line points.
+
+    The second half exists because the two can disagree. An install that
+    switched doors — the curl one-liner's checkout replaced by the npm
+    package — left the rc line naming the older tree, and the shell went on
+    running code `tai version` no longer reported: the release number comes
+    from the tree the wrapper execs, the plugin comes from wherever the rc
+    says. Both facts are read here, so the mismatch is visible in the same
+    command a user runs to answer "which tai is this".
+    """
     version = _read_version()
     print(f"tai {version}")
+    from pathlib import Path
+    repo = _repo_dir()
+    home = Path.home()
+    for shell, rc_name, plugin in (("zsh", ".zshrc", "tai.zsh"),
+                                   ("bash", ".bashrc", "tai.bash")):
+        wired = ""
+        try:
+            for line in (home / rc_name).read_text(
+                    encoding="utf-8", errors="surrogateescape").splitlines():
+                if line.lstrip().startswith("#") or "source" not in line \
+                        or plugin not in line:
+                    continue
+                tokens = [t for t in line.split() if plugin in t]
+                if tokens:
+                    wired = tokens[-1].strip("\"'")
+                    break
+        except OSError:
+            pass
+        if not wired:
+            print(f"{shell} plugin not wired")
+            continue
+        note = ""
+        try:
+            if Path(wired).expanduser().resolve() != \
+                    (repo / "plugins" / plugin).resolve():
+                note = " — another install; 'tai update' rewires it here"
+        except OSError:
+            pass
+        print(f"{shell} plugin {wired}{note}")
     return 0
 
 
@@ -842,8 +932,10 @@ def main() -> int:
     if argv and argv[0] == "record" and "--help" not in argv and "-h" not in argv:
         return cmd_record(_fast_record(argv[1:]))
     if argv == ["version"]:
-        print(f"tai {_read_version()}")
-        return 0
+        # The report is two small rc reads beside the version file — the lean
+        # path can afford what the parser path would print, and both doors
+        # must say the same thing about the wiring.
+        return cmd_version(None)
     # Any other command is a tai process the user asked for, and a non-empty
     # spool is records waiting for one: drain it here, so `tai suggest`,
     # `tai refresh` or the dashboard never answer from a store that is a few