terminal-ai-helper 2.0.0 → 2.0.1

package/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

package/install.sh

@@ -142,12 +142,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 +156,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 +209,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.0.1",
   "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

@@ -57,7 +57,10 @@ 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.
 
 ## Commands
 
@@ -69,7 +72,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():
@@ -694,9 +703,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 +889,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