deepy-cli 0.2.4__tar.gz → 0.2.6__tar.gz

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.4
+Version: 0.2.6
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko
@@ -18,7 +18,8 @@ Requires-Dist: orjson>=3.10,<4
 Requires-Dist: pydantic>=2.12,<3
 Requires-Dist: prompt-toolkit>=3.0,<4
 Requires-Dist: pyyaml>=6.0,<7
-Requires-Dist: rich>=13.9,<15
+Requires-Dist: rich>=14.2,<15
+Requires-Dist: textual>=8.2,<9
 Requires-Dist: tiktoken>=0.9,<1
 Requires-Dist: tomli-w>=1
 Requires-Python: >=3.12
@@ -153,6 +154,27 @@ cd your-project
 deepy
 ```
 
+### Experimental Textual TUI
+
+Deepy's stable default UI is still launched with `deepy`. Users who want to try
+the new opt-in Textual interface can run:
+
+```bash
+deepy tui
+```
+
+This first iteration focuses on experience and TUI-native interactions: a
+scrollable transcript, live thinking and assistant blocks, prompt suggestions
+for slash commands and `@file` mentions, status/help surfaces, and a Deepy-owned
+diff view. It is experimental and may change between releases.
+
+Known limitations: the TUI does not add interactive shell/PTTY support yet, and
+toad / textual-diff-view are only design references. Deepy does not copy their
+AGPL source or depend on those packages.
+
+Please report feedback through GitHub Issues and include your terminal, shell,
+operating system, and the exact `deepy tui` workflow you tried.
+
 ## Installation Notes
 
 Use this order for a fresh machine:

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/README.md

@@ -124,6 +124,27 @@ cd your-project
 deepy
 ```
 
