terminal-ai-helper 2.3.1 → 2.3.2

package/VERSION

@@ -1 +1 @@
-2.3.1
+2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.3.1",
+  "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

@@ -762,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.