terminal-ai-helper 2.2.0 → 2.3.0

package/VERSION

@@ -1 +1 @@
-2.2.0
+2.3.0

package/package.json

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

@@ -562,6 +562,23 @@ _tai_line_init() {
   _TAI_ISEARCH=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