kiwi-code 0.0.27__tar.gz → 0.0.28__tar.gz

{kiwi_code-0.0.27 → kiwi_code-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.27
+Version: 0.0.28
 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.27 → kiwi_code-0.0.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.27"
+version = "0.0.28"
 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.27 → kiwi_code-0.0.28}/src/kiwi_tui/screens/dashboard.py

@@ -37,7 +37,7 @@ class UserMessageRow(Horizontal):
         self._text = text
 
     def compose(self) -> ComposeResult:
-        yield Static("YOU:", classes="user-label", markup=False)
+        yield Static("", classes="user-label", markup=False)
         yield Static(self._text, classes="user-body", markup=False)
 
 
@@ -148,6 +148,7 @@ class DashboardScreen(Screen):
         self.current_action_id = self.DEFAULT_ACTION_ID
         self.current_run_id = None  # Track the current conversation run_id
         self.active_stream_tasks = []  # Track active SSE stream tasks to cancel them
+        self.current_run_kind: str | None = None  # 'action' or 'graph' (best-effort)
         self._last_listed_ids: list[str] = []  # Index for #N shortcuts
         self._pending_urls: list[str] = []  # File URLs to attach to next message
         self._metadata: dict = {}  # Persistent metadata for all subsequent runs
@@ -866,6 +867,7 @@ class DashboardScreen(Screen):
                 self._set_streaming(False)
                 self.current_action_id = self.DEFAULT_ACTION_ID
                 self.current_run_id = None
+                self.current_run_kind = None
                 self._update_run_status_bar()
                 self._clear_chat_messages()
                 show(f"Starting new conversation with default action ({self.DEFAULT_ACTION_ID}).")
@@ -885,6 +887,7 @@ class DashboardScreen(Screen):
                     return
                 self.current_action_id = action_id
                 self.current_run_id = None
+                self.current_run_kind = None
                 self._update_run_status_bar()
                 self._clear_chat_messages()
                 show("\n".join(["Switched to action:"] + lines))
@@ -904,11 +907,108 @@ class DashboardScreen(Screen):
                     show(f"Run not found: {run_id}", is_error=True)
                     return
                 self.current_run_id = run_id
+                self.current_run_kind = "action"
                 self._update_run_status_bar()
                 show("\n".join(["Continuing run:"] + lines))
                 await self._load_conversation_history_async(run_id)
                 return
 
+            if cmd == "/name":
+                new_name = " ".join(args).strip()
+                if not new_name:
+                    show("Usage: /name <new name>")
+                    return
+                if not self.current_run_id:
+                    show(
+                        "Error: no run id yet. Start a conversation (send a message), or use /continue <run_id>, or pick one from /runs list.",
+                        is_error=True,
+                    )
+                    return
+
+                api_client = self._get_api_client_for_command(command)
+                if not api_client:
+                    return
+
+                run_id = self.current_run_id
+
+                from autobots_client.models.action_result_update import ActionResultUpdate
+                from autobots_client.api.action_results import (
+                    update_action_result_v1_action_results_put,
+                )
+                from autobots_client.models.action_graph_result_update import ActionGraphResultUpdate
+                from autobots_client.api.action_graphs_results import (
+                    update_action_graph_result_v1_action_graphs_results_put,
+                )
+
+                def _try_rename_action_run() -> tuple[int, str]:
+                    try:
+                        resp = update_action_result_v1_action_results_put.sync_detailed(
+                            client=api_client,
+                            id=run_id,
+                            body=ActionResultUpdate(name=new_name),
+                        )
+                        return resp.status_code, ""
+                    except Exception as e:
+                        return 0, str(e)
+
+                def _try_rename_graph_run() -> tuple[int, str]:
+                    try:
+                        resp = update_action_graph_result_v1_action_graphs_results_put.sync_detailed(
+                            client=api_client,
+                            id=run_id,
+                            body=ActionGraphResultUpdate(name=new_name),
+                        )
+                        return resp.status_code, ""
+                    except Exception as e:
+                        return 0, str(e)
+
+                # Decide which API to target first (action run vs graph run).
+                preferred_kind = self.current_run_kind or "action"
+                tried: list[str] = []
+                status_code: int = 0
+                err: str = ""
+
+                async def _attempt(kind: str) -> tuple[int, str]:
+                    if kind == "graph":
+                        return await asyncio.to_thread(_try_rename_graph_run)
+                    return await asyncio.to_thread(_try_rename_action_run)
+
+                # Try preferred kind first, then fall back to the other kind for common "wrong endpoint" failures.
+                for kind in (preferred_kind, "graph" if preferred_kind != "graph" else "action"):
+                    tried.append(kind)
+                    status_code, err = await _attempt(kind)
+                    if status_code == 200:
+                        # Lock-in for future /name calls so we don't have to guess again.
+                        self.current_run_kind = kind
+                        break
+                    # Only fall back on "not found" / validation errors (or exceptions -> status_code=0).
+                    if status_code not in (0, 404, 422):
+                        break
+
+                if status_code != 200:
+                    details = err or ""
+                    show(
+                        f"Error: failed to rename run {run_id}. Tried: {', '.join(tried)}. HTTP {status_code}. {details}",
+                        is_error=True,
+                    )
+                    return
+
+                # Best-effort: update local cached run name (used by the quit-time cleanup prompt).
+                try:
+                    from kiwi_tui.runtime_agent import meta_path_for_run
+
+                    mp = meta_path_for_run(run_id)
+                    meta: dict[str, object] = {}
+                    if mp.exists():
+                        meta = json.loads(mp.read_text(encoding="utf-8") or "{}")
+                    meta["run_name"] = new_name
+                    mp.write_text(json.dumps(meta, indent=2, default=str), encoding="utf-8")
+                except Exception:
+                    pass
+
+                show(f"Renamed run {run_id} to: {new_name}")
+                return
+
             if cmd == "/status":
                 info = [
                     f"Action ID:  {self.current_action_id}",
@@ -983,7 +1083,7 @@ class DashboardScreen(Screen):
         from autobots_client.types import UNSET
         opts = self._parse_command_opts(command)
         name = opts.get("name")
-        limit = int(opts.get("limit", "20"))
+        limit = int(opts.get("limit", "50"))
         offset = int(opts.get("offset", "0"))
         resp = await asyncio.to_thread(
             lambda: list_actions_v1_actions_get.sync_detailed(
@@ -1001,14 +1101,24 @@ class DashboardScreen(Screen):
             f"Actions ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select an action"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Name", "Type", "Version", "Created"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {_val(doc.name):<30} {_val(doc.type_.value):<25} "
-                f"{_val(doc.version):<6} {_fmt_date(doc.created_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        _val(doc.name),
+                        _val(doc.type_.value),
+                        _val(doc.version),
+                        _fmt_date(doc.created_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_action_picked)
+        self.app.push_screen(
+            IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_action_picked
+        )
 
     async def _render_runs_list_async(self, command: str, api_client) -> None:
         from kiwi_cli.commands import _val, _fmt_date
@@ -1033,7 +1143,7 @@ class DashboardScreen(Screen):
                 action_id=opts.get("action_id") or UNSET,
                 action_name=opts.get("action_name") or UNSET,
                 status=status_enum,
-                limit=int(opts.get("limit", "20")),
+                limit=int(opts.get("limit", "50")),
                 offset=int(opts.get("offset", "0")),
             )
         )
@@ -1045,14 +1155,22 @@ class DashboardScreen(Screen):
             f"Action Runs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a run"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Status", "Name", "Created", "Updated"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {doc.status.value:<12} {_val(doc.name):<30} "
-                f"{_fmt_date(doc.created_at):<18} {_fmt_date(doc.updated_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        doc.status.value,
+                        _val(doc.name),
+                        _fmt_date(doc.created_at),
+                        _fmt_date(doc.updated_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_run_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_run_picked)
 
     async def _render_graphs_list_async(self, command: str, api_client) -> None:
         from kiwi_cli.commands import _val, _fmt_date
@@ -1060,7 +1178,7 @@ class DashboardScreen(Screen):
         from autobots_client.types import UNSET
         opts = self._parse_command_opts(command)
         name = opts.get("name")
-        limit = int(opts.get("limit", "20"))
+        limit = int(opts.get("limit", "50"))
         offset = int(opts.get("offset", "0"))
         resp = await asyncio.to_thread(
             lambda: list_action_graphs_v1_action_graphs_get.sync_detailed(
@@ -1078,14 +1196,22 @@ class DashboardScreen(Screen):
             f"Action Graphs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a graph"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Name", "Version", "Published", "Created"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {_val(doc.name):<30} {_val(doc.version):<6} "
-                f"{_val(doc.is_published):<10} {_fmt_date(doc.created_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        _val(doc.name),
+                        _val(doc.version),
+                        _val(doc.is_published),
+                        _fmt_date(doc.created_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_graph_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_graph_picked)
 
     async def _render_graph_runs_list_async(self, command: str, api_client) -> None:
         from kiwi_cli.commands import _val, _fmt_date
@@ -1112,7 +1238,7 @@ class DashboardScreen(Screen):
                 action_graph_id=opts.get("graph_id") or UNSET,
                 action_graph_name=opts.get("graph_name") or UNSET,
                 status=status_enum,
-                limit=int(opts.get("limit", "20")),
+                limit=int(opts.get("limit", "50")),
                 offset=int(opts.get("offset", "0")),
             )
         )
@@ -1124,14 +1250,22 @@ class DashboardScreen(Screen):
             f"Action Graph Runs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a graph run"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Status", "Name", "Created", "Updated"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {doc.status.value:<12} {_val(doc.name):<30} "
-                f"{_fmt_date(doc.created_at):<18} {_fmt_date(doc.updated_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        doc.status.value,
+                        _val(doc.name),
+                        _fmt_date(doc.created_at),
+                        _fmt_date(doc.updated_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_graph_run_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_graph_run_picked)
 
 
     def _get_api_client(self):
@@ -1207,7 +1341,7 @@ class DashboardScreen(Screen):
 
         opts = self._parse_command_opts(command)
         name = opts.get("name")
-        limit = int(opts.get("limit", "20"))
+        limit = int(opts.get("limit", "50"))
         offset = int(opts.get("offset", "0"))
 
         resp = list_actions_v1_actions_get.sync_detailed(
@@ -1223,14 +1357,22 @@ class DashboardScreen(Screen):
             f"Actions ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select an action"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Name", "Type", "Version", "Created"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {_val(doc.name):<30} {_val(doc.type_.value):<25} "
-                f"{_val(doc.version):<6} {_fmt_date(doc.created_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        _val(doc.name),
+                        _val(doc.type_.value),
+                        _val(doc.version),
+                        _fmt_date(doc.created_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_action_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_action_picked)
 
     def _render_runs_list(self, command: str, api_client) -> None:
         """Render /runs list with clickable rows."""
@@ -1257,7 +1399,7 @@ class DashboardScreen(Screen):
             action_id=opts.get("action_id") or UNSET,
             action_name=opts.get("action_name") or UNSET,
             status=status_enum,
-            limit=int(opts.get("limit", "20")),
+            limit=int(opts.get("limit", "50")),
             offset=int(opts.get("offset", "0")),
         )
         if resp.status_code != 200:
@@ -1269,14 +1411,22 @@ class DashboardScreen(Screen):
             f"Action Runs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a run"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Status", "Name", "Created", "Updated"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {doc.status.value:<12} {_val(doc.name):<30} "
-                f"{_fmt_date(doc.created_at):<18} {_fmt_date(doc.updated_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        doc.status.value,
+                        _val(doc.name),
+                        _fmt_date(doc.created_at),
+                        _fmt_date(doc.updated_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_run_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_run_picked)
 
     def _render_graphs_list(self, command: str, api_client) -> None:
         """Render /graphs list with clickable rows."""
@@ -1286,7 +1436,7 @@ class DashboardScreen(Screen):
 
         opts = self._parse_command_opts(command)
         name = opts.get("name")
-        limit = int(opts.get("limit", "20"))
+        limit = int(opts.get("limit", "50"))
         offset = int(opts.get("offset", "0"))
 
         resp = list_action_graphs_v1_action_graphs_get.sync_detailed(
@@ -1301,14 +1451,22 @@ class DashboardScreen(Screen):
             f"Action Graphs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a graph"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Name", "Version", "Published", "Created"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {_val(doc.name):<30} {_val(doc.version):<6} "
-                f"{_val(doc.is_published):<10} {_fmt_date(doc.created_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        _val(doc.name),
+                        _val(doc.version),
+                        _val(doc.is_published),
+                        _fmt_date(doc.created_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_graph_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_graph_picked)
     def _render_graph_runs_list(self, command: str, api_client) -> None:
         """Render /graph-runs list with clickable rows."""
         from kiwi_cli.commands import _val, _fmt_date
@@ -1334,7 +1492,7 @@ class DashboardScreen(Screen):
             action_graph_id=opts.get("graph_id") or UNSET,
             action_graph_name=opts.get("graph_name") or UNSET,
             status=status_enum,
-            limit=int(opts.get("limit", "20")),
+            limit=int(opts.get("limit", "50")),
             offset=int(opts.get("offset", "0")),
         )
         if resp.status_code != 200:
@@ -1346,14 +1504,22 @@ class DashboardScreen(Screen):
             f"Action Graph Runs ({result.total_count} total, showing {result.offset}-{result.offset + len(result.docs)}). "
             "Select a graph run"
         )
-        options: list[tuple[str, str]] = []
+        columns = ["#", "Status", "Name", "Created", "Updated"]
+        rows: list[tuple[str, list[str]]] = []
         for idx, doc in enumerate(result.docs, 1):
-            label = (
-                f"{idx:<4} {doc.status.value:<12} {_val(doc.name):<30} "
-                f"{_fmt_date(doc.created_at):<18} {_fmt_date(doc.updated_at)}"
+            rows.append(
+                (
+                    doc.field_id,
+                    [
+                        str(idx),
+                        doc.status.value,
+                        _val(doc.name),
+                        _fmt_date(doc.created_at),
+                        _fmt_date(doc.updated_at),
+                    ],
+                )
             )
-            options.append((doc.field_id, label))
-        self.app.push_screen(IdPickerScreen(title, options), callback=self._on_graph_run_picked)
+        self.app.push_screen(IdPickerScreen(title, columns=columns, rows=rows), callback=self._on_graph_run_picked)
 
 
     # ----------------------------
@@ -1387,6 +1553,7 @@ class DashboardScreen(Screen):
                 return
             self.current_action_id = action_id
             self.current_run_id = None
+            self.current_run_kind = None
             self._update_run_status_bar()
             self._clear_chat_messages()
             self.app.notify(f"Switched to action: {action_id}", severity="information")
@@ -1420,6 +1587,7 @@ class DashboardScreen(Screen):
                 self._show_command_result("Run selection", f"Run not found: {run_id}", is_error=True)
                 return
             self.current_run_id = run_id
+            self.current_run_kind = "action"
             self._update_run_status_bar()
             self.app.notify(f"Continuing run: {run_id}", severity="information")
             await self._load_conversation_history_async(run_id)
@@ -1483,6 +1651,7 @@ class DashboardScreen(Screen):
                 self._show_command_result("Graph run selection", f"Graph run not found: {graph_run_id}", is_error=True)
                 return
             self.current_run_id = graph_run_id
+            self.current_run_kind = "graph"
             self._update_run_status_bar()
             self.app.notify(f"Continuing graph run: {graph_run_id}", severity="information")
         finally:
@@ -1610,6 +1779,7 @@ class DashboardScreen(Screen):
                 return
             self.current_action_id = action_id
             self.current_run_id = None
+            self.current_run_kind = None
             self._update_run_status_bar()
             self.add_message("\n".join(["Switched to action:"] + lines), "info")
 
@@ -1625,28 +1795,34 @@ class DashboardScreen(Screen):
 
         elif btn_id.startswith("run-select-"):
             # Continue this run
-            run_id = btn_id[len("run-select-"):]
+            run_id = btn_id[len("run-select-") :]
             from kiwi_cli.commands import runs_get
+
             lines = runs_get(api_client, id=run_id)
             if lines and lines[0].startswith("Error"):
                 self.add_message(f"Run not found: {run_id}", "error")
                 return
+
             self.current_run_id = run_id
+            self.current_run_kind = "action"
             self._update_run_status_bar()
             self.add_message("\n".join(["Continuing run:"] + lines), "info")
             self._load_conversation_history(run_id)
 
         elif btn_id.startswith("graph-run-select-"):
             # Continue this graph run
-            graph_run_id = btn_id[len("graph-run-select-"):]
+            graph_run_id = btn_id[len("graph-run-select-") :]
             from kiwi_cli.commands import graph_runs_get
+
             lines = graph_runs_get(api_client, id=graph_run_id)
             if lines and lines[0].startswith("Error"):
                 self.add_message(f"Graph run not found: {graph_run_id}", "error")
                 return
+
             self.current_run_id = graph_run_id
+            self.current_run_kind = "graph"
+            self._update_run_status_bar()
             self.add_message("\n".join(["Continuing graph run:"] + lines), "info")
-
         else:
             return
 
@@ -2014,6 +2190,7 @@ class DashboardScreen(Screen):
             logger.info(f"Continuing conversation with run_id: {run_id}")
         else:
             self.current_run_id = run_id
+            self.current_run_kind = "action"
             # If a pending runtime was started (e.g. via /connect-cli before the
             # run existed), bind it now that we have a run_id.
             try:

kiwi_code-0.0.28/src/kiwi_tui/screens/id_picker.py

@@ -0,0 +1,247 @@
+"""Generic modal picker for selecting an item by ID.
+
+Used for slash-command list views (e.g. /actions list, /runs list) so the
+list UI is separate from the main chat timeline.
+"""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import DataTable, OptionList, Static
+from textual.widgets.option_list import Option
+
+from textual.events import (
+    MouseScrollDown,
+    MouseScrollLeft,
+    MouseScrollRight,
+    MouseScrollUp,
+)
+
+
+class _IdPickerDataTable(DataTable):
+    """DataTable that supports horizontal trackpad / shift-scroll gestures.
+
+    Notes:
+    - Some terminals emit horizontal scrolling as MouseScrollLeft/Right events.
+    - Some emit MouseScrollDown/Up with delta_x set.
+    - Some map horizontal scrolling to Shift+wheel (shift=True with delta_y).
+
+    We handle all of the above so the IdPicker table can be scrolled horizontally
+    with a touchpad when the terminal supports it.
+    """
+
+    _H_SCROLL_MULTIPLIER = 4
+
+    def _scroll_x(self, dx: int) -> None:
+        if dx == 0:
+            return
+        self.scroll_relative(x=dx * self._H_SCROLL_MULTIPLIER, y=0, animate=False)
+
+    def _try_handle_horizontal_from_delta(
+        self, delta_x: int, *, shift: bool, delta_y: int
+    ) -> bool:
+        dx = delta_x
+        if dx == 0 and shift and delta_y != 0:
+            dx = delta_y
+        if dx == 0:
+            return False
+        self._scroll_x(dx)
+        return True
+
+    def _on_mouse_scroll_down(self, event: MouseScrollDown) -> None:
+        if self._try_handle_horizontal_from_delta(
+            event.delta_x, shift=event.shift, delta_y=event.delta_y
+        ):
+            event.stop()
+            return
+        return super()._on_mouse_scroll_down(event)
+
+    def _on_mouse_scroll_up(self, event: MouseScrollUp) -> None:
+        if self._try_handle_horizontal_from_delta(
+            event.delta_x, shift=event.shift, delta_y=event.delta_y
+        ):
+            event.stop()
+            return
+        return super()._on_mouse_scroll_up(event)
+
+    def _on_mouse_scroll_left(self, event: MouseScrollLeft) -> None:
+        # Ensure negative direction regardless of terminal conventions.
+        dx = event.delta_x or -1
+        self._scroll_x(-abs(dx))
+        event.stop()
+
+    def _on_mouse_scroll_right(self, event: MouseScrollRight) -> None:
+        # Ensure positive direction regardless of terminal conventions.
+        dx = event.delta_x or 1
+        self._scroll_x(abs(dx))
+        event.stop()
+
+
+
+class IdPickerScreen(ModalScreen[str]):
+    """Modal that lets the user pick an item (returns its ID).
+
+    - Returns the selected ID.
+    - Returns an empty string if cancelled.
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+        Binding("ctrl+left", "hscroll_left", "Scroll left", show=False),
+        Binding("ctrl+right", "hscroll_right", "Scroll right", show=False),
+    ]
+    CSS = """
+    IdPickerScreen {
+        align: center middle;
+    }
+
+    #idpicker-container {
+        width: 90;
+        height: 90%;
+        background: $surface;
+        border: solid $accent;
+        padding: 0 1;
+    }
+
+    #idpicker-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        background: $surface;
+        height: 1;
+        margin-bottom: 0;
+    }
+
+    #idpicker-table {
+        height: 1fr;
+        width: 100%;
+        background: $surface;
+        /* Slightly dim the row text so it's easier on the eyes. */
+        color: $foreground 80%;
+        border: none;
+        overflow-x: auto;
+        overflow-y: auto;
+        scrollbar-gutter: auto;
+        scrollbar-background: $surface;
+        scrollbar-background-hover: $surface;
+        scrollbar-background-active: $surface;
+        scrollbar-corner-color: $surface;
+        scrollbar-color: $panel;
+        scrollbar-color-hover: $primary;
+        scrollbar-color-active: $primary;
+        scrollbar-size-vertical: 1;
+        scrollbar-size-horizontal: 1;
+        padding: 0 1;
+    }
+
+
+    /* Softer column-header styling (avoid the high-contrast cyan/white look). */
+    #idpicker-table > .datatable--header {
+        background: $brand-cyan;
+        color: black;
+    }
+    /* Override Textual's ANSI-mode defaults (it makes headers bright blue by default). */
+    #idpicker-table:ansi > .datatable--header {
+        background: $brand-cyan;
+        color: black;
+    }
+    #idpicker-table > .datatable--header-cursor {
+        background: $brand-cyan;
+        color: black;
+    }
+    #idpicker-table > .datatable--header-hover {
+        background: $brand-cyan;
+    }
+    #idpicker-list {
+        height: 1fr;
+        width: 100%;
+        border: none;
+        overflow-x: auto;
+        overflow-y: auto;
+        scrollbar-gutter: auto;
+        scrollbar-background: $surface;
+        scrollbar-background-hover: $surface;
+        scrollbar-background-active: $surface;
+        scrollbar-corner-color: $surface;
+        scrollbar-color: $panel;
+        scrollbar-color-hover: $primary;
+        scrollbar-color-active: $primary;
+        scrollbar-size-vertical: 1;
+        scrollbar-size-horizontal: 1;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(
+        self,
+        title: str,
+        options: list[tuple[str, str]] | None = None,
+        *,
+        columns: list[str] | None = None,
+        rows: list[tuple[str, list[str] | tuple[str, ...]]] | None = None,
+    ):
+        super().__init__()
+        self._title = title
+        self._options = options or []
+        self._columns = columns
+        self._rows = rows
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="idpicker-container"):
+            yield Static(self._title, id="idpicker-title")
+            if self._columns is not None and self._rows is not None:
+                table = _IdPickerDataTable(id="idpicker-table", zebra_stripes=True)
+                # Add a bit of breathing room between columns for readability.
+                table.cell_padding = 2
+                table.cursor_type = "row"
+                table.add_columns(*self._columns)
+                for item_id, cells in self._rows:
+                    table.add_row(*list(cells), key=item_id)
+                yield table
+            else:
+                option_list = OptionList(id="idpicker-list")
+                for item_id, label in self._options:
+                    # Option.id is independent of widget IDs; it only needs to be unique in this list.
+                    option_list.add_option(Option(label, id=item_id))
+                yield option_list
+
+    def on_mount(self) -> None:
+        """Focus the primary list widget."""
+        try:
+            if self._columns is not None and self._rows is not None:
+                self.query_one("#idpicker-table", DataTable).focus()
+            else:
+                self.query_one("#idpicker-list", OptionList).focus()
+        except Exception:
+            # Don't crash the modal due to focus issues.
+            pass
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        self.dismiss(event.option.id or "")
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        key = getattr(event.row_key, "value", None)
+        self.dismiss(key or "")
+
+
+    def action_hscroll_left(self) -> None:
+        """Scroll the table horizontally to the left (Ctrl+Left)."""
+        try:
+            table = self.query_one("#idpicker-table", DataTable)
+        except Exception:
+            return
+        table.scroll_relative(x=-10, y=0, animate=False)
+
+    def action_hscroll_right(self) -> None:
+        """Scroll the table horizontally to the right (Ctrl+Right)."""
+        try:
+            table = self.query_one("#idpicker-table", DataTable)
+        except Exception:
+            return
+        table.scroll_relative(x=10, y=0, animate=False)
+    def action_cancel(self) -> None:
+        self.dismiss("")

