fix(injection): send newlines as Return on the xdotool backend (#962)

* fix(injection): send newlines as Return on the xdotool backend

xdotool type maps '\n' to the Linefeed keysym, which GTK targets
silently drop — "new line" produced nothing on X11 even though the
segment reached the injector.  Split each chunk on '\n' and press
Return between typed segments so a newline lands as a real keypress
in every app.

Verified against a live GtkTextView on Xvfb: the same "A\nB" input
that previously produced 'AB' now produces 'A\nB'.

Fixes #955

* fix(commands): consume trailing punctuation after mid-utterance commands

"New paragraph." inside a longer utterance substituted correctly but
left the engine's sentence-final period typed after the break
("\\n\\n. Does this work now?").  Text-command substitution now
consumes a run of trailing , . ! ? ; : … when it precedes whitespace
or the end of the segment — the reporter's comma-phrased case
("…, new paragraph, …") stops leaking the stray comma the same way.
A mark glued to following text ("newline.io") is untouched.

Fixes #955

* fix(injection,commands): resume mid-chunk on retry, don't eat produced marks

Greptile review follow-ups on #962:

- A failed Return mid-chunk left 'typed' at the chunk start, so the
  retry re-sent text xdotool had already delivered.  'typed' now
  advances per typed segment and per Return keypress, so the retry
  resumes exactly at the un-typed position — and the clipboard
  fallback reports the same progress if retries run out.
- _TRAILING_PUNCTUATION could consume a mark produced by an earlier
  command replacement ('hello new line exclamation mark' gave '\\n'
  instead of '\\n!').  The eater now only consumes marks before
  whitespace; the end-of-utterance case ('hello new line.') is a
  pre-pass on the raw segment before any substitution runs.

* style: black-format comment indent and test condition

* fix(commands): strip segment before the end-of-utterance cleanup

Trailing whitespace ('hello new line. ') hid the final mark from the
pre-pass: the raw segment ended in a space, and the stripped segment
left the dot at end-of-string where the mid-utterance eater cannot
touch it.  Strip first, then run the cleanup.

Also add the missing type hints on the new test helper.

---------

Co-authored-by: Jatin K Malik <jatinkrmalik@gmail.com>

src/vocalinux/speech_recognition/command_processor.py

@@ -27,6 +27,14 @@ _ATTACH_LEFT_WS = r"[^\S\n]*"
 # phrases — the same marks stay untouched on real text.
 _EDGE_PUNCTUATION = ".,!?;:…"
 
+# Trailing punctuation right after a spoken command mid-utterance is also
+# phrasing, not text ("testing, new paragraph, done" must not type a stray
+# comma after the break).  Command substitution consumes it — but only
+# before whitespace: a mark at end-of-string may have been produced by an
+# earlier command replacement ("…new line exclamation mark" → "\n!"), and
+# the end-of-utterance case is handled by a pre-pass on the raw segment.
+_TRAILING_PUNCTUATION = r"(?:[,.!?;:…]+(?=\s))?"
+
 # Base English text commands (always present).
 _BASE_TEXT_COMMANDS = {
     # Line commands
@@ -119,7 +127,8 @@ class CommandProcessor:
         """Compile regex patterns for command matching."""
         # Longer phrases first so alternation prefers "punto interrogativo" over "punto"
         text_keys = sorted(self.text_commands.keys(), key=len, reverse=True)
-        text_cmd_pattern = r"\b(" + "|".join(re.escape(cmd) for cmd in text_keys) + r")\b"
+        self._text_cmd_alternation = "|".join(re.escape(cmd) for cmd in text_keys)
+        text_cmd_pattern = r"\b(" + self._text_cmd_alternation + r")\b"
         self.text_cmd_regex = re.compile(text_cmd_pattern, re.IGNORECASE)
 
         # Create regex pattern for action commands
@@ -267,6 +276,18 @@ class CommandProcessor:
                 "", self.action_cmd_regex.sub("", self.text_cmd_regex.sub("", core))
             )
             segment_text = core if core and not residual.strip() else text
+
+            # End-of-utterance form of _TRAILING_PUNCTUATION: a segment that
+            # ends with a command plus engine marks ("hello new line.") has
+            # no following whitespace for the eater to see, so strip the run
+            # here.  Runs at end-of-string mid-loop are left alone — a mark
+            # there may have been produced by another command's replacement.
+            segment_text = re.sub(
+                r"(\b(?:" + self._text_cmd_alternation + r")\b)[,.!?;:…]+$",
+                r"\1",
+                segment_text.strip(),
+                flags=re.IGNORECASE,
+            )
             processed_text = segment_text.strip()
 
             # Handle action commands
@@ -304,14 +325,14 @@ class CommandProcessor:
                     if replacement in _ATTACH_LEFT_REPLACEMENTS:
                         # Punctuation: drop horizontal space before the spoken phrase
                         processed_text = re.sub(
-                            _ATTACH_LEFT_WS + cmd_pattern + _ATTACH_LEFT_WS,
+                            _ATTACH_LEFT_WS + cmd_pattern + _TRAILING_PUNCTUATION + _ATTACH_LEFT_WS,
                             replacement,
                             processed_text,
                             flags=re.IGNORECASE,
                         )
                     else:
                         processed_text = re.sub(
-                            cmd_pattern,
+                            cmd_pattern + _TRAILING_PUNCTUATION,
                             replacement,
                             processed_text,
                             flags=re.IGNORECASE,