terminal-ai-helper 2.2.0 → 2.3.1

package/VERSION

@@ -1 +1 @@
-2.2.0
+2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.2.0",
+  "version": "2.3.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/plugins/zsh/widgets.zsh

@@ -114,6 +114,26 @@ _tai_update() {
     fi
     return
   fi
+  # The accept echo is the one redraw that paints nothing. When the line is
+  # accepted, zsh re-renders it as it will run, and that render fires this
+  # hook — which answered it like any keystroke: it ran the query for the
+  # line one last time and painted the hint back onto the row the shell was
+  # leaving. The report: Enters on an empty prompt stacked gray `cd …` lines
+  # that read as commands the user ran, and a scrollback reader believed
+  # them. So the accept path raises _TAI_ACCEPT, and this hook takes tai's
+  # own paint down and stands aside: the echo shows what was typed, and what
+  # tai drew goes down with the line it rode in on. line-init lowers the
+  # flag with everything else it resets — the next line paints as usual.
+  if (( _TAI_ACCEPT )); then
+    _TAI_SUGGESTION=""
+    (( _TAI_MENU_IDX )) && _tai_menu_close
+    if (( _TAI_DREW )); then
+      POSTDISPLAY=""
+      region_highlight=()
+      _TAI_DREW=0
+    fi
+    return
+  fi
   local -i ours_was=$_TAI_DREW
   # What the last widget was decides whether this buffer is typed. The hook
   # runs after every widget, and the names here are the ones that mean an
@@ -348,10 +368,32 @@ tai-enter() {
   # A glimpsed menu still swallows the selection; Enter at a disarmed menu is
   # the line's Enter.
   if (( _TAI_MENU_IDX )); then _tai_menu_close; POSTDISPLAY=""; region_highlight=(); fi
+  # What runs is what was typed, and the echo of it must say so. zsh's final
+  # render of the accepted line fires the redraw hook, which would answer it
+  # with a fresh query and paint the hint back onto the row being left; the
+  # flag stands the hook down for that one render. See _tai_update.
+  _TAI_ACCEPT=1
   zle accept-line
 }
 zle -N tai-enter
 
+# Enter is not the only door to a running line: TAI_NO_MENU=1 leaves ^M on
+# stock accept-line, and so can a user binding of their own. The wrapper
+# raises the same flag tai-enter raises, so the accept echo paints nothing
+# in those shells either. It is registered only while the name is still the
+# builtin — an accept-line another plugin wrapped is theirs, their clear
+# already answers their own hint, and tai-enter raises the flag itself
+# before it calls accept-line by name, so the hook stands down either way.
+typeset -gi _TAI_ACCEPT=0
+tai-accept-line() {
+  _TAI_ACCEPT=1
+  zle .accept-line
+}
+zle -N tai-accept-line
+case "${widgets[accept-line]:-}" in
+  builtin*) zle -N accept-line tai-accept-line ;;
+esac
+
 # Right arrow accepts the suggestion at the end of the line, and moves the
 # cursor one character anywhere else. Bound straight to tai-accept it took
 # forward-char away entirely: with a ghost on screen there was then no key left
@@ -560,8 +602,29 @@ _tai_line_init() {
   # exit hook, and a flag carried into the next line would stand tai down for
   # every keystroke of it. The hook pair is the truth; this is the belt.
   _TAI_ISEARCH=0
+  # Nor is a line still being accepted: the accept flag stands the redraw
+  # hook down for the echo of the line that is leaving, and a new line is
+  # painted on again from its first redraw.
+  _TAI_ACCEPT=0
   region_highlight=()
   _tai_menu_close
+  # The prophecy. _TAI_SEQ answers "what did I run after this", and the fresh
+  # prompt is where that answer is taken — so the reset above is followed by
+  # the question, through the same _tai_update the redraw hook runs: it looks
+  # the empty buffer up against _TAI_LAST, judges the head's relative paths
+  # where the prompt stands, and paints the gray line the arrow accepts. The
+  # report: the sequence table held `sudo …` after the denied `systemctl …`
+  # and the prompt said nothing, because line-init only ever cleared, and no
+  # widget-triggered redraw fires before the first keystroke — by which time
+  # the buffer is no longer empty and the ordinary prefix lookup has replaced
+  # the question. Nothing here can answer before the first command has run:
+  # _TAI_LAST is set by precmd, so a shell that just opened queries an empty
+  # last command and paints nothing — the prophecy is learned, never a
+  # default. The query is cached, so the first real redraw of this line
+  # restores the answer instead of recomputing it, and every guard the redraw
+  # path applies (isearch stand-down, ours-only clearing, the paste rule) is
+  # this path's guard too, because it is the same call.
+  _tai_update
 }
 
 # The isearch flag the redraw hook stands down under, and the pair that