{kiwi_code-0.0.27 → kiwi_code-0.0.28}/src/kiwi_tui/slash_commands.py

@@ -20,6 +20,7 @@ SLASH_COMMANDS: list[SlashCommand] = [
     SlashCommand("Session", "/status", "Show current action & run", "/status"),
     SlashCommand("Session", "/cancel", "Cancel active request", "/cancel"),
     SlashCommand("Session", "/use <action_id>", "Switch to a different action", "/use "),
+    SlashCommand("Session", "/name <new name>", "Rename the current run (action run or graph run)", "/name "),
     SlashCommand("Session", "/continue <run_id>", "Continue an existing run", "/continue "),
 
     # Files

{kiwi_code-0.0.27 → kiwi_code-0.0.28}/uv.lock

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

kiwi_code-0.0.27/src/kiwi_tui/screens/id_picker.py

@@ -1,75 +0,0 @@
-"""Generic modal picker for selecting an item by ID.
-
-Used for slash-command list views (e.g. /actions list, /runs list) so the
-list UI is separate from the main chat timeline.
-"""
-
-from __future__ import annotations
-
-from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.containers import Vertical
-from textual.screen import ModalScreen
-from textual.widgets import OptionList, Static
-from textual.widgets.option_list import Option
-
-
-class IdPickerScreen(ModalScreen[str]):
-    """Modal that lets the user pick an item (returns its ID).
-
-    - Returns the selected ID.
-    - Returns an empty string if cancelled.
-    """
-
-    BINDINGS = [
-        Binding("escape", "cancel", "Cancel", show=True),
-    ]
-
-    CSS = """
-    IdPickerScreen {
-        align: center middle;
-    }
-
-    #idpicker-container {
-        width: 90;
-        height: 80%;
-        background: $surface;
-        border: solid $accent;
-        padding: 1 2;
-    }
-
-    #idpicker-title {
-        width: 100%;
-        text-align: center;
-        text-style: bold;
-        color: $primary;
-        height: auto;
-        margin-bottom: 1;
-    }
-
-    #idpicker-list {
-        height: 1fr;
-        width: 100%;
-        border: solid $panel;
-    }
-    """
-
-    def __init__(self, title: str, options: list[tuple[str, str]]):
-        super().__init__()
-        self._title = title
-        self._options = options
-
-    def compose(self) -> ComposeResult:
-        with Vertical(id="idpicker-container"):
-            yield Static(self._title, id="idpicker-title")
-            option_list = OptionList(id="idpicker-list")
-            for item_id, label in self._options:
-                # Option.id is independent of widget IDs; it only needs to be unique in this list.
-                option_list.add_option(Option(label, id=item_id))
-            yield option_list
-
-    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
-        self.dismiss(event.option.id or "")
-
-    def action_cancel(self) -> None:
-        self.dismiss("")