deepy-cli 0.1.1__py3-none-any.whl

deepy/tools/file_state.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class FileSnapshot:
+    mtime_ns: int
+    size: int
+    full_read: bool
+
+
+@dataclass
+class FileSnippet:
+    id: str
+    path: Path
+    start_line: int
+    end_line: int
+    text: str
+
+
+@dataclass
+class FileState:
+    _snapshots: dict[Path, FileSnapshot] = field(default_factory=dict)
+    _snippets: dict[str, FileSnippet] = field(default_factory=dict)
+    _next_snippet_id: int = 0
+
+    def mark_read(self, path: Path, *, full: bool = True) -> None:
+        resolved = path.resolve()
+        stat = resolved.stat()
+        existing = self._snapshots.get(resolved)
+        self._snapshots[resolved] = FileSnapshot(
+            mtime_ns=stat.st_mtime_ns,
+            size=stat.st_size,
+            full_read=full or bool(existing and existing.full_read),
+        )
+
+    def check_writable(
+        self,
+        path: Path,
+        *,
+        require_read: bool = True,
+        allow_partial: bool = False,
+    ) -> tuple[bool, str | None]:
+        resolved = path.resolve()
+        snapshot = self._snapshots.get(resolved)
+        if snapshot is None:
+            if require_read and resolved.exists():
+                return False, "File must be read before it can be modified."
+            return True, None
+        if require_read and not snapshot.full_read and not allow_partial:
+            return False, "File must be read before it can be modified."
+        if not resolved.exists():
+            return False, "File changed since it was read: it no longer exists."
+        stat = resolved.stat()
+        if stat.st_mtime_ns != snapshot.mtime_ns or stat.st_size != snapshot.size:
+            return False, "File changed since it was read; read it again before editing."
+        return True, None
+
+    def mark_written(self, path: Path) -> None:
+        if path.exists():
+            self.mark_read(path)
+
+    def create_snippet(
+        self,
+        path: Path,
+        *,
+        start_line: int,
+        end_line: int,
+        text: str,
+    ) -> FileSnippet:
+        self._next_snippet_id += 1
+        snippet = FileSnippet(
+            id=f"snippet_{self._next_snippet_id}",
+            path=path.resolve(),
+            start_line=start_line,
+            end_line=end_line,
+            text=text,
+        )
+        self._snippets[snippet.id] = snippet
+        return snippet
+
+    def get_snippet(self, snippet_id: str) -> FileSnippet | None:
+        return self._snippets.get(snippet_id)

deepy/tools/result.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from deepy.utils import json as json_utils
+
+
+@dataclass(frozen=True)
+class ToolResult:
+    ok: bool
+    name: str
+    output: str = ""
+    error: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+    awaitUserResponse: bool = False
+    followUpMessages: list[dict[str, Any]] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = {
+            "ok": self.ok,
+            "name": self.name,
+            "output": self.output,
+            "error": self.error,
+            "metadata": self.metadata,
+            "awaitUserResponse": self.awaitUserResponse,
+        }
+        if self.followUpMessages is not None:
+            payload["followUpMessages"] = self.followUpMessages
+        return payload
+
+    def to_json(self) -> str:
+        return json_utils.dumps(self.to_dict())
+
+    @classmethod
+    def ok_result(
+        cls,
+        name: str,
+        output: str = "",
+        *,
+        metadata: dict[str, Any] | None = None,
+    ) -> "ToolResult":
+        return cls(ok=True, name=name, output=output, metadata=metadata or {})
+
+    @classmethod
+    def error_result(
+        cls,
+        name: str,
+        error: str,
+        *,
+        output: str = "",
+        metadata: dict[str, Any] | None = None,
+    ) -> "ToolResult":
+        return cls(ok=False, name=name, output=output, error=error, metadata=metadata or {})

deepy/tools/shell_utils.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import re
+
+
+ShellKind = str
+NUL_REDIRECT_RE = re.compile(r"(\d?&?>+\s*)[Nn][Uu][Ll](?=\s|$|[|&;)\n])")
+
+
+def get_shell_kind(shell_path: str) -> ShellKind:
+    executable = shell_path.replace("\\", "/").split("/")[-1].lower()
+    if executable in {"bash", "bash.exe"}:
+        return "bash"
+    if executable in {"zsh", "zsh.exe"}:
+        return "zsh"
+    return "unknown"
+
+
+def build_shell_init_command(shell_path: str) -> str | None:
+    kind = get_shell_kind(shell_path)
+    if kind == "zsh":
+        return 'ZSHRC="${ZDOTDIR:-$HOME}/.zshrc"; if [ -f "$ZSHRC" ]; then . "$ZSHRC"; fi'
+    if kind == "bash":
+        return 'BASHRC="${BASH_ENV:-$HOME/.bashrc}"; if [ -f "$BASHRC" ]; then . "$BASHRC"; fi'
+    return None
+
+
+def build_disable_extglob_command(shell_path: str) -> str | None:
+    kind = get_shell_kind(shell_path)
+    if kind == "bash":
+        return "shopt -u extglob 2>/dev/null || true"
+    if kind == "zsh":
+        return "setopt NO_EXTENDED_GLOB 2>/dev/null || true"
+    return None
+
+
+def rewrite_windows_null_redirect(command: str) -> str:
+    return NUL_REDIRECT_RE.sub(r"\1/dev/null", command)
+
+
+def windows_path_to_posix_path(windows_path: str) -> str:
+    if windows_path.startswith("\\\\"):
+        return windows_path.replace("\\", "/")
+    drive_match = re.match(r"^([A-Za-z]):[/\\]", windows_path)
+    if drive_match:
+        drive_letter = drive_match.group(1).lower()
+        return f"/{drive_letter}{windows_path[2:].replace('\\', '/')}"
+    return windows_path.replace("\\", "/")
+
+
+def posix_path_to_windows_path(posix_path: str) -> str:
+    if posix_path.startswith("//"):
+        return posix_path.replace("/", "\\")
+
+    cygdrive_match = re.match(r"^/cygdrive/([A-Za-z])(/|$)", posix_path)
+    if cygdrive_match:
+        drive_letter = cygdrive_match.group(1).upper()
+        rest = posix_path[len(f"/cygdrive/{cygdrive_match.group(1)}") :]
+        return f"{drive_letter}:{(rest or '\\').replace('/', '\\')}"
+
+    drive_match = re.match(r"^/([A-Za-z])(/|$)", posix_path)
+    if drive_match:
+        drive_letter = drive_match.group(1).upper()
+        rest = posix_path[2:]
+        return f"{drive_letter}:{(rest or '\\').replace('/', '\\')}"
+
+    return posix_path.replace("/", "\\")
+
+
+def normalize_file_path(path: str, platform: str) -> str:
+    if platform == "win32":
+        return posix_path_to_windows_path(path)
+    return path
+
+
+def is_absolute_file_path(path: str, platform: str) -> bool:
+    if platform == "win32":
+        if re.match(r"^[A-Za-z]:[/\\]", path):
+            return True
+        if path.startswith("\\\\"):
+            return True
+        return bool(re.match(r"^/(?:cygdrive/)?[A-Za-z](?:/|$)", path))
+    return path.startswith("/")

deepy/ui/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .terminal import SlashCommand, parse_slash_command, run_interactive
+
+__all__ = ["SlashCommand", "parse_slash_command", "run_interactive"]

deepy/ui/app.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from typing import Any, Literal
+
+from deepy.llm.context import estimate_tokens_for_text
+from deepy.sessions import SessionEntry
+from deepy.skills import SkillInfo
+from deepy.ui.ask_user_question import AskUserQuestionItem
+
+
+AppView = Literal["chat", "sessions", "skills", "status", "question"]
+
+
+@dataclass(frozen=True)
+class StreamProgress:
+    text_tokens: int = 0
+    reasoning_tokens: int = 0
+    tool_calls: int = 0
+
+
+@dataclass(frozen=True)
+class DeepyAppState:
+    current_view: AppView = "chat"
+    busy: bool = False
+    messages: list[dict[str, Any]] = field(default_factory=list)
+    sessions: list[SessionEntry] = field(default_factory=list)
+    skills: list[SkillInfo] = field(default_factory=list)
+    status_line: str = ""
+    error_line: str = ""
+    stream_progress: StreamProgress = field(default_factory=StreamProgress)
+    running_processes: dict[str, dict[str, str]] = field(default_factory=dict)
+    pending_questions: list[AskUserQuestionItem] = field(default_factory=list)
+
+
+def set_view(state: DeepyAppState, view: AppView) -> DeepyAppState:
+    return replace(state, current_view=view)
+
+
+def set_busy(state: DeepyAppState, busy: bool, *, status_line: str = "") -> DeepyAppState:
+    return replace(state, busy=busy, status_line=status_line)
+
+
+def append_message(state: DeepyAppState, message: dict[str, Any]) -> DeepyAppState:
+    return replace(state, messages=[*state.messages, message])
+
+
+def set_sessions(state: DeepyAppState, sessions: list[SessionEntry]) -> DeepyAppState:
+    return replace(state, sessions=list(sessions))
+
+
+def set_skills(state: DeepyAppState, skills: list[SkillInfo]) -> DeepyAppState:
+    return replace(state, skills=list(skills))
+
+
+def set_status_line(state: DeepyAppState, status_line: str) -> DeepyAppState:
+    return replace(state, status_line=status_line, error_line="")
+
+
+def set_error_line(state: DeepyAppState, error_line: str) -> DeepyAppState:
+    return replace(state, error_line=error_line)
+
+
+def update_stream_progress(
+    state: DeepyAppState,
+    *,
+    text_delta: str = "",
+    reasoning_delta: str = "",
+    tool_call: bool = False,
+) -> DeepyAppState:
+    progress = state.stream_progress
+    return replace(
+        state,
+        stream_progress=StreamProgress(
+            text_tokens=progress.text_tokens + _estimate_tokens(text_delta),
+            reasoning_tokens=progress.reasoning_tokens + _estimate_tokens(reasoning_delta),
+            tool_calls=progress.tool_calls + (1 if tool_call else 0),
+        ),
+    )
+
+
+def set_running_processes(
+    state: DeepyAppState,
+    running_processes: dict[str, dict[str, str]],
+) -> DeepyAppState:
+    return replace(
+        state,
+        running_processes={pid: dict(value) for pid, value in running_processes.items()},
+    )
+
+
+def set_pending_questions(
+    state: DeepyAppState,
+    pending_questions: list[AskUserQuestionItem],
+) -> DeepyAppState:
+    return replace(
+        state,
+        current_view="question" if pending_questions else state.current_view,
+        pending_questions=list(pending_questions),
+    )
+
+
+def clear_for_new_session(state: DeepyAppState) -> DeepyAppState:
+    return replace(
+        state,
+        current_view="chat",
+        busy=False,
+        messages=[],
+        status_line="Started a new session.",
+        error_line="",
+        stream_progress=StreamProgress(),
+        running_processes={},
+        pending_questions=[],
+    )
+
+
+def _estimate_tokens(text: str) -> int:
+    return estimate_tokens_for_text(text)

deepy/ui/ask_user_question.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+from deepy.utils import json as json_utils
+
+
+OTHER_VALUE = "__other__"
+
+
+@dataclass(frozen=True)
+class AskUserQuestionOption:
+    label: str
+    description: str | None = None
+
+
+@dataclass(frozen=True)
+class AskUserQuestionItem:
+    question: str
+    options: list[AskUserQuestionOption]
+    multi_select: bool | None = None
+
+
+@dataclass(frozen=True)
+class PendingAskUserQuestion:
+    message_id: str
+    session_id: str
+    questions: list[AskUserQuestionItem]
+
+
+@dataclass(frozen=True)
+class AskUserQuestionOptionEntry:
+    label: str
+    value: str
+    description: str | None = None
+    is_other: bool = False
+
+
+def build_options(question: AskUserQuestionItem | None) -> list[AskUserQuestionOptionEntry]:
+    if question is None:
+        return []
+    return [
+        *[
+            AskUserQuestionOptionEntry(
+                label=option.label,
+                value=option.label,
+                description=option.description,
+            )
+            for option in question.options
+        ],
+        AskUserQuestionOptionEntry(label="Other", value=OTHER_VALUE, is_other=True),
+    ]
+
+
+def build_answer_for_question(
+    question: AskUserQuestionItem,
+    focused_option: AskUserQuestionOptionEntry | None,
+    selected_values: list[str],
+    other_text: str,
+) -> str | None:
+    trimmed_other = other_text.strip()
+    if question.multi_select:
+        labels = [value.strip() for value in selected_values if value != OTHER_VALUE and value.strip()]
+        if OTHER_VALUE in selected_values and not trimmed_other:
+            return None
+        if trimmed_other:
+            labels.append(trimmed_other)
+        return ", ".join(labels) if labels else None
+
+    if focused_option is None:
+        return None
+    if focused_option.is_other:
+        return trimmed_other or None
+    return focused_option.label
+
+
+def find_pending_ask_user_question(
+    messages: list[Mapping[str, Any]],
+    status: str | None,
+) -> PendingAskUserQuestion | None:
+    if status != "waiting_for_user":
+        return None
+
+    for message in reversed(messages):
+        if message.get("role") != "tool" or message.get("visible") is False:
+            continue
+        questions = parse_ask_user_question_content(message.get("content"))
+        if not questions:
+            continue
+        message_id = message.get("id")
+        session_id = message.get("session_id") or message.get("sessionId")
+        if not isinstance(message_id, str) or not isinstance(session_id, str):
+            continue
+        return PendingAskUserQuestion(
+            message_id=message_id,
+            session_id=session_id,
+            questions=questions,
+        )
+    return None
+
+
+def parse_ask_user_question_content(content: Any) -> list[AskUserQuestionItem]:
+    if not isinstance(content, str) or not content:
+        return []
+    try:
+        parsed = json_utils.loads(content)
+    except json_utils.JSONDecodeError:
+        return []
+    if not isinstance(parsed, Mapping) or parsed.get("awaitUserResponse") is not True:
+        return []
+    metadata = parsed.get("metadata")
+    if not isinstance(metadata, Mapping) or metadata.get("kind") != "ask_user_question":
+        return []
+    return normalize_questions(metadata.get("questions"))
+
+
+def normalize_questions(raw: Any) -> list[AskUserQuestionItem]:
+    if not isinstance(raw, list):
+        return []
+
+    questions: list[AskUserQuestionItem] = []
+    for item in raw:
+        if not isinstance(item, Mapping):
+            continue
+        question = _stripped_string(item.get("question"))
+        raw_options = item.get("options")
+        if not question or not isinstance(raw_options, list):
+            continue
+        options = [
+            option
+            for raw_option in raw_options
+            if (option := normalize_option(raw_option)) is not None
+        ]
+        if not options:
+            continue
+        multi_select = item.get("multiSelect")
+        questions.append(
+            AskUserQuestionItem(
+                question=question,
+                options=options,
+                multi_select=multi_select if isinstance(multi_select, bool) else None,
+            )
+        )
+    return questions
+
+
+def normalize_option(raw: Any) -> AskUserQuestionOption | None:
+    if not isinstance(raw, Mapping):
+        return None
+    label = _stripped_string(raw.get("label"))
+    if not label:
+        return None
+    description = _stripped_string(raw.get("description"))
+    return AskUserQuestionOption(label=label, description=description or None)
+
+
+def format_ask_user_question_answers(answers: Mapping[str, str]) -> str:
+    answer_text = ", ".join(
+        f'"{_escape_answer_part(question)}"="{_escape_answer_part(answer)}"'
+        for question, answer in answers.items()
+    )
+    return (
+        f"User has answered your questions: {answer_text}. "
+        "You can now continue with the user's answers in mind."
+    )
+
+
+def format_ask_user_question_decline() -> str:
+    return (
+        "The user declined to answer the questions. Continue with the available context, "
+        "or ask again if the information is required."
+    )
+
+
+def _stripped_string(value: Any) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _escape_answer_part(value: str) -> str:
+    normalized = " ".join(value.split())
+    return normalized.replace("\\", "\\\\").replace('"', '\\"')

deepy/ui/exit_summary.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+INNER_WIDTH = 98
+CONTENT_WIDTH = INNER_WIDTH - 4
+
+
+@dataclass(frozen=True)
+class UsageFields:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cached_tokens: int = 0
+    reasoning_tokens: int = 0
+
+    @property
+    def has_usage(self) -> bool:
+        return self.prompt_tokens > 0 or self.completion_tokens > 0 or self.reasoning_tokens > 0
+
+
+def extract_usage_fields(usage: Any) -> UsageFields:
+    if not isinstance(usage, Mapping):
+        return UsageFields()
+
+    prompt_tokens = _number_field(usage.get("prompt_tokens"))
+    completion_tokens = _number_field(usage.get("completion_tokens"))
+    cached_tokens = 0
+
+    prompt_details = usage.get("prompt_tokens_details")
+    if isinstance(prompt_details, Mapping):
+        cached_tokens = _number_field(prompt_details.get("cached_tokens"))
+
+    if cached_tokens == 0:
+        cached_tokens = _number_field(usage.get("prompt_cache_hit_tokens"))
+    completion_details = usage.get("completion_tokens_details")
+    output_details = usage.get("output_tokens_details")
+    reasoning_tokens = 0
+    if isinstance(completion_details, Mapping):
+        reasoning_tokens = _number_field(completion_details.get("reasoning_tokens"))
+    if reasoning_tokens == 0 and isinstance(output_details, Mapping):
+        reasoning_tokens = _number_field(output_details.get("reasoning_tokens"))
+    if reasoning_tokens == 0:
+        reasoning_tokens = _number_field(usage.get("reasoning_tokens"))
+
+    return UsageFields(
+        prompt_tokens=prompt_tokens,
+        completion_tokens=completion_tokens,
+        cached_tokens=cached_tokens,
+        reasoning_tokens=reasoning_tokens,
+    )
+
+
+def build_exit_summary_text(
+    *,
+    session: Any | None = None,
+    messages: list[Mapping[str, Any]] | None = None,
+    model: str | None = None,
+) -> str:
+    usage = extract_usage_fields(_get_usage(session))
+    assistant_count = sum(1 for message in messages or [] if message.get("role") == "assistant")
+
+    rows = [
+        "",
+        "Goodbye!",
+        "",
+    ]
+
+    if usage.has_usage:
+        rows.extend(_usage_rows(usage, assistant_count=assistant_count, model=model or "unknown"))
+
+    rows.append("")
+    body = "\n".join(_box_line(row) for row in rows)
+    border = "─" * INNER_WIDTH
+    return f"╭{border}╮\n{body}\n╰{border}╯"
+
+
+def _usage_rows(usage: UsageFields, *, assistant_count: int, model: str) -> list[str]:
+    col_model = 26
+    col_reqs = 6
+    col_input = 14
+    col_output = 14
+    col_cached = 14
+    col_reasoning = 14
+    table_width = col_model + col_reqs + col_input + col_output + col_cached + col_reasoning
+    header = (
+        _pad_right("Cumulative Model Usage", col_model)
+        + _pad_left("Reqs", col_reqs)
+        + _pad_left("Input Tokens", col_input)
+        + _pad_left("Output Tokens", col_output)
+        + _pad_left("Cached Tokens", col_cached)
+        + _pad_left("Reasoning", col_reasoning)
+    )
+    data = (
+        _pad_right(model, col_model)
+        + _pad_right(str(assistant_count).rjust(col_reqs), col_reqs)
+        + _pad_right(_format_number(usage.prompt_tokens).rjust(col_input), col_input)
+        + _pad_right(_format_number(usage.completion_tokens).rjust(col_output), col_output)
+        + _pad_right(_format_number(usage.cached_tokens).rjust(col_cached), col_cached)
+        + _pad_right(_format_number(usage.reasoning_tokens).rjust(col_reasoning), col_reasoning)
+    )
+    return [
+        header,
+        "─" * table_width,
+        data,
+        "",
+    ]
+
+
+def _get_usage(session: Any | None) -> Any:
+    if session is None:
+        return None
+    if isinstance(session, Mapping):
+        return session.get("usage")
+    return getattr(session, "usage", None)
+
+
+def _number_field(value: Any) -> int:
+    if isinstance(value, bool):
+        return 0
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    return 0
+
+
+def _format_number(value: int) -> str:
+    return f"{value:,}"
+
+
+def _box_line(text: str) -> str:
+    return f"│  {_pad_right(text, CONTENT_WIDTH)}  │"
+
+
+def _pad_right(text: str, width: int) -> str:
+    return text + " " * max(0, width - len(text))
+
+
+def _pad_left(text: str, width: int) -> str:
+    return " " * max(0, width - len(text)) + text