vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/ui/latex.py

@@ -0,0 +1,349 @@
+"""LaTeX math-to-Unicode converter.
+
+Adapted from innomd by Innomatica GmbH (MIT License).
+Source: https://github.com/Innomatica-GmbH/innomd
+Commit: 35021c740a44d197cae4e8c0ab142e0b5e0cdaec
+"""
+
+import re
+
+GREEK = {
+    r"\alpha": "α",
+    r"\beta": "β",
+    r"\gamma": "γ",
+    r"\delta": "δ",
+    r"\epsilon": "ε",
+    r"\varepsilon": "ε",
+    r"\zeta": "ζ",
+    r"\eta": "η",
+    r"\theta": "θ",
+    r"\vartheta": "ϑ",
+    r"\iota": "ι",
+    r"\kappa": "κ",
+    r"\lambda": "λ",
+    r"\mu": "μ",
+    r"\nu": "ν",
+    r"\xi": "ξ",
+    r"\pi": "π",
+    r"\varpi": "ϖ",
+    r"\rho": "ρ",
+    r"\varrho": "ϱ",
+    r"\sigma": "σ",
+    r"\varsigma": "ς",
+    r"\tau": "τ",
+    r"\upsilon": "υ",
+    r"\phi": "φ",
+    r"\varphi": "ϕ",
+    r"\chi": "χ",
+    r"\psi": "ψ",
+    r"\omega": "ω",
+    r"\Gamma": "Γ",
+    r"\Delta": "Δ",
+    r"\Theta": "Θ",
+    r"\Lambda": "Λ",
+    r"\Xi": "Ξ",
+    r"\Pi": "Π",
+    r"\Sigma": "Σ",
+    r"\Upsilon": "Υ",
+    r"\Phi": "Φ",
+    r"\Psi": "Ψ",
+    r"\Omega": "Ω",
+    r"\hbar": "ℏ",
+    r"\ell": "ℓ",
+    r"\Re": "ℜ",
+    r"\Im": "ℑ",
+}
+
+OPERATORS = {
+    r"\cdot": "·",
+    r"\times": "×",
+    r"\div": "÷",
+    r"\pm": "±",
+    r"\mp": "∓",
+    r"\ast": "∗",
+    r"\star": "⋆",
+    r"\circ": "∘",
+    r"\bullet": "•",
+    r"\leq": "≤",
+    r"\le": "≤",
+    r"\geq": "≥",
+    r"\ge": "≥",
+    r"\neq": "≠",
+    r"\ne": "≠",
+    r"\approx": "≈",
+    r"\equiv": "≡",
+    r"\sim": "∼",
+    r"\simeq": "≃",
+    r"\cong": "≅",
+    r"\propto": "∝",
+    r"\ll": "≪",
+    r"\gg": "≫",
+    r"\infty": "∞",
+    r"\partial": "∂",
+    r"\nabla": "∇",
+    r"\prime": "′",
+    r"\sum": "∑",
+    r"\prod": "∏",
+    r"\coprod": "∐",
+    r"\int": "∫",
+    r"\iint": "∬",
+    r"\iiint": "∭",
+    r"\oint": "∮",
+    r"\sqrt": "√",
+    r"\rightarrow": "→",
+    r"\to": "→",
+    r"\leftarrow": "←",
+    r"\gets": "←",
+    r"\Rightarrow": "⇒",
+    r"\Leftarrow": "⇐",
+    r"\Leftrightarrow": "⇔",
+    r"\leftrightarrow": "↔",
+    r"\uparrow": "↑",
+    r"\downarrow": "↓",
+    r"\mapsto": "↦",
+    r"\longrightarrow": "⟶",
+    r"\longleftarrow": "⟵",
+    r"\in": "∈",
+    r"\notin": "∉",
+    r"\ni": "∋",
+    r"\subset": "⊂",
+    r"\supset": "⊃",
+    r"\subseteq": "⊆",
+    r"\supseteq": "⊇",
+    r"\cup": "∪",
+    r"\cap": "∩",
+    r"\setminus": "∖",
+    r"\emptyset": "∅",
+    r"\varnothing": "∅",
+    r"\forall": "∀",
+    r"\exists": "∃",
+    r"\nexists": "∄",
+    r"\neg": "¬",
+    r"\land": "∧",
+    r"\wedge": "∧",
+    r"\lor": "∨",
+    r"\vee": "∨",
+    r"\therefore": "∴",
+    r"\because": "∵",
+    r"\ldots": "…",
+    r"\cdots": "⋯",
+    r"\vdots": "⋮",
+    r"\ddots": "⋱",
+    r"\dots": "…",
+    r"\quad": " ",
+    r"\qquad": " ",
+    r"\,": " ",
+    r"\;": " ",
+    r"\:": " ",
+    r"\!": "",
+    r"\ ": " ",
+    r"\%": "%",
+    r"\$": "$",
+    r"\&": "&",
+    r"\#": "#",
+    r"\_": "_",
+    r"\{": "{",
+    r"\}": "}",
+    r"\deg": "°",
+    r"\degree": "°",
+    r"\langle": "⟨",
+    r"\rangle": "⟩",
+    r"\lfloor": "⌊",
+    r"\rfloor": "⌋",
+    r"\lceil": "⌈",
+    r"\rceil": "⌉",
+    r"\aleph": "ℵ",
+    r"\Box": "□",
+    r"\Diamond": "◇",
+    r"\triangle": "△",
+    r"\mathbb{R}": "ℝ",
+    r"\mathbb{N}": "ℕ",
+    r"\mathbb{Z}": "ℤ",
+    r"\mathbb{Q}": "ℚ",
+    r"\mathbb{C}": "ℂ",
+    r"\mathbb{P}": "ℙ",
+    r"\mathcal{L}": "ℒ",
+    r"\mathcal{H}": "ℋ",
+    r"\left": "",
+    r"\right": "",
+    r"\bigl": "",
+    r"\bigr": "",
+    r"\big": "",
+    r"\Big": "",
+    r"\Bigg": "",
+    r"\displaystyle": "",
+    r"\textstyle": "",
+    r"\scriptstyle": "",
+}
+
+SUPERSCRIPT = str.maketrans(
+    "0123456789+-=()nabcdefghijklmoprstuvwxyzABDEGHIJKLMNOPRTUVW",
+    "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿᵃᵇᶜᵈᵉᶠᵍʰᵢʲᵏˡᵐᵒʳˢᵗᵘᵛʷʸᵚᵜᵝᵞᵟᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁ",
+)
+SUBSCRIPT = str.maketrans("0123456789+-=()aehijklmnoprstuvx", "₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓ")
+_SYMBOL_ITEMS = sorted(list(GREEK.items()) + list(OPERATORS.items()), key=lambda x: -len(x[0]))
+_SQRT_INDEX_RE = re.compile(r"\\sqrt\[([^\]]+)\]\{([^{}]+)\}")
+_DISPLAY_DOLLAR_RE = re.compile(r"\$\$(.+?)\$\$", re.DOTALL)
+_DISPLAY_BRACKET_RE = re.compile(r"\\\[(.+?)\\\]", re.DOTALL)
+_INLINE_DOLLAR_RE = re.compile(r"(?<!\$)\$(.+?)\$(?!\$)")
+_INLINE_PAREN_RE = re.compile(r"\\\((.+?)\\\)")
+_FENCE_RE = re.compile(r"(^```.*?^```)", re.DOTALL | re.MULTILINE)
+
+
+def _to_super(s: str) -> str:
+    if s and all(c in "0123456789+-=()nabcdefghijklmoprstuvwxyzABDEGHIJKLMNOPRTUVW" for c in s):
+        return s.translate(SUPERSCRIPT)
+    if len(s) == 1:
+        return "^" + s
+    return "^(" + s + ")"
+
+
+def _to_sub(s: str) -> str:
+    if s and all(c in "0123456789+-=()aehijklmnoprstuvx" for c in s):
+        return s.translate(SUBSCRIPT)
+    if len(s) == 1:
+        return "_" + s
+    return "_(" + s + ")"
+
+
+def _balanced_groups(s: str, start: int) -> tuple[str, int] | None:
+    if start >= len(s) or s[start] != "{":
+        return None
+    depth = 0
+    for i in range(start, len(s)):
+        if s[i] == "{":
+            depth += 1
+        elif s[i] == "}":
+            depth -= 1
+            if depth == 0:
+                return s[start + 1 : i], i + 1
+    return None
+
+
+def _replace_command_with_groups(text: str, name: str, n_args: int, fn) -> str:
+    out = []
+    i = 0
+    pattern = "\\" + name
+    while i < len(text):
+        if text.startswith(pattern, i):
+            after = i + len(pattern)
+            if after < len(text) and text[after].isalpha():
+                out.append(text[i])
+                i += 1
+                continue
+            args = []
+            j = after
+            while j < len(text) and text[j] == " ":
+                j += 1
+            ok = True
+            for _ in range(n_args):
+                grp = _balanced_groups(text, j)
+                if grp is None:
+                    ok = False
+                    break
+                args.append(grp[0])
+                j = grp[1]
+            if ok:
+                out.append(fn(args))
+                i = j
+                continue
+        out.append(text[i])
+        i += 1
+    return "".join(out)
+
+
+def _convert_math(tex: str) -> str:
+    s = tex
+    for _ in range(3):
+        for cmd in (
+            "text",
+            "mathrm",
+            "mathbf",
+            "mathit",
+            "mathsf",
+            "mathtt",
+            "operatorname",
+            "textbf",
+            "textit",
+        ):
+            s = _replace_command_with_groups(s, cmd, 1, lambda a: a[0])
+    for _ in range(4):
+        s = _replace_command_with_groups(
+            s,
+            "frac",
+            2,
+            lambda a: (
+                f"({a[0]})/({a[1]})"
+                if any(c in a[0] + a[1] for c in "+-**·× ")
+                else f"{a[0]}/{a[1]}"
+            ),
+        )
+        s = _replace_command_with_groups(
+            s,
+            "dfrac",
+            2,
+            lambda a: (
+                f"({a[0]})/({a[1]})"
+                if any(c in a[0] + a[1] for c in "+-**·× ")
+                else f"{a[0]}/{a[1]}"
+            ),
+        )
+        s = _replace_command_with_groups(
+            s,
+            "tfrac",
+            2,
+            lambda a: (
+                f"({a[0]})/({a[1]})"
+                if any(c in a[0] + a[1] for c in "+-**·× ")
+                else f"{a[0]}/{a[1]}"
+            ),
+        )
+    s = _SQRT_INDEX_RE.sub(lambda m: _to_super(m.group(1)) + "√(" + m.group(2) + ")", s)
+    s = _replace_command_with_groups(s, "sqrt", 1, lambda a: "√(" + a[0] + ")")
+    s = _replace_command_with_groups(s, "vec", 1, lambda a: a[0] + "⃗")
+    s = _replace_command_with_groups(s, "hat", 1, lambda a: a[0] + "̂")
+    s = _replace_command_with_groups(s, "bar", 1, lambda a: a[0] + "̄")
+    s = _replace_command_with_groups(s, "dot", 1, lambda a: a[0] + "̇")
+    for k, v in _SYMBOL_ITEMS:
+        if k and k[-1].isalpha():
+            s = re.sub(re.escape(k) + r"(?![A-Za-z])", v, s)
+        else:
+            s = s.replace(k, v)
+    s = re.sub(r"\^\{([^{}]+)\}", lambda m: _to_super(m.group(1)), s)
+    s = re.sub(r"_\{([^{}]+)\}", lambda m: _to_sub(m.group(1)), s)
+    s = re.sub(r"\^(\\?[A-Za-z0-9+\-])", lambda m: _to_super(m.group(1).lstrip("\\")), s)
+    s = re.sub(r"_(\\?[A-Za-z0-9+\-])", lambda m: _to_sub(m.group(1).lstrip("\\")), s)
+    prev = None
+    while prev != s:
+        prev = s
+        s = re.sub(r"\{([^{}]*)\}", r"\1", s)
+    s = re.sub(r"[ \t]+", " ", s).strip()
+    return s
+
+
+def preprocess_latex(text: str) -> str:
+    r"""Convert LaTeX math delimiters in *text* to Unicode, leaving code fences untouched.
+
+    Handles inline ``$...$``, ``\(...\)``, display ``$$...$$``, and ``\[...\]``.
+    Math inside fenced code blocks (`` ``` ``) is preserved verbatim.
+    """
+    if "$" not in text and "\\(" not in text and "\\[" not in text:
+        return text
+
+    def _process_part(part: str) -> str:
+        part = _DISPLAY_DOLLAR_RE.sub(lambda m: "\n\n" + _convert_math(m.group(1)) + "\n\n", part)
+        part = _DISPLAY_BRACKET_RE.sub(lambda m: "\n\n" + _convert_math(m.group(1)) + "\n\n", part)
+        part = _INLINE_DOLLAR_RE.sub(lambda m: _convert_math(m.group(1)), part)
+        return _INLINE_PAREN_RE.sub(lambda m: _convert_math(m.group(1)), part)
+
+    if "```" not in text:
+        return _process_part(text)
+
+    parts = _FENCE_RE.split(text)
+    out = []
+    for part in parts:
+        if part.startswith("```"):
+            out.append(part)
+            continue
+        out.append(_process_part(part))
+    return "".join(out)