+### Experimental Textual TUI
+
+Deepy's stable default UI is still launched with `deepy`. Users who want to try
+the new opt-in Textual interface can run:
+
+```bash
+deepy tui
+```
+
+This first iteration focuses on experience and TUI-native interactions: a
+scrollable transcript, live thinking and assistant blocks, prompt suggestions
+for slash commands and `@file` mentions, status/help surfaces, and a Deepy-owned
+diff view. It is experimental and may change between releases.
+
+Known limitations: the TUI does not add interactive shell/PTTY support yet, and
+toad / textual-diff-view are only design references. Deepy does not copy their
+AGPL source or depend on those packages.
+
+Please report feedback through GitHub Issues and include your terminal, shell,
+operating system, and the exact `deepy tui` workflow you tried.
+
 ## Installation Notes
 
 Use this order for a fresh machine:

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.4"
+version = "0.2.6"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [
@@ -24,7 +24,8 @@ dependencies = [
     "pydantic>=2.12,<3",
     "prompt-toolkit>=3.0,<4",
     "pyyaml>=6.0,<7",
-    "rich>=13.9,<15",
+    "rich>=14.2,<15",
+    "textual>=8.2,<9",
     "tiktoken>=0.9,<1",
     "tomli-w>=1",
 ]

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
 
 
 def main() -> None:

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/src/deepy/cli.py

@@ -78,6 +78,8 @@ def _build_parser() -> argparse.ArgumentParser:
     run_parser.add_argument("--session", help="Resume an existing session id.")
     run_parser.add_argument("--skill", action="append", default=[], help="Load a skill by name.")
 
+    subparsers.add_parser("tui", help="Start the experimental Textual TUI.")
+
     sessions_parser = subparsers.add_parser("sessions", help="Inspect project sessions.")
     sessions_sub = sessions_parser.add_subparsers(dest="sessions_command", required=True)
     sessions_sub.add_parser("list", help="List sessions for the current project.")
@@ -410,6 +412,29 @@ def _cmd_status(args: argparse.Namespace) -> int:
     return 0
 
 
+def _ensure_interactive_settings(args: argparse.Namespace) -> Settings:
+    settings = load_settings(args.config)
+    if not settings.model.api_key:
+        print("Deepy needs a DeepSeek API key before starting interactive mode.")
+        setup_args = argparse.Namespace(config=args.config, force=True)
+        _cmd_config_setup(setup_args)
+        settings = load_settings(args.config)
+    if settings.path is not None and not settings.ui.theme_configured:
+        theme = _prompt_theme_value(default=settings.ui.theme)
+        update_config_theme(settings.path, theme)
+        settings = load_settings(args.config)
+    return settings
+
+
+def _cmd_tui(args: argparse.Namespace) -> int:
+    if not sys.stdin.isatty():
+        print("experimental TUI requires a TTY; use `deepy` for the stable terminal UI.", file=sys.stderr)
+        return 1
+    from deepy.tui import run_tui
+
+    return run_tui(_ensure_interactive_settings(args), project_root=Path.cwd())
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = _build_parser()
     args = parser.parse_args(argv)
@@ -435,20 +460,12 @@ def main(argv: Sequence[str] | None = None) -> int:
         return _cmd_skills(args)
     if args.command == "status":
         return _cmd_status(args)
+    if args.command == "tui":
+        return _cmd_tui(args)
 
     if not sys.stdin.isatty():
         parser.error("interactive mode requires a TTY; use `deepy doctor` or `deepy config show`.")
-    settings = load_settings(args.config)
-    if not settings.model.api_key:
-        print("Deepy needs a DeepSeek API key before starting interactive mode.")
-        setup_args = argparse.Namespace(config=args.config, force=True)
-        _cmd_config_setup(setup_args)
-        settings = load_settings(args.config)
-    if settings.path is not None and not settings.ui.theme_configured:
-        theme = _prompt_theme_value(default=settings.ui.theme)
-        update_config_theme(settings.path, theme)
-        settings = load_settings(args.config)
-    return run_interactive(settings)
+    return run_interactive(_ensure_interactive_settings(args))
 
 
 if __name__ == "__main__":

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/src/deepy/llm/runner.py

@@ -25,6 +25,11 @@ from .events import DeepyStreamEvent, normalize_stream_event
 from .provider import ProviderBundle, build_provider_bundle
 
 DEFAULT_MAX_TURNS = 100
+INTERRUPTED_MARKER_TEXT = (
+    "Interrupted by user with Esc. This turn was stopped before completion. "
+    "Do not continue the interrupted request unless the user explicitly asks to continue."
+)
+INTERRUPTED_TOOL_OUTPUT_TEXT = "Tool execution interrupted by user with Esc."
 
 
 @dataclass(frozen=True)
@@ -128,6 +133,7 @@ async def run_prompt_once(
     pending_questions: list[dict[str, Any]] = []
     usage = TokenUsage()
     interrupt_task: asyncio.Task[bool] | None = None
+    session_baseline_count = len(await session.get_items())
     try:
         result = Runner.run_streamed(
             agent,
@@ -272,6 +278,12 @@ async def run_prompt_once(
         raise
 
     interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
+    if interrupted:
+        await _reconcile_interrupted_session_tail(
+            session,
+            baseline_count=session_baseline_count,
+            prompt=prompt,
+        )
 
     final_output = getattr(result, "final_output", None)
     output = final_output if isinstance(final_output, str) else "".join(chunks)
@@ -512,6 +524,143 @@ async def _finish_interrupt_task(task: asyncio.Task[bool] | None) -> bool:
     return False
 
 
+async def _reconcile_interrupted_session_tail(
+    session: DeepyJsonlSession,
+    *,
+    baseline_count: int,
+    prompt: str,
+) -> None:
+    items = await session.get_items()
+    if baseline_count < 0 or baseline_count > len(items):
+        return
+    suffix = items[baseline_count:]
+    if not suffix:
+        return
+
+    if len(suffix) == 1 and _is_user_prompt_item(suffix[0], prompt):
+        await session.pop_item()
+        return
+
+    additions = _interrupted_tool_output_items(suffix)
+    if not _is_interrupt_marker_item(suffix[-1]):
+        additions.append(_interrupted_marker_item())
+    if additions:
+        await session.add_items(additions)
+
+
+def _is_user_prompt_item(item: dict[str, Any], prompt: str) -> bool:
+    if item.get("role") != "user":
+        return False
+    return _item_text_content(item) == prompt
+
+
+def _item_text_content(item: dict[str, Any]) -> str:
+    content = item.get("content")
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for part in content:
+        if isinstance(part, dict):
+            text = part.get("text")
+            if text is None:
+                text = part.get("input_text")
+            if isinstance(text, str):
+                parts.append(text)
+    return "".join(parts)
+
+
+def _interrupted_tool_output_items(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    output_call_ids = {
+        call_id
+        for item in items
+        if (call_id := _function_call_output_id(item))
+    }
+    additions: list[dict[str, Any]] = []
+    added_call_ids: set[str] = set()
+    for item in items:
+        for call_id, output_item in _missing_output_items_for_call(item, output_call_ids):
+            if call_id in added_call_ids:
+                continue
+            additions.append(output_item)
+            added_call_ids.add(call_id)
+    return additions
+
+
+def _missing_output_items_for_call(
+    item: dict[str, Any],
+    output_call_ids: set[str],
+) -> list[tuple[str, dict[str, Any]]]:
+    call_id = _function_call_id(item)
+    if call_id:
+        return (
+            []
+            if call_id in output_call_ids
+            else [
+                (
+                    call_id,
+                    {
+                        "type": "function_call_output",
+                        "call_id": call_id,
+                        "output": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                    },
+                )
+            ]
+        )
+
+    missing: list[tuple[str, dict[str, Any]]] = []
+    if item.get("role") != "assistant":
+        return missing
+    tool_calls = item.get("tool_calls")
+    if not isinstance(tool_calls, list):
+        return missing
+    for tool_call in tool_calls:
+        if not isinstance(tool_call, dict):
+            continue
+        chat_call_id = tool_call.get("id")
+        if not isinstance(chat_call_id, str) or not chat_call_id or chat_call_id in output_call_ids:
+            continue
+        missing.append(
+            (
+                chat_call_id,
+                {
+                    "role": "tool",
+                    "tool_call_id": chat_call_id,
+                    "content": INTERRUPTED_TOOL_OUTPUT_TEXT,
+                },
+            )
+        )
+    return missing
+
+
+def _function_call_id(item: dict[str, Any]) -> str:
+    if item.get("type") != "function_call":
+        return ""
+    call_id = item.get("call_id")
+    if call_id is None:
+        call_id = item.get("id")
+    return call_id if isinstance(call_id, str) else ""
+
+
+def _function_call_output_id(item: dict[str, Any]) -> str:
+    if item.get("type") == "function_call_output":
+        call_id = item.get("call_id")
+        return call_id if isinstance(call_id, str) else ""
+    if item.get("role") == "tool":
+        tool_call_id = item.get("tool_call_id")
+        return tool_call_id if isinstance(tool_call_id, str) else ""
+    return ""
+
+
+def _interrupted_marker_item() -> dict[str, Any]:
+    return {"role": "assistant", "content": INTERRUPTED_MARKER_TEXT}
+
+
+def _is_interrupt_marker_item(item: dict[str, Any]) -> bool:
+    return item.get("role") == "assistant" and item.get("content") == INTERRUPTED_MARKER_TEXT
+
+
 def _pending_questions_from_tool_output(output: str) -> list[dict[str, Any]]:
     if not output.strip():
         return []

{deepy_cli-0.2.4 → deepy_cli-0.2.6}/src/deepy/mcp.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import re
+from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal, Mapping
@@ -156,7 +157,6 @@ class DeepyMcpRuntime:
 
     def _build_sdk_servers(self) -> list[Any]:
         from agents.mcp import (
-            MCPServerStdio,
             MCPServerStdioParams,
             MCPServerStreamableHttp,
             MCPServerStreamableHttpParams,
@@ -185,7 +185,7 @@ class DeepyMcpRuntime:
                     params["env"] = dict(definition.env)
                 if definition.cwd:
                     params["cwd"] = definition.cwd
-                server = MCPServerStdio(
+                server = _quiet_stdio_server(
                     params=params,
                     name=definition.name,
                     cache_tools_list=self.settings.mcp.cache_tools_list,
@@ -419,6 +419,25 @@ def _status_from_definition(
     )
 
 
+def _quiet_stdio_server(**kwargs: Any) -> Any:
+    from agents.mcp import MCPServerStdio
+
+    class DeepyQuietMCPServerStdio(MCPServerStdio):
+        def create_streams(self) -> Any:
+            return _quiet_stdio_client(self.params)
+
+    return DeepyQuietMCPServerStdio(**kwargs)
+
+
+@asynccontextmanager
+async def _quiet_stdio_client(params: Any):
+    from mcp import stdio_client
+
+    with open(os.devnull, "w", encoding="utf-8") as errlog:
+        async with stdio_client(params, errlog=errlog) as streams:
+            yield streams
+
+
 def _load_mcp_file(
     path: Path,
     source: str,

deepy_cli-0.2.6/src/deepy/tui/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .runner import run_tui
+
+__all__ = ["run_tui"]