TUI: explicit Option/Meta+Backspace word-delete + openhack --showkey

Bind word-delete (erase previous word) explicitly and eagerly to the
escape-prefixed backspace/delete encodings — (escape, backspace) [ESC+DEL
\x1b\x7f and ESC+BS, both parse to (escape, c-h)], (escape, delete) [the
Option+forward-delete CSI], and c-w — so it's deterministic across
terminals and can't be pre-empted by the lone-escape handlers. Verified
in a real pseudo-terminal: "hello world foo" + each sequence -> "hello
world "; a plain backspace still deletes one char.

Adds `openhack --showkey`: a raw-key diagnostic that prints the exact
byte sequence a terminal sends for each keypress (e.g. Option+Backspace),
so a nonstandard encoding can be identified and bound precisely.

Claude-Session: https://claude.ai/code/session_016PMahuFwyaHhR5aUeeC1TM

Author: ananay

openhack/__main__.py

@@ -13,6 +13,7 @@
   openhack --providers                List LLM providers you can connect
   openhack --login                    Log in to your OpenHack account
   openhack --setup                    Run the setup wizard
+  openhack --showkey                  Print the raw bytes your terminal sends (key diagnostic)
   openhack --help                     Show usage
 """
 
@@ -264,6 +265,52 @@ def _cmd_classify():
     print(f"  Run 'openhack --resume {sid}' to scan\n")
 
 
+def _cmd_showkey():
+    """Print the raw byte sequence your terminal sends for each keypress.
+
+    Diagnostic for key-binding issues (e.g. Option+Backspace): run it, press
+    the key, and it prints the exact bytes so a binding can target them.
+    """
+    import os
+    import select
+
+    try:
+        import termios
+        import tty
+    except ImportError:
+        print("showkey needs a POSIX terminal.")
+        return
+    if not sys.stdin.isatty():
+        print("Run this in a real terminal (stdin is not a TTY).")
+        return
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    print("Press keys to see what your terminal sends (Ctrl-C to quit).", flush=True)
+    print("Try: Option+Backspace, Ctrl-W, Option+Left.\n", flush=True)
+    try:
+        tty.setraw(fd)
+        while True:
+            if not select.select([fd], [], [], None)[0]:
+                continue
+            buf = os.read(fd, 1)
+            # Drain the rest of a multi-byte escape sequence.
+            while select.select([fd], [], [], 0.02)[0]:
+                buf += os.read(fd, 1)
+            if buf in (b"\x03", b"\x04"):  # Ctrl-C / Ctrl-D
+                break
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)  # restore to print
+            hexs = " ".join(f"\\x{c:02x}" for c in buf)
+            pretty = buf.decode("latin-1").replace("\x1b", "ESC")
+            print(f"  {hexs:<20}  ({pretty!r})", flush=True)
+            tty.setraw(fd)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    print(flush=True)
+
+
 def _cmd_login():
     """Run the device login flow."""
     from openhack.setup import run_first_time_setup
@@ -288,6 +335,7 @@ def _cmd_setup():
     "classify": _cmd_classify,
     "login": _cmd_login,
     "setup": _cmd_setup,
+    "showkey": _cmd_showkey,
 }
 
 

openhack/tui.py

@@ -1359,6 +1359,23 @@ def _select_word_right(event):
             buf.start_selection()
             buf.cursor_position += pos
 
+        # Option/Meta + Backspace — erase the word before the cursor (the
+        # standard word-delete every shell/editor does). macOS sends ESC + DEL
+        # (\x1b\x7f) which prompt_toolkit parses as (escape, c-h); the ESC+BS and
+        # Option+forward-delete variants land on (escape, delete). We bind them
+        # explicitly and eagerly so the behavior is deterministic and can't be
+        # pre-empted by the lone-escape handlers.
+        @kb.add("escape", "backspace", eager=True, filter=~modal_open)
+        @kb.add("escape", "delete", eager=True, filter=~modal_open)
+        @kb.add("c-w", eager=True, filter=~modal_open)
+        def _delete_word_before(event):
+            buf = event.current_buffer
+            pos = buf.document.find_previous_word_beginning()
+            if pos:
+                buf.delete_before_cursor(-pos)
+            elif buf.document.text_before_cursor:
+                buf.delete_before_cursor(len(buf.document.text_before_cursor))
+
         # Tab navigation — only in scanning/viewing modes, and only when the
         # input is empty so they don't conflict with typing.
         def _in_tabs() -> bool: