deepy-cli 0.1.12__tar.gz → 0.1.14__tar.gz

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.1.12
+Version: 0.1.14
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko
@@ -17,7 +17,6 @@ Requires-Dist: openai>=2.26,<3
 Requires-Dist: orjson>=3.10,<4
 Requires-Dist: pydantic>=2.12,<3
 Requires-Dist: prompt-toolkit>=3.0,<4
-Requires-Dist: pywinpty>=2.0,<3 ; sys_platform == 'win32'
 Requires-Dist: rich>=13.9,<15
 Requires-Dist: tiktoken>=0.9,<1
 Requires-Dist: tomli-w>=1
@@ -79,7 +78,7 @@ of hiding tool calls behind chat text.
 - **Local command mode**: type `!cmd` to run a non-interactive local shell command
   without sending it to the model; the result is still saved as context.
 - **Cross-platform shell handling**: POSIX shell, PowerShell, cmd, Windows paths,
-  UTF-8 output, CRLF editing, and pywinpty-backed local command mode.
+  UTF-8 output, CRLF editing, and non-interactive Windows local command mode.
 
 ## See It Work
 

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/README.md

@@ -50,7 +50,7 @@ of hiding tool calls behind chat text.
 - **Local command mode**: type `!cmd` to run a non-interactive local shell command
   without sending it to the model; the result is still saved as context.
 - **Cross-platform shell handling**: POSIX shell, PowerShell, cmd, Windows paths,
-  UTF-8 output, CRLF editing, and pywinpty-backed local command mode.
+  UTF-8 output, CRLF editing, and non-interactive Windows local command mode.
 
 ## See It Work
 

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.1.12"
+version = "0.1.14"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [
@@ -23,7 +23,6 @@ dependencies = [
     "orjson>=3.10,<4",
     "pydantic>=2.12,<3",
     "prompt-toolkit>=3.0,<4",
-    "pywinpty>=2.0,<3; sys_platform == 'win32'",
     "rich>=13.9,<15",
     "tiktoken>=0.9,<1",
     "tomli-w>=1",

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/src/deepy/__init__.py

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

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/src/deepy/tools/builtin.py

@@ -26,6 +26,7 @@ from deepy.utils import json as json_utils
 
 from .file_state import FileSnippet, FileState
 from .result import ToolResult
+from .shell_output import decode_shell_output
 from .shell_utils import RuntimeEnvironment
 from .shell_utils import build_disable_extglob_command
 from .shell_utils import build_shell_init_command
@@ -2159,54 +2160,10 @@ def _read_captured_output(stream, *, marker: str | None = None) -> tuple[str, st
     truncated = len(data) > MAX_BASH_CAPTURE_CHARS
     if truncated:
         data = data[:MAX_BASH_CAPTURE_CHARS]
-    text, encoding = _decode_shell_output(data, marker=marker)
+    text, encoding = decode_shell_output(data, marker=marker)
     return text, encoding, truncated
 
 
-def _decode_shell_output(data: bytes, *, marker: str | None = None) -> tuple[str, str]:
-    if not data:
-        return "", "empty"
-    if marker:
-        marker_bytes = marker.encode("ascii")
-        marker_index = data.find(marker_bytes)
-        if marker_index >= 0:
-            sentinel_start = marker_index
-            if sentinel_start > 0 and data[sentinel_start - 1 : sentinel_start] == b"\n":
-                sentinel_start -= 1
-                if sentinel_start > 0 and data[sentinel_start - 1 : sentinel_start] == b"\r":
-                    sentinel_start -= 1
-            visible, visible_encoding = _decode_shell_output_bytes(data[:sentinel_start])
-            sentinel = data[sentinel_start:].decode("utf-8", errors="replace")
-            return visible + sentinel, visible_encoding
-    return _decode_shell_output_bytes(data)
-
-
-def _decode_shell_output_bytes(data: bytes) -> tuple[str, str]:
-    if not data:
-        return "", "empty"
-    if data.startswith((b"\xff\xfe", b"\xfe\xff")):
-        return data.decode("utf-16", errors="replace"), "utf-16"
-    if _looks_like_utf16le(data):
-        return data.decode("utf-16le", errors="replace"), "utf-16le"
-    try:
-        return data.decode("utf-8-sig"), "utf-8-sig" if data.startswith(b"\xef\xbb\xbf") else "utf-8"
-    except UnicodeDecodeError:
-        pass
-    try:
-        return data.decode("gb18030"), "gb18030"
-    except UnicodeDecodeError:
-        return data.decode("utf-8", errors="replace"), "utf-8-replace"
-
-
-def _looks_like_utf16le(data: bytes) -> bool:
-    if len(data) < 4:
-        return False
-    sample = data[: min(len(data), 4096)]
-    odd_nuls = sample[1::2].count(0)
-    even_nuls = sample[0::2].count(0)
-    return odd_nuls >= max(2, len(sample) // 8) and odd_nuls > even_nuls * 2
-
-
 def _build_shell_command(
     command: str,
     marker: str,

deepy_cli-0.1.14/src/deepy/tools/shell_output.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+
+def decode_shell_output(data: bytes, *, marker: str | None = None) -> tuple[str, str]:
+    if not data:
+        return "", "empty"
+    if marker:
+        marker_bytes = marker.encode("ascii")
+        marker_index = data.find(marker_bytes)
+        if marker_index >= 0:
+            sentinel_start = marker_index
+            if sentinel_start > 0 and data[sentinel_start - 1 : sentinel_start] == b"\n":
+                sentinel_start -= 1
+                if sentinel_start > 0 and data[sentinel_start - 1 : sentinel_start] == b"\r":
+                    sentinel_start -= 1
+            visible, visible_encoding = decode_shell_output_bytes(data[:sentinel_start])
+            sentinel = data[sentinel_start:].decode("utf-8", errors="replace")
+            return visible + sentinel, visible_encoding
+    return decode_shell_output_bytes(data)
+
+
+def decode_shell_output_bytes(data: bytes) -> tuple[str, str]:
+    if not data:
+        return "", "empty"
+    if data.startswith((b"\xff\xfe", b"\xfe\xff")):
+        return data.decode("utf-16", errors="replace"), "utf-16"
+    if _looks_like_utf16le(data):
+        return data.decode("utf-16le", errors="replace"), "utf-16le"
+    try:
+        return data.decode("utf-8-sig"), "utf-8-sig" if data.startswith(b"\xef\xbb\xbf") else "utf-8"
+    except UnicodeDecodeError:
+        pass
+    try:
+        return data.decode("gb18030"), "gb18030"
+    except UnicodeDecodeError:
+        return data.decode("utf-8", errors="replace"), "utf-8-replace"
+
+
+def _looks_like_utf16le(data: bytes) -> bool:
+    if len(data) < 4:
+        return False
+    sample = data[: min(len(data), 4096)]
+    odd_nuls = sample[1::2].count(0)
+    even_nuls = sample[0::2].count(0)
+    return odd_nuls >= max(2, len(sample) // 8) and odd_nuls > even_nuls * 2

{deepy_cli-0.1.12 → deepy_cli-0.1.14}/src/deepy/ui/local_command.py

@@ -4,6 +4,7 @@ import errno
 import contextlib
 import os
 import queue
+import re
 import select
 import shutil
 import signal
@@ -17,6 +18,7 @@ from pathlib import Path
 from typing import Any
 
 from deepy.tools.result import ToolResult
+from deepy.tools.shell_output import decode_shell_output_bytes
 from deepy.tools.shell_utils import RuntimeEnvironment, detect_runtime_environment
 from deepy.utils import json as json_utils
 
@@ -29,6 +31,21 @@ DEFAULT_LOCAL_COMMAND_TIMEOUT_MS = 120_000
 DEFAULT_DISPLAY_OUTPUT_LIMIT = 30_000
 DEFAULT_CONTEXT_OUTPUT_LIMIT = 8_000
 _TRUNCATED_MARKER = "\n... output truncated ...\n"
+_ANSI_CONTROL_RE = re.compile(
+    r"""
+    \x1b
+    (?:
+        \[[0-?]*[ -/]*[@-~]
+        |\][^\x07\x1b]*(?:\x07|\x1b\\)
+        |P[^\x1b]*(?:\x1b\\)
+        |_[^\x1b]*(?:\x1b\\)
+        |\^[^\x1b]*(?:\x1b\\)
+        |[@-Z\\-_]
+    )
+    """,
+    re.VERBOSE,
+)
+_TERMINAL_CONTROL_CHAR_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]")
 
 
 @dataclass(frozen=True)
@@ -97,7 +114,8 @@ def run_local_command(
     capture_limit = max(display_limit, context_limit) + len(_TRUNCATED_MARKER)
 
     if runtime.os_family == "windows":
-        return _run_windows_pty(
+        _prepare_windows_process_env(process_env)
+        return _run_windows_pipes(
             command,
             cwd=cwd,
             env=process_env,
@@ -155,6 +173,8 @@ def shell_tool_result_json(
     output: str | None = None,
 ) -> str:
     rendered_output = result.context_output if output is None else output
+    if result.os_family == "windows":
+        rendered_output = _sanitize_terminal_output(rendered_output)
     metadata = _shell_metadata(result)
     if result.ok:
         return ToolResult.ok_result("shell", rendered_output, metadata=metadata).to_json()
@@ -270,7 +290,7 @@ def _run_posix_pty(
     )
 
 
-def _run_windows_pty(
+def _run_windows_pipes(
     command: str,
     *,
     cwd: Path,
@@ -284,70 +304,56 @@ def _run_windows_pty(
     started_at: float,
     should_interrupt: Callable[[], bool] | None,
 ) -> LocalCommandResult:
-    try:
-        from winpty import PtyProcess  # type: ignore[import-not-found]
-    except Exception:
-        error = "Windows local command mode requires the pywinpty package."
-        return _error_result(
-            command,
-            cwd=cwd,
-            runtime=runtime,
-            shell_path=shell_path,
-            timeout_ms=timeout_ms,
-            started_at=started_at,
-            tty_mode="unavailable",
-            error=error,
-        )
-
-    process = None
+    process: subprocess.Popen[bytes] | None = None
     timed_out = False
     interrupted = False
-    captured = ""
+    captured = bytearray()
     capture_truncated = False
-    output_queue: queue.Queue[str] = queue.Queue()
-    stop_reader = threading.Event()
+    output_queue: queue.Queue[bytes] = queue.Queue()
     try:
-        process = PtyProcess.spawn(
+        process = subprocess.Popen(
             [shell_path, *_shell_args(runtime, command)],
             cwd=str(cwd),
             env=env,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            close_fds=True,
         )
-        reader = threading.Thread(
-            target=_read_windows_pty_output,
-            args=(process, output_queue, stop_reader),
-            daemon=True,
-        )
+        reader = threading.Thread(target=_read_pipe_output, args=(process, output_queue), daemon=True)
         reader.start()
         deadline = started_at + timeout_ms / 1000
         while True:
-            captured, drained_truncated = _drain_text_queue(
+            drained_truncated = _drain_bytes_queue(
                 output_queue,
                 captured,
                 capture_limit,
             )
             capture_truncated = capture_truncated or drained_truncated
-            if not process.isalive():
+            if process.poll() is not None:
                 break
             if callable(should_interrupt) and should_interrupt():
                 interrupted = True
-                process.terminate(force=True)
+                _terminate_windows_process(process)
                 break
             remaining = deadline - time.monotonic()
             if remaining <= 0:
                 timed_out = True
-                process.terminate(force=True)
+                _terminate_windows_process(process)
                 break
             time.sleep(min(0.05, remaining))
-        stop_reader.set()
         reader.join(timeout=0.2)
-        captured, drained_truncated = _drain_text_queue(output_queue, captured, capture_limit)
-        capture_truncated = capture_truncated or drained_truncated
-        exit_code = process.exitstatus
-        output = captured
+        capture_truncated = (
+            capture_truncated or _drain_bytes_queue(output_queue, captured, capture_limit)
+        )
+        if len(captured) >= capture_limit:
+            capture_truncated = True
+        exit_code = process.poll()
+        output = _sanitize_terminal_output(_decode_output(bytes(captured), windows_compatible=True))
         error = _command_error(exit_code, timed_out=timed_out, interrupted=interrupted)
     except Exception as exc:
         exit_code = None
-        output = captured
+        output = _sanitize_terminal_output(_decode_output(bytes(captured), windows_compatible=True))
         error = str(exc)
 
     display_output, display_truncated = _limit_output(output, display_limit)
@@ -364,7 +370,7 @@ def _run_windows_pty(
         command_dialect=runtime.command_dialect,
         path_style=runtime.path_style,
         os_family=runtime.os_family,
-        tty_mode="winpty",
+        tty_mode="pipe",
         duration_ms=_elapsed_ms(started_at),
         timeout_ms=timeout_ms,
         timed_out=timed_out,
@@ -376,36 +382,37 @@ def _run_windows_pty(
     )
 
 
-def _read_windows_pty_output(
-    process: Any,
-    output_queue: queue.Queue[str],
-    stop_reader: threading.Event,
+def _read_pipe_output(
+    process: subprocess.Popen[bytes],
+    output_queue: queue.Queue[bytes],
 ) -> None:
-    while not stop_reader.is_set():
+    stream = process.stdout
+    if stream is None:
+        return
+    while True:
         try:
-            chunk = process.read(4096)
+            chunk = stream.read1(4096)
         except Exception:
             return
-        if chunk:
-            output_queue.put(chunk)
-        elif not process.isalive():
+        if not chunk:
             return
+        output_queue.put(chunk)
 
 
-def _drain_text_queue(
-    output_queue: queue.Queue[str],
-    captured: str,
+def _drain_bytes_queue(
+    output_queue: queue.Queue[bytes],
+    captured: bytearray,
     capture_limit: int,
-) -> tuple[str, bool]:
+) -> bool:
     truncated = False
     while True:
         try:
             chunk = output_queue.get_nowait()
         except queue.Empty:
-            return captured, truncated
+            return truncated
         if len(captured) < capture_limit:
             remaining = capture_limit - len(captured)
-            captured += chunk[:remaining]
+            captured.extend(chunk[:remaining])
             if len(chunk) > remaining:
                 truncated = True
         else:
@@ -472,6 +479,20 @@ def _terminate_process(process: subprocess.Popen[bytes]) -> None:
             process.wait(timeout=0.2)
 
 
+def _terminate_windows_process(process: subprocess.Popen[bytes]) -> None:
+    if process.poll() is not None:
+        return
+    with contextlib.suppress(OSError):
+        process.terminate()
+    try:
+        process.wait(timeout=0.2)
+    except subprocess.TimeoutExpired:
+        with contextlib.suppress(OSError):
+            process.kill()
+        with contextlib.suppress(OSError, subprocess.TimeoutExpired):
+            process.wait(timeout=0.2)
+
+
 def _limit_output(output: str, limit: int) -> tuple[str, bool]:
     if limit <= 0:
         return (_TRUNCATED_MARKER if output else ""), bool(output)
@@ -484,8 +505,26 @@ def _limit_output(output: str, limit: int) -> tuple[str, bool]:
     return output[:keep] + marker, True
 
 
-def _decode_output(output: bytes) -> str:
-    return output.replace(b"\r\n", b"\n").replace(b"\r", b"\n").decode("utf-8", errors="replace")
+def _decode_output(output: bytes, *, windows_compatible: bool = False) -> str:
+    if windows_compatible:
+        text, _ = decode_shell_output_bytes(output)
+    else:
+        text = output.decode("utf-8", errors="replace")
+    return _normalize_line_endings(text)
+
+
+def _prepare_windows_process_env(env: dict[str, str]) -> None:
+    env.setdefault("PYTHONUTF8", "1")
+    env.setdefault("PYTHONIOENCODING", "utf-8")
+
+
+def _sanitize_terminal_output(output: str) -> str:
+    normalized = _normalize_line_endings(output)
+    return _TERMINAL_CONTROL_CHAR_RE.sub("", _ANSI_CONTROL_RE.sub("", normalized))
+
+
+def _normalize_line_endings(output: str) -> str:
+    return output.replace("\r\n", "\n").replace("\r", "\n")
 
 
 def _command_error(exit_code: int | None, *, timed_out: bool, interrupted: bool) -> str | None: