comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/assistant_render.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Literal
+
+from rich.console import Group, RenderableType
+from rich.markdown import Markdown
+from rich.text import Text
+
+from comate_cli.terminal_agent.message_style import (
+    ASSISTANT_PREFIX,
+    ASSISTANT_PREFIX_STYLE,
+    USER_PREFIX,
+    USER_PREFIX_STYLE,
+)
+
+_LEADING_NOISE_CHARS = frozenset(
+    {
+        "\ufeff",  # BOM
+        "\u200b",  # zero width space
+        "\u200c",  # zero width non-joiner
+        "\u200d",  # zero width joiner
+        "\u2060",  # word joiner
+        "\u00ad",  # soft hyphen
+    }
+)
+_BLOCK_MARKDOWN_PREFIX_RE = re.compile(
+    r"^\s*(#{1,6}\s+|[-*+]\s+|\d+\.\s+|>\s+|```|~~~)",
+    re.MULTILINE,
+)
+_AMBIGUOUS_BLOCK_PREFIX_RE = re.compile(r"^\s*(#{1,6}|[-*+]|>|\d+\.|`{1,2}|~{1,2})$")
+_SegmentMode = Literal["prefixed_plain_first_line", "markdown_only"]
+_Block = RenderableType | tuple[str, Text]
+
+
+def _is_noise_char(ch: str) -> bool:
+    if not ch:
+        return True
+    if ch.isspace() or ch in _LEADING_NOISE_CHARS:
+        return True
+    category = unicodedata.category(ch)
+    # C*: control/format classes; M*: combining marks (often invisible without base)
+    if category.startswith("C") or category in {"Mn", "Me"}:
+        return True
+    return False
+
+
+def _strip_leading_noise(text: str) -> str:
+    """Strip leading whitespace and invisible formatting noise."""
+    idx = 0
+    total = len(text)
+    while idx < total:
+        ch = text[idx]
+        if _is_noise_char(ch):
+            idx += 1
+            continue
+        break
+    return text[idx:]
+
+
+def _first_visible_line(content: str) -> str:
+    lines = content.splitlines()
+    if not lines:
+        return ""
+    for line in lines:
+        candidate = _strip_leading_noise(line)
+        if candidate:
+            return candidate
+    return ""
+
+
+def _split_first_line(content: str) -> tuple[str, str]:
+    if not content:
+        return "", ""
+    if "\n" not in content:
+        return content, ""
+    first_line, remainder = content.split("\n", 1)
+    return first_line.rstrip("\r"), remainder
+
+
+def _is_block_markdown_start(first_line: str) -> bool:
+    if not first_line:
+        return False
+    return _BLOCK_MARKDOWN_PREFIX_RE.match(first_line) is not None
+
+
+def _is_ambiguous_block_start(first_line: str) -> bool:
+    if not first_line:
+        return False
+    return _AMBIGUOUS_BLOCK_PREFIX_RE.match(first_line) is not None
+
+
+class AssistantStreamRenderer:
+    """Turn-scoped assistant renderer that exposes renderables for a parent Live layout."""
+
+    def __init__(self) -> None:
+        self._trim_segment_leading_noise_pending = True
+        self._segment_chunks: list[str] = []
+        self._segment_mode: _SegmentMode | None = None
+        self._blocks: list[_Block] = []
+        self._last_block_external = False
+        self._pending_gap_before_next_segment = False
+
+    def _reset_segment_state(self) -> None:
+        self._trim_segment_leading_noise_pending = True
+        self._segment_chunks = []
+        self._segment_mode = None
+
+    def start_turn(self) -> None:
+        self._blocks = []
+        self._last_block_external = False
+        self._pending_gap_before_next_segment = False
+        self._reset_segment_state()
+
+    def _resolve_segment_mode(self, content: str) -> _SegmentMode | None:
+        first_line = _first_visible_line(content)
+        if not first_line:
+            return None
+        if _is_ambiguous_block_start(first_line):
+            return None
+        if _is_block_markdown_start(first_line):
+            return "markdown_only"
+        return "prefixed_plain_first_line"
+
+    @staticmethod
+    def _build_segment_renderable(mode: _SegmentMode, content: str) -> RenderableType:
+        if mode == "markdown_only":
+            return Markdown(content, code_theme="monokai", hyperlinks=True)
+
+        first_line, remainder = _split_first_line(content)
+        prefixed = Text()
+        prefixed.append(f"{ASSISTANT_PREFIX} ", style=ASSISTANT_PREFIX_STYLE)
+        prefixed.append(first_line)
+
+        if not remainder:
+            return prefixed
+        return Group(
+            prefixed,
+            Markdown(remainder, code_theme="monokai", hyperlinks=True),
+        )
+
+    @staticmethod
+    def _is_gap_block(renderable: RenderableType) -> bool:
+        return isinstance(renderable, Text) and not renderable.plain
+
+    @staticmethod
+    def _materialize_block(block: _Block) -> RenderableType:
+        if isinstance(block, tuple) and len(block) == 2 and block[0] == "tool_ref":
+            return block[1]
+        return block
+
+    def _append_gap_if_needed(self) -> None:
+        if self._blocks and not self._is_gap_block(self._blocks[-1]):
+            self._blocks.append(Text(""))
+
+    def _render_unresolved_segment_if_needed(self) -> None:
+        if not self._segment_chunks or self._segment_mode is not None:
+            return
+        # Segment ended before ambiguous markdown prefix was disambiguated.
+        # Fall back to visible plain-text prefixed rendering to avoid content loss.
+        self._segment_mode = "prefixed_plain_first_line"
+
+    def _flush_active_segment(self, *, inter_block_gap: bool) -> bool:
+        self._render_unresolved_segment_if_needed()
+        content = "".join(self._segment_chunks)
+        mode = self._segment_mode
+        self._reset_segment_state()
+        if not content or mode is None:
+            return False
+
+        self._blocks.append(self._build_segment_renderable(mode, content))
+        self._last_block_external = False
+        if inter_block_gap:
+            self._append_gap_if_needed()
+        return True
+
+    def append_external_lines(self, lines: list[tuple[str, str]]) -> None:
+        if not lines:
+            return
+        self._flush_active_segment(inter_block_gap=True)
+        if not self._last_block_external:
+            self._append_gap_if_needed()
+        for content, style in lines:
+            self._blocks.append(Text(content, style=style))
+        self._last_block_external = True
+
+    def append_tool_line(self, text_ref: Text) -> None:
+        self._flush_active_segment(inter_block_gap=True)
+        if not self._last_block_external:
+            self._append_gap_if_needed()
+        self._blocks.append(("tool_ref", text_ref))
+        self._last_block_external = True
+
+    def append_user_message(self, content: str) -> None:
+        text = Text()
+        text.append(f"{USER_PREFIX} ", style=USER_PREFIX_STYLE)
+        text.append(content)
+        self._blocks.append(text)
+        self._append_gap_if_needed()
+        self._last_block_external = True
+
+    def append_text(self, text: str) -> None:
+        if self._trim_segment_leading_noise_pending:
+            text = _strip_leading_noise(text)
+            if not text:
+                return
+            self._trim_segment_leading_noise_pending = False
+        if not text:
+            return
+
+        if not self._segment_chunks and self._pending_gap_before_next_segment:
+            self._append_gap_if_needed()
+            self._pending_gap_before_next_segment = False
+
+        self._segment_chunks.append(text)
+        content = "".join(self._segment_chunks)
+        if self._segment_mode is None:
+            self._segment_mode = self._resolve_segment_mode(content)
+        self._last_block_external = False
+
+    def insert_gap_before_next_segment(self) -> None:
+        if self._segment_chunks:
+            return
+        if not self._blocks:
+            return
+        self._pending_gap_before_next_segment = True
+
+    def flush_line_for_external_event(self) -> None:
+        self._flush_active_segment(inter_block_gap=True)
+
+    def finalize_turn(self) -> None:
+        self._flush_active_segment(inter_block_gap=False)
+        self._pending_gap_before_next_segment = False
+
+    def renderable(self) -> RenderableType:
+        blocks = [self._materialize_block(block) for block in self._blocks]
+        content = "".join(self._segment_chunks)
+        if content and self._segment_mode is not None:
+            blocks.append(self._build_segment_renderable(self._segment_mode, content))
+        if not blocks:
+            return Text("")
+        return Group(*blocks)

