voidx 1.0.0__py3-none-any.whl

voidx/ui/app_components/__init__.py

@@ -0,0 +1 @@
+"""Implementation parts for PromptToolkitTui."""

voidx/ui/app_components/clipboard_image.py

@@ -0,0 +1,245 @@
+"""Clipboard image capture and compression helpers."""
+
+from __future__ import annotations
+
+import platform
+import secrets
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Callable
+
+from voidx.agent.attachments import MAX_IMAGE_ATTACHMENT_BYTES
+
+CLIPBOARD_ATTACHMENT_DIR = ".voidx/attachments"
+KEEP_ORIGINAL_BYTES = 3_000_000
+TARGET_IMAGE_BYTES = 4_000_000
+MAX_IMAGE_EDGE = 2048
+JPEG_QUALITIES = (85, 75, 65, 55)
+
+CaptureClipboardPng = Callable[[Path], str]
+CompressImage = Callable[[Path, Path], bool]
+NameFactory = Callable[[], str]
+
+_CAPTURE_SCRIPT = r"""
+ObjC.import('AppKit');
+ObjC.import('Foundation');
+
+function run(argv) {
+  const outPath = argv[0];
+  const pasteboard = $.NSPasteboard.generalPasteboard;
+  let data = pasteboard.dataForType('public.png');
+
+  if (!data) {
+    const image = $.NSImage.alloc.initWithPasteboard(pasteboard);
+    if (!image) {
+      return 'no_image';
+    }
+    const tiff = image.TIFFRepresentation;
+    if (!tiff) {
+      return 'no_image';
+    }
+    const rep = $.NSBitmapImageRep.imageRepWithData(tiff);
+    if (!rep) {
+      return 'no_image';
+    }
+    data = rep.representationUsingTypeProperties($.NSPNGFileType, $({}));
+  }
+
+  if (!data) {
+    return 'no_image';
+  }
+  return data.writeToFileAtomically(outPath, true) ? 'ok' : 'write_failed';
+}
+"""
+
+
+@dataclass(frozen=True)
+class ClipboardImageResult:
+    status: str
+    message: str
+    rel_path: str = ""
+    size: int = 0
+    compressed: bool = False
+
+    @property
+    def ok(self) -> bool:
+        return self.status == "ok"
+
+
+def paste_clipboard_image(
+    workspace: str,
+    *,
+    capture_clipboard_png: CaptureClipboardPng | None = None,
+    compress_image: CompressImage | None = None,
+    name_factory: NameFactory | None = None,
+) -> ClipboardImageResult:
+    root = Path(workspace).resolve()
+    target_dir = root / CLIPBOARD_ATTACHMENT_DIR
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    stem = name_factory() if name_factory else _attachment_stem()
+    png_path = target_dir / f"{stem}.png"
+    jpg_path = target_dir / f"{stem}.jpg"
+
+    capture = capture_clipboard_png or _capture_clipboard_png
+    status = capture(png_path)
+    if status != "ok":
+        _safe_unlink(png_path)
+        return ClipboardImageResult(status=_result_status(status), message=_capture_message(status))
+
+    if not png_path.exists() or png_path.stat().st_size == 0:
+        _safe_unlink(png_path)
+        return ClipboardImageResult(status="error", message="Clipboard image could not be saved.")
+
+    original_size = png_path.stat().st_size
+    if original_size <= KEEP_ORIGINAL_BYTES:
+        return _ok_result(root, png_path, compressed=False)
+
+    compressor = compress_image or _compress_image_to_jpeg
+    compressed = compressor(png_path, jpg_path)
+    choice = _best_usable_image(png_path, jpg_path if compressed else None)
+    if choice is not None:
+        chosen_path, chosen_compressed = choice
+        for path in (png_path, jpg_path):
+            if path != chosen_path:
+                _safe_unlink(path)
+        return _ok_result(root, chosen_path, compressed=chosen_compressed)
+
+    smallest = _smallest_existing_size(png_path, jpg_path)
+    _safe_unlink(png_path)
+    _safe_unlink(jpg_path)
+    size_text = _format_size(smallest) if smallest else "unknown size"
+    return ClipboardImageResult(
+        status="too_large",
+        message=f"Clipboard image too large after compression: {size_text}",
+    )
+
+
+def _capture_clipboard_png(output_path: Path) -> str:
+    if platform.system() != "Darwin":
+        return "unsupported"
+    try:
+        result = subprocess.run(
+            ["osascript", "-l", "JavaScript", "-e", _CAPTURE_SCRIPT, str(output_path)],
+            capture_output=True,
+            text=True,
+            timeout=8,
+            check=False,
+        )
+    except FileNotFoundError:
+        return "unsupported"
+    except subprocess.TimeoutExpired:
+        return "error: clipboard read timed out"
+
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout).strip()
+        return f"error: {detail or 'clipboard read failed'}"
+    return (result.stdout or "").strip() or "error: clipboard read failed"
+
+
+def _compress_image_to_jpeg(source: Path, destination: Path) -> bool:
+    if platform.system() != "Darwin":
+        return False
+
+    wrote_file = False
+    for quality in JPEG_QUALITIES:
+        try:
+            result = subprocess.run(
+                [
+                    "sips",
+                    "-s",
+                    "format",
+                    "jpeg",
+                    "-s",
+                    "formatOptions",
+                    str(quality),
+                    "--resampleHeightWidthMax",
+                    str(MAX_IMAGE_EDGE),
+                    str(source),
+                    "--out",
+                    str(destination),
+                ],
+                capture_output=True,
+                text=True,
+                timeout=20,
+                check=False,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return wrote_file
+        if result.returncode != 0 or not destination.exists():
+            continue
+        wrote_file = True
+        if destination.stat().st_size <= TARGET_IMAGE_BYTES:
+            return True
+    return wrote_file
+
+
+def _best_usable_image(png_path: Path, jpg_path: Path | None) -> tuple[Path, bool] | None:
+    candidates: list[tuple[int, Path, bool]] = []
+    if png_path.exists():
+        candidates.append((png_path.stat().st_size, png_path, False))
+    if jpg_path is not None and jpg_path.exists():
+        candidates.append((jpg_path.stat().st_size, jpg_path, True))
+    usable = [item for item in candidates if item[0] <= MAX_IMAGE_ATTACHMENT_BYTES]
+    if not usable:
+        return None
+    _, path, compressed = min(usable, key=lambda item: item[0])
+    return path, compressed
+
+
+def _ok_result(root: Path, path: Path, *, compressed: bool) -> ClipboardImageResult:
+    rel_path = path.resolve().relative_to(root).as_posix()
+    size = path.stat().st_size
+    suffix = " (compressed)" if compressed else ""
+    return ClipboardImageResult(
+        status="ok",
+        message=f"Pasted image: {rel_path} ({_format_size(size)}){suffix}",
+        rel_path=rel_path,
+        size=size,
+        compressed=compressed,
+    )
+
+
+def _capture_message(status: str) -> str:
+    if status == "no_image":
+        return "Clipboard does not contain an image."
+    if status == "unsupported":
+        return "Clipboard image paste is only supported on macOS right now."
+    if status == "write_failed":
+        return "Clipboard image could not be written."
+    if status.startswith("error:"):
+        return status.removeprefix("error:").strip() or "Clipboard image paste failed."
+    return "Clipboard image paste failed."
+
+
+def _result_status(status: str) -> str:
+    if status in {"no_image", "unsupported"}:
+        return status
+    return "error"
+
+
+def _smallest_existing_size(*paths: Path) -> int:
+    sizes = [path.stat().st_size for path in paths if path.exists()]
+    return min(sizes) if sizes else 0
+
+
+def _attachment_stem() -> str:
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    return f"clipboard-{timestamp}-{secrets.token_hex(4)}"
+
+
+def _safe_unlink(path: Path) -> None:
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        return
+
+
+def _format_size(size: int) -> str:
+    if size < 1024:
+        return f"{size} B"
+    if size < 1024 * 1024:
+        return f"{size / 1024:.1f} KB"
+    return f"{size / (1024 * 1024):.1f} MB"

voidx/ui/app_components/commands.py

@@ -0,0 +1,18 @@
+"""Prompt completions for the TUI."""
+
+from __future__ import annotations
+
+from prompt_toolkit.completion import Completer, Completion
+
+
+class SlashCommandCompleter(Completer):
+    def __init__(self, commands: list[tuple[str, str]]):
+        self.commands = commands
+
+    def get_completions(self, document, complete_event):
+        text = document.text
+        if text.startswith("/"):
+            p = text.lower()
+            for name, desc in self.commands:
+                if name.lower().startswith(p):
+                    yield Completion(name, start_position=-len(text), display_meta=desc)

voidx/ui/app_components/controls.py

@@ -0,0 +1,29 @@
+"""Prompt-toolkit controls used by the TUI."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.margins import Margin
+from prompt_toolkit.mouse_events import MouseEvent
+
+
+class TranscriptControl(FormattedTextControl):
+    def __init__(self, tui) -> None:
+        self._tui = tui
+        super().__init__(tui._render_body, focusable=False, show_cursor=False)
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> None:
+        return self._tui._handle_body_mouse(mouse_event)
+
+
+class TranscriptScrollbarMargin(Margin):
+    def __init__(self, tui) -> None:
+        self._tui = tui
+
+    def get_width(self, get_ui_content: Callable[[], object]) -> int:
+        return 1
+
+    def create_margin(self, window_render_info: object, width: int, height: int) -> list[tuple[str, str]]:
+        return self._tui._render_scrollbar_margin(height)

voidx/ui/app_components/file_picker.py

@@ -0,0 +1,115 @@
+"""Workspace file picker helpers for @ attachments."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+SKIP_DIRS = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "venv",
+    "node_modules",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    "dist",
+    "build",
+}
+MAX_SCAN_FILES = 5_000
+
+
+@dataclass(frozen=True)
+class AttachmentToken:
+    start: int
+    end: int
+    query: str
+    quoted: bool = False
+
+
+@dataclass(frozen=True)
+class FileCandidate:
+    rel_path: str
+    kind: str
+    size: int
+
+
+def find_attachment_token(text: str, cursor: int) -> AttachmentToken | None:
+    cursor = max(0, min(cursor, len(text)))
+    start = text.rfind("@", 0, cursor)
+    while start != -1:
+        if start == 0 or text[start - 1].isspace():
+            break
+        start = text.rfind("@", 0, start)
+    if start == -1:
+        return None
+    if start + 1 < len(text) and text[start + 1] == '"':
+        closing = text.find('"', start + 2)
+        if closing != -1 and closing < cursor:
+            return None
+        return AttachmentToken(start=start, end=cursor, query=text[start + 2:cursor], quoted=True)
+    token = text[start + 1:cursor]
+    if any(ch.isspace() for ch in token):
+        return None
+    return AttachmentToken(start=start, end=cursor, query=token, quoted=False)
+
+
+def list_file_candidates(workspace: str, query: str, limit: int = 8) -> list[FileCandidate]:
+    root = Path(workspace).resolve()
+    if not root.exists() or not root.is_dir():
+        return []
+    normalized_query = query.strip().lower().replace("\\", "/")
+    candidates: list[FileCandidate] = []
+    scanned = 0
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [name for name in dirnames if name not in SKIP_DIRS and not name.startswith(".")]
+        rel_dir = Path(dirpath).resolve().relative_to(root).as_posix()
+        for filename in filenames:
+            if filename.startswith("."):
+                continue
+            path = Path(dirpath) / filename
+            try:
+                rel_path = path.resolve().relative_to(root).as_posix()
+            except ValueError:
+                continue
+            scanned += 1
+            if scanned > MAX_SCAN_FILES:
+                break
+            rel_lower = rel_path.lower()
+            if normalized_query and normalized_query not in rel_lower:
+                continue
+            candidates.append(FileCandidate(
+                rel_path=rel_path,
+                kind="image" if is_image_file(rel_path) else "file",
+                size=path.stat().st_size,
+            ))
+        if scanned > MAX_SCAN_FILES:
+            break
+    candidates.sort(key=lambda item: (
+        not item.rel_path.lower().startswith(normalized_query),
+        len(item.rel_path),
+        item.rel_path,
+    ))
+    return candidates[:limit]
+
+
+def attachment_token_text(rel_path: str) -> str:
+    if any(ch.isspace() for ch in rel_path):
+        return f'@"{rel_path}"'
+    return f"@{rel_path}"
+
+
+def is_image_file(path: str | Path) -> bool:
+    return Path(path).suffix.lower() in IMAGE_EXTENSIONS
+
+
+def format_size(size: int) -> str:
+    if size < 1024:
+        return f"{size} B"
+    if size < 1024 * 1024:
+        return f"{size / 1024:.1f} KB"
+    return f"{size / (1024 * 1024):.1f} MB"

voidx/ui/app_components/formatting.py

@@ -0,0 +1,187 @@
+"""Formatting helpers for prompt_toolkit TUI rendering."""
+
+from __future__ import annotations
+
+import re
+from io import StringIO
+from typing import Any
+
+from prompt_toolkit.formatted_text import FormattedText, to_formatted_text
+from rich.console import Console
+from rich.text import Text
+
+from voidx.ui.dock_components.formatting import ANSI_LINE_PREFIX
+
+_ANSI_CONSOLE: Console | None = None
+
+
+def _get_ansi_console(width: int) -> Console:
+    global _ANSI_CONSOLE
+    if _ANSI_CONSOLE is None or _ANSI_CONSOLE.width != width:
+        _ANSI_CONSOLE = Console(
+            file=StringIO(),
+            force_terminal=True,
+            color_system="truecolor",
+            width=width,
+        )
+    return _ANSI_CONSOLE
+
+
+def _rich_to_ansi(markup: str, width: int) -> str:
+    console = _get_ansi_console(width)
+    buffer = console.file
+    buffer.seek(0)
+    buffer.truncate()
+    console.print(markup, end="")
+    return buffer.getvalue()
+
+
+def _lines_to_formatted_text(lines: list[str], width: int, *, follow_tail: bool = True) -> FormattedText:
+    console = _get_ansi_console(width)
+    result = []
+
+    for line in lines:
+        marker = line.find(ANSI_LINE_PREFIX)
+        if marker == -1:
+            markup_part = line
+            ansi_part = ""
+        else:
+            markup_part = line[:marker]
+            ansi_part = line[marker + len(ANSI_LINE_PREFIX):]
+
+        if markup_part:
+            try:
+                text = Text.from_markup(markup_part)
+                segments = console.render(text)
+                for segment in segments:
+                    style = segment.style
+                    pt_style = ""
+                    if style:
+                        if style.color:
+                            if style.color.is_system_defined:
+                                pt_style += f"fg:{style.color.name} "
+                            else:
+                                pt_style += f"fg:{style.color.get_truecolor().hex} "
+                        if style.bgcolor:
+                            if style.bgcolor.is_system_defined:
+                                pt_style += f"bg:{style.bgcolor.name} "
+                            else:
+                                pt_style += f"bg:{style.bgcolor.get_truecolor().hex} "
+                        if style.bold:
+                            pt_style += "bold "
+                        if style.italic:
+                            pt_style += "italic "
+                        if style.underline:
+                            pt_style += "underline "
+                        if style.dim:
+                            pt_style += "class:dim "
+                    result.append((pt_style.strip(), segment.text))
+            except Exception:
+                result.append(("", markup_part))
+
+        if ansi_part:
+            from prompt_toolkit.formatted_text.ansi import ANSI
+
+            parsed = ANSI(ansi_part + "\x1b[0m")
+            result.extend(to_formatted_text(parsed))
+
+        result.append(("", "\n"))
+
+    if result and result[-1] == ("", "\n"):
+        result.pop()
+    if result and follow_tail:
+        result.append(("[SetCursorPosition]", ""))
+
+    return FormattedText(result)
+
+
+def _continuation_prefix(line: str) -> str:
+    text = _visible_text(line)
+    leading = len(text) - len(text.lstrip(" "))
+    stripped = text[leading:]
+    extra = 0
+    if stripped.startswith(("• ", "- ", "* ")):
+        extra = 2
+    else:
+        ordered = re.match(r"\d+[.)]\s+", stripped)
+        if ordered:
+            extra = len(ordered.group(0))
+        elif stripped.startswith(("├─ ", "└─ ")):
+            extra = 3
+    return " " * (leading + extra)
+
+
+def _visible_text(line: str) -> str:
+    marker = line.find(ANSI_LINE_PREFIX)
+    if marker == -1:
+        markup_part = line
+        ansi_part = ""
+    else:
+        markup_part = line[:marker]
+        ansi_part = line[marker + len(ANSI_LINE_PREFIX):]
+
+    parts: list[str] = []
+    if markup_part:
+        try:
+            parts.append(Text.from_markup(markup_part).plain)
+        except Exception:
+            parts.append(markup_part)
+    if ansi_part:
+        parts.append(Text.from_ansi(ansi_part).plain)
+    return "".join(parts)
+
+
+def _clip(text: str, width: int) -> str:
+    if width <= 0:
+        return ""
+    if len(text) <= width:
+        return text
+    if width <= 1:
+        return "…"
+    prefix = text[: width - 1].rstrip()
+    last_space = prefix.rfind(" ")
+    if last_space > width // 3:
+        prefix = prefix[:last_space].rstrip()
+    return prefix + "…"
+
+
+def _friendly_choice_label(label: str, value: str, desc: str) -> str:
+    if value == "a":
+        return "Yes, and don't ask again this session"
+    if value == "y":
+        return "Yes, allow once"
+    if value == "n":
+        return "No, deny"
+    return desc or label
+
+
+def _permission_target(args: dict[str, Any]) -> str:
+    for key in ("command", "file_path", "path", "pattern", "url", "query", "agent", "role"):
+        value = args.get(key)
+        if value:
+            return str(value).replace("\n", " ")
+    return ""
+
+
+def _args_preview(args: dict[str, Any]) -> str:
+    parts: list[str] = []
+    for key, value in args.items():
+        if key in {"command", "file_path", "path", "pattern", "url", "query", "agent", "role"}:
+            continue
+        text = str(value).replace("\n", " ")
+        parts.append(f"{key}={text}")
+        if len(parts) >= 3:
+            break
+    return ", ".join(parts)
+
+
+def _mcp_status_label(status: str) -> tuple[str, str]:
+    normalized = status.strip().lower()
+    if normalized in {"connected", "configured", "ready"}:
+        label = "connected" if normalized == "connected" else normalized
+        return ("class:command.ok", f"✓ {label}")
+    if normalized in {"disabled", "off"}:
+        return ("class:command.dim", "disabled")
+    if normalized in {"error", "failed"}:
+        return ("class:command.error", "✗ error")
+    return ("class:command.dim", normalized or "unknown")

voidx/ui/app_components/git_changes.py

@@ -0,0 +1,51 @@
+"""Git change stats for the input bar."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class ChangeStats:
+    files_changed: int = 0
+    insertions: int = 0
+    deletions: int = 0
+    has_changes: bool = False
+
+
+def get_change_stats(workspace: str = ".") -> ChangeStats:
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--shortstat", "--cached"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+            cwd=workspace,
+        )
+        if result.returncode != 0:
+            return ChangeStats()
+        line = result.stdout.strip()
+        if not line:
+            return ChangeStats()
+        return _parse_shortstat(line)
+    except Exception:
+        return ChangeStats()
+
+
+def _parse_shortstat(line: str) -> ChangeStats:
+    stats = ChangeStats()
+    files_part = line.split(",")[0] if "," in line else line
+    if "file" in files_part:
+        num = "".join(c for c in files_part.split()[0] if c.isdigit())
+        stats.files_changed = int(num) if num else 0
+    for part in line.split(","):
+        part = part.strip()
+        if "insertion" in part:
+            num = "".join(c for c in part.split()[0] if c.isdigit())
+            stats.insertions = int(num) if num else 0
+        elif "deletion" in part:
+            num = "".join(c for c in part.split()[0] if c.isdigit())
+            stats.deletions = int(num) if num else 0
+    stats.has_changes = stats.files_changed > 0
+    return stats