deepy-cli 0.1.1__py3-none-any.whl

deepy/ui/thinking_state.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping
+
+
+def find_expanded_thinking_id(messages: Iterable[Any]) -> str | None:
+    expanded: str | None = None
+    for message in messages:
+        if _field(message, "role") != "assistant":
+            continue
+        if _is_thinking_message(message):
+            message_id = _field(message, "id")
+            expanded = message_id if isinstance(message_id, str) else None
+        else:
+            expanded = None
+    return expanded
+
+
+def _is_thinking_message(message: Any) -> bool:
+    meta = _field(message, "meta")
+    if isinstance(meta, Mapping):
+        return meta.get("asThinking") is True
+    return getattr(meta, "asThinking", False) is True
+
+
+def _field(value: Any, name: str) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(name)
+    return getattr(value, name, None)

deepy/ui/welcome.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from deepy.skills import SkillInfo
+from deepy.update_check import VersionUpdate
+from deepy.ui.styles import STYLE_ACCENT, STYLE_ASSISTANT, STYLE_INFO, STYLE_MUTED
+from deepy.ui.slash_commands import (
+    BUILTIN_SLASH_COMMANDS,
+    format_slash_command_description,
+)
+
+
+@dataclass(frozen=True)
+class WelcomeTip:
+    label: str
+    description: str
+
+
+@dataclass(frozen=True)
+class WelcomeSetting:
+    label: str
+    value: str
+
+
+CORE_WELCOME_COMMANDS = (
+    "/resume",
+    "/new",
+    "/skills",
+)
+
+CORE_SHORTCUT_TIPS = (
+    WelcomeTip("/", "Command menu"),
+    WelcomeTip("Esc", "Interrupt turn"),
+    WelcomeTip("Ctrl+D twice", "Quit"),
+)
+
+COMPACT_COMMAND_DESCRIPTIONS = {
+    "/skills": "List skills",
+    "/new": "New session",
+    "/resume": "Resume session",
+    "/exit": "Quit",
+}
+
+DEEPY_ASCII_LOGO = (
+    "      .-''''-.",
+    "   .-'  >_   '-.",
+    "  /   .----.    \\",
+    " |   | >_ |  o   |",
+    " |    '----'     |",
+    "  \\    Deepy    /",
+    "   '-.______.--'",
+)
+
+
+def format_home_relative_path(value: str | Path, home: str | Path | None = None) -> str:
+    path = Path(os.path.abspath(os.path.expanduser(str(value))))
+    home_value = str(Path.home()) if home is None else str(home)
+    home_path = Path(os.path.abspath(os.path.expanduser(home_value)))
+    try:
+        relative = path.relative_to(home_path)
+    except ValueError:
+        return str(path)
+    return "~" if str(relative) == "." else f"~/{relative}"
+
+
+def build_welcome_tips(skills: list[SkillInfo]) -> list[WelcomeTip]:
+    del skills
+    slash_tips = [
+        WelcomeTip(
+            label=item.label,
+            description=COMPACT_COMMAND_DESCRIPTIONS.get(
+                item.label,
+                format_slash_command_description(item.description),
+            ),
+        )
+        for item in BUILTIN_SLASH_COMMANDS
+        if item.label in CORE_WELCOME_COMMANDS
+    ]
+    return [*slash_tips, *CORE_SHORTCUT_TIPS]
+
+
+def build_welcome_settings(
+    *,
+    model: str,
+    thinking_enabled: bool,
+    reasoning_effort: str,
+    project_root: str | Path,
+    current_version: str,
+    version_update: VersionUpdate | None = None,
+    home: str | Path | None = None,
+) -> list[WelcomeSetting]:
+    settings = [
+        WelcomeSetting("Version", _format_version_value(current_version, version_update)),
+        WelcomeSetting("Model", model),
+        WelcomeSetting("Thinking", "on" if thinking_enabled else "off"),
+        WelcomeSetting("Reasoning", reasoning_effort),
+        WelcomeSetting("CWD", format_home_relative_path(project_root, home=home)),
+    ]
+    if version_update is not None:
+        settings.append(WelcomeSetting("Update", version_update.install_hint))
+    return settings
+
+
+def _format_version_value(current_version: str, version_update: VersionUpdate | None) -> str:
+    if version_update is None:
+        return current_version
+    return (
+        f"{current_version} -> {version_update.latest_version} available "
+        f"from {version_update.source}"
+    )
+
+
+def build_deepy_ascii_logo() -> Text:
+    logo = Text()
+    for index, line in enumerate(DEEPY_ASCII_LOGO):
+        if index:
+            logo.append("\n")
+        logo.append(line, style=f"bold {STYLE_ACCENT}" if "Deepy" in line else STYLE_INFO)
+    return logo
+
+
+def _build_section(title: str, rows: list[WelcomeSetting | WelcomeTip]) -> Table:
+    section = Table.grid()
+    section.add_column()
+    section.add_row(Text(title, style="bold bright_white"))
+    section.add_row(Text(""))
+
+    body = Table.grid(padding=(0, 2))
+    body.add_column(style=STYLE_ACCENT, no_wrap=True)
+    body.add_column(style="bright_white")
+    for row in rows:
+        body.add_row(row.label, row.description if isinstance(row, WelcomeTip) else row.value)
+    section.add_row(body)
+    return section
+
+
+def build_welcome_panel(
+    *,
+    model: str,
+    thinking_enabled: bool,
+    reasoning_effort: str,
+    project_root: str | Path,
+    skills: list[SkillInfo],
+    current_version: str,
+    version_update: VersionUpdate | None = None,
+    home: str | Path | None = None,
+) -> Panel:
+    settings = build_welcome_settings(
+        model=model,
+        thinking_enabled=thinking_enabled,
+        reasoning_effort=reasoning_effort,
+        project_root=project_root,
+        current_version=current_version,
+        version_update=version_update,
+        home=home,
+    )
+    tips = build_welcome_tips(skills)
+
+    hero = Table.grid(padding=(0, 3), expand=False)
+    hero.add_column()
+    hero.add_column(ratio=1)
+
+    intro = Text()
+    intro.append("Deepy\n", style=f"bold {STYLE_ASSISTANT}")
+    intro.append("Terminal coding agent for DeepSeek.\n", style="bright_white")
+    intro.append("Read, edit, run tools, and keep project context.", style=STYLE_MUTED)
+
+    hero.add_row(build_deepy_ascii_logo(), intro)
+
+    body = Table.grid(padding=(0, 4), expand=False)
+    body.add_column()
+    body.add_column()
+    body.add_row(
+        _build_section("Session", settings),
+        _build_section("Commands", tips[:10]),
+    )
+
+    return Panel(
+        Group(
+            hero,
+            Text(""),
+            body,
+        ),
+        title="Deepy is ready",
+        border_style=STYLE_INFO,
+        expand=False,
+    )

deepy/update_check.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import re
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from deepy.utils import json as json_utils
+
+DEFAULT_PYPI_PACKAGE = "deepy-cli"
+DEFAULT_GITHUB_REPO = "kirineko/deepy"
+DEFAULT_TIMEOUT_SECONDS = 0.8
+
+UrlOpen = Callable[..., Any]
+
+
+@dataclass(frozen=True)
+class VersionCandidate:
+    version: str
+    source: str
+    url: str
+
+
+@dataclass(frozen=True)
+class VersionUpdate:
+    current_version: str
+    latest_version: str
+    source: str
+    url: str
+    install_hint: str
+
+
+def check_for_version_update(
+    current_version: str,
+    *,
+    pypi_package: str = DEFAULT_PYPI_PACKAGE,
+    github_repo: str = DEFAULT_GITHUB_REPO,
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    urlopen: UrlOpen = urllib.request.urlopen,
+) -> VersionUpdate | None:
+    candidates = [
+        candidate
+        for candidate in (
+            fetch_latest_pypi_version(pypi_package, timeout_seconds=timeout_seconds, urlopen=urlopen),
+            fetch_latest_github_version(github_repo, timeout_seconds=timeout_seconds, urlopen=urlopen),
+        )
+        if candidate is not None
+    ]
+    latest = _latest_candidate(candidates)
+    if latest is None or compare_versions(latest.version, current_version) <= 0:
+        return None
+    return VersionUpdate(
+        current_version=current_version,
+        latest_version=latest.version,
+        source=latest.source,
+        url=latest.url,
+        install_hint=f"uv tool upgrade {pypi_package}",
+    )
+
+
+def fetch_latest_pypi_version(
+    package_name: str,
+    *,
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    urlopen: UrlOpen = urllib.request.urlopen,
+) -> VersionCandidate | None:
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        with urlopen(_request(url), timeout=timeout_seconds) as response:
+            payload = _read_json_response(response)
+    except (OSError, urllib.error.URLError, json_utils.JSONDecodeError):
+        return None
+    info = payload.get("info") if isinstance(payload, dict) else None
+    version = info.get("version") if isinstance(info, dict) else None
+    if not isinstance(version, str) or not version.strip():
+        return None
+    return VersionCandidate(version=version.strip(), source="PyPI", url=f"https://pypi.org/project/{package_name}/")
+
+
+def fetch_latest_github_version(
+    repo: str,
+    *,
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    urlopen: UrlOpen = urllib.request.urlopen,
+) -> VersionCandidate | None:
+    release = _fetch_github_release_version(repo, timeout_seconds=timeout_seconds, urlopen=urlopen)
+    if release is not None:
+        return release
+    return _fetch_github_tag_version(repo, timeout_seconds=timeout_seconds, urlopen=urlopen)
+
+
+def compare_versions(a: str, b: str) -> int:
+    left = _version_parts(a)
+    right = _version_parts(b)
+    width = max(len(left), len(right))
+    for index in range(width):
+        left_part = left[index] if index < len(left) else 0
+        right_part = right[index] if index < len(right) else 0
+        if left_part > right_part:
+            return 1
+        if left_part < right_part:
+            return -1
+    return 0
+
+
+def _fetch_github_release_version(
+    repo: str,
+    *,
+    timeout_seconds: float,
+    urlopen: UrlOpen,
+) -> VersionCandidate | None:
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    try:
+        with urlopen(_request(url), timeout=timeout_seconds) as response:
+            payload = _read_json_response(response)
+    except (OSError, urllib.error.URLError, json_utils.JSONDecodeError):
+        return None
+    tag = payload.get("tag_name") if isinstance(payload, dict) else None
+    version = _normalize_tag_version(tag)
+    if version is None:
+        return None
+    html_url = payload.get("html_url") if isinstance(payload, dict) else None
+    return VersionCandidate(
+        version=version,
+        source="GitHub",
+        url=html_url if isinstance(html_url, str) and html_url else f"https://github.com/{repo}/releases/latest",
+    )
+
+
+def _fetch_github_tag_version(
+    repo: str,
+    *,
+    timeout_seconds: float,
+    urlopen: UrlOpen,
+) -> VersionCandidate | None:
+    url = f"https://api.github.com/repos/{repo}/tags?per_page=1"
+    try:
+        with urlopen(_request(url), timeout=timeout_seconds) as response:
+            payload = _read_json_response(response)
+    except (OSError, urllib.error.URLError, json_utils.JSONDecodeError):
+        return None
+    if not isinstance(payload, list) or not payload:
+        return None
+    first = payload[0]
+    tag = first.get("name") if isinstance(first, dict) else None
+    version = _normalize_tag_version(tag)
+    if version is None:
+        return None
+    return VersionCandidate(version=version, source="GitHub", url=f"https://github.com/{repo}/releases/tag/{tag}")
+
+
+def _latest_candidate(candidates: list[VersionCandidate]) -> VersionCandidate | None:
+    latest: VersionCandidate | None = None
+    for candidate in candidates:
+        if latest is None or compare_versions(candidate.version, latest.version) > 0:
+            latest = candidate
+    return latest
+
+
+def _read_json_response(response: Any) -> dict[str, Any] | list[Any]:
+    data = response.read()
+    if isinstance(data, str):
+        text = data
+    else:
+        text = data.decode("utf-8", errors="replace")
+    parsed = json_utils.loads(text)
+    return parsed if isinstance(parsed, (dict, list)) else {}
+
+
+def _request(url: str) -> urllib.request.Request:
+    return urllib.request.Request(
+        url,
+        headers={
+            "Accept": "application/json",
+            "User-Agent": "Deepy update check",
+        },
+        method="GET",
+    )
+
+
+def _normalize_tag_version(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    stripped = value.strip()
+    if stripped.startswith(("v", "V")):
+        stripped = stripped[1:]
+    return stripped if _version_parts(stripped) else None
+
+
+def _version_parts(value: str) -> list[int]:
+    match = re.match(r"^\s*v?(\d+(?:\.\d+)*)", value, flags=re.IGNORECASE)
+    if not match:
+        return []
+    return [int(part) for part in match.group(1).split(".")]

deepy/usage.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class TokenUsage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+    prompt_cache_hit_tokens: int = 0
+    prompt_cache_miss_tokens: int = 0
+    reasoning_tokens: int = 0
+    requests: int = 0
+    request_usage_entries: list[dict[str, Any]] = field(default_factory=list)
+
+    @property
+    def known(self) -> bool:
+        return any(
+            (
+                self.prompt_tokens,
+                self.completion_tokens,
+                self.total_tokens,
+                self.prompt_cache_hit_tokens,
+                self.prompt_cache_miss_tokens,
+                self.reasoning_tokens,
+                self.requests,
+            )
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = asdict(self)
+        return {key: value for key, value in payload.items() if value not in (0, [], None)}
+
+
+def normalize_usage(value: Any) -> TokenUsage:
+    payload = _to_mapping(value)
+    if payload is None:
+        return TokenUsage()
+
+    prompt_tokens = _int_field(payload.get("prompt_tokens"))
+    completion_tokens = _int_field(payload.get("completion_tokens"))
+    total_tokens = _int_field(payload.get("total_tokens"))
+
+    sdk_input_tokens = _int_field(payload.get("input_tokens"))
+    sdk_output_tokens = _int_field(payload.get("output_tokens"))
+    if prompt_tokens == 0:
+        prompt_tokens = sdk_input_tokens
+    if completion_tokens == 0:
+        completion_tokens = sdk_output_tokens
+    if total_tokens == 0:
+        total_tokens = prompt_tokens + completion_tokens
+
+    prompt_details = _to_mapping(payload.get("prompt_tokens_details")) or {}
+    completion_details = _to_mapping(payload.get("completion_tokens_details")) or {}
+    input_details = _to_mapping(payload.get("input_tokens_details")) or {}
+    output_details = _to_mapping(payload.get("output_tokens_details")) or {}
+
+    prompt_cache_hit_tokens = _first_int(
+        payload.get("prompt_cache_hit_tokens"),
+        prompt_details.get("cached_tokens"),
+        input_details.get("cached_tokens"),
+    )
+    prompt_cache_miss_tokens = _int_field(payload.get("prompt_cache_miss_tokens"))
+    if prompt_cache_miss_tokens == 0 and prompt_tokens and prompt_cache_hit_tokens:
+        prompt_cache_miss_tokens = max(prompt_tokens - prompt_cache_hit_tokens, 0)
+    reasoning_tokens = _first_int(
+        completion_details.get("reasoning_tokens"),
+        output_details.get("reasoning_tokens"),
+    )
+
+    request_entries = _request_usage_entries(payload.get("request_usage_entries"))
+    if not request_entries and payload:
+        entry = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+        }
+        if prompt_cache_hit_tokens:
+            entry["prompt_cache_hit_tokens"] = prompt_cache_hit_tokens
+        if prompt_cache_miss_tokens:
+            entry["prompt_cache_miss_tokens"] = prompt_cache_miss_tokens
+        if reasoning_tokens:
+            entry["reasoning_tokens"] = reasoning_tokens
+        if any(entry.values()):
+            request_entries = [entry]
+    requests = _int_field(payload.get("requests"))
+    if requests == 0 and request_entries:
+        requests = len(request_entries)
+
+    return TokenUsage(
+        prompt_tokens=prompt_tokens,
+        completion_tokens=completion_tokens,
+        total_tokens=total_tokens,
+        prompt_cache_hit_tokens=prompt_cache_hit_tokens,
+        prompt_cache_miss_tokens=prompt_cache_miss_tokens,
+        reasoning_tokens=reasoning_tokens,
+        requests=requests,
+        request_usage_entries=request_entries,
+    )
+
+
+def merge_usage(*items: TokenUsage | Mapping[str, Any] | None) -> TokenUsage:
+    total = TokenUsage()
+    for item in items:
+        usage = item if isinstance(item, TokenUsage) else normalize_usage(item)
+        if not usage.known:
+            continue
+        total = TokenUsage(
+            prompt_tokens=total.prompt_tokens + usage.prompt_tokens,
+            completion_tokens=total.completion_tokens + usage.completion_tokens,
+            total_tokens=total.total_tokens + usage.total_tokens,
+            prompt_cache_hit_tokens=total.prompt_cache_hit_tokens + usage.prompt_cache_hit_tokens,
+            prompt_cache_miss_tokens=total.prompt_cache_miss_tokens + usage.prompt_cache_miss_tokens,
+            reasoning_tokens=total.reasoning_tokens + usage.reasoning_tokens,
+            requests=total.requests + usage.requests,
+            request_usage_entries=[
+                *total.request_usage_entries,
+                *usage.request_usage_entries,
+            ],
+        )
+    return total
+
+
+def usage_from_run_result(result: Any) -> TokenUsage:
+    context = getattr(result, "context_wrapper", None)
+    usage = getattr(context, "usage", None)
+    return normalize_usage(usage)
+
+
+def format_usage_line(usage: TokenUsage | Mapping[str, Any] | None) -> str:
+    normalized = usage if isinstance(usage, TokenUsage) else normalize_usage(usage)
+    if not normalized.known:
+        return "usage=unknown"
+    parts = [f"context input {normalized.prompt_tokens:,}"]
+    cache_tokens = normalized.prompt_cache_hit_tokens + normalized.prompt_cache_miss_tokens
+    if cache_tokens:
+        cache_hit_rate = normalized.prompt_cache_hit_tokens / cache_tokens * 100
+        parts.append(f"fresh input {normalized.prompt_cache_miss_tokens:,}")
+        parts.append(
+            f"cached input {normalized.prompt_cache_hit_tokens:,} "
+            f"({cache_hit_rate:.1f}% hit)"
+        )
+    parts.append(f"output {normalized.completion_tokens:,}")
+    if normalized.reasoning_tokens:
+        parts.append(f"reasoning {normalized.reasoning_tokens:,}")
+    parts.append(f"total {normalized.total_tokens:,}")
+    return " · ".join(parts)
+
+
+def _to_mapping(value: Any) -> Mapping[str, Any] | None:
+    if isinstance(value, Mapping):
+        return value
+    model_dump = getattr(value, "model_dump", None)
+    if callable(model_dump):
+        dumped = model_dump()
+        return dumped if isinstance(dumped, Mapping) else None
+    if hasattr(value, "__dict__"):
+        return dict(value.__dict__)
+    return None
+
+
+def _int_field(value: Any) -> int:
+    if isinstance(value, bool):
+        return 0
+    if isinstance(value, int):
+        return max(value, 0)
+    if isinstance(value, float) and value.is_integer():
+        return max(int(value), 0)
+    return 0
+
+
+def _first_int(*values: Any) -> int:
+    for value in values:
+        number = _int_field(value)
+        if number:
+            return number
+    return 0
+
+
+def _request_usage_entries(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    entries: list[dict[str, Any]] = []
+    for item in value:
+        normalized = normalize_usage(item)
+        if normalized.known:
+            payload = normalized.to_dict()
+            payload.pop("request_usage_entries", None)
+            entries.append(payload)
+    return entries

deepy/utils/__init__.py

@@ -0,0 +1,15 @@
+from .debug_logger import debug_log_path, log_debug_event, normalize_error
+from .error_logger import error_log_path, log_api_error, mask_sensitive
+from .notify import build_notify_env, format_duration_seconds, launch_notify_script
+
+__all__ = [
+    "build_notify_env",
+    "debug_log_path",
+    "error_log_path",
+    "format_duration_seconds",
+    "launch_notify_script",
+    "log_api_error",
+    "log_debug_event",
+    "mask_sensitive",
+    "normalize_error",
+]

deepy/utils/debug_logger.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import traceback
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from . import json as json_utils
+
+
+def debug_log_path(deepy_home: Path | None = None) -> Path:
+    home = deepy_home or Path.home() / ".deepy"
+    return home / "logs" / "debug.log"
+
+
+def normalize_error(error: BaseException | object) -> dict[str, str]:
+    if isinstance(error, BaseException):
+        payload = {
+            "name": error.__class__.__name__,
+            "message": str(error),
+        }
+        stack = "".join(traceback.format_exception(type(error), error, error.__traceback__)).strip()
+        if stack:
+            payload["stack"] = stack
+        return payload
+    return {"name": "UnknownError", "message": str(error)}
+
+
+def log_debug_event(entry: Mapping[str, Any], *, deepy_home: Path | None = None) -> None:
+    try:
+        path = debug_log_path(deepy_home)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as fh:
+            fh.write(json_utils.dumps(_to_serializable(entry)))
+            fh.write("\n")
+    except Exception:
+        return
+
+
+def _to_serializable(value: Any, seen: set[int] | None = None) -> Any:
+    seen = seen or set()
+    if isinstance(value, BaseException):
+        return normalize_error(value)
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        marker = id(value)
+        if marker in seen:
+            return "[Circular]"
+        seen.add(marker)
+        return {str(key): _to_serializable(item, seen) for key, item in value.items()}
+    if isinstance(value, list | tuple | set):
+        marker = id(value)
+        if marker in seen:
+            return "[Circular]"
+        seen.add(marker)
+        return [_to_serializable(item, seen) for item in value]
+    try:
+        json_utils.dumps(value)
+    except TypeError:
+        return str(value)
+    return value