voidx 3.4.1__tar.gz → 3.4.2__tar.gz

{voidx-3.4.1/src/voidx.egg-info → voidx-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.1
+Version: 3.4.2
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/__init__.py

@@ -1,3 +1,3 @@
 """VoidX - A coding agent that quantifies everything."""
 
-__version__ = "3.4.1"
+__version__ = "3.4.2"

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/agent/attachments.py

@@ -152,9 +152,23 @@ def is_image_path(path: Path | str) -> bool:
     return Path(path).suffix.lower() in IMAGE_EXTENSIONS
 
 
+_PASTED_RE = re.compile(r"<pasted>\n.*?\n</pasted>", re.DOTALL)
+
+
+def _pasted_spans(text: str) -> list[tuple[int, int]]:
+    """Return (start, end) spans of all <pasted>...</pasted> blocks."""
+    return [(m.start(), m.end()) for m in _PASTED_RE.finditer(text)]
+
+
 def _attachment_tokens(text: str) -> list[tuple[int, int, str]]:
     tokens: list[tuple[int, int, str]] = []
+    excluded = _pasted_spans(text)
     for match in _ATTACHMENT_RE.finditer(text):
+        # Skip @-references and [image-] tokens inside <pasted> blocks —
+        # pasted content is quoted material (e.g. code with decorators),
+        # not user-authored attachment references.
+        if any(start <= match.start() < end for start, end in excluded):
+            continue
         image_stem = match.group(3)
         if image_stem:
             raw_path = f":image:{image_stem}"

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/ui/output/dock/app.py

@@ -7,17 +7,15 @@ from typing import Any, Callable, Sequence
 
 from rich.console import Console, Group
 from rich.live import Live
-from rich.markup import escape
 from rich.text import Text
 
+from rich.markup import escape
+
 from voidx.ui.output.dock.formatting import (
     ANSI_LINE_PREFIX,
-    _ansi_line,
     _clean,
-    _markdown_lines,
-    _strip_ansi_trailing_space,
+    _PASTED_RE,
     _text_from_line,
-    split_pasted_segments,
 )
 from voidx.ui.output.dock.nodes import DockNodeMixin
 from voidx.ui.output.dock.stream import DockStreamMixin
@@ -222,12 +220,13 @@ class BottomInputDock(DockStreamMixin, DockStatusMixin, DockNodeMixin):
         if self._tree.root.children:
             self._append_root_spacer()
         preview = _clean(text)
-        segments = split_pasted_segments(preview)
-        header, body_lines = self._render_turn_segments(segments)
+        preview = _PASTED_RE.sub(r"\1", preview)
+        header, body_lines = self._render_turn_text(preview)
+        header = f"[bold white]❯[/] {header}" if header else "[bold white]❯[/]"
         self._current_turn = self._tree.new_node(
             parent=self._tree.root,
             node_type="turn",
-            header=f"[bold white]❯[/] {header}",
+            header=header,
             body_lines=body_lines,
             collapsed=False,
         )
@@ -235,40 +234,17 @@ class BottomInputDock(DockStreamMixin, DockStatusMixin, DockNodeMixin):
         self.refresh()
         return self._current_turn
 
-    def _render_turn_segments(
-        self, segments: list[tuple[bool, str]]
-    ) -> tuple[str, list[str]]:
-        """Render (is_pasted, content) segments into (header, body_lines).
+    def _render_turn_text(self, text: str) -> tuple[str, list[str]]:
+        """Render user turn text into (header, body_lines) as plain text.
 
-        Non-pasted segments use escape() plain text (existing behavior).
-        Pasted segments use _markdown_lines() with _ansi_line() wrapping.
+        <pasted> wrapper tags are stripped (content kept), then the entire
+        text is rendered as escaped plain text — no markdown formatting.
         """
-        header = ""
-        body_lines: list[str] = []
-        width = self._markdown_width()
-        for index, (is_pasted, content) in enumerate(segments):
-            if is_pasted:
-                md_lines = [
-                    _ansi_line(line)
-                    for line in _markdown_lines(content, width)
-                ]
-                if index == 0 and md_lines:
-                    header = md_lines[0]
-                    body_lines.extend(md_lines[1:])
-                else:
-                    body_lines.extend(md_lines)
-            else:
-                lines = [
-                    _strip_ansi_trailing_space(line)
-                    for line in ((content.splitlines() or [content]) if content else [])
-                ]
-                if index == 0 and lines:
-                    header = escape(lines[0])
-                    body_lines.extend(escape(line) for line in lines[1:])
-                else:
-                    body_lines.extend(escape(line) for line in lines)
-        if not header and body_lines:
-            header = body_lines.pop(0)
+        lines = text.splitlines() or [text] if text else []
+        if not lines:
+            return "", []
+        header = escape(lines[0])
+        body_lines = [escape(line) for line in lines[1:]]
         return header, body_lines
 
     def ensure_agent(self) -> OutputNode:

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/ui/output/tree.py

@@ -14,6 +14,27 @@ from rich.text import Text
 USER_ROW_STYLE = "white on #3a3937"
 TOOL_META_BRANCH = "[dim]└[/dim] "
 
+# Must match voidx.ui.output.dock.formatting.ANSI_LINE_PREFIX.
+# Duplicated here to avoid circular imports (formatting imports from dock,
+# dock imports from tree).
+_ANSI_LINE_PREFIX = "\x00voidx-ansi\x00"
+
+
+def _visible_len(line: str) -> int:
+    """Compute visible cell length of a render line safely.
+
+    Lines may contain an ANSI_LINE_PREFIX marker separating rich-markup text
+    from ANSI-styled text (pasted segments).  The ANSI portion can contain
+    arbitrary characters including ``[/]`` that would crash Text.from_markup,
+    so it is parsed with Text.from_ansi instead.
+    """
+    marker = line.find(_ANSI_LINE_PREFIX)
+    if marker == -1:
+        return cell_len(Text.from_markup(line).plain)
+    text = Text.from_markup(line[:marker])
+    text.append_text(Text.from_ansi(line[marker + len(_ANSI_LINE_PREFIX):]))
+    return cell_len(text.plain)
+
 
 @dataclass
 class OutputNode:
@@ -617,15 +638,29 @@ class OutputTree:
 
 
 def _full_width_row(line: str, width: int) -> str:
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
-    return f"[{USER_ROW_STYLE}]{line}{padding}[/]"
+    return _wrap_full_width(line, padding, USER_ROW_STYLE)
 
 
 def _permission_row(line: str, width: int) -> str:
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
-    return f"[white on #3a3937]{line}{padding}[/]"
+    return _wrap_full_width(line, padding, "white on #3a3937")
+
+
+def _wrap_full_width(line: str, padding: str, style: str) -> str:
+    """Wrap a line with a background style and padding to full width.
+
+    When the line contains an ANSI_LINE_PREFIX marker, the closing tag and
+    padding must go *before* the marker so that _text_from_line parses them
+    with Text.from_markup (which understands tags) rather than leaving them
+    as literal text in the Text.from_ansi portion.
+    """
+    marker = line.find(_ANSI_LINE_PREFIX)
+    if marker == -1:
+        return f"[{style}]{line}{padding}[/]"
+    return f"[{style}]{line[:marker]}{padding}[/]{line[marker:]}"
 
 
 def _is_full_width_user_row(node: OutputNode) -> bool:
@@ -644,7 +679,7 @@ def _pad_diff_background_row(line: str, width: int) -> str:
         marker = "[/on #4a0000]"
     if not marker:
         return line
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
     return line.replace(marker, f"{padding}{marker}", 1)
 

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/ui/tui/panels.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from voidx.config import Settings
 from voidx.skills.service import SkillRegistry, SkillService
+from voidx.ui.output.dock.formatting import _PASTED_RE
 from voidx.ui.tools.attachment_tokens import attachment_token_text
 from voidx.ui.tools.file_picker import (
     AttachmentToken,
@@ -37,7 +38,12 @@ class _PanelManagerMixin:
     # ── submit ───────────────────────────────────────────────────────────
 
     def _submit_text_prompt(self) -> None:
-        value = self._get_input_text()
+        value = self._expand_registered_tokens(self._get_input_text())
+        # Clarify answers are plain text — strip <pasted> wrapper tags that
+        # _expand_registered_tokens adds (those tags are only consumed by the
+        # main input path's split_pasted_segments in start_turn rendering).
+        value = _PASTED_RE.sub(r"\1", value)
+        self._paste_entries.clear()
         self._text_queue.put_nowait(value)
 
     def _cancel_text_prompt(self) -> None:

{voidx-3.4.1 → voidx-3.4.2}/src/voidx/ui/tui/parser.py

@@ -101,9 +101,13 @@ class _InputParserMixin:
         (multiple newlines or a long run), wraps them in a bracketed-paste
         sequence so ``_process_paste`` handles them as a unit.
 
-        Works with ANY first character, not just newlines — pasted text
-        often starts with a regular character (e.g. "line1\\r\\nline2").
-        Returns the bracketed-paste bytes, or ``None`` if this is not a paste.
+        Returns the bracketed-paste bytes when the drained content looks
+        like a paste. Returns the raw bytes of ALL drained characters
+        (including ``first_char``) when they don't look like a paste —
+        this lets the caller process them in arrival order without
+        stashing extras into ``_pending_bytes``, which previously caused
+        IME/keyboard characters to be reordered across reads. Returns
+        ``None`` when nothing follows ``first_char`` (a single keypress).
         """
         import msvcrt
         import time
@@ -132,12 +136,11 @@ class _InputParserMixin:
         newline_count = buffer.count("\r") + buffer.count("\n")
         if newline_count >= 2 or len(buffer) > 8:
             return b"\x1b[200~" + buffer.encode("utf-8", errors="replace") + b"\x1b[201~"
-        # Not a paste: preserve any extra chars we consumed so they are
-        # processed on the next _process_input call instead of being lost.
-        extra = buffer[1:]
-        if extra:
-            self._pending_bytes = extra.encode("utf-8", errors="replace")
-        return None
+        # Not a paste: return all drained chars as raw bytes so the caller
+        # processes them in arrival order. Previously, only first_char was
+        # returned and the rest was stashed in _pending_bytes, which caused
+        # fast IME/keyboard input to be reordered across reads.
+        return buffer.encode("utf-8", errors="replace")
 
     async def _read_input_line(self) -> bytes:
         """Fallback: read a line from stdin (not a tty)."""

{voidx-3.4.1 → voidx-3.4.2/src/voidx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.1
+Version: 3.4.2
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT