kiwi-code 0.0.437.dev1__tar.gz → 0.0.439__tar.gz

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.437.dev1
+Version: 0.0.439
 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.437.dev1 → kiwi_code-0.0.439}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.437.dev1"
+version = "0.0.439"
 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.437.dev1 → kiwi_code-0.0.439}/src/kiwi_cli/__init__.py

@@ -1,3 +1,3 @@
 """Kiwi CLI - command-line interface and shared infrastructure modules."""
 
-__version__ = "0.1.0"
+__version__ = "0.0.439"

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/src/kiwi_runtime/__init__.py

@@ -1,3 +1,3 @@
 """Kiwi Runtime — terminal agent that connects to the server via WebSocket."""
 
-__version__ = "0.1.0"
+__version__ = "0.0.439"

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/src/kiwi_tui/__init__.py

@@ -1,3 +1,3 @@
 """Autobots TUI - A textual-based terminal user interface."""
 
-__version__ = "0.1.0"
+__version__ = "0.0.439"

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/src/kiwi_tui/main.py

@@ -841,8 +841,21 @@ class AutobotsTUI(App):
             pass
         self.exit()
 
-    def _on_runtime_cleanup_done(self, pids_to_kill: list[int]) -> None:
-        """Callback from RuntimeCleanupScreen."""
+    def _on_runtime_cleanup_done(self, pids_to_kill: list[int] | None) -> None:
+        """Callback from RuntimeCleanupScreen.
+
+        - None: user chose to go back to Kiwi Code (cancel quit).
+        - []: exit without killing anything.
+        - [pid, ...]: kill selected pids and exit.
+        """
+        if pids_to_kill is None:
+            # Quit canceled; return to the TUI.
+            try:
+                self.notify("Quit canceled", severity="information")
+            except Exception:
+                pass
+            return
+
         for pid in pids_to_kill:
             try:
                 kill_pid(int(pid))
@@ -962,15 +975,47 @@ def _run_tui(runtime_args: RuntimeConnectArgs | None = None):
     logger.info("Autobots TUI terminated")
 
 
-def _serve_tui(port: int = 8566):
+def _run_term_tui(runtime_args: RuntimeConnectArgs | None = None) -> None:
+    """Run the *term* (terminal-first) TUI.
+
+    This is the default UI for `kiwi`. Use `kiwi alt` for the legacy UI.
+    """
+    from kiwi_tui.term_app import TermApp
+
+    config = AppConfig()
+
+    # If the user passed `--server`, use the same value for the TUI HTTP backend.
+    if runtime_args and runtime_args.server:
+        try:
+            config.backend_url = http_url_from_server(runtime_args.server)
+        except Exception:
+            pass
+
+    setup_logging(log_level=config.log_level)
+
+    logger.info("=" * 60)
+    logger.info("Starting Kiwi Term TUI")
+    logger.info("=" * 60)
+
+    app = TermApp(config=config, runtime_args=runtime_args)
+    app.run()
+
+    logger.info("Kiwi Term TUI terminated")
+
+
+def _serve_tui(port: int = 8566, extra_argv: list[str] | None = None) -> None:
     """Serve the TUI in the browser via textual serve."""
+    import shlex
     import sys
+
     from textual_serve.server import Server
 
-    server = Server(f"{sys.executable} -m kiwi_tui.main", port=port)
+    cmd = [sys.executable, "-m", "kiwi_tui.main", *(extra_argv or [])]
+    server = Server(shlex.join(cmd), port=port)
     server.serve()
 
 
+
 def _reexec_as_kiwi() -> None:
     """Re-exec via a symlink named ``kiwi`` so the kernel-reported
     process name (``ps -o comm`` / VS Code's ``${process}``) becomes
@@ -1126,6 +1171,19 @@ def main() -> int:
         sys.stdout.flush()
 
     argv = sys.argv[1:]
+
+    # UI selector (defaults to term UI).
+    # - `kiwi` => term UI
+    # - `kiwi alt` => legacy UI
+    # - `kiwi term` => explicit term UI (compat)
+    ui_mode = "term"
+    if argv and argv[0] == "alt":
+        ui_mode = "legacy"
+        argv = argv[1:]
+    elif argv and argv[0] == "term":
+        ui_mode = "term"
+        argv = argv[1:]
+
     if argv and argv[0] in {"login", "logout", "whoami"}:
         return _run_auth_command(argv)
 
@@ -1137,14 +1195,14 @@ def main() -> int:
             "--port", "-p", type=int, default=8566, help="Port to serve on (default: 8566)"
         )
         serve_args = serve_parser.parse_args(argv[1:])
-        _serve_tui(port=serve_args.port)
+        _serve_tui(port=serve_args.port, extra_argv=["alt"] if ui_mode == "legacy" else None)
         return 0
 
     parser = argparse.ArgumentParser(
-        prog="kiwi",
+        prog="kiwi alt" if ui_mode == "legacy" else "kiwi",
         description="Kiwi Code",
         epilog=(
-            "Examples: `kiwi` (TUI), `kiwi --terminal \"Hi\"`, "
+            "Examples: `kiwi` (TUI), `kiwi alt` (legacy TUI), `kiwi --terminal \"Hi\"`, "
             "`kiwi login`, `kiwi whoami`, `kiwi serve`."
         ),
     )
@@ -1241,7 +1299,10 @@ def main() -> int:
             )
         )
 
-    _run_tui(runtime_args=runtime_args)
+    if ui_mode == "legacy":
+        _run_tui(runtime_args=runtime_args)
+    else:
+        _run_term_tui(runtime_args=runtime_args)
     return 0
 
 

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/src/kiwi_tui/screens/dashboard.py

@@ -49,7 +49,7 @@ class AssistantMessageRow(Horizontal):
     """A single assistant message rendered with a left dot + markdown body.
 
     While streaming, shows a footer line under the message:
-      [Kiwi] <verb>  <spinner>
+     <verb>  <spinner>
 
     Requirement: the footer is visible only while streaming and disappears when
     the final output is available.
@@ -80,7 +80,7 @@ class AssistantMessageRow(Horizontal):
 
             # Footer comes after the body, and is only visible while streaming.
             with Horizontal(classes="assistant-footer"):
-                yield Static(f"[Kiwi] {self._verb}", classes="assistant-name", markup=False)
+                yield Static(f"{self._verb}", classes="assistant-name", markup=False)
                 yield Static("⣾", classes="assistant-spinner", markup=False)
 
     def update_markdown(self, markdown_text: str) -> None:
@@ -299,7 +299,8 @@ class DashboardScreen(Screen):
 
     /* Grayish background to indicate "in progress" assistant output. */
     .assistant-message.streaming {
-        background: $assistant-stream-bg;
+        /* Match the normal background so the streaming row doesn't look like a separate "block". */
+        background: $background;
     }
 
     .assistant-dot {
@@ -786,31 +787,52 @@ class DashboardScreen(Screen):
 
 
     def on_paste(self, event: events.Paste) -> None:
-        """Handle terminal paste/drop events that land on the screen instead of the input."""
+        """Handle paste events that land on the screen rather than the input.
+
+        - If the paste looks like local file paths (terminal drag/drop), route it
+          through the upload flow.
+        - Otherwise forward the paste to the chat input if it isn't focused.
+        """
         try:
             chat_input = self.query_one("#chat-input", ChatInput)
         except Exception:
             return
 
         file_paths = chat_input._extract_pasted_file_paths(event.text)
-        if not file_paths:
+        if file_paths:
+            event.prevent_default()
+            event.stop()
+            try:
+                self._close_inline_picker()
+            except Exception:
+                pass
+            self.notify(
+                f"Detected {len(file_paths)} file{'s' if len(file_paths) != 1 else ''}. Uploading...",
+                title="Attachments",
+                severity="information",
+                timeout=2.5,
+                markup=False,
+            )
+            self._on_files_selected(file_paths)
+            return
+
+        if chat_input.has_focus:
             return
 
         event.prevent_default()
         event.stop()
         try:
-            self._close_inline_picker()
+            chat_input.focus()
         except Exception:
             pass
-        self.notify(
-            f"Detected {len(file_paths)} file{'s' if len(file_paths) != 1 else ''}. Uploading...",
-            title="Attachments",
-            severity="information",
-            timeout=2.5,
-            markup=False,
-        )
-        self._on_files_selected(file_paths)
-
+        try:
+            if result := chat_input._replace_via_keyboard(event.text, *chat_input.selection):
+                chat_input.move_cursor(result.end_location)
+        except Exception:
+            try:
+                chat_input.insert(event.text)
+            except Exception:
+                pass
     def on_chat_input_submitted(self, event: ChatInput.Submitted) -> None:
         """Handle message submission (Enter)."""
         self._do_send()
@@ -836,6 +858,22 @@ class DashboardScreen(Screen):
         if self._cmd_running:
             return
 
+        lower = command.strip().lower()
+        if lower in {"/quit"}:
+            # Mirror ctrl+q behavior (App action 'quit').
+            try:
+                quit_action = getattr(self.app, "action_quit", None)
+                if callable(quit_action):
+                    quit_action()
+                else:
+                    self.app.exit()
+            except Exception:
+                try:
+                    self.app.exit()
+                except Exception:
+                    pass
+            return
+
         # /help is a UI-first experience (picker + copy). Don't run it through the CLI dispatcher.
         if command.strip().lower() == "/help":
             self.app.push_screen(HelpScreen())
@@ -937,6 +975,47 @@ class DashboardScreen(Screen):
                 show(body)
                 return
 
+            if cmd == "/detach":
+                if not self._pending_urls:
+                    toast("No files attached.", title="/detach", severity="warning")
+                    return
+
+                from kiwi_tui.screens.detach_files import PendingFilesDetachScreen
+
+                pending_snapshot = list(self._pending_urls)
+
+                def _on_detach_result(result: list[str] | None) -> None:
+                    if not result:
+                        return
+                    if "__all__" in result:
+                        removed = self._clear_pending_files()
+                        if removed:
+                            toast(
+                                f"Detached {removed} file{'s' if removed != 1 else ''}.",
+                                title="Attachments",
+                                timeout=4,
+                            )
+                        return
+
+                    removed_urls: list[str] = []
+                    for u in result:
+                        if self._detach_pending_file(u):
+                            removed_urls.append(u)
+
+                    if removed_urls:
+                        names = [Path(u.rsplit('/', 1)[-1]).name for u in removed_urls]
+                        toast(
+                            f"Detached {len(removed_urls)} file{'s' if len(removed_urls) != 1 else ''}: {', '.join(names)}",
+                            title="Attachments",
+                            timeout=4,
+                        )
+
+                self.app.push_screen(
+                    PendingFilesDetachScreen(pending_snapshot),
+                    callback=_on_detach_result,
+                )
+                return
+
             if cmd == "/clear-files":
                 count = self._clear_pending_files()
                 show(f"Cleared {count} pending file(s).")
@@ -2874,7 +2953,7 @@ class DashboardScreen(Screen):
         """Run action and stream results via SSE.
 
         UX requirement: as soon as the user hits Enter, show an "in progress"
-        assistant row (dot + [Kiwi] header + spinner) and animate it until we
+        assistant row (dot + header + spinner) and animate it until we
         have a terminal result (success/error), regardless of whether SSE is
         currently emitting tokens.
         """

kiwi_code-0.0.439/src/kiwi_tui/screens/detach_files.py

@@ -0,0 +1,146 @@
+"""Modal UI for detaching one or more pending file attachments.
+
+Used by both DashboardScreen (stable) and TermDashboardScreen (term mode).
+
+The modal returns:
+- None when cancelled
+- ["__all__"] when user chose to detach all
+- list[str] of attachment URLs selected for detaching
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, SelectionList, Static
+from textual.widgets.selection_list import Selection
+
+
+class PendingFilesDetachScreen(ModalScreen[list[str] | None]):
+    """Multi-select detach UI for pending attachments."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+    ]
+
+    CSS = """
+    PendingFilesDetachScreen {
+        align: center middle;
+    }
+
+    #detach-container {
+        width: 90;
+        height: 70%;
+        background: $primary-background;
+        border: solid $accent;
+        padding: 1 2;
+    }
+
+    #detach-title {
+        width: 100%;
+        text-style: bold;
+        color: $primary;
+        height: 1;
+        content-align: center middle;
+    }
+
+    #detach-subtitle {
+        width: 100%;
+        height: 1;
+        color: $foreground;
+        opacity: 0.75;
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+
+    #detach-list {
+        height: 1fr;
+        width: 100%;
+        border: none;
+        background: $primary-background;
+        color: $foreground;
+        scrollbar-size-vertical: 1;
+    }
+
+    #detach-buttons {
+        width: 100%;
+        height: auto;
+        margin-top: 1;
+        content-align: center middle;
+    }
+
+    #detach-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    def __init__(self, pending_urls: list[str]):
+        super().__init__()
+        self._pending_urls = list(pending_urls)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="detach-container"):
+            yield Static("Detach attachments", id="detach-title", markup=False)
+            yield Static("Select file(s) to detach", id="detach-subtitle", markup=False)
+
+            # Deduplicate display names to avoid confusing duplicates.
+            name_counts: dict[str, int] = {}
+            selections: list[Selection] = []
+            for url in self._pending_urls:
+                name = Path(str(url).rsplit("/", 1)[-1]).name or "(unnamed)"
+                count = name_counts.get(name, 0) + 1
+                name_counts[name] = count
+                label = name if count == 1 else f"{name} ({count})"
+                selections.append(Selection(label, url, initial_state=False))
+
+            yield SelectionList(*selections, id="detach-list")
+
+            with Horizontal(id="detach-buttons"):
+                yield Button("Detach selected", id="detach-selected", variant="default")
+                yield Button("Detach all", id="detach-all", variant="default")
+                yield Button("Cancel", id="cancel", variant="default")
+
+    def on_mount(self) -> None:
+        try:
+            self.query_one("#detach-list", SelectionList).focus()
+        except Exception:
+            pass
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = (event.button.id or "").strip()
+        if btn_id == "cancel":
+            self.dismiss(None)
+            return
+
+        if btn_id == "detach-all":
+            self.dismiss(["__all__"])
+            return
+
+        if btn_id == "detach-selected":
+            try:
+                selected = list(self.query_one("#detach-list", SelectionList).selected)
+            except Exception:
+                selected = []
+
+            if not selected:
+                try:
+                    self.app.notify(
+                        "No files selected.",
+                        title="Detach",
+                        severity="warning",
+                        timeout=2.5,
+                        markup=False,
+                    )
+                except Exception:
+                    pass
+                return
+
+            self.dismiss(selected)
+            return

{kiwi_code-0.0.437.dev1 → kiwi_code-0.0.439}/src/kiwi_tui/screens/runtime_cleanup.py

@@ -41,17 +41,22 @@ class RuntimeRow:
 
 
 class RuntimeCleanupList(OptionList):
-    """OptionList with explicit key handling so toggling always works."""
-
     BINDINGS = [
-        Binding("escape", "cancel_exit", "Exit (keep all)", show=True),
-        Binding("ctrl+c", "cancel_exit", "Exit (keep all)", show=False),
-        Binding("enter", "confirm_exit", "Confirm & exit", show=True),
-        Binding("ctrl+s", "confirm_exit", "Confirm & exit", show=False),
+        # Navigation / selection
         Binding("space", "toggle_kill", "Toggle kill", show=True),
         Binding("t", "toggle_kill", "Toggle kill", show=False),
         Binding("y", "mark_kill", "Mark kill", show=False),
         Binding("n", "unmark_kill", "Unmark kill", show=False),
+        # Confirm / exit
+        Binding("enter", "confirm_exit", "Exit (kill selected)", show=True),
+        Binding("ctrl+s", "confirm_exit", "Exit (kill selected)", show=False),
+        # Cancel quit (go back to main UI)
+        Binding("escape", "back", "Back to Kiwi Code", show=True),
+        Binding("b", "back", "Back to Kiwi Code", show=False),
+        Binding("ctrl+c", "back", "Back to Kiwi Code", show=False),
+        # Exit without killing anything
+        Binding("ctrl+q", "cancel_exit", "Exit (keep all)", show=True),
+        Binding("q", "cancel_exit", "Exit (keep all)", show=False),
     ]
 
     def _cleanup_screen(self) -> "RuntimeCleanupScreen | None":
@@ -83,6 +88,11 @@ class RuntimeCleanupList(OptionList):
         if screen:
             screen.action_confirm()
 
+    def action_back(self) -> None:
+        screen = self._cleanup_screen()
+        if screen:
+            screen.action_back()
+
     def action_cancel_exit(self) -> None:
         screen = self._cleanup_screen()
         if screen:
@@ -90,7 +100,6 @@ class RuntimeCleanupList(OptionList):
 
     def on_key(self, event: events.Key) -> None:
         """Normalize some terminal key variants (notably space)."""
-        key = (event.key or "").lower()
         char = (event.character or "")
 
         # Some terminals send printable space without mapping to "space".
@@ -106,12 +115,35 @@ class RuntimeCleanupList(OptionList):
         # key binding handling.
         return
 
-class RuntimeCleanupScreen(ModalScreen[list[int]]):
+
+    def on_click(self, event: events.Click) -> None:
+        """Mouse support: click an item to toggle [ ] / [x].
+
+        We intentionally *don't* render boxed buttons in this CLI-style UI, so
+        clicking a row should behave like pressing Space on that row (similar to
+        the /detach panel).
+        """
+        # Let OptionList's own click handling run (so the highlight follows the
+        # mouse), then toggle the currently highlighted row on the next tick.
+        try:
+            self.app.call_later(self.action_toggle_kill)
+        except Exception:
+            self.action_toggle_kill()
+
+class RuntimeCleanupScreen(ModalScreen[list[int] | None]):
     """Prompt the user to select which runtimes to terminate."""
 
     # Fallback bindings if focus leaves the list.
     BINDINGS = [
-        Binding("escape", "cancel", "Exit (keep all)", show=False),
+        # Back to Kiwi Code (cancel quit)
+        Binding("escape", "back", "Back", show=True),
+        Binding("b", "back", "Back", show=False),
+        Binding("ctrl+c", "back", "Back", show=False),
+
+        # Exit choices
+        Binding("ctrl+q", "cancel", "Exit (keep all)", show=True),
+        Binding("q", "cancel", "Exit (keep all)", show=False),
+        Binding("enter", "confirm", "Exit (kill selected)", show=True),
         Binding("ctrl+s", "confirm", "Exit (kill selected)", show=False),
     ]
 
@@ -146,6 +178,7 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
         color: $brand-cyan;
         text-style: bold;
     }
+
     """
 
     def __init__(self, rows: list[RuntimeRow]):
@@ -157,7 +190,8 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
         yield Header(icon="❊")
         yield Static(
             "Interactive runtime cleanup\n"
-            "Use ↑/↓ to move, Space to toggle kill, Enter to confirm & exit, Esc to keep all.",
+            "Use ↑/↓ to move, Space to toggle kill.\n"
+            "Enter = exit (kill selected) • Ctrl+Q = exit (keep all) • Esc = back to Kiwi Code.",
             id="runtime-cleanup-help",
         )
         yield RuntimeCleanupList(id="runtime-list")
@@ -178,11 +212,12 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
         # Best-effort: fetch missing run names in background (doesn't block exit).
         self.run_worker(self._fetch_missing_names(), exclusive=True)
 
+
     def _option_id_for_row(self, r: RuntimeRow) -> str:
         return f"{r.kind}:{r.runtime_id}:{r.pid}"
 
     def _format_row(self, r: RuntimeRow) -> Text:
-        kill = "YES" if r.kill else "NO"
+        marker = "[x]" if r.kill else "[ ]"
         # Note: kinds come from runtime_agent.list_known_runtimes(): "by-run" or "pending".
         name = r.name or ("(pending)" if r.kind == "pending" else "(unknown)")
         row = Text()
@@ -190,8 +225,8 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
             cyan = self.app.get_css_variables().get("brand-cyan", "#63d8dc")
         except Exception:
             cyan = "#63d8dc"
-        row.append(f"Kill={kill}", style=f"bold {cyan}")
-        row.append(f"  {name}", style="bold")
+        row.append(f"  {marker}", style=f"bold {cyan}")
+        row.append(f" {name}", style="bold")
         row.append(f"  |  {r.runtime_id}  |  pid {r.pid}  |  {r.kind}")
         return row
 
@@ -298,6 +333,10 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
         except Exception as e:
             logger.debug(f"Runtime cleanup name fetch failed: {e}")
 
+    def action_back(self) -> None:
+        """Cancel quit and return to the TUI."""
+        self.dismiss(None)
+
     def action_confirm(self) -> None:
         pids = [r.pid for r in self._rows if r.kill and r.pid]
         self.dismiss(pids)