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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.1.8
+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.8` 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.8 → 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.8` 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.8 → deepy_cli-0.1.9}/pyproject.toml

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

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

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

{deepy_cli-0.1.8 → 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
@@ -232,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
@@ -1309,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,
@@ -1325,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)}
@@ -1364,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)

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

@@ -34,6 +34,7 @@ SHIFT_ENTER_SEQUENCES = (
     "\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)
@@ -92,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
 
 
@@ -111,16 +118,40 @@ 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:
+    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
 
@@ -145,6 +176,46 @@ def install_windows_shift_enter_key_sequence_override(
     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,
@@ -160,6 +231,20 @@ def _is_windows_shift_enter_key_press(
     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(
     session: PromptSession[str],
     message: AnyFormattedText | None = None,