vtx/ui/launch.py

@@ -0,0 +1,108 @@
+"""TUI entrypoint and the exit summary printed after the app closes."""
+
+from __future__ import annotations
+
+import argparse
+import time
+
+from rich.console import Console
+
+from vtx import config
+
+from .app import Vtx
+
+_LOGO = [
+    "██╗   ██╗████████╗██╗  ██╗",
+    "██║   ██║╚══██╔══╝╚██╗██╔╝",
+    "██║   ██║   ██║    ╚███╔╝ ",
+    "╚██╗ ██╔╝   ██║    ██╔██╗ ",
+    " ╚████╔╝    ██║   ██╔╝ ██╗",
+    "  ╚═══╝     ╚═╝   ╚═╝  ╚═╝",
+]
+
+
+def _format_duration(seconds: float) -> str:
+    total = int(seconds)
+    if total < 60:
+        return f"{total}s"
+    minutes = total // 60
+    secs = total % 60
+    return f"{minutes}m {secs}s"
+
+
+def _print_exit_message(
+    hints: list[str],
+    session_id: str | None = None,
+    duration_seconds: float | None = None,
+    file_changes: dict[str, tuple[int, int]] | None = None,
+) -> None:
+    colors = config.ui.colors
+    console = Console(highlight=False)
+
+    for hint in hints:
+        console.print(
+            f"[{colors.muted}]Hint:[/{colors.muted}] [{colors.dim}]{hint}[/{colors.dim}]"
+        )
+
+    t = colors.dim
+    logo_color = colors.dim
+    info_lines: list[str] = []
+
+    if duration_seconds is not None:
+        info_lines.append(f"[{t}]Time {_format_duration(duration_seconds)}[/{t}]")
+
+    if file_changes:
+        n_files = len(file_changes)
+        total_added = sum(a for a, _ in file_changes.values())
+        total_removed = sum(r for _, r in file_changes.values())
+        info_lines.append(
+            f"[{t}]Changed {n_files} file{'s' if n_files != 1 else ''}[/{t}]"
+            f" [{colors.diff_added}]+{total_added}[/{colors.diff_added}]"
+            f" [{colors.diff_removed}]-{total_removed}[/{colors.diff_removed}]"
+        )
+
+    if session_id:
+        info_lines.append(
+            f"[{colors.muted}]To resume:[/{colors.muted}] "
+            f"[{colors.accent}]vtx -r {session_id}[/{colors.accent}]"
+        )
+
+    if not info_lines:
+        return
+
+    while len(info_lines) < len(_LOGO):
+        info_lines.append("")
+
+    console.print()
+    for logo_line, info_line in zip(_LOGO, info_lines, strict=False):
+        padding = "  " if info_line else ""
+        console.print(f"  [{logo_color}]{logo_line}[/{logo_color}]{padding}{info_line}")
+    console.print()
+
+
+def run_tui(args: argparse.Namespace) -> None:
+    app = Vtx(
+        model=args.model,
+        provider=args.provider,
+        api_key=args.api_key,
+        base_url=args.base_url,
+        resume_session=args.resume_session,
+        continue_recent=args.continue_recent,
+        openai_compat_auth_mode=args.openai_compat_auth,
+        anthropic_compat_auth_mode=args.anthropic_compat_auth,
+    )
+    app.run()
+
+    hints = list(app._exit_hints)
+    session_id: str | None = None
+    duration: float | None = None
+    file_changes: dict[str, tuple[int, int]] | None = None
+
+    if app._session:
+        session_id = app._session.id
+        file_changes = app._session.file_changes_summary() or None
+    if app._session_start_time is not None:
+        duration = time.time() - app._session_start_time
+
+    if hints or session_id:
+        _print_exit_message(hints, session_id, duration, file_changes)

vtx/ui/path_complete.py

@@ -0,0 +1,228 @@
+"""
+Path completion engine for tab completion.
+
+Handles filesystem path completion with caching, tilde expansion,
+and longest common prefix matching for multiple results.
+"""
+
+import os
+import re
+
+
+class PathComplete:
+    """
+    Async path completion with caching.
+
+    Features:
+    - Expands ~ and resolves relative paths
+    - Caches directory listings for performance
+    - Finds longest common prefix for multiple matches
+    - Returns completion text and alternatives
+    """
+
+    def __init__(self) -> None:
+        self._cache: dict[str, list[str]] = {}
+
+    def clear_cache(self) -> None:
+        self._cache.clear()
+
+    async def __call__(self, cwd: str, path_fragment: str) -> tuple[str, list[str]]:
+        """
+        Complete a path fragment.
+
+        Args:
+            cwd: Current working directory for resolving relative paths
+            path_fragment: The partial path to complete
+
+        Returns:
+            Tuple of (completion_text, alternatives)
+            - completion_text: Text to append to complete the path (or longest common prefix)
+            - alternatives: List of all matching paths (empty if unique match)
+        """
+        if not path_fragment:
+            return "", []
+
+        # Expand ~ to home directory
+        if path_fragment.startswith("~"):
+            expanded = os.path.expanduser(path_fragment)
+        else:
+            expanded = path_fragment
+
+        # Resolve relative to cwd if not absolute
+        base_path = os.path.join(cwd, expanded) if not os.path.isabs(expanded) else expanded
+
+        # Normalize the path
+        base_path = os.path.normpath(base_path)
+
+        # Determine directory to list and prefix to match
+        # Only list directory contents if path ends with / (explicit intent)
+        # Otherwise, match the basename as a prefix in the parent directory
+        ends_with_sep = path_fragment.endswith("/") or path_fragment.endswith(os.sep)
+        is_home_only = path_fragment in ("~", "~/")
+        is_dot_path = path_fragment in (".", "..")
+
+        if ends_with_sep or is_home_only:
+            # User wants to see directory contents
+            if os.path.isdir(base_path):
+                dir_to_list = base_path
+                match_prefix = ""
+            else:
+                return "", []
+        elif is_dot_path:
+            # Special case: . or .. should complete to ./ or ../
+            return "/", []
+        else:
+            # User is typing a name - match it in the parent directory
+            dir_to_list = os.path.dirname(base_path)
+            match_prefix = os.path.basename(base_path)
+            if not dir_to_list:
+                dir_to_list = cwd
+
+        # Get directory listing (cached or fresh)
+        entries = await self._list_directory(dir_to_list)
+        if entries is None:
+            return "", []
+
+        # Filter entries by prefix
+        matches = [e for e in entries if e.lower().startswith(match_prefix.lower())]
+
+        if not matches:
+            return "", []
+
+        if len(matches) == 1:
+            # Unique match - complete it
+            match = matches[0]
+            full_path = os.path.join(dir_to_list, match)
+
+            # Add trailing separator for directories
+            if os.path.isdir(full_path):
+                match = match + os.sep
+
+            # Calculate what to append
+            completion = match[len(match_prefix) :]
+            return completion, []
+
+        # Multiple matches - find longest common prefix
+        lcp = self._longest_common_prefix(matches)
+        completion = lcp[len(match_prefix) :]
+
+        # Build full display paths for alternatives
+        alternatives = []
+        for match in sorted(matches):
+            full_path = os.path.join(dir_to_list, match)
+            if os.path.isdir(full_path):
+                alternatives.append(match + os.sep)
+            else:
+                alternatives.append(match)
+
+        return completion, alternatives
+
+    async def _list_directory(self, path: str) -> list[str] | None:
+        """
+        List directory contents (cached).
+
+        Returns None if directory doesn't exist or can't be read.
+        """
+        if path in self._cache:
+            return self._cache[path]
+
+        try:
+            entries = os.listdir(path)
+            self._cache[path] = entries
+            return entries
+        except OSError:
+            return None
+
+    @staticmethod
+    def extract_path_fragment(text: str) -> tuple[str, int]:
+        """
+        Extract the path fragment from text before cursor.
+
+        Returns (path_fragment, start_column) or ("", -1) if no path found.
+        """
+        if not text:
+            return "", -1
+
+        # Handle quoted paths - look for an unclosed quote
+        in_quote = False
+        quote_char = None
+        quote_start = -1
+
+        for i, char in enumerate(text):
+            if char in "\"'":
+                if not in_quote:
+                    in_quote = True
+                    quote_char = char
+                    quote_start = i
+                elif char == quote_char:
+                    in_quote = False
+                    quote_char = None
+                    quote_start = -1
+
+        if in_quote and quote_start >= 0:
+            # Return the content after the opening quote
+            return text[quote_start + 1 :], quote_start
+
+        # Not in a quote - find the last whitespace-separated token
+        # that looks like a path
+        # Match paths:
+        # - Starting with ~ (home dir)
+        # - Starting with ./ or ../ (relative)
+        # - Starting with / (absolute)
+        # - Containing / (like src/main.py)
+        match = re.search(r"(~[^\s]*|\.\.?/[^\s]*|/[^\s]*|[^\s]*/[^\s]*)$", text)
+        if match:
+            return match.group(1), match.start()
+
+        # Check if the last word could be a relative path (no slashes yet)
+        # This allows completing "src" to "src/"
+        words = text.split()
+        if words:
+            last_word = words[-1]
+            start = text.rfind(last_word)
+            # Only treat as path if it could be a valid path start
+            if last_word and not last_word.startswith("-"):
+                return last_word, start
+
+        return "", -1
+
+    @staticmethod
+    def get_base_path(path_fragment: str) -> str:
+        """
+        Get the directory portion of a path fragment.
+
+        For "src/vtx/t" returns "src/vtx/"
+        For "src" returns ""
+        """
+        if os.sep in path_fragment:
+            return path_fragment.rsplit(os.sep, 1)[0] + os.sep
+        if "/" in path_fragment:  # Handle forward slash on all platforms
+            return path_fragment.rsplit("/", 1)[0] + "/"
+        return ""
+
+    def _longest_common_prefix(self, strings: list[str]) -> str:
+        """Find the longest common prefix of a list of strings (case-insensitive)."""
+        if not strings:
+            return ""
+        if len(strings) == 1:
+            return strings[0]
+
+        # Use first string as reference
+        first = strings[0]
+        result = []
+
+        for i, char in enumerate(first):
+            # Check if all other strings have this character at position i
+            char_lower = char.lower()
+            for s in strings[1:]:
+                if i >= len(s) or s[i].lower() != char_lower:
+                    return "".join(result)
+            result.append(char)
+
+        return "".join(result)
+
+    def invalidate(self, path: str) -> None:
+        """Invalidate cache for a specific directory."""
+        normalized = os.path.normpath(path)
+        if normalized in self._cache:
+            del self._cache[normalized]