terminal-ai-helper 1.3.6 → 2.0.1

package/VERSION

@@ -1 +1 @@
-1.3.6
+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": "1.3.6",
+  "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": {
@@ -36,4 +36,4 @@
   "devDependencies": {
     "vitepress": "^1.6.3"
   }
-}
+}

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
@@ -200,9 +203,10 @@ rc file.
 
 `tai update` stops rather than overwrite a copy you have edited yourself.
 `tai uninstall` removes the shell integration, the wrapper, the indexes, the
-SQLite history 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.
+SQLite history, the cached knowledge and the `~/.tai` checkout itself; a
+folder that is not a tai checkout is named and left alone. On an npm install
+it also runs `npm rm -g terminal-ai-helper` itself. Restart the terminal
+afterwards.
 
 ## Why it stays fast
 

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():
@@ -505,6 +514,7 @@ def cmd_eval_jev(a) -> int:
 
 def cmd_uninstall(a) -> int:
     import shutil
+    import subprocess
     from pathlib import Path
 
     from tai.paths import data_dir
@@ -519,7 +529,17 @@ def cmd_uninstall(a) -> int:
     # BIN_DIR is the one that gets removed.
     wrapper = Path(os.environ.get("BIN_DIR") or home / ".local" / "bin") / "tai"
     removed = []
+    npm_door = False
     if wrapper.exists() or wrapper.is_symlink():
+        # The wrapper names the checkout it execs, and that name is the door:
+        # a wrapper pointing into node_modules means the package itself is
+        # still installed, and the uninstall is not done until npm has it
+        # back. Read before unlink; a wrapper that cannot be read still goes.
+        try:
+            npm_door = ("node_modules/terminal-ai-helper"
+                        in wrapper.read_text(errors="replace"))
+        except OSError:
+            pass
         wrapper.unlink()
         removed.append(str(wrapper))
     if data.exists():
@@ -565,9 +585,47 @@ def cmd_uninstall(a) -> int:
             tmp.write_text(new, encoding="utf-8", errors="surrogateescape")
             os.replace(tmp, rc)
             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.
+    checkout = Path(os.environ.get("TAI_DIR") or home / ".tai")
+    left = None
+    if checkout.exists():
+        if ((checkout / "tai" / "cli.py").exists()
+                and (checkout / "install.sh").exists()):
+            shutil.rmtree(checkout)
+            removed.append(str(checkout))
+        else:
+            left = checkout
+    # 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
+    # tree this command runs from can be the thing being removed.
+    npm_note = ""
+    if npm_door or _install_method(_repo_dir()) == "npm":
+        npm = shutil.which("npm")
+        if npm:
+            done = subprocess.run([npm, "rm", "-g", "terminal-ai-helper"],
+                                  capture_output=True, text=True)
+            if done.returncode == 0:
+                removed.append("terminal-ai-helper (npm global package)")
+            else:
+                npm_note = done.stderr.strip()
+        else:
+            npm_note = ("npm is not on PATH — the package is removed with: "
+                        "npm rm -g terminal-ai-helper")
     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}")
     return 0
 
 
@@ -645,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
 
 
@@ -793,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