deepy-cli 0.1.1__py3-none-any.whl

deepy/ui/loading_text.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Mapping
+
+from deepy.usage import format_usage_line, normalize_usage
+
+
+STALL_THRESHOLD_MS = 3_000
+
+
+def build_loading_text(
+    *,
+    progress: Any | None,
+    now_ms: int | float,
+    processes: Mapping[str, Any] | None = None,
+    usage: Any | None = None,
+) -> str:
+    usage_suffix = _usage_suffix(usage)
+    process_text = build_process_loading_text(processes, now_ms=now_ms)
+    if process_text:
+        return f"{process_text}{usage_suffix}"
+
+    if progress is None:
+        return f"Thinking...{usage_suffix}"
+
+    started_at = parse_timestamp_ms(_field(progress, "startedAt"))
+    if started_at is None:
+        return f"Thinking...{usage_suffix}"
+
+    elapsed_ms = max(0, int(now_ms - started_at))
+    if elapsed_ms < STALL_THRESHOLD_MS:
+        return f"Thinking...{usage_suffix}"
+
+    elapsed_seconds = elapsed_ms // 1_000
+    tokens = _field(progress, "formattedTokens") or "0"
+    return f"Thinking... ({elapsed_seconds}s) · ↓ {tokens} tokens{usage_suffix}"
+
+
+def build_process_loading_text(
+    processes: Mapping[str, Any] | None,
+    *,
+    now_ms: int | float,
+) -> str | None:
+    if not processes:
+        return None
+    first = next(iter(processes.values()), None)
+    if first is None:
+        return None
+    start_time = _field(first, "startTime") or ""
+    command = _field(first, "command") or "Running process..."
+    return f"({format_elapsed_time(start_time, now_ms=now_ms)}) {command}"
+
+
+def format_elapsed_time(start_time_iso: str, *, now_ms: int | float) -> str:
+    start_time = parse_timestamp_ms(start_time_iso)
+    elapsed_ms = 0 if start_time is None else max(0, int(now_ms - start_time))
+    elapsed_seconds = elapsed_ms // 1_000
+    minutes = elapsed_seconds // 60
+    seconds = elapsed_seconds % 60
+    if minutes > 0:
+        return f"{minutes}m{seconds}s"
+    return f"{seconds}s"
+
+
+def parse_timestamp_ms(value: Any) -> int | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        normalized = value.replace("Z", "+00:00")
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+    return int(parsed.timestamp() * 1_000)
+
+
+def _field(value: Any, name: str) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(name)
+    return getattr(value, name, None)
+
+
+def _usage_suffix(usage: Any | None) -> str:
+    normalized = normalize_usage(usage)
+    if not normalized.known:
+        return ""
+    return f" · {format_usage_line(normalized)}"

deepy/ui/markdown.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Literal
+
+from rich.text import Text
+
+
+SegmentKind = Literal["text", "code"]
+
+
+@dataclass(frozen=True)
+class MarkdownSegment:
+    kind: SegmentKind
+    body: str
+    lang: str = ""
+
+
+def render_markdown(text: str) -> Text:
+    output = Text()
+    if not text:
+        return output
+
+    for segment in split_by_fences(text):
+        if segment.kind == "code":
+            if segment.lang:
+                output.append(f"code {segment.lang}\n", style="dim")
+            for index, line in enumerate(segment.body.splitlines() or [""]):
+                if index:
+                    output.append("\n")
+                output.append(f"  {line}", style="bright_white on #1f2430")
+        else:
+            output.append(render_inline_block(segment.body))
+    return output
+
+
+def split_by_fences(text: str) -> list[MarkdownSegment]:
+    segments: list[MarkdownSegment] = []
+    lines = text.splitlines()
+    buffer: list[str] = []
+    in_fence = False
+    fence_lang = ""
+    fence_body: list[str] = []
+
+    def flush_text() -> None:
+        nonlocal buffer
+        if buffer:
+            segments.append(MarkdownSegment(kind="text", body="\n".join(buffer)))
+            buffer = []
+
+    for line in lines:
+        fence_match = re.match(r"^\s*```(\w*)\s*$", line)
+        if fence_match:
+            if not in_fence:
+                flush_text()
+                in_fence = True
+                fence_lang = fence_match.group(1) or ""
+                fence_body = []
+            else:
+                segments.append(
+                    MarkdownSegment(kind="code", lang=fence_lang, body="\n".join(fence_body))
+                )
+                in_fence = False
+                fence_lang = ""
+                fence_body = []
+            continue
+
+        if in_fence:
+            fence_body.append(line)
+        else:
+            buffer.append(line)
+
+    if in_fence:
+        segments.append(MarkdownSegment(kind="code", lang=fence_lang, body="\n".join(fence_body)))
+    else:
+        flush_text()
+    return segments
+
+
+def render_inline_block(text: str) -> Text:
+    rendered = Text()
+    lines = text.split("\n")
+    for index, line in enumerate(lines):
+        if index:
+            rendered.append("\n")
+        rendered.append(render_inline_line(line))
+    return rendered
+
+
+def render_inline_line(line: str) -> Text:
+    heading = re.match(r"^(\s*)(#{1,6})\s+(.*)$", line)
+    if heading:
+        lead, hashes, content = heading.groups()
+        rendered = Text(lead)
+        rendered.append(content, style="bold cyan" if len(hashes) > 2 else "bold bright_cyan")
+        return rendered
+
+    list_match = re.match(r"^(\s*)([-*+])\s+(.*)$", line)
+    if list_match:
+        lead, _bullet, content = list_match.groups()
+        rendered = Text(lead)
+        rendered.append("•", style="bright_blue")
+        rendered.append(" ")
+        rendered.append(render_inline_spans(content))
+        return rendered
+
+    number_match = re.match(r"^(\s*)(\d+\.)\s+(.*)$", line)
+    if number_match:
+        lead, marker, content = number_match.groups()
+        rendered = Text(lead)
+        rendered.append(marker, style="yellow")
+        rendered.append(" ")
+        rendered.append(render_inline_spans(content))
+        return rendered
+
+    quote = re.match(r"^(\s*)>\s?(.*)$", line)
+    if quote:
+        lead, content = quote.groups()
+        rendered = Text(lead)
+        rendered.append("| ", style="dim")
+        start = len(rendered)
+        rendered.append(render_inline_spans(content))
+        rendered.stylize("italic", start, len(rendered))
+        return rendered
+
+    return render_inline_spans(line)
+
+
+def render_inline_spans(text: str) -> Text:
+    rendered = Text()
+    pattern = re.compile(
+        r"`([^`]+)`"
+        r"|\*\*([^*]+)\*\*"
+        r"|(?<!\*)\*([^*]+)\*(?!\*)"
+        r"|_([^_\n]+)_"
+    )
+    position = 0
+    for match in pattern.finditer(text):
+        if match.start() > position:
+            rendered.append(text[position : match.start()])
+        code, bold, star_italic, underscore_italic = match.groups()
+        if code is not None:
+            rendered.append(code, style="bold bright_yellow")
+        elif bold is not None:
+            rendered.append(bold, style="bold bright_white")
+        else:
+            rendered.append(star_italic or underscore_italic or "", style="italic")
+        position = match.end()
+    if position < len(text):
+        rendered.append(text[position:])
+    return rendered