package/readme.md

@@ -14,6 +14,9 @@ autocomplete that knows *you*:
 systemctl <→>         restart nginx           ← the hint, taken
 git <Tab>             pull      status        ← your habits, ranked
 cd D<Tab>             Desktop/  Documents/  Downloads/
+
+systemctl stop cups.path
+❯ sudo systemctl stop cups.path   ← what you did last time, already waiting
 ```
 
 ![tai in action — the hint, the ranked list, the filesystem, a typo
@@ -77,7 +80,11 @@ tai uninstall   # remove everything tai added
    `Ctrl-F` takes it whole, `Alt-F` one word.
 2. **Press `Tab`.** On a first word your history ranks the lines it knows;
    `Enter` fills one in, a second `Enter` runs it.
-3. **Run `tai web`.** A localhost dashboard of everything it learned, with a
+3. **Run a command and look at the next prompt.** When a command fails the way
+   it failed before, the empty line already shows, in grey, what you did about
+   it last time — `sudo …` after the denied `systemctl …`, `rm -r …` after the
+   refused `rm`. `→` takes it; typing replaces it.
+4. **Run `tai web`.** A localhost dashboard of everything it learned, with a
    try box that answers exactly what the prompt would.
 
 Every command you run teaches it — secrets, multi-line pastes and stray keys
@@ -88,7 +95,7 @@ machine. New commands show up within seconds; no restart, ever.
 
 | key                     | what it does                                                                                                                                           |
 | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `→`                     | take the hint at the end of the line, else move right                                                                                                  |
+| `→`                     | take the hint at the end of the line, else move right — on a fresh prompt the hint is what followed the command you just ran                           |
 | `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 |
@@ -137,6 +144,11 @@ memory, an array hit in microseconds.
   exists, here, on your PATH.
 - **A tool you have never run still gets an answer:** `tool --help`. Run it
   once and the real `--help` is learned in the background.
+- **A fresh prompt carries what came next.** After a command, the empty line
+  shows in grey what your own history followed it with — ranked by how often
+  it followed, judged where the prompt stands like every suggestion. It is
+  learned or it is nothing: nothing built in, nothing before your first
+  command, and a follower whose path does not resolve here is not offered.
 
 - **If another plugin also draws hints, both work.** `→`, `Ctrl-F` and
   `Alt-F` take whatever is on screen, and tai never overwrites a hint it did

package/tai/index.py

@@ -413,15 +413,19 @@ def build(max_commands: int = 20000) -> int:
 
     seq: dict[str, list[str]] = defaultdict(list)
     for prev, counter in eng.seq.items():
-        # Sorted here, best first, because a shell now reads the order as the
-        # ranking and not only as a tiebreak: the zsh menu shows a key's values in
-        # the order they are stored, while _tai_best still re-ranks by
-        # _TAI_SCORE to pick one. It used to add `count * 2.5` to a milli-score,
-        # which is 0.08% of the value it was added to: the list looked
-        # sequence-ranked and was really just base-score ranked with extra steps.
-        values = [cmd for cmd, _ in sorted(
-            ((cmd, scores.get(cmd, 0)) for cmd in counter),
-            key=lambda x: (-x[1], x[0]))[:SEQ_CANDIDATE_CAP]]
+        # Ordered by how often the pair happened, then by how good the line is,
+        # best first — because the head of this list is the line a fresh prompt
+        # offers, and "what did I run after this" is answered by what followed
+        # *most*, not by the best-scoring line that ever did. The engine's own
+        # sequence factor is the pair's normalized count for the same reason;
+        # ordering the list by base score alone (an earlier shape, with the
+        # count discarded here) made the prophecy disagree with the engine on
+        # exactly the key the prophecy exists for: after `git add -A`, the
+        # history's `git commit -m …` lost the head to a bare `ls` that had
+        # merely followed once and scored well on its own.
+        values = [cmd for cmd, _, _ in sorted(
+            ((cmd, counter[cmd], scores.get(cmd, 0)) for cmd in counter),
+            key=lambda x: (-x[1], -x[2], x[0]))[:SEQ_CANDIDATE_CAP]]
         # A key whose every follower was stale has no answer left, and writing
         # it as an empty string puts `_TAI_SEQ[key] = ''` in the file. The zsh
         # plugin splits that into one empty line and the bash one reads it as an