comate_cli/terminal_agent/env_utils.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def read_env_int(name: str, default: int) -> int:
+    raw = os.getenv(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        value = int(raw.strip())
+    except ValueError:
+        logger.warning(f"Invalid env var {name}={raw!r}; using default {default}.")
+        return default
+    if value <= 0:
+        logger.warning(f"Invalid env var {name}={raw!r}; using default {default}.")
+        return default
+    return value
+
+
+def read_env_float(name: str, default: float) -> float:
+    raw = os.getenv(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        value = float(raw.strip())
+    except ValueError:
+        logger.warning(f"Invalid env var {name}={raw!r}; using default {default}.")
+        return default
+    if value <= 0:
+        logger.warning(f"Invalid env var {name}={raw!r}; using default {default}.")
+        return default
+    return value
+

comate_cli/terminal_agent/error_display.py

@@ -0,0 +1,46 @@
+"""Unified error formatter for terminal agent"""
+from __future__ import annotations
+
+
+def format_error(exc: Exception) -> tuple[str, str | None]:
+    """Convert exception to user-friendly message.
+
+    Returns:
+        (error_message, suggestion) - Error message and optional suggestion
+    """
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    # LLM Provider errors
+    if exc_type == "ModelRateLimitError":
+        return "⚠️ Rate limit exceeded", "Wait a moment, or use /model to switch"
+
+    if exc_type == "ModelProviderError":
+        code = getattr(exc, 'status_code', None)
+        if code == 404:
+            return "⚠️ Model not found or invalid API path", "Check .agent/settings.json"
+        if code == 401:
+            return "⚠️ Invalid or expired API key", "Check api_key in .agent/settings.json"
+        if code == 403:
+            return "⚠️ Access denied to this model", "Check API key permissions"
+        if code and code >= 500:
+            return f"⚠️ Server error ({code})", "Try again later"
+        return f"⚠️ API error: {_truncate(exc_msg, 80)}", None
+
+    # Session errors
+    if exc_type == "ChatSessionClosedError":
+        return "⚠️ Session closed", "Please restart the CLI"
+
+    # Network errors (generic detection)
+    lower_msg = exc_msg.lower()
+    if "timeout" in lower_msg or "timed out" in lower_msg:
+        return "⚠️ Request timed out", "Check network connection, or try again"
+    if "connection" in lower_msg:
+        return "⚠️ Connection failed", "Check network and API endpoint"
+
+    # Generic fallback
+    return f"⚠️ Error: {_truncate(exc_msg, 60)}", "You can continue typing"
+
+
+def _truncate(s: str, max_len: int) -> str:
+    return s[:max_len] + "..." if len(s) > max_len else s