voidx-cli 3.5.2__py3-none-any.whl

voidx_cli/clipboard_mixin.py

@@ -0,0 +1,83 @@
+"""Clipboard image paste support for PureTui."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from voidx.ui.tools.clipboard_image import (
+    ClipboardImageResult,
+    paste_clipboard_image as _paste_clipboard_image_from_system,
+)
+from voidx.ui.tools.clipboard_text import (
+    ClipboardTextResult,
+    read_clipboard_text as _read_clipboard_text_from_system,
+)
+
+
+class _ClipboardMixin:
+    def paste_clipboard_image(self, *, quiet_no_image: bool = False) -> ClipboardImageResult:
+        result = _paste_clipboard_image(self.status.workspace)
+        if result.ok:
+            stem = Path(result.rel_path).stem
+            self._insert_text_token(self._register_image_paste(stem, result.size) + " ")
+        if result.ok or not quiet_no_image:
+            self._notice = result.message
+        self.invalidate()
+        return result
+
+    def _paste_clipboard_image_quiet(self) -> None:
+        self.paste_clipboard_image(quiet_no_image=True)
+
+    def paste_clipboard_text(self, *, quiet_no_text: bool = False) -> ClipboardTextResult:
+        result = _read_clipboard_text()
+        if result.ok:
+            self._insert_pasted_text(result.text)
+        if result.ok or not quiet_no_text:
+            self._notice = result.message
+        self.invalidate()
+        return result
+
+    def _paste_clipboard_text_quiet(self) -> ClipboardTextResult:
+        return self.paste_clipboard_text(quiet_no_text=True)
+
+    def _paste_clipboard_quiet(self) -> None:
+        image_result = self.paste_clipboard_image(quiet_no_image=True)
+        if image_result.ok:
+            return
+        if image_result.status not in {"no_image", "unsupported"}:
+            return
+        self._paste_clipboard_text_quiet()
+
+    _CHANGE_COUNT_SCRIPT = (
+        'use framework "AppKit"\n'
+        "set pb to current application's NSPasteboard's generalPasteboard()\n"
+        "return (pb's changeCount) as text"
+    )
+
+    def _read_clipboard_change_count(self) -> int:
+        try:
+            result = subprocess.run(
+                ["osascript", "-e", self._CHANGE_COUNT_SCRIPT],
+                capture_output=True, text=True, timeout=2, check=False,
+            )
+            return int(result.stdout.strip()) if result.returncode == 0 else -1
+        except Exception:
+            return -1
+
+
+def _paste_clipboard_image(workspace: str) -> ClipboardImageResult:
+    app_module = sys.modules.get("voidx_cli.app")
+    paste = getattr(app_module, "paste_clipboard_image_from_system", None)
+    if callable(paste):
+        return paste(workspace)
+    return _paste_clipboard_image_from_system(workspace)
+
+
+def _read_clipboard_text() -> ClipboardTextResult:
+    app_module = sys.modules.get("voidx_cli.app")
+    paste = getattr(app_module, "paste_clipboard_text_from_system", None)
+    if callable(paste):
+        return paste()
+    return _read_clipboard_text_from_system()

voidx_cli/helpers.py

@@ -0,0 +1,144 @@
+"""Shared helpers for TUI modules — ANSI escape constants, pure functions."""
+
+from __future__ import annotations
+
+import re
+
+from rich.cells import cell_len
+from rich.markup import escape as rich_escape
+from rich.text import Text
+
+from voidx.ui.output.dock.formatting import ANSI_LINE_PREFIX
+from voidx.ui.tools.file_picker import FileCandidate, format_size
+
+_ANSI_STRIP_RE = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
+
+_DISABLE_MOUSE_REPORTING = (
+    "\x1b[?9l"
+    "\x1b[?1000l"
+    "\x1b[?1002l"
+    "\x1b[?1003l"
+    "\x1b[?1005l"
+    "\x1b[?1006l"
+    "\x1b[?1015l"
+)
+
+_ENTER_TERMINAL_SEQUENCE = f"{_DISABLE_MOUSE_REPORTING}\x1b[?2004h\x1b[?25l"
+_EXIT_TERMINAL_SEQUENCE = f"{_DISABLE_MOUSE_REPORTING}\x1b[?2004l\x1b[?25h"
+
+
+def _ctrl(key: str) -> bytes:
+    return bytes([ord(key) - 0x60])
+
+
+def _is_printable(data: bytes) -> bool:
+    """Single-byte printable character (including space)."""
+    return len(data) == 1 and 0x20 <= data[0] <= 0x7E
+
+
+def _is_utf8_continuation(b: int) -> bool:
+    return 0x80 <= b <= 0xBF
+
+
+def _utf8_len(first: int) -> int:
+    if first < 0x80:
+        return 1
+    if first < 0xE0:
+        return 2
+    if first < 0xF0:
+        return 3
+    return 4
+
+
+def _csi_modifier_has_shift(mod: int) -> bool:
+    # xterm/CSI-u modifier values are 1 + bitmask, so Shift alone is 2.
+    return mod > 1 and bool((mod - 1) & 1)
+
+
+def _parse_csi_modifier(params: list[str]) -> int:
+    try:
+        return int(params[1]) if len(params) > 1 and params[1] else 0
+    except ValueError:
+        return 0
+
+
+def _escape_markup(text: str) -> str:
+    return rich_escape(text)
+
+
+def _safe_status_value(value: object, fallback: str) -> str:
+    try:
+        text = str(value)
+    except Exception:
+        return fallback
+    return text if text else fallback
+
+
+def _call_status(func: object, fallback: str) -> str:
+    if not callable(func):
+        return fallback
+    try:
+        return _safe_status_value(func(), fallback)
+    except Exception:
+        return fallback
+
+
+def _call_bool(func: object) -> bool:
+    if not callable(func):
+        return False
+    try:
+        return bool(func())
+    except Exception:
+        return False
+
+
+def _call_int(func: object, fallback: int) -> int:
+    if not callable(func):
+        return fallback
+    try:
+        return int(func())
+    except Exception:
+        return fallback
+
+
+def _rendered_row_count(text: str) -> int:
+    if not text:
+        return 0
+    return text.count("\n") + 1
+
+
+def _clip_cells(text: str, width: int) -> str:
+    if width <= 0:
+        return ""
+    if cell_len(text) <= width:
+        return text
+    if width <= 1:
+        return "…"[:width]
+    limit = width - cell_len("…")
+    used = 0
+    result: list[str] = []
+    for char in text:
+        char_width = cell_len(char)
+        if used + char_width > limit:
+            break
+        result.append(char)
+        used += char_width
+    return "".join(result) + "…"
+
+
+def _candidate_meta(candidate: FileCandidate) -> str:
+    if candidate.kind == "dir":
+        return f"  dir · {candidate.size} items"
+    if candidate.kind == "image":
+        return f"  image · {format_size(candidate.size)}"
+    return f"  file · {format_size(candidate.size)}"
+
+
+def _plain_line(line: str) -> str:
+    """Convert a tree render line (Rich markup + possible ANSI) to plain text."""
+    marker = line.find(ANSI_LINE_PREFIX)
+    if marker == -1:
+        return Text.from_markup(line).plain
+    text = Text.from_markup(line[:marker])
+    text.append_text(Text.from_ansi(line[marker + len(ANSI_LINE_PREFIX):]))
+    return text.plain

voidx_cli/input.py

@@ -0,0 +1,370 @@
+"""Line editing — cursor movement, insert/delete, history."""
+
+from __future__ import annotations
+
+
+class _InputEditorMixin:
+    """Methods: _current_line, _set_current_line, _insert_text, _delete_backward,
+    _delete_forward, _insert_newline, _cursor_left, _cursor_right, _cursor_home,
+    _cursor_end, _history_prev, _history_next, _load_history_item, _record_history,
+    _is_input_empty, _get_input_text, _clear_input, _input_cursor_position,
+    _set_input_text_and_cursor, _insert_text_token."""
+
+    # ── line editing ─────────────────────────────────────────────────────
+
+    def _current_line(self) -> str:
+        return self._input_lines[self._cursor_row] if self._input_lines else ""
+
+    def _set_current_line(self, text: str) -> None:
+        if self._input_lines:
+            self._input_lines[self._cursor_row] = text
+
+    # ── paste token registry ─────────────────────────────────────────────
+
+    def _paste_entries_snapshot(self) -> list[dict[str, object]]:
+        return [dict(entry) for entry in getattr(self, "_paste_entries", [])]
+
+    def _restore_paste_entries(self, entries: list[dict[str, object]]) -> None:
+        self._paste_entries = [dict(entry) for entry in entries]
+        max_id = 0
+        for entry in self._paste_entries:
+            try:
+                max_id = max(max_id, int(entry.get("id", 0)))
+            except (TypeError, ValueError):
+                continue
+        self._paste_next_id = max_id + 1
+
+    def _clear_paste_entries(self) -> None:
+        self._paste_entries = []
+        self._paste_next_id = 1
+
+    def _register_paste_entry(self, *, kind: str, display: str, expanded: str) -> str:
+        paste_id = self._paste_next_id
+        self._paste_next_id += 1
+        entry = {
+            "id": paste_id,
+            "kind": kind,
+            "display": display,
+            "expanded": expanded,
+        }
+        self._paste_entries.append(entry)
+        return display
+
+    def _register_text_paste(self, text: str) -> str:
+        paste_id = self._paste_next_id
+        display = self._compute_text_paste_display(paste_id, text)
+        return self._register_paste_entry(kind="text", display=display, expanded=text)
+
+    @staticmethod
+    def _compute_text_paste_display(paste_id: int, text: str) -> str:
+        line_count = len(text.split("\n"))
+        if line_count > 1:
+            return f"[Pasted text #{paste_id} +{line_count - 1} lines]"
+        return f"[Pasted text #{paste_id} {len(text)} chars]"
+
+    def _register_image_paste(self, stem: str, size: int) -> str:
+        from voidx.ui.tools.attachment_tokens import image_attachment_token_text
+
+        paste_id = self._paste_next_id
+        display = f"[Pasted image #{paste_id} {self._format_paste_size(size)}]"
+        return self._register_paste_entry(
+            kind="image",
+            display=display,
+            expanded=image_attachment_token_text(stem),
+        )
+
+    def _expand_registered_tokens(
+        self,
+        text: str,
+        entries: list[dict[str, object]] | None = None,
+    ) -> str:
+        result = text
+        for entry in entries if entries is not None else self._paste_entries:
+            display = str(entry.get("display", ""))
+            expanded = str(entry.get("expanded", ""))
+            if display:
+                if entry.get("kind") == "text":
+                    expanded = f"<pasted>\n{expanded}\n</pasted>"
+                result = result.replace(display, expanded)
+        return result
+
+    @staticmethod
+    def _format_paste_size(size: int) -> str:
+        if size < 1024:
+            return f"{size}B"
+        if size < 1024 * 1024:
+            return f"{round(size / 1024)}KB"
+        return f"{size / (1024 * 1024):.1f}MB"
+
+    def _registered_paste_displays(self) -> list[tuple[str, str]]:
+        displays = []
+        for entry in getattr(self, "_paste_entries", []):
+            display = str(entry.get("display", ""))
+            kind = str(entry.get("kind", "text"))
+            if display:
+                displays.append((display, kind))
+        displays.sort(key=lambda item: len(item[0]), reverse=True)
+        return displays
+
+    def _clear_attachment_suppression_on_edit(self) -> None:
+        self._attachment_panel_suppressed_text = ""
+        self._skill_panel_suppressed_text = ""
+
+    def _insert_text(self, text: str) -> None:
+        if self._active_choice is not None:
+            if len(text) != 1 or not text.isascii():
+                return
+            quick = text.lower()
+            for label, value, _desc in self._active_choice:
+                if len(label) == 1 and label.lower() == quick:
+                    self._finish_choice(value)
+                    self.invalidate()
+                    return
+            return
+
+        self._reset_ctrl_c()
+        line = self._current_line()
+        col = min(self._cursor_col, len(line))
+        new_line = line[:col] + text + line[col:]
+        self._set_current_line(new_line)
+        self._cursor_col = col + len(text)
+        self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()
+
+    def _delete_backward(self) -> None:
+        if self._active_choice is not None:
+            return
+        self._reset_ctrl_c()
+        if self._cursor_col > 0:
+            line = self._current_line()
+            col = self._cursor_col
+            new_line = line[: col - 1] + line[col:]
+            self._set_current_line(new_line)
+            self._cursor_col -= 1
+            self._clear_attachment_suppression_on_edit()
+        elif self._cursor_row > 0:
+            # Join with previous line
+            prev_line = self._input_lines[self._cursor_row - 1]
+            cur_line = self._current_line()
+            new_cursor = len(prev_line)
+            self._input_lines[self._cursor_row - 1] = prev_line + cur_line
+            del self._input_lines[self._cursor_row]
+            self._cursor_row -= 1
+            self._cursor_col = new_cursor
+            self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()
+
+    def _delete_forward(self) -> None:
+        if self._active_choice is not None:
+            return
+        self._reset_ctrl_c()
+        line = self._current_line()
+        col = min(self._cursor_col, len(line))
+        if col < len(line):
+            new_line = line[:col] + line[col + 1 :]
+            self._set_current_line(new_line)
+            self._clear_attachment_suppression_on_edit()
+        elif self._cursor_row < len(self._input_lines) - 1:
+            # Join with next line
+            next_line = self._input_lines[self._cursor_row + 1]
+            self._input_lines[self._cursor_row] = line + next_line
+            del self._input_lines[self._cursor_row + 1]
+            self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()
+
+    def _insert_newline(self) -> None:
+        if self._active_choice is not None:
+            return
+        self._reset_ctrl_c()
+        line = self._current_line()
+        col = min(self._cursor_col, len(line))
+        before = line[:col]
+        after = line[col:]
+        self._input_lines[self._cursor_row] = before
+        self._input_lines.insert(self._cursor_row + 1, after)
+        self._cursor_row += 1
+        self._cursor_col = 0
+        self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()
+
+    def _cursor_left(self) -> None:
+        if self._active_choice is not None:
+            return
+        if self._cursor_col > 0:
+            self._cursor_col -= 1
+        elif self._cursor_row > 0:
+            self._cursor_row -= 1
+            self._cursor_col = len(self._current_line())
+        self._update_input_panels()
+
+    def _cursor_right(self) -> None:
+        if self._active_choice is not None:
+            return
+        line = self._current_line()
+        if self._cursor_col < len(line):
+            self._cursor_col += 1
+        elif self._cursor_row < len(self._input_lines) - 1:
+            self._cursor_row += 1
+            self._cursor_col = 0
+        self._update_input_panels()
+
+    def _cursor_home(self) -> None:
+        if self._active_choice is not None:
+            return
+        self._cursor_col = 0
+        self._update_input_panels()
+
+    def _cursor_end(self) -> None:
+        if self._active_choice is not None:
+            return
+        self._cursor_col = len(self._current_line())
+        self._update_input_panels()
+
+    def _clamp_cursor_col(self) -> None:
+        self._cursor_col = min(self._cursor_col, len(self._current_line()))
+
+    def _cursor_up_or_history(self) -> None:
+        if self._cursor_row > 0:
+            self._cursor_row -= 1
+            self._clamp_cursor_col()
+            self._update_input_panels()
+            return
+        self._history_prev()
+
+    def _cursor_down_or_history(self) -> None:
+        if self._cursor_row < len(self._input_lines) - 1:
+            self._cursor_row += 1
+            self._clamp_cursor_col()
+            self._update_input_panels()
+            return
+        self._history_next()
+
+    # ── history ──────────────────────────────────────────────────────────
+
+    def _history_prev(self) -> None:
+        if self._active_choice is not None or not self._input_history:
+            return
+        self._reset_ctrl_c()
+        if self._history_idx == -1:
+            self._history_draft = list(self._input_lines)
+            self._history_draft_paste_entries = self._paste_entries_snapshot()
+            self._history_idx = len(self._input_history) - 1
+        elif self._history_idx > 0:
+            self._history_idx -= 1
+        self._load_history_item()
+
+    def _history_next(self) -> None:
+        if self._active_choice is not None:
+            return
+        if self._history_idx == -1:
+            return
+        self._reset_ctrl_c()
+        self._history_idx += 1
+        if self._history_idx >= len(self._input_history):
+            self._history_idx = -1
+            self._input_lines = list(self._history_draft)
+            self._restore_paste_entries(self._history_draft_paste_entries)
+            self._cursor_row = len(self._input_lines) - 1
+            self._cursor_col = len(self._current_line())
+            self._clear_attachment_suppression_on_edit()
+            self._update_input_panels()
+            return
+        self._load_history_item()
+
+    def _load_history_item(self) -> None:
+        if 0 <= self._history_idx < len(self._input_history):
+            text = self._input_history[self._history_idx]
+            self._input_lines = text.split("\n")
+            if 0 <= self._history_idx < len(self._input_history_paste_entries):
+                self._restore_paste_entries(self._input_history_paste_entries[self._history_idx])
+            else:
+                self._clear_paste_entries()
+            self._cursor_row = len(self._input_lines) - 1
+            self._cursor_col = len(self._current_line())
+            self._clear_attachment_suppression_on_edit()
+            self._update_input_panels()
+
+    def _record_history(self, text: str, paste_entries: list[dict[str, object]] | None = None) -> None:
+        stripped = text.strip()
+        if stripped and (not self._input_history or self._input_history[-1] != stripped):
+            self._input_history.append(stripped)
+            self._input_history_paste_entries.append([dict(entry) for entry in (paste_entries or [])])
+            limit = max(int(self.INPUT_HISTORY_LIMIT), 0)
+            if limit == 0:
+                self._input_history.clear()
+                self._input_history_paste_entries.clear()
+            elif len(self._input_history) > limit:
+                overflow = len(self._input_history) - limit
+                del self._input_history[:overflow]
+                del self._input_history_paste_entries[:overflow]
+        self._history_idx = -1
+
+    # ── input helpers ────────────────────────────────────────────────────
+
+    def _is_input_empty(self) -> bool:
+        return len(self._input_lines) == 1 and not self._input_lines[0]
+
+    def _get_input_text(self) -> str:
+        return "\n".join(self._input_lines)
+
+    def _clear_input(self) -> None:
+        self._input_lines = [""]
+        self._cursor_row = 0
+        self._cursor_col = 0
+        self._command_panel_active = False
+        self._attachment_selected = 0
+        self._attachment_panel_suppressed_text = ""
+        self._attachment_matches_cache_key = None
+        self._attachment_matches_cache = []
+        self._skill_selected = 0
+        self._skill_panel_suppressed_text = ""
+        self._skill_matches_cache_key = None
+        self._skill_matches_cache = []
+        self._clear_paste_entries()
+
+    def _input_cursor_position(self) -> int:
+        """Return the logical character offset used by attachment-token parsing."""
+        cursor = 0
+        for row in range(min(self._cursor_row, len(self._input_lines))):
+            cursor += len(self._input_lines[row]) + 1
+        if self._input_lines:
+            cursor += min(self._cursor_col, len(self._current_line()))
+        return cursor
+
+    def _set_input_text_and_cursor(self, text: str, cursor: int) -> None:
+        self._input_lines = text.split("\n") or [""]
+        cursor = max(0, min(cursor, len(text)))
+        before = text[:cursor]
+        self._cursor_row = before.count("\n")
+        last_newline = before.rfind("\n")
+        self._cursor_col = len(before) if last_newline == -1 else len(before) - last_newline - 1
+        self._clear_attachment_suppression_on_edit()
+
+    def _insert_text_token(self, token: str) -> None:
+        self._reset_ctrl_c()
+        line = self._current_line()
+        col = min(self._cursor_col, len(line))
+        self._set_current_line(line[:col] + token + line[col:])
+        self._cursor_col = col + len(token)
+        self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()
+
+    def _replace_token_in_editor(self, old_token: str, new_token: str) -> None:
+        """Replace a token string in the input with an updated version.
+
+        Used when merging split-batch pastes: the old token (e.g.
+        "[Pasted text #1 +3 lines]") is replaced in-place by the new
+        token (e.g. "[Pasted text #1 +4 lines]") with updated line count.
+        """
+        self._reset_ctrl_c()
+        line = self._current_line()
+        idx = line.rfind(old_token)
+        if idx == -1:
+            # Token not found on current line — fall back to inserting new
+            self._insert_text_token(new_token)
+            return
+        new_line = line[:idx] + new_token + line[idx + len(old_token):]
+        self._set_current_line(new_line)
+        self._cursor_col = idx + len(new_token)
+        self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()