terminal-ai-helper 2.3.0 → 2.3.2

package/VERSION

@@ -1 +1 @@
-2.3.0
+2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "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/bash/keys.bash

@@ -15,6 +15,12 @@ _tai_prompt() {
   raw="${raw#"${raw%%[![:space:]]*}"}"       # drop the leading indent
   while [[ "$raw" == [0-9]* ]]; do raw="${raw#?}"; done   # drop the history number
   last_cmd="${raw#"${raw%%[![:space:]]*}"}"  # drop the space after it
+  # A completion's own space rides the line into the history (`nano ` after a
+  # menu choice), and the store strips it — but this shell's next prediction
+  # looks the last command up in the sequence table by its exact text, and the
+  # table's keys are the stored, stripped rows. Trim here, once per command,
+  # so `nano ` predicts what followed `nano` and records the same row either way.
+  while [[ "$last_cmd" == *[[:space:]] ]]; do last_cmd="${last_cmd%?}"; done
   if [[ -n "$last_cmd" && "$last_cmd" != "$_TAI_LAST" ]]; then
     _TAI_LAST="$last_cmd"
     # The unit cache pre-loads itself in the background after a command that
@@ -247,12 +253,25 @@ _tai_complete() {
 # by both loops above — once as the file that is here, once as the line the
 # history holds — and COMPREPLY holding it twice makes readline print it twice.
 _tai_reply() {
-  local c
+  local c x
   # A learned line carrying raw control bytes is not a completion it is this
   # plugin's promise to never paint: what it would write is escape bytes.
   [[ "$1" =~ [[:cntrl:]] ]] && return 0
-  for c in "${COMPREPLY[@]}"; do [[ "$c" == "$1" ]] && return 0; done
-  COMPREPLY+=("$1")
+  c="$1"
+  # A completion that leaves the line one bare word is a command waiting for
+  # its arguments, and readline's own completion would have written the space
+  # between them (`cat tzz_solo `). `-o nospace` took that append away from
+  # every entry so a directory's slash could stand alone, so the entries that
+  # want the space carry it — measured on a real shell, a match holding a
+  # trailing space is inserted verbatim, and the common prefix of matches that
+  # disagree past the space is the prefix alone. Three shapes carry none: a
+  # directory's slash, which is the path still being typed; a whole learned
+  # line, which is the line the user ran, and whose space would ride the next
+  # Enter into the history as a row of its own; and a name that already holds
+  # a space, which is more than one shell word already.
+  if [[ -n "$c" && "$c" != */ && "$c" != *[[:space:]]* ]]; then c="$c "; fi
+  for x in "${COMPREPLY[@]}"; do [[ "$x" == "$c" ]] && return 0; done
+  COMPREPLY+=("$c")
 }
 complete -o nospace -F _tai_complete tai 2>/dev/null
 # -o default is what makes Tab fall back to readline's own filename completion

package/plugins/zsh/menu.zsh

@@ -769,6 +769,24 @@ _tai_menu_commit() {
   # slash from truncating what gets written.
   (( ${_TAI_MENU_Q[_TAI_MENU_IDX]} )) && { _tai_quote "$entry"; entry="$_TAI_QUOTED" }
   BUFFER="${BUFFER[1,$(( _TAI_MENU_FROM - 1 ))]}$entry${BUFFER[_TAI_MENU_TO + 1,-1]}"
+  # A completion that leaves the line one bare word is a command waiting for its
+  # arguments, and the space between them is written for the user — every
+  # shell's own completion does this, and readline's half of this plugin always
+  # did (`cat tzz_solo `). The report: choosing `nano` out of the menu put
+  # `nano` in the line, and the user typed the space by hand, once per line,
+  # every time. Three shapes write nothing after them: a directory's slash,
+  # which is the path still being typed; a whole learned line, which is the
+  # line the user ran, and whose space would ride the next Enter into the
+  # history as a row of its own; and a name that already holds a space, whose
+  # quoting is the shell word it is.
+  [[ "$entry" != */ && "$entry" != *[[:space:]]* ]] && BUFFER+=" "
+  # What the commit wrote is the line the user took. Without this, the space a
+  # bare-word commit writes is one deletion from the learned line itself, and
+  # the loose glimpse answered the very next redraw with the line just taken —
+  # `cd tzz_dir ` re-offering `cd tzz_dir` from under the cursor. The same
+  # dismiss an Up from a glimpse sets: while the text stands, the list does not
+  # spring back, and the next keystroke re-arms it.
+  _TAI_MENU_DISMISS="$BUFFER"
   CURSOR=${#BUFFER}
   _tai_menu_close
 }

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,6 +602,10 @@ _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
@@ -716,6 +762,12 @@ _tai_preexec() {
   # resolved in the background write instead, which also means the repo, branch
   # and cwd all describe the same moment. bash has always done it this way.
   _TAI_CMD="$1"
+  # A completion's own space rides the line into preexec (`nano ` after a menu
+  # choice), and the store strips it on the way in — but this shell's next
+  # prediction looks the last command up in the sequence table by its exact
+  # text, and the table's keys are the stored, stripped rows. Trim here, once
+  # per command, so `nano ` predicts what followed `nano`.
+  while [[ "$_TAI_CMD" == *[[:space:]] ]]; do _TAI_CMD="${_TAI_CMD%?}"; done
   # The directory the command was *run from*. A prompt-time $PWD comes after the
   # command, so for `cd src` the recorded origin was the destination — and the
   # path-liveness check judged the cd's argument against the place it had just

package/readme.md

@@ -38,7 +38,7 @@ exec zsh
 ✓ bash installed
 
   1. Type a few letters — tai finishes the command in grey. → takes it.
-  2. Tab opens a menu of what fits. Enter picks; a second Enter runs.
+  2. Tab opens a menu of what fits. Enter picks, space after the command included; a second Enter runs.
   3. It learns from your history — offline, private, no account.
 
   Try it now: type "cd " and watch the grey.