kiwi-code 0.0.35__tar.gz → 0.0.36__tar.gz

{kiwi_code-0.0.35 → kiwi_code-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.35
+Version: 0.0.36
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.35 → kiwi_code-0.0.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.35"
+version = "0.0.36"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.35 → kiwi_code-0.0.36}/src/kiwi_tui/widgets.py

@@ -2,6 +2,7 @@
 
 import shlex
 import sys
+import time
 from pathlib import Path
 from urllib.parse import unquote, urlparse
 
@@ -94,6 +95,11 @@ class ChatInput(TextArea):
         self._history_index: int = -1
         self._draft: str = ""  # saves current text when browsing history
         self.picker_active: bool = False  # True when inline file picker is showing
+        self._pending_clipboard_paste: str | None = None
+        self._recent_paste_text: str = ""
+        self._recent_paste_at: float = 0.0
+        self._last_value_snapshot: str = self.text
+        self._normalizing_duplicate_paste: bool = False
 
         # Ensure a sensible initial height. This will be refined after the first layout.
         self._adjust_height()
@@ -160,16 +166,69 @@ class ChatInput(TextArea):
                     resolved_paths = []
                     break
                 path = Path(normalized_token).expanduser()
-                if not path.exists() or not path.is_file():
+                try:
+                    if not path.exists() or not path.is_file():
+                        resolved_paths = []
+                        break
+                    resolved_paths.append(str(path.resolve()))
+                except OSError:
                     resolved_paths = []
                     break
-                resolved_paths.append(str(path.resolve()))
             if resolved_paths:
                 # Preserve order while removing duplicates.
                 return list(dict.fromkeys(resolved_paths))
 
         return None
 
+    def _remember_recent_paste(self, text: str) -> None:
+        """Remember the latest paste payload to avoid duplicate insertions."""
+        if not text:
+            return
+        self._recent_paste_text = text
+        self._recent_paste_at = time.monotonic()
+
+    def _is_recent_duplicate_paste(self, text: str, *, window_sec: float = 0.25) -> bool:
+        """Return True when the same paste payload was just handled."""
+        if not text:
+            return False
+
+    def _flush_pending_clipboard_paste(self, expected_text: str) -> None:
+        """Insert a deferred clipboard paste if no terminal paste event arrived."""
+        if self.read_only:
+            self._pending_clipboard_paste = None
+            return
+        if self._pending_clipboard_paste != expected_text:
+            return
+        self._pending_clipboard_paste = None
+        if result := self._replace_via_keyboard(expected_text, *self.selection):
+            self.move_cursor(result.end_location)
+            self.focus()
+
+    def _collapse_duplicate_append(self, previous: str, current: str) -> str | None:
+        """Collapse accidental duplicate text appended to the end of the input.
+
+        Some terminals appear to deliver a single paste twice. In the observed
+        failure mode, the duplicated text is appended contiguously at the cursor
+        position, so the new value becomes `previous + chunk + chunk`.
+        """
+        if current == previous:
+            return None
+        if not current.startswith(previous):
+            return None
+        tail = current[len(previous):]
+        if not tail or len(tail) % 2 != 0:
+            return None
+        half = len(tail) // 2
+        if half < 3:
+            return None
+        left = tail[:half]
+        right = tail[half:]
+        if left != right:
+            return None
+        # Avoid collapsing legitimately long repeated-character pastes.
+        if len(set(left)) == 1:
+            return None
+        return previous + left
     def _move_cursor_to_end(self) -> None:
         try:
             self.move_cursor(self.document.end)
@@ -218,6 +277,22 @@ class ChatInput(TextArea):
 
     def on_text_area_changed(self, event: TextArea.Changed) -> None:
         # Keep height in sync with content changes.
+        if self._normalizing_duplicate_paste:
+            self._last_value_snapshot = self.value
+            self._adjust_height()
+            return
+
+        previous = self._last_value_snapshot
+        current = self.value
+        collapsed = self._collapse_duplicate_append(previous, current)
+        if collapsed is not None:
+            self._normalizing_duplicate_paste = True
+            try:
+                self.value = collapsed
+                current = collapsed
+            finally:
+                self._normalizing_duplicate_paste = False
+        self._last_value_snapshot = current
         self._adjust_height()
 
     def update_suggestion(self) -> None:
@@ -357,8 +432,16 @@ class ChatInput(TextArea):
         if self.disabled or self.read_only:
             return
 
+        if self._pending_clipboard_paste == event.text:
+            self._pending_clipboard_paste = None
+        elif self._is_recent_duplicate_paste(event.text):
+            event.prevent_default()
+            event.stop()
+            return
+
         file_paths = self._extract_pasted_file_paths(event.text)
         if file_paths:
+            self._remember_recent_paste(event.text)
             event.prevent_default()
             event.stop()
             self.post_message(self.FilePathsPasted(file_paths))
@@ -366,6 +449,17 @@ class ChatInput(TextArea):
             return
 
         await super()._on_paste(event)
+        self._remember_recent_paste(event.text)
+
+    def action_paste(self) -> None:
+        """Rely on terminal/native paste delivery to avoid duplicate textbox inserts.
+
+        In some terminals, invoking the widget paste action and receiving a terminal
+        paste event both happen for a single user paste gesture, which duplicates the
+        inserted text. We therefore make the explicit TextArea paste action a no-op
+        and let the terminal-delivered `Paste` event be the single source of truth.
+        """
+        return
 
 class StatusBadge(Static):
     """A colored status badge widget."""

{kiwi_code-0.0.35 → kiwi_code-0.0.36}/tests/test_tui_headless.py

@@ -199,6 +199,146 @@ async def test_tui_drag_drop_paste_uploads_file_paths(
         assert chat_input.value == ""
         assert screen._pending_urls == ["https://example.com/uploaded/drag-file.txt"]
 
+@pytest.mark.asyncio
+async def test_tui_chat_input_dedupes_clipboard_paste_echo(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A local clipboard paste followed by a terminal paste event should insert once."""
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from textual import events
+    from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    app._clipboard = "run-123"  # type: ignore[attr-defined]
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        chat_input.action_paste()
+        await chat_input._on_paste(events.Paste("run-123"))
+        await pilot.pause()
+
+        assert chat_input.value == "run-123"
+
+@pytest.mark.asyncio
+async def test_tui_long_text_paste_is_not_treated_as_file_path(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Long pasted text should not crash path detection and should remain normal text."""
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from textual import events
+    from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        long_text = "A" * 5000
+        await chat_input._on_paste(events.Paste(long_text))
+        await pilot.pause()
+
+        assert chat_input.value == long_text
+
+
+@pytest.mark.asyncio
+async def test_tui_chat_input_collapses_duplicate_pasted_text(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """If the terminal inserts the same pasted text twice, collapse it back to one copy."""
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        duplicated = "Action: AutoCodeAction: AutoCode"
+        chat_input.value = duplicated
+        chat_input.on_text_area_changed(ChatInput.Changed(chat_input))
+        await pilot.pause()
+
+        assert chat_input.value == "Action: AutoCode"
+
+
+
+
 @pytest.mark.asyncio
 async def test_tui_screen_level_paste_uploads_file_paths(
     isolated_home: Path, monkeypatch: pytest.MonkeyPatch

{kiwi_code-0.0.35 → kiwi_code-0.0.36}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.35"
+version = "0.0.36"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },