deepy-cli 0.1.7__tar.gz → 0.1.9__tar.gz

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.1.7
+Version: 0.1.9
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko
@@ -238,5 +238,5 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy `0.1.7` is released through GitHub and PyPI. Standalone binaries and npm
+Deepy `0.1.9` is released through GitHub and PyPI. Standalone binaries and npm
 wrappers can be added later, but the primary distribution is the Python CLI.

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/README.md

@@ -210,5 +210,5 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy `0.1.7` is released through GitHub and PyPI. Standalone binaries and npm
+Deepy `0.1.9` is released through GitHub and PyPI. Standalone binaries and npm
 wrappers can be added later, but the primary distribution is the Python CLI.

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.1.7"
+version = "0.1.9"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/src/deepy/__init__.py

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

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/src/deepy/data/tools/shell.md

@@ -9,5 +9,9 @@ Use the runtime context's command dialect and path style: PowerShell uses
 PowerShell commands and Windows paths, `cmd` uses cmd syntax, and `posix` uses
 POSIX shell syntax.
 
+On Windows PowerShell, Python child processes run with UTF-8 I/O defaults for
+the command invocation; do not ask users to run `chcp` or change their
+PowerShell profile for Unicode output.
+
 Runs in the session cwd, preserves cwd between calls when supported, and returns
 stdout/stderr JSON with cwd, exit-code, and shell metadata.

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/src/deepy/tools/builtin.py

@@ -141,6 +141,13 @@ class MatchOccurrence:
     end_line: int
 
 
+@dataclass(frozen=True)
+class EditMatchResult:
+    matches: list[MatchOccurrence]
+    matched_text: str
+    matched_via: str
+
+
 @dataclass(frozen=True)
 class ClosestMatch:
     text: str
@@ -208,6 +215,7 @@ class ShellInvocation:
     shell_path: str
     args: list[str]
     runtime_environment: RuntimeEnvironment
+    env: dict[str, str] | None = None
 
 
 def _find_occurrences(text: str, needle: str, scope: tuple[int, int]) -> list[MatchOccurrence]:
@@ -231,6 +239,63 @@ def _find_occurrences(text: str, needle: str, scope: tuple[int, int]) -> list[Ma
         search_index = found + len(needle)
 
 
+def _find_edit_occurrences(
+    text: str,
+    needle: str,
+    scope: tuple[int, int],
+    line_endings: str,
+    *,
+    matched_via: str = "exact",
+) -> EditMatchResult | None:
+    matches = _find_occurrences(text, needle, scope)
+    if matches:
+        return EditMatchResult(matches=matches, matched_text=needle, matched_via=matched_via)
+    normalized_needle = _normalize_line_endings(needle, line_endings)
+    if normalized_needle == needle:
+        return None
+    normalized_matches = _find_occurrences(text, normalized_needle, scope)
+    if not normalized_matches:
+        return None
+    return EditMatchResult(
+        matches=normalized_matches,
+        matched_text=normalized_needle,
+        matched_via=_line_ending_matched_via(matched_via),
+    )
+
+
+def _find_loose_escape_edit_occurrences(
+    text: str,
+    needle: str,
+    scope: tuple[int, int],
+    line_endings: str,
+) -> list[tuple[MatchOccurrence, float, str, str]]:
+    matches = [
+        (occurrence, score, matched_text, "loose_escape")
+        for occurrence, score, matched_text in _find_loose_escape_occurrences(text, needle, scope)
+    ]
+    normalized_needle = _normalize_line_endings(needle, line_endings)
+    if normalized_needle == needle:
+        return matches
+    matches.extend(
+        (
+            occurrence,
+            score,
+            matched_text,
+            "loose_escape_line_endings",
+        )
+        for occurrence, score, matched_text in _find_loose_escape_occurrences(
+            text,
+            normalized_needle,
+            scope,
+        )
+    )
+    return matches
+
+
+def _line_ending_matched_via(matched_via: str) -> str:
+    return "line_endings" if matched_via == "exact" else f"{matched_via}_line_endings"
+
+
 def _offset_to_line(text: str, offset: int) -> int:
     if offset <= 0:
         return 1
@@ -1308,12 +1373,14 @@ class ToolRuntime:
             return ToolResult.error_result(name, error or "File is not writable.").to_json()
         text_metadata = _read_text_metadata(target)
         text = text_metadata.content
+        line_endings = text_metadata.line_endings
         scope = _edit_scope(text, snippet)
-        matches = _find_occurrences(text, old, scope)
-        matched_via = "exact"
+        match_result = _find_edit_occurrences(text, old, scope, line_endings)
+        matches = match_result.matches if match_result is not None else []
+        matched_via = match_result.matched_via if match_result is not None else "exact"
         replacement_new = new
         if not matches:
-            loose_matches = _find_loose_escape_occurrences(text, old, scope)
+            loose_matches = _find_loose_escape_edit_occurrences(text, old, scope, line_endings)
             if len(loose_matches) == 1 and loose_matches[0][1] == 1.0:
                 corrected = _correct_escaped_strings_with_llm(
                     self.settings,
@@ -1324,14 +1391,20 @@ class ToolRuntime:
                 )
                 if corrected is not None:
                     corrected_old, corrected_new = corrected
-                    corrected_matches = _find_occurrences(text, corrected_old, scope)
-                    if corrected_matches:
-                        matches = corrected_matches
+                    corrected_match_result = _find_edit_occurrences(
+                        text,
+                        corrected_old,
+                        scope,
+                        line_endings,
+                        matched_via="llm_escape_correction",
+                    )
+                    if corrected_match_result is not None:
+                        matches = corrected_match_result.matches
                         replacement_new = corrected_new
-                        matched_via = "llm_escape_correction"
+                        matched_via = corrected_match_result.matched_via
                 if not matches:
                     matches = [loose_matches[0][0]]
-                    matched_via = "loose_escape"
+                    matched_via = loose_matches[0][3]
         if not matches:
             closest_match = _find_closest_match(text, old, scope)
             metadata = {"scope": _format_scope_metadata(target, snippet, scope, text)}
@@ -1363,7 +1436,6 @@ class ToolRuntime:
                     ),
                 },
             ).to_json()
-        line_endings = text_metadata.line_endings
         normalized_new = _normalize_line_endings(replacement_new, line_endings)
         updated = _apply_replacements(text, matches, normalized_new, replace_all)
         _write_text_with_encoding(target, updated, text_metadata.encoding)
@@ -1399,6 +1471,7 @@ class ToolRuntime:
                 process = subprocess.Popen(
                     [shell_invocation.shell_path, *shell_invocation.args],
                     cwd=self.cwd,
+                    env=shell_invocation.env,
                     text=True,
                     stdout=stdout_file,
                     stderr=stderr_file,
@@ -1750,8 +1823,7 @@ def _read_text_preserving_newlines(path: Path) -> str:
 def _read_text_metadata(path: Path) -> TextFileMetadata:
     data = path.read_bytes()
     encoding = _detect_text_encoding(data)
-    python_encoding = "utf-16" if encoding == "utf16le" else "utf-8"
-    text = data.decode(python_encoding, errors="replace")
+    text = data.decode(_python_text_encoding(encoding), errors="replace")
     return TextFileMetadata(
         content=text,
         encoding=encoding,
@@ -1762,12 +1834,32 @@ def _read_text_metadata(path: Path) -> TextFileMetadata:
 def _detect_text_encoding(data: bytes) -> str:
     if len(data) >= 2 and data[0] == 0xFF and data[1] == 0xFE:
         return "utf16le"
+    if data.startswith(b"\xef\xbb\xbf"):
+        return "utf8-sig"
+    try:
+        data.decode("utf-8", errors="strict")
+        return "utf8"
+    except UnicodeDecodeError:
+        pass
+    try:
+        data.decode("gb18030", errors="strict")
+        return "gb18030"
+    except UnicodeDecodeError:
+        return "utf8"
+
+
+def _python_text_encoding(encoding: str) -> str:
+    if encoding == "utf16le":
+        return "utf-16"
+    if encoding == "utf8-sig":
+        return "utf-8-sig"
+    if encoding == "gb18030":
+        return "gb18030"
     return "utf8"
 
 
 def _write_text_with_encoding(path: Path, content: str, encoding: str) -> None:
-    python_encoding = "utf-16" if encoding == "utf16le" else "utf-8"
-    path.write_text(content, encoding=python_encoding)
+    path.write_text(content, encoding=_python_text_encoding(encoding))
 
 
 def _coerce_write_content(path: Path, content: object) -> tuple[str, dict[str, object], str | None]:
@@ -2034,25 +2126,41 @@ def _build_shell_command(
         platform_name=platform_name,
         os_name=os_name,
     )
+    process_env = _build_shell_process_env(runtime_environment, env)
     if runtime_environment.command_dialect == "powershell":
         return ShellInvocation(
             shell_path=resolved_shell,
             args=_build_powershell_args(command, marker),
             runtime_environment=runtime_environment,
+            env=process_env,
         )
     if runtime_environment.command_dialect == "cmd":
         return ShellInvocation(
             shell_path=resolved_shell,
             args=_build_cmd_args(command, marker),
             runtime_environment=runtime_environment,
+            env=process_env,
         )
     return ShellInvocation(
         shell_path=resolved_shell,
         args=_build_posix_shell_args(command, marker, resolved_shell),
         runtime_environment=runtime_environment,
+        env=process_env,
     )
 
 
+def _build_shell_process_env(
+    runtime_environment: RuntimeEnvironment,
+    env: dict[str, str] | None = None,
+) -> dict[str, str] | None:
+    if runtime_environment.os_family != "windows":
+        return dict(env) if env is not None else None
+    process_env = dict(os.environ if env is None else env)
+    process_env.setdefault("PYTHONUTF8", "1")
+    process_env.setdefault("PYTHONIOENCODING", "utf-8")
+    return process_env
+
+
 def _build_posix_shell_args(command: str, marker: str, shell_path: str) -> list[str]:
     normalized_command = rewrite_windows_null_redirect(command)
     parts = [
@@ -2073,6 +2181,8 @@ def _build_posix_shell_args(command: str, marker: str, shell_path: str) -> list[
 def _build_powershell_args(command: str, marker: str) -> list[str]:
     script = "\n".join(
         [
+            "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+            "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
             "$global:LASTEXITCODE = $null",
             "try {",
             command,

{deepy_cli-0.1.7 → deepy_cli-0.1.9}/src/deepy/ui/prompt_input.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
+import sys
 from typing import Callable
 from unicodedata import normalize
 
@@ -32,6 +33,8 @@ SHIFT_ENTER_SEQUENCES = (
     "\x1b[27;2;13~",  # xterm modified-key format.
     "\x1b[13;2u",  # Kitty/fixterms CSI-u format, used by modern terminals.
 )
+_WINDOWS_SHIFT_ENTER_PATCH_ATTR = "_deepy_shift_enter_patched"
+_WINDOWS_SHIFT_ENTER_VT100_PATCH_ATTR = "_deepy_shift_enter_vt100_patched"
 
 
 @dataclass(frozen=True)
@@ -90,6 +93,12 @@ def build_prompt_key_bindings(
     def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
         event.current_buffer.insert_text("\n")
 
+    if is_windows_newline_fallback_enabled():
+
+        @bindings.add("c-j")
+        def _(event) -> None:  # pragma: no cover - prompt_toolkit calls this callback
+            event.current_buffer.insert_text("\n")
+
     return bindings
 
 
@@ -102,6 +111,138 @@ def install_shift_enter_key_sequence_overrides() -> None:
     prefix_cache = getattr(vt100_parser, "_IS_PREFIX_OF_LONGER_MATCH_CACHE", None)
     if hasattr(prefix_cache, "clear"):
         prefix_cache.clear()
+    install_windows_shift_enter_key_sequence_override()
+
+
+def install_windows_shift_enter_key_sequence_override(
+    *,
+    platform_name: str | None = None,
+    console_input_reader_cls: type | None = None,
+    vt100_console_input_reader_cls: type | None = None,
+    event_types: object | None = None,
+    key_event_record_cls: type | None = None,
+) -> bool:
+    resolved_platform = platform_name or sys.platform
+    if not resolved_platform.startswith("win"):
+        return False
+    if console_input_reader_cls is None and vt100_console_input_reader_cls is None:
+        try:
+            from prompt_toolkit.input import win32
+        except (AssertionError, ImportError):
+            return False
+        console_input_reader_cls = win32.ConsoleInputReader
+        vt100_console_input_reader_cls = getattr(win32, "Vt100ConsoleInputReader", None)
+        if event_types is None:
+            event_types = getattr(win32, "EventTypes", None)
+        if key_event_record_cls is None:
+            key_event_record_cls = getattr(win32, "KEY_EVENT_RECORD", None)
+    patched = False
+    if console_input_reader_cls is not None:
+        patched = _patch_windows_console_input_reader(console_input_reader_cls) or patched
+    if vt100_console_input_reader_cls is not None:
+        patched = (
+            _patch_windows_vt100_console_input_reader(
+                vt100_console_input_reader_cls,
+                event_types=event_types,
+                key_event_record_cls=key_event_record_cls,
+            )
+            or patched
+        )
+    return patched
+
+
+def _patch_windows_console_input_reader(console_input_reader_cls: type) -> bool:
+    if getattr(console_input_reader_cls, _WINDOWS_SHIFT_ENTER_PATCH_ATTR, False):
+        return True
+
+    from prompt_toolkit.key_binding.key_processor import KeyPress
+
+    original_handler = console_input_reader_cls._event_to_key_presses
+    shift_pressed = getattr(console_input_reader_cls, "SHIFT_PRESSED", 0x0010)
+
+    def patched_event_to_key_presses(self, ev):
+        key_presses = original_handler(self, ev)
+        if _is_windows_shift_enter_key_press(ev, key_presses, shift_pressed=shift_pressed):
+            return [KeyPress(Keys.Escape, ""), key_presses[0]]
+        return key_presses
+
+    setattr(
+        console_input_reader_cls,
+        "_deepy_original_event_to_key_presses",
+        original_handler,
+    )
+    console_input_reader_cls._event_to_key_presses = patched_event_to_key_presses
+    setattr(console_input_reader_cls, _WINDOWS_SHIFT_ENTER_PATCH_ATTR, True)
+    return True
+
+
+def _patch_windows_vt100_console_input_reader(
+    vt100_console_input_reader_cls: type,
+    *,
+    event_types: object | None,
+    key_event_record_cls: type | None,
+) -> bool:
+    if event_types is None or key_event_record_cls is None:
+        return False
+    if getattr(vt100_console_input_reader_cls, _WINDOWS_SHIFT_ENTER_VT100_PATCH_ATTR, False):
+        return True
+
+    original_get_keys = vt100_console_input_reader_cls._get_keys
+    shift_pressed = getattr(vt100_console_input_reader_cls, "SHIFT_PRESSED", 0x0010)
+
+    def patched_get_keys(self, read, input_records):
+        for index in range(read.value):
+            input_record = input_records[index]
+            if input_record.EventType not in event_types:
+                continue
+            event_name = event_types[input_record.EventType]
+            event = getattr(input_record.Event, event_name)
+            if not isinstance(event, key_event_record_cls) or not event.KeyDown:
+                continue
+            if _is_windows_shift_enter_event(event, shift_pressed=shift_pressed):
+                yield SHIFT_ENTER_SEQUENCES[0]
+                continue
+            u_char = event.uChar.UnicodeChar
+            if u_char != "\x00":
+                yield u_char
+
+    setattr(
+        vt100_console_input_reader_cls,
+        "_deepy_original_get_keys",
+        original_get_keys,
+    )
+    vt100_console_input_reader_cls._get_keys = patched_get_keys
+    setattr(vt100_console_input_reader_cls, _WINDOWS_SHIFT_ENTER_VT100_PATCH_ATTR, True)
+    return True
+
+
+def _is_windows_shift_enter_key_press(
+    ev,
+    key_presses: list,
+    *,
+    shift_pressed: int,
+) -> bool:
+    if not key_presses or len(key_presses) != 1:
+        return False
+    control_key_state = getattr(ev, "ControlKeyState", 0)
+    if not control_key_state & shift_pressed:
+        return False
+    key = getattr(key_presses[0], "key", None)
+    return key in {Keys.ControlM, Keys.ControlJ, Keys.Enter}
+
+
+def _is_windows_shift_enter_event(ev, *, shift_pressed: int) -> bool:
+    control_key_state = getattr(ev, "ControlKeyState", 0)
+    if not control_key_state & shift_pressed:
+        return False
+    u_char = getattr(getattr(ev, "uChar", None), "UnicodeChar", "")
+    virtual_key_code = getattr(ev, "VirtualKeyCode", None)
+    return u_char in {"\r", "\n"} or virtual_key_code == 13
+
+
+def is_windows_newline_fallback_enabled(platform_name: str | None = None) -> bool:
+    resolved_platform = platform_name or sys.platform
+    return resolved_platform.startswith("win")
 
 
 def prompt_for